Update for changes in mdast

Author: wooorm

index.js

@@ -6,10 +6,10 @@ var zwitch = require('zwitch')
 var mapz = require('mapz')
 var unist = require('unist-util-assert')
 
-/* Construct. */
+// Construct.
 var mdast = zwitch('type')
 
-/* Expose. */
+// Expose.
 exports = unist.wrap(mdast)
 module.exports = exports
 
@@ -19,11 +19,11 @@ exports.void = unist.void
 exports.wrap = unist.wrap
 exports.all = mapz(exports, {key: 'children', indices: false})
 
-/* Core interface. */
+// Core interface.
 mdast.unknown = unknown
 mdast.invalid = unknown
 
-/* Per-type handling. */
+// Per-type handling.
 mdast.handlers = {
   root: unist.wrap(root),
   paragraph: exports.parent,
@@ -39,6 +39,7 @@ mdast.handlers = {
   text: exports.text,
   inlineCode: exports.text,
   yaml: exports.text,
+  toml: exports.text,
   code: unist.wrap(code),
   thematicBreak: exports.void,
   break: exports.void,
@@ -72,11 +73,11 @@ function root(node, ancestor) {
 function list(node) {
   parent(node)
 
-  if (node.loose != null) {
+  if (node.spread != null) {
     assert.strictEqual(
-      typeof node.loose,
+      typeof node.spread,
       'boolean',
-      '`loose` must be `boolean`'
+      '`spread` must be `boolean`'
     )
   }
 
@@ -103,11 +104,11 @@ function list(node) {
 function listItem(node) {
   parent(node)
 
-  if (node.loose != null) {
+  if (node.spread != null) {
     assert.strictEqual(
-      typeof node.loose,
+      typeof node.spread,
       'boolean',
-      '`loose` must be `boolean`'
+      '`spread` must be `boolean`'
     )
   }
 
@@ -133,6 +134,11 @@ function code(node) {
   if (node.lang != null) {
     assert.strictEqual(typeof node.lang, 'string', '`lang` must be `string`')
   }
+
+  if (node.meta != null) {
+    assert.ok(node.lang != null, 'code with `meta` must also have `lang`')
+    assert.strictEqual(typeof node.meta, 'string', '`meta` must be `string`')
+  }
 }
 
 function footnoteDefinition(node) {
@@ -143,6 +149,10 @@ function footnoteDefinition(node) {
     'string',
     '`footnoteDefinition` must have `identifier`'
   )
+
+  if (node.label != null) {
+    assert.strictEqual(typeof node.label, 'string', '`label` must be `string`')
+  }
 }
 
 function definition(node) {
@@ -154,10 +164,12 @@ function definition(node) {
     '`identifier` must be `string`'
   )
 
-  if (node.url != null) {
-    assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
+  if (node.label != null) {
+    assert.strictEqual(typeof node.label, 'string', '`label` must be `string`')
   }
 
+  assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
+
   if (node.title != null) {
     assert.strictEqual(typeof node.title, 'string', '`title` must be `string`')
   }
@@ -166,9 +178,7 @@ function definition(node) {
 function link(node) {
   parent(node)
 
-  if (node.url != null) {
-    assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
-  }
+  assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
 
   if (node.title != null) {
     assert.strictEqual(typeof node.title, 'string', '`title` must be `string`')
@@ -178,17 +188,15 @@ function link(node) {
 function image(node) {
   unist.void(node)
 
-  if (node.url != null) {
-    assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
+  assert.strictEqual(typeof node.url, 'string', '`url` must be `string`')
+
+  if (node.title != null) {
+    assert.strictEqual(typeof node.title, 'string', '`title` must be `string`')
   }
 
   if (node.alt != null) {
     assert.strictEqual(typeof node.alt, 'string', '`alt` must be `string`')
   }
-
-  if (node.title != null) {
-    assert.strictEqual(typeof node.title, 'string', '`title` must be `string`')
-  }
 }
 
 function linkReference(node) {
@@ -200,6 +208,10 @@ function linkReference(node) {
     '`identifier` must be `string`'
   )
 
+  if (node.label != null) {
+    assert.strictEqual(typeof node.label, 'string', '`label` must be `string`')
+  }
+
   if (node.referenceType != null) {
     assert.notStrictEqual(
       ['shortcut', 'collapsed', 'full'].indexOf(node.referenceType),
@@ -218,6 +230,10 @@ function imageReference(node) {
     '`identifier` must be `string`'
   )
 
+  if (node.label != null) {
+    assert.strictEqual(typeof node.label, 'string', '`label` must be `string`')
+  }
+
   if (node.alt != null) {
     assert.strictEqual(typeof node.alt, 'string', '`alt` must be `string`')
   }
@@ -239,6 +255,10 @@ function footnoteReference(node) {
     'string',
     '`identifier` must be `string`'
   )
+
+  if (node.label != null) {
+    assert.strictEqual(typeof node.label, 'string', '`label` must be `string`')
+  }
 }
 
 function table(node) {

test/code.js

@@ -24,5 +24,21 @@ test('assert(code)', function(t) {
     'should throw if `lang` is not a string'
   )
 
+  t.throws(
+    function() {
+      assert({type: 'code', lang: 'js', meta: 1, value: ''})
+    },
+    /`meta` must be `string`: `{ type: 'code', lang: 'js', meta: 1, value: '' }`$/,
+    'should throw if `meta` is not a string'
+  )
+
+  t.throws(
+    function() {
+      assert({type: 'code', meta: '', value: ''})
+    },
+    /code with `meta` must also have `lang`: `{ type: 'code', meta: '', value: '' }`$/,
+    'should throw if `meta` is defined but not `lang`'
+  )
+
   t.end()
 })

test/definition.js

@@ -12,6 +12,14 @@ test('assert(definition)', function(t) {
     'should throw if `definition` has no `identifier`'
   )
 
+  t.throws(
+    function() {
+      assert({type: 'definition', identifier: '1'})
+    },
+    /`url` must be `string`: `{ type: 'definition', identifier: '1' }`$/,
+    'should throw if `definition` has no `url`'
+  )
+
   t.throws(
     function() {
       assert({type: 'definition', identifier: 1})
@@ -20,24 +28,32 @@ test('assert(definition)', function(t) {
     'should throw if `identifier` is not a `string`'
   )
 
+  t.throws(
+    function() {
+      assert({type: 'definition', url: 1})
+    },
+    /`identifier` must be `string`: `{ type: 'definition', url: 1 }`$/,
+    'should throw if `url` is not a `string`'
+  )
+
   t.doesNotThrow(function() {
-    assert({type: 'definition', identifier: '1'})
+    assert({type: 'definition', identifier: '1', url: '1'})
   }, 'should not throw if `definition` has no other properties')
 
   t.throws(
     function() {
-      assert({type: 'definition', identifier: '1', url: 1})
+      assert({type: 'definition', identifier: '1', url: '1', title: 1})
     },
-    /`url` must be `string`: `{ type: 'definition', identifier: '1', url: 1 }`$/,
-    'should throw if `identifier` is not a `string`'
+    /`title` must be `string`: `{ type: 'definition', identifier: '1', url: '1', title: 1 }`$/,
+    'should throw if `title` is not a `string`'
   )
 
   t.throws(
     function() {
-      assert({type: 'definition', identifier: '1', title: 1})
+      assert({type: 'definition', identifier: '1', url: '1', label: 1})
     },
-    /`title` must be `string`: `{ type: 'definition', identifier: '1', title: 1 }`$/,
-    'should throw if `title` is not a `string`'
+    /`label` must be `string`: `{ type: 'definition', identifier: '1', url: '1', label: 1 }`$/,
+    'should throw if `label` is not a `string`'
   )
 
   t.end()

test/footnote-definition.js

@@ -32,5 +32,18 @@ test('assert(footnoteDefinition)', function(t) {
     assert({type: 'footnoteDefinition', identifier: '1', children: []})
   }, 'should not throw if `footnoteDefinition` has an identifier')
 
+  t.throws(
+    function() {
+      assert({
+        type: 'footnoteDefinition',
+        identifier: '1',
+        label: 1,
+        children: []
+      })
+    },
+    /`label` must be `string`: `{ type: 'footnoteDefinition',\s+identifier: '1',\s+label: 1,\s+children: \[] }`$/,
+    'should throw if `label` is not a `string`'
+  )
+
   t.end()
 })

test/footnote-reference.js

@@ -24,5 +24,13 @@ test('assert(footnoteReference)', function(t) {
     assert({type: 'footnoteReference', identifier: '1'})
   }, 'should not throw if `footnoteReference` has no other properties')
 
+  t.throws(
+    function() {
+      assert({type: 'footnoteReference', identifier: '1', label: 1})
+    },
+    /`label` must be `string`: `{ type: 'footnoteReference', identifier: '1', label: 1 }`$/,
+    'should throw if `label` is not a `string`'
+  )
+
   t.end()
 })

test/image-reference.js

@@ -48,5 +48,13 @@ test('assert(imageReference)', function(t) {
     })
   }, 'should not throw if `referenceType` is valid')
 
+  t.throws(
+    function() {
+      assert({type: 'imageReference', identifier: '1', label: 1})
+    },
+    /`label` must be `string`: `{ type: 'imageReference', identifier: '1', label: 1 }`$/,
+    'should throw if `label` is not a `string`'
+  )
+
   t.end()
 })

test/image.js

@@ -4,31 +4,39 @@ var test = require('tape')
 var assert = require('..')
 
 test('assert(image)', function(t) {
-  t.doesNotThrow(function() {
-    assert({type: 'image'})
-  }, 'should not throw if `image` has no other properties')
+  t.throws(
+    function() {
+      assert({type: 'image'})
+    },
+    /`url` must be `string`: `{ type: 'image' }`$/,
+    'should throw without `url`'
+  )
 
   t.throws(
     function() {
       assert({type: 'image', url: 1})
     },
     /`url` must be `string`: `{ type: 'image', url: 1 }`$/,
-    'should throw if `identifier` is not a `string`'
+    'should throw if `url` is not a `string`'
   )
 
+  t.doesNotThrow(function() {
+    assert({type: 'image', url: '1'})
+  }, 'should not throw if `image` has no other properties')
+
   t.throws(
     function() {
-      assert({type: 'image', title: 1})
+      assert({type: 'image', url: '1', title: 1})
     },
-    /`title` must be `string`: `{ type: 'image', title: 1 }`$/,
+    /`title` must be `string`: `{ type: 'image', url: '1', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   )
 
   t.throws(
     function() {
-      assert({type: 'image', alt: 1})
+      assert({type: 'image', url: '1', alt: 1})
     },
-    /`alt` must be `string`: `{ type: 'image', alt: 1 }`$/,
+    /`alt` must be `string`: `{ type: 'image', url: '1', alt: 1 }`$/,
     'should throw if `alt` is not a `string`'
   )
 

test/link-reference.js

@@ -54,5 +54,13 @@ test('assert(linkReference)', function(t) {
     })
   }, 'should not throw if `referenceType` is valid')
 
+  t.throws(
+    function() {
+      assert({type: 'linkReference', identifier: '1', children: [], label: 1})
+    },
+    /`label` must be `string`: `{ type: 'linkReference', identifier: '1', children: \[], label: 1 }`$/,
+    'should throw if `label` is not a `string`'
+  )
+
   t.end()
 })

test/link.js

@@ -12,23 +12,31 @@ test('assert(link)', function(t) {
     'should throw if `link` is not a parent'
   )
 
-  t.doesNotThrow(function() {
-    assert({type: 'link', children: []})
-  }, 'should not throw if `link` has no other properties')
+  t.throws(
+    function() {
+      assert({type: 'link', children: []})
+    },
+    /`url` must be `string`: `{ type: 'link', children: \[] }`$/,
+    'should throw without `url`'
+  )
 
   t.throws(
     function() {
       assert({type: 'link', children: [], url: 1})
     },
     /`url` must be `string`: `{ type: 'link', children: \[], url: 1 }`$/,
-    'should throw if `identifier` is not a `string`'
+    'should throw if `url` is not a `string`'
   )
 
+  t.doesNotThrow(function() {
+    assert({type: 'link', children: [], url: '1'})
+  }, 'should not throw if `link` has no other properties')
+
   t.throws(
     function() {
-      assert({type: 'link', children: [], title: 1})
+      assert({type: 'link', children: [], url: '1', title: 1})
     },
-    /`title` must be `string`: `{ type: 'link', children: \[], title: 1 }`$/,
+    /`title` must be `string`: `{ type: 'link', children: \[], url: '1', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   )