pandoc-jats-ruby 0.0.3

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pandoc/jats/ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pandoc-jats-ruby/default.jats

@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.0 20120330//EN"
+                  "JATS-journalpublishing1.dtd">
+$if(article.type)$
+<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="1.0" article-type="$article.type$">
+$else$
+<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="1.0" article-type="other">
+$endif$
+<front>
+<journal-meta>
+$if(journal.publisher-id)$
+<journal-id journal-id-type="publisher-id">$journal.publisher-id$</journal-id>
+$endif$
+$if(journal.nlm-ta)$
+<journal-id journal-id-type="nlm-ta">$journal.nlm-ta$</journal-id>
+$endif$
+$if(journal.pmc)$
+<journal-id journal-id-type="pmc">$journal.pmc$</journal-id>
+$endif$
+<journal-title-group>
+$if(journal.title)$
+<journal-title>$journal.title$</journal-title>
+$endif$
+$if(journal.abbrev-title)$
+<abbrev-journal-title>$journal.abbrev-title$</abbrev-journal-title>
+$endif$
+</journal-title-group>
+$if(journal.pissn)$
+<issn pub-type="ppub">$journal.pissn$</issn>
+$endif$
+$if(journal.eissn)$
+<issn pub-type="epub">$journal.eissn$</issn>
+$endif$
+<publisher>
+<publisher-name>$journal.publisher-name$</publisher-name>
+$if(journal.publisher-loc)$
+<publisher-loc>$journal.publisher-loc$</publisher-loc>
+$endif$
+</publisher>
+</journal-meta>
+<article-meta>
+$if(article.publisher-id)$
+<article-id pub-id-type="publisher-id">$article.publisher-id$</article-id>
+$endif$
+$if(article.doi)$
+<article-id pub-id-type="doi">$article.doi$</article-id>
+$endif$
+$if(article.pmid)$
+<article-id pub-id-type="pmid">$article.pmid$</article-id>
+$endif$
+$if(article.pmcid)$
+<article-id pub-id-type="pmcid">$article.pmcid$</article-id>
+$endif$
+$if(article.art-access-id)$
+<article-id pub-id-type="art-access-id">$article.art-access-id$</article-id>
+$endif$
+$if(article.heading)$
+<article-categories>
+<subj-group subj-group-type="heading">
+<subject>$article.heading$</subject>
+</subj-group>
+$if(article.categories)$
+<subj-group subj-group-type="categories">
+$for(article.categories)$
+<subject>$article.categories$</subject>
+$endfor$
+</subj-group>
+$endif$
+</article-categories>
+$endif$
+$if(title)$
+<title-group>
+<article-title>$title$</article-title>
+</title-group>
+$endif$
+$if(author)$
+<contrib-group>
+$for(author)$
+<contrib contrib-type="author">
+$if(author.orcid)$
+<contrib-id contrib-id-type="orcid">$author.orcid$</contrib-id>
+$endif$
+<name>
+$if(author.surname)$
+<surname>$author.surname$</surname>
+<given-names>$author.given-names$</given-names>
+$else$
+<string-name>$author$</string-name>
+$endif$
+</name>
+$if(author.email)$
+<email>$author.email$</email>
+$endif$
+$if(author.aff-id)$
+<xref ref-type="aff" rid="aff-$contrib.aff-id$"/>
+$endif$
+$if(author.cor-id)$
+<xref ref-type="corresp" rid="cor-$author.cor-id$"><sup>*</sup></xref>
+$endif$
+</contrib>
+$endfor$
+</contrib-group>
+$endif$
+$if(article.author-notes)$
+<author-notes>
+$if(article.author-notes.corresp)$
+$for(article.author-notes.corresp)$
+<corresp id="cor-$article.author-notes.corresp.id$">* E-mail: <email>$article.author-notes.corresp.email$</email></corresp>
+$endfor$
+$endif$
+$if(article.author-notes.conflict)$
+<fn fn-type="conflict"><p>$article.author-notes.conflict$</p></fn>
+$endif$
+$if(article.author-notes.con)$
+<fn fn-type="con"><p>$article.author-notes.con$</p></fn>
+$endif$
+</author-notes>
+$endif$
+$if(date)$
+$if(date.iso-8601)$
+<pub-date pub-type="epub" iso-8601-date="$date.iso-8601$">
+$else$
+<pub-date pub-type="epub">
+$endif$
+$if(date.day)$
+<day>$pub-date.day$</day>
+$endif$
+$if(date.month)$
+<month>$pub-date.month$</month>
+$endif$
+$if(date.year)$
+<year>$pub-date.year$</year>
+$else$
+<string-date>$date$</string-date>
+$endif$
+</pub-date>
+$endif$
+$if(article.volume)$
+<volume>$article.volume$</volume>
+$endif$
+$if(article.issue)$
+<issue>$article.issue$</issue>
+$endif$
+$if(article.fpage)$
+<fpage>$article.fpage$</fpage>
+$endif$
+$if(article.lpage)$
+<lpage>$article.lpage$</lpage>
+$endif$
+$if(article.elocation-id)$
+<elocation-id>$article.elocation-id$</elocation-id>
+$endif$
+$if(history)$
+<history>
+</history>
+$endif$
+$if(copyright)$
+<permissions>
+$if(copyright.statement)$
+<copyright-statement>$copyright.statement$</copyright-statement>
+$endif$
+$if(copyright.year)$
+<copyright-year>$copyright.year$</copyright-year>
+$endif$
+$if(copyright.holder)$
+<copyright-holder>$copyright.holder$</copyright-holder>
+$endif$
+$if(copyright.text)$
+<license license-type="$copyright.type$" xlink:href="$copyright.link$">
+<license-p>$copyright.text$</license-p>
+</license>
+</permissions>
+$endif$
+$endif$
+$if(tags)$
+<kwd-group kwd-group-type="author">
+$for(tags)$
+<kwd>$tags$</kwd>
+$endfor$
+</kwd-group>
+$endif$
+$if(article.funding-statement)$
+<funding-group>
+<funding-statement>$article.funding-statement$</funding-statement>
+</funding-group>
+$endif$
+</article-meta>
+$if(notes)$
+<notes>$notes$</notes>
+$endif$
+</front>
+$body$
+</article>

data/lib/pandoc-jats-ruby/jats.lua

@@ -0,0 +1,662 @@
+-- This is a JATS custom writer for pandoc.  It produces output
+-- that tries to conform to the JATS 1.0 specification
+-- http://jats.nlm.nih.gov/archiving/tag-library/1.0/index.html
+--
+-- Invoke with: pandoc -t jats.lua
+--
+-- Note:  you need not have lua installed on your system to use this
+-- custom writer.  However, if you do have lua installed, you can
+-- use it to test changes to the script.  'lua JATS.lua' will
+-- produce informative error messages if your code contains
+-- syntax errors.
+--
+-- Released under the GPL, version 2 or greater. See LICENSE for more info.
+
+-- Tables to store metadata, headers, sections, back sections, references, figures and footnotes
+local meta = {}
+local headers = {}
+local sections = {}
+local back = {}
+local references = {}
+local figures = {}
+
+-- This function is called once for the whole document. Parameters:
+-- body is a string, metadata is a table, variables is a table.
+-- This gives you a fragment.  You could use the metadata table to
+-- fill variables in a custom lua template.  Or, pass `--template=...`
+-- to pandoc, and pandoc will do the template processing as
+-- usual.
+function Doc(body, metadata, variables)
+  meta = metadata or {}
+
+  -- if document doesn't start with section, add top-level section without title
+  if string.sub(body, 1, 6) ~= '</sec>' then
+    body = Header(1, '') .. '\n' .. body
+  end
+
+  -- strip closing section tag from beginning, add to end of document
+  body = string.sub(body, 7) .. '</sec>'
+
+  -- parse sections, turn body into table of sections
+  for lev, title, content in string.gmatch(body, '<sec.-lev="(.-)".->%s<title>(.-)</title>(.-)</sec>') do
+    attr = section_helper(tonumber(lev), content, title)
+  end
+
+  body = xml('body', '\n' .. table.concat(sections, '\n') .. '\n')
+
+  if #back > 0 then
+    body = body .. '\n' .. xml('back', '\n' .. table.concat(back, '\n'))
+  end
+
+  return body
+end
+
+-- XML character entity escaping and unescaping
+function escape(s)
+  local map = { ['<'] = '&lt;',
+                ['>'] = '&gt;',
+                ['&'] = '&amp;',
+                ['"'] = '&quot;',
+                ['\'']= '&#39;' }
+  return s:gsub("[<>&\"']", function(x) return map[x] end)
+end
+
+function unescape(s)
+  local map = { ['&lt;'] = '<',
+                ['&gt;'] = '>',
+                ['&amp;'] = '&',
+                ['&quot;'] = '"',
+                ['&#39;']= '\'' }
+  return s:gsub('(&(#?)([%d%a]+);)', function(x) return map[x] end)
+end
+
+-- Helper function to convert an attributes table into
+-- a string that can be put into XML elements.
+function attributes(attr)
+  local attr_table = {}
+  for x, y in pairsByKeys(attr) do
+    if y and y ~= '' then
+      table.insert(attr_table, string.format(' %s="%s"', x, escape(y)))
+    end
+  end
+  return table.concat(attr_table)
+end
+
+-- sort table, so that attributes are in consistent order
+function pairsByKeys (t, f)
+  local a = {}
+  for n in pairs(t) do table.insert(a, n) end
+  table.sort(a, f)
+  local i = 0      -- iterator variable
+  local iter = function ()   -- iterator function
+    i = i + 1
+    if a[i] == nil then return nil
+    else return a[i], t[a[i]]
+    end
+  end
+  return iter
+end
+
+-- generic xml builder
+function xml(tag, s, attr)
+  attr = attr and attributes(attr) or ''
+  s = s and '>' .. s .. '</' .. tag .. '>' or '/>'
+  return '<' .. tag .. attr .. s
+end
+
+-- Flatten nested table, needed for nested YAML metadata['
+-- We only flatten associative arrays and create composite key,
+-- numbered arrays and flat tables are left intact.
+-- We also convert all hyphens in keys to underscores,
+-- so that they are proper variable names
+function flatten_table(tbl)
+  local result = {}
+
+  local function flatten(tbl, key)
+    for k, v in pairs(tbl) do
+      if type(k) == 'number' and k > 0 and k <= #tbl then
+        result[key] = tbl
+        break
+      else
+        k = (key and key .. '-' or '') .. k
+        if type(v) == 'table' then
+          flatten(v, k)
+        else
+          result[k] = v
+        end
+      end
+    end
+  end
+
+  flatten(tbl)
+  return result
+end
+
+-- Read a file from the working directory and
+-- return its contents (or nil if not found).
+function read_file(name)
+  local base, ext = name:match("([^%.]*)(.*)")
+  local fname = base .. ext
+  local file = io.open(fname, "r")
+  if not file then return nil end
+  return file:read("*all")
+end
+
+-- Parse YAML string and return table.
+-- We only understand a subset.
+function parse_yaml(s)
+  local l = {}
+  local c = {}
+  local i = 0
+  local k = nil
+
+  -- patterns
+  line_pattern = '(.-)\r?\n'
+  config_pattern = '^(%s*)([%w%-]+):%s*(.-)$'
+
+  -- First split string into lines
+  local function lines(line)
+    table.insert(l, line)
+    return ""
+  end
+
+  lines((s:gsub(line_pattern, lines)))
+
+  -- Then go over each line and check value and indentation
+  for _, v in ipairs(l) do
+    v:gsub(config_pattern, function(indent, tag, v)
+      if (v == '') then
+        i, k = string.len(indent), tag
+        c[tag] = {}
+      else
+        -- check whether value is enclosed by brackets, i.e. an array
+        if v:find('^%[(.-)%]$') then
+          arr = {};
+          for match in (v:sub(2, -2) .. ','):gmatch('(.-)' .. ',%s*') do
+              table.insert(arr, match);
+          end
+          v = arr;
+        else
+          -- if it is a string, remove optional enclosing quotes
+          v = v:match('^["\']*(.-)["\']*$')
+        end
+
+        if string.len(indent) == i + 2 and k then
+          c[k][tag] = v
+        else
+          c[tag] = v
+        end
+      end
+    end)
+  end
+
+  return c
+end
+
+-- add appropriate sec-type attribute
+function sec_type_helper(s)
+  local map = { ['Abstract']= 'abstract',
+                ['Acknowledgments']= 'acknowledgements',
+                ['Author Summary']= 'author-summary',
+                ['Conclusions'] = 'conclusions',
+                ['Discussion'] = 'discussion',
+                ['Glossary'] = 'glossary',
+                ['Introduction'] = 'intro',
+                ['Materials and Methods'] = 'materials|methods',
+                ['Notes'] = 'notes',
+                ['References']= 'references',
+                ['Results']= 'results',
+                ['Supporting Information']= 'supplementary-material',
+                ['Supplementary Information']= 'supplementary-material' }
+  return map[s]
+end
+
+function section_helper(lev, s, title)
+  local attr = { ['sec-type'] = sec_type_helper(title) }
+
+  if attr['sec-type'] == "acknowledgements" then
+    table.insert(back, Ack(s, title))
+  elseif attr['sec-type'] == "references" then
+    table.insert(back, RefList(s, title))
+  elseif attr['sec-type'] == "notes" then
+    table.insert(back, Note(s, title))
+  elseif attr['sec-type'] == "glossary" then
+    table.insert(back, Glossary(s, title))
+  elseif attr['sec-type'] == "abstract" or attr['sec-type'] == "author-summary" then
+    -- discard, should be provided via metadata
+  elseif attr['sec-type'] == "supplementary-material" then
+    table.insert(sections, SupplementaryMaterial(s, title))
+  else
+    table.insert(sections, Section(lev, s, title, attr))
+  end
+
+  return attr
+end
+
+-- Create table with year, month, day and iso8601-formatted date
+-- Input is iso8601-formatted date as string
+-- Return nil if input is not a valid date
+function date_helper(iso_date)
+  if not iso_date or string.len(iso_date) ~= 10 then return nil end
+
+  _,_,y,m,d = string.find(iso_date, '(%d+)-(%d+)-(%d+)')
+  time = os.time({ year = y, month = m, day = d })
+  date = os.date('*t', time)
+  date.iso8601 = string.format('%04d-%02d-%02d', date.year, date.month, date.day)
+  return date
+end
+
+-- Create affiliation table, linked to authors via aff-id
+function affiliation_helper(tbl)
+
+  set = {}
+  i = 0
+  for _,author in ipairs(tbl.author) do
+    if author.affiliation then
+      if not set[author.affiliation] then
+        i = i + 1
+        set[author.affiliation] = i
+      end
+      author['aff-id'] = set[author.affiliation]
+    end
+  end
+
+  tbl.aff = {}
+  for k,v in pairs(set) do
+    aff = { id = v, name = k }
+    table.insert(tbl.aff, aff)
+  end
+
+  return tbl
+end
+
+-- Create corresponding author table, linked to authors via cor-id
+function corresp_helper(tbl)
+
+  set = {}
+  i = 0
+  for _,author in ipairs(tbl.author) do
+    if author.corresp and author.email then
+      i = i + 1
+      set[i] = author.email
+      author['cor-id'] = i
+    end
+  end
+
+  tbl.corresp = {}
+  for k,v in pairs(set) do
+    corresp = { id = k, email = v }
+    table.insert(tbl.corresp, corresp)
+  end
+
+  return tbl
+end
+
+-- temporary fix
+function fix_citeproc(s)
+  s = s:gsub('</surname>, ', '</surname>')
+  s = s:gsub('</name></name><name>','</name>')
+  return s
+end
+
+-- Convert pandoc alignment to something HTML can use.
+-- align is AlignLeft, AlignRight, AlignCenter, or AlignDefault.
+function html_align(align)
+  local map = { ['AlignRight']= 'right',
+                ['AlignCenter']= 'center' }
+  return map[align] or 'left'
+end
+
+-- Blocksep is used to separate block elements.
+function Blocksep()
+  return "\n"
+end
+
+-- The functions that follow render corresponding pandoc elements.
+-- s is always a string, attr is always a table of attributes, and
+-- items is always an array of strings (the items in a list).
+-- Comments indicate the types of other variables.
+-- Defined at https://github.com/jgm/pandoc/blob/master/src/Text/Pandoc/Writers/Custom.hs
+
+-- block elements
+
+function Plain(s)
+  return s
+end
+
+function Para(s)
+  return xml('p', s)
+end
+
+function RawBlock(s)
+  return xml('preformat', s)
+end
+
+-- JATS restricts use to inside table cells (<td> and <th>)
+function HorizontalRule()
+  return '<hr/>'
+end
+
+-- lev is an integer, the header level.
+-- we can't use closing tags, as we don't know the end of the section
+function Header(lev, s, attr)
+  attr = attr or {}
+  attr['lev'] = '' .. lev
+  return '</sec>\n<sec' .. attributes(attr) .. '>\n' .. xml('title', s)
+end
+
+function Note(s)
+  return s
+end
+
+function CodeBlock(s, attr)
+  -- If code block has class 'dot', pipe the contents through dot
+  -- and base64, and include the base64-encoded png as a data: URL.
+  if attr.class and string.match(' ' .. attr.class .. ' ',' dot ') then
+    local png = pipe("base64", pipe("dot -Tpng", s))
+    return '<img src="data:image/png;base64,' .. png .. '"/>'
+  -- otherwise treat as code (one could pipe through a highlighter)
+  else
+    return "<pre><code" .. attributes(attr) .. ">" .. escape(s) ..
+           "</code></pre>"
+  end
+end
+
+function BlockQuote(s)
+  xml('boxed-text', s)
+end
+
+-- Caption is a string, aligns is an array of strings,
+-- widths is an array of floats, headers is an array of
+-- strings, rows is an array of arrays of strings.
+function Table(caption, aligns, widths, headers, rows)
+  local buffer = {}
+  local function add(s)
+    table.insert(buffer, s)
+  end
+  table.insert(buffer, '<table-wrap>')
+  if caption ~= '' then
+    -- if caption begins with <bold> text, make it the <title>
+    caption = string.gsub('<p>' .. caption, "^<p><bold>(.-)</bold>%s", "<title>%1</title>\n<p>")
+    add(xml('caption>', caption))
+  end
+  add("<table>")
+  if widths and widths[1] ~= 0 then
+    for _, w in pairs(widths) do
+      add('<col width="' .. string.format("%d%%", w * 100) .. '" />')
+    end
+  end
+  local header_row = {}
+  local empty_header = true
+  for i, h in pairs(headers) do
+    local align = html_align(aligns[i])
+
+    -- remove <p> tag
+    h = h:gsub("^<p>(.-)</p>", "%1")
+
+    table.insert(header_row,'<th align="' .. align .. '">' .. h .. '</th>')
+    empty_header = empty_header and h == ""
+  end
+  if empty_header then
+    head = ""
+  else
+    add('<tr>')
+    for _,h in pairs(header_row) do
+      add(h)
+    end
+    add('</tr>')
+  end
+  for _, row in pairs(rows) do
+    add('<tr>')
+    for i,c in pairs(row) do
+      -- remove <p> tag
+      c = c:gsub("^<p>(.-)</p>", "%1")
+      add('<td align="' .. html_align(aligns[i]) .. '">' .. c .. '</td>')
+    end
+    add('</tr>')
+  end
+  add('</table>\n</table-wrap>')
+  return table.concat(buffer,'\n')
+end
+
+function BulletList(items)
+  local attr = { ['list-type'] = 'bullet' }
+  return List(items, attr)
+end
+
+function OrderedList(items)
+  local attr = { ['list-type'] = 'order' }
+  return List(items, attr)
+end
+
+function List(items, attr)
+  local buffer = {}
+  for _, item in pairs(items) do
+    table.insert(buffer, xml('list-item', item))
+  end
+  return xml('list', '\n' .. table.concat(buffer, '\n') .. '\n', attr)
+end
+
+-- Revisit association list StackValue instance.
+-- items is a table of tables
+function DefinitionList(items)
+  local buffer = {}
+  for _,item in pairs(items) do
+    for k, v in pairs(item) do
+      local term = xml('term', k)
+      local def = xml('def', table.concat(v,'</def><def>'))
+      table.insert(buffer, xml('def-item', term .. def))
+    end
+  end
+  return xml('def-list', '\n' .. table.concat(buffer, '\n') .. '\n')
+end
+
+function Div(s, attr)
+  return s
+end
+
+-- custom block elements for JATS
+
+-- section is generated after header to allow reordering
+function Section(lev, s, title, attr)
+  local last = headers[#headers]
+  local h = last and last.h or {}
+  h[lev] = (h[lev] or 0) + 1
+  for i = lev + 1, #headers do
+    table.remove(h, i)
+  end
+
+  local header = { ['h'] = h,
+                   ['title'] = title,
+                   ['id'] = 'sec-' .. table.concat(h,'.'),
+                   ['sec-type'] = attr['sec-type'] }
+
+  table.insert(headers, header)
+
+  attr = { ['id'] = header['id'], ['sec-type'] = header['sec-type'] }
+  title = xml('title', title ~= '' and title or nil)
+  return xml('sec', '\n' .. title .. s, attr)
+end
+
+function SupplementaryMaterial(s, title, attr)
+  attr = {}
+  title = xml('title', title)
+  local caption = xml('caption', title .. s)
+  return xml('supplementary-material', '\n' .. caption .. '\n', attr)
+end
+
+function Ack(s, title)
+  title = title and '\n' .. xml('title', title) or ''
+  return xml('ack', title .. s)
+end
+
+function Glossary(s, title, attr)
+  title = xml('title', title)
+  return xml('glossary', title .. s, attr)
+end
+
+function RefList(s, title)
+  s = fix_citeproc(s)
+
+  -- format ids
+  s = string.gsub(s, '<ref id="(%d+)">', function (r)
+        local attr = { ['id'] = string.format('r%03d', tonumber(r)) }
+        return '<ref ' .. attributes(attr) .. '>'
+      end)
+
+  for ref in string.gmatch(s, '(<ref.-</ref>)') do
+    Ref(ref)
+  end
+
+  if #references > 0 then
+    title = xml('title', title)
+    return xml('ref-list', title .. table.concat(references, '\n'), attr)
+  else
+    return ''
+  end
+end
+
+function Ref(s)
+  table.insert(references, s)
+  return #references
+end
+
+-- inline elements
+
+function Str(s)
+  return s
+end
+
+function Space()
+  return ' '
+end
+
+function Emph(s)
+  return xml('italic', s)
+end
+
+function Strong(s)
+  return xml('bold', s)
+end
+
+function Strikeout(s)
+  return xml('strike', s)
+end
+
+function Superscript(s)
+  return xml('sup', s)
+end
+
+function Subscript(s)
+  return xml('sub', s)
+end
+
+function SmallCaps(s)
+  return xml('sc', s)
+end
+
+function SingleQuoted(s)
+  return "'" .. s .. "'"
+end
+
+function DoubleQuoted(s)
+  return '"' .. s .. '"'
+end
+
+-- format in-text citation
+function Cite(s)
+  local ids = {}
+  for id in string.gmatch(s, '(%d+)') do
+    id = tonumber(id)
+    -- workaround to discard year mistakenly taken for key
+    if id and id < 1000 then
+      local attr = { ['ref-type'] = 'bibr',
+                     ['rid'] = string.format("r%03d", id) }
+      table.insert(ids, xml('xref', '[' .. id .. ']', attr))
+    end
+  end
+  if #ids > 0 then
+    return table.concat(ids)
+  else
+    -- return original key for backwards compatibility
+    return s
+  end
+end
+
+function Code(s, attr)
+  return xml('preformat', s, attr)
+end
+
+function DisplayMath(s)
+  return xml('disp-formula', s)
+end
+
+function InlineMath(s)
+  return xml('inline-formula', s)
+end
+
+function RawInline(s)
+  return xml('preformat', s)
+end
+
+function LineBreak()
+  return ' '
+end
+
+function Link(s, src, title)
+  if src ~= '' and s ~= '' then
+    attr = { ['ext-link-type'] = 'uri',
+             ['xlink:href'] = escape(src),
+             ['xlink:title'] = escape(title),
+             ['xlink:type'] = 'simple' }
+
+    return xml('ext-link', s, attr)
+  else
+    return s
+  end
+end
+
+function CaptionedImage(s, src, title)
+  -- if title begins with <bold> text, make it the <title>
+  title = string.gsub(title, "^<bold>(.-)</bold>%s", function(t) xml('title', t) end)
+  local num = #figures + 1
+  local attr = { ['id'] = string.format("g%03d", num) }
+  local caption = xml('caption', s)
+  local fig = xml('fig', caption .. Image(nil, src, title), attr)
+
+  table.insert(figures, fig)
+  return fig
+end
+
+function Image(s, src, title)
+  local attr = { ['mimetype'] = 'image',
+                 ['xlink:href'] = escape(src),
+                 ['xlink:title'] = escape(title),
+                 ['xlink:type'] = 'simple' }
+
+  return xml('graphic', s, attr)
+end
+
+-- handle bold and italic
+function Span(s, attr)
+  if attr.style == "font-weight:bold" then
+    return Strong(s)
+  elseif attr.style == "font-style:italic" then
+    return Emph(s)
+  elseif attr.style == "font-variant: small-caps" then
+    return SmallCaps(s)
+  else
+    return s
+  end
+end
+
+-- The following code will produce runtime warnings when you haven't defined
+-- all of the functions you need for the custom writer, so it's useful
+-- to include when you're working on a writer.
+local meta = {}
+meta.__index =
+  function(_, key)
+    io.stderr:write(string.format("WARNING: Undefined function '%s'\n",key))
+    return function() return "" end
+  end
+setmetatable(_G, meta)