updated to simplify and resolve merges

Author: HenrikJoreteg

lib/parse.js

@@ -0,0 +1,108 @@
+/*jshint -W030 */
+var tagRE = /<[a-zA-Z\-\!\/](?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])*>/g
+
+var parseTag = require('./parse-tag')
+// re-used obj for quick lookups of components
+var empty = Object.create ? Object.create(null) : {}
+
+module.exports = function parse(html, options) {
+  options || (options = {})
+  options.components || (options.components = empty)
+  var result = []
+  var current
+  var level = -1
+  var arr = []
+  var byTag = {}
+  var inComponent = false
+
+  if (html.indexOf('<') !== 0) {
+    var end = html.indexOf('<')
+    result.push({
+      type: 'text',
+      content: end === -1 ? html : html.substring(0, end),
+    })
+  }
+
+  html.replace(tagRE, function (tag, index) {
+    if (inComponent) {
+      if (tag !== '</' + current.name + '>') {
+        return
+      } else {
+        inComponent = false
+      }
+    }
+    var isOpen = tag.charAt(1) !== '/'
+    var start = index + tag.length
+    var nextChar = html.charAt(start)
+    var parent
+
+    if (isOpen) {
+      level++
+
+      current = parseTag(tag)
+      if (current.type === 'tag' && options.components[current.name]) {
+        current.type = 'component'
+        inComponent = true
+      }
+
+      if (
+        !current.voidElement &&
+        !inComponent &&
+        nextChar &&
+        nextChar !== '<'
+      ) {
+        current.children.push({
+          type: 'text',
+          content: html.slice(start, html.indexOf('<', start)),
+        })
+      }
+
+      byTag[current.tagName] = current
+
+      // if we're at root, push new base node
+      if (level === 0) {
+        result.push(current)
+      }
+
+      parent = arr[level - 1]
+
+      if (parent) {
+        parent.children.push(current)
+      }
+
+      arr[level] = current
+    }
+
+    if (!isOpen || current.voidElement) {
+      if (
+        level > -1 &&
+        (current.voidElement || current.name === tag.slice(2, tag.indexOf(' ')))
+      ) {
+        level--
+      }
+
+      if (!inComponent && nextChar !== '<' && nextChar) {
+        // trailing text node
+        // if we're at the root, push a base text node. otherwise add as
+        // a child to the current node.
+        parent = level === -1 ? result : arr[level].children
+
+        // calculate correct end of the content slice in case there's
+        // no tag after the text node.
+        var end = html.indexOf('<', start)
+        var content = html.slice(start, end === -1 ? undefined : end)
+        // if a node is nothing but whitespace, no need to add it.
+        if (!/^\s*$/.test(content)) {
+          parent.push({
+            type: 'text',
+            content: content,
+          })
+        }
+      }
+
+      current = arr[level]
+    }
+  })
+
+  return result
+}

src/parse.js

@@ -13,6 +13,15 @@ export default function parse(html, options) {
   let level = -1
   let inComponent = false
 
+  // handle text at top level
+  if (html.indexOf('<') !== 0) {
+    var end = html.indexOf('<')
+    result.push({
+      type: 'text',
+      content: end === -1 ? html : html.substring(0, end),
+    })
+  }
+
   html.replace(tagRE, function (tag, index) {
     if (inComponent) {
       if (tag !== '</' + current.name + '>') {
@@ -76,7 +85,12 @@ export default function parse(html, options) {
     }
 
     if (!isOpen || current.voidElement) {
-      level--
+      if (
+        level > -1 &&
+        (current.voidElement || current.name === tag.slice(2, -1))
+      ) {
+        level--
+      }
       if (!inComponent && nextChar !== '<' && nextChar) {
         // trailing text node
         // if we're at the root, push a base text node. otherwise add as

test/parse.js

@@ -504,6 +504,39 @@ test('parse', function (t) {
     'should handle trailing text nodes at the top-level'
   )
 
+  html = 'Hi <div>There</div>'
+  parsed = HTML.parse(html)
+  t.deepEqual(
+    parsed,
+    [
+      {
+        type: 'text',
+        content: 'Hi ',
+      },
+      {
+        type: 'tag',
+        name: 'div',
+        attrs: {},
+        voidElement: false,
+        children: [{ type: 'text', content: 'There' }],
+      },
+    ],
+    'should handle leading text nodes at the top-level'
+  )
+
+  html = 'Hi There'
+  parsed = HTML.parse(html)
+  t.deepEqual(
+    parsed,
+    [
+      {
+        type: 'text',
+        content: 'Hi There',
+      },
+    ],
+    'should handle plain strings of text with no tags'
+  )
+
   html = '<div>Hi</div> There <span>something</span> <a></a>else '
   parsed = HTML.parse(html)
   t.deepEqual(
@@ -632,6 +665,52 @@ test('parse', function (t) {
     'should parse attr values with quotes, opposite'
   )
 
+  html = '<div>Hi</span>There</div>'
+  parsed = HTML.parse(html)
+  t.deepEqual(
+    parsed,
+    [
+      {
+        type: 'tag',
+        name: 'div',
+        attrs: {},
+        voidElement: false,
+        children: [
+          { type: 'text', content: 'Hi' },
+          { type: 'text', content: 'There' },
+        ],
+      },
+    ],
+    "should skip over closing tags that don't match the current tag name"
+  )
+
+  html = '<p>Hi There</p></span>root text</p><p>Try again</p>'
+  parsed = HTML.parse(html)
+  t.deepEqual(
+    parsed,
+    [
+      {
+        type: 'tag',
+        name: 'p',
+        attrs: {},
+        voidElement: false,
+        children: [{ type: 'text', content: 'Hi There' }],
+      },
+      {
+        type: 'text',
+        content: 'root text',
+      },
+      {
+        type: 'tag',
+        name: 'p',
+        attrs: {},
+        voidElement: false,
+        children: [{ type: 'text', content: 'Try again' }],
+      },
+    ],
+    'should not go lower than the root level (-1)'
+  )
+
   t.end()
 })