fix(newlines): merged sibling newlines after badge removal

Author: travi

package.json

@@ -81,6 +81,7 @@
   },
   "dependencies": {
     "mdast-util-definitions": "^2.0.1",
-    "unist-util-remove": "^2.0.0"
+    "unist-util-remove": "^2.0.0",
+    "unist-util-visit": "^2.0.2"
   }
 }

src/merge-newlines-in-paragraph-test.js

@@ -0,0 +1,76 @@
+import any from '@travi/any';
+import {assert} from 'chai';
+import mergeNewlines from './merge-newlines-in-paragraph';
+
+suite('merge newlines in a paragraph', () => {
+  const originalChildren = any.listOf(any.simpleObject);
+  const index = any.integer({max: originalChildren.length - 1});
+
+  test('that a newline node is removed if its direct sibling is also a newline', () => {
+    const node = {...any.simpleObject(), type: 'text', value: '\n'};
+    const parent = {
+      ...any.simpleObject(),
+      type: 'paragraph',
+      children: [
+        ...originalChildren.slice(0, index),
+        {type: 'text', value: '\n'},
+        {type: 'text', value: '\n'},
+        ...originalChildren.slice(index)
+      ]
+    };
+
+    mergeNewlines(node, index, parent);
+
+    assert.deepEqual(
+      parent.children,
+      [
+        ...originalChildren.slice(0, index),
+        {type: 'text', value: '\n'},
+        ...originalChildren.slice(index)
+      ]
+    );
+  });
+
+  test('that a newline node is removed if node is the last child of the parent', () => {
+    const node = {...any.simpleObject(), type: 'text', value: '\n'};
+    const parent = {
+      ...any.simpleObject(),
+      type: 'paragraph',
+      children: [
+        ...originalChildren,
+        {type: 'text', value: '\n'}
+      ]
+    };
+
+    mergeNewlines(node, originalChildren.length, parent);
+
+    assert.deepEqual(parent.children, originalChildren);
+  });
+
+  test('that the children of the parent are unchanged if the parent is not a `paragraph`', () => {
+    const node = {...any.simpleObject(), type: 'text', value: '\n'};
+    const parent = {...any.simpleObject(), children: [...originalChildren]};
+
+    mergeNewlines(node, index, parent);
+
+    assert.deepEqual(parent.children, originalChildren);
+  });
+
+  test('that the children of the parent are unchanged if the node is not a `text` node', () => {
+    const node = {...any.simpleObject(), type: any.word(), value: '\n'};
+    const parent = {...any.simpleObject(), children: [...originalChildren], type: 'paragraph'};
+
+    mergeNewlines(node, index, parent);
+
+    assert.deepEqual(parent.children, originalChildren);
+  });
+
+  test('that the children of the parent are unchanged if the node is not a newline', () => {
+    const node = {...any.simpleObject(), type: 'text', value: any.word()};
+    const parent = {...any.simpleObject(), children: [...originalChildren], type: 'paragraph'};
+
+    mergeNewlines(node, index, parent);
+
+    assert.deepEqual(parent.children, originalChildren);
+  });
+});

src/merge-newlines-in-paragraph.js

@@ -0,0 +1,17 @@
+function nodeIsLastChild(index, parent) {
+  return index === parent.children.length - 1;
+}
+
+function nextSiblingIsNewline(nextSibling) {
+  return nextSibling && 'text' === nextSibling.type && '\n' === nextSibling.value;
+}
+
+export default function (node, index, parent) {
+  if ('paragraph' === parent.type) {
+    const nextSibling = parent.children[index + 1];
+
+    if (nodeIsLastChild(index, parent) || nextSiblingIsNewline(nextSibling)) {
+      parent.children.splice(index, 1);
+    }
+  }
+}

src/plugin-test.js

@@ -2,7 +2,9 @@ import {assert} from 'chai';
 import any from '@travi/any';
 import sinon from 'sinon';
 import * as remove from '../thirdparty-wrappers/unist-util-remove';
+import * as visit from '../thirdparty-wrappers/unist-util-visit';
 import * as referencedBadgePredicateFactory from './referenced-badge-predicate';
+import mergeNewlines from './merge-newlines-in-paragraph';
 import {GREENKEEPER_URL} from './constants';
 import plugin from './plugin';
 
@@ -14,6 +16,7 @@ suite('plugin', () => {
 
     sandbox.stub(remove, 'default');
     sandbox.stub(referencedBadgePredicateFactory, 'default');
+    sandbox.stub(visit, 'default');
   });
 
   teardown(() => sandbox.restore());
@@ -29,5 +32,6 @@ suite('plugin', () => {
     assert.calledWith(remove.default, tree, {type: 'definition', identifier: 'greenkeeper-badge'});
     assert.calledWith(remove.default, tree, {type: 'definition', identifier: 'greenkeeper-link'});
     assert.calledWith(remove.default, tree, referencedBadgePredicate);
+    assert.calledWith(visit.default, tree, {type: 'text', value: '\n'}, mergeNewlines);
   });
 });

src/plugin.js

@@ -1,5 +1,7 @@
 import remove from '../thirdparty-wrappers/unist-util-remove';
+import visit from '../thirdparty-wrappers/unist-util-visit';
 import createReferencedBadgePredicate from './referenced-badge-predicate';
+import mergeNewlines from './merge-newlines-in-paragraph';
 import {GREENKEEPER_URL} from './constants';
 
 export default function () {
@@ -8,5 +10,6 @@ export default function () {
     remove(tree, createReferencedBadgePredicate(tree));
     remove(tree, {type: 'definition', identifier: 'greenkeeper-badge'});
     remove(tree, {type: 'definition', identifier: 'greenkeeper-link'});
+    visit(tree, {type: 'text', value: '\n'}, mergeNewlines);
   };
 }

test/integration/features/step_definitions/badge-steps.js

@@ -14,9 +14,14 @@ const inlineGreenkeeperBadge = `[![Greenkeeper badge](https://badges.greenkeeper
 }.svg)](https://greenkeeper.io/)`;
 const greenkeeperBadgeWithReferencedDefinitions = '[![Greenkeeper][greenkeeper-badge]][greenkeeper-link]';
 const otherInlineBadge = `[![${any.word()}](${any.url()})](${any.url()})`;
+const anotherInlineBadge = `[![${any.word()}](${any.url()})](${any.url()})`;
 const otherBadgeWithReferencedDefinitions = `[![${any.word()}][${imageReference}]][${linkReference}]`;
+const anotherBadgeWithReferencedDefinitions = `[![${any.word()}][${imageReference}]][${linkReference}]`;
 const otherBadgeDefinitions = `[${imageReference}]: ${any.url()}
 
+[${linkReference}]: ${any.url()}`;
+const anotherSetOfBadgeDefinitions = `[${imageReference}]: ${any.url()}
+
 [${linkReference}]: ${any.url()}`;
 
 Before(function () {
@@ -42,26 +47,32 @@ Given('a greenkeeper badge exists with referenced definitions', async function (
 });
 
 Given('other inline badges exist', async function () {
+  this.badgeGroup.unshift(anotherInlineBadge);
   this.badgeGroup.push(otherInlineBadge);
+  otherBadges.push(anotherInlineBadge);
   otherBadges.push(otherInlineBadge);
 });
 
 Given('other badges exist with referenced definitions', async function () {
+  this.badgeGroup.unshift(anotherBadgeWithReferencedDefinitions);
   this.badgeGroup.push(otherBadgeWithReferencedDefinitions);
+  otherBadges.push(anotherBadgeWithReferencedDefinitions);
   otherBadges.push(otherBadgeWithReferencedDefinitions);
 
   this.badgeDefinitions.push(otherBadgeDefinitions);
+  this.badgeDefinitions.push(anotherSetOfBadgeDefinitions);
   otherDefinitions.push(otherBadgeDefinitions);
+  otherDefinitions.push(anotherSetOfBadgeDefinitions);
 });
 
 Then('the greenkeeper badge is removed from the README', async function () {
   assert.equal(
     this.resultingContent,
-    `# some-project
-${otherBadges.length ? `
+    `# some-project${otherBadges.length ? `
 
 ${otherBadges.join('\n')}
-` : ''}
+` : `
+`}
 ${normalLink}${otherDefinitions.length ? `
 
 ${otherDefinitions.join('\n\n')}` : ''}

thirdparty-wrappers/unist-util-visit.js

@@ -0,0 +1,3 @@
+import visit from 'unist-util-visit';
+
+export default visit;