Use simpler structure for HTML without fragments

1 files changed, 55 insertions, 35 deletions

diff --git a/tests/html/simplify.tests.js b/tests/html/simplify.tests.js
index db7beb4..ccc5610 100644
--- a/tests/html/simplify.tests.js
+++ b/tests/html/simplify.tests.js
@@ -1,46 +1,52 @@
 var assert = require("assert");
 
+var _ = require("underscore");
+
 var test = require("../testing").test;
 var html = require("../../lib/html");
 var htmlPaths = require("../../lib/html-paths");
 
-
 var nonFreshElement = html.nonFreshElement;
-var fragment = html.fragment;
 var text = html.text;
-var pathToNode = html.pathToNode;
+var pathToNodes = html.pathToNodes;
 
 describe("simplify", function() {
     test("empty text nodes are removed", function() {
         assert.deepEqual(
-            html.simplify(fragment([text("")])),
-            fragment([]));
+            simplifyNode(text("")),
+            []
+        );
     });
     
     test("elements with no children are removed", function() {
         assert.deepEqual(
-            html.simplify(fragment([nonFreshElement("p", {}, [])])),
-            fragment([]));
+            simplifyNode(nonFreshElement("p", {}, [])),
+            []
+        );
     });
     
     test("elements only containing empty nodes are removed", function() {
         assert.deepEqual(
-            html.simplify(fragment([nonFreshElement("p", {}, [text("")])])),
-            fragment([]));
+            simplifyNode(nonFreshElement("p", {}, [text("")])),
+            []
+        );
     });
     
     test("empty children of element are removed", function() {
         assert.deepEqual(
-            html.simplify(fragment([nonFreshElement("p", {}, [text("Hello"), text("")])])),
-            fragment([nonFreshElement("p", {}, [text("Hello")])]));
+            simplifyNode(nonFreshElement("p", {}, [text("Hello"), text("")])),
+            [nonFreshElement("p", {}, [text("Hello")])]
+        );
     });
     
     test("successive fresh elements are not collapsed", function() {
         var path = htmlPaths.elements([
-            htmlPaths.element("p", {}, {fresh: true})]);
-        var original = fragment([
-            pathToNode(path, [text("Hello")]),
-            pathToNode(path, [text(" there")])]);
+            htmlPaths.element("p", {}, {fresh: true})
+        ]);
+        var original = concat(
+            pathToNodes(path, [text("Hello")]),
+            pathToNodes(path, [text(" there")])
+        );
         
         assert.deepEqual(
             html.simplify(original),
@@ -49,13 +55,15 @@ describe("simplify", function() {
     
     test("successive plain non-fresh elements are collapsed if they have the same tag name", function() {
         var path = htmlPaths.elements([
-            htmlPaths.element("p", {}, {fresh: false})]);
+            htmlPaths.element("p", {}, {fresh: false})
+        ]);
         assert.deepEqual(
-            html.simplify(fragment([
-                pathToNode(path, [text("Hello")]),
-                pathToNode(path, [text(" there")])])),
-            fragment([
-                pathToNode(path, [text("Hello"), text(" there")])]));
+            html.simplify(concat(
+                pathToNodes(path, [text("Hello")]),
+                pathToNodes(path, [text(" there")])
+            )),
+            pathToNodes(path, [text("Hello"), text(" there")])
+        );
     });
     
     test("non-fresh can collapse into preceding fresh element", function() {
@@ -64,19 +72,22 @@ describe("simplify", function() {
         var nonFreshPath = htmlPaths.elements([
             htmlPaths.element("p", {}, {fresh: false})]);
         assert.deepEqual(
-            html.simplify(fragment([
-                pathToNode(freshPath, [text("Hello")]),
-                pathToNode(nonFreshPath, [text(" there")])])),
-            fragment([
-                pathToNode(freshPath, [text("Hello"), text(" there")])]));
+            html.simplify(concat(
+                pathToNodes(freshPath, [text("Hello")]),
+                pathToNodes(nonFreshPath, [text(" there")])
+            )),
+            pathToNodes(freshPath, [text("Hello"), text(" there")])
+        );
     });
     
     test("children of collapsed element can collapse with children of another collapsed element", function() {
         assert.deepEqual(
-            html.simplify(fragment([
+            html.simplify([
                 nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("Hello")])]),
-                nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("there")])])])),
-            fragment([nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("Hello"), text("there")])])]));
+                nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("there")])])
+            ]),
+            [nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("Hello"), text("there")])])]
+        );
     });
     
     test("empty elements are removed before collapsing", function() {
@@ -85,11 +96,20 @@ describe("simplify", function() {
         var nonFreshPath = htmlPaths.elements([
             htmlPaths.element("p", {}, {fresh: false})]);
         assert.deepEqual(
-            html.simplify(fragment([
-                pathToNode(nonFreshPath, [text("Hello")]),
-                pathToNode(freshPath, []),
-                pathToNode(nonFreshPath, [text(" there")])])),
-            fragment([
-                pathToNode(nonFreshPath, [text("Hello"), text(" there")])]));
+            html.simplify(concat(
+                pathToNodes(nonFreshPath, [text("Hello")]),
+                pathToNodes(freshPath, []),
+                pathToNodes(nonFreshPath, [text(" there")])
+            )),
+            pathToNodes(nonFreshPath, [text("Hello"), text(" there")])
+        );
     });
 });
+
+function simplifyNode(node) {
+    return html.simplify([node]);
+}
+
+function concat() {
+    return _.flatten(arguments, true);
+}