aurum / doc / aurum.txt

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
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
*aurum.txt* Plugin for dealing with source files under various VCS control
==============================================================================
CONTENTS                                                      *aurum-contents*
    1. Intro                                         |aurum-intro|
    2. Functionality provided                        |aurum-functionality|
        2.1. Commands                                |aurum-commands|
        2.2. Functions                               |aurum-functions|
        2.3. aurum:// pseudo-protocol                |aurum://|
        2.4. Global mappings                         |aurum-mappings|
    4. Options                                       |aurum-options|
    5. Globs                                         |aurum-globs|
    6. Log templates                                 |aurum-logtemplates|
        6.1. Built-in template styles                |aurum-logstyles|
    7. Record mode                                   |aurum-record|
    8. Internal objects                              |aurum-objects|
        8.1. Repository                              |aurum-repository|
        8.2. Changeset                               |aurum-changeset|
    9. Creating your own driver                      |aurum-new-driver|
    10. Notes about various driver implementations   |aurum-driver-notes|
        10.1. Mercurial                              |aurum-driver-Mercurial|
        10.2. Git                                    |aurum-driver-Git|
        10.3. Subversion                             |aurum-driver-Subversion|
    11. Changelog                                    |aurum-changelog|

==============================================================================
1. Intro                                                         *aurum-intro*

This plugin provides a vim <--> VCS (currently mercurial, git and subversion) 
integration for your projects. Features:
  - Partially committing changes (|:AuRecord|).
  - Viewing file state at particular revision (|aurum://file|, |:AuFile|).
  - Viewing uncommited changes in a |vimdiff|, as well as changes between 
    specific revisions (|:AuVimDiff|). It is also possible to open multiple 
    tabs with all changes to all files viewed as side-by-side diffs.
  - Viewing revisions log (|:AuLog|). Output is highly customizable.
  - Viewing working directory status (|:AuStatus|).
  - Commiting changes (|:AuCommit|), commit messages are remembered in case of 
    rollback (|g:aurum_remembermsg|).
  - Obtaining various URL’s out of remote repository URL (like URL of the HTML 
    version of the current file with URL fragment pointing to the current line 
    attached: useful for sharing) (|:AuHyperlink|). For mercurial it also 
    supports git and subversion revisions (in case you are using hg-git and 
    hgsubversion respectively).
  - |aurum#changeset()|, |aurum#repository()| and |aurum#status()| functions 
    that are to be used from modeline.
  - Frontends for various other VCS commands.
Most commands can be reached with a set of mappings (see |aurum-mappings|), 
all mappings are customizable.

Plugin’s mercurial driver is able to use mercurial python API as well as its 
CLI, but remember that the former is much slower and less tested. In order to 
use mercurial python API you must have vim compiled with |+python| (mercurial 
currently does not support python 3) and have mercurial in python’s sys.path 
(note: on windows msi installer is not adding mercurial to sys.path, so you 
won’t be able to use its python API).

Plugin requires some additional plugins:
  - frawor (https://bitbucket.org/ZyX_I/frawor)
(with their dependencies).

Note: aurum supports VAM (https://github.com/MarcWeber/vim-addon-manager). It 
      is prefered that you use it for aurum installation.

==============================================================================
2. Functionality provided                                *aurum-functionality*

------------------------------------------------------------------------------
2.1. Commands                                                 *aurum-commands*

There are some common things for all commands:
1. All commands are constructed using |FWC| and thus you can truncate all 
   keyword options (but only if truncated version is unambigious).
2. If some command accepts file or glob argument it is likely to be able to 
   get repository location from it, thus “repo” option is not needed (or is 
   even ignored). This also applies to options like “file”/“files”.
3. Commands accepting filenames or globs also accept “:” meaning “current 
   file”.                      *aurum-current-revision* *aurum-current-file*
4. “current file” and “current revision” are determined in the following 
   fashion:
   1. |aurum://file|:{repo}:{rev}:{file} buffers: current revision is {rev} 
      and current file is {file}.
   2. |aurum://status|: current file is file under cursor and current revision 
      is first status revision.
   3. |aurum://diff| buffers: current file is one of the files which section 
      is located under the cursor and current revision is either second or 
      first diffed revision.
   4. |aurum://annotate| buffers: current file is file under cursor (annotate 
      may follow renames/copies; target filename is not explicitely mentioned) 
      and current revision is revision under cursor.
   5. For other buffers: current file is file name, current revision is 
      working directory revision.

AuAnnotate [file {file}] [rev {rev}] [repo {repo}]               *:AuAnnotate*
    Annotate rev {rev} of a file {file}. By default annotates current revision 
    of a current file (|aurum-current-file|).

AuBranch[!] {branch} [repo {repo}]                                 *:AuBranch*
    Set current branch name to {branch}. Bang forces creating of the branch 
    even if it currently exists.

AuCommit {options} [glob1 [glob2 [...]]]                           *:AuCommit*
    Commit files matching given globs (current file if no globs were given). 
    If “message” option was not specified, opens |aurum://commit| buffer. You 
    can specify string “all” instead of the globs, in this case changes to all 
    tracked files will be commited (equivalent to running “!hg commit”).
    Possible options:
    Option  Description ~
    type    Either one of modified/added/removed/deleted/unknown or string 
            containing capitalized first letters of mentined status names 
            (additionally “?” for unknown and “!” for deleted). May be 
            specified more then once. Determines what files should be matched 
            against given globs: “AuCommit **” is equivalent to “AuCommit 
            all”, but “AuCommit type MARDU **” will also add untracked and 
            remove missing files (like “hg commit -A”). Does not affect 
            “:AuCommit all” and “:AuCommit”, latter will always add current 
            file if it was untracked.
    message Commit message.
    user    Committer.
    date    Commit date in form yy-mm-dd_HH:MM:SS. Both date and time parts 
            are optional (though you must specify one of them), you can omit 
            year or use full four-digit form. Seconds are also optional.
    [no]closebranch
            Flag. See description of --close-branch in “hg help commit”.
    repo    Path. Repository that should be committed to.

AuDiff {options} {diffoptions} [glob1 [...]]                         *:AuDiff*
    View differences between revisions specified in options (default: between 
    working directory state and working directory revision).
    Possible options:
    Option  Description ~
    rev1    First revision. If it is the only revision set, then AuDiff will 
            show changes made by given revision.
    rev2    Second revision. If it is the only revision set, then AuDiff will 
            show changes between working directory and given revision.
            If both revisions are given then it will compare first revision 
            against second one.
    changes Overrides rev1 and rev2. Acts just like if “rev1” is set and 
            “rev2” is not.
    cmd     Command used to open |aurum://diff| buffer.
            Default: “silent edit”.
    repo    Path. Repository where diff should be run.
                                                           *aurum-diffoptions*
    Diffoption    Description ~
    numlines      Unsigned integer. Number of context lines that should be 
                  shown.
    [no]reverse   Flag. Determines whether reversed patch should be generated.
    [no]ignorews  Flag. Determines whether whitespace characters should be 
                  ignored when comparing lines.
    [no]iwsamount Flag. Determines whether changes in amount of whitespace 
                  characters should be ignored.
    [no]iblanks   Flag. Determines whether changes consisting only of blank 
                  lines should be ignored.
    [no]showfunc  Flag. Determines whether it should be shown in which 
                  function changes were made.
    [no]alltext   Flag. Determines whether all files should be treated as text 
                  files.
    [no]dates     Flag. Determines whether dates should be shown in headers.
    [no]git       Flag. Determines whether extended git format should be used.

AuFile [{rev} [{file}]] [[no]replace] [cmd {cmd}] [repo {repo}]      *:AuFile*
    View file as it was at given revision. If “replace” option is given, then 
    current buffer contents will be replaced instead of opening new 
    |aurum://file| buffer. “cmd” option determines which command will be used 
    to open aurum://file buffer (default: “silent edit”) (may be overriden by 
    “replace” option).

AuGrep {pattern} {opts}                                              *:AuGrep*
    Populates |quickfix| list with the results of searching repository for 
    given {pattern} ({pattern} syntax is determined by used VCS). If any globs 
    are given, then only files matching these globs are searched.
    Possible options:
    Option         Description ~
    [no]ignorecase Flag. Determines whether case should be ignored.
    revrange       Accepts two revisions as arguments. Adds revisions between 
                   given ones to the list of revisions that should be searched 
                   for. May be specified more then once.
    revision       Accepts one revision. Adds it to the list of revisions that 
                   should be searched for. May be specified more then once.
    files          Glob. Determines which files should be searched. May be 
                   specified more then once.
    repo           Path. Repository that should be searched.
    [no]wdfiles    Flag. Determines whether :AuGrep should output files in 
                   working directory if they have not changed since found 
                   revision. Overrides |g:aurum_workdirfiles|.
    [no]workmatch  Flag. When processing “files” option if this flag is true 
                   (default) it will grep only files present in working 
                   directory changeset. If this flag is false, :AuGrep will 
                   process all changesets in order to find out files matching 
                   pattern(s) given in “files” option.

AuHyperlink {opts}                                              *:AuHyperlink*
    Constructs a URL and puts it into system clipboard (see |quote+|).
    Possible options:
    Option    Description ~
    rev       Revision that is to be refered. Defaults:
                  URL types                   Default ~
                  html,raw,annotate,filehist  |aurum-current-revision|
                  bundle,changeset            working directory revision
                  log                         same as above, but mainly ignored
                  clone,push                  not applicable (not used)
              Note: Depending on specific repository this argument may be 
                    unsupported (mostly hgsubversion repositories), supported 
                    only partly (mostly hg-git repositories: supported only if 
                    revision in question has first bookmark mapping to git 
                    branch) or under specific conditions (kenai.com requires 
                    revision numbers matching in your and remote repository).
    file      File that is to be refered (url=html,raw,annotate,filehist).
              Default: see |aurum-current-file|.
    url       URL type. Accepted types (default: html):         *aurum-ho-url*
                  Type      Description ~
                  html      URL of the file, HTML formatted
                  raw       URL of the file, raw bundle
                  annotate  URL of the file, annotated
                  filehist  URL of the file history
                  bundle    URL of the repository snapshot
                  changeset URL of the changeset (usually, diff)
                  log       URL of the commit log
                  clone     URL of the repository, read-only
                  push      URL of the repository, read-write
    line      Determines whether URL fragment refering to given line should be 
              added to the URL. Only for url=file and url=annotate.
              Default: not added. If given line is 0 then current line number 
              will be used unless “rev” or “file” options are given or refered 
              file is not the current one.
    cmd       Command that is used to copy url to register.
              Default: "let @+=%s". Do not forget to escape spaces.
              Value of this option is used in this fashion: >
                execute printf(cmd, string(URL))
<   repo      Path. Repository that should be used.

    Note: you can extend list of supported remote repositories by using 
          |g:aurum_hypsites| option.

AuJunk [forget] [ignore] [remove] [ignoreglobs] glob1 [...]          *:AuJunk*
    Forget, ignore or remove (default: remove) files matching given globs 
    (specify “:” to act on current file). With “ignoreglobs” it will ignore 
    not matching files, but given globs. Unlike other commands you must 
    specify at least one glob (or “:”) here, without this it will fail.
    Note: It won’t touch untracked files unless “ignore” option was specified.

AuLog [{repo}] {options} {diffoptions}                                *:AuLog*
    Open buffer with changeset log. For {diffoptions} see |aurum-diffoptions|.
    Possible options:
    Option      Description ~
    files       Glob. If present, only revisions where file matching glob was 
                modified are shown. It also tracks renames and copies of 
                a file. May be specified more then once.
                Note: This option also affects files shown when “stat”, 
                      “patch”, “showfiles”, “showrenames” and “showcopies” 
                      options are specified (unless |aurum-lo-ignfiles| is 
                      also present).
    date        String of a form y-m-d_H:M where all components except first 
                are optional. Each of y, m, d, H, M may be either a number, 
                a dot (meaning put current value here) and a star (meaning 
                “any”). “y” is either a four- or two-digit year. If present, 
                selects revisions that match given date. You can also use 
                “>={date}”, “<={date}” and “{date1}<=>{date2}” (“=” may be 
                omitted).
    search      Regex. If present, selects revisions where description matches 
                given regular expression.
    user        Regex. If present, selects revisions where user matches given 
                regular expression.
    branch      String. If present, selects revisions with given branch name.
    limit       Number (1 to inf). Shows at most {limit} revisions, starting 
                from the tip.
    revision    Revision. Shows only specified revision.
    revrange    Two revisions. Shows revisions that are between specified 
                ones.
    [no]merges  Flag. “merges” selects revisions with more then one parent, 
                “nomerges” selects revisions that have one or no parents.
    style       String. Specifies template name, see |aurum-logstyles|.
    template    Variable name. Specifies variable from which template should 
                be loaded.
                                                           *aurum-lo-ignfiles*
    ignfiles    One of “patch”, “renames”, “copies”, “files”, “diff”, 
                “mappings”. May be specified more then once. Overrides 
                |g:aurum_ignorefiles|. Determines when “files” option will be 
                ignored:
                  Value    Description ~
                  patch    “patch” and “stat” will always show full changeset 
                           patch or statistics.
                  renames  “showrenames” will always show all renamed files.
                  copies   “showcopies” will always show all copied files.
                  files    “showfiles” will always show all changed files.
                  diff     AuLog Fdiff and RFdiff mappings will show changes 
                           done to all changed files.
                  open     AuLog Diff, Rdiff, Vdiff, RVdiff, File, Open and 
                           Annotate mappings will show all changed files in 
                           file selection dialog.
    cmd         Command. Determines which command should be used to open log.
                Default: “silent new”.
    [no]stat    Flag. Determines whether summary of changes should be shown.
    [no]patch   Flag. Determines whether revision patch should be shown.
    [no]showfiles
                Flag. Determines whether list of files changed in given 
                revision should be shown.
    [no]showcopies
                Flag. Determines whether copies should be shown.
    [no]showrenames
                Flag. Determines whether renames should be shown.
    [no]procinput
                Flag. Overrides |g:aurum_procinput|: determines whether user 
                input will be processed while generating log.
                Note If enabled, acts like g:aurum_procinput=2.

                                                                     *:AuMove*
AuMove [copy] [rightrepl] [leftpattern] [pretend] [repo {repo}] [args ...]
    Move (with “copy” option: copy) files. Depending on number and type of 
    arguments it can be one of the following:
    - No arguments: move current file to current directory.
    - One argument that is a name of existing directory: move current file to 
      given directory.
    - At least two arguments with “rightrepl” option given: capture parts of 
      filenames matching wildcards and use last argument as the replacement 
      string (see |substitute()|). Example: >
          AuMove rightrepl **.txt \\1.doc
            file.txt     -> file.doc
            dir/file.txt -> dir/file.doc
<   - At least two arguments with “leftpattern” option given: take all 
      arguments except last as a pattern and use the last argument as 
      replacement string (see |substitute()|). Example: >
          AuMove leftpattern \\v^(.*)\\.txt$ \\1.doc
            file.txt     -> file.doc
            dir/file.txt -> dir/file.doc
<     Note that this is the only case when paths are assumed to be relative to 
           repository root. In any other cases they are assumed to be relative 
           to current directory.
    - Two arguments containing at least one star or question mark which both 
      have just the same number of unescaped stars and/or question marks 
      arranged in the same order. In this case it acts like “zmv -W”: parts of 
      filename matching wildcards are captured (note vim allows only up to 
      9 capturing groups), and each wildcard in the right argument is replaced 
      by the match: >
          AuMove **.txt **.doc
            file.txt     -> file.doc
            dir/file.txt -> dir/file.doc
<     Note that “AuMove */*.txt **.doc” won’t work.
    - Two or more arguments with last one that is a name of existing 
      directory: move files matching given patterns (all arguments but the 
      last one) to given directory (last argument).
      You may also specify unexisting directory with trailing forward slash. 
      In this case it will be created.
    - One or more arguments that have not matched any of the above rules: move 
      files matching given patterns (patterns are all arguments) to the 
      current directory.
    If “pretend” option is given :AuMove won’t actually do anything, just 
    print what it will do (relative to repository root, not to current 
    directory).
    Note: you must either be at repository root (see |:cd|) or have all 
          arguments look like “path/to/repository/{meaningfulPart}”.

AuName[!] {name} {opts} [{rev}]                                      *:AuName*
    Name (tag/bookmark/...) revision {rev} (default: working directory 
    revision) as {name}. If bang is given, then force naming even if {name} 
    already exists. Possible options:
    Option      Description ~
    type        String, determines what will be done. Depends on repository 
                object, for mercurial repositories it will be likely “tag” or 
                “bookmark”.
                Default: first item present in |aurum-repo.labeltypes|.
    [no]delete  Flag. If enabled, then {rev} argument will be ignored and 
                tag/bookmark/... will be deleted. Default: disabled.
    [no]local   Flag. If enabled, then name will not be pushed.
                Default: disabled.
    repo        Path. Repository that should be operated upon.

AuOther[!] {action} [{rev}[ {url}[ {repo}]]]                        *:AuOther*
    Push, pull or view what will be pushed or pulled. {rev} determines 
    revision to be pushed/pulled, {url} determines where it should be pushed 
    to/pulled from. If bang is present, then push even to unrelated 
    repositories. Use ":" instead of any optional argument to get the same 
    behavior as if it was not specified.
    Possible actions:
    Action    Description ~
    push      Push
    pull      Pull
    outgoing  View what will be pushed if you replace “outgoing” with “push”
    incoming  View what will be pulled if you replace “incoming” with “pull”

AuRecord {opts} [glob1 [...]]                                      *:AuRecord*
    Start record mode (|aurum-record|). Possible options are just the same as 
    |:AuCommit| has (except for “type” option that is absent).

AuStatus [{repo}] {opts}                                           *:AuStatus*
    Display status of the repository. Possible options:
    Option  Description ~
    files   Glob. If given, only status of files that match given glob will be 
            displayed. May be specified more then once.
    rev     Revision. If given :AuStatus will display status not relative to 
            working revision, but to the given one. If “wdrev” is specified, 
            then it will display status as if {wdrev} was working directory 
            state and current working directory was revision from repository.
    wdrev   Revision. If given :AuStatus will display status as if {wdrev} was 
            working directory state.
    changes Revision. Works like specifying {changes} as “rev” option and its 
            first parent as “wdrev” option. Overrides “rev” and “wdrev” 
            options.
    show    Either one of modified/added/removed/deleted/unknown/ignored/clean 
            or string containing capitalized first letters of mentined status 
            names (additionally “?” for unknown and “!” for deleted). May be 
            specified more then once. Determines files with what statuses 
            should be displayed. Default: modified, added, removed, deleted, 
            unknown. You can also specify “all” instead of statuses, it will 
            act as “show MARDUIC”.
    cmd     Command. Determines which command should be used to open 
            |aurum://status| buffer. Default: “silent botright new”. If 
            specified, |g:aurum_usestatwin| option has no effect and status 
            window also won’t be resized.

AuTrack[!] [glob1 [...]]                                            *:AuTrack*
    Make files matching given globs be tracked by VCS (current file if no 
    globs were given). You can also specify “:” instead of one of the globs to 
    track current file name. Adding “!” is equivalent to passing “--force” to 
    the underlying VCS.
    Note that this command matches files that has unknown and removed status, 
    so it won’t make ignored files tracked.

AuUpdate[!] [{rev} [{repo}]]                                       *:AuUpdate*
    Update working directory state to revision {rev}. With “!” it will ignore 
    uncommited changes (really it is specifying “--force” to the underlying 
    VCS).

AuVimDiff {opts} [rev1 [...]]                                     *:AuVimDiff*
    Opens a vimdiff windows. Possible options:
    Option       Description ~
    file         File to be opened. Default: |aurum-current-file|.
                 Not used when “full” option is enabled.
    files        Pattern, determines files to be opened. Default: all files.
                 Not used when “full” option is disabled.
                 Note: each pattern must contain at least one non-word 
                       character (|/\W|).
    [no]curfile  Determines whether current state of the file should be used.
    [no]usewin   Overrides |g:aurum_usewin|. Determines whether new window 
                 should be opened instead of using existing one. First file 
                 will always be opened in current window unless “full” is 
                 enabled.
    [no]full     If enabled, opens multiple tabs containing all files changed 
                 between selected revisions (revisions and working directory 
                 state if “curfile” is enabled). Overrides “file” option, 
                 makes |g:aurum_usewin| and “usewin” options not applicable.
    [no]onlymodified
                 Determines whether removed and added files should be included 
                 in the full diff (default: not included: option enabled).
    [no]untracked
                 Determines whether untracked (deleted and unknown) files 
                 should be included in the full diff (default: no) in addition 
                 to tracked ones.
                 Disables “onlymodified” option.
    repo         Path. Repository that should be used.

    Note: if less then two revisions (or one revision and “curfile”) were 
          specified, one will be working directory state or current revision 
          (see |aurum-current-revision|) and second (unless one revision is 
          specified) will either be working directory revision or, if it is 
          equal to current revision, its first parent.
                          *g:frawormap_AuVimDiff* *g:frawormap_AuVimDiff_Exit*
    :AuVimDiff command defines Exit mappings for all opened buffers. By 
    default lhs of this mapping is “X” with leader “<Leader>” (“<Leader>X”), 
    but this can be customized using g:frawormap_AuVimDiff and 
    g:frawormap_AuVimDiff_Exit variables. This mapping will disable diff, 
    close (and, possibly, wipe out) opened buffers and try to restore view 
    state of the first buffer (unless it was opened by :AuVimDiff).

------------------------------------------------------------------------------
2.2. Functions                                               *aurum-functions*

aurum#repository :: () -> repo                            *aurum#repository()*
    Returns a repository object. Cached (update time is controlled by 
    |g:aurum_repocachetime|). See |aurum-repository|.

aurum#changeset :: ([{repo}]) -> changeset                 *aurum#changeset()*
    Returns a working directory changeset object. Cached (update time is 
    controlled by |g:aurum_cscachetime|). See |aurum-changeset|.

aurum#status :: ([{repo}]) -> status                          *aurum#status()*
    Returns a current file status (one of the keys of a dictionary returned by 
    |aurum-rf-status|) or zero. Cached (update time is controlled by 
    |g:aurum_statuscachetime|).

------------------------------------------------------------------------------
2.3. aurum:// pseudo-protocol                                       *aurum://*

Aurum provides a number of commands that can be opened or read using filenames 
starting with aurum://. Some things you should know:
- If pseudo-protocol supports more then one argument, in all but last 
  arguments colons and backslashes should be escaped. In a last argument you 
  may not escape anything (unless this argument is an options dictionary).
- While all commands take filenames relative to current directory, all 
  pseudo-protocols should be passed filenames relative to repository root.
- None of pseudo-protocols accepts globs outside of {opts}.
- When stated that {opts} are the same as used by some command it does not 
  mean that you can truncate options or use “no{option}” version. Truncations 
  are not allowed and flags should look like “{option}:1” or “{option}:0”. Two 
  subsequent options look like “{o1}:{v1},{o2}:{v2}”. Options that accept 
  lists or more then one argument will look like “{o}:{v1};{v2};...”. To 
  include semicolon here it should be escaped. You should also escape commas, 
  backslashes and colons. If command accepts {diffopts} then they can also be 
  added.
  Options “cmd” and “repo” are always ignored.
- All arguments for all pseudo-protocols are assumed to be escaped in the 
  following fashion:
                 Char  Esc ~
                    %  %%
                    ,  %c
                    :  %.
                    ;  %s
                    /  %-
                    \  %+
                  [,]  %b, %B
                  {,}  %f, %F
                    *  %a
                    ?  %q
                    `  %'
                    $  %d
  You must escape only argument delimiters (colon for most arguments, colon 
  and comma for non-list option arguments, colon, semicolon and comma for list 
  option arguments) and percent sign, but in this case you may run into 
  trouble: for example, “*” produces |E480| (no match) error on windows 
  because it can’t be escaped with backslash which is path separator.
- All mappings are created using |frawor-f-mapgroup.add| and thus can 
  customized using |g:frawormap_mgid| and |g:frawormap_mgid_mapname|.
- All buffers that define mappings also define Exit mapping (with default 
  LHS=X)

aurum://annotate:{repo}:{rev}:{file}                        *aurum://annotate*
    Annotate file {file} from repository {repo} at revision {rev}.
    Local mappings (mgid=AuAnnotate, without leader by default) (current 
    revision=revision under cursor):                  *g:frawormap_AuAnnotate*
             *g:frawormap_AuAnnotate_Enter*  *g:frawormap_AuAnnotate_Fdiff*
             *g:frawormap_AuAnnotate_RFdiff* *g:frawormap_AuAnnotate_FVdiff*
             *g:frawormap_AuAnnotate_Diff*   *g:frawormap_AuAnnotate_RFVdiff*
             *g:frawormap_AuAnnotate_Rdiff*  *g:frawormap_AuAnnotate_Annotate*
             *g:frawormap_AuAnnotate_RVdiff* *g:frawormap_AuAnnotate_Open*
             *g:frawormap_AuAnnotate_Update* *g:frawormap_AuAnnotate_Next*
             *g:frawormap_AuAnnotate_Prev*       *aurum-m-AuAnnotate_Prev*
                 *aurum-m-AuAnnotate_Enter*      *aurum-m-AuAnnotate_Fdiff*
                 *aurum-m-AuAnnotate_RFdiff*     *aurum-m-AuAnnotate_FVdiff*
                 *aurum-m-AuAnnotate_Diff*       *aurum-m-AuAnnotate_RFVdiff*
                 *aurum-m-AuAnnotate_Rdiff*      *aurum-m-AuAnnotate_Annotate*
                 *aurum-m-AuAnnotate_RVdiff*     *aurum-m-AuAnnotate_Open*
                 *aurum-m-AuAnnotate_Update*     *aurum-m-AuAnnotate_Next*
    Mapname  LHS  Description ~
    Enter    <CR> View changes between file and current revision (|vimdiff|)
    FVdiff   gD   View diff between working directory and current revision 
                  (using |vimdiff| in multiple tabs)
    RFVdiff  gC   View diff between current revision and its first parent 
                  (using |vimdiff| in multiple tabs)
    Fdiff    gd   View diff between working directory and current revision
    RFdiff   gc   View diff between current revision and its first parent
    Diff      d   View diff between file and current revision
    Rdiff     c   Like Fdiff, but view only changes made to annotated file
    Vdiff     D   Same as Enter
    RVdiff    C   View changes between current revision and its parent 
                  (|vimdiff|)
    Annotate  a   Reannotate file using current revision (only if both 
                  annotate and annotated buffers are open)
    Open      o   Open file from current revision (if both annotate and 
                  annotated buffers are open: and annotate it)
    Update    U   Update working directory to current revision.
                  Accepts count: {count}=3: update to first parent of first 
                  parent of current revision
    Next      K   Reannotate file using first child of annotated revision.
                  Accepts count, in this case first child is taken {count} 
                  times ({count}=2: first child of first child)
    Prev      J   Reannotate file using first parent of annotated revision.
                  Accepts count, in this case first parent is taken {count} 
                  times ({count}=2: first parent of first parent)

    Note These mappings are defined for aurumannotate filetype.

aurum://commit:{repo}:{user}:{date}:{closebranch}:{files}     *aurum://commit*
    Open buffer that prompts for a commit message. Writing this buffer will 
    record the commit and close the buffer. It is the only pseudo-protocol 
    type you can’t use this with |:read|.
    Local mappings (mgid=AuCommitMessage, default leader: "<LocalLeader>"):
                                                 *g:frawormap_AuCommitMessage*
                                          *g:frawormap_AuCommitMessage_Commit*
                                              *aurum-m-AuCommitMessage_Commit*
    Mapname  LHS  Description ~
    Commit    i   Finish writing commit message and commit changes

    Note These mappings are defined for aurumcommit filetype.

aurum://diff:{repo}:{rev1}:{rev2}:{files}:{diffopts}            *aurum://diff*
    Open differencies between revisions {rev1} and {rev2} of files {files} 
    (semicolon-delimited list, semicolons in filenames can be escaped). For 
    {diffopts} see |aurum-diffoptions|. If one of {rev1} or {rev2} is empty 
    then it will open the same diff as |:AuDiff| would if “rev1”, “rev2” and 
    “changes” options were not given. If {files} is empty, then it will show 
    all changes.
    Local mappings (mgid=AuDiff, without leader by default):
                                                          *g:frawormap_AuDiff*
                         *g:frawormap_AuDiff_Next* *g:frawormap_AuDiff_FVdiff*
                         *g:frawormap_AuDiff_Prev* *g:frawormap_AuDiff_Vdiff*
                         *g:frawormap_AuDiff_Open* *g:frawormap_AuDiff_Update*
                             *aurum-m-AuDiff_Next*     *aurum-m-AuDiff_FVdiff*
                             *aurum-m-AuDiff_Prev*     *aurum-m-AuDiff_Vdiff*
                             *aurum-m-AuDiff_Open*     *aurum-m-AuDiff_Update*
    Mapname  LHS  Description ~
    Next      K   Change all revisions specified to aurum://diff to their 
                  first children. Accepts count, in this case first child is 
                  taken {count} times ({count}=2: first child of first 
                  child)
    Prev      J   Change all revisions specified to aurum://diff to their 
                  first parents. Accepts count, in this case first parent is 
                  taken {count} times ({count}=2: first parent of first 
                  parent)
    Update    U   Update working directory to one of revisions (first or 
                  second, which is non-empty).
                  Accepts count: {count}=3: update to first parent of first 
                  parent of the revision
    Open      o   Open file which diff is located under cursor. If {rev1} is 
                  empty it will try to open file located in working directory 
                  and fallback to {rev2} version. If {rev1} is not empty, it 
                  will open {rev1} version.
    Vdiff     D   View diff section under cursor using |vimdiff|.
    FVdiff    gD  View the whole diff in a multiple tabs using |vimdiff|.

    Note These mappings are defined only when buffer is created using 
         |:AuDiff| command or from most mappings.

aurum://file:{repo}:{rev}:{file}                                *aurum://file*
    Open file {file} from repository {repo} as it was at revision {rev}.
    Local mappings (mgid=AuFile, without leader by default):
                                                          *g:frawormap_AuFile*
                        *g:frawormap_AuFile_Next*  *g:frawormap_AuFile_Prev*
                        *g:frawormap_AuFile_Diff*  *g:frawormap_AuFile_Update*
                        *g:frawormap_AuFile_Rdiff* *g:frawormap_AuFile_RVdiff*
                        *g:frawormap_AuFile_Vdiff*     *aurum-m-AuFile_Vdiff*
                            *aurum-m-AuFile_Next*      *aurum-m-AuFile_Prev*
                            *aurum-m-AuFile_Rdiff*     *aurum-m-AuFile_RVdiff*
                            *aurum-m-AuFile_Diff*      *aurum-m-AuFile_Update*
    Mapname  LHS  Description ~
    Next      K   View current file as it was at first child of current 
                  revision. Accepts count, in this case first child is taken 
                  {count} times ({count}=2: first child of first child)
    Prev      J   View current file as it was at first parent of current 
                  revision. Accepts count, in this case first parent is taken 
                  {count} times ({count}=2: first parent of first parent)
    Update    U   Update working directory to current revision.
                  Accepts count: {count}=3: update to first parent of first 
                  parent of current revision
    Diff      d   View diff between current buffer and file from working 
                  directory
    Rdiff     c   View changes introduced to {file} in {rev}
    Vdiff     D   View |vimdiff| between current buffer and file from working 
                  directory
    RVdiff    C   View |vimdiff| between current buffer and aurum://file 
                  buffer with revision set to first parent of {rev} and same 
                  {repo} and {file} arguments

    Note These mappings are defined only when buffer is created using 
         |:AuFile| command or from most mappings.

aurum://log:{repo}:{opts}                                        *aurum://log*
    Open log for given repo. {opts} are the same as used by |:AuLog|.
    Local mappings (mgid=AuLog, current revision=revision under cursor):
                                                           *g:frawormap_AuLog*
                        *g:frawormap_AuLog_File*  *g:frawormap_AuLog_Enter*
                        *g:frawormap_AuLog_User*  *g:frawormap_AuLog_Update*
                        *g:frawormap_AuLog_Rev*   *g:frawormap_AuLog_Branch*
                        *g:frawormap_AuLog_Diff*  *g:frawormap_AuLog_FVdiff*
                        *g:frawormap_AuLog_Fdiff* *g:frawormap_AuLog_RFVdiff*
                        *g:frawormap_AuLog_Next*  *g:frawormap_AuLog_RFdiff*
                        *g:frawormap_AuLog_Prev*  *g:frawormap_AuLog_Rdiff*
                        *g:frawormap_AuLog_Open*  *g:frawormap_AuLog_Annotate*
                        *g:frawormap_AuLog_Date*      *aurum-m-AuLog_Date*
                            *aurum-m-AuLog_File*      *aurum-m-AuLog_Enter*
                            *aurum-m-AuLog_User*      *aurum-m-AuLog_Update*
                            *aurum-m-AuLog_Rev*       *aurum-m-AuLog_Branch*
                            *aurum-m-AuLog_Diff*      *aurum-m-AuLog_Fdiff*
                            *aurum-m-AuLog_Next*      *aurum-m-AuLog_RFdiff*
                            *aurum-m-AuLog_Prev*      *aurum-m-AuLog_Rdiff*
                            *aurum-m-AuLog_Open*      *aurum-m-AuLog_Annotate*
    Mapname  LHS  Description ~
    Enter    <CR> Depending on element under cursor:
                  Element          Action ~
                  branch           Same as Branch mapping
                  user             Same as User mapping
                  time             Same as Date mapping
                  revision number  Same as Rev mapping
                  revision hash    Same as Rev mapping
                  filename         Same as Open mapping
                  (any other)      Same as RFdiff mapping
    File     gF   View history of one of the files present in revision under 
                  cursor (if there is a filename under cursor then it will be 
                  used)
    User     gu   View only revisions that were added by the user who added 
                  current one
    Date     gM   View only revisions that were added in the same month as 
                  current one
    Branch   gb   View only revisions that are in the same branch as current
    Rev      gr   View only ancestors of current revision
    FVdiff   gD   View changes between current revision and working directory 
                  state in a multiple tabs each containing |vimdiff|
    RFVdiff  gC   View all changes introduced by current revision as 
                  a |vimdiff| in a multiple tabs
    Fdiff    gd   View changes between current revision and working directory 
                  state
    RFdiff   gc   View changes introduced by current revision
    Diff      d   View diff between working directory and current revision 
                  versions of one of the files
    Rdiff     c   View changes introduced by current revision to one of the 
                  files
    Next      K   Jump to first child of current revision
                  Accepts count, in this case first child is taken {count} 
                  times ({count}=2: first child of first child)
    Prev      J   Jump to first parent of current revision
                  Accepts count, in this case first parent is taken {count} 
                  times ({count}=2: first parent of first parent)
    Open      o   Open one of the files changed in current revision
    Annotate  a   Open one of the files changed in current revision and 
                  annotate it
    Update    U   Update working directory to current revision
                  Accepts count: {count}=3: update to first parent of first 
                  parent of current revision

    Note These mappings are defined for aurumlog filetype.

aurum://status:{repo}:{opts}                                  *aurum://status*
    View status of a repository {repo}. {opts} are the same as used by 
    |:AuStatus|.
    Local mappings (mgid=AuStatus, without leader by default):
                                                        *g:frawormap_AuStatus*
                 *g:frawormap_AuStatus_Open*   *g:frawormap_AuStatus_ROpen*
                 *g:frawormap_AuStatus_RFdiff* *g:frawormap_AuStatus_Fdiff*
                 *g:frawormap_AuStatus_FVdiff* *g:frawormap_AuStatus_RFVdiff*
                 *g:frawormap_AuStatus_Diff*   *g:frawormap_AuStatus_vDiff*
                 *g:frawormap_AuStatus_Rdiff*  *g:frawormap_AuStatus_vRdiff*
                 *g:frawormap_AuStatus_Vdiff*  *g:frawormap_AuStatus_RVdiff*
                 *g:frawormap_AuStatus_vVdiff* *g:frawormap_AuStatus_vRVdiff*
                 *g:frawormap_AuStatus_Commit* *g:frawormap_AuStatus_Annotate*
                 *g:frawormap_AuStatus_Track*  *g:frawormap_AuStatus_vCommit*
                 *g:frawormap_AuStatus_vTrack* *g:frawormap_AuStatus_Forget*
                 *g:frawormap_AuStatus_vForget*    *aurum-m-AuStatus_vForget*
                     *aurum-m-AuStatus_Open*       *aurum-m-AuStatus_ROpen*
                     *aurum-m-AuStatus_RFdiff*     *aurum-m-AuStatus_Fdiff*
                     *aurum-m-AuStatus_FVdiff*     *aurum-m-AuStatus_RFVdiff*
                     *aurum-m-AuStatus_Diff*       *aurum-m-AuStatus_vDiff*
                     *aurum-m-AuStatus_Rdiff*      *aurum-m-AuStatus_vRdiff*
                     *aurum-m-AuStatus_Vdiff*      *aurum-m-AuStatus_RVdiff*
                     *aurum-m-AuStatus_vVdiff*     *aurum-m-AuStatus_vRVdiff*
                     *aurum-m-AuStatus_Commit*     *aurum-m-AuStatus_Annotate*
                     *aurum-m-AuStatus_Track*      *aurum-m-AuStatus_vCommit*
                     *aurum-m-AuStatus_vTrack*     *aurum-m-AuStatus_Forget*
    Mapname  LHS  Description ~
    Open     <CR> Open file under cursor
    ROpen     o   Open file under cursor as it was at first revision (working 
                  directory revision by default)
    RFdiff   gd   View changes introduced by first revision
    Fdiff    gc   View diff between two revisions (or working directory state 
                  and first revision)
    RFVdiff  gD   Like RFdiff, but show them in multiple tabs using |vimdiff|
    FVdiff   gC   Like Fdiff,  but show them in multiple tabs using |vimdiff|
    Diff      d   Like RFdiff, but show only current file
    vDiff     d   Like RFdiff, but shows files selected in visual mode
    Rdiff     c   Like Fdiff, but show only current file
    vRdiff    c   Like Fdiff, but shows files selected in visual mode
    Vdiff     D   Like Diff, but use |vimdiff| to view changes
    vVdiff    D   Like FVdiff, but limit files only to selected ones
    RVdiff    C   Like Rdiff, but use |vimdiff| to view changes
    vRVdiff   C   Like RFVdiff, but limit files only to selected ones
    Annotate  a   Open file under cursor and annotate it
    Commit    i   Commit changes made to file under cursor
    vCommit   i   Commit changes made to selected files
    Track     A   Make file under cursor be tracked by VCS
    vTrack    A   Make selected files be tracked by VCS
    Forget    R   Make VCS forget file under cursor
    vForget   R   Make VCS forget selected files

    Note all mappings that have v{Mapname} version also accept count. In this 
         case it will work like selecting {count} lines starting from current 
         one and invoking v{Mapname}
    Note These mappings are defined for aurumstatus filetype.

------------------------------------------------------------------------------
2.4. Global mappings                                          *aurum-mappings*
                                                           *g:frawormap_Aurum*

All mappings (not only global) are created using |frawor-f-mapgroup.add| and 
thus can customized using |g:frawormap_mgid| and |g:frawormap_mgid_mapname|. 
For global mappings mgid=Aurum, default leader is “<Leader>a”. Unlike other 
mappings (which call internal functions), global ones call one of :Au* 
commands. Present mappings:

                      *g:frawormap_Aurum_Commit* *g:frawormap_Aurum_CommitAll*
                      *g:frawormap_Aurum_ROpen*  *g:frawormap_Aurum_Revert*
                      *g:frawormap_Aurum_Vdiff*  *g:frawormap_Aurum_Diff*
                      *g:frawormap_Aurum_Fdiff*  *g:frawormap_Aurum_Annotate*
                      *g:frawormap_Aurum_Status* *g:frawormap_Aurum_Record*
                      *g:frawormap_Aurum_Log*    *g:frawormap_Aurum_LogFile*
                      *g:frawormap_Aurum_URL*    *g:frawormap_Aurum_LineURL*
                      *g:frawormap_Aurum_Track*  *g:frawormap_Aurum_Forget*
                      *g:frawormap_Aurum_Push*   *g:frawormap_Aurum_Pull*
                      *g:frawormap_Aurum_FVdiff*     *aurum-m-Aurum-FVdiff*
                          *aurum-m-Aurum_Commit*     *aurum-m-Aurum_CommitAll*
                          *aurum-m-Aurum_ROpen*      *aurum-m-Aurum_Revert*
                          *aurum-m-Aurum_Vdiff*      *aurum-m-Aurum_Diff*
                          *aurum-m-Aurum_Fdiff*      *aurum-m-Aurum_Annotate*
                          *aurum-m-Aurum_Status*     *aurum-m-Aurum_Record*
                          *aurum-m-Aurum_Log*        *aurum-m-Aurum_LogFile*
                          *aurum-m-Aurum_URL*        *aurum-m-Aurum_LineURL*
                          *aurum-m-Aurum_Track*      *aurum-m-Aurum_Forget*
                          *aurum-m-Aurum_Push*       *aurum-m-Aurum_Pull*
Mapname    LHS  Command     Description ~
Commit      i   AuCommit    Commit changes to current file
CommitAll   I   AuCommit ** Commit changes to all files
ROpen       o   AuFile      View contents of the current file as it was at the 
                            the working directory revision
Revert      O   AuFile . : replace
                            Replace current buffer with contents of the 
                            current file as it was at the working directory 
                            revision
Vdiff       D   AuVimDiff   View differencies between buffer contents and 
                            version from working directory revision
Diff        d   AuDiff :    Like Vdiff, but view them in diff format
Fdiff      gd   AuDiff      Like Diff, but view changes in all files
FVdiff     gD   AuVimDiff full
                            View all differencies between working directory 
                            state and working directory revision
Annotate    a   AuAnnotate  Annotate current buffer
Status      s   AuStatus | wincmd p
                            Open status window and switch back
Record      r   AuRecord    Switch to record mode
Log         L   AuLog       View the revision history
LogFile     l   AuLog : files :
                            View revisions where current file was changed
URL         H   AuHyperlink Create URL where current file can be viewed 
                            remotely and copy it to clipboard (|quote+|)
LineURL     h   AuHyperlink line 0
                            As URL, but also adds URL fragment pointing to 
                            current line
Track       A   AuTrack     Make current file be tracked by VCS
Forget      R   AuJunk forget :
                            Make VCS forget current file (it won’t remove the 
                            file though)
Push        P   AuOther push
                            Push new commits to remote repository.
Pull        p   AuOther push | AuUpdate
                            Pull new commits from remote repository and 
                            perform an update.

==============================================================================
4. Options                                                     *aurum-options*

All options used by aurum are obtained using |frawor-f-getoption| and thus you 
can write g:aurumOptions.option instead of g:aurum_option. All options are 
also global-local: you can also define an option for the current buffer using 
buffer-local b:aurum_option (b:aurumOptions.option) variable.

                                                         *g:aurum_cscachetime*
*cachetime                   *g:aurum_statuscachetime* *g:aurum_repocachetime*
    Unsigned integer, defines time since last cache update after which cache 
    will become invalid. Time is specified in seconds.
    Type  Default  Used by ~
    cs       3     |aurum#changeset()|
    status   5     |aurum#status()|
    repo     7     |aurum#repository()|, all completion functions

ignorefiles                                              *g:aurum_ignorefiles*
    List containing 0 or more strings. Determines when “files” option given to 
    |:AuLog| (or to |aurum://log|) should be ignored. See |aurum-lo-ignfiles|.
    Default: empty.

closewindow                                              *g:aurum_closewindow*
    Bool. Determines whether log window should be closed when executing 
    mappings (except mappings that add a filter and exit mapping).
    Default: 1.

procinput                                                  *g:aurum_procinput*
    0, 1 or 2. If not zero, consumes and passes user input to |:normal| while 
    generating a log thus allowing you to navigate it while it is being 
    created. Value 1 will make logger additionally check whether there were 
    some characters in input buffer before creation of log started. If there 
    were characters, then processing user input will be disabled (because in 
    other case it will possibly break mappings that do not expect such 
    behavior from |:AuLog|).
    Default value: 1.
    Note: if you somehow switch buffers while log is being generated then 
          buffer with generated log will be wiped out, log generation will 
          stop.
    Note: Input is processed between generating two revisions. As generator is 
          normally much faster then you, then you are limited to single 
          character commands. There is a hack though that allows you to bypass 
          this problem:
            Input    Action ~
            g, z, y, `, ', m, [, ], @, q, Z, <C-w>, t, T, f, F
                     Waits until you type next character
            /, ?, :, !
                     Waits until you type <CR> ("\r" or "\n") or <Esc>
            1-9      Waits until you type next non-digit
            "        Waits until you type two characters

recheight                                                  *g:aurum_recheight*
    VimL |expression| that evaluates to unsigned integer or unsigned integer. 
    Determines height of status window shown in record mode (|aurum-record|).
    Default: winheight/5 (in empty tab |winheight()| will return roughly the 
             same value as 'lines').

diffopts                                                    *g:aurum_diffopts*
    Dictionary. For possible keys see |aurum-diffoptions| (no truncations are 
    allowed, flags should be turned into “{option : 0}” for “nooption”, 
    “{option : 1}” for “option”).
    Default: empty.

usestatwin                                                *g:aurum_usestatwin*
    Bool. Determines whether sequential calls to |:AuStatus| with same 
    arguments should use existing status window or open a new one.
    Default: 1.

remembermsg                                              *g:aurum_remembermsg*
    Bool. Determines whether message typed in commit buffer should be saved 
    when commit is performed in case of rollback. This message will appear in 
    commit buffer if you do |:AuCommit| and tip revision hash is equal to hash 
    of tip revision saved after previous |:AuCommit| run.
    Default: 1.
                                                   *g:AuPreviousCommitMessage*
                                      *g:AuPreviousTip* *g:AuPreviousRepoPath*
    Note that this option determines whether message should be saved, not 
         whether it should be restored. Message will be restored from 
         g:AuPreviousCommitMessage variable if repository path is equal to 
         g:AuPreviousRepoPath and tip revision hash is equal to 
         g:AuPreviousTip. It does not matter who set these variables and what 
         is the value of “remembermsg” option.

bufleaveremembermsg                              *g:aurum_bufleaveremembermsg*
    Bool. Determines whether message typed in commit buffer should be saved 
    when message buffer is left excluding the case when buffer is left after 
    commit is done. See note under |g:AuPreviousCommitMessage|.
    Default: 1.

usewin                                                        *g:aurum_usewin*
    Bool. Determines whether |:AuVimDiff| should use existing window. Existing 
    window will be used if it is located to the left or right ('diffopt' 
    contains “vertical”) or below or above ('diffopt' does not contain 
    “vertical”) current window and has just the same vertical or horizontal 
    size (vertical if 'diffopt' contains “vertical”, horizontal otherwise).
    Default: 0.

workdirfiles                                            *g:aurum_workdirfiles*
    Bool. Determines whether |:AuGrep| should output files in working 
    directory if they have not changed since revision found.
    Default: 1.

hypsites                                                    *g:aurum_hypsites*
    List of pairs, just like |aurum-repo.hypsites|. Defines additional 
    repository information in case some repository support is not/can not be 
    added to the aurum.
    Values of this option are checked before |aurum-repo.hypsites|.

The following options are driver-specific:

hg_useshell                                              *g:aurum_hg_useshell*
    List (either true list or string with values separated by anything that is 
    not a lowercase letter) of Mercurial commands that are to be called 
    without using Mercurial Python API.

    Functions supporting this option: |rf-commit|, |rf-update|, |rf-move| 
    (uses "rename" mercurial command), |rf-copy|, |rf-forget|, |rf-remove|, 
    |rf-add|, |rf-branch|, |rf-label| (uses "tag" or "bookmark" Mercurial 
    commands). Every function except |rf-move| and |rf-label| uses Mercurial 
    command identical to its name.

==============================================================================
5. Globs                                                         *aurum-globs*

Globs used by aurum are similar to globs used by mercurial, but have different 
implementation: they are transformed into vim regular expressions that are 
then applied to a list of filenames in normalized form (path/to/file: path 
comoponents are separated by exactly one forward slash, used path is relative 
to repository root). Supported metacharacters:
Meta  Regex     Description ~
**    .*        Like “*” below, but also match inside subdirectories
*     [^/]*     Matches any number of any characters in given directory
?     [^/]      Matches exactly one character in given directory
[!ab] [^ab]     Matches any character that is neither a nor b (see |/[]|)
[ab]  [ab]      Matches a or b (see |/[]|)
{a,b} \(a\|b\)  Matches a or b. Unlike [ab], {a,b} treats a and b as globs

==============================================================================
6. Log templates                                          *aurum-logtemplates*

Log template is a list of NL-separated lines. Inside a string only two 
characters are special: newline and $. First designates that here new line 
should be started. Second designates that next word should be replaced with 
appropriate value. You can pass additional arguments using ${word}#{args}# 
syntax where {args} is {positional1},{positional2},...,{keyword}:{value},...
Accepted {keyword}s are
Keyword    Description ~
flbeg      For multiline template strings: determine what string should be 
           prepended to the first line.
expr       Use this expression instead of default to get resulting string. 
           Inside an expression “@@@” refers to original data, “@N@” - to Nth 
           positional parameter (count starts from zero), “@-@” - to number of 
           leading columns taken by graph lines, “@.@” - to current 
           |aurum-changeset| object, “@<@” - to string that should be 
           prepended to every line (valid for complex multiline template 
           strings).
synreg     Pass this regular expression to “syn match”. Useful if you override 
           output of the {word} using “expr” keyword.
pref, suf  For some single-line statements (currently: rev, parents, children, 
           tags, bookmarks and branch): if result of evaluating {word} is 
           non-empty (for branch: is not equal to "default") add value of the 
           argument before (pref) or after (suf) the {word}.
Number of positional parameters is fixed and depends on {word}. You can escape 
“#” if you need it included into one of parameters. You should also escape 
backslash, colon (unless it separates {keyword} from value) and comma (unless 
it separates arguments).

Generator created after parsing templates throws away lines that contain only 
one {word} that is “parents”, “children”, “tags”, “bookmarks”, “files” or 
“changes” if it expands to an empty string.

Multiline {word}s have two types:
1. Simple multiline: line beginnings are added by generator.
2. Complex multiline: line beginnings are added by expression (using @<@).

When multiline {word} is preceded by another text, this text is repeated at 
the start of each line. Text that follows multiline {word} is not repeated 
thus you can see it only on the last line. Example: >
        S$hide#H# $description#flbeg:F# E
expands to >
        FSH First line of description
        SH second line of description
        SH last line of description E

Note you can’t have two multiline {word}s on one line.

Possible {word}s:
Word         Description ~
hide         Requires one positional parameter. $hide#{text}# is just like 
             plain {text}, except that with $hide {text} will be highlighted 
             using |hl-Ignore| highlighting group. It is useful if you want to 
             be able to properly highlight multiline {word}s.
empty        Nothing. Should be used to include empty line somewhere or force 
             generator not to throw away some line.
branch       String, branch name. Accepts one positional parameter which 
             determines whether “default” branch should be shown. Any value 
             other then "keep" will tell template engine not to show the 
             branch name in this case. Default value: "keep".
hex, user    String with value equal to the value of corresponding changeset 
             property.
rev          Like above, but also accepts additional argument which determines 
             whether revision should be shown if |aurum-repo.hasrevisions| is 
             false. Any value of this additional argument that is not equal to 
             "keep" designates that it should be ignored in this case.
             Default value: "ignore".
time         String representation of the date. Accepts one positional 
             parameter: string that will be passed to |strftime()| to format 
             the time. Default value: "%d %b %Y %H:%M".
parents, children
             List of space-separated hashes designating parents or children of 
             current changeset.
tags, bookmarks
             List of tags or bookmarks separated by the first positional 
             parameter (default value: ", ").
summary      First line of description.
description  (multiline) Description of a changeset.
patch        (multiline) Differences introduced by processed changeset. Not 
             shown unless “patch” option was given.
stat         (multiline) Summary of changes introduced by processed changeset. 
             Not shown unless “stat” option was given.
files, changes
             (complex multiline) Files that were changed in processed 
             revision. “files” will only show modified and added files (files 
             that are present in processed changeset), “changes” will also 
             show removed files. Accepts one positional parameter: string used 
             to separate two filenames (default: ", "). Not shown unless 
             “showfiles” option was given.
renames, copies
             (complex multiline) Renames or copies in a form {src}{p1}{dest}. 
             Accepts one positional parameter: string used to separate two 
             filenames (default: " to "). Not shown unless “showrenames” or 
             “showcopies” option was given.

------------------------------------------------------------------------------
6.1. Built-in template styles                               *aurum-logstyles*

default                                                  *aurum-style-default*
    Default style: >
      Changeset 1:454ae580ce74 (branch A)
      Commited 01 Jan 2011 00:00 by Bob <bob@example.com>
      Tags: tip
      Files: foo/bar.txt, foo/barbaz.txt, foo/baz.txt
      Renamed foo/baz.txt to foo/bar.txt
      Copied foo/baz.txt to foo/barbaz.txt
        Guess bar is better name for baz
        And barbaz is not worse

hgdef                                                      *aurum-style-hgdef*
    Style that mimics default “hg log” style: >
      changeset:   1:454ae580ce74
      branch:      A
      tags:        tip
      user:        Bob <bob@example.com>
      date:        Sun Jan 01 00:00:00 2011
      files:       foo/bar.txt foo/barbaz.txt foo/baz.txt
      summary:     Guess bar is better name for baz

hgdescr                                                  *aurum-style-hgdescr*
    Style that mimics default “hg log” style with verbose flag on (the only 
    difference is description instead of summary as other shown items are 
    controlled by other |:AuLog| options): >
      changeset:   1:454ae580ce74
      branch:      A
      tags:        tip
      user:        Bob <bob@example.com>
      date:        Sun Jan 01 00:00:00 2011
      files:       foo/bar.txt foo/barbaz.txt foo/baz.txt
      description:
      Guess bar is better name for baz
      And barbaz is not worse

compact                                                  *aurum-style-compact*
    Style that mimics “compact” “hg log” style: >
      1[tip]   454ae580ce74 2011-01-01 00:00 Bob <bob@example.com>
        Guess bar is better name for baz

cdescr                                                    *aurum-style-cdescr*
    Like “compact” above, but with full description instead of summary: >
      1[tip]   454ae580ce74 2011-01-01 00:00 Bob <bob@example.com>
        Guess bar is better name for baz
        And barbaz is not worse

git                                                          *aurum-style-git*
    Git-like style: >
      commit 454ae580ce74
      Author: Bob <bob@example.com>
      Date:   Sun Jan 01 00:00:00 2011

          Guess bar is better name for baz
          And barbaz is not worse

gitoneline                                            *aurum-style-gitoneline*
    Git --pretty=oneline-like style: >
      454ae580ce74 Guess bar is better name for baz

Note that in all styles handling of “stat” and “patch” |:AuLog| options is the 
     same: required info is added to the end of the block, “stat” goes first.

     Timezone info is never present as aurum does not use it, all dates are 
     shown using local time. I won’t fix this: Vim built-in |strftime()| 
     function does not accept timezone argument and I do not think it is worth 
     implementing in vimscript.

svn                                                          *aurum-style-svn*
    Svn-like style: >
      r1 | Bob <bob@example.com> | 2011-01-01 00:00:00 (Sun, 01 Jan 2011) | 3 lines

      Guess bar is better name for baz
      And barbaz is not worse

==============================================================================
7. Record mode                                                  *aurum-record*

Record mode is used to interactively select changes that should be committed. 
|:AuRecord| command opens a new tab page and splits it into three windows: 
recorded, original and status:
  +------------------+------------------+ `
  |                  |                  | `
  |                  |                  | `
  |                  |                  | `
  |     recorded     |     original     | `
  |                  |                  | `
  |                  |                  | `
  |                  |                  | `
  +------------------+------------------+ `
  |                                     | `
  |                status               | `
  |                                     | `
  +-------------------------------------+ `
After entering record mode status window becomes focused. It contains output 
similar to the output of |:AuStatus| command, but with one additional column 
added at the beginning of the line. This column may contain one of four status 
characters:
Character  Meaning ~
    -      Changes done to this file won’t be committed (default)
    +      All changes done to this file will be committed
    *      You have made changes to this file in record mode. These changes 
           will be commited
    ^      You have made changes to this file in record mode, but then chose 
           not to commit them. They will reappear again when you use 
           |aurum-m-AuRecord_Edit| mapping
In status window there are additional mappings available (mgid=AuRecord, 
without leader by default):                             *g:frawormap_AuRecord*
                       *g:frawormap_AuRecord_Edit* *g:frawormap_AuRecord_Undo*
                           *aurum-m-AuRecord_Edit*     *aurum-m-AuRecord_Undo*
Mapping  LHS  Description ~
Edit      O   Edit file under cursor. In original window there will be changed 
              version of file (for modified files) or nothing (files with 
              other statuses when edited for the first time), in recorded 
              window there will be version of file that will be committed 
              (initially unmodified compared to version stored in repository). 
              If file is edited for the second time in recorded window there 
              will be version of file modified in record mode and in original 
              window there will be backup of the file (or version from 
              repository if file in question was removed or deleted).
Undo      u   Undo adds/removes of the file. Won’t undo changes made to the 
              file using Edit mapping.
:AuRecord also makes some AuStatus mappings change their meaning:
Mapping                 New meaning ~
|aurum-m-AuStatus_Track|  select changes made to file(s) for committing
|aurum-m-AuStatus_Commit| finish record mode and commit selected changes
|aurum-m-AuStatus_Forget| unselect changes made to file(s), don’t commit them

Note that if you quit commit buffer or close status window you will also exit 
     record mode discarding all changes you have made.

:AuRecord defines the following mappings in recorded window 
(mgid=AuRecordLeft, default leader: "<Leader>"):    *g:frawormap_AuRecordLeft*
          *g:frawormap_AuRecordLeft_Discard* *g:frawormap_AuRecordLeft_Exit*
          *g:frawormap_AuRecordLeft_Commit*  *g:frawormap_AuRecordLeft_Remove*
              *aurum-m-AuRecordLeft_Discard*     *aurum-m-AuRecordLeft_Exit*
              *aurum-m-AuRecordLeft_Commit*      *aurum-m-AuRecordLeft_Remove*
Mapping  LHS  Description ~
Discard   x   Discard all changes made to edited file. If file is opened for 
              the second time only unsaved changes will be discarded
Exit      X   Exit record mode, discarding all changes made to all files and 
              not committing anything
Commit    i   Commit selected changes and exit record mode
Remove    R   Like Discard, but also unselect it (makes difference if file is 
              edited for the second time)

==============================================================================
8. Internal objects                                            *aurum-objects*

------------------------------------------------------------------------------
8.1. Repository                                             *aurum-repository*

Repository is a dictionary containing at least the following keys:

cslist :: [ cs ]                                           *aurum-repo.cslist*
    List of |aurum-changeset| objects. It is empty by default and may be 
    populated only when you call |aurum-rf-getchangesets|. See also 
    |aurum-cs.rev|.
    Obsolete, use |aurum-rf-getchangesets|.
changesets :: {hex : cs}                               *aurum-repo.changesets*
    Dictionary containing all |aurum-changeset| objects that are associated 
    with the repository. For each changeset cs is repo.changesets[cs.hex].
csnum :: UInt                                               *aurum-repo.csnum*
    Total number of revisions in repository. For any changeset 
    cs.rev<repo.csnum. See also |aurum-cs.rev|.
local :: Bool                                               *aurum-repo.local*
    1 if repository is local, 0 otherwise.
    Note that aurum is really useless for working with remote repositories.
path :: path                                                 *aurum-repo.path*
    String which was passed to |aurum-rf-repo| function.
hypsites :: [(expr, dict)]                               *aurum-repo.hypsites*
    List of pairs that determines how string returned by 
    |aurum-rf-getrepoprop| with (repo, "url") as arguments should be 
    transformed into a URL by |:AuHyperlink| command. First expression is 
    “matcher”: if it evaluates to true, then expressions from the following 
    dictionary will be used, keys are same as url types (|aurum-ho-url|). 
    Unsupported URL types should not be represented by dictionary key. 
    Additional keys “hline” and “aline” stand for URL fragments pointing to 
    the specified line (“hline” for “html”, “aline” for “annotate”) (without 
    the leading hash).
    Local variables you can use in expressions:
        Variable   Description ~
        repo       Repository object (|aurum-repository|).
        hex        Changeset hash (|aurum-cs.hex|) (url≠clone,push).
        url        URL of remote repository from local repository 
                   configuration.
        protocol, user, domain, port, path
                   Parts of the URL: {protocol}://{user}@{domain}{path}, 
                   {path} must start with either forward slash or colon.
        matcher    First item in the current pair.
        dict       Second item in the current pair.
        utype      URL type.
        line       Line number (only inside “hline” and “aline” expressions).
    You should not normally use or alter this key, use |g:aurum_hypsites| if 
    you want to add support for particular remote repository.
labeltypes :: [ String ]                               *aurum-repo.labeltypes*
    List of label types supported by |aurum-rf-label|. First type will be 
    default used by |:AuName|.
requires_sort :: Bool                               *aurum-repo.requires_sort*
    Determines whether it is necessary to run sort_in_topological_order 
    function on commit lists returned by |aurum-rf-revrange| and 
    |aurum-rf-getchangesets| when it is about to be displayed in |aurum://log| 
    buffer. If it is false, then this list will only be reversed 
    (|reverse()|).
    See |aurum-rf-getchangesets| for the description of what “topological 
    order” is.
    This key is optional, default value: true.
has_octopus_merges :: Bool                     *aurum-repo.has_octopus_merges*
    Determines whether repository has merges containing more then two parents. 
    In this case slower, but more universal algorithm will be used.
    This key is optional, default value: true.
has_merges :: Bool                                     *aurum-repo.has_merges*
    Determines whether repository history can contain any merges. If false, 
    uses the fastest and the simplest graphing algorithm: “just draw a line in 
    a first column”.
    This key is optional, default value: true.
hexreg :: Regex                                            *aurum-repo.hexreg*
    Determines regular expression which must be matched by any |aurum-cs.hex| 
    value. If present, this |regex| will be used in syntax rules generated by 
    plugin/aurum/log, otherwise two syntax rules will be constructed: one rule 
    that matches exactly 12 first hexadecimal numbers (|/\x|) followed by 
    another rule than matches any positive number of hexadecimal characters 
    and conceals them (requires |+conceal| to work properly).
hasrevisions :: Bool                                 *aurum-repo.hasrevisions*
    Determines whether |aurum-cs.rev| contains something different from 
    abbreviated hash. If this option is false, then in log produced by 
    |aurum://log| revisions will be ignored.
    This key is optional, default value: true.
initprops :: [ propname ]                               *aurum-repo.initprops*
    Contains list of properties that are always set by |aurum-rf-getcs|.
    This key is optional, default value: ["rev", "hex", "parents", "tags", 
    "bookmarks", "branch", "time", "user", "description"]
                                                        *aurum-repo.iterfuncs*
iterfuncs :: {String : {"start": startfunc, "next": nextfunc}}
        startfunc :: repo, opts -> d
         nextfunc :: d -> cs
    Dictionary containing keys "ancestors", "revrange" and "changesets" (all 
    are optional). Each key’s value should in turn contain dictionary 
    containing two keys: "start" and "next", both corresponding values have to 
    be function references:
    1. "start" function must accept |aurum-repo| dictionary and |:AuLog| 
       options dictionary and return something that will be saved (for 
       example, |Dictionary| containing a counter).
       Note due to |E704| error returned value must not be a function 
            reference.
       Note 2: try to omit processsing options dictionary more then it is 
               required to do the job (see below). It will be done in any case 
               by log generator function.
    2. "next" function must accept value returned by "start" function and 
       return |aurum-changeset| object. Returned objects must be sorted in 
       topological order like described under |aurum-rf-getchangesets|.

    Value of "changesets" key will be used to view full repository history.
    Value of "revrange" key will be used to view history between specified 
    revisions (they will be contained in opts.revrange).
    Value of "ancestors" key will be used to view specific changesets 
    ancestors (it will be contained in opts.revision).

    This key is optional, see |aurum-new-driver|. If some of keys inside 
    iterfuncs dictionary are missing they will also be added.
functions :: {String : FRef}                            *aurum-repo.functions*
    Dictionary that contains all driver-specific functions. All functions 
    except |aurum-rf-repo|, |aurum-rf-checkdir| and |aurum-rf-checkremote| 
    accept repository object as its first argument, so it is not mentioned in 
    function descriptions. Here is the list:
  getcs :: hex -> cs                                          *aurum-rf-getcs*
    Returns |aurum-changeset| object which has given hash. See also 
    |aurum-cs.hex|.
  getwork :: () -> cs                                       *aurum-rf-getwork*
    Get changeset object for the working directory revision.
  getnthparent :: hex, n -> [ cs ]                     *aurum-rf-getnthparent*
    Get nth generation grand-parent of given revision. Use negative n to get 
    nth generation child instead.
  getchangesets :: () -> [ cs ]                       *aurum-rf-getchangesets*
    Pull all changesets contained in repository into |aurum-repo.changesets| 
    dictionary. If this function is not called, then |aurum-repo.changesets| 
    dictionary contains only changesets that were used at least ones. Returns 
    list of pulled changesets. This list should be sorted in topological order 
    (thus meaning that every changeset appears before every its parent) or 
    |aurum-repo.requires_sort| should be set to true.
  revrange :: hex, hex -> [ cs ]                           *aurum-rf-revrange*
    Get revision range (inclusive).
  updatechangesets :: () -> _                      *aurum-rf-updatechangesets*
    Updates data stored in repository. Is called automatically if 
    |aurum-repo.cslist| is not empty when you get the repository object unless 
    this object is obtained from cash used by |aurum#repository()|.
  getrevhex :: csdescr -> hex                             *aurum-rf-getrevhex*
    Given some changeset description (it may be tag, bookmark, branch name, 
    revision number, ... - whatever VCS supports) get changeset hash.
    Note that functions mentioned above may support not only revision hashes 
         in place of {hex} arguments, but also whatever “getrevhex” supports, 
         but this is not guaranteed. For example, status() accepts revision 
         number in both mercurial drivers, but though zero is a valid 
         revision, it is used to indicate absence of an argument and thus you 
         have to write "0" (String) where you want to write just 0 (Number).
  gettiphex :: () -> hex                                  *aurum-rf-gettiphex*
    Get changeset hash of the last revision in a repository.
  getworkhex :: () -> hex                                *aurum-rf-getworkhex*
    Get changeset hash of the working directory revision.
  setcsprop :: cs, propname -> _                          *aurum-rf-setcsprop*
    Function that adds requested property to given changeset. Is used by 
    default |aurum-rf-getcsprop| if changeset dictionary does not contain 
    property with given name.
  getcsprop :: cs | hex, propname -> propvalue            *aurum-rf-getcsprop*
    Returns requested changeset property. Can accept either |aurum-changeset| 
    object or changeset hash. “propname” can be a name of any property 
    described in |aurum-changeset| section, but it should be normally used for 
    pulling properties that are not obtained by |aurum-rf-getcs| by default: 
    “files”, “changes”, “renames”, “copies”, “allfiles”, “chidlren”.
                                                             *aurum-rf-status*
  status :: [hex[, hex[, [ file ][, requiresclean]]]] -> {status : [ file ]}
    Returns dictionary where values are lists of files and keys are 
    "modified", "added" (new tracked files), "removed" (made untracked, not 
    necessary deleted from filesystem), "deleted" (just deleted from 
    filesystem without making files untracked), "unknown" (new untracked 
    files), "ignored" and "clean" (unmodified).
    Specifying 0 instead of any optional argument acts like not specifying 
    this argument.
    Note: “clean” may be empty unless {requiresclean} argument is present and 
          true.
  dirty :: file -> Bool                                       *aurum-rf-dirty*
    Check whether file is “dirty” (meaning that it has changes that can be 
    committed).
                                                             *aurum-rf-commit*
  commit :: message[, [ file ][, user[, date[, closebranch]]]] -> _
    Commit changes made to specified files (default depends on VCS, normally 
    it is “commit changes made to all tracked files (including additions and 
    removes))”. “closebranch” and “force” arguments have Bool type, “user” and 
    “date” are strings. Neither “user” nor “date” argument should have any 
    normalized form, they just should be accepted by VCS.
  branch :: branch, force -> _                               *aurum-rf-branch*
    Create new branch.
  label :: type, label, hex, force, local -> _                *aurum-rf-label*
    Label specific revision (if rev is 0 then remove label).
    Note: if this function accepts label with type {type}, 
          |aurum-rf-getrepoprop| must be able to list labels of this type in 
          property "{type}slist".
  update :: hex, force                                       *aurum-rf-update*
    Update working directory to changeset {hex}.
  move :: force, fdir, file -> _                               *aurum-rf-move*
  copy :: force, fdir, file -> _                               *aurum-rf-copy*
    Move or copy given file or directory (second argument) to given 
    destination (third argument).
    Note: directories are always passed with trailing forward slash.
  add    :: fdir -> _                                        *aurum-rf-add*
  forget :: fdir -> _                                        *aurum-rf-forget*
  remove :: fdir -> _                                        *aurum-rf-remove*
  ignore :: fdir -> _                                        *aurum-rf-ignore*
    Forget, remove, add (make tracked) or ignore (add to .hgignore or 
    something similar) given file or directory. “ignore” function properly 
    escapes file if it happen to contain any wildcards.
    Note: directories are always passed with trailing forward slash.
  ignoreglob :: glob -> _                                *aurum-rf-ignoreglob*
    Add given glob to .hgignore or similar.
                                                               *aurum-rf-grep*
  grep :: pattern, [ file ], [ Either hex (hex, hex) ], ic, wdf -> qflist
    Search repository for given pattern and return results in a list that can 
    be passed to |setqflist()| function with small modifications (see below). 
    Second argument here controls what files should be searched for. Third 
    controls revisions that are to be searched (tuple variant: range of 
    revisions). {ic} determines whether case should be ignored and {wdf} 
    determines whether grep should output files in working directory if they 
    have not changed since found revision.
    Note: If you want to use grep() directly, you should remember that 
          “filename” key may contain either an absolute filename or pair 
          (revision, filename (relative to repository root)). Second is to be 
          transformed into |aurum://file| path.
  readfile :: repo, hex, file -> [ String ]                *aurum-rf-readfile*
    Returns a list of strings (similar to |readfile()| output with "b" flag 
    set) that contains file contents as it was at given revision.
  annotate :: repo, hex, file -> [ rev ]                   *aurum-rf-annotate*
    Returns a list of 3-tuples: ({hex}, {file}, {line-number}), one 3-tuple 
    for each line of the file as it was at given changeset. {hex} must be 
    anything supported by |aurum-rf-getcs|, {file} is a filename (in case this 
    function is able to track copies or renames) and {line-number} is number 
    of the corresponding line in that file as it was at that revision.
    If {line-number} is 0, then |aurum://annotate| mappings will use line 
    contents to search for the same line in another revision.
  diff :: hex, hex, [ file ], diffopts -> [ String ]           *aurum-rf-diff*
    Returns list of strings (similar to |readfile()| output with "b" flag set) 
    that contains changes made to given files between given revisions. If list 
    of files is empty, then changes made to all files will be returned. See 
    |aurum-diffopts| for description of {diffopts} argument.
                                                       *aurum-rf-difftobuffer*
  difftobuffer :: bufnr, hex, hex, [ file ], diffopts -> + buffer
    Like writing output of |aurum-rf-diff| to specified buffer.
  diffre :: diffopts -> regex                                *aurum-rf-diffre*
    Returns a regular expression that will be used for searching diff section 
    headers (normally lines starting with ^diff) and obtaining file names from 
    them. Is used by a number of command for obtaining current file name while 
    in diff buffer and also by |aurum-rf-getstats| function.
  diffname :: line, regex, diffopts -> fname               *aurum-rf-diffname*
    Given {line} that matches {regex} returned by |aurum-rf-diffre|, return 
    a filename.
  getstats :: diff, diffopts -> stats                      *aurum-rf-getstats*
    Returns a dictionary describing summary of changes described in {diff} (it 
    is what |aurum-rf-diff| returns). Dictionary will contain the following 
    keys:
    Key         Description ~
    insertions  Number of lines inserted.
    deletions   Number of lines deleted.
    files       Dictionary where keys are file names and values are 
                dictionaries with two keys: “insertions” and “deletions”. They 
                contain same information as above stats keys, but these 
                statistics refers to one file only.
  getrepoprop :: propname -> propvalue                  *aurum-rf-getrepoprop*
    Get some repository property. Supported {propname}s:
    Property name  Description ~
    tagslist, brancheslist, bookmarkslist
                   List of strings containing tags, branches and bookmarks 
                   present in current repo respectively. Is used for 
                   completion in commands that accept {rev} argument and by 
                   |:AuBranch| and |:AuName| in order to check whether branch 
                   can be created/revision can be named.
    url            Remote repository URL. For mercurial it is either 
                   paths.default-push or paths.default whichever is defined.
  reltorepo :: path -> path                               *aurum-rf-reltorepo*
    Turn absolute or relative to current directory path into relative to 
    repository root one.
  push :: dryrun, force[, url[, rev]] -> _                     *aurum-rf-push*
  pull :: dryrun, force[, url[, rev]] -> _                     *aurum-rf-pull*
    Push or pull to given or default URL. If {rev} argument is present, then 
    push/pull only this revision. {dryrun} designates that nothing should be 
    actually done, only what will be done should be shown.
    Note: unlike other functions, this should expect any possible revision 
    specification.
    Note 2: if URL is a directory, it is supposed to be related to repository 
    root, not to current working directory.
The following functions do not accept repo argument:
  repo :: path -> repo                                         *aurum-rf-repo*
    Creates new repository object using repository located at given path.
    Note you must not ever use this directly, this is to be called by repo.get 
         function from plugin/aurum/repo. If you use it directly, you will be 
         missing some setup that will render newly created object useless.
  checkdir    :: path -> Bool                           *aurum-rf-checkdir*
  checkremote :: path -> Bool                           *aurum-rf-checkremote*
    These two functions check whether given path contains repository supported 
    by specific driver. First is called once for each directory in path, 
    ending with root (drive name like “C:” in windows, “/” in POSIX OS’es) and 
    is likely to contain something as simple as >
        function s:driver.checkdir(path)
            return isdirectory(a:path."/.hg")
        endfunction
<   . Second is called once on paths that contain “://” in their string (it is 
    likely to return just 0 because normal work with remote repositories is 
    impossible in most VCS’es).
  getroot :: path -> path|0                                 *aurum-rf-getroot*
    Being given a path for which |aurum-rf-checkdir| returns true should 
    return a repository root.
    If absent acts like the below function, thus considering any directory for 
    which |aurum-rf-checkdir| returns true being a repository root >
        function s:driver.getroot(path)
            return a:path
        endfunction

------------------------------------------------------------------------------
8.2. Changeset                                               *aurum-changeset*

Changeset is a dictionary containing the following keys (some of them may be 
not present by default and will be added only after running 
|aurum-rf-getcsprop|):

Key          Description ~
hex          Unique revision identifier (usually hash)          *aurum-cs.hex*
rev          Revision number                                    *aurum-cs.rev*
time         Time when cs was added (in second since epoch)    *aurum-cs.time*
description  Changeset description                      *aurum-cs.description*
user         Name of the user who added the changeset          *aurum-cs.user*
parents      List of revision parents hashes                *aurum-cs.parents*
children     List of revision children hashes              *aurum-cs.children*
branch       Branch name                                     *aurum-cs.branch*
tags         List of tags associated with the changeset        *aurum-cs.tags*
bookmarks    List of bookmarks associated with the cs     *aurum-cs.bookmarks*
allfiles     List of all files present in the revision     *aurum-cs.allfiles*
files        List of files present in cs that were modified   *aurum-cs.files*
removes      List of files that were deleted in cs          *aurum-cs.removes*
changes      List of files that were modified in cs         *aurum-cs.changes*
             (|aurum-cs.files| + |aurum-cs.removes|)
renames      Dictionary {newname : oldname}                 *aurum-cs.renames*
copies       Dictionary {copyname : originname}              *aurum-cs.copies*

==============================================================================
9. Creating your own driver                                 *aurum-new-driver*
                                                           *aurum-f-regdriver*
In order to create driver you must use “regdriver” feature defined in 
plugin/aurum/repo (you must specify it in dependencies and then you will get 
|s:_f|.regdriver() function). This feature accepts two arguments: name of the 
driver (only latin letters, digits and underscores are allowed, see |/\w|) and 
dictionary with repository functions (only function references are allowed):
Required functions: |aurum-rf-repo|, |aurum-rf-getcs|, |aurum-rf-checkdir|.
Optional functions:
  Function               Default behavior ~
  |aurum-rf-getnthparent|  Use |aurum-rf-getcs| and |aurum-rf-getcsprop| 
                         (properties "parents" or "children")
  |aurum-rf-getcsprop|     Checks whether requested key is present in the 
                         changeset object. If yes returns its value, otherwise 
                         calls |aurum-rf-setcsprop|.
  |aurum-rf-dirty|         Use |aurum-rf-status| and check whether file has 
                         status different from “ignored” or “clean”
  |aurum-rf-move|          Uses |aurum-rf-copy| and |aurum-rf-remove| to 
                         emulate renaming command.
  |aurum-rf-copy|          Copies file to destination (using command-line “cp” 
                         (cp -- source target), “copy” (copy source target) or 
                         |readfile()| + |writefile()| (in last case 
                         permissions are not copied)), then uses 
                         |aurum-rf-add| to make destination tracked.
  |aurum-rf-remove|        Uses |aurum-rf-forget| to untrack file and then 
                         |delete()|s it.
  |aurum-rf-grep|          Does just the same what git grep does: iterates 
                         over given revisions and searches for given regular 
                         expression (in this case: vim |regexp|) in each file. 
                         If third argument is empty, then searches working 
                         directory versions of files present in current 
                         changeset. Uses |aurum-rf-getcsprop| (with “allfiles” 
                         argument), |aurum-rf-revrange|, |aurum-rf-getcs| and 
                         |aurum-rf-readfile|.
                         Slow!
  |aurum-rf-difftobuffer|  Wrapper around |aurum-rf-diff|.
  |aurum-rf-diffname|      Uses value of first capturing group of given 
                         regular expression.
  |aurum-rf-getstats|      Parses git-like unified diff, depends on 
                         |aurum-rf-diffre| and |aurum-rf-diffname|.
  |aurum-rf-reltorepo|     Uses |aurum-repo.path| to get requested path.
  |aurum-rf-checkremote|   Returns 0.
  |aurum-repo.iterfuncs|   "changeset": Uses |aurum-rf-getchangesets|
                         "revrange": Uses |aurum-rf-revrange|
                         "ancestors": Iterates recursively over 
                                      |aurum-cs.parents|, parents of the 
                                      parents and so on.
Other functions, mentioned in |aurum-repo.functions|, but not mentioned here, 
throw an "nimp" exception.

==============================================================================
10. Notes about various driver implementations            *aurum-driver-notes*

------------------------------------------------------------------------------
10.1. Mercurial                                       *aurum-driver-Mercurial*

|aurum-rf-label|:
    Supported labels: tag (non-local/local), bookmark (non-local).

|aurum-repo.hypsites|:
    1. When processing various git repositories checked out using hg-git 
       (http://hg-git.github.com/) it is assumed that |aurum-cs.hex| can be 
       replaced with first bookmark or first tag that starts with "default/" 
       with "default/" part removed.
    2. Svn revisions are not supported at all, |aurum-cs.hex| in driver is 
       replaced with static string "HEAD".
|aurum-rf-status|: For non-python driver this function does not support names 
    containing newlines.
|aurum-rf-grep|: For non-python driver filenames that look like 
    {smth}:{num>=0}:{num>0} are not supported and will lead to invalid 
    results.
*aurum-rf-svnrev* exists and produces svn revision number out of repository 
    object and mercurial revision specification.
*aurum-rf-githex* exists and produces git sha1 out of repository object and 
    mercurial revision specification. This function is present only when using 
    python version of driver.
Python driver was not tested under windows (wine) at all.

------------------------------------------------------------------------------
10.2. Git                                                   *aurum-driver-Git*

|aurum-rf-label|: Supported labels: tag, branch (both non-local).

|aurum-cs.branch| always contains string "default".
|aurum-cs.tags| contains list of all references pointing to given commit, not 
    just tags.
|aurum-cs.rev| contains truncated hash (for use in |aurum://annotate|).
|aurum-repo.cslist| is always empty
|aurum-rf-status|: if at least one of first two optional arguments is 
    non-zero, then then unknown and deleted files won’t be shown (if any). 
    Ignored files are not shown in any case.
|aurum-rf-gettiphex|: Same as |aurum-rf-getworkhex|.
|aurum-rf-diff|: Options "git", "iblanks", "showfunc", "dates" are not 
    supported.
|aurum-rf-checkdir| does not support bare repositories.
|aurum-rf-setcsprop|: is not able to get real renames, copies, changes, files 
    and removes for merge changesets (“real” here means “generated by merge 
    conflicts”: if file A was modified in both parents, then it is to be 
    listed in merge_cs.changes only if git was unable to merge changes and had 
    to ask user to do this).
|aurum-rf-getchangesets| is not modifying |aurum-repo.cslist|.
|aurum-rf-grep| will either search working directory (if no revisions were 
    given) or given revisions (mercurial driver is searching all revisions if 
    no revisions are given). Unlike mercurial where matching line will be 
    shown only if they were found in first revision in range or in line that 
    was added/modified in given revision, with this function you will see all 
    matches in all revisions.
    Note: This function always uses extended regular expressions.
|aurum-rf-annotate| won’t output annotation of file in working directory, it 
    is always returning annotation of file at given revision.
|aurum-rf-update| will avoid “detached HEAD” state whenever possible. In order 
    to make this behavior sensible it has a hack for |:AuUpdate| with branch 
    name as an argument, but it may also search .git/refs/heads for {hex} 
    argument and use first found file with contents equal to {hex} as a branch 
    name.

------------------------------------------------------------------------------
10.3. Subversion                                     *aurum-driver-Subversion*

|aurum-rf-label|, |aurum-rf-branch| are not supported.

|aurum-cs.branch| always contains string "default".
|aurum-cs.rev| and |aurum-cs.hex| have the same value, though second one is 
    a string.
|aurum-cs.time| is always 0 if “date” programm from coreutils is missing.
|aurum-cs.hex| contains the stringified value of |aurum-cs.rev| and thus is 
    not fixed-length.
|aurum-repo.cslist|: repo.cslist[cs.rev] is any revision with .rev≥cs.rev, not 
    necessary cs itself.
|aurum-rf-diff|: Options "git", "iblanks", "dates", "alltext" are not 
    supported, option "reverse" is supported only if two revisions are given.
|aurum-rf-status|: if at least one of first two optional arguments is 
    non-zero, then then unknown and deleted files won’t be shown (if any). 
    Ignored files are not shown in any case.
    Note: this function may output directories in a list.
|aurum-rf-annotate| neither tracks renames/copies nor is able to output line 
    numbers.
|aurum-rf-grep| uses internal grep implementation based on 
    |aurum-rf-readfile|. Thus it is slow, but supports vim |regexp|.
    See more in |aurum-f-regdriver|.
|aurum-rf-ignoreglob| uses “svn propset svn:ignore” and thus is limited to 
    non-recursive globs applying to exactly one directory: ignoring 
    “subdir*/ignored*” will ignore all files with names starting with 
    “ignored” in a directory “subdir*”, which is probably not what you 
    initially wanted.

==============================================================================
11. Changelog                                                *aurum-changelog*

@aurum/repo (reflects all drivers’ API changes):
    1.0: Instead of depending on drivers, make drivers depend on @aurum/repo
    1.1: Added repo.branch and repo.label
    1.2: Added setlines function, default implementations of |aurum-rf-copy|, 
         |aurum-rf-getstats|, |aurum-rf-getcsprop| and |aurum-rf-diffname|.
    1.3: Added default implementation of |aurum-rf-revrange|.
    2.0: Purged support of numeric ranges out of |aurum-rf-revrange|, returned 
         value of |aurum-rf-getchangesets| is not stated as ignored.
    2.1: Added |aurum-repo.iterfuncs| support.
    2.2: Added |aurum-repo.initprops|.
    2.3: Added |aurum-rf-getroot| support.
    2.4: Added {requiresclean} argument to |aurum-rf-status|.
    2.5: Added parsecmdarg and crnl resources
    3.0: Moved setlines and some other functions to @aurum/lineutils
    3.1: Added |aurum-rf-push| and |aurum-rf-pull|
@aurum:
    0.1: Added |:AuBranch| and |:AuName|.
    0.2: Added |:AuOther|.
@aurum/edit:
    1.0: Removed setlines function (moved it to @aurum/repo).
    1.1: Added “requiresbvar” _f.newcommand option.
    1.2: Added “mgroup” _f.newcommand option and mrun resource
@aurum/vimdiff:
    0.1: Added full, untracked, onlymodified and files options to |:AuVimDiff|
    0.2: Added _r.vimdiff.full.
@aurum/log:
    0.1: Added |aurum-style-git| and |aurum-style-gitoneline| log styles, 
         added skipping of $rev if |aurum-repo.hasrevisions| is false, made it 
         separate graph from content using non-breaking spaces.
    0.2: Added |:AuLog| procinput option.
    0.3: Added @-@ and @.@ expr “variables”.
@aurum/status:
    1.0: Renamed |:AuStatus| “rev1” and “rev2” options to “rev” and “wdrev” 
         respectively. Same for |aurum://status| “rev1” and “rev2” options.
@aurum/commit:
    1.0: Added fifth argument to _r.commit.commit()
@aurum/annotate:
    1.0: Removed one argument to _r.annotate.setannbuf()

vim: ft=help:tw=78
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.