created by

Ingo Karkat

script type

utility

description

DESCRIPTION The built-in :sort command is powerful, but it still is line-based. It doesn't take into account folded lines, nor can it sort entire blocks like function definitions, paragraphs, etc. But often, one needs to sort exactly such areas as single entities, i.e. without changing the line order within them. A workaround in Vim is condensing each block into a single line, performing the sorting, and then expanding again. (External, more powerful sort commands could be used, too.) This plugin implements this workaround and encapsulates the three separate steps in one handy command. While :sort has several flags for sorting on various numbers, and a /{pattern}/ can be specified to skip or sort on, it doesn't allow arbitrary (Vimscript) expressions. This plugin offers extension commands that evaluate an expression per line, put that number in front of the line, do a numerical sort, and then remove the temporary number again. Specializations handle the common sort by number of characters and by the line's display width. SOURCE - :SortVisible inspired by   http://stackoverflow.com/questions/13554191/sorting-vim-folds - :SortRangesByRange inspired by   http://superuser.com/questions/752032/how-do-i-sort-multiple-blocks-of-text-by-the-first-line-in-each-block-in-vim - :SortByExpr inspired by   http://stackoverflow.com/questions/11531073/how-do-you-sort-a-range-of-lines-by-length - :SortWORDs inspired by   http://stackoverflow.com/questions/26739697/sort-line-horizontally-in-vim   http://stackoverflow.com/questions/1327978/sorting-words-not-lines-in-vim SEE ALSO - The LineJuggler.vim plugin (vimscript #4140) offers many quick mappings to   move around (blocks of) lines. For small data sets, manual shifting may be   quicker than coming up with a correct sort command. USAGE :[range]SortVisible[!] [i][u][r][n][x][o] [/{pattern}/]                         Sort visible lines in the buffer / [range]. Lines                         inside closed folds are kept intact; sorting is done                         on all lines of the fold as one unit; i.e. the order                         of the other lines inside the fold does _not_ change! :[range]SortRangesByHeader[!] /{expr}/ [i][u][r][n][x][o] [/{pattern}/]                         Each match of {expr} (in the buffer / [range]) starts                         a new area that sorts as one unit; i.e. the order of                         the other lines inside the area does _not_ change!                         Lines before the first header are sorted individually. :[range]SortRangesByMatch[!] /{expr}/ [i][u][r][n][x][o] [/{pattern}/]                         Each (multi-line) match of {expr} (in the buffer /                         [range]) defines an area that sorts as one unit,                         together with individual non-matching lines. :[range]SortRangesByRange[!] {range} [i][u][r][n][x][o] [/{pattern}/]                         Each {range} (in the buffer / [range]) defines an area                         that sorts as one unit.                         Note: For this command, /{pattern}/ must be separated                         from the {range} by a [i][u][r][n][x][o] flag or a                         space; you cannot directly concatenate them.                         Note: The text must not contain embedded <Nul>                         characters (^@) for the above commands! :[range]ReorderVisible {reorder-expr}                         Reorder visible lines in the buffer / [range] by                         collecting into a List of Strings (multiple folded                         lines are joined with newlines) and passing it (as                         v:val) to {reorder-expr}. :[range]ReorderFolded {reorder-expr}                         Reorder folded lines in the buffer / [range] by                         collecting into a List of Strings (multiple folded                         lines are joined with newlines) and passing it (as                         v:val) to {reorder-expr}. Those are then re-inserted                         in between any unfolded lines, which stay as they                         were. :[range]ReorderUnfolded {reorder-expr}                         Reorder unfolded lines in the buffer / [range] by                         collecting into a List of Strings (subsequent unfolded                         lines are joined with newlines) and passing it (as                         v:val) to {reorder-expr}. Those are then re-inserted                         in between any closed folds, which stay as they were. :[range]ReorderByHeader /{expr}/ {reorder-expr}                         Each match of {expr} (in the buffer / [range]) starts                         a new area that is reordered as one unit (joined with                         newlines) by passing it (as v:val) to {reorder-expr}.                         Lines before the first header are reordered as another                         single unit. :[range]ReorderOnlyByMatch /{expr}/ {reorder-expr}                         Each (multi-line) match of {expr} (in the buffer /                         [range]) defines an area that is reordered as one unit                         (joined with newlines) by passing it (as v:val) to                         {reorder-expr}. Those are then re-inserted in between                         any non-matching lines, which stay as they were. :[range]ReorderByMatchAndNonMatches /{expr}/ {reorder-expr}                         Each (multi-line) match of {expr} (in the buffer /                         [range]) defines an area that is reordered as one unit                         (joined with newlines), together with units of                         non-matching lines, by passing it (as v:val) to                         {reorder-expr}. :[range]ReorderByMatchAndLines /{expr}/ {reorder-expr}                         Each (multi-line) match of {expr} (in the buffer /                         [range]) defines an area that is reordered as one unit                         (joined with newlines), together with individual                         non-matching lines, by passing it (as v:val) to                         {reorder-expr}. :[range]ReorderOnlyByRange {range} {reorder-expr}                         Each {range} (in the buffer / [range]) defines an area                         that is reordered as one unit (joined with newlines),                         by passing it (as v:val) to {reorder-expr}. Those are                         then re-inserted in between any non-matching lines,                         which stay as they were. :[range]ReorderByRangeAndNonMatches {range} {reorder-expr}                         Each {range} (in the buffer / [range]) defines an area                         that is reordered as one unit (joined with newlines),                         together with individual non-matching lines, by                         passing it (as v:val) to {reorder-expr}. :[range]ReorderByRangeAndLines {range} {reorder-expr}                         Each {range} (in the buffer / [range]) defines an area                         that is reordered as one unit (joined with newlines),                         together with individual non-matching lines, by                         passing it (as v:val) to {reorder-expr}. :[range]SortByExpr[!] {expr}                         Sort lines in [range] by the {expr}, which should take                         the current line as input via v:val and return a                         number. With [!] the order is reversed. :[range]SortByExprUnique[!] {expr}                         Sort lines in [range] by the {expr}; only the first                         line that gets a certain number from {expr} is kept.                         With [!] the order is reversed. :[range]SortByCharLength[!]                         Sort lines in [range] by the number of characters. :[range]SortByWidth[!]                         Sort lines in [range] by the display width. :[range]SortEach /{delimiter-pattern}/[{joiner}/] :[range]SortEach /{delimiter-pattern}/[{joiner}]/ [i][u][r][n][x][o] /{pattern}/                         Sort individual elements delimited by                         {delimiter-pattern} (or newlines) in the current line                         / [range], and join them back together with the first                         matching delimiter [or {joiner}]. :[range]SortWORDs[!] [i][u][r][n][x][o] [/{pattern}/]                         Sort individual (whitespace-delimited) WORDs in the                         current line / [range]. :[range]UniqAny [i][r] [/{pattern}/]                         Remove lines in [range] that have already been                         encountered earlier (not necessarily adjacent).                         With [i] case is ignored.                         When /{pattern}/ is specified and there is no [r] flag                         the text matched with {pattern} is ignored.                         With [r] only the matching {pattern} is considered;                         the rest is ignored.                         If a {pattern} is used, any lines which don't have a                         match for {pattern} are kept. :[range]UniqSubsequent [i][r] [/{pattern}/]                         Remove second and succeeding copies of repeated                         adjacent lines in [range].                         With [i] case is ignored.                         When /{pattern}/ is specified and there is no [r] flag                         the text matched with {pattern} is ignored.                         With [r] only the matching {pattern} is considered;                         the rest is ignored.                         If a {pattern} is used, any lines which don't have a                         match for {pattern} are kept. EXAMPLE We're taking any Vimscript file with multiple function definitions as an example, and show how to sort whole functions according to function name (and arguments). To use folding, we first have to define the folds, then trigger the sorting:     :g/^function/,/^endfunction/fold     :SortVisible If we don't care about including any lines after the "endfunction", we can just base the areas on the function start:     :SortRangesByHeader /^function/ But we'll get better results with an explicit end. One way is to define a multi-line pattern that covers the entire function:     :SortRangesByMatch /^function\_.\{-}\nendfunction$/ Another way spans up a range, similar to what we've done above to define the folds:     :SortRangesByRange /^function/,/^endfunction$/

install details

INSTALLATION The code is hosted in a Git repo at     https://github.com/inkarkat/vim-AdvancedSorters You can use your favorite plugin manager, or "git clone" into a directory used for Vim packages. Releases are on the "stable" branch, the latest unstable development snapshot on "master". This script is also packaged as a vimball. If you have the "gunzip" decompressor in your PATH, simply edit the *.vmb.gz package in Vim; otherwise, decompress the archive first, e.g. using WinZip. Inside Vim, install by sourcing the vimball or via the :UseVimball command.     vim AdvancedSorters*.vmb.gz     :so % To uninstall, use the :RmVimball command. DEPENDENCIES - Requires Vim 7.0 or higher. - Requires the ingo-library.vim plugin (vimscript #4433), version 1.039 or   higher.

Click on the package to download.

package	script version	date	Vim version	user	release notes
AdvancedSorters-1.30.vmb.gz	1.30	2020-02-03	7.0	Ingo Karkat	- CHG: Rename :Uniq to :UniqAny and add :UniqSubsequent variant. - Add :SortEach generalization of :SortWORDs. - CHG: Rename :SortUnfolded to :SortVisible. - ENH: Add various :ReorderBy... commands that mirror the :SortVisible and :SortRangedBy... commands, but allow arbitrary reorderings via a Vimscript expression. *** You need to update to ingo-library (vimscript #4433) version 1.039! ***
AdvancedSorters-1.21.vmb.gz	1.21	2016-10-26	7.0	Ingo Karkat	- BUG: :SortUnfolded and :SortRangedBy... remove comment sigils (like "#") when 'formatoptions' contains "j". Temporarily reset 'formatoptions' to avoid interference of user settings. Thanks to Holger Mitschke for reporting this!
AdvancedSorters-1.20.vmb.gz	1.20	2015-02-09	7.0	Ingo Karkat	- Add :Uniq command. - Also support [/{pattern}/] [i][u][r][n][x][o] :sort argument order (and mixed). - FIX: Include missing Words.vim module that prevented the :SortWORDs command introduced in the previous version 1.10 from functioning.
AdvancedSorters-1.10.vmb.gz	1.10	2014-12-23	7.0	Ingo Karkat	- Add :SortWORDs command.
AdvancedSorters-1.02.vmb.gz	1.02	2014-11-06	7.0	Ingo Karkat	- BUG: :.SortRangesBy... doesn't work correctly on a closed fold; need to use ingo#range#NetStart(). *** You need to update to ingo-library (vimscript #4433) version 1.022! ***
AdvancedSorters-1.01.vmb.gz	1.01	2014-07-10	7.0	Ingo Karkat	- Make :SortRangesByRange work for Vim versions before 7.4.218 that don't have uniq(). *** You need to update to ingo-library (vimscript #4433) version 1.021! ***
AdvancedSorters-1.00.vmb.gz	1.00	2014-06-11	7.0	Ingo Karkat	Initial upload

ip used for rating: 3.145.15.205