Repository navigation
Expand file tree
/
Copy pathmini-align.txt
More file actions
905 lines (745 loc) · 33.8 KB
/
Copy pathmini-align.txt
File metadata and controls
905 lines (745 loc) · 33.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
*mini.align* Align text interactively
*MiniAlign*
MIT License Copyright (c) 2022 Evgeni Chasnovski
==============================================================================
Rich and flexible customization of both alignment rules and user interaction.
Works with charwise, linewise, and blockwise selections in both Normal mode
(on textobject/motion; with dot-repeat) and Visual mode.
Features:
- Alignment is done in three main steps:
- <Split> lines into parts based on Lua pattern(s) or user-supplied rule.
- <Justify> parts for certain side(s) to be same width inside columns.
- <Merge> parts to be lines, with customizable delimiter(s).
Each main step can be preceded by other steps (pre-steps) to achieve
highly customizable outcome. See `steps` value in |MiniAlign.config|. For
more details, see |MiniAlign-glossary| and |MiniAlign-algorithm|.
- User can control alignment interactively by pressing customizable modifiers
(single keys representing how alignment steps and/or options should change).
Some of default modifiers:
- Press `s` to enter split Lua pattern.
- Press `j` to choose justification side from available ones ("left",
"center", "right", "none").
- Press `m` to enter merge delimiter.
- Press `f` to enter filter Lua expression to configure which parts
will be affected (like "align only first column").
- Press `i` to ignore some commonly unwanted split matches.
- Press `p` to pair neighboring parts so they be aligned together.
- Press `t` to trim whitespace from parts.
- Press `<BS>` (backspace) to delete some last pre-step.
For more details, see |MiniAlign-modifiers-builtin| and |MiniAlign-examples|.
- Alignment can be done with instant preview (result is updated after each
modifier) or without it (result is shown and accepted after non-default
split pattern is set).
- Every user interaction is accompanied with helper status message showing
relevant information about current alignment process.
# Setup ~
This module needs a setup with `require('mini.align').setup({})` (replace
`{}` with your `config` table). It will create global Lua table `MiniAlign`
which you can use for scripting or manually (with `:lua MiniAlign.*`).
See |MiniAlign.config| for available config settings.
You can override runtime config settings (like `config.modifiers`) locally
to buffer inside `vim.b.minialign_config` which should have same structure
as `MiniAlign.config`. See |mini.nvim-buffer-local-config| for more details.
To stop module from showing non-error feedback, set `config.silent = true`.
# Comparisons ~
- 'junegunn/vim-easy-align':
- 'mini.align' is mostly designed after 'junegunn/vim-easy-align', so
there are a lot of similarities.
- Both plugins allow users to change alignment options interactively by
pressing modifier keys (albeit completely different default ones).
'junegunn/vim-easy-align' has those modifiers fixed, while 'mini.align'
allows their full customization. See |MiniAlign.config| for examples.
- 'junegunn/vim-easy-align' is designed to treat delimiters differently
than other parts of strings. 'mini.align' doesn't distinguish split
parts from one another by design: splitting is allowed to be done
based on some other logic than by splitting on delimiters.
- 'junegunn/vim-easy-align' initially aligns by only first delimiter.
'mini.align' initially aligns by all delimiter.
- 'junegunn/vim-easy-align' implements special filtering by delimiter
row number. 'mini.align' has builtin filtering based on Lua code
supplied by user in modifier phase. See |MiniAlign.gen_step.filter|
and 'f' builtin modifier.
- 'mini.align' treats any non-registered modifier as a plain delimiter
pattern, while 'junegunn/vim-easy-align' does not.
- 'mini.align' exports core Lua function used for aligning strings
(|MiniAlign.align_strings()|).
- 'godlygeek/tabular':
- 'godlygeek/tabular' is mostly designed around single command which is
customized by printing its parameters. 'mini.align' implements
different concept of interactive alignment through pressing
customizable single character modifiers.
- 'godlygeek/tabular' can detect region upon which alignment can be
desirable. 'mini.align' does not by design: use Visual selection or
textobject/motion to explicitly define region to align.
# Disabling ~
To disable, set `vim.g.minialign_disable` (globally) or `vim.b.minialign_disable`
(for a buffer) to `true`. Considering high number of different scenarios
and customization intentions, writing exact rules for disabling module's
functionality is left to user. See |mini.nvim-disabling-recipes| for common
recipes.
------------------------------------------------------------------------------
*MiniAlign-glossary*
Glossary
PARTS 2d array of strings (array of arrays of strings).
See more in |MiniAlign.as_parts()|.
ROW First-level array of parts (like `parts[1]`).
COLUMN Array of strings, constructed from parts elements with the same
second-level index (like `{ parts[1][1],` `parts[2][1], ... }`).
STEP A named callable. See |MiniAlign.new_step()|. When used in terms of
alignment steps, callable takes two arguments: some object (parts
or string array) and option table.
SPLIT Process of taking array of strings and converting it into parts.
JUSTIFY Process of taking parts and converting them to aligned parts (all
elements have same widths inside columns).
MERGE Process of taking parts and converting it back to array of strings.
Usually by concatenating rows into strings.
REGION Table representing region in a buffer. Fields: <from> and <to> for
inclusive start and end positions (<to> might be `nil` to describe
empty region). Each position is also a table with line <line> and
column <col> (both start at 1).
MODE Either charwise ("char", `v`, |charwise|), linewise ("line", `V`,
|linewise|) or blockwise ("block", `<C-v>`, |blockwise-visual|)
------------------------------------------------------------------------------
*MiniAlign-algorithm*
Algorithm design
There are two main processes implemented in 'mini.align': strings alignment
and interactive region alignment. See |MiniAlign-glossary| for more information
about used terms.
Strings alignment ~
Main implementation is in |MiniAlign.align_strings()|. Its input is array of
strings and output - array of aligned strings. The process consists from three
main steps (split, justify, merge) which can be preceded by any number of
preliminary steps (pre-split, pre-justify, pre-merge).
Algorithm:
- <Pre-split>. Take input array of strings and consecutively apply all
pre-split steps (`steps.pre_split`). Each one has `(strings, opts)` signature
and should modify array in place.
- <Split>. Take array of strings and convert it to parts with `steps.split()`.
It has `(strings, opts)` signature and should return parts.
- <Pre-justify>. Take parts and consecutively apply all pre-justify
steps (`steps.pre_justify`). Each one has `(parts, opts)` signature and
should modify parts in place.
- <Justify>. Take parts and apply `steps.justify()`. It has `(parts, opts)`
signature and should modify parts in place.
- <Pre-merge>. Take parts and consecutively apply all pre-merge
steps (`steps.pre_merge`). Each one has `(parts, opts)` signature and
should modify parts in place.
- <Merge>. Take parts and convert it to array of strings with `steps.merge()`.
It has `(parts, opts)` signature and should return array of strings.
Notes:
- All table objects are initially copied so that modification in place doesn't
affect workflow.
- Default main steps are designed to be controlled via options. See
|MiniAlign.align_strings()| and default step entries in |MiniAlign.gen_step|.
- All steps are guaranteed to take same option table as second argument.
This allows steps to "talk" to each other, i.e. earlier steps can pass data
to later ones.
Interactive region alignment ~
Interactive alignment is a main entry point for most users. It can be done
in two flavors:
- <Without preview>. Initiated via mapping defined in `start` of
`MiniAlign.config.mappings`. Alignment is accepted once split pattern becomes
non-default.
- <With preview>. Initiated via mapping defined in `start_with_preview` of
`MiniAlign.config.mappings`. Alignment result is shown after every modifier
and is accepted after `<CR>` (`Enter`) is hit. Note: each preview is done by
applying current alignment steps and options to the initial region lines,
not the ones currently displaying in preview.
Lifecycle (assuming default mappings):
- <Initiate alignment>:
- In Normal mode type `ga` (or `gA` to show preview) followed by textobject
or motion defining region to be aligned.
- In Visual mode select region and type `ga` (or `gA` to show preview).
Strings contained in selected region will be used as input to
|MiniAlign.align_strings()|.
Beware of mode when selecting region: charwise (`v`), linewise (`V`), or
blockwise (`<C-v>`). They all behave differently.
- <Press modifiers>. Press single keys one at a time:
- If pressed key is among table keys of `modifiers` table of
|MiniAlign.config|, its function value is executed. It usually modifies
some options(s) and/or affects some pre-step(s).
- If pressed key is not among defined modifiers, it is treated as plain
split pattern.
This process can either end by itself (usually in case of no preview and
non-default split pattern being set) or you can choose to end it manually.
- <Accept or discard>. In case of active preview, accept current result by
pressing `<CR>`. Discard any result and return to initial regions with
either `<Esc>` or `<C-c>`.
See more in |MiniAlign-modifiers-builtin| and |MiniAlign-examples|.
Notes:
- Visual blockwise selection works best with 'virtualedit' equal to "block"
or "all".
------------------------------------------------------------------------------
*MiniAlign-modifiers-builtin*
Overview of builtin modifiers
All examples assume interactive alignment with preview in linewise mode. With
default mappings, use `V` to select lines and `gA` to initiate alignment. It
might be helpful to copy lines into modifiable buffer and experiment yourself.
Notes:
- Any pressed key which doesn't have defined modifier will be treated as
plain split pattern.
- All modifiers can be customized inside |MiniAlign.setup|. See "Modifiers"
section of |MiniAlign.config|.
Main option modifiers ~
<s> Enter split pattern (confirm prompt by pressing `<CR>`). Input is treated
as plain delimiter.
Before: >
a-b-c
aa-bb-cc
<
After typing `s-<CR>`: >
a -b -c
aa-bb-cc
<
<j> Choose justify side. Prompts user (with helper message) to type single
character identifier of side: `l`eft, `c`enter, `r`ight, `n`one.
Before: >
a_b_c
aa_bb_cc
<
After typing `_jr` (first make split by `_`): >
a_ b_ c
aa_bb_cc
<
<m> Enter merge delimiter (confirm prompt by pressing `<CR>`).
Before: >
a_b_c
aa_bb_cc
<
After typing `_m--<CR>` (first make split by `_`): >
a --_--b --_--c
aa--_--bb--_--cc
<
Modifiers adding pre-steps ~
<f> Enter filter expression. See more details in |MiniAlign.gen_step.filter()|.
Before: >
a_b_c
aa_bb_cc
<
After typing `_fn==1<CR>` (first make split by `_`): >
a _b_c
aa_bb_cc
<
<i> Ignore some split matches. It modifies `split_exclude_patterns` option by
adding commonly wanted patterns. See more details in
|MiniAlign.gen_step.ignore_split()|.
Before: >
/* This_is_assumed_to_be_comment */
a"_"_b
aa_bb
<
After typing `_i` (first make split by `_`): >
/* This_is_assumed_to_be_comment */
a"_"_b
aa _bb
<
<p> Pair neighboring parts.
Before: >
a_b_c
aaa_bbb_ccc
<
After typing `_p` (first make split by `_`): >
a_ b_ c
aaa_bbb_ccc
<
<t> Trim parts from whitespace on both sides (keeping indentation).
Before: >
a _ b _ c
aa _bb _cc
<
After typing `_t` (first make split by `_`): >
a _b _c
aa_bb_cc
<
Delete some last pre-step ~
<BS> Delete one of the pre-steps. If there is only one kind of pre-steps,
remove its latest added one. If not, prompt user to choose pre-step kind
by entering single character: `s`plit, `j`ustify, `m`erge.
Examples:
- `tp<BS>` results in only "trim" step to be left.
- `it<BS>` prompts to choose which step to delete (pre-split or
pre-justify in this case).
Special configurations for common splits ~
<=> Use special pattern to align by a group of consecutive "=". It can be
preceded by any number of punctuation marks and followed by some sommon
punctuation characters. Trim whitespace and merge with single space.
Before: >
a=b
aa<=bb
aaa===bbb
aaaa = cccc
<
After typing `=`: >
a = b
aa <= bb
aaa === bbb
aaaa = cccc
<
<,> Besides splitting by "," character, trim whitespace, pair neighboring
parts and merge with single space.
Before: >
a,b
aa,bb
aaa , bbb
<
After typing `,`: >
a, b
aa, bb
aaa, bbb
<
< > (Space bar) Squash consecutive whitespace into single single space (accept
possible indentation) and split by `%s+` pattern (keeps indentation).
Before: >
a b c
aa bb cc
<
After typing `<Space>`: >
a b c
aa bb cc
------------------------------------------------------------------------------
*MiniAlign-examples*
More complex examples to explore functionality
Copy lines in modifiable buffer, initiate alignment with preview (`gAip`)
and try typing suggested key sequences.
These are modified examples taken from 'junegunn/vim-easy-align'.
Equal sign ~
Lines:
# This=is=assumed=to be a comment
"a ="
a =
a = 1
bbbb = 2
ccccccc = 3
ccccccccccccccc
ddd = 4
eeee === eee = eee = eee=f
fff = ggg += gg &&= gg
g != hhhhhhhh == 888
i := 5
i %= 5
i *= 5
j =~ 5
j >= 5
aa => 123
aa <<= 123
aa >>= 123
bbb => 123
c => 1233123
d => 123
dddddd &&= 123
dddddd ||= 123
dddddd /= 123
gg <=> ee
Key sequences:
- `=`
- `=jc`
- `=jr`
- `=m!<CR>`
- `=p`
- `=i` (execute `:lua vim.o.commentstring = '# %s'` for full experience)
- `=<BS>`
- `=<BS>p`
- `=fn==1<CR>`
- `=<BS>fn==1<CR>t`
- `=frow>7<CR>`
------------------------------------------------------------------------------
*MiniAlign.setup()*
`MiniAlign.setup`({config})
Module setup
Parameters ~
{config} `(table|nil)` Module config table. See |MiniAlign.config|.
Usage ~
`require('mini.align').setup({})` (replace `{}` with your `config` table)
------------------------------------------------------------------------------
*MiniAlign.config*
`MiniAlign.config`
Module config
Default values:
>
MiniAlign.config = {
-- Module mappings. Use `''` (empty string) to disable one.
mappings = {
start = 'ga',
start_with_preview = 'gA',
},
-- Modifiers changing alignment steps and/or options
modifiers = {
-- Main option modifiers
['s'] = --<function: enter split pattern>,
['j'] = --<function: choose justify side>,
['m'] = --<function: enter merge delimiter>,
-- Modifiers adding pre-steps
['f'] = --<function: filter parts by entering Lua expression>,
['i'] = --<function: ignore some split matches>,
['p'] = --<function: pair parts>,
['t'] = --<function: trim parts>,
-- Delete some last pre-step
['<BS>'] = --<function: delete some last pre-step>,
-- Special configurations for common splits
['='] = --<function: enhanced setup for '='>,
[','] = --<function: enhanced setup for ','>,
[' '] = --<function: enhanced setup for ' '>,
},
-- Default options controlling alignment process
options = {
split_pattern = '',
justify_side = 'left',
merge_delimiter = '',
},
-- Default steps performing alignment (if `nil`, default is used)
steps = {
pre_split = {},
split = nil,
pre_justify = {},
justify = nil,
pre_merge = {},
merge = nil,
},
-- Whether to disable showing non-error feedback
silent = false,
}
<
# Options ~
## Modifiers ~
`MiniAlign.config.modifiers` is used to define interactive user experience
of managing alignment process. It is a table with single character keys and
modifier function values.
Each modifier function:
- Is called when corresponding modifier key is pressed.
- Has signature `(steps, opts)` and should modify any of its input in place.
Examples:
- Modifier function used for default 'i' modifier: >
function(steps, _)
table.insert(steps.pre_split, MiniAlign.gen_step.ignore_split())
end
<
- Tweak 't' modifier to use highest indentation instead of keeping it: >
require('mini.align').setup({
modifiers = {
t = function(steps, _)
local trim_high = MiniAlign.gen_step.trim('both', 'high')
table.insert(steps.pre_justify, trim_high)
end
}
})
<
- Tweak `j` modifier to cycle through available "justify_side" option
values (like in 'junegunn/vim-easy-align'): >
require('mini.align').setup({
modifiers = {
j = function(_, opts)
local next_option = ({
left = 'center', center = 'right', right = 'none', none = 'left',
})[opts.justify_side]
opts.justify_side = next_option or 'left'
end,
},
})
<
## Options ~
`MiniAlign.config.options` defines default values of options used to control
behavior of steps.
Examples:
- Set `justify_side = 'center'` to center align at initialization.
For more details about options see |MiniAlign.align_strings()| and entries of
|MiniAlign.gen_step| for default main steps.
## Steps ~
`MiniAlign.config.steps` defines default steps to be applied during
alignment process.
Examples:
- Align by default only first pair of columns: >
local align = require('mini.align')
align.setup({
steps = {
pre_justify = { align.gen_step.filter('n == 1') }
},
})
------------------------------------------------------------------------------
*MiniAlign.align_strings()*
`MiniAlign.align_strings`({strings}, {opts}, {steps})
Align strings
For details about alignment process see |MiniAlign-algorithm|.
Parameters ~
{strings} `(table)` Array of strings.
{opts} `(table|nil)` Options. Its copy will be passed to steps as second
argument. Extended with `MiniAlign.config.options`.
This is a place to control default main steps:
- `opts.split_pattern` - Lua pattern(s) used to make split parts.
- `opts.split_exclude_patterns` - which split matches should be ignored.
- `opts.justify_side` - which direction(s) alignment should be done.
- `opts.justify_offsets` - offsets tweaking width of first column
- `opts.merge_delimiter` - which delimiter(s) to use when merging.
For more information see |MiniAlign.gen_step| entry for corresponding
default step.
{steps} `(table|nil)` Steps. Extended with `MiniAlign.config.steps`.
Possible `nil` values are replaced with corresponding default steps:
- `split` - |MiniAlign.gen_step.default_split()|.
- `justify` - |MiniAlign.gen_step.default_justify()|.
- `merge` - |MiniAlign.gen_step.default_merge()|.
------------------------------------------------------------------------------
*MiniAlign.align_user()*
`MiniAlign.align_user`({mode})
Align current region with user-supplied steps
Mostly designed to be used inside mappings.
Will use |MiniAlign.align_strings()| and set the following options in `opts`:
- `justify_offsets` - array of offsets used to achieve actual alignment of
a region. It is non-trivial (not array of zeros) only for charwise
selection: offset of first string is computed as width of prefix to the
left of region start.
- `region` - current affected region (see |MiniAlign-glossary|). Can be
used to create more advanced steps.
- `mode` - mode of selection (see |MiniAlign-glossary|).
Parameters ~
{mode} `(string)` Selection mode. One of "char", "line", "block".
------------------------------------------------------------------------------
*MiniAlign.as_parts()*
`MiniAlign.as_parts`({arr2d})
Convert 2d array of strings to parts
This function verifies if input is a proper 2d array of strings and adds
methods to its copy.
Class ~
{parts}
Fields ~
{apply} `(function)` Takes callable `f` and applies it to every part.
Callable should have signature `(s, data)`: `s` is a string part,
`data` - table with its data (<row> has row number, <col> has column number).
Returns new 2d array.
{apply_inplace} `(function)` Takes callable `f` and applies it to every part.
Should have same signature as in `apply` method. Outputs (should all be
strings) are assigned in place to a corresponding parts element. Returns
parts itself to enable method chaining.
{get_dims} `(function)` Return dimensions of parts array: a table with
<row> and <col> keys having number of rows and number of columns (maximum
number of elements across all rows).
{group} `(function)` Concatenate neighboring strings based on supplied
boolean mask and direction (one of "left", default, or "right"). Has
signature `(mask, direction)` and modifies parts in place. Returns parts
itself to enable method chaining.
Example:
- Parts: { { "a", "b", "c" }, { "d", "e" }, { "f" } }
- Mask: { { false, false, true }, { true, false }, { false } }
- Result for direction "left": { { "abc" }, { "d", "e" }, { "f" } }
- Result for direction "right": { { "ab","c" }, { "de" }, { "f" } }
{pair} `(function)` Concatenate neighboring element pairs. Takes
`direction` as input (one of "left", default, or "right") and applies
`group()` for an alternating mask.
Example:
- Parts: { { "a", "b", "c" }, { "d", "e" }, { "f" } }
- Result for direction "left": { { "ab", "c" }, { "de" }, { "f" } }
- Result for direction "right": { { "a", "bc" }, { "de" }, { "f" } }
{slice_col} `(function)` Return column with input index `j`. Note: it might
not be an array if rows have unequal number of columns.
{slice_row} `(function)` Return row with input index `i`.
{trim} `(function)` Trim elements whitespace. Has signature `(direction, indent)`
and modifies parts in place. Returns parts itself to enable method chaining.
- Possible values of `direction`: "both" (default), "left", "right",
"none". Defines from which side whitespaces should be removed.
- Possible values of `indent`: "keep" (default), "low", "high", "remove".
Defines what to do with possible indent (left whitespace of first string
in a row). Value "keep" keeps it; "low" makes all indent equal to the
lowest across rows; "high" - highest across rows; "remove" - removes indent.
Usage ~
>
parts = MiniAlign.as_parts({ { 'a', 'b' }, { 'c' } })
print(vim.inspect(parts.get_dims())) -- Should be { row = 2, col = 2 }
parts.apply_inplace(function(s, data)
return ' ' .. data.row .. s .. data.col .. ' '
end)
print(vim.inspect(parts)) -- Should be { { ' 1a1 ', ' 1b2 ' }, { ' 2c1 ' } }
parts.trim('both', 'remove').pair()
print(vim.inspect(parts)) -- Should be { { '1a11b2' }, { '2c1' } }
------------------------------------------------------------------------------
*MiniAlign.new_step()*
`MiniAlign.new_step`({name}, {action})
Create step
A step is basically a named callable object. Having a name bundled with
some action powers helper status message during interactive alignment process.
Parameters ~
{name} `(string)` Step name.
{action} `(function|table)` Step action. Should be a callable object
(see |vim.is_callable()|).
Return ~
`(table)` A table with keys: <name> with `name` argument, <action> with `action`.
------------------------------------------------------------------------------
*MiniAlign.gen_step*
`MiniAlign.gen_step`
Generate common action steps
This is a table with function elements. Call to actually get step.
Each step action is a function that has signature `(object, opts)`, where
`object` is either parts or array of strings (depends on which stage of
alignment process it is assumed to be applied) and `opts` is table of options.
Outputs of elements named `default_*` are used as default corresponding main
step (split, justify, merge). Behavior of all of them depend on values from
supplied options (second argument).
Outputs of other elements depend on both step generator input values and
options supplied at execution. This design is mostly because their output
can be used several times in pre-steps.
Usage ~
>
local align = require('mini.align')
align.setup({
modifiers = {
-- Use 'T' modifier to remove both whitespace and indent
T = function(steps, _)
table.insert(steps.pre_justify, align.gen_step.trim('both', 'remove'))
end,
},
options = {
-- By default align "right", "left", "right", "left", ...
justify_side = { 'right', 'left' },
},
steps = {
-- Align by default only first pair of columns
pre_justify = { align.gen_step.filter('n == 1') },
},
})
------------------------------------------------------------------------------
*MiniAlign.gen_step.default_split()*
`MiniAlign.gen_step.default_split`()
Generate default split step
Output splits strings using matches of Lua pattern(s) from `split_pattern`
option which are not dismissed by `split_exclude_patterns` option.
Outline of how single string is split:
- Convert `split_pattern` option to array of strings (string is converted
as one-element array). This array will be recycled in case there are more
split matches than in converted `split_pattern` array (which almost always).
- Find all forbidden spans (intervals inside string) - all matches of all
patterns in `split_exclude_patterns`.
- Find match for the next pattern. If it is not inside any forbidden span,
add preceding unmatched substring and matched split as two parts. Repeat
with the next pattern.
- If no pattern match is found, add the rest of string as final part.
Output uses following options (as part second argument, `opts` table):
- <split_pattern> - string or array of strings used to detect split matches
and create parts. Default: `''` meaning no matches (whole string is used
as part). Examples: `'%s+'`, `{ '<', '>' }`.
- <split_exclude_patterns> - array of strings defining which regions to
exclude from being matched. Default: `{}`. Examples: `{ '".-"', '^%s*#.*' }`.
Return ~
`(table)` A step named "split" and with appropriate callable action.
See also ~
|MiniAlign.gen_step.ignore_split()| heavily uses `split_exclude_patterns`.
------------------------------------------------------------------------------
*MiniAlign.gen_step.default_justify()*
`MiniAlign.gen_step.default_justify`()
Generate default justify step
Output makes column elements of string parts have equal width by adding
left and/or right whitespace padding. Which side(s) to pad is defined by
`justify_side` option. Width of first column can be tweaked with `justify_offsets`
option.
Outline of how parts are justified:
- Convert `justify_side` option to array of strings (single string is
converted as one-element array). Recycle this array to have length equal
to number of columns in parts.
- For all columns compute maximum width of strings from it (add offsets from
`justify_offsets` to first column widths). Note: for left alignment, width
of last row element does not affect column width. This is mainly because
it won't be padded and helps dealing with "no single match" lines.
- Make all elements have same width inside column by adding appropriate
amount of whitespace. Which side(s) to add is controlled by the corresponding
`justify_side` array element. Note: padding is done with spaces which
might conflict with tab indentation.
Output uses following options (as part second argument, `opts` table):
- <justify_side> - string or array of strings. Each element can be one of
"left" (pad right side), "center" (pad both sides equally), "right" (pad
left side), "none" (no padding). Default: "left".
- <justify_offsets> - array of numeric left offsets of rows. Used to adjust
for possible not equal indents, like in case of charwise selection when
left edge is not on the first column. Default: array of zeros. Set
automatically during interactive alignment in charwise mode.
Return ~
`(table)` A step named "justify" and with appropriate callable action.
------------------------------------------------------------------------------
*MiniAlign.gen_step.default_merge()*
`MiniAlign.gen_step.default_merge`()
Generate default merge step
Output merges rows of parts into strings by placing merge delimiter(s)
between them.
Outline of how parts are converted to array of strings:
- Convert `merge_delimiter` option to array of strings (single string is
converted as one-element array). Recycle this array to have length equal
to number of columns in parts minus 1.
- Exclude empty strings from parts. They add nothing to output except extra
usage of merge delimiter.
- Concatenate each row interleaving with array of merge delimiters.
Output uses following options (as part second argument, `opts` table):
- <merge_delimiter> - string or array of strings. Default: `''`.
Examples: `' '`, `{ '', ' ' }`.
Return ~
`(table)` A step named "merge" and with appropriate callable action.
------------------------------------------------------------------------------
*MiniAlign.gen_step.filter()*
`MiniAlign.gen_step.filter`({expr})
Generate filter step
Construct function predicate from supplied Lua string expression and make
step evaluating it on every part element.
Outline of how filtering is done:
- Convert Lua filtering expression into function predicate which can be
evaluated in manually created context (some specific variables being set).
- Compute boolean mask for parts by applying predicate to each element of
2d array with special variables set to specific values (see next section).
- Group parts with compted mask. See `group()` method of parts in
|MiniAlign.as_parts()|.
Special variables which can be used in expression:
- <row> - row number of current element.
- <ROW> - total number of rows in parts.
- <col> - column number of current element.
- <COL> - total number of columns in current row.
- <s> - string value of current element.
- <n> - column pair number of current element. Useful when filtering by
result of pattern splitting.
- <N> - total number of column pairs in current row.
- All variables from global table `_G`.
Tips:
- This general filtering approach can be used to both include and exclude
certain parts from alignment. Examples:
- Use `row ~= 2` to align all parts except from second row.
- Use `n == 1` to align only by first pair of columns.
- Filtering by last equal sign usually can be done with `n >= (N - 1)`
(because there is usually something to the right of it).
Parameters ~
{expr} `(string)` Lua expression as a string which will be used as predicate.
Return ~
`(table|nil)` A step named "filter" and with appropriate callable action.
------------------------------------------------------------------------------
*MiniAlign.gen_step.ignore_split()*
`MiniAlign.gen_step.ignore_split`({patterns}, {exclude_comment})
Generate ignore step
Output adds certain values to `split_exclude_patterns` option. Should be
used as pre-split step.
Parameters ~
{patterns} `(table)` Array of patterns to be added to
`split_exclude_patterns` as is. Default: `{ [[".-"]] }` (excludes strings
for most cases).
{exclude_comment} `(boolean|nil)` Whether to add comment pattern to
`split_exclude_patterns`. Comment pattern is derived from 'commentstring'
option. Default: `true`.
Return ~
`(table)` A step named "ignore" and with appropriate callable action.
See also ~
|MiniAlign.gen_step.default_split()| for details about
`split_exclude_patterns` option.
------------------------------------------------------------------------------
*MiniAlign.gen_step.pair()*
`MiniAlign.gen_step.pair`({direction})
Generate pair step
Output calls `pair()` method of parts (see |MiniAlign.as_parts()|) with
supplied `direction` argument.
Parameters ~
{direction} `(string)` Which direction to pair. One of "left" (default) or
Return ~
`(table)` A step named "pair" and with appropriate callable action.
------------------------------------------------------------------------------
*MiniAlign.gen_step.trim()*
`MiniAlign.gen_step.trim`({direction}, {indent})
Generate trim step
Output calls `trim()` method of parts (see |MiniAlign.as_parts()|) with
supplied `direction` and `indent` arguments.
Parameters ~
{direction} `(string|nil)` Which sides to trim whitespace. One of "both"
(default), "left", "right", "none".
{indent} `(string|nil)` What to do with possible indent (left whitespace
of first string in a row). One of "keep" (default), "low", "high", "remove".
Return ~
`(table)` A step named "trim" and with appropriate callable action.
vim:tw=78:ts=8:noet:ft=help:norl: