Add interface for spreading flow, fix spread

Closes GH-4.

Author: wooorm

lib/index.js

@@ -3,10 +3,8 @@ module.exports = toMarkdown
 var zwitch = require('zwitch')
 var defaultHandlers = require('./handle')
 var defaultUnsafePatterns = require('./unsafe')
+var defaultJoin = require('./join')
 
-// To do (extension)
-// - GFM: `tableCellPadding`, `tablePipeAlign`, `stringLength`.
-// - Footnotes: `footnote`, `footnoteDefinition`, `footnoteReference`.
 function toMarkdown(tree, options) {
   var settings = options || {}
   var extensions = configure(settings)
@@ -21,7 +19,8 @@ function toMarkdown(tree, options) {
     stack: stack,
     enter: enter,
     options: settings,
-    unsafePatterns: extensions.unsafe
+    unsafePatterns: extensions.unsafe,
+    join: extensions.join
   }
   var result = handle(tree, null, context, {before: '\n', after: '\n'})
 
@@ -55,19 +54,32 @@ function unknown(node) {
 
 function configure(settings) {
   var unsafe = defaultUnsafePatterns
+  var join = defaultJoin
   var handlers = Object.assign({}, defaultHandlers)
   var extensions = [
-    {unsafe: settings.unsafe, handlers: settings.handlers}
+    {unsafe: settings.unsafe, handlers: settings.handlers, join: settings.join}
   ].concat(settings.extensions || [])
   var length = extensions.length
   var index = -1
   var extension
 
+  if (settings.tightDefinitions) {
+    join = [joinDefinition].concat(join)
+  }
+
   while (++index < length) {
     extension = extensions[index]
     unsafe = unsafe.concat(extension.unsafe || [])
+    join = join.concat(extension.join || [])
     handlers = Object.assign(handlers, extension.handlers || {})
   }
 
-  return {unsafe: unsafe, handlers: handlers}
+  return {unsafe: unsafe, join: join, handlers: handlers}
+}
+
+function joinDefinition(left, right) {
+  // No blank line between adjacent definitions.
+  if (left.type === 'definition' && left.type === right.type) {
+    return 0
+  }
 }

lib/join.js

@@ -0,0 +1,39 @@
+module.exports = [joinDefaults]
+
+var formatCodeAsIndented = require('./util/format-code-as-indented')
+var formatHeadingAsSetext = require('./util/format-heading-as-setext')
+
+function joinDefaults(left, right, parent, context) {
+  if (
+    // Two lists with the same marker.
+    (left.type === 'list' &&
+      right.type === left.type &&
+      Boolean(left.ordered) === Boolean(right.ordered)) ||
+    // Adjacent quotes.
+    (left.type === 'blockquote' && right.type === left.type) ||
+    // Indented code after list or another indented code.
+    (right.type === 'code' &&
+      formatCodeAsIndented(right, context) &&
+      (left.type === 'list' ||
+        (left.type === right.type && formatCodeAsIndented(left, context))))
+  ) {
+    return false
+  }
+
+  // Join children of a list or an item.
+  // In which case, `parent` has a `spread` field.
+  if (typeof parent.spread === 'boolean') {
+    if (
+      left.type === 'paragraph' &&
+      // Two paragraphs.
+      (left.type === right.type ||
+        right.type === 'definition' ||
+        // Paragraph followed by a setext heading.
+        (right.type === 'heading' && formatHeadingAsSetext(right, context)))
+    ) {
+      return
+    }
+
+    return parent.spread ? 1 : 0
+  }
+}

lib/util/container-flow.js

@@ -1,46 +1,50 @@
 module.exports = flow
 
-var formatCodeAsIndented = require('../util/format-code-as-indented')
+var repeat = require('repeat-string')
 
 function flow(parent, context) {
   var children = parent.children || []
   var length = children.length
-  var index = -1
-  var results = []
   var next = children[0]
-  // Act as if we’re between eols, because we are.
-  var safeOptions = {before: '\n', after: '\n'}
+  var results = []
+  var index = -1
   var child
-  var after
 
   while (++index < length) {
     child = next
     next = children[index + 1]
 
-    results.push(context.handle(child, parent, context, safeOptions))
+    results.push(
+      context.handle(child, parent, context, {before: '\n', after: '\n'})
+    )
 
     if (next) {
-      if (
-        child.type === 'list' &&
-        ((next.type === 'code' && formatCodeAsIndented(next, context)) ||
-          (child.type === next.type &&
-            Boolean(child.ordered) === Boolean(next.ordered)))
-      ) {
-        after = '\n\n<!---->\n\n'
-      } else if (
-        parent.spread === false ||
-        (context.options.tightDefinitions &&
-          child.type === 'definition' &&
-          child.type === next.type)
-      ) {
-        after = '\n'
-      } else {
-        after = '\n\n'
-      }
-
-      results.push(after)
+      results.push(between(child, next))
     }
   }
 
   return results.join('')
+
+  function between(left, right) {
+    var index = -1
+    var result
+
+    while (++index < context.join.length) {
+      result = context.join[index](left, right, parent, context)
+
+      if (result === true || result === 1) {
+        break
+      }
+
+      if (typeof result === 'number') {
+        return repeat('\n', 1 + Number(result))
+      }
+
+      if (result === false) {
+        return '\n\n<!---->\n\n'
+      }
+    }
+
+    return '\n\n'
+  }
 }

readme.md

@@ -135,8 +135,16 @@ Marker to use to serialize strong (`'*'` or `'_'`, default: `'*'`).
 
 ###### `options.tightDefinitions`
 
-Whether to separate definitions with a single line feed (`boolean`, default:
-`false`).
+Whether to join definitions w/o a blank line (`boolean`, default: `false`).
+Shortcut for a join function like so:
+
+```js
+function (left, right) {
+  if (left.type === 'definition' && right.type === 'definition') {
+    return 0
+  }
+}
+```
 
 ##### Extension options
 
@@ -147,18 +155,39 @@ Each `ToMarkdownExtension` is an object with optional `unsafe` and `handlers`
 keys, mapping to the values which can also be passed in directly, documented
 below.
 
-###### `options.unsafe`
-
-List of patterns to escape.
-Useful for syntax extensions.
-Take a look at [`lib/unsafe.js`][unsafe] for examples.
-
 ###### `options.handlers`
 
 Object mapping node types to custom handlers.
 Useful for syntax extensions.
 Take a look at [`lib/handle`][handlers] for examples.
 
+###### `options.join`
+
+List of functions used to determine what to place between two flow nodes.
+Often, they are joined by one blank line.
+In certain cases, it’s nicer to have them next to each other.
+Or, they can’t occur together.
+These functions receive two adjacent nodes and their parent and can return
+`number` or `boolean`, referring to how many blank lines to use between them.
+A return value of `true` is as passing `1`.
+A return value of `false` means the nodes cannot be joined by a blank line, such
+as two adjacent block quotes or indented code after a list, in which case a
+comment will be injected to break them up:
+
+```markdown
+> Quote 1
+
+<!---->
+
+> Quote 2
+```
+
+###### `options.unsafe`
+
+List of patterns to escape.
+Useful for syntax extensions.
+Take a look at [`lib/unsafe.js`][unsafe] for examples.
+
 ##### Returns
 
 `string` — Serialized markdown.

test.js

@@ -66,7 +66,7 @@ test('core', function (t) {
       ]
     }),
     'a\n\n*\n\n<!---->\n\n*\n\n1.\n\n<!---->\n\n1.\n\nd\n',
-    'should inject HTML comments between lists w/ the same ordered as they’d otherwise run into each other'
+    'should inject HTML comments between lists w/ the same marker'
   )
 
   t.equal(
@@ -79,7 +79,96 @@ test('core', function (t) {
       ]
     }),
     '    a\n\n*\n\n<!---->\n\n    b\n',
-    'should inject HTML comments between lists and an indented code as they’d otherwise run into each other'
+    'should inject HTML comments between lists and an indented code'
+  )
+
+  t.equal(
+    to({
+      type: 'root',
+      children: [
+        {type: 'code', value: 'a'},
+        {type: 'code', value: 'b'}
+      ]
+    }),
+    '    a\n\n<!---->\n\n    b\n',
+    'should inject HTML comments between adjacent indented code'
+  )
+
+  t.equal(
+    to({
+      type: 'root',
+      children: [
+        {
+          type: 'blockquote',
+          children: [
+            {type: 'paragraph', children: [{type: 'text', value: 'a'}]}
+          ]
+        },
+        {
+          type: 'blockquote',
+          children: [
+            {type: 'paragraph', children: [{type: 'text', value: 'b'}]}
+          ]
+        }
+      ]
+    }),
+    '> a\n\n<!---->\n\n> b\n',
+    'should inject HTML comments between two block quotes'
+  )
+
+  t.equal(
+    to({
+      type: 'listItem',
+      spread: false,
+      children: [
+        {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
+        {type: 'paragraph', children: [{type: 'text', value: 'b'}]}
+      ]
+    }),
+    '*   a\n\n    b\n',
+    'should not honour `spread: false` for two paragraphs'
+  )
+
+  t.equal(
+    to({
+      type: 'listItem',
+      spread: false,
+      children: [
+        {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
+        {type: 'definition', label: 'b', url: 'c'}
+      ]
+    }),
+    '*   a\n\n    [b]: c\n',
+    'should not honour `spread: false` for a paragraph and a definition'
+  )
+
+  t.equal(
+    to({
+      type: 'listItem',
+      spread: false,
+      children: [
+        {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
+        {type: 'heading', depth: 1, children: [{type: 'text', value: 'b'}]}
+      ]
+    }),
+    '*   a\n    # b\n',
+    'should honour `spread: false` for a paragraph and a heading'
+  )
+
+  t.equal(
+    to(
+      {
+        type: 'listItem',
+        spread: false,
+        children: [
+          {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
+          {type: 'heading', depth: 1, children: [{type: 'text', value: 'b'}]}
+        ]
+      },
+      {setext: true}
+    ),
+    '*   a\n\n    b\n    =\n',
+    'should not honour `spread: false` for a paragraph and a setext heading'
   )
 
   t.throws(