Repository navigation
Expand file tree
/
Copy pathmini-visits.txt
More file actions
937 lines (741 loc) · 39.1 KB
/
Copy pathmini-visits.txt
File metadata and controls
937 lines (741 loc) · 39.1 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
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
*mini.visits* Track and reuse file system visits
MIT License Copyright (c) 2023 Evgeni Chasnovski
------------------------------------------------------------------------------
*MiniVisits*
Features:
- Persistently track file system visits (both files and directories)
per project directory. Store visit index is human readable and editable.
- Visit index is normalized on every write to contain relevant information.
Exact details can be customized. See |MiniVisits.normalize_index()|.
- Built-in ability to persistently add labels to path for later use.
See |MiniVisits.add_label()| and |MiniVisits.remove_label()|.
- Exported functions to reuse visit data:
- List visited paths/labels with custom filter and sort (uses "robust
frecency" by default). Can be used as source for pickers.
See |MiniVisits.list_paths()| and |MiniVisits.list_labels()|.
See |MiniVisits.gen_filter| and |MiniVisits.gen_sort|.
- Select visited paths/labels using |vim.ui.select()|.
See |MiniVisits.select_path()| and |MiniVisits.select_label()|.
- Iterate through visit paths in target direction ("forward", "backward",
"first", "last"). See |MiniVisits.iterate_paths()|.
- Exported functions to manually update visit index allowing persistent
track of any user information. See `*_index()` functions.
Notes:
- All data is stored _only_ in in-session Lua variable (for quick operation)
and at `config.store.path` on disk (for persistent usage).
- Most of functions affect an in-session data which gets written to disk only
before Neovim is closing or when users asks to.
- It doesn't account for paths being renamed or moved (because there is no
general way to detect that). Usually a manual intervention to the visit
index is required after the change but _before_ the next writing to disk
(usually before closing current session) because it will treat previous
path as deleted and remove it from index.
There is a |MiniVisits.rename_in_index()| helper for that.
If rename/move is done with |mini.files|, index is autoupdated.
Sources with more details:
- |MiniVisits-overview|
- |MiniVisits-index-specification|
- |MiniVisits-examples|
# Setup ~
This module needs a setup with `require('mini.visits').setup({})` (replace
`{}` with your `config` table). It will create global Lua table `MiniVisits`
which you can use for scripting or manually (with `:lua MiniVisits.*`).
See |MiniVisits.config| for `config` structure and default values.
You can override runtime config settings locally to buffer inside
`vim.b.minivisits_config` which should have same structure as
`MiniVisits.config`. See |mini.nvim-buffer-local-config| for more details.
# Comparisons ~
- [nvim-telescope/telescope-frecency.nvim](https://github.com/nvim-telescope/telescope-frecency.nvim):
- It stores array of actual visit timestamps, while this module tracks
only total number and latest timestamp of visits. This is by design
as a different trade-off between how much data is being used/stored
and complexity of underlying "frecency" sorting.
- By default tracks a buffer only once per session, while this module
tracks on every meaningful buffer enter. This leads to a more relevant
in-session sorting.
- Implements an original frecency algorithm of Firefox's address bar,
while this module uses own "robust frecency" approach.
- Mostly designed to work with 'nvim-telescope/telescope.nvim', while
this module provides general function to list paths and select
with |vim.ui.select()|.
- Does not allow use of custom data (like labels), while this module does.
- [ThePrimeagen/harpoon](https://github.com/ThePrimeagen/harpoon):
- Has slightly different concept than general labeling, which more
resembles adding paths to an ordered stack. This module implements
a more common labeling which does not imply order with ability to
make it automated depending on the task and/or preference.
- Implements marks as positions in a path, while this module labels paths.
- Writes data on disk after every meaning change, while this module is
more conservative and read only when Neovim closes or when asked to.
- Has support for labeling terminals, while this modules is oriented
only towards paths.
- Has dedicated UI to manage marks, while this module does not by design.
There are functions for adding and removing label from the path.
- Does not provide functionality to track and reuse any visited path,
while this module does.
# Disabling ~
To disable automated tracking, set `vim.g.minivisits_disable` (globally) or
`vim.b.minivisits_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.
------------------------------------------------------------------------------
*MiniVisits-overview*
# Tracking visits ~
File system visits (both directory and files) tracking is done in two steps:
- On every dedicated event (`config.track.event`, |BufEnter| by default) timer
is (re)started to actually register visit after certain amount of time
(`config.track.delay` milliseconds, 1000 by default). It is not registered
immediately to allow navigation to target buffer in several steps
(for example, with series of |:bnext| / |:bprevious|).
- When delay time passes without any dedicated events being triggered
(meaning user is "settled" on certain buffer), |MiniVisits.register_visit()|
is called if all of the following conditions are met:
- Module is not disabled (see "Disabling" section in |mini.visits|).
- Buffer is normal with non-empty name (used as visit path).
- Visit path does not equal to the latest tracked one. This is to allow
temporary enter of non-normal buffers (like help, terminal, etc.)
without artificial increase of visit count.
Visit is autoregistered for |current-directory| and leads to increase of count
and latest time of visit. See |MiniVisits-index-specification| for more details.
Notes:
- All data is stored _only_ in in-session Lua variable (for quick operation)
and at `config.store.path` on disk (for persistent usage). It is automatically
written to disk before every Neovim exit (if `config.store.autowrite` is set).
- Tracking can be disabled by supplying empty string as `track.event`.
Then it is up to the user to properly call |MiniVisits.register_visit()|.
# Reusing visits ~
Visit data can be reused in at least these ways:
- Get a list of visited paths (see |MiniVisits.list_paths()|) and use it
to visualize/pick/navigate visit history.
- Select one of the visited paths to open it (see |MiniVisits.select_path()|).
- Move along visit history (see |MiniVisits.iterate_paths()|).
- Utilize labels. Any visit can be added one or more labels (like "core",
"tmp", etc.). They are bound to the visit (path registered for certain
directory) and are stored persistently.
Labels can be used to manually create groups of files and/or directories
that have particular interest to the user.
There is no one right way to use them, though. See |MiniVisits-examples|
for some inspiration.
- Utilizing custom data. Visit index can be manipulated manually using
`_index()` set of functions. All "storable" (i.e. not functions or
metatables) user data inside index is then stored on disk, so it can be
used to create any kind of workflow user wants.
See |MiniVisits-examples| for some actual configuration and workflow examples.
------------------------------------------------------------------------------
*MiniVisits-index-specification*
# Structure ~
Visit index is a table containing actual data in two level deep nested tables.
First level keys are paths of project directory (a.k.a "cwd") for which
visits are registered.
Second level keys are actual visit paths. Their values are tables with visit
data which should follow these requirements:
- Field <count> should be present and be a number. It represents the number
of times this path was visited under particular cwd.
- Field <latest> should be present and be a number. It represents the time
of latest path visit under particular cwd.
By default computed with |os.time()| (up to a second).
- Field <labels> might not be present. If present, it should be a table
with string labels as keys and `true` as values. It represents labels of
the path under particular cwd.
Notes:
- All paths are absolute.
- Visit path should not necessarily be a part of corresponding cwd.
- Both `count` and `latest` can be any number: whole, fractional, negative, etc.
Example of an index data: >lua
{
['/home/user/project_1'] = {
['home/user/project_1/file'] = { count = 3, latest = 1699796000 },
['home/user/project_1/subdir'] = {
count = 10, latest = 1699797000, labels = { core = true },
},
},
['/home/user/project_2'] = {
['home/user/project_1/file'] = {
count = 0, latest = 0, labels = { other = true },
},
['home/user/project_2/README'] = { count = 1, latest = 1699798000 },
},
}
<
# Storage ~
When stored on disk, visit index is a file containing Lua code returning
visit index table. It can be edited by hand as long as it contains a valid
Lua code (to be executed with |dofile()|).
Notes:
- Storage is implemented in such a way that it doesn't really support more
than one parallel Neovim processes. Meaning that if there are two or more
simultaneous Neovim processes with same visit index storage path, the last
one writing to it will preserve its visit history while others - won't.
# Normalization ~
To ensure that visit index contains mostly relevant data, it gets normalized:
automatically inside |MiniVisits.write_index()| or
via |MiniVisits.normalize_index()|.
What normalization actually does can be configured in `config.store.normalize`.
See |MiniVisits.gen_normalize.default()| for default normalization approach.
------------------------------------------------------------------------------
*MiniVisits-examples*
This module provides a flexible framework for working with file system visits.
Exact choice of how to organize workflow is left to the user.
Here are some examples for inspiration which can be combined together.
# Use different sorting ~
Default sorting in |MiniVisits.gen_sort.default()| allows flexible adjustment
of which feature to prefer more: recency or frequency. Here is an example of
how to make set of keymaps for three types of sorting combined with two types
of scopes (all visits and only for current cwd): >lua
local make_select_path = function(select_global, recency_weight)
local visits = require('mini.visits')
local sort = visits.gen_sort.default({ recency_weight = recency_weight })
local select_opts = { sort = sort }
return function()
local cwd = select_global and '' or vim.fn.getcwd()
visits.select_path(cwd, select_opts)
end
end
local map = function(lhs, desc, ...)
vim.keymap.set('n', lhs, make_select_path(...), { desc = desc })
end
-- Adjust LHS and description to your liking
map('<Leader>vr', 'Select recent (all)', true, 1)
map('<Leader>vR', 'Select recent (cwd)', false, 1)
map('<Leader>vy', 'Select frecent (all)', true, 0.5)
map('<Leader>vY', 'Select frecent (cwd)', false, 0.5)
map('<Leader>vf', 'Select frequent (all)', true, 0)
map('<Leader>vF', 'Select frequent (cwd)', false, 0)
<
Note: If using |mini.pick|, consider |MiniExtra.pickers.visit_paths()|.
# Use manual labels ~
Labels is a powerful tool to create groups of associated paths.
Usual workflow consists of:
- Add label with |MiniVisits.add_label()| (prompts for actual label).
- Remove label with |MiniVisits.remove_label()| (prompts for actual label).
- When need to use labeled groups, call |MiniVisits.select_label()| which
will then call |MiniVisits.select_path()| to select path among those
having selected label.
Note: If using |mini.pick|, consider |MiniExtra.pickers.visit_labels()|.
To make this workflow smoother, here is an example of keymaps: >lua
local map_vis = function(keys, call, desc)
local rhs = '<Cmd>lua MiniVisits.' .. call .. '<CR>'
vim.keymap.set('n', '<Leader>' .. keys, rhs, { desc = desc })
end
map_vis('vv', 'add_label()', 'Add label')
map_vis('vV', 'remove_label()', 'Remove label')
map_vis('vl', 'select_label("", "")', 'Select label (all)')
map_vis('vL', 'select_label()', 'Select label (cwd)')
<
# Use fixed labels ~
During work on every project there is usually a handful of files where core
activity is concentrated. This can be made easier by creating mappings
which add/remove special fixed label (for example, "core") and select paths
with that label for both all and current cwd. Example: >lua
-- Create and select
local map_vis = function(keys, call, desc)
local rhs = '<Cmd>lua MiniVisits.' .. call .. '<CR>'
vim.keymap.set('n', '<Leader>' .. keys, rhs, { desc = desc })
end
map_vis('vv', 'add_label("core")', 'Add to core')
map_vis('vV', 'remove_label("core")', 'Remove from core')
map_vis('vc', 'select_path("", { filter = "core" })', 'Select core (all)')
map_vis('vC', 'select_path(nil, { filter = "core" })', 'Select core (cwd)')
-- Iterate based on recency
local sort_latest = MiniVisits.gen_sort.default({ recency_weight = 1 })
local map_iterate_core = function(lhs, direction, desc)
local opts = { filter = 'core', sort = sort_latest, wrap = true }
local rhs = function()
MiniVisits.iterate_paths(direction, vim.fn.getcwd(), opts)
end
vim.keymap.set('n', lhs, rhs, { desc = desc })
end
map_iterate_core('[{', 'last', 'Core label (earliest)')
map_iterate_core('[[', 'forward', 'Core label (earlier)')
map_iterate_core(']]', 'backward', 'Core label (later)')
map_iterate_core(']}', 'first', 'Core label (latest)')
<
# Use automated labels ~
When using version control system (such as Git), usually there is already
an identifier that groups files you are working with - branch name.
Here is an example of keymaps to add/remove label equal to branch name: >lua
local map_branch = function(keys, action, desc)
local rhs = function()
local branch = vim.fn.system('git rev-parse --abbrev-ref HEAD')
if vim.v.shell_error ~= 0 then return nil end
branch = vim.trim(branch)
require('mini.visits')[action](branch)
end
vim.keymap.set('n', '<Leader>' .. keys, rhs, { desc = desc })
end
map_branch('vb', 'add_label', 'Add branch label')
map_branch('vB', 'remove_label', 'Remove branch label')
<
------------------------------------------------------------------------------
*MiniVisits.setup()*
`MiniVisits.setup`({config})
Module setup
Parameters ~
{config} `(table|nil)` Module config table. See |MiniVisits.config|.
Usage ~
>lua
require('mini.visits').setup() -- use default config
-- OR
require('mini.visits').setup({}) -- replace {} with your config table
<
------------------------------------------------------------------------------
*MiniVisits.config*
`MiniVisits.config`
Defaults ~
>lua
MiniVisits.config = {
-- How visit index is converted to list of paths
list = {
-- Predicate for which paths to include (all by default)
filter = nil,
-- Sort paths based on the visit data (robust frecency by default)
sort = nil,
},
-- Whether to disable showing non-error feedback
silent = false,
-- How visit index is stored
store = {
-- Whether to write all visits before Neovim is closed
autowrite = true,
-- Function to ensure that written index is relevant
normalize = nil,
-- Path to store visit index
path = vim.fn.stdpath('data') .. '/mini-visits-index',
},
-- How visit tracking is done
track = {
-- Start visit register timer at this event
-- Supply empty string (`''`) to not do this automatically
event = 'BufEnter',
-- Debounce delay after event to register a visit
delay = 1000,
},
}
<
# List ~
*MiniVisits.config.list*
`config.list` defines how visit index is converted to a path list by default.
`list.filter` is a callable which should take a path data and return `true` if
this path should be present in the list.
Default: output of |MiniVisits.gen_filter.default()|.
Path data is a table with at least these fields:
- <path> `(string)` - absolute path of visit.
- <count> `(number)` - number of visits.
- <latest> `(number)` - timestamp of latest visit.
- <labels> `(table|nil)` - table of labels (has string keys with `true` values).
Notes:
- Both `count` and `latest` (in theory) can be any number. But built-in tracking
results into positive integer `count` and `latest` coming from |os.time()|.
- There can be other entries if they are set by user as index entry.
`list.sort` is a callable which should take an array of path data and return
a sorted array of path data (or at least tables each containing <path> field).
Default: output of |MiniVisits.gen_sort.default()|.
Single path data entry is a table with a same structure as for `list.filter`.
Note, that `list.sort` can be used both to filter, sort, or even return paths
unrelated to the input.
# Silent ~
`config.silent` is a boolean controlling whether to show non-error feedback
(like adding/removing labels, etc.). Default: `false`.
# Store ~
`config.store` defines how visit index is stored on disk to enable persistent
data across several sessions.
`store.autowrite` is a boolean controlling whether to write visit data to
disk on |VimLeavePre| event. Default: `true`.
`store.normalize` is a callable which should take visit index
(see |MiniVisits-index-specification|) as input and return "normalized" visit
index as output. This is used to ensure that visit index is up to date and
contains only relevant data. For example, it controls how old and
irrelevant visits are "forgotten", and more.
Default: output of |MiniVisits.gen_normalize.default()|.
`store.path` is a path to which visit index is written. See "Storage" section
of |MiniVisits-index-specification| for more details.
Note: set to empty string to disable any writing with not explicitly set
path (including the one on |VimLeavePre|).
Default: "mini-visits-index" file inside |$XDG_DATA_HOME|.
# Track ~
`config.track` defines how visits are tracked (index entry is autoupdated).
See "Tracking visits" section in |MiniVisits-overview| for more details.
`track.event` is a proper Neovim |{event}| on which track get triggered.
Note: set to empty string to disable automated tracking.
Default: |BufEnter|.
`track.delay` is a delay in milliseconds after event is triggered and visit
is autoregistered.
Default: 1000 (to allow navigation between buffers without tracking
intermediate ones).
------------------------------------------------------------------------------
*MiniVisits.register_visit()*
`MiniVisits.register_visit`({path}, {cwd})
Register visit
Steps:
- Ensure that there is an entry for path-cwd pair.
- Add 1 to visit `count`.
- Set `latest` visit time to equal current time.
Parameters ~
{path} `(string|nil)` Visit path. Default: path of current buffer if normal,
error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Default: |current-directory|.
------------------------------------------------------------------------------
*MiniVisits.add_path()*
`MiniVisits.add_path`({path}, {cwd})
Add path to index
Ensures that there is a (one or more) entry for path-cwd pair. If entry is
already present, does nothing. If not - creates it with both `count` and
`latest` set to 0.
Parameters ~
{path} `(string|nil)` Visit path. Can be empty string to mean "all visited
paths for `cwd`". Default: path of current buffer if normal, error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
------------------------------------------------------------------------------
*MiniVisits.add_label()*
`MiniVisits.add_label`({label}, {path}, {cwd})
Add label to path
Steps:
- Ensure that there is an entry for path-cwd pair.
- Add label to the entry.
Parameters ~
{label} `(string|nil)` Label string. Default: `nil` to ask from user.
{path} `(string|nil)` Visit path. Can be empty string to mean "all visited
paths for `cwd`". Default: path of current buffer if normal, error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
------------------------------------------------------------------------------
*MiniVisits.remove_path()*
`MiniVisits.remove_path`({path}, {cwd})
Remove path
Deletes a (one or more) entry for path-cwd pair from an index. If entry is
already absent, does nothing.
Notes:
- Affects only in-session Lua variable. Call |MiniVisits.write_index()| to
make it persistent.
Parameters ~
{path} `(string|nil)` Visit path. Can be empty string to mean "all visited
paths for `cwd`". Default: path of current buffer if normal, error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
------------------------------------------------------------------------------
*MiniVisits.remove_label()*
`MiniVisits.remove_label`({label}, {path}, {cwd})
Remove label from path
Steps:
- Remove label from (one or more) index entry.
- If it was last label in an entry, remove `labels` key.
Parameters ~
{label} `(string|nil)` Label string. Default: `nil` to ask from user.
{path} `(string|nil)` Visit path. Can be empty string to mean "all visited
paths for `cwd`". Default: path of current buffer if normal, error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
------------------------------------------------------------------------------
*MiniVisits.list_paths()*
`MiniVisits.list_paths`({cwd}, {opts})
List visit paths
Convert visit index for certain cwd into an ordered list of visited paths.
Supports custom filtering and sorting.
Examples: >lua
-- Get paths sorted from most to least recent
local sort_recent = MiniVisits.gen_sort.default({ recency_weight = 1 })
MiniVisits.list_paths(nil, { sort = sort_recent })
-- Get paths from all cwd sorted from most to least frequent
local sort_frequent = MiniVisits.gen_sort.default({ recency_weight = 0 })
MiniVisits.list_paths('', { sort = sort_frequent })
-- Get paths not including hidden
local is_not_hidden = function(path_data)
return not vim.startswith(vim.fn.fnamemodify(path_data.path, ':t'), '.')
end
MiniVisits.list_paths(nil, { filter = is_not_hidden })
<
Parameters ~
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
{opts} `(table|nil)` Options. Possible fields:
- <filter> `(function)` - predicate to filter paths. For more information
about how it is used, see |MiniVisits.config.list|.
Default: value of `config.list.filter` with |MiniVisits.gen_filter.default()|
as its default.
- <sort> `(function)` - path data sorter. For more information about how
it is used, see |MiniVisits.config.list|.
Default: value of `config.list.sort` or |MiniVisits.gen_sort.default()|
as its default.
Return ~
`(table)` Array of visited paths.
------------------------------------------------------------------------------
*MiniVisits.list_labels()*
`MiniVisits.list_labels`({path}, {cwd}, {opts})
List visit labels
Convert visit index for certain path-cwd pair into an ordered list of labels.
Supports custom filtering for paths. Result is ordered from most to least
frequent label.
Examples: >lua
-- Get labels for current path-cwd pair
MiniVisits.list_labels()
-- Get labels for current path across all cwd
MiniVisits.list_labels(nil, '')
-- Get all available labels excluding ones from hidden files
local is_not_hidden = function(path_data)
return not vim.startswith(vim.fn.fnamemodify(path_data.path, ':t'), '.')
end
MiniVisits.list_labels('', '', { filter = is_not_hidden })
<
Parameters ~
{path} `(string|nil)` Visit path. Can be empty string to mean "all visited
paths for `cwd`". Default: path of current buffer if normal, error otherwise.
{cwd} `(string|nil)` Visit cwd (project directory). Can be empty string to mean
"all visited cwd". Default: |current-directory|.
{opts} `(table|nil)` Options. Possible fields:
- <filter> `(function)` - predicate to filter paths. For more information
about how it is used, see |MiniVisits.config.list|.
Default: value of `config.list.filter` with |MiniVisits.gen_filter.default()|
as its default.
- <sort> `(function)` - path data sorter. For more information about how
it is used, see |MiniVisits.config.list|.
Default: value of `config.list.sort` or |MiniVisits.gen_sort.default()|
as its default.
Return ~
`(table)` Array of available labels.
------------------------------------------------------------------------------
*MiniVisits.select_path()*
`MiniVisits.select_path`({cwd}, {opts})
Select visit path
Uses |vim.ui.select()| with an output of |MiniVisits.list_paths()| and
calls |:edit| on the chosen item.
Note: if you have |mini.pick|, consider using |MiniExtra.pickers.visit_labels()|
and |MiniExtra.pickers.visit_paths()|.
Examples:
- Select from all visited paths: `MiniVisits.select_path('')`
- Select from paths under current directory sorted from most to least recent: >lua
local sort_recent = MiniVisits.gen_sort.default({ recency_weight = 1 })
MiniVisits.select_path(nil, { sort = sort_recent })
<
Parameters ~
{cwd} `(string|nil)` Forwarded to |MiniVisits.list_paths()|.
{opts} `(table|nil)` Forwarded to |MiniVisits.list_paths()|.
------------------------------------------------------------------------------
*MiniVisits.select_label()*
`MiniVisits.select_label`({path}, {cwd}, {opts})
Select visit label
Uses |vim.ui.select()| with an output of |MiniVisits.list_labels()| and
calls |MiniVisits.select_path()| to get target paths with selected label.
Note: if you have |mini.pick|, consider using |MiniExtra.pickers.visit_labels()|.
Examples:
- Select from labels of current path: `MiniVisits.select_label()`
- Select from all visited labels: `MiniVisits.select_label('', '')`
- Select from current project labels and sort paths (after choosing) from most
to least recent: >lua
local sort_recent = MiniVisits.gen_sort.default({ recency_weight = 1 })
MiniVisits.select_label('', nil, { sort = sort_recent })
<
Parameters ~
{path} `(string|nil)` Forwarded to |MiniVisits.list_labels()|.
{cwd} `(string|nil)` Forwarded to |MiniVisits.list_labels()|.
{opts} `(table|nil)` Forwarded to both |MiniVisits.list_labels()|
and |MiniVisits.select_path()| (after choosing a label).
------------------------------------------------------------------------------
*MiniVisits.iterate_paths()*
`MiniVisits.iterate_paths`({direction}, {cwd}, {opts})
Iterate visit paths
Steps:
- Compute a sorted array of target paths using |MiniVisits.list_paths()|.
- Identify the current index inside the array based on path of current buffer.
- Iterate through the array certain amount of times in a dedicated direction:
- For "first" direction - forward starting from index 0 (so that single
first iteration leads to first path).
- For "backward" direction - backward starting from current index.
- For "forward" direction - forward starting from current index.
- For "last" direction - backward starting from index after the last one
(so that single first iteration leads to the last path).
Notes:
- Mostly designed to be used as a mapping. See `MiniVisits-examples`.
- If path from current buffer is not in the output of `MiniVisits.list_paths()`,
starting index is inferred such that first iteration lands on first item
(if iterating forward) or last item (if iterating backward).
- Navigation with this function is not tracked (see |MiniVisits-overview|).
This is done to allow consecutive application without affecting
underlying list of paths.
Examples assuming underlying array of files `{ "file1", "file2", "file3" }`:
- `MiniVisits("first")` results into focusing on "file1".
- `MiniVisits("backward", { n_times = 2 })` from "file3" results into "file1".
- `MiniVisits("forward", { n_times = 10 })` from "file1" results into "file3".
- `MiniVisits("last", { n_times = 4, wrap = true })` results into "file3".
Parameters ~
{direction} `(string)` One of "first", "backward", "forward", "last".
{cwd} `(string|nil)` Forwarded to |MiniVisits.list_paths()|.
{opts} `(table|nil)` Options. Possible fields:
- <filter> `(function)` - forwarded to |MiniVisits.list_paths()|.
- <sort> `(function)` - forwarded to |MiniVisits.list_paths()|.
- <n_times> `(number)` - number of steps to go in certain direction.
Default: |v:count1|.
- <wrap> `(boolean)` - whether to wrap around list edges. Default: `false`.
------------------------------------------------------------------------------
*MiniVisits.get_index()*
`MiniVisits.get_index`()
Get active visit index
Return ~
`(table)` Copy of currently active visit index table.
------------------------------------------------------------------------------
*MiniVisits.set_index()*
`MiniVisits.set_index`({index})
Set active visit index
Parameters ~
{index} `(table)` Visit index table.
------------------------------------------------------------------------------
*MiniVisits.reset_index()*
`MiniVisits.reset_index`()
Reset active visit index
Set currently active visit index to the output of |MiniVisits.read_index()|.
Does nothing if reading the index failed.
------------------------------------------------------------------------------
*MiniVisits.normalize_index()*
`MiniVisits.normalize_index`({index})
Normalize visit index
Applies `config.store.normalize` (|MiniVisits.gen_normalize.default()| by default)
to the input index object and returns the output (if it fits in the definition
of index object; see |MiniVisits-index-specification|).
Parameters ~
{index} `(table|nil)` Index object. Default: copy of the current index.
Return ~
`(table)` Normalized index object.
------------------------------------------------------------------------------
*MiniVisits.read_index()*
`MiniVisits.read_index`({store_path})
Read visit index from disk
Parameters ~
{store_path} `(string|nil)` Path on the disk containing visit index data.
Default: `config.store.path`.
Notes:
- Can return `nil` if path is empty string or file is not readable.
- File is sourced with |dofile()| as a regular Lua file.
Return ~
`(table|nil)` Output of the file source.
------------------------------------------------------------------------------
*MiniVisits.write_index()*
`MiniVisits.write_index`({store_path}, {index})
Write visit index to disk
Steps:
- Normalize index with |MiniVisits.normalize_index()|.
- Ensure path is valid (all parent directories are created, etc.).
- Write index object to the path so that it is readable
with |MiniVisits.read_index()|.
Parameters ~
{store_path} `(string|nil)` Path on the disk where to write visit index data.
Default: `config.store.path`. Note: if empty string, nothing is written.
{index} `(table|nil)` Index object to write to disk.
Default: current session index.
------------------------------------------------------------------------------
*MiniVisits.rename_in_index()*
`MiniVisits.rename_in_index`({path_from}, {path_to}, {index})
Rename path in index
A helper to react for a path rename/move in order to preserve its visit data.
It works both for file and directory paths.
Notes:
- It does not update current index, but returns a modified index object.
Use |MiniVisits.set_index()| to make it current.
- Use only full paths.
- Do not append `/` to directory paths. Use same format as for files.
Assuming `path_from` and `path_to` are variables containing full paths
before and after rename/move, here is an example to update current index: >lua
local new_index = MiniVisits.rename_in_index(path_from, path_to)
MiniVisits.set_index(new_index)
<
Parameters ~
{path_from} `(string)` Full path to be renamed.
{path_to} `(string)` Full path to be replaced with.
{index} `(table|nil)` Index object inside which to perform renaming.
Default: current session index.
Return ~
`(table)` Index object with renamed path.
------------------------------------------------------------------------------
*MiniVisits.gen_filter*
`MiniVisits.gen_filter`
Generate filter function
This is a table with function elements. Call to actually get specification.
------------------------------------------------------------------------------
*MiniVisits.gen_filter.default()*
`MiniVisits.gen_filter.default`()
Default filter
Always returns `true` resulting in no actual filter.
Return ~
`(function)` Visit filter function. See |MiniVisits.config.list| for more details.
------------------------------------------------------------------------------
*MiniVisits.gen_filter.this_session()*
`MiniVisits.gen_filter.this_session`()
Filter visits from current session
Return ~
`(function)` Visit filter function. See |MiniVisits.config.list| for more details.
------------------------------------------------------------------------------
*MiniVisits.gen_sort*
`MiniVisits.gen_sort`
Generate sort function
This is a table with function elements. Call to actually get specification.
------------------------------------------------------------------------------
*MiniVisits.gen_sort.default()*
`MiniVisits.gen_sort.default`({opts})
Default sort
Sort paths using "robust frecency" approach. It relies on the rank operation:
based on certain reference number for every item, assign it a number
between 1 (best) and number of items (worst). Ties are dealt with "average
rank" approach: each element with a same reference number is assigned
an average rank among such elements. This way total rank sum depends only
on number of paths.
Here is an algorithm outline:
- Rank paths based on frequency (`count` value): from most to least frequent.
- Rank paths based on recency (`latest` value): from most to least recent.
- Combine ranks from previous steps with weights:
`score = (1 - w) * rank_frequency + w * rank_recency`, where `w` is
"recency weight". The smaller this weight the less recency affects outcome.
Examples:
- Default recency weight 0.5 results into "robust frecency" sorting: it
combines both frequency and recency.
This is called a "robust frecency" because actual values don't have direct
effect on the outcome, only ordering matters. For example, if there is
a very frequent file with `count = 100` while all others have `count = 5`,
it will not massively dominate the outcome as long as it is not very recent.
- Having recency weight 1 results into "from most to least recent" sorting.
- Having recency weight 0 results into "from most to least frequent" sorting.
Parameters ~
{opts} `(table|nil)` Option. Possible fields:
- <recency_weight> `(number)` - a number between 0 and 1 for recency weight.
Default: 0.5.
Return ~
`(function)` Visit sort function. See |MiniVisits.config.list| for more details.
------------------------------------------------------------------------------
*MiniVisits.gen_sort.z()*
`MiniVisits.gen_sort.z`()
Z sort
Sort as in https://github.com/rupa/z.
Return ~
`(function)` Visit sort function. See |MiniVisits.config.list| for more details.
------------------------------------------------------------------------------
*MiniVisits.gen_normalize*
`MiniVisits.gen_normalize`
Generate normalize function
This is a table with function elements. Call to actually get specification.
------------------------------------------------------------------------------
*MiniVisits.gen_normalize.default()*
`MiniVisits.gen_normalize.default`({opts})
Generate default normalize function
Steps:
- Prune visits, i.e. remove outdated visits:
- If `count` number of visits is below prune threshold, remove that visit
entry from particular cwd (it can still be present in others).
- If either first (cwd) or second (path) level key doesn't represent an
actual path on disk, remove the whole associated value.
- NOTE: if visit has any label, it is not automatically pruned.
- Decay visits, i.e. possibly make visits more outdated. This is an important
part to the whole usability: together with pruning it results into automated
removing of paths which were visited long ago and are not relevant.
Decay is done per cwd if its total `count` values sum exceeds decay threshold.
It is performed through multiplying each `count` by same coefficient so that
the new total sum of `count` is equal to some smaller target value.
Note: only two decimal places are preserved, so the sum might not be exact.
- Prune once more to ensure that there are no outdated paths after decay.
Parameters ~
{opts} `(table|nil)` Options. Possible fields:
- <decay_threshold> `(number)` - decay threshold. Default: 1000.
- <decay_target> `(number)` - decay target. Default: 800.
- <prune_threshold> `(number)` - prune threshold. Default: 0.5.
- <prune_paths> `(boolean)` - whether to prune outdated paths. Default: `true`.
Return ~
`(function)` Visit index normalize function. See "Store" in |MiniVisits.config|.
vim:tw=78:ts=8:noet:ft=help:norl: