Add errors when extensions mess up

Author: wooorm

Diff for: lib/index.js

@@ -7,14 +7,16 @@ var codes = require('micromark/lib/character/codes')
 var constants = require('micromark/lib/constant/constants')
 var types = require('micromark/lib/constant/types')
 
-var decode = require('parse-entities/decode-entity')
 var toString = require('mdast-util-to-string')
+var assign = require('micromark/dist/constant/assign')
 var own = require('micromark/dist/constant/has-own-property')
 var normalizeIdentifier = require('micromark/dist/util/normalize-identifier')
 var safeFromInt = require('micromark/dist/util/safe-from-int')
 var parser = require('micromark/dist/parse')
 var preprocessor = require('micromark/dist/preprocess')
 var postprocess = require('micromark/dist/postprocess')
+var decode = require('parse-entities/decode-entity')
+var stringifyPosition = require('unist-util-stringify-position')
 
 function fromMarkdown(value, encoding, options) {
   if (typeof encoding !== 'string') {
@@ -144,13 +146,26 @@ function compiler(options) {
 
   function compile(events) {
     var stack = [{type: 'root', children: []}]
+    var tokenStack = []
     var index = -1
     var listStack = []
     var length
     var handler
     var listStart
     var event
 
+    var context = {
+      stack: stack,
+      tokenStack: tokenStack,
+      config: config,
+      enter: enter,
+      exit: exit,
+      buffer: buffer,
+      resume: resume,
+      setData: setData,
+      getData: getData
+    }
+
     while (++index < events.length) {
       event = events[index]
 
@@ -177,22 +192,25 @@ function compiler(options) {
 
       if (own.call(handler, events[index][1].type)) {
         handler[events[index][1].type].call(
-          {
-            stack: stack,
-            config: config,
-            enter: enter,
-            exit: exit,
-            buffer: buffer,
-            resume: resume,
-            sliceSerialize: events[index][2].sliceSerialize,
-            setData: setData,
-            getData: getData
-          },
+          assign({sliceSerialize: events[index][2].sliceSerialize}, context),
           events[index][1]
         )
       }
     }
 
+    if (tokenStack.length > 0) {
+      throw new Error(
+        'Cannot close document, a token (`' +
+          tokenStack[tokenStack.length - 1].type +
+          '`, ' +
+          stringifyPosition({
+            start: tokenStack[tokenStack.length - 1].start,
+            end: tokenStack[tokenStack.length - 1].end
+          }) +
+          ') is still open'
+      )
+    }
+
     // Figure out `root` position.
     stack[0].position = {
       start: point(
@@ -367,6 +385,7 @@ function compiler(options) {
   function enter(node, token) {
     this.stack[this.stack.length - 1].children.push(node)
     this.stack.push(node)
+    this.tokenStack.push(token)
     node.position = {start: point(token.start)}
     return node
   }
@@ -382,6 +401,30 @@ function compiler(options) {
 
   function exit(token) {
     var node = this.stack.pop()
+    var open = this.tokenStack.pop()
+
+    if (!open) {
+      throw new Error(
+        'Cannot close `' +
+          token.type +
+          '` (' +
+          stringifyPosition({start: token.start, end: token.end}) +
+          '): it’s not open'
+      )
+    } else if (open.type !== token.type) {
+      throw new Error(
+        'Cannot close `' +
+          token.type +
+          '` (' +
+          stringifyPosition({start: token.start, end: token.end}) +
+          '): a different token (`' +
+          open.type +
+          '`, ' +
+          stringifyPosition({start: open.start, end: open.end}) +
+          ') is open'
+      )
+    }
+
     node.position.end = point(token.end)
     return node
   }

Diff for: test/index.js

@@ -123,6 +123,52 @@ test('mdast-util-from-markdown', function (t) {
     this.exit(token)
   }
 
+  t.throws(
+    function () {
+      fromMarkdown('a', {
+        mdastExtensions: [
+          {enter: {paragraph: brokenParagraph}, exit: {paragraph: noop}}
+        ]
+      })
+
+      function brokenParagraph(token) {
+        this.enter({type: 'paragraph', children: []}, token)
+      }
+
+      function noop() {}
+    },
+    /Cannot close document, a token \(`paragraph`, 1:1-1:2\) is still open/,
+    'should crash if a token is opened but not closed'
+  )
+
+  t.throws(
+    function () {
+      fromMarkdown('a', {
+        mdastExtensions: [{enter: {paragraph: brokenParagraph}}]
+      })
+
+      function brokenParagraph(token) {
+        this.exit(token)
+      }
+    },
+    /Cannot close `paragraph` \(1:1-1:2\): it’s not open/,
+    'should crash when closing a token that isn’t open'
+  )
+
+  t.throws(
+    function () {
+      fromMarkdown('a', {
+        mdastExtensions: [{exit: {paragraph: brokenParagraph}}]
+      })
+
+      function brokenParagraph(token) {
+        this.exit(Object.assign({}, token, {type: 'lol'}))
+      }
+    },
+    /Cannot close `lol` \(1:1-1:2\): a different token \(`paragraph`, 1:1-1:2\) is open/,
+    'should crash when closing a token when a different one is open'
+  )
+
   t.deepEqual(
     fromMarkdown('<tel:123>').children[0],
     {