From 0f69dc10ce8ba3a2085adb304d0d0aec0154b9c3 Mon Sep 17 00:00:00 2001
From: Matthew Beale <matt.beale@madhatted.com>
Date: Wed, 22 Jul 2015 15:53:16 -0400
Subject: [PATCH] Post nodes no longer store closed and open, but all their
 markups

---
 src/js/models/image.js                  |   4 +-
 src/js/models/marker.js                 |  43 +++++--
 src/js/models/markup-section.js         |   6 +-
 src/js/models/markup.js                 |  16 ++-
 src/js/parsers/dom.js                   |  36 ++----
 src/js/parsers/mobiledoc.js             |  10 +-
 src/js/parsers/section.js               |  12 +-
 src/js/renderers/editor-dom.js          |  13 +-
 src/js/renderers/mobiledoc.js           |  23 ++--
 src/js/utils/post-builder.js            |  27 ++---
 tests/unit/models/marker-test.js        |   8 +-
 tests/unit/models/section-test.js       |   2 +-
 tests/unit/parsers/dom-test.js          | 151 +++++++++++++-----------
 tests/unit/parsers/mobiledoc-test.js    |  12 +-
 tests/unit/renderers/editor-dom-test.js |   4 +-
 tests/unit/renderers/mobiledoc-test.js  |   6 +-
 16 files changed, 196 insertions(+), 177 deletions(-)

diff --git a/src/js/models/image.js b/src/js/models/image.js
index b78610114..aadf218ea 100644
--- a/src/js/models/image.js
+++ b/src/js/models/image.js
@@ -1,6 +1,8 @@
+export const IMAGE_SECTION_TYPE = 'image-section';
+
 export default class Image {
   constructor() {
-    this.type = 'imageSection';
+    this.type = IMAGE_SECTION_TYPE;
     this.src = null;
   }
 }
diff --git a/src/js/models/marker.js b/src/js/models/marker.js
index fcf281cef..dd9b69ba6 100644
--- a/src/js/models/marker.js
+++ b/src/js/models/marker.js
@@ -1,5 +1,4 @@
-export const MARKUP_TAG_NAMES = ['b', 'a', 'i', 'em', 'strong'];
-const MARKER_TYPE = 'marker';
+export const MARKER_TYPE = 'marker';
 
 import { detect } from 'content-kit-editor/utils/array-utils';
 
@@ -9,7 +8,9 @@ const Marker = class Marker {
     this.markups = [];
     this.type = MARKER_TYPE;
 
-    markups.forEach(m => this.addMarkup(m));
+    if (markups && markups.length) {
+      markups.forEach(m => this.addMarkup(m));
+    }
   }
 
   get length() {
@@ -25,15 +26,7 @@ const Marker = class Marker {
   }
 
   addMarkup(markup) {
-    const {tagName} = markup;
-
-    if (MARKUP_TAG_NAMES.indexOf(tagName) === -1) {
-      throw new Error(`Cannot add markup of tagName ${tagName}`);
-    }
-
-    if (!this.hasMarkup(tagName)) {
-      this.markups.push(markup);
-    }
+    this.markups.push(markup);
   }
 
   hasMarkup(tagName) {
@@ -62,6 +55,32 @@ const Marker = class Marker {
 
     return [m1, m2];
   }
+
+  get openedMarkups() {
+    if (!this.previousSibling) {
+      return this.markups.slice();
+    }
+    let i;
+    for (i=0; i<this.markups.length; i++) {
+      if (this.markups[i] !== this.previousSibling.markups[i]) {
+        return this.markups.slice(i);
+      }
+    }
+    return [];
+  }
+
+  get closedMarkups() {
+    if (!this.nextSibling) {
+      return this.markups.slice();
+    }
+    let i;
+    for (i=0; i<this.markups.length; i++) {
+      if (this.markups[i] !== this.nextSibling.markups[i]) {
+        return this.markups.slice(i);
+      }
+    }
+    return [];
+  }
 };
 
 export default Marker;
diff --git a/src/js/models/markup-section.js b/src/js/models/markup-section.js
index 5821c1811..122a9ed1e 100644
--- a/src/js/models/markup-section.js
+++ b/src/js/models/markup-section.js
@@ -1,12 +1,12 @@
 export const DEFAULT_TAG_NAME = 'p';
-export const SECTION_TAG_NAMES = [
-  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'div'
+export const VALID_MARKUP_SECTION_TAGNAMES = [
+  'p', 'h3', 'h2', 'h1', 'blockquote', 'ul', 'ol'
 ];
 export const MARKUP_SECTION_TYPE = 'markup-section';
 
 export default class Section {
   constructor(tagName, markers=[]) {
-    this.markers = markers;
+    this.markers = [];
     this.tagName = tagName || DEFAULT_TAG_NAME;
     this.type = MARKUP_SECTION_TYPE;
 
diff --git a/src/js/models/markup.js b/src/js/models/markup.js
index 8e75f2a15..8acc254c5 100644
--- a/src/js/models/markup.js
+++ b/src/js/models/markup.js
@@ -1,9 +1,21 @@
-const MARKUP_TYPE = 'markup';
+export const MARKUP_TYPE = 'markup';
+export const VALID_MARKUP_TAGNAMES = [
+  'b',
+  'i',
+  'strong',
+  'em',
+  'a',
+  'li'
+];
 
 export default class Markup {
-  constructor(tagName, attributes={}) {
+  constructor(tagName, attributes=[]) {
     this.tagName = tagName.toLowerCase();
     this.attributes = attributes;
     this.type = MARKUP_TYPE;
+
+    if (VALID_MARKUP_TAGNAMES.indexOf(this.tagName) === -1) {
+      throw new Error(`Cannot create markup of tagName ${tagName}`);
+    }
   }
 }
diff --git a/src/js/parsers/dom.js b/src/js/parsers/dom.js
index ef5c372d3..0b8a3d50a 100644
--- a/src/js/parsers/dom.js
+++ b/src/js/parsers/dom.js
@@ -1,11 +1,11 @@
 import { generateBuilder } from '../utils/post-builder';
 import { trim } from 'content-kit-utils';
+import { VALID_MARKUP_SECTION_TAGNAMES } from '../models/markup-section';
+import { VALID_MARKUP_TAGNAMES } from '../models/markup';
 
 const ELEMENT_NODE = 1;
 const TEXT_NODE = 3;
 
-const MARKUP_SECTION_TAG_NAMES = ['P', 'H3', 'H2', 'H1', 'BLOCKQUOTE', 'UL', 'OL'];
-
 const ALLOWED_ATTRIBUTES = ['href', 'rel', 'src'];
 
 function isEmptyTextNode(node) {
@@ -57,28 +57,19 @@ function readAttributes(node) {
   return null;
 }
 
-const VALID_MARKER_ELEMENTS = [
-  'B',
-  'I',
-  'STRONG',
-  'EM',
-  'A',
-  'LI'
-];
-
 function isValidMarkerElement(element) {
-  return VALID_MARKER_ELEMENTS.indexOf(element.tagName) !== -1;
+  return VALID_MARKUP_TAGNAMES.indexOf(element.tagName.toLowerCase()) !== -1;
 }
 
 function parseMarkers(section, postBuilder, topNode) {
-  var markerTypes = [];
+  var markups = [];
   var text = null;
   var currentNode = topNode;
   while (currentNode) {
     switch(currentNode.nodeType) {
     case ELEMENT_NODE:
       if (isValidMarkerElement(currentNode)) {
-        markerTypes.push(postBuilder.generateMarkerType(currentNode.tagName, readAttributes(currentNode)));
+        markups.push(postBuilder.generateMarkup(currentNode.tagName, readAttributes(currentNode)));
       }
       break;
     case TEXT_NODE:
@@ -88,34 +79,31 @@ function parseMarkers(section, postBuilder, topNode) {
 
     if (currentNode.firstChild) {
       if (isValidMarkerElement(currentNode) && text !== null) {
-        section.markers.push(postBuilder.generateMarker(markerTypes, 0, text));
-        markerTypes = [];
+        section.markers.push(postBuilder.generateMarker(markups.slice(), text));
         text = null;
       }
       currentNode = currentNode.firstChild;
     } else if (currentNode.nextSibling) {
       if (currentNode === topNode) {
-        section.markers.push(postBuilder.generateMarker(markerTypes, markerTypes.length, text));
+        section.markers.push(postBuilder.generateMarker(markups.slice(), text));
         break;
       } else {
         currentNode = currentNode.nextSibling;
         if (currentNode.nodeType === ELEMENT_NODE && isValidMarkerElement(currentNode) && text !== null) {
-          section.markers.push(postBuilder.generateMarker(markerTypes, 0, text));
-          markerTypes = [];
+          section.markers.push(postBuilder.generateMarker(markups.slice(), text));
           text = null;
         }
       }
     } else {
-      var toClose = 0;
+      section.markers.push(postBuilder.generateMarker(markups.slice(), text));
+
       while (currentNode && !currentNode.nextSibling && currentNode !== topNode) {
         currentNode = currentNode.parentNode;
         if (isValidMarkerElement(currentNode)) {
-          toClose++;
+          markups.pop();
         }
       }
 
-      section.markers.push(postBuilder.generateMarker(markerTypes, toClose, text));
-      markerTypes = [];
       text = null;
 
       if (currentNode === topNode) {
@@ -142,7 +130,7 @@ NewHTMLParser.prototype = {
     case ELEMENT_NODE:
       var tagName = sectionElement.tagName;
       // <p> <h2>, etc
-      if (MARKUP_SECTION_TAG_NAMES.indexOf(tagName) !== -1) {
+      if (VALID_MARKUP_SECTION_TAGNAMES.indexOf(tagName.toLowerCase()) !== -1) {
         section = postBuilder.generateMarkupSection(tagName, readAttributes(sectionElement));
         var node = sectionElement.firstChild;
         while (node) {
diff --git a/src/js/parsers/mobiledoc.js b/src/js/parsers/mobiledoc.js
index cd82e64e6..bcbe6160a 100644
--- a/src/js/parsers/mobiledoc.js
+++ b/src/js/parsers/mobiledoc.js
@@ -18,6 +18,7 @@ export default class MobiledocParser {
 
     const post = this.builder.generatePost();
 
+    this.markups = [];
     this.markerTypes = this.parseMarkerTypes(markerTypes);
     this.parseSections(sections, post);
 
@@ -29,7 +30,7 @@ export default class MobiledocParser {
   }
 
   parseMarkerType([tagName, attributes]) {
-    return this.builder.generateMarkerType(tagName, attributes);
+    return this.builder.generateMarkup(tagName, attributes);
   }
 
   parseSections(sections, post) {
@@ -77,8 +78,11 @@ export default class MobiledocParser {
   }
 
   parseMarker([markerTypeIndexes, closeCount, value], section) {
-    const markerTypes = markerTypeIndexes.map(index => this.markerTypes[index]);
-    const marker = this.builder.generateMarker(markerTypes, closeCount, value);
+    markerTypeIndexes.forEach(index => {
+      this.markups.push(this.markerTypes[index]);
+    });
+    const marker = this.builder.generateMarker(this.markups.slice(), value);
     section.markers.push(marker);
+    this.markups = this.markups.slice(0, this.markups.length-closeCount);
   }
 }
diff --git a/src/js/parsers/section.js b/src/js/parsers/section.js
index e46524937..adfc9d0b3 100644
--- a/src/js/parsers/section.js
+++ b/src/js/parsers/section.js
@@ -4,12 +4,12 @@ const ELEMENT_NODE = 1;
 import MarkupSection from 'content-kit-editor/models/markup-section';
 import {
   DEFAULT_TAG_NAME,
-  SECTION_TAG_NAMES
-} from 'content-kit-editor/models/section';
+  VALID_MARKUP_SECTION_TAGNAMES
+} from 'content-kit-editor/models/markup-section';
 
 import Marker from 'content-kit-editor/models/marker';
 import Markup from 'content-kit-editor/models/markup';
-import { MARKUP_TAG_NAMES } from 'content-kit-editor/models/marker';
+import { VALID_MARKUP_TAGNAMES } from 'content-kit-editor/models/markup';
 import { getAttributes } from 'content-kit-editor/utils/dom-utils';
 import { forEach } from 'content-kit-editor/utils/array-utils';
 
@@ -93,19 +93,19 @@ export default {
 
   isSectionElement(element) {
     return element.nodeType === ELEMENT_NODE &&
-      SECTION_TAG_NAMES.indexOf(element.tagName.toLowerCase()) !== -1;
+      VALID_MARKUP_SECTION_TAGNAMES.indexOf(element.tagName.toLowerCase()) !== -1;
   },
 
   markupFromElement(element) {
     const tagName = element.tagName.toLowerCase();
-    if (MARKUP_TAG_NAMES.indexOf(tagName) === -1) { return null; }
+    if (VALID_MARKUP_TAGNAMES.indexOf(tagName) === -1) { return null; }
 
     return new Markup(tagName, getAttributes(element));
   },
 
   sectionTagNameFromElement(element) {
     let tagName = element.tagName.toLowerCase();
-    if (SECTION_TAG_NAMES.indexOf(tagName) === -1) { tagName = DEFAULT_TAG_NAME; }
+    if (VALID_MARKUP_SECTION_TAGNAMES.indexOf(tagName) === -1) { tagName = DEFAULT_TAG_NAME; }
     return tagName;
   }
 };
diff --git a/src/js/renderers/editor-dom.js b/src/js/renderers/editor-dom.js
index 8ac8dfb6a..2fc884940 100644
--- a/src/js/renderers/editor-dom.js
+++ b/src/js/renderers/editor-dom.js
@@ -2,7 +2,8 @@ import RenderNode from "content-kit-editor/models/render-node";
 import CardNode from "content-kit-editor/models/card-node";
 import { detect } from 'content-kit-editor/utils/array-utils';
 import { POST_TYPE } from "../models/post";
-import { MARKUP_SECTION_TYPE } from "../models/section";
+import { MARKUP_SECTION_TYPE } from "../models/markup-section";
+import { IMAGE_SECTION_TYPE } from "../models/image";
 
 function createElementFromMarkerType(doc, markerType) {
   var element = doc.createElement(markerType.tagName);
@@ -23,7 +24,7 @@ function renderMarkupSection(doc, section, markers) {
   var openedElement;
   for (i=0, l=markers.length;i<l;i++) {
     marker = markers[i];
-    openTypes = marker.open;
+    openTypes = marker.markups;
     closeTypes = marker.close;
     text = marker.value;
 
@@ -77,13 +78,9 @@ class Visitor {
       }
       renderNode.element = element;
     }
-  } 
-
-  section(renderNode, section) {
-    this.markupSection(renderNode, section);
   }
 
-  imageSection(renderNode, section) {
+  [IMAGE_SECTION_TYPE](renderNode, section) {
     if (renderNode.element) {
       if (renderNode.element.src !== section.src) {
         renderNode.element.src = section.src;
@@ -137,7 +134,7 @@ let destroyHooks = {
       renderNode.element.parentNode.removeChild(renderNode.element);
     }
   },
-  imageSection(renderNode, section) {
+  [IMAGE_SECTION_TYPE](renderNode, section) {
     let post = renderNode.parentNode.postNode;
     post.removeSection(section);
     renderNode.element.parentNode.removeChild(renderNode.element);
diff --git a/src/js/renderers/mobiledoc.js b/src/js/renderers/mobiledoc.js
index db2e4cd42..259e43d38 100644
--- a/src/js/renderers/mobiledoc.js
+++ b/src/js/renderers/mobiledoc.js
@@ -1,28 +1,31 @@
 import {visit, visitArray, compile} from "../utils/compiler";
 import { POST_TYPE } from "../models/post";
-import { SECTION_TYPE } from "../models/section";
+import { MARKUP_SECTION_TYPE } from "../models/markup-section";
+import { IMAGE_SECTION_TYPE } from "../models/image";
+import { MARKER_TYPE } from "../models/marker";
+import { MARKUP_TYPE } from "../models/markup";
 
 let visitor = {
   [POST_TYPE](node, opcodes) {
     opcodes.push(['openPost']);
     visitArray(visitor, node.sections, opcodes);
   },
-  [SECTION_TYPE](node, opcodes) {
+  [MARKUP_SECTION_TYPE](node, opcodes) {
     opcodes.push(['openMarkupSection', node.tagName]);
     visitArray(visitor, node.markers, opcodes);
   },
-  imageSection(node, opcodes) {
+  [IMAGE_SECTION_TYPE](node, opcodes) {
     opcodes.push(['openImageSection', node.src]);
   },
   card(node, opcodes) {
     opcodes.push(['openCardSection', node.name, node.payload]);
   },
-  marker(node, opcodes) {
-    opcodes.push(['openMarker', node.close, node.value]);
-    visitArray(visitor, node.open, opcodes);
+  [MARKER_TYPE](node, opcodes) {
+    opcodes.push(['openMarker', node.closedMarkups.length, node.value]);
+    visitArray(visitor, node.openedMarkups, opcodes);
   },
-  markerType(node, opcodes) {
-    opcodes.push(['openMarkerType', node.tagName, node.attributes]);
+  [MARKUP_TYPE](node, opcodes) {
+    opcodes.push(['openMarkup', node.tagName, node.attributes]);
   }
 };
 
@@ -50,12 +53,12 @@ let postOpcodeCompiler = {
     this.sections = [];
     this.result = [this.markerTypes, this.sections];
   },
-  openMarkerType(tagName, attributes) {
+  openMarkup(tagName, attributes) {
     if (!this._seenMarkerTypes) {
       this._seenMarkerTypes = {};
     }
     let index;
-    if (attributes) {
+    if (attributes.length) {
       this.markerTypes.push([tagName, attributes]);
       index = this.markerTypes.length - 1;
     } else {
diff --git a/src/js/utils/post-builder.js b/src/js/utils/post-builder.js
index 6742fae62..131a05a57 100644
--- a/src/js/utils/post-builder.js
+++ b/src/js/utils/post-builder.js
@@ -1,6 +1,8 @@
 import Post from "../models/post";
 import MarkupSection from "../models/markup-section";
 import ImageSection from "../models/image";
+import Marker from "../models/marker";
+import Markup from "../models/markup";
 
 var builder = {
   generatePost() {
@@ -24,32 +26,17 @@ var builder = {
     const type = 'card';
     return { name, payload, type };
   },
-  // open: Array
-  // close: Integer
-  // value: String
-  generateMarker: function(open, close, value) {
-    return {
-      type: 'marker',
-      open: open,
-      close: close,
-      value: value
-    };
+  generateMarker: function(markers, value) {
+    return new Marker(value, markers);
   },
-  generateMarkerType: function(tagName, attributes) {
+  generateMarkup: function(tagName, attributes) {
     if (attributes) {
       // FIXME: This could also be cached
-      return {
-        type: 'markerType',
-        tagName: tagName,
-        attributes: attributes
-      };
+      return new Markup(tagName, attributes);
     }
     var markerType = this._markerTypeCache[tagName];
     if (!markerType) {
-      this._markerTypeCache[tagName] = markerType = {
-        type: 'markerType',
-        tagName: tagName
-      };
+      this._markerTypeCache[tagName] = markerType = new Markup(tagName);
     }
     return markerType;
   }
diff --git a/tests/unit/models/marker-test.js b/tests/unit/models/marker-test.js
index e8017829d..07e7d781b 100644
--- a/tests/unit/models/marker-test.js
+++ b/tests/unit/models/marker-test.js
@@ -34,12 +34,12 @@ test('a marker can have a markup applied to it', (assert) => {
   assert.ok(m1.hasMarkup('b'));
 });
 
-test('a marker cannot have the same markup tagName applied twice', (assert) => {
+test('a marker can have the same markup tagName applied twice', (assert) => {
   const m1 = new Marker('hi there!');
   m1.addMarkup(new Markup('b'));
   m1.addMarkup(new Markup('b'));
 
-  assert.equal(m1.markups.length, 1, 'markup only applied once');
+  assert.equal(m1.markups.length, 2, 'markup only applied once');
 });
 
 test('a marker can have a complex markup applied to it', (assert) => {
@@ -51,14 +51,14 @@ test('a marker can have a complex markup applied to it', (assert) => {
   assert.equal(m1.getMarkup('a').attributes.href, 'blah');
 });
 
-test('a marker cannot have the same complex markup tagName applied twice, even with different attributes', (assert) => {
+test('a marker can have the same complex markup tagName applied twice, even with different attributes', (assert) => {
   const m1 = new Marker('hi there!');
   const markup1 = new Markup('a', {href:'blah'});
   const markup2 = new Markup('a', {href:'blah2'});
   m1.addMarkup(markup1);
   m1.addMarkup(markup2);
 
-  assert.equal(m1.markups.length, 1, 'only one markup');
+  assert.equal(m1.markups.length, 2, 'only one markup');
   assert.equal(m1.getMarkup('a').attributes.href, 'blah',
                'first markup is applied');
 });
diff --git a/tests/unit/models/section-test.js b/tests/unit/models/section-test.js
index dba96fa70..149f1f60d 100644
--- a/tests/unit/models/section-test.js
+++ b/tests/unit/models/section-test.js
@@ -1,6 +1,6 @@
 const {module, test} = QUnit;
 
-import Section from 'content-kit-editor/models/section';
+import Section from 'content-kit-editor/models/markup-section';
 import Marker from 'content-kit-editor/models/marker';
 import Markup from 'content-kit-editor/models/markup';
 
diff --git a/tests/unit/parsers/dom-test.js b/tests/unit/parsers/dom-test.js
index 7d6b3fc64..af942eadb 100644
--- a/tests/unit/parsers/dom-test.js
+++ b/tests/unit/parsers/dom-test.js
@@ -33,10 +33,10 @@ test('blank textnodes are ignored', (assert) => {
   let post = parser.parse(buildDOM('<p>first line</p>\n<p>second line</p>'));
 
   let expectedFirst = builder.generateMarkupSection('P');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'first line'));
+  expectedFirst.markers.push(builder.generateMarker([], 'first line'));
   expectedPost.appendSection(expectedFirst);
   let expectedSecond = builder.generateMarkupSection('P');
-  expectedSecond.markers.push(builder.generateMarker([], 0, 'second line'));
+  expectedSecond.markers.push(builder.generateMarker([], 'second line'));
   expectedPost.appendSection(expectedSecond);
 
   assert.deepEqual(post, expectedPost);
@@ -46,10 +46,10 @@ test('textnode adjacent to p tag becomes section', (assert) => {
   const post = parser.parse(buildDOM('<p>first line</p>second line'));
 
   let expectedFirst = builder.generateMarkupSection('P');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'first line'));
+  expectedFirst.markers.push(builder.generateMarker([], 'first line'));
   expectedPost.appendSection(expectedFirst);
   let expectedSecond = builder.generateMarkupSection('P', {}, true);
-  expectedSecond.markers.push(builder.generateMarker([], 0, 'second line'));
+  expectedSecond.markers.push(builder.generateMarker([], 'second line'));
   expectedPost.appendSection(expectedSecond);
 
   assert.deepEqual(post, expectedPost);
@@ -59,7 +59,7 @@ test('p tag (section markup) should create a block', (assert) => {
   const post = parser.parse(buildDOM('<p>text</p>'));
 
   let expectedFirst = builder.generateMarkupSection('P');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'text'));
+  expectedFirst.markers.push(builder.generateMarker([], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -70,8 +70,8 @@ test('strong tag (stray markup) without a block should create a block', (assert)
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG')
-  ], 1, 'text'));
+    builder.generateMarkup('STRONG')
+  ], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -81,12 +81,13 @@ test('strong tag with inner em (stray markup) without a block should create a bl
   const post = parser.parse(buildDOM('<strong><em>stray</em> markup tags</strong>.'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
+  let strong = builder.generateMarkup('STRONG');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG'),
-    builder.generateMarkerType('EM')
-  ], 1, 'stray'));
-  expectedFirst.markers.push(builder.generateMarker([], 1, ' markup tags'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, '.'));
+    strong,
+    builder.generateMarkup('EM')
+  ], 'stray'));
+  expectedFirst.markers.push(builder.generateMarker([strong], ' markup tags'));
+  expectedFirst.markers.push(builder.generateMarker([], '.'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -96,7 +97,7 @@ test('stray text (stray markup) should create a block', (assert) => {
   const post = parser.parse(buildDOM('text'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'text'));
+  expectedFirst.markers.push(builder.generateMarker([], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -106,11 +107,11 @@ test('text node, strong tag, text node (stray markup) without a block should cre
   const post = parser.parse(buildDOM('start <strong>bold</strong> end'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'start '));
+  expectedFirst.markers.push(builder.generateMarker([], 'start '));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG')
-  ], 1, 'bold'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' end'));
+    builder.generateMarkup('STRONG')
+  ], 'bold'));
+  expectedFirst.markers.push(builder.generateMarker([], ' end'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -121,8 +122,8 @@ test('italic tag (stray markup) without a block should create a block', (assert)
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('EM')
-  ], 1, 'text'));
+    builder.generateMarkup('EM')
+  ], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -132,7 +133,7 @@ test('u tag (stray markup) without a block should strip U and create a block', (
   const post = parser.parse(buildDOM('<u>text</u>'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'text'));
+  expectedFirst.markers.push(builder.generateMarker([], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -144,8 +145,8 @@ test('a tag (stray markup) without a block should create a block', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('A', ['href', url])
-  ], 1, 'text'));
+    builder.generateMarkup('A', ['href', url])
+  ], 'text'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -168,8 +169,8 @@ test('sub tag (stray markup) without a block should filter SUB and create a bloc
   const post = parser.parse(buildDOM('footnote<sub>1</sub>'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'footnote'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, '1'));
+  expectedFirst.markers.push(builder.generateMarker([], 'footnote'));
+  expectedFirst.markers.push(builder.generateMarker([], '1'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -179,8 +180,8 @@ test('sup tag (stray markup) without a block should filter SUP and create a bloc
   const post = parser.parse(buildDOM('e=mc<sup>2</sup>'));
 
   let expectedFirst = builder.generateMarkupSection('P', {}, true);
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'e=mc'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, '2'));
+  expectedFirst.markers.push(builder.generateMarker([], 'e=mc'));
+  expectedFirst.markers.push(builder.generateMarker([], '2'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -191,11 +192,11 @@ test('list (stray markup) without a block should create a block', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('UL');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 1'));
+    builder.generateMarkup('LI')
+  ], 'Item 1'));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 2'));
+    builder.generateMarkup('LI')
+  ], 'Item 2'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -206,30 +207,35 @@ test('nested tags (section markup) should create a block', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('P');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('EM'),
-    builder.generateMarkerType('STRONG')
-  ], 2, 'Double.'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' '));
+    builder.generateMarkup('EM'),
+    builder.generateMarkup('STRONG')
+  ], 'Double.'));
+  expectedFirst.markers.push(builder.generateMarker([], ' '));
+  let firstStrong = builder.generateMarkup('STRONG');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG'),
-    builder.generateMarkerType('EM')
-  ], 1, 'Double staggered'));
-  expectedFirst.markers.push(builder.generateMarker([], 1, ' start.'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' '));
+    firstStrong,
+    builder.generateMarkup('EM')
+  ], 'Double staggered'));
+  expectedFirst.markers.push(builder.generateMarker([firstStrong], ' start.'));
+  expectedFirst.markers.push(builder.generateMarker([], ' '));
+  let secondStrong = builder.generateMarkup('STRONG');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG')
-  ], 0, 'Double '));
+    secondStrong
+  ], 'Double '));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('EM')
-  ], 2, 'staggered end.'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' '));
+    secondStrong,
+    builder.generateMarkup('EM')
+  ], 'staggered end.'));
+  expectedFirst.markers.push(builder.generateMarker([], ' '));
+  let thirdStrong = builder.generateMarkup('STRONG');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('STRONG')
-  ], 0, 'Double '));
+    thirdStrong
+  ], 'Double '));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('EM')
-  ], 1, 'staggered'));
-  expectedFirst.markers.push(builder.generateMarker([], 1, ' middle.'));
+    thirdStrong,
+    builder.generateMarkup('EM')
+  ], 'staggered'));
+  expectedFirst.markers.push(builder.generateMarker([thirdStrong], ' middle.'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -338,8 +344,8 @@ test('attributes', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('P');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('A', ['href', href, 'rel', rel])
-  ], 1, 'Link to google.com'));
+    builder.generateMarkup('A', ['href', href, 'rel', rel])
+  ], 'Link to google.com'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -350,8 +356,8 @@ test('attributes filters out inline styles and classes', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('P');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('B')
-  ], 1, 'test'));
+    builder.generateMarkup('B')
+  ], 'test'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -361,7 +367,7 @@ test('blocks: paragraph', (assert) => {
   const post = parser.parse(buildDOM('<p>TEXT</p>'));
 
   let expectedFirst = builder.generateMarkupSection('P');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'TEXT'));
+  expectedFirst.markers.push(builder.generateMarker([], 'TEXT'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -371,7 +377,7 @@ test('blocks: heading', (assert) => {
   const post = parser.parse(buildDOM('<h2>TEXT</h2>'));
 
   let expectedFirst = builder.generateMarkupSection('H2');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'TEXT'));
+  expectedFirst.markers.push(builder.generateMarker([], 'TEXT'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -381,7 +387,7 @@ test('blocks: subheading', (assert) => {
   const post = parser.parse(buildDOM('<h3>TEXT</h3>'));
 
   let expectedFirst = builder.generateMarkupSection('H3');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'TEXT'));
+  expectedFirst.markers.push(builder.generateMarker([], 'TEXT'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -406,7 +412,7 @@ test('blocks: quote', (assert) => {
   const post = parser.parse(buildDOM('<blockquote>quote</blockquote>'));
 
   let expectedFirst = builder.generateMarkupSection('BLOCKQUOTE');
-  expectedFirst.markers.push(builder.generateMarker([], 0, 'quote'));
+  expectedFirst.markers.push(builder.generateMarker([], 'quote'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -417,12 +423,12 @@ test('blocks: list', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('UL');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 1'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' '));
+    builder.generateMarkup('LI')
+  ], 'Item 1'));
+  expectedFirst.markers.push(builder.generateMarker([], ' '));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 2'));
+    builder.generateMarkup('LI')
+  ], 'Item 2'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -433,12 +439,12 @@ test('blocks: ordered list', (assert) => {
 
   let expectedFirst = builder.generateMarkupSection('OL');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 1'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, ' '));
+    builder.generateMarkup('LI')
+  ], 'Item 1'));
+  expectedFirst.markers.push(builder.generateMarker([], ' '));
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('LI')
-  ], 1, 'Item 2'));
+    builder.generateMarkup('LI')
+  ], 'Item 2'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
@@ -498,12 +504,13 @@ test('converts tags to mapped values', (assert) => {
   const post = parser.parse(buildDOM('<p><b><i>Converts</i> tags</b>.</p>'));
 
   let expectedFirst = builder.generateMarkupSection('P');
+  let bold = builder.generateMarkup('B');
   expectedFirst.markers.push(builder.generateMarker([
-    builder.generateMarkerType('B'),
-    builder.generateMarkerType('I')
-  ], 1, 'Converts'));
-  expectedFirst.markers.push(builder.generateMarker([], 1, ' tags'));
-  expectedFirst.markers.push(builder.generateMarker([], 0, '.'));
+    bold,
+    builder.generateMarkup('I')
+  ], 'Converts'));
+  expectedFirst.markers.push(builder.generateMarker([bold], ' tags'));
+  expectedFirst.markers.push(builder.generateMarker([], '.'));
   expectedPost.appendSection(expectedFirst);
 
   assert.deepEqual(post, expectedPost);
diff --git a/tests/unit/parsers/mobiledoc-test.js b/tests/unit/parsers/mobiledoc-test.js
index 1bf217fab..4c28d4f3e 100644
--- a/tests/unit/parsers/mobiledoc-test.js
+++ b/tests/unit/parsers/mobiledoc-test.js
@@ -34,7 +34,7 @@ test('#parse doc without marker types', (assert) => {
   const parsed = parser.parse(mobiledoc);
 
   let section = builder.generateMarkupSection('P', [], false);
-  let marker  = builder.generateMarker([], 0, 'hello world');
+  let marker  = builder.generateMarker([], 'hello world');
   section.markers.push(marker);
   post.appendSection(section);
 
@@ -61,13 +61,13 @@ test('#parse doc with marker type', (assert) => {
   const parsed = parser.parse(mobiledoc);
 
   let section = builder.generateMarkupSection('P', [], false);
-  let aMarkerType = builder.generateMarkerType('A', ['href', 'google.com']);
-  let bMarkerType = builder.generateMarkerType('B');
+  let aMarkerType = builder.generateMarkup('A', ['href', 'google.com']);
+  let bMarkerType = builder.generateMarkup('B');
 
   let markers  = [
-    builder.generateMarker([aMarkerType], 0, 'hello'),
-    builder.generateMarker([bMarkerType], 1, 'brave new'),
-    builder.generateMarker([], 1, 'world')
+    builder.generateMarker([aMarkerType], 'hello'),
+    builder.generateMarker([aMarkerType, bMarkerType], 'brave new'),
+    builder.generateMarker([aMarkerType], 'world')
   ];
   section.markers = markers;
   post.appendSection(section);
diff --git a/tests/unit/renderers/editor-dom-test.js b/tests/unit/renderers/editor-dom-test.js
index 48549681d..231517309 100644
--- a/tests/unit/renderers/editor-dom-test.js
+++ b/tests/unit/renderers/editor-dom-test.js
@@ -115,8 +115,8 @@ test('renders a post with marker', (assert) => {
   post.appendSection(section);
   section.markers.push(
     builder.generateMarker([
-      builder.generateMarkerType('STRONG')
-    ], 1, 'Hi')
+      builder.generateMarkup('STRONG')
+    ], 'Hi')
   );
 
   let node = new RenderNode(post);
diff --git a/tests/unit/renderers/mobiledoc-test.js b/tests/unit/renderers/mobiledoc-test.js
index 43ee815e1..196dca3c8 100644
--- a/tests/unit/renderers/mobiledoc-test.js
+++ b/tests/unit/renderers/mobiledoc-test.js
@@ -24,13 +24,13 @@ test('renders a post with marker', (assert) => {
   post.appendSection(section);
   section.markers.push(
     builder.generateMarker([
-      builder.generateMarkerType('STRONG')
-    ], 1, 'Hi')
+      builder.generateMarkup('STRONG')
+    ], 'Hi')
   );
   let mobiledoc = render(post);
   assert.deepEqual(mobiledoc, [
     [
-      ['STRONG']
+      ['strong']
     ],
     [
       [1, 'P', [