data/pandoc.lua · typeable/pandoc

git.iko.soy/typeable/pandoc

on fbce422 help sign in

typeable/pandoc/data/pandoc.lua

813 lines 24 kB history raw

1--[[

2pandoc.lua

6Permission to use, copy, modify, and/or distribute this software for any purpose

7with or without fee is hereby granted, provided that the above copyright notice

8and this permission notice appear in all copies.

10THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH

11REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

12FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,

13INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

14OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

15TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF

16THIS SOFTWARE.

17]]

19---

20-- Lua functions for pandoc scripts.

21--

22-- @author Albert Krewinkel

24-- @license MIT

25local M = {

26 _VERSION = "0.2.0"

27}

29------------------------------------------------------------------------

30-- The base class for pandoc's AST elements.

31-- @type Element

32-- @local

33local Element = {}

35--- Create a new element subtype

36-- @local

37function Element:make_subtype(o)

38 o = o or {}

39 setmetatable(o, self)

40 self.__index = self

41 return o

42end

44--- Create a new element given its tag and arguments

45-- @local

46function Element:new(tag, ...)

47 local element = { t = tag }

48 local content = {...}

49 -- special case for unary constructors

50 if #content == 1 then

51 element.c = content[1]

52 -- Don't set 'c' field if no further arguments were given. This is important

53 -- for nullary constructors like `Space` and `HorizontalRule`.

54 elseif #content > 0 then

55 element.c = content

56 end

57 setmetatable(element, self)

58 self.__index = self

59 return element

60end

62--- Create a new constructor

63-- @local

64-- @param tag Tag used to identify the constructor

65-- @param fn Function to be called when constructing a new element

66-- @return function that constructs a new element

67function Element:create_constructor(tag, fn, accessors)

68 local constr = self:make_subtype({tag = tag, getters = {}, setters = {}})

70 -- Add accessors to the metatable

71 if type(accessors) == "string" then

72 constr.getters[accessors] = function(elem)

73 return elem.c

74 end

75 constr.setters[accessors] = function(elem, v)

76 elem.c = v

77 end

78 else

79 for i = 1, #(accessors or {}) do

80 if type(accessors[i]) == "string" then

81 constr.getters[accessors[i]] = function(elem)

82 return elem.c[i]

83 end

84 constr.setters[accessors[i]] = function(elem, v)

85 elem.c[i] = v

86 end

87 else -- only two levels of nesting are supported

88 for k, v in ipairs(accessors[i]) do

89 constr.getters[v] = function(elem)

90 return elem.c[i][k]

91 end

92 constr.setters[v] = function(elem, v)

93 elem.c[i][k] = v

94 end

95 end

96 end

97 end

98 end

100 function constr:new(...)

101 local obj = fn(...)

102 setmetatable(obj, self)

103 self.__index = function(t, k)

104 if getmetatable(t).getters[k] then

105 return getmetatable(t).getters[k](t)

106 elseif k == "t" then

107 return getmetatable(t)["tag"]

108 else

109 return getmetatable(t)[k]

110 end

111 end

112 self.__newindex = function(t, k, v)

113 if getmetatable(t).setters[k] then

114 getmetatable(t).setters[k](t, v)

115 else

116 rawset(t, k, v)

117 end

118 end

119 return obj

120 end

121 self.constructor = self.constructor or {}

122 self.constructor[tag] = constr

123 return constr

124end

125

126--- Calls the constructor, creating a new element.

127-- @local

128function Element.__call(t, ...)

129 return t:new(...)

130end

131

132------------------------------------------------------------------------

133--- Pandoc Document

134-- @section document

135

136--- A complete pandoc document

137-- @function Doc

138-- @tparam {Block,...} blocks document content

139-- @tparam[opt] Meta meta document meta data

140function M.Doc(blocks, meta)

141 meta = meta or {}

142 return {

143 ["blocks"] = blocks,

144 ["meta"] = meta,

145 ["pandoc-api-version"] = {1,17,0,5},

146 }

147end

148

149

150------------------------------------------------------------------------

151-- MetaValue

152-- @section MetaValue

153M.MetaValue = Element:make_subtype{}

154M.MetaValue.__call = function(t, ...)

155 return t:new(...)

156end

157--- Meta blocks

158-- @function MetaBlocks

159-- @tparam {Block,...} blocks blocks

160

161--- Meta inlines

162-- @function MetaInlines

163-- @tparam {Inline,...} inlines inlines

164

165--- Meta list

166-- @function MetaList

167-- @tparam {MetaValue,...} meta_values list of meta values

168

169--- Meta map

170-- @function MetaMap

171-- @tparam table a string-index map of meta values

172M.meta_value_types = {

173 "MetaBlocks",

174 "MetaInlines",

175 "MetaList",

176 "MetaMap",

177}

178for i = 1, #M.meta_value_types do

179 M[M.meta_value_types[i]] = M.MetaValue:create_constructor(

180 M.meta_value_types[i],

181 function(content)

182 return content

183 end

184 )

185end

186

187--- Creates string to be used in meta data.

188-- Does nothing, lua strings are meta strings.

189-- @function MetaString

190-- @tparam string str string value

191function M.MetaString(str)

192 return str

193end

194

195--- Creates boolean to be used in meta data.

196-- Does nothing, lua booleans are meta booleans.

197-- @function MetaBool

198-- @tparam boolean bool boolean value

199function M.MetaBool(bool)

200 return bool

201end

202

203------------------------------------------------------------------------

204-- Blocks

205-- @section Block

206

207--- Block elements

208M.Block = Element:make_subtype{}

209M.Block.__call = function (t, ...)

210 return t:new(...)

211end

212

213--- Creates a block quote element

214-- @function BlockQuote

215-- @tparam {Block,...} content block content

216-- @treturn Block block quote element

217M.BlockQuote = M.Block:create_constructor(

218 "BlockQuote",

219 function(content) return {c = content} end,

220 "content"

221)

222

223--- Creates a bullet (i.e. unordered) list.

224-- @function BulletList

225-- @tparam {{Block,...},...} content list of items

226-- @treturn Block block quote element

227M.BulletList = M.Block:create_constructor(

228 "BulletList",

229 function(content) return {c = content} end,

230 "content"

231)

232

233--- Creates a code block element

234-- @function CodeBlock

235-- @tparam string text code string

236-- @tparam[opt] Attr attributes element attributes

237-- @treturn Block code block element

238M.CodeBlock = M.Block:create_constructor(

239 "CodeBlock",

240 function(text, attributes) return {c = {attributes, text}} end,

241 {{"identifier", "classes", "attributes"}, "text"}

242)

243

244--- Creates a definition list, containing terms and their explanation.

245-- @function DefinitionList

246-- @tparam {{{Inline,...},{Block,...}},...} content list of items

247-- @treturn Block block quote element

248M.DefinitionList = M.Block:create_constructor(

249 "DefinitionList",

250 function(content) return {c = content} end,

251 "content"

252)

253

254--- Creates a div element

255-- @function Div

256-- @tparam {Block,...} content block content

257-- @tparam[opt] Attr attributes element attributes

258-- @treturn Block code block element

259M.Div = M.Block:create_constructor(

260 "Div",

261 function(content, attributes) return {c = {attributes, content}} end,

262 {{"identifier", "classes", "attributes"}, "content"}

263)

264

265--- Creates a block quote element.

266-- @function Header

267-- @tparam int level header level

268-- @tparam {Inline,...} content inline content

269-- @tparam Attr attributes element attributes

270-- @treturn Block header element

271M.Header = M.Block:create_constructor(

272 "Header",

273 function(level, content, attributes)

274 return {c = {level, attributes, content}}

275 end,

276 {"level", {"identifier", "classes", "attributes"}, "content"}

277)

278

279--- Creates a horizontal rule.

280-- @function HorizontalRule

281-- @treturn Block horizontal rule

282M.HorizontalRule = M.Block:create_constructor(

283 "HorizontalRule",

284 function() return {} end

285)

286

287--- Creates a line block element.

288-- @function LineBlock

289-- @tparam {{Inline,...},...} content inline content

290-- @treturn Block block quote element

291M.LineBlock = M.Block:create_constructor(

292 "LineBlock",

293 function(content) return {c = content} end,

294 "content"

295)

296

297--- Creates a null element.

298-- @function Null

299-- @treturn Block null element

300M.Null = M.Block:create_constructor(

301 "Null",

302 function() return {} end

303)

304

305--- Creates an ordered list.

306-- @function OrderedList

307-- @tparam {{Block,...},...} items list items

308-- @param[opt] listAttributes list parameters

309-- @treturn Block

310M.OrderedList = M.Block:create_constructor(

311 "OrderedList",

312 function(items, listAttributes)

313 return {c = {listAttributes,items}}

314 end,

315 {{"start", "style", "delimiter"}, "content"}

316)

317

318--- Creates a para element.

319-- @function Para

320-- @tparam {Inline,...} content inline content

321-- @treturn Block block quote element

322M.Para = M.Block:create_constructor(

323 "Para",

324 function(content) return {c = content} end,

325 "content"

326)

327

328--- Creates a plain element.

329-- @function Plain

330-- @tparam {Inline,...} content inline content

331-- @treturn Block block quote element

332M.Plain = M.Block:create_constructor(

333 "Plain",

334 function(content) return {c = content} end,

335 "content"

336)

337

338--- Creates a raw content block of the specified format.

339-- @function RawBlock

340-- @tparam string format format of content

341-- @tparam string text string content

342-- @treturn Block block quote element

343M.RawBlock = M.Block:create_constructor(

344 "RawBlock",

345 function(format, text) return {c = {format, text}} end,

346 {"format", "text"}

347)

348

349--- Creates a table element.

350-- @function Table

351-- @tparam {Inline,...} caption table caption

352-- @tparam {AlignDefault|AlignLeft|AlignRight|AlignCenter,...} aligns alignments

353-- @tparam {int,...} widths column widths

354-- @tparam {Block,...} headers header row

355-- @tparam {{Block,...}} rows table rows

356-- @treturn Block block quote element

357M.Table = M.Block:create_constructor(

358 "Table",

359 function(caption, aligns, widths, headers, rows)

360 return {c = {caption, aligns, widths, headers, rows}}

361 end

362)

363

364

365------------------------------------------------------------------------

366-- Inline

367-- @section Inline

368

369--- Inline element class

370M.Inline = Element:make_subtype{}

371M.Inline.__call = function (t, ...)

372 return t:new(...)

373end

374

375--- Creates a Cite inline element

376-- @function Cite

377-- @tparam {Inline,...} content List of inlines

378-- @tparam {Citation,...} citations List of citations

379-- @treturn Inline citations element

380M.Cite = M.Inline:create_constructor(

381 "Cite",

382 function(content, citations) return {c = {citations, content}} end,

383 {"citations", "content"}

384)

385

386--- Creates a Code inline element

387-- @function Code

388-- @tparam string text brief image description

389-- @tparam[opt] Attr attributes additional attributes

390-- @treturn Inline code element

391M.Code = M.Inline:create_constructor(

392 "Code",

393 function(text, attributes) return {c = {attributes, text}} end,

394 {{"identifier", "classes", "attributes"}, "text"}

395)

396

397--- Creates an inline element representing emphasised text.

398-- @function Emph

399-- @tparam {Inline,..} content inline content

400-- @treturn Inline emphasis element

401M.Emph = M.Inline:create_constructor(

402 "Emph",

403 function(content) return {c = content} end,

404 "content"

405)

406

407--- Creates a Image inline element

408-- @function Image

409-- @tparam {Inline,..} caption text used to describe the image

410-- @tparam string src path to the image file

411-- @tparam[opt] string title brief image description

412-- @tparam[opt] Attr attributes additional attributes

413-- @treturn Inline image element

414M.Image = M.Inline:create_constructor(

415 "Image",

416 function(caption, src, title, attributes)

417 title = title or ""

418 attributes = attributes or Attribute.empty

419 return {c = {attributes, caption, {src, title}}}

420 end,

421 {"attributes", "caption", {"src", "title"}}

422)

423

424--- Create a LineBreak inline element

425-- @function LineBreak

426-- @treturn Inline linebreak element

427M.LineBreak = M.Inline:create_constructor(

428 "LineBreak",

429 function() return {} end

430)

431

432--- Creates a link inline element, usually a hyperlink.

433-- @function Link

434-- @tparam {Inline,..} content text for this link

435-- @tparam string target the link target

436-- @tparam[opt] string title brief link description

437-- @tparam[opt] Attr attributes additional attributes

438-- @treturn Inline image element

439M.Link = M.Inline:create_constructor(

440 "Link",

441 function(content, target, title, attributes)

442 title = title or ""

443 attributes = attributes or Attribute.empty

444 return {c = {attributes, content, {target, title}}}

445 end,

446 {"attributes", "content", {"target", "title"}}

447)

448

449--- Creates a Math element, either inline or displayed. It is usually simpler to

450-- use one of the specialized functions @{InlineMath} or @{DisplayMath} instead.

451-- @function Math

452-- @tparam "InlineMath"|"DisplayMath" mathtype rendering specifier

453-- @tparam string text Math content

454-- @treturn Inline Math element

455M.Math = M.Inline:create_constructor(

456 "Math",

457 function(mathtype, text)

458 return {c = {mathtype, text}}

459 end,

460 {"mathtype", "text"}

461)

462--- Creates a DisplayMath element.

463-- @function DisplayMath

464-- @tparam string text Math content

465-- @treturn Inline Math element

466M.DisplayMath = M.Inline:create_constructor(

467 "DisplayMath",

468 function(text) return M.Math("DisplayMath", text) end,

469 {"mathtype", "text"}

470)

471--- Creates an InlineMath inline element.

472-- @function InlineMath

473-- @tparam string text Math content

474-- @treturn Inline Math element

475M.InlineMath = M.Inline:create_constructor(

476 "InlineMath",

477 function(text) return M.Math("InlineMath", text) end,

478 {"mathtype", "text"}

479)

480

481--- Creates a Note inline element

482-- @function Note

483-- @tparam {Block,...} content footnote block content

484M.Note = M.Inline:create_constructor(

485 "Note",

486 function(content) return {c = content} end,

487 "content"

488)

489

490--- Creates a Quoted inline element given the quote type and quoted content. It

491-- is usually simpler to use one of the specialized functions @{SingleQuoted} or

492-- @{DoubleQuoted} instead.

493-- @function Quoted

494-- @tparam "DoubleQuote"|"SingleQuote" quotetype type of quotes to be used

495-- @tparam {Inline,..} content inline content

496-- @treturn Inline quoted element

497M.Quoted = M.Inline:create_constructor(

498 "Quoted",

499 function(quotetype, content) return {c = {quotetype, content}} end,

500 {"quotetype", "content"}

501)

502--- Creates a single-quoted inline element.

503-- @function SingleQuoted

504-- @tparam {Inline,..} content inline content

505-- @treturn Inline quoted element

506-- @see Quoted

507M.SingleQuoted = M.Inline:create_constructor(

508 "SingleQuoted",

509 function(content) return M.Quoted(M.SingleQuote, content) end,

510 {"quotetype", "content"}

511)

512--- Creates a single-quoted inline element.

513-- @function DoubleQuoted

514-- @tparam {Inline,..} content inline content

515-- @treturn Inline quoted element

516-- @see Quoted

517M.DoubleQuoted = M.Inline:create_constructor(

518 "DoubleQuoted",

519 function(content) return M.Quoted("DoubleQuote", content) end,

520 {"quotetype", "content"}

521)

522

523--- Creates a RawInline inline element

524-- @function RawInline

525-- @tparam string format format of the contents

526-- @tparam string text string content

527-- @treturn Inline raw inline element

528M.RawInline = M.Inline:create_constructor(

529 "RawInline",

530 function(format, text) return {c = {format, text}} end,

531 {"format", "text"}

532)

533

534--- Creates text rendered in small caps

535-- @function SmallCaps

536-- @tparam {Inline,..} content inline content

537-- @treturn Inline smallcaps element

538M.SmallCaps = M.Inline:create_constructor(

539 "SmallCaps",

540 function(content) return {c = content} end,

541 "content"

542)

543

544--- Creates a SoftBreak inline element.

545-- @function SoftBreak

546-- @treturn Inline softbreak element

547M.SoftBreak = M.Inline:create_constructor(

548 "SoftBreak",

549 function() return {} end

550)

551

552--- Create a Space inline element

553-- @function Space

554-- @treturn Inline space element

555M.Space = M.Inline:create_constructor(

556 "Space",

557 function() return {} end

558)

559

560--- Creates a Span inline element

561-- @function Span

562-- @tparam {Inline,..} content inline content

563-- @tparam[opt] Attr attributes additional attributes

564-- @treturn Inline span element

565M.Span = M.Inline:create_constructor(

566 "Span",

567 function(content, attributes) return {c = {attributes, content}} end,

568 {{"identifier", "classes", "attributes"}, "content"}

569)

570

571--- Creates a Str inline element

572-- @function Str

573-- @tparam string text content

574-- @treturn Inline string element

575M.Str = M.Inline:create_constructor(

576 "Str",

577 function(text) return {c = text} end,

578 "text"

579)

580

581--- Creates text which is striked out.

582-- @function Strikeout

583-- @tparam {Inline,..} content inline content

584-- @treturn Inline strikeout element

585M.Strikeout = M.Inline:create_constructor(

586 "Strikeout",

587 function(content) return {c = content} end,

588 "content"

589)

590

591--- Creates a Strong element, whose text is usually displayed in a bold font.

592-- @function Strong

593-- @tparam {Inline,..} content inline content

594-- @treturn Inline strong element

595M.Strong = M.Inline:create_constructor(

596 "Strong",

597 function(content) return {c = content} end,

598 "content"

599)

600

601--- Creates a Subscript inline element

602-- @function Subscript

603-- @tparam {Inline,..} content inline content

604-- @treturn Inline subscript element

605M.Subscript = M.Inline:create_constructor(

606 "Subscript",

607 function(content) return {c = content} end,

608 "content"

609)

610

611--- Creates a Superscript inline element

612-- @function Superscript

613-- @tparam {Inline,..} content inline content

614-- @treturn Inline strong element

615M.Superscript = M.Inline:create_constructor(

616 "Superscript",

617 function(content) return {c = content} end,

618 "content"

619)

620

621

622------------------------------------------------------------------------

623-- Helpers

624-- @section helpers

625

626-- Attr

627M.Attr = {}

628M.Attr._field_names = {identifier = 1, classes = 2, attributes = 3}

629--- Create a new set of attributes (Attr).

630-- @function Attr

631-- @tparam[opt] string identifier element identifier

632-- @tparam[opt] {string,...} classes element classes

633-- @tparam[opt] table attributes table containing string keys and values

634-- @return element attributes

635M.Attr.__call = function(t, identifier, classes, attributes)

636 identifier = identifier or ''

637 classes = classes or {}

638 attributes = attributes or {}

639 local attr = {identifier, classes, attributes}

640 setmetatable(attr, t)

641 return attr

642end

643M.Attr.__index = function(t, k)

644 return rawget(t, k) or

645 rawget(t, M.Attr._field_names[k]) or

646 rawget(getmetatable(t), k)

647end

648M.Attr.__newindex = function(t, k, v)

649 if M.Attr._field_names[k] then

650 rawset(t, M.Attr._field_names[k], v)

651 else

652 rawset(t, k, v)

653 end

654end

655setmetatable(M.Attr, M.Attr)

656

657

658--- Creates a single citation.

659-- @function Citation

660-- @tparam string id citation identifier (like a bibtex key)

661-- @tparam AuthorInText|SuppressAuthor|NormalCitation mode citation mode

662-- @tparam[opt] {Inline,...} prefix citation prefix

663-- @tparam[opt] {Inline,...} suffix citation suffix

664-- @tparam[opt] int note_num note number

665-- @tparam[opt] int note_num hash number

666M.Citation = function(id, mode, prefix, suffix, note_num, hash)

667 prefix = prefix or {}

668 suffix = suffix or {}

669 note_num = note_num or 0

670 hash = hash or 0

671 return {

672 citationId = id,

673 citationPrefix = prefix,

674 citationSuffix = suffix,

675 citationMode = mode,

676 citationNoteNum = note_num,

677 citationHash = hash,

678 }

679end

680

681

682------------------------------------------------------------------------

683-- Constants

684-- @section constants

685

686--- Author name is mentioned in the text.

687-- @see Citation

688-- @see Cite

689M.AuthorInText = "AuthorInText"

690

691--- Author name is suppressed.

692-- @see Citation

693-- @see Cite

694M.SuppressAuthor = "SuppressAuthor"

695

696--- Default citation style is used.

697-- @see Citation

698-- @see Cite

699M.NormalCitation = "NormalCitation"

700

701--- Table cells aligned left.

702-- @see Table

703M.AlignLeft = "AlignLeft"

704

705--- Table cells right-aligned.

706-- @see Table

707M.AlignRight = "AlignRight"

708

709--- Table cell content is centered.

710-- @see Table

711M.AlignCenter = "AlignCenter"

712

713--- Table cells are alignment is unaltered.

714-- @see Table

715M.AlignDefault = "AlignDefault"

716

717--- Default list number delimiters are used.

718-- @see OrderedList

719M.DefaultDelim = "DefaultDelim"

720

721--- List numbers are delimited by a period.

722-- @see OrderedList

723M.Period = "Period"

724

725--- List numbers are delimited by a single parenthesis.

726-- @see OrderedList

727M.OneParen = "OneParen"

728

729--- List numbers are delimited by a double parentheses.

730-- @see OrderedList

731M.TwoParens = "TwoParens"

732

733--- List are numbered in the default style

734-- @see OrderedList

735M.DefaultStyle = "DefaultStyle"

736

737--- List items are numbered as examples.

738-- @see OrderedList

739M.Example = "Example"

740

741--- List are numbered using decimal integers.

742-- @see OrderedList

743M.Decimal = "Decimal"

744

745--- List are numbered using lower-case roman numerals.

746-- @see OrderedList

747M.LowerRoman = "LowerRoman"

748

749--- List are numbered using upper-case roman numerals

750-- @see OrderedList

751M.UpperRoman = "UpperRoman"

752

753--- List are numbered using lower-case alphabetic characters.

754-- @see OrderedList

755M.LowerAlpha = "LowerAlpha"

756

757--- List are numbered using upper-case alphabetic characters.

758-- @see OrderedList

759M.UpperAlpha = "UpperAlpha"

760

761

762------------------------------------------------------------------------

763-- Helper Functions

764-- @section helpers

765

766--- Parse the given string into a Pandoc document.

767-- The method used to interpret input is specified by *format*. Acceptable

768-- values for this parameter are equal to those that can be given to the

769-- `--from` command line option.

770-- @tparam string markup the markup to be parsed

771-- @tparam[opt] string format format specification, defaults to "markdown".

772-- @return Doc pandoc document

773-- @usage

774-- local org_markup = "/emphasis/" -- Input to be read

775-- local document = pandoc.read(org_markup, "org")

776-- -- Get the first block of the document

777-- local block = document.blocks[1]

778-- -- The inline element in that block is an `Emph`

779-- assert(block.content[1].t == "Emph")

780function M.read(markup, format)

781 format = format or "markdown"

782 local pd = pandoc.__read(format, markup)

783 if type(pd) == "string" then

784 error(pd)

785 else

786 return pd

787 end

788end

789

790--- Use functions defined in the global namespace to create a pandoc filter.

791-- All globally defined functions which have names of pandoc elements are

792-- collected into a new table.

793-- @return A list of filter functions

794-- @usage

795-- -- within a file defining a pandoc filter:

796-- function Str(text)

797-- return pandoc.Str(utf8.upper(text))

798-- end

799--

800-- return {pandoc.global_filter()}

801-- -- the above is equivallent to

802-- -- return {{Str = Str}}

803function M.global_filter()

804 local res = {}

805 for k, v in pairs(_G) do

806 if M.Inline.constructor[k] or M.Block.constructor[k] or k == "Doc" then

807 res[k] = v

808 end

809 end

810 return res

811end

812

813return M