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
|
---
author:
- Albert Krewinkel
- John MacFarlane
date: 'December 6, 2017'
title: Pandoc Lua Filters
---
# Introduction
Pandoc has long supported filters, which allow the pandoc
abstract syntax tree (AST) to be manipulated between the parsing
and the writing phase. Traditional pandoc filters accept a JSON
representation of the pandoc AST and produce an altered JSON
representation of the AST. They may be written in any
programming language, and invoked from pandoc using the
`--filter` option.
Although traditional filters are very flexible, they have a
couple of disadvantages. First, there is some overhead in
writing JSON to stdout and reading it from stdin (twice, once on
each side of the filter). Second, whether a filter will work
will depend on details of the user's environment. A filter may
require an interpreter for a certain programming language to be
available, as well as a library for manipulating the pandoc AST
in JSON form. One cannot simply provide a filter that can be
used by anyone who has a certain version of the pandoc
executable.
Starting with pandoc 2.0, we have made it possible to write
filters in lua without any external dependencies at all. A lua
interpreter and a lua library for creating pandoc filters is
built into the pandoc executable. Pandoc data types are
marshalled to lua directly, avoiding the overhead of writing
JSON to stdout and reading it from stdin.
Here is an example of a lua filter that converts strong emphasis
to small caps:
``` {.lua}
return {
{
Strong = function (elem)
return pandoc.SmallCaps(elem.c)
end,
}
}
```
or equivalently,
``` {.lua}
function Strong(elem)
return pandoc.SmallCaps(elem.c)
end
```
This says: walk the AST, and when you find a Strong element,
replace it with a SmallCaps element with the same content.
To run it, save it in a file, say `smallcaps.lua`, and invoke
pandoc with `--lua-filter=smallcaps.lua`.
Here's a quick performance comparison, using a version of the
pandoc manual, MANUAL.txt, and versions of the same filter
written in compiled Haskell (`smallcaps`) and interpreted Python
(`smallcaps.py`):
Command Time
-------------------------------------------------- -------
`pandoc MANUAL.txt` 1.01s
`pandoc MANUAL.txt --filter ./smallcaps` 1.36s
`pandoc MANUAL.txt --filter ./smallcaps.py` 1.40s
`pandoc MANUAL.txt --lua-filter ./smallcaps.lua` 1.03s
As you can see, the lua filter avoids the substantial overhead
associated with marshalling to and from JSON over a pipe.
# Lua filter structure
Lua filters are tables with element names as keys and values
consisting of functions acting on those elements.
Filters are expected to be put into separate files and are
passed via the `--lua-filter` command-line argument. For
example, if a filter is defined in a file `current-date.lua`,
then it would be applied like this:
pandoc --lua-filter=current-date.lua -f markdown MANUAL.txt
The `--lua-filter` option may be supplied multiple times. Pandoc
applies all filters (including JSON filters specified via
`--filter` and lua filters specified via `--lua-filter`) in the
order they appear on the command line.
Pandoc expects each lua file to return a list of filters. The
filters in that list are called sequentially, each on the result
of the previous filter. If there is no value returned by the
filter script, then pandoc will try to generate a single filter
by collecting all top-level functions whose names correspond to
those of pandoc elements (e.g., `Str`, `Para`, `Meta`, or
`Pandoc`). (That is why the two examples above are equivalent.)
For each filter, the document is traversed and each element
subjected to the filter. Elements for which the filter contains
an entry (i.e. a function of the same name) are passed to lua
element filtering function. In other words, filter entries will
be called for each corresponding element in the document,
getting the respective element as input.
The return of a filter function must one of the following:
- nil: this means that the object should remain unchanged.
- a pandoc object: this must be of the same type as the input
and will replace the original object.
- a list of pandoc objects: these will replace the original
object; the list is merged with the neighbors of the orignal
objects (spliced into the list the original object belongs
to); returning an empty list deletes the object.
The function's output must result in an element of the same type
as the input. This means a filter function acting on an inline
element must return either nil, an inline, or a list of inlines,
and a function filtering a block element must return one of nil,
a block, or a list of block elements. Pandoc will throw an error
if this condition is violated.
If there is no function matching the element's node type, then
the filtering system will look for a more general fallback
function. Two fallback functions are supported, `Inline` and
`Block`. Each matches elements of the respective type.
Elements without matching functions are left untouched.
See [module documentation](#module-pandoc) for a list of pandoc
elements.
## Global variables
Pandoc passes additional data to Lua filters by setting global
variables.
`FORMAT`
: The global `FORMAT` is set to the format of the pandoc
writer being used (`html5`, `latex`, etc.), so the behavior
of a filter can be made conditional on the eventual output
format.
`PANDOC_READER_OPTIONS`
: Table of the options which were provided to the parser.
`PANDOC_VERSION`
: Contains the pandoc version as a numerically indexed table,
most significant number first. E.g., for pandoc 2.1.1, the
value of the variable is a table `{2, 1, 1}`. Use
`table.concat(PANDOC_VERSION, '.')` to produce a version
string. This variable is also set in custom writers.
`PANDOC_API_VERSION`
: Contains the version of the pandoc-types API against which
pandoc was compiled. It is given as a numerically indexed
table, most significant number first. E.g., if pandoc was
compiled against pandoc-types 1.17.3, then the value of the
variable will be a table `{1, 17, 3}`. Use
`table.concat(PANDOC_API_VERSION, '.')` to produce a version
string from this table. This variable is also set in custom
writers.
`PANDOC_SCRIPT_FILE`
: The name used to involve the filter. This value can be used
to find files relative to the script file. This variable is
also set in custom writers.
# Pandoc Module
The `pandoc` lua module is loaded into the filter's lua
environment and provides a set of functions and constants to
make creation and manipulation of elements easier. The global
variable `pandoc` is bound to the module and should generally
not be overwritten for this reason.
Two major functionalities are provided by the module: element
creator functions and access to some of pandoc's main
functionalities.
## Element creation
Element creator functions like `Str`, `Para`, and `Pandoc` are
designed to allow easy creation of new elements that are simple
to use and can be read back from the lua environment.
Internally, pandoc uses these functions to create the lua
objects which are passed to element filter functions. This means
that elements created via this module will behave exactly as
those elements accessible through the filter function parameter.
## Exposed pandoc functionality
Some pandoc functions have been made available in lua:
- [`walk_block`](#walk_block) and
[`walk_inline`](#walk_inline) allow filters to be applied
inside specific block or inline elements;
- [`read`](#read) allows filters to parse strings into pandoc
documents;
- [`pipe`](#pipe) runs an external command with input from and
output to strings;
- the [`pandoc.mediabag`](#module-pandoc.mediabag) module
allows access to the "mediabag," which stores binary content
such as images that may be included in the final document;
- the [`pandoc.utils`](#module-pandoc.utils) module contains
various utility functions.
# Lua interpreter initialization
The way the Lua interpreter is set-up can be controlled by
placing a file `init.lua` in pandoc's data directory. The
default init file loads the `pandoc` and `pandoc.mediabag`
modules:
``` {.lua}
pandoc = require 'pandoc'
pandoc.mediabag = require 'pandoc.mediabag'
```
A common use-case would be to add code to load additional
modules or to alter default modules. E.g., the following snippet
adds all unicode-aware functions defined in the [`text`
module](#module-text) to the default `string` module, prefixed
with the string `uc_`.
``` {.lua}
for name, fn in pairs(require 'text') do
string['uc_' .. name] = fn
end
```
This makes it possible to apply these functions on strings using
colon syntax (`mystring:uc_upper()`).
# Examples
## Macro substitution.
The following filter converts the string `{{helloworld}}` into
emphasized text "Hello, World".
``` {.lua}
return {
{
Str = function (elem)
if elem.text == "{{helloworld}}" then
return pandoc.Emph {pandoc.Str "Hello, World"}
else
return elem
end
end,
}
}
```
## Default metadata file
This filter causes metadata defined in an external file
(`metadata-file.yaml`) to be used as default values in a
document's metadata:
``` {.lua}
-- read metadata file into string
local metafile = io.open('metadata-file.yaml', 'r')
local content = metafile:read("*a")
metafile:close()
-- get metadata
local default_meta = pandoc.read(content, "markdown").meta
return {
{
Meta = function(meta)
-- use default metadata field if it hasn't been defined yet.
for k, v in pairs(default_meta) do
if meta[k] == nil then
meta[k] = v
end
end
return meta
end,
}
```
## Setting the date in the metadata
This filter sets the date in the document's metadata to the
current date:
``` {.lua}
function Meta(m)
m.date = os.date("%B %e, %Y")
return m
end
```
## Extracting information about links
This filter prints a table of all the URLs linked to in the
document, together with the number of links to that URL.
``` {.lua}
links = {}
function Link (el)
if links[el.target] then
links[el.target] = links[el.target] + 1
else
links[el.target] = 1
end
return el
end
function Doc (blocks, meta)
function strCell(str)
return {pandoc.Plain{pandoc.Str(str)}}
end
local caption = {pandoc.Str "Link", pandoc.Space(), pandoc.Str "count"}
local aligns = {pandoc.AlignDefault, pandoc.AlignLeft}
local widths = {0.8, 0.2}
local headers = {strCell "Target", strCell "Count"}
local rows = {}
for link, count in pairs(links) do
rows[#rows + 1] = {strCell(link), strCell(count)}
end
return pandoc.Doc(
{pandoc.Table(caption, aligns, widths, headers, rows)},
meta
)
end
```
## Replacing placeholders with their metadata value
Lua filter functions are run in the order
> *Inlines → Blocks → Meta → Pandoc*.
Passing information from a higher level (e.g., metadata) to a
lower level (e.g., inlines) is still possible by using two
filters living in the same file:
``` {.lua}
local vars = {}
function get_vars (meta)
for k, v in pairs(meta) do
if v.t == 'MetaInlines' then
vars["$" .. k .. "$"] = {table.unpack(v)}
end
end
end
function replace (el)
if vars[el.text] then
return pandoc.Span(vars[el.text])
else
return el
end
end
return {{Meta = get_vars}, {Str = replace}}
```
If the contents of file `occupations.md` is
``` {.markdown}
---
name: Samuel Q. Smith
occupation: Professor of Phrenology
---
Name
: \$name\$
Occupation
: \$occupation\$
```
then running `pandoc --lua-filter=meta-vars.lua occupations.md`
will output:
``` {.html}
<dl>
<dt>Name</dt>
<dd><p><span>Samuel Q. Smith</span></p>
</dd>
<dt>Occupation</dt>
<dd><p><span>Professor of Phrenology</span></p>
</dd>
</dl>
```
## Modifying pandoc's `MANUAL.txt` for man pages
This is the filter we use when converting `MANUAL.txt` to man
pages. It converts level-1 headers to uppercase (using
`walk_block` to transform inline elements inside headers),
removes footnotes, and replaces links with regular text.
``` {.lua}
-- we use preloaded text to get a UTF-8 aware 'upper' function
local text = require('text')
function Header(el)
if el.level == 1 then
return pandoc.walk_block(el, {
Str = function(el)
return pandoc.Str(text.upper(el.text))
end })
end
end
function Link(el)
return el.content
end
function Note(el)
return {}
end
```
## Creating a handout from a paper
This filter extracts all the numbered examples, section headers,
block quotes, and figures from a document, in addition to any
divs with class `handout`. (Note that only blocks at the "outer
level" are included; this ignores blocks inside nested
constructs, like list items.)
``` {.lua}
-- creates a handout from an article, using its headings,
-- blockquotes, numbered examples, figures, and any
-- Divs with class "handout"
function Pandoc(doc)
local hblocks = {}
for i,el in pairs(doc.blocks) do
if (el.t == "Div" and el.classes[1] == "handout") or
(el.t == "BlockQuote") or
(el.t == "OrderedList" and el.style == "Example") or
(el.t == "Para" and #el.c == 1 and el.c[1].t == "Image") or
(el.t == "Header") then
table.insert(hblocks, el)
end
end
return pandoc.Pandoc(hblocks, doc.meta)
end
```
## Counting words in a document
This filter counts the words in the body of a document (omitting
metadata like titles and abstracts), including words in code. It
should be more accurate than `wc -w` run directly on a Markdown
document, since the latter will count markup characters, like
the `#` in front of an ATX header, or tags in HTML documents, as
words. To run it, `pandoc --lua-filter wordcount.lua myfile.md`.
``` {.lua}
-- counts words in a document
words = 0
wordcount = {
Str = function(el)
-- we don't count a word if it's entirely punctuation:
if el.text:match("%P") then
words = words + 1
end
end,
Code = function(el)
_,n = el.text:gsub("%S+","")
words = words + n
end,
CodeBlock = function(el)
_,n = el.text:gsub("%S+","")
words = words + n
end
}
function Pandoc(el)
-- skip metadata, just count body:
pandoc.walk_block(pandoc.Div(el.blocks), wordcount)
print(words .. " words in body")
os.exit(0)
end
```
## Converting ABC code to music notation
This filter replaces code blocks with class `abc` with images
created by running their contents through `abcm2ps` and
ImageMagick's `convert`. (For more on ABC notation, see
<http://abcnotation.com>.)
Images are added to the mediabag. For output to binary formats,
pandoc will use images in the mediabag. For textual formats, use
`--extract-media` to specify a directory where the files in the
mediabag will be written, or (for HTML only) use
`--self-contained`.
``` {.lua}
-- Pandoc filter to process code blocks with class "abc" containing
-- ABC notation into images.
--
-- * Assumes that abcm2ps and ImageMagick's convert are in the path.
-- * For textual output formats, use --extract-media=abc-images
-- * For HTML formats, you may alternatively use --self-contained
local filetypes = { html = {"png", "image/png"}
, latex = {"pdf", "application/pdf"}
}
local filetype = filetypes[FORMAT][1] or "png"
local mimetype = filetypes[FORMAT][2] or "image/png"
local function abc2eps(abc, filetype)
local eps = pandoc.pipe("abcm2ps", {"-q", "-O", "-", "-"}, abc)
local final = pandoc.pipe("convert", {"-", filetype .. ":-"}, eps)
return final
end
function CodeBlock(block)
if block.classes[1] == "abc" then
local img = abc2eps(block.text, filetype)
local fname = pandoc.sha1(img) .. "." .. filetype
pandoc.mediabag.insert(fname, mimetype, img)
return pandoc.Para{ pandoc.Image({pandoc.Str("abc tune")}, fname) }
end
end
```
## Building images with tikz
This filter converts raw LaTeX tikz environments into images. It
works with both PDF and HTML output. The tikz code is compiled
to an image using `pdflatex`, and the image is converted (if
necessary) from pdf to png format using ImageMagick's `convert`,
so both of these must be in the system path. Converted images
are cached in the working directory and given filenames based on
a hash of the source, so that they need not be regenerated each
time the document is built. (A more sophisticated version of
this might put these in a special cache directory.)
``` {.lua}
local function tikz2image(src, filetype, outfile)
local tmp = os.tmpname()
local tmpdir = string.match(tmp, "^(.*[\\/])") or "."
local f = io.open(tmp .. ".tex", 'w')
f:write("\\documentclass{standalone}\n\\usepackage{tikz}\n\\begin{document}\n")
f:write(src)
f:write("\n\\end{document}\n")
f:close()
os.execute("pdflatex -output-directory " .. tmpdir .. " " .. tmp)
if filetype == 'pdf' then
os.rename(tmp .. ".pdf", outfile)
else
os.execute("convert " .. tmp .. ".pdf " .. outfile)
end
os.remove(tmp .. ".tex")
os.remove(tmp .. ".pdf")
os.remove(tmp .. ".log")
os.remove(tmp .. ".aux")
end
extension_for = {
html = 'png',
html4 = 'png',
html5 = 'png',
latex = 'pdf',
beamer = 'pdf' }
local function file_exists(name)
local f = io.open(name, 'r')
if f ~= nil then
io.close(f)
return true
else
return false
end
end
function RawBlock(el)
local filetype = extension_for[FORMAT] or "png"
local fname = pandoc.sha1(el.text) .. "." .. filetype
if not file_exists(fname) then
tikz2image(el.text, filetype, fname)
end
return pandoc.Para({pandoc.Image({}, fname)})
end
```
Example of use:
pandoc --lua-filter tikz.lua -s -o cycle.html <<EOF
Here is a diagram of the cycle:
\begin{tikzpicture}
\def \n {5}
\def \radius {3cm}
\def \margin {8} % margin in angles, depends on the radius
\foreach \s in {1,...,\n}
{
\node[draw, circle] at ({360/\n * (\s - 1)}:\radius) {$\s$};
\draw[->, >=latex] ({360/\n * (\s - 1)+\margin}:\radius)
arc ({360/\n * (\s - 1)+\margin}:{360/\n * (\s)-\margin}:\radius);
}
\end{tikzpicture}
EOF
# Module text
UTF-8 aware text manipulation functions, implemented in Haskell.
These are available to any lua filter. However, the module must
be explicitly loaded:
``` {.lua}
-- uppercase all regular text in a document:
text = require 'text'
function Str (s)
s.text = text.upper(s.text)
return s
end
```
[`lower (s)`]{#text-lower}
: Returns a copy of a UTF-8 string, converted to lowercase.
[`upper (s)`]{#text-upper}
: Returns a copy of a UTF-8 string, converted to uppercase.
[`reverse (s)`]{#text-reverse}
: Returns a copy of a UTF-8 string, with characters reversed.
[`len (s)`]{#text-len}
: Returns the length of a UTF-8 string.
[`sub (s)`]{#text-sub}
: Returns a substring of a UTF-8 string, using lua's string
indexing rules.
# Module pandoc
Lua functions for pandoc scripts.
## Pandoc Document
[`Pandoc (blocks[, meta])`]{#Pandoc}
: A complete pandoc document
Parameters:
`blocks`:
: document content
`meta`:
: document meta data
## Meta
[`Meta (table)`]{#Meta}
: Create a new Meta object.
Parameters:
`table`:
: table containing document meta information
## MetaValue
[`MetaBlocks (blocks)`]{#MetaBlocks}
: Meta blocks
Parameters:
`blocks`:
: blocks
[`MetaInlines (inlines)`]{#MetaInlines}
: Meta inlines
Parameters:
`inlines`:
: inlines
[`MetaList (meta_values)`]{#MetaList}
: Meta list
Parameters:
`meta_values`:
: list of meta values
[`MetaMap (key_value_map)`]{#MetaMap}
: Meta map
Parameters:
`key_value_map`:
: a string-indexed map of meta values
[`MetaString (str)`]{#MetaString}
: Creates string to be used in meta data.
Parameters:
`str`:
: string value
[`MetaBool (bool)`]{#MetaBool}
: Creates boolean to be used in meta data.
Parameters:
`bool`:
: boolean value
## Blocks
[`Block`]{#Block}
: Block elements
[`BlockQuote (content)`]{#BlockQuote}
: Creates a block quote element
Parameters:
`content`:
: block content
Returns: block quote element
[`BulletList (content)`]{#BulletList}
: Creates a bullet (i.e.
Parameters:
`content`:
: list of items
Returns: bullet list element
[`CodeBlock (text[, attr])`]{#CodeBlock}
: Creates a code block element
Parameters:
`text`:
: code string
`attr`:
: element attributes
Returns: code block element
[`DefinitionList (content)`]{#DefinitionList}
: Creates a definition list, containing terms and their
explanation.
Parameters:
`content`:
: list of items
Returns: definition list element
[`Div (content[, attr])`]{#Div}
: Creates a div element
Parameters:
`content`:
: block content
`attr`:
: element attributes
Returns: div element
[`Header (level, content[, attr])`]{#Header}
: Creates a header element.
Parameters:
`level`:
: header level
`content`:
: inline content
`attr`:
: element attributes
Returns: header element
[`HorizontalRule ()`]{#HorizontalRule}
: Creates a horizontal rule.
Returns: horizontal rule
[`LineBlock (content)`]{#LineBlock}
: Creates a line block element.
Parameters:
`content`:
: inline content
Returns: line block element
[`Null ()`]{#Null}
: Creates a null element.
Returns: null element
[`OrderedList (items[, listAttributes])`]{#OrderedList}
: Creates an ordered list.
Parameters:
`items`:
: list items
`listAttributes`:
: list parameters
Returns: ordered list element
[`Para (content)`]{#Para}
: Creates a para element.
Parameters:
`content`:
: inline content
Returns: paragraph element
[`Plain (content)`]{#Plain}
: Creates a plain element.
Parameters:
`content`:
: inline content
Returns: plain element
[`RawBlock (format, text)`]{#RawBlock}
: Creates a raw content block of the specified format.
Parameters:
`format`:
: format of content
`text`:
: string content
Returns: raw block element
[`Table (caption, aligns, widths, headers, rows)`]{#Table}
: Creates a table element.
Parameters:
`caption`:
: table caption
`aligns`:
: alignments
`widths`:
: column widths
`headers`:
: header row
`rows`:
: table rows
Returns: table element
## Inline
[`Inline`]{#Inline}
: Inline element class
[`Cite (content, citations)`]{#Cite}
: Creates a Cite inline element
Parameters:
`content`:
: List of inlines
`citations`:
: List of citations
Returns: citations element
[`Code (text[, attr])`]{#Code}
: Creates a Code inline element
Parameters:
`text`:
: brief image description
`attr`:
: additional attributes
Returns: code element
[`Emph (content)`]{#Emph}
: Creates an inline element representing emphasised text.
Parameters:
`content`:
: inline content
Returns: emphasis element
[`Image (caption, src[, title[, attr]])`]{#Image}
: Creates a Image inline element
Parameters:
`caption`:
: text used to describe the image
`src`:
: path to the image file
`title`:
: brief image description
`attr`:
: additional attributes
Returns: image element
[`LineBreak ()`]{#LineBreak}
: Create a LineBreak inline element
Returns: linebreak element
[`Link (content, target[, title[, attr]])`]{#Link}
: Creates a link inline element, usually a hyperlink.
Parameters:
`content`:
: text for this link
`target`:
: the link target
`title`:
: brief link description
`attr`:
: additional attributes
Returns: image element
[`Math (mathtype, text)`]{#Math}
: Creates a Math element, either inline or displayed.
Parameters:
`mathtype`:
: rendering specifier
`text`:
: Math content
Returns: Math element
[`DisplayMath (text)`]{#DisplayMath}
: Creates a DisplayMath element (DEPRECATED).
Parameters:
`text`:
: Math content
Returns: Math element
[`InlineMath (text)`]{#InlineMath}
: Creates an InlineMath inline element (DEPRECATED).
Parameters:
`text`:
: Math content
Returns: Math element
[`Note (content)`]{#Note}
: Creates a Note inline element
Parameters:
`content`:
: footnote block content
[`Quoted (quotetype, content)`]{#Quoted}
: Creates a Quoted inline element given the quote type and
quoted content.
Parameters:
`quotetype`:
: type of quotes to be used
`content`:
: inline content
Returns: quoted element
[`SingleQuoted (content)`]{#SingleQuoted}
: Creates a single-quoted inline element (DEPRECATED).
Parameters:
`content`:
: inline content
Returns: quoted element
See also: [Quoted](#Quoted)
[`DoubleQuoted (content)`]{#DoubleQuoted}
: Creates a single-quoted inline element (DEPRECATED).
Parameters:
`content`:
: inline content
Returns: quoted element
See also: [Quoted](#Quoted)
[`RawInline (format, text)`]{#RawInline}
: Creates a RawInline inline element
Parameters:
`format`:
: format of the contents
`text`:
: string content
Returns: raw inline element
[`SmallCaps (content)`]{#SmallCaps}
: Creates text rendered in small caps
Parameters:
`content`:
: inline content
Returns: smallcaps element
[`SoftBreak ()`]{#SoftBreak}
: Creates a SoftBreak inline element.
Returns: softbreak element
[`Space ()`]{#Space}
: Create a Space inline element
Returns: space element
[`Span (content[, attr])`]{#Span}
: Creates a Span inline element
Parameters:
`content`:
: inline content
`attr`:
: additional attributes
Returns: span element
[`Str (text)`]{#Str}
: Creates a Str inline element
Parameters:
`text`:
: content
Returns: string element
[`Strikeout (content)`]{#Strikeout}
: Creates text which is striked out.
Parameters:
`content`:
: inline content
Returns: strikeout element
[`Strong (content)`]{#Strong}
: Creates a Strong element, whose text is usually displayed in
a bold font.
Parameters:
`content`:
: inline content
Returns: strong element
[`Subscript (content)`]{#Subscript}
: Creates a Subscript inline element
Parameters:
`content`:
: inline content
Returns: subscript element
[`Superscript (content)`]{#Superscript}
: Creates a Superscript inline element
Parameters:
`content`:
: inline content
Returns: strong element
## Element components
[`Attr ([identifier[, classes[, attributes]]])`]{#Attr}
: Create a new set of attributes (Attr).
Parameters:
`identifier`:
: element identifier
`classes`:
: element classes
`attributes`:
: table containing string keys and values
Returns: element attributes
[`Citation (id, mode[, prefix[, suffix[, note_num[, hash]]]])`]{#Citation}
: Creates a single citation.
Parameters:
`id`:
: citation identifier (like a bibtex key)
`mode`:
: citation mode
`prefix`:
: citation prefix
`suffix`:
: citation suffix
`note_num`:
: note number
`hash`:
: hash number
## Constants
[`AuthorInText`]{#AuthorInText}
: Author name is mentioned in the text.
See also: [Citation](#Citation)
[`SuppressAuthor`]{#SuppressAuthor}
: Author name is suppressed.
See also: [Citation](#Citation)
[`NormalCitation`]{#NormalCitation}
: Default citation style is used.
See also: [Citation](#Citation)
[`AlignLeft`]{#AlignLeft}
: Table cells aligned left.
See also: [Table](#Table)
[`AlignRight`]{#AlignRight}
: Table cells right-aligned.
See also: [Table](#Table)
[`AlignCenter`]{#AlignCenter}
: Table cell content is centered.
See also: [Table](#Table)
[`AlignDefault`]{#AlignDefault}
: Table cells are alignment is unaltered.
See also: [Table](#Table)
[`DefaultDelim`]{#DefaultDelim}
: Default list number delimiters are used.
See also: [OrderedList](#OrderedList)
[`Period`]{#Period}
: List numbers are delimited by a period.
See also: [OrderedList](#OrderedList)
[`OneParen`]{#OneParen}
: List numbers are delimited by a single parenthesis.
See also: [OrderedList](#OrderedList)
[`TwoParens`]{#TwoParens}
: List numbers are delimited by a double parentheses.
See also: [OrderedList](#OrderedList)
[`DefaultStyle`]{#DefaultStyle}
: List are numbered in the default style
See also: [OrderedList](#OrderedList)
[`Example`]{#Example}
: List items are numbered as examples.
See also: [OrderedList](#OrderedList)
[`Decimal`]{#Decimal}
: List are numbered using decimal integers.
See also: [OrderedList](#OrderedList)
[`LowerRoman`]{#LowerRoman}
: List are numbered using lower-case roman numerals.
See also: [OrderedList](#OrderedList)
[`UpperRoman`]{#UpperRoman}
: List are numbered using upper-case roman numerals
See also: [OrderedList](#OrderedList)
[`LowerAlpha`]{#LowerAlpha}
: List are numbered using lower-case alphabetic characters.
See also: [OrderedList](#OrderedList)
[`UpperAlpha`]{#UpperAlpha}
: List are numbered using upper-case alphabetic characters.
See also: [OrderedList](#OrderedList)
## Helper functions
[`pipe (command, args, input)`]{#pipe}
: Runs command with arguments, passing it some input, and
returns the output.
Returns:
- Output of command.
Raises:
- A table containing the keys `command`, `error_code`, and
`output` is thrown if the command exits with a non-zero
error code.
Usage:
local output = pandoc.pipe("sed", {"-e","s/a/b/"}, "abc")
[`walk_block (element, filter)`]{#walk_block}
: Apply a filter inside a block element, walking its contents.
Parameters:
`element`:
: the block element
`filter`:
: a lua filter (table of functions) to be applied within
the block element
Returns: the transformed block element
[`walk_inline (element, filter)`]{#walk_inline}
: Apply a filter inside an inline element, walking its
contents.
Parameters:
`element`:
: the inline element
`filter`:
: a lua filter (table of functions) to be applied within
the inline element
Returns: the transformed inline element
[`read (markup[, format])`]{#read}
: Parse the given string into a Pandoc document.
Parameters:
`markup`:
: the markup to be parsed
`format`:
: format specification, defaults to \"markdown\".
Returns: pandoc document
Usage:
local org_markup = "/emphasis/" -- Input to be read
local document = pandoc.read(org_markup, "org")
-- Get the first block of the document
local block = document.blocks[1]
-- The inline element in that block is an `Emph`
assert(block.content[1].t == "Emph")
# Module pandoc.utils
This module exposes internal pandoc functions and utility
functions.
[`hierarchicalize (blocks)`]{#utils-hierarchicalize}
: Convert list of blocks into an hierarchical list. An
hierarchical elements is either a normal block (but no
Header), or a `Sec` element. The latter has the following
fields:
- level: level in the document hierarchy;
- numbering: list of integers of length `level`,
specifying the absolute position of the section in the
document;
- attr: section attributes (see [Attr](#Attr));
- contents: nested list of hierarchical elements.
Returns:
- List of hierarchical elements
Usage:
local blocks = {
pandoc.Header(2, pandoc.Str 'first'),
pandoc.Header(2, pandoc.Str 'second'),
}
local elements = pandoc.utils.hierarchicalize(blocks)
print(table.concat(elements[1].numbering, '.')) -- 0.1
print(table.concat(elements[2].numbering, '.')) -- 0.2
[`run_json_filter (doc, filter[, args])`]{#utils-run_json_filter}
: Filter the given doc by passing it through the a JSON filter.
Parameters:
`doc`:
: the Pandoc document to filter
`filter`:
: filter to run
`args`:
: list of arguments passed to the filter. Defaults to
`{FORMAT}`.
Returns:
- ([Pandoc](#Pandoc)) Filtered document
Usage:
-- Assumes `some_blocks` contains blocks for which a
-- separate literature section is required.
local sub_doc = pandoc.Pandoc(some_blocks, metadata)
sub_doc_with_bib = pandoc.utils.run_json_filter(
sub_doc,
'pandoc-citeproc'
)
some_blocks = sub_doc.blocks -- some blocks with bib
[`normalize_date (date_string)`]{#utils-normalize_date}
: Parse a date and convert (if possible) to "YYYY-MM-DD"
format. We limit years to the range 1601-9999 (ISO 8601
accepts greater than or equal to 1583, but MS Word only
accepts dates starting 1601).
Returns:
- A date string, or nil when the conversion failed.
[`sha1 (contents)`]{#utils-sha1}
: Returns the SHA1 has of the contents.
Returns:
- SHA1 hash of the contents.
Usage:
local fp = pandoc.utils.sha1("foobar")
[`stringify (element)`]{#utils-stringify}
: Converts the given element (Pandoc, Meta, Block, or Inline)
into a string with all formatting removed.
Returns:
- A plain string representation of the given element.
Usage:
local inline = pandoc.Emph{pandoc.Str 'Moin'}
-- outputs "Moin"
print(pandoc.utils.stringify(inline))
[`to_roman_numeral (integer)`]{#utils-to_roman_numeral}
: Converts an integer \< 4000 to uppercase roman numeral.
Returns:
- A roman numeral string.
Usage:
local to_roman_numeral = pandoc.utils.to_roman_numeral
local pandoc_birth_year = to_roman_numeral(2006)
-- pandoc_birth_year == 'MMVI'
# Module pandoc.mediabag
The `pandoc.mediabag` module allows accessing pandoc's media
storage. The "media bag" is used when pandoc is called with the
`--extract-media` or `--standalone`/`-s` option.
[`insert (filepath, mime_type, contents)`]{#mediabag-insert}
: Adds a new entry to pandoc's media bag.
Parameters:
`filepath`:
: filename and path relative to the output folder.
`mime_type`:
: the file's MIME type
`contents`:
: the binary contents of the file.
Usage:
local fp = "media/hello.txt"
local mt = "text/plain"
local contents = "Hello, World!"
pandoc.mediabag(fp, mt, contents)
[`list ()`]{#mediabag-list}
: Get a summary of the current media bag contents.
Returns: A list of elements summarizing each entry in the
media bag. The summary item contains the keys `path`,
`type`, and `length`, giving the filepath, MIME type, and
length of contents in bytes, respectively.
Usage:
-- calculate the size of the media bag.
local mb_items = pandoc.mediabag.list()
local sum = 0
for i = 1, #mb_items:
sum = sum + mb_items[i].length
end
print(sum)
[`lookup (filepath)`]{#mediabag-lookup}
: Lookup a media item in the media bag, returning mime type
and contents.
Parameters:
`filepath`:
: name of the file to look up.
Returns:
- the entries MIME type, or nil if the file was not found.
- contents of the file, or nil if the file was not found.
Usage:
local filename = "media/diagram.png"
local mt, contents = pandoc.mediabag.lookup(filename)
[`fetch (source, base_url)`]{#mediabag-fetch}
: Fetches the given source from a URL or local file. Returns
two values: the contents of the file and the mime type (or
an empty string).
Returns:
- the entries MIME type, or nil if the file was not found.
- contents of the file, or nil if the file was not found.
Usage:
local diagram_url = "https://pandoc.org/diagram.jpg"
local contents = pandoc.mediabag.fetch(diagram_url, ".")
# Module pandoc.List
Pandoc\'s List type and helper methods
## Metamethods
[`pandoc.List:__concat (list)`]{#pandoc.List:__concat}
: Concatenates two lists.
Parameters:
`list`:
: second list concatenated to the first
Returns: a new list containing all elements from list1 and
list2
## Methods
[`pandoc.List:clone ()`]{#pandoc.List:clone}
: Returns a (shallow) copy of the list.
[`pandoc.List:includes (needle, init)`]{#pandoc.List:includes}
: Checks if the list has an item equal to the given needle.
Parameters:
`needle`:
: item to search for
`init`:
: index at which the search is started
Returns: true if a list item is equal to the needle, false
otherwise
[`pandoc.List:find (needle, init)`]{#pandoc.List:find}
: Returns the value and index of the first occurrence of the
given item.
Parameters:
`needle`:
: item to search for
`init`:
: index at which the search is started
Returns: first item equal to the needle, or nil if no such
item exists.
[`pandoc.List:find_if (pred, init)`]{#pandoc.List:find_if}
: Returns the value and index of the first element for which
the predicate holds true.
Parameters:
`pred`:
: the predicate function
`init`:
: index at which the search is started
Returns: first item for which \`test\` succeeds, or nil if
no such item exists.
[`pandoc.List:extend (list)`]{#pandoc.List:extend}
: Adds the given list to the end of this list.
Parameters:
`list`:
: list to appended
[`pandoc.List:map (fn)`]{#pandoc.List:map}
: Returns a copy of the current list by applying the given
function to all elements.
Parameters:
`fn`:
: function which is applied to all list items.
[`pandoc.List:filter (pred)`]{#pandoc.List:filter}
: Returns a new list containing all items satisfying a given
condition.
Parameters:
`pred`:
: condition items must satisfy.
Returns: a new list containing all items for which \`test\`
was true.
|