Merge https://github.com/jgm/pandoc

4 files changed, 389 insertions, 145 deletions

diff --git a/test/lua/implicit-doc-filter.lua b/test/lua/implicit-doc-filter.lua
index 253462d1c..f053dc1b2 100644
--- a/test/lua/implicit-doc-filter.lua
+++ b/test/lua/implicit-doc-filter.lua
@@ -1,4 +1,4 @@
-function Doc (doc)
+function Pandoc (doc)
   local meta = {}
   local hello = { pandoc.Str "Hello,", pandoc.Space(), pandoc.Str "World!" }
   local blocks = { pandoc.Para(hello) }
diff --git a/test/lua/module/pandoc-types.lua b/test/lua/module/pandoc-types.lua
index d4e063a5c..d9c9f82ac 100644
--- a/test/lua/module/pandoc-types.lua
+++ b/test/lua/module/pandoc-types.lua
@@ -55,31 +55,6 @@ return {
       end),
     },
 
-    group 'list-like behavior' {
-      test('can access version component numbers', function ()
-        local version = Version '2.7.3'
-        assert.is_nil(version[0])
-        assert.are_equal(version[1], 2)
-        assert.are_equal(version[2], 7)
-        assert.are_equal(version[3], 3)
-      end),
-      test('can be iterated over', function ()
-        local version_list = {2, 7, 3}
-        local final_index = 0
-        for i, v in pairs(Version(version_list)) do
-          assert.are_equal(v, version_list[i])
-          final_index = i
-        end
-        assert.are_equal(final_index, 3)
-      end),
-      test('length is the number of components', function ()
-        assert.are_equal(#(Version '0'), 1)
-        assert.are_equal(#(Version '1.6'), 2)
-        assert.are_equal(#(Version '8.7.5'), 3)
-        assert.are_equal(#(Version '2.9.1.5'), 4)
-      end)
-    },
-
     group 'conversion to string' {
       test('converting from and to string is a noop', function ()
         local version_string = '1.19.4'
diff --git a/test/lua/module/pandoc-utils.lua b/test/lua/module/pandoc-utils.lua
index 9bd903f2d..4cf2c84a7 100644
--- a/test/lua/module/pandoc-utils.lua
+++ b/test/lua/module/pandoc-utils.lua
@@ -39,6 +39,46 @@ return {
     end)
   },
 
+  group 'equals' {
+    test('compares Pandoc elements', function ()
+      assert.is_truthy(
+        utils.equals(pandoc.Pandoc{'foo'}, pandoc.Pandoc{'foo'})
+      )
+    end),
+    test('compares Block elements', function ()
+      assert.is_truthy(
+        utils.equals(pandoc.Plain{'foo'}, pandoc.Plain{'foo'})
+      )
+      assert.is_falsy(
+        utils.equals(pandoc.Para{'foo'}, pandoc.Plain{'foo'})
+      )
+    end),
+    test('compares Inline elements', function ()
+      assert.is_truthy(
+        utils.equals(pandoc.Emph{'foo'}, pandoc.Emph{'foo'})
+      )
+      assert.is_falsy(
+        utils.equals(pandoc.Emph{'foo'}, pandoc.Strong{'foo'})
+      )
+    end),
+    test('compares Inline with Block elements', function ()
+      assert.is_falsy(
+        utils.equals(pandoc.Emph{'foo'}, pandoc.Plain{'foo'})
+      )
+      assert.is_falsy(
+        utils.equals(pandoc.Para{'foo'}, pandoc.Strong{'foo'})
+      )
+    end),
+    test('compares Pandoc with Block elements', function ()
+      assert.is_falsy(
+        utils.equals(pandoc.Pandoc{'foo'}, pandoc.Plain{'foo'})
+      )
+      assert.is_falsy(
+        utils.equals(pandoc.Para{'foo'}, pandoc.Pandoc{'foo'})
+      )
+    end),
+  },
+
   group 'make_sections' {
     test('sanity check', function ()
       local blks = {
@@ -62,6 +102,31 @@ return {
     end),
   },
 
+  group 'references' {
+    test('gets references from doc', function ()
+      local ref = {
+        ['author'] = {
+          {given = 'Max', family = 'Mustermann'}
+        },
+        ['container-title'] = pandoc.Inlines('JOSS'),
+        ['id']     = 'test',
+        ['issued'] = {['date-parts'] = {{2021}}},
+        ['title']  = pandoc.Inlines{
+          pandoc.Quoted('DoubleQuote', 'Interesting'),
+          pandoc.Space(),
+          'work'
+        },
+        ['type']   = 'article-journal',
+      }
+      local nocite = pandoc.Cite(
+        '@test',
+        {pandoc.Citation('test', 'NormalCitation')}
+      )
+      local doc = pandoc.Pandoc({}, {nocite = nocite, references = {ref}})
+      assert.are_same({ref}, pandoc.utils.references(doc))
+    end)
+  },
+
   group 'sha1' {
     test('hashing', function ()
       local ref_hash = '0a0a9f2a6772942557ab5355d76af442f8f65e01'
@@ -70,7 +135,7 @@ return {
   },
 
   group 'stringify' {
-    test('inlines', function ()
+    test('Inline', function ()
       local inline = pandoc.Emph{
         pandoc.Str 'Cogito',
         pandoc.Space(),
@@ -79,7 +144,49 @@ return {
         pandoc.Str 'sum.',
       }
       assert.are_equal('Cogito ergo sum.', utils.stringify(inline))
-    end)
+    end),
+    test('Block', function ()
+      local block = pandoc.Para{
+        pandoc.Str 'Make',
+        pandoc.Space(),
+        pandoc.Str 'it',
+        pandoc.Space(),
+        pandoc.Str 'so.',
+      }
+      assert.are_equal('Make it so.', utils.stringify(block))
+    end),
+    test('boolean', function ()
+      assert.are_equal('true', utils.stringify(true))
+      assert.are_equal('false', utils.stringify(false))
+    end),
+    test('number', function ()
+      assert.are_equal('5', utils.stringify(5))
+      assert.are_equal('23.23', utils.stringify(23.23))
+    end),
+    test('Attr', function ()
+      local attr = pandoc.Attr('foo', {'bar'}, {a = 'b'})
+      assert.are_equal('', utils.stringify(attr))
+    end),
+    test('List', function ()
+      local list = pandoc.List{pandoc.Str 'a', pandoc.Blocks('b')}
+      assert.are_equal('ab', utils.stringify(list))
+    end),
+    test('Blocks', function ()
+      local blocks = pandoc.Blocks{pandoc.Para 'a', pandoc.Header(1, 'b')}
+      assert.are_equal('ab', utils.stringify(blocks))
+    end),
+    test('Inlines', function ()
+      local inlines = pandoc.Inlines{pandoc.Str 'a', pandoc.Subscript('b')}
+      assert.are_equal('ab', utils.stringify(inlines))
+    end),
+    test('Meta', function ()
+      local meta = pandoc.Meta{
+        a = pandoc.Inlines 'funny and ',
+        b = 'good movie',
+        c = pandoc.List{pandoc.Inlines{pandoc.Str '!'}}
+      }
+      assert.are_equal('funny and good movie!', utils.stringify(meta))
+    end),
   },
 
   group 'to_roman_numeral' {
@@ -91,6 +198,46 @@ return {
     end)
   },
 
+  group 'type' {
+    test('nil', function ()
+      assert.are_equal(utils.type(nil), 'nil')
+    end),
+    test('boolean', function ()
+      assert.are_equal(utils.type(true), 'boolean')
+      assert.are_equal(utils.type(false), 'boolean')
+    end),
+    test('number', function ()
+      assert.are_equal(utils.type(5), 'number')
+      assert.are_equal(utils.type(-3.02), 'number')
+    end),
+    test('string', function ()
+      assert.are_equal(utils.type(''), 'string')
+      assert.are_equal(utils.type('asdf'), 'string')
+    end),
+    test('plain table', function ()
+      assert.are_equal(utils.type({}), 'table')
+    end),
+    test('List', function ()
+      assert.are_equal(utils.type(pandoc.List{}), 'List')
+    end),
+    test('Inline', function ()
+      assert.are_equal(utils.type(pandoc.Str 'a'), 'Inline')
+      assert.are_equal(utils.type(pandoc.Emph 'emphasized'), 'Inline')
+    end),
+    test('Inlines', function ()
+      assert.are_equal(utils.type(pandoc.Inlines{pandoc.Str 'a'}), 'Inlines')
+      assert.are_equal(utils.type(pandoc.Inlines{pandoc.Emph 'b'}), 'Inlines')
+    end),
+    test('Blocks', function ()
+      assert.are_equal(utils.type(pandoc.Para 'a'), 'Block')
+      assert.are_equal(utils.type(pandoc.CodeBlock 'true'), 'Block')
+    end),
+    test('Inlines', function ()
+      assert.are_equal(utils.type(pandoc.Blocks{'a'}), 'Blocks')
+      assert.are_equal(utils.type(pandoc.Blocks{pandoc.CodeBlock 'b'}), 'Blocks')
+    end),
+  },
+
   group 'to_simple_table' {
     test('convertes Table', function ()
       function simple_cell (blocks)
@@ -106,14 +253,14 @@ return {
         {long = {pandoc.Plain {
                    pandoc.Str "the", pandoc.Space(), pandoc.Str "caption"}}},
         {{pandoc.AlignDefault, nil}},
-        {pandoc.Attr(), {{pandoc.Attr(), {simple_cell{pandoc.Plain "head1"}}}}},
+        pandoc.TableHead{pandoc.Row{simple_cell{pandoc.Plain "head1"}}},
         {{
             attr = pandoc.Attr(),
-            body = {{pandoc.Attr(), {simple_cell{pandoc.Plain "cell1"}}}},
+            body = {pandoc.Row{simple_cell{pandoc.Plain "cell1"}}},
             head = {},
             row_head_columns = 0
         }},
-        {pandoc.Attr(), {}},
+        pandoc.TableFoot(),
         pandoc.Attr()
       )
       local stbl = utils.to_simple_table(tbl)
@@ -155,5 +302,32 @@ return {
       -- reversible
       assert.are_same(simple_table, utils.to_simple_table(tbl))
     end),
+    test('empty caption', function ()
+      local simple_table = pandoc.SimpleTable(
+        {},
+        {pandoc.AlignDefault},
+        {0},
+        {{pandoc.Plain 'a'}},
+        {{{pandoc.Plain 'b'}}}
+      )
+      local tbl = utils.from_simple_table(simple_table)
+      assert.are_equal(
+        pandoc.Blocks{},
+        tbl.caption.long
+      )
+      assert.is_nil(tbl.caption.short)
+    end),
+    test('empty body', function ()
+      local simple_table = pandoc.SimpleTable(
+        pandoc.Inlines('a nice caption'),
+        {pandoc.AlignDefault},
+        {0},
+        {{pandoc.Plain 'a'}},
+        {}
+      )
+      local tbl = utils.from_simple_table(simple_table)
+      tbl.bodies:map(print)
+      assert.are_same(pandoc.List(), tbl.bodies)
+    end),
   }
 }
diff --git a/test/lua/module/pandoc.lua b/test/lua/module/pandoc.lua
index fa1748c18..892ffee03 100644
--- a/test/lua/module/pandoc.lua
+++ b/test/lua/module/pandoc.lua
@@ -8,126 +8,182 @@ function os_is_windows ()
   return package.config:sub(1,1) == '\\'
 end
 
+-- Constructor behavior is tested in the hslua-pandoc-types module, so
+-- we just make sure the functions are present.
 return {
-  group 'Attr' {
-    group 'Constructor' {
-      test('returns null-Attr if no arguments are given', function ()
-        local attr = pandoc.Attr()
-        assert.are_equal(attr.identifier, '')
-        assert.are_same(attr.classes, {})
-        assert.are_same(attr.attributes, {})
-      end),
-      test(
-        'accepts string-indexed table or list of pairs as attributes',
-        function ()
-          local attributes_list = pandoc.List:new {{'one', '1'}, {'two', '2'}}
-          local attr_from_list = pandoc.Attr('', {}, attributes_list:clone())
-
-          assert.are_same(
-            pandoc.List:new(attr_from_list.attributes),
-            attributes_list
-          )
-
-          local attributes_table = {one = '1', two = '2'}
-          local attr_from_table = pandoc.Attr('', {}, attributes_table)
-
-          local assoc_list_from_table =
-            pandoc.List:new(attr_from_table.attributes)
-          -- won't work in general, but does in this special case
-          table.sort(assoc_list_from_table, function(x, y) return x[1]<y[1] end)
-          assert.are_same(
-            assoc_list_from_table,
-            attributes_list
-          )
-        end
-      )
+  group 'Constructors' {
+    group 'Misc' {
+      test('pandoc.Attr is a function', function ()
+        assert.are_equal(type(pandoc.Attr), 'function')
+      end),
+      test('pandoc.AttributeList is a function', function ()
+        assert.are_equal(type(pandoc.AttributeList), 'function')
+      end),
+      test('pandoc.Blocks is a function', function ()
+        assert.are_equal(type(pandoc.Blocks), 'function')
+      end),
+      test('pandoc.Citation is a function', function ()
+        assert.are_equal(type(pandoc.Citation), 'function')
+      end),
+      test('pandoc.Inlines is a function', function ()
+        assert.are_equal(type(pandoc.Inlines), 'function')
+      end),
+      test('pandoc.SimpleTable is a function', function ()
+        assert.are_equal(type(pandoc.SimpleTable), 'function')
+      end),
+      test('pandoc.Meta is a function', function ()
+        assert.are_equal(type(pandoc.Meta), 'function')
+      end),
+      test('pandoc.Pandoc is a function', function ()
+        assert.are_equal(type(pandoc.Pandoc), 'function')
+      end),
     },
-    group 'AttributeList' {
-      test('allows access via fields', function ()
-        local attributes = pandoc.Attr('', {}, {{'a', '1'}, {'b', '2'}}).attributes
-        assert.are_equal(attributes.a, '1')
-        assert.are_equal(attributes.b, '2')
-      end),
-      test('allows access to pairs via numerical indexing', function ()
-        local attributes = pandoc.Attr('', {}, {{'a', '1'}, {'b', '2'}}).attributes
-        assert.are_same(attributes[1], {'a', '1'})
-        assert.are_same(attributes[2], {'b', '2'})
-      end),
-      test('adds entries by field name', function ()
-        local attributes = pandoc.Attr('',{}, {{'c', '1'}, {'d', '2'}}).attributes
-        attributes.e = '3'
-        assert.are_same(
-          -- checking the full AttributeList would "duplicate" entries
-          setmetatable(attributes, nil),
-          {{'c', '1'}, {'d', '2'}, {'e', '3'}}
-        )
+    group "Inline elements" {
+      test('pandoc.AttributeList is a function', function ()
+        assert.are_equal(type(pandoc.Cite), 'function')
+      end),
+      test('pandoc.AttributeList is a function', function ()
+        assert.are_equal(type(pandoc.Code), 'function')
+      end),
+      test('pandoc.Emph is a function', function ()
+        assert.are_equal(type(pandoc.Emph), 'function')
+      end),
+      test('pandoc.Image is a function', function ()
+        assert.are_equal(type(pandoc.Image), 'function')
+      end),
+      test('pandoc.Link is a function', function ()
+        assert.are_equal(type(pandoc.Link), 'function')
+      end),
+      test('pandoc.Math is a function', function ()
+        assert.are_equal(type(pandoc.Math), 'function')
+      end),
+      test('pandoc.Note is a function', function ()
+        assert.are_equal(type(pandoc.Note), 'function')
+      end),
+      test('pandoc.Quoted is a function', function ()
+        assert.are_equal(type(pandoc.Quoted), 'function')
+      end),
+      test('pandoc.SmallCaps is a function', function ()
+        assert.are_equal(type(pandoc.SmallCaps), 'function')
+      end),
+      test('pandoc.SoftBreak is a function', function ()
+        assert.are_equal(type(pandoc.SoftBreak), 'function')
+      end),
+      test('pandoc.Span is a function', function ()
+        assert.are_equal(type(pandoc.Span), 'function')
+      end),
+      test('pandoc.Str is a function', function ()
+        assert.are_equal(type(pandoc.Str), 'function')
+      end),
+      test('pandoc.Strikeout is a function', function ()
+      assert.are_equal(type(pandoc.Strikeout), 'function')
+      end),
+      test('pandoc.Strong is a function', function ()
+        assert.are_equal(type(pandoc.Strong), 'function')
+      end),
+      test('pandoc.Subscript is a function', function ()
+        assert.are_equal(type(pandoc.Subscript), 'function')
+      end),
+      test('pandoc.Superscript is a function', function ()
+        assert.are_equal(type(pandoc.Superscript), 'function')
+      end),
+      test('pandoc.Underline is a function', function ()
+        assert.are_equal(type(pandoc.Underline), 'function')
       end),
-      test('deletes entries by field name', function ()
-        local attributes = pandoc.Attr('',{}, {a = '1', b = '2'}).attributes
-        attributes.a = nil
-        assert.is_nil(attributes.a)
-        local assoc_list = setmetatable(attributes, nil)
-        assert.are_same(assoc_list, {{'b', '2'}})
-      end),
-      test('remains unchanged if deleted key did not exist', function ()
-        local assoc_list = pandoc.List:new {{'alpha', 'x'}, {'beta', 'y'}}
-        local attributes = pandoc.Attr('', {}, assoc_list:clone()).attributes
-        attributes.a = nil
-        assert.are_same(pandoc.List:new(attributes), assoc_list)
-      end),
-      test('gives key-value pairs when iterated-over', function ()
-        local attributes = {width = '11', height = '22', name = 'test'}
-        local attr = pandoc.Attr('', {}, attributes)
-        local count = 0
-        for k, v in pairs(attr.attributes) do
-          assert.are_equal(attributes[k], v)
-          count = count + 1
-        end
-        assert.are_equal(count, 3)
-      end)
     },
-    group 'HTML-like attribute tables' {
-      test('in element constructor', function ()
-        local html_attributes = {
-          id = 'the-id',
-          class = 'class1 class2',
-          width = '11',
-          height = '12'
-        }
-        local attr = pandoc.Span('test', html_attributes).attr
-        assert.are_equal(attr.identifier, 'the-id')
-        assert.are_equal(attr.classes[1], 'class1')
-        assert.are_equal(attr.classes[2], 'class2')
-        assert.are_equal(attr.attributes.width, '11')
-        assert.are_equal(attr.attributes.height, '12')
-      end),
-      test('element attr setter', function ()
-        local html_attributes = {
-          id = 'the-id',
-          class = 'class1 class2',
-          width = "11",
-          height = "12"
-        }
-        local span = pandoc.Span 'test'
-        span.attr = html_attributes
-        assert.are_equal(span.attr.identifier, 'the-id')
-        assert.are_equal(span.attr.classes[1], 'class1')
-        assert.are_equal(span.attr.classes[2], 'class2')
-        assert.are_equal(span.attr.attributes.width, '11')
-        assert.are_equal(span.attr.attributes.height, '12')
-      end),
-      test('element attrbutes setter', function ()
-        local attributes = {
-          width = "11",
-          height = "12"
-        }
-        local span = pandoc.Span 'test'
-        span.attributes = attributes
-        assert.are_equal(span.attr.attributes.width, '11')
-        assert.are_equal(span.attr.attributes.height, '12')
-      end)
+    group "Block elements" {
+      test('pandoc.BlockQuote is a function', function ()
+        assert.are_equal(type(pandoc.BlockQuote), 'function')
+      end),
+      test('pandoc.BulletList is a function', function ()
+        assert.are_equal(type(pandoc.BulletList), 'function')
+      end),
+      test('pandoc.CodeBlock is a function', function ()
+        assert.are_equal(type(pandoc.CodeBlock), 'function')
+      end),
+      test('pandoc.DefinitionList is a function', function ()
+        assert.are_equal(type(pandoc.DefinitionList), 'function')
+      end),
+      test('pandoc.Div is a function', function ()
+        assert.are_equal(type(pandoc.Div), 'function')
+      end),
+      test('pandoc.Header is a function', function ()
+        assert.are_equal(type(pandoc.Header), 'function')
+      end),
+      test('pandoc.LineBlock is a function', function ()
+        assert.are_equal(type(pandoc.LineBlock), 'function')
+      end),
+      test('pandoc.Null is a function', function ()
+        assert.are_equal(type(pandoc.Null), 'function')
+      end),
+      test('pandoc.OrderedList is a function', function ()
+        assert.are_equal(type(pandoc.OrderedList), 'function')
+      end),
+      test('pandoc.Para is a function', function ()
+        assert.are_equal(type(pandoc.Para), 'function')
+      end),
+      test('pandoc.Plain is a function', function ()
+        assert.are_equal(type(pandoc.Plain), 'function')
+      end),
+      test('pandoc.RawBlock is a function', function ()
+        assert.are_equal(type(pandoc.Plain), 'function')
+      end),
+      test('pandoc.Table is a function', function ()
+        assert.are_equal(type(pandoc.Table), 'function')
+      end),
     }
   },
+  group 'MetaValue elements' {
+    test('MetaList elements behave like lists', function ()
+      local metalist = pandoc.MetaList{}
+      assert.are_equal(type(metalist.insert), 'function')
+      assert.are_equal(type(metalist.remove), 'function')
+    end),
+    test('`tag` is an alias for `t``', function ()
+      assert.are_equal((pandoc.MetaList{}).tag, (pandoc.MetaList{}).t)
+      assert.are_equal((pandoc.MetaMap{}).tag, (pandoc.MetaMap{}).t)
+      assert.are_equal((pandoc.MetaInlines{}).tag, (pandoc.MetaInlines{}).t)
+      assert.are_equal((pandoc.MetaBlocks{}).tag, (pandoc.MetaBlocks{}).t)
+    end),
+  },
+  group 'Meta' {
+    test('inline list is treated as MetaInlines', function ()
+      local meta = pandoc.Pandoc({}, {test = {pandoc.Emph 'check'}}).meta
+      assert.are_same(meta.test, {pandoc.Emph{pandoc.Str 'check'}})
+    end),
+    test('inline element is treated as MetaInlines singleton', function ()
+      local meta = pandoc.Pandoc({}, {test = pandoc.Emph 'check'}).meta
+      assert.are_same(meta.test, {pandoc.Emph{pandoc.Str 'check'}})
+    end),
+    test('block list is treated as MetaBlocks', function ()
+      local meta = pandoc.Pandoc({}, {test = {pandoc.Plain 'check'}}).meta
+      assert.are_same(meta.test, {pandoc.Plain{pandoc.Str 'check'}})
+    end),
+    test('block element is treated as MetaBlocks singleton', function ()
+      local meta = pandoc.Pandoc({}, {test = pandoc.Plain 'check'}).meta
+      assert.are_same(meta.test, {pandoc.Plain{pandoc.Str 'check'}})
+    end),
+  },
+  group 'Other types' {
+    group 'ReaderOptions' {
+      test('returns a userdata value', function ()
+        local opts = pandoc.ReaderOptions {}
+        assert.are_equal(type(opts), 'userdata')
+      end),
+      test('can construct from table', function ()
+        local opts = pandoc.ReaderOptions {columns = 66}
+        assert.are_equal(opts.columns, 66)
+      end),
+      test('can construct from other ReaderOptions value', function ()
+        local orig = pandoc.ReaderOptions{columns = 65}
+        local copy = pandoc.ReaderOptions(orig)
+        for k, v in pairs(orig) do
+          assert.are_same(copy[k], v)
+        end
+        assert.are_equal(copy.columns, 65)
+      end),
+    },
+  },
 
   group 'clone' {
     test('clones Attr', function ()
@@ -163,6 +219,8 @@ return {
       local cloned = cite:clone()
       cite.id = 'newton'
       assert.are_same(cloned.id, 'leibniz')
+      assert.are_same(cite.id, 'newton')
+      assert.are_same(cite.mode, cloned.mode)
     end),
   },
 
@@ -205,6 +263,22 @@ return {
       })
       assert.are_same(expected, pandoc.read(valid_markdown))
     end),
+    test('unsupported extension', function ()
+      assert.error_matches(
+        function () pandoc.read('foo', 'gfm+empty_paragraphs') end,
+        'Extension empty_paragraphs not supported for gfm'
+      )
+    end),
+    test('read with other indented code classes', function()
+      local indented_code = '    return true'
+      local expected = pandoc.Pandoc({
+          pandoc.CodeBlock('return true', {class='foo'})
+      })
+      assert.are_same(
+        expected,
+        pandoc.read(indented_code, 'markdown', {indented_code_classes={'foo'}})
+      )
+    end),
     test('failing read', function ()
       assert.error_matches(
         function () pandoc.read('foo', 'nosuchreader') end,
@@ -249,5 +323,26 @@ return {
       )
       assert.are_equal('1234', table.concat(acc))
     end)
+  },
+
+  group 'Marshal' {
+    group 'Inlines' {
+      test('Strings are broken into words', function ()
+        assert.are_equal(
+          pandoc.Emph 'Nice, init?',
+          pandoc.Emph{pandoc.Str 'Nice,', pandoc.Space(), pandoc.Str 'init?'}
+        )
+      end)
+    },
+    group 'Blocks' {
+      test('Strings are broken into words and wrapped in Plain', function ()
+        assert.are_equal(
+          pandoc.Div{
+            pandoc.Plain{pandoc.Str 'Nice,', pandoc.Space(), pandoc.Str 'init?'}
+          },
+          pandoc.Div{'Nice, init?'}
+        )
+      end)
+    }
   }
 }