Return root element directly when reading XML

18 files changed, 98 insertions, 115 deletions

diff --git a/lib/docx/comments-reader.js b/lib/docx/comments-reader.js
index 41bf8f6..725fdb4 100644
--- a/lib/docx/comments-reader.js
+++ b/lib/docx/comments-reader.js
@@ -2,8 +2,8 @@ var documents = require("../documents");
 var Result = require("../results").Result;
 
 function createCommentsReader(bodyReader) {
-    function readCommentsXml(xml) {
-        return Result.combine(xml.root.getElementsByTagName("w:comment")
+    function readCommentsXml(element) {
+        return Result.combine(element.getElementsByTagName("w:comment")
             .map(readCommentElement));
     }
 
diff --git a/lib/docx/content-types-reader.js b/lib/docx/content-types-reader.js
index 5364b87..8233119 100644
--- a/lib/docx/content-types-reader.js
+++ b/lib/docx/content-types-reader.js
@@ -13,11 +13,11 @@ var fallbackContentTypes = {
 exports.defaultContentTypes = contentTypes({}, {});
 
 
-function readContentTypesFromXml(xml) {
+function readContentTypesFromXml(element) {
     var extensionDefaults = {};
     var overrides = {};
     
-    xml.root.children.forEach(function(child) {
+    element.children.forEach(function(child) {
         if (child.name === "content-types:Default") {
             extensionDefaults[child.attributes.Extension] = child.attributes.ContentType;
         }
diff --git a/lib/docx/document-xml-reader.js b/lib/docx/document-xml-reader.js
index c241c70..12ca19e 100644
--- a/lib/docx/document-xml-reader.js
+++ b/lib/docx/document-xml-reader.js
@@ -7,8 +7,8 @@ var Result = require("../results").Result;
 function DocumentXmlReader(options) {
     var bodyReader = options.bodyReader;
     
-    function convertXmlToDocument(documentXml) {
-        var body = documentXml.root.first("w:body");
+    function convertXmlToDocument(element) {
+        var body = element.first("w:body");
         
         var result = bodyReader.readXmlElements(body.children)
             .map(function(children) {
diff --git a/lib/docx/notes-reader.js b/lib/docx/notes-reader.js
index a74f79b..98edfdc 100644
--- a/lib/docx/notes-reader.js
+++ b/lib/docx/notes-reader.js
@@ -5,8 +5,8 @@ exports.createFootnotesReader = createReader.bind(this, "footnote");
 exports.createEndnotesReader = createReader.bind(this, "endnote");
 
 function createReader(noteType, bodyReader) {
-    function readNotesXml(xml) {
-        return Result.combine(xml.root.getElementsByTagName("w:" + noteType)
+    function readNotesXml(element) {
+        return Result.combine(element.getElementsByTagName("w:" + noteType)
             .filter(isFootnoteElement)
             .map(readFootnoteElement));
     }
diff --git a/lib/docx/numbering-xml.js b/lib/docx/numbering-xml.js
index 7a3f4ce..2cfd9e1 100644
--- a/lib/docx/numbering-xml.js
+++ b/lib/docx/numbering-xml.js
@@ -15,15 +15,15 @@ function Numbering(nums) {
     };
 }
 
-function readNumberingXml(xml) {
-    var abstractNums = readAbstractNums(xml);
-    var nums = readNums(xml, abstractNums);
+function readNumberingXml(root) {
+    var abstractNums = readAbstractNums(root);
+    var nums = readNums(root, abstractNums);
     return new Numbering(nums);
 }
 
-function readAbstractNums(xml) {
+function readAbstractNums(root) {
     var abstractNums = {};
-    xml.root.getElementsByTagName("w:abstractNum").forEach(function(element) {
+    root.getElementsByTagName("w:abstractNum").forEach(function(element) {
         var id = element.attributes["w:abstractNumId"];
         abstractNums[id] = readAbstractNum(element);
     });
@@ -43,9 +43,9 @@ function readAbstractNum(element) {
     return levels;
 }
 
-function readNums(xml, abstractNums) {
+function readNums(root, abstractNums) {
     var nums = {};
-    xml.root.getElementsByTagName("w:num").forEach(function(element) {
+    root.getElementsByTagName("w:num").forEach(function(element) {
         var id = element.attributes["w:numId"];
         var abstractNumId = element.first("w:abstractNumId").attributes["w:val"];
         nums[id] = abstractNums[abstractNumId];
diff --git a/lib/docx/office-xml-reader.js b/lib/docx/office-xml-reader.js
index f9e0b8b..a8d4c47 100644
--- a/lib/docx/office-xml-reader.js
+++ b/lib/docx/office-xml-reader.js
@@ -23,8 +23,7 @@ var xmlNamespaceMap = {
 function read(xmlString) {
     return xml.readString(xmlString, xmlNamespaceMap)
         .then(function(document) {
-            document.root = collapseAlternateContent(document.root)[0];
-            return document;
+            return collapseAlternateContent(document)[0];
         });
 }
 
diff --git a/lib/docx/relationships-reader.js b/lib/docx/relationships-reader.js
index 7747bda..93fc618 100644
--- a/lib/docx/relationships-reader.js
+++ b/lib/docx/relationships-reader.js
@@ -1,9 +1,9 @@
 exports.readRelationships = readRelationships;
 
 
-function readRelationships(relationshipsXml) {
+function readRelationships(element) {
     var relationships = {};
-    relationshipsXml.root.children.forEach(function(child) {
+    element.children.forEach(function(child) {
         if (child.name === "{http://schemas.openxmlformats.org/package/2006/relationships}Relationship") {
             relationships[child.attributes.Id] = {
                 target: child.attributes.Target
diff --git a/lib/docx/style-map.js b/lib/docx/style-map.js
index 70c0b83..9fe26bb 100644
--- a/lib/docx/style-map.js
+++ b/lib/docx/style-map.js
@@ -24,8 +24,7 @@ function updateRelationships(docxFile) {
     var relationshipElementName = "{" + relationshipsUri + "}Relationship";
     return docxFile.read(path, "utf8")
         .then(xml.readString)
-        .then(function(relationshipsDocument) {
-            var relationshipsContainer = relationshipsDocument.root;
+        .then(function(relationshipsContainer) {
             var relationships = relationshipsContainer.children;
             addOrUpdateElement(relationships, relationshipElementName, "Id", {
                 "Id": "rMammothStyleMap",
@@ -44,8 +43,7 @@ function updateContentTypes(docxFile) {
     var overrideName = "{" + contentTypesUri + "}Override";
     return docxFile.read(path, "utf8")
         .then(xml.readString)
-        .then(function(typesDocument) {
-            var typesElement = typesDocument.root;
+        .then(function(typesElement) {
             var children = typesElement.children;
             addOrUpdateElement(children, overrideName, "PartName", {
                 "PartName": styleMapAbsolutePath,
diff --git a/lib/docx/styles-reader.js b/lib/docx/styles-reader.js
index 3419ac4..4462cf0 100644
--- a/lib/docx/styles-reader.js
+++ b/lib/docx/styles-reader.js
@@ -13,7 +13,7 @@ function Styles(paragraphStyles, characterStyles) {
     };
 }
 
-function readStylesXml(xml) {
+function readStylesXml(root) {
     var paragraphStyles = {};
     var characterStyles = {};
     
@@ -22,7 +22,7 @@ function readStylesXml(xml) {
         "character": characterStyles
     };
     
-    xml.root.getElementsByTagName("w:style").forEach(function(styleElement) {
+    root.getElementsByTagName("w:style").forEach(function(styleElement) {
         var style = readStyleElement(styleElement);
         var styleSet = styles[style.type];
         if (styleSet) {
diff --git a/lib/xml/reader.js b/lib/xml/reader.js
index 844ee0c..0c2e7f5 100644
--- a/lib/xml/reader.js
+++ b/lib/xml/reader.js
@@ -58,9 +58,7 @@ function readString(xmlString, namespaceMap) {
     parser.onend = function() {
         if (!finished) {
             finished = true;
-            deferred.resolve({
-                root: rootElement.children[0]
-            });
+            deferred.resolve(rootElement.children[0]);
         }
     };
     
diff --git a/test/document-to-html.tests.js b/test/document-to-html.tests.js
index 10ea265..0b4f905 100644
--- a/test/document-to-html.tests.js
+++ b/test/document-to-html.tests.js
@@ -513,8 +513,7 @@ describe('DocumentConverter', function() {
             .then(function(result) {
                 return xml.readString(result.value);
             })
-            .then(function(htmlImageElementDocument) {
-                var htmlImageElement = htmlImageElementDocument.root;
+            .then(function(htmlImageElement) {
                 assert.equal(htmlImageElement.attributes.alt, "It's a hat");
             });
     });
diff --git a/test/docx/comments-reader.tests.js b/test/docx/comments-reader.tests.js
index 2902f29..4bb0e9b 100644
--- a/test/docx/comments-reader.tests.js
+++ b/test/docx/comments-reader.tests.js
@@ -7,30 +7,29 @@ var xml = require("../../lib/xml");
 var test = require("../test")(module);
 
 
-var bodyReader = new BodyReader({});
+function readComment(element) {
+    var bodyReader = new BodyReader({});
+    var commentsReader = createCommentsReader(bodyReader);
+    var comments = commentsReader(element);
+    assert.equal(comments.value.length, 1);
+    return comments.value[0];
+}
 
 test('ID and body of comment are read', function() {
     var body = [xml.element("w:p")];
-    var comments = createCommentsReader(bodyReader)({
-        root: xml.element("w:comments", {}, [
-            xml.element("w:comment", {"w:id": "1"}, body)
-        ])
-    });
-    assert.equal(comments.value.length, 1);
-    assert.deepEqual(comments.value[0].body, [new documents.Paragraph([])]);
-    assert.deepEqual(comments.value[0].commentId, "1");
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1"}, body)
+    ]));
+    assert.deepEqual(comment.body, [new documents.Paragraph([])]);
+    assert.deepEqual(comment.commentId, "1");
 });
 
 
 test('when optional attributes of comment are missing then they are read as null', function() {
     var body = [xml.element("w:p")];
-    var comments = createCommentsReader(bodyReader)({
-        root: xml.element("w:comments", {}, [
-            xml.element("w:comment", {"w:id": "1"}, body)
-        ])
-    });
-    assert.equal(comments.value.length, 1);
-    var comment = comments.value[0];
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1"})
+    ]));
     assert.strictEqual(comment.authorName, null);
     assert.strictEqual(comment.authorInitials, null);
 });
@@ -38,27 +37,18 @@ test('when optional attributes of comment are missing then they are read as null
 
 test('when optional attributes of comment are blank then they are read as null', function() {
     var body = [xml.element("w:p")];
-    var comments = createCommentsReader(bodyReader)({
-        root: xml.element("w:comments", {}, [
-            xml.element("w:comment", {"w:id": "1", "w:author": " ", "w:initials": " "}, body)
-        ])
-    });
-    assert.equal(comments.value.length, 1);
-    var comment = comments.value[0];
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1", "w:author": " ", "w:initials": " "})
+    ]));
     assert.strictEqual(comment.authorName, null);
     assert.strictEqual(comment.authorInitials, null);
 });
 
 
 test('when optional attributes of comment are not blank then they are read', function() {
-    var body = [xml.element("w:p")];
-    var comments = createCommentsReader(bodyReader)({
-        root: xml.element("w:comments", {}, [
-            xml.element("w:comment", {"w:id": "1", "w:author": "The Piemaker", "w:initials": "TP"}, body)
-        ])
-    });
-    assert.equal(comments.value.length, 1);
-    var comment = comments.value[0];
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1", "w:author": "The Piemaker", "w:initials": "TP"})
+    ]));
     assert.strictEqual(comment.authorName, "The Piemaker");
     assert.strictEqual(comment.authorInitials, "TP");
 });
diff --git a/test/docx/content-types-reader.tests.js b/test/docx/content-types-reader.tests.js
index a223d09..5ea93ec 100644
--- a/test/docx/content-types-reader.tests.js
+++ b/test/docx/content-types-reader.tests.js
@@ -7,28 +7,28 @@ var test = require("../testing").test;
 
 describe('readContentTypesFromXml', function() {
     test('reads default-per-extension from XML', function() {
-        var contentTypes = readContentTypesFromXml({
-            root: new XmlElement("content-types:Types", {}, [
+        var contentTypes = readContentTypesFromXml(
+            new XmlElement("content-types:Types", {}, [
                 new XmlElement("content-types:Default", {Extension: "png", ContentType: "image/png"})
             ])
-        });
+        );
         assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/png");
     });
     
     test('reads overrides in preference to defaults', function() {
-        var contentTypes = readContentTypesFromXml({
-            root: new XmlElement("content-types:Types", {}, [
+        var contentTypes = readContentTypesFromXml(
+            new XmlElement("content-types:Types", {}, [
                 new XmlElement("content-types:Default", {Extension: "png", ContentType: "image/png"}),
                 new XmlElement("content-types:Override", {PartName: "/word/media/hat.png", ContentType: "image/hat"})
             ])
-        });
+        );
         assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/hat");
     });
     
     test('fallback content types have common image types', function() {
-        var contentTypes = readContentTypesFromXml({
-            root: new XmlElement("content-types:Types", {}, [])
-        });
+        var contentTypes = readContentTypesFromXml(
+            new XmlElement("content-types:Types", {}, [])
+        );
         assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/png");
         assert.equal(contentTypes.findContentType("word/media/hat.gif"), "image/gif");
         assert.equal(contentTypes.findContentType("word/media/hat.jpg"), "image/jpeg");
@@ -39,9 +39,9 @@ describe('readContentTypesFromXml', function() {
     });
     
     test('fallback content types are case insensitive on extension', function() {
-        var contentTypes = readContentTypesFromXml({
-            root: new XmlElement("content-types:Types", {}, [])
-        });
+        var contentTypes = readContentTypesFromXml(
+            new XmlElement("content-types:Types", {}, [])
+        );
         assert.equal(contentTypes.findContentType("word/media/hat.PnG"), "image/png");
     });
 });
diff --git a/test/docx/notes-reader.tests.js b/test/docx/notes-reader.tests.js
index 79ffed3..85a49f5 100644
--- a/test/docx/notes-reader.tests.js
+++ b/test/docx/notes-reader.tests.js
@@ -11,11 +11,11 @@ describe('readFootnotesXml', function() {
     test('ID and body of footnote are read', function() {
         var bodyReader = new BodyReader({});
         var footnoteBody = [new XmlElement("w:p", {}, [])];
-        var footnotes = createFootnotesReader(bodyReader)({
-            root: new XmlElement("w:footnotes", {}, [
+        var footnotes = createFootnotesReader(bodyReader)(
+            new XmlElement("w:footnotes", {}, [
                 new XmlElement("w:footnote", {"w:id": "1"}, footnoteBody)
             ])
-        });
+        );
         assert.equal(footnotes.value.length, 1);
         assert.deepEqual(footnotes.value[0].body, [new documents.Paragraph([])]);
         assert.deepEqual(footnotes.value[0].noteId, "1");
@@ -28,11 +28,11 @@ footnoteTypeIsIgnored('separator');
 function footnoteTypeIsIgnored(type) {
     describe('footnotes of type ' + type + ' are ignored', function() {
         test('ID and body of footnote are read', function() {
-            var footnotes = createFootnotesReader()({
-                root: new XmlElement("w:footnotes", {}, [
+            var footnotes = createFootnotesReader()(
+                new XmlElement("w:footnotes", {}, [
                     new XmlElement("w:footnote", {"w:id": "1", "w:type": type}, [])
                 ])
-            });
+            );
             assert.equal(footnotes.value.length, 0);
         });
     });
diff --git a/test/docx/numbering-xml.tests.js b/test/docx/numbering-xml.tests.js
index 2fea5fb..fb28cb8 100644
--- a/test/docx/numbering-xml.tests.js
+++ b/test/docx/numbering-xml.tests.js
@@ -7,8 +7,8 @@ var test = require("../testing").test;
 
 describe('readNumberingXml', function() {
     test('w:num element inherits levels from w:abstractNum', function() {
-        var numbering = readNumberingXml({
-            root: new XmlElement("w:numbering", {}, [
+        var numbering = readNumberingXml(
+            new XmlElement("w:numbering", {}, [
                 new XmlElement("w:abstractNum", {"w:abstractNumId": "42"}, [
                     new XmlElement("w:lvl", {"w:ilvl": "0"}, [
                         new XmlElement("w:numFmt", {"w:val": "bullet"})
@@ -21,7 +21,7 @@ describe('readNumberingXml', function() {
                     new XmlElement("w:abstractNumId", {"w:val": "42"})
                 ])
             ])
-        });
+        );
         duck.assertThat(numbering.findLevel("47", "0"), duck.hasProperties({
             isOrdered: false
         }));
diff --git a/test/docx/office-xml-reader.tests.js b/test/docx/office-xml-reader.tests.js
index 9d202ba..f28c4f3 100644
--- a/test/docx/office-xml-reader.tests.js
+++ b/test/docx/office-xml-reader.tests.js
@@ -20,7 +20,7 @@ describe("office-xml-reader", function() {
             '</mc:AlternateContent>' +
             '</numbering>';
         return officeXmlReader.read(xmlString).then(function(element) {
-            assert.deepEqual(element.root.children, [xml.element("fallback")]);
+            assert.deepEqual(element.children, [xml.element("fallback")]);
         });
     });
 });
diff --git a/test/docx/styles-reader.tests.js b/test/docx/styles-reader.tests.js
index 4ff19c7..8de53ef 100644
--- a/test/docx/styles-reader.tests.js
+++ b/test/docx/styles-reader.tests.js
@@ -7,66 +7,66 @@ var test = require("../testing").test;
 
 describe('readStylesXml', function() {
     test('paragraph style is null if no style with that ID exists', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [])
-        });
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [])
+        );
         assert.equal(styles.findParagraphStyleById("Heading1"), null);
     });
     
     test('paragraph style can be found by ID', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 paragraphStyleElement("Heading1", "Heading 1")
             ])
-        });
+        );
         assert.equal(styles.findParagraphStyleById("Heading1").styleId, "Heading1");
     });
     
     test('character style can be found by ID', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 characterStyleElement("Heading1Char", "Heading 1 Char")
             ])
-        });
+        );
         assert.equal(styles.findCharacterStyleById("Heading1Char").styleId, "Heading1Char");
     });
     
     test('paragraph and character styles are distinct', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 paragraphStyleElement("Heading1", "Heading 1"),
                 characterStyleElement("Heading1Char", "Heading 1 Char")
             ])
-        });
+        );
         assert.equal(styles.findCharacterStyleById("Heading1"), null);
         assert.equal(styles.findParagraphStyleById("Heading1Char"), null);
     });
     
     test('character and table styles are distinct', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 styleElement("table", "Heading1", "Heading 1")
             ])
-        });
+        );
         assert.equal(styles.findCharacterStyleById("Heading1"), null);
     });
     
     test('styles include names', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 paragraphStyleElement("Heading1", "Heading 1")
             ])
-        });
+        );
         assert.equal(styles.findParagraphStyleById("Heading1").name, "Heading 1");
     });
 
     test('style name is null if w:name element does not exist', function() {
-        var styles = readStylesXml({
-            root: new XmlElement("w:styles", {}, [
+        var styles = readStylesXml(
+            new XmlElement("w:styles", {}, [
                 styleWithoutWNameElement("paragraph", "Heading1"),
                 styleWithoutWNameElement("character", "Heading1Char")
             ])
-        });
+        );
         assert.equal(styles.findParagraphStyleById("Heading1").name, null);
         assert.equal(styles.findCharacterStyleById("Heading1Char").name, null);
     });
diff --git a/test/xml/reader.tests.js b/test/xml/reader.tests.js
index afc98de..005753c 100644
--- a/test/xml/reader.tests.js
+++ b/test/xml/reader.tests.js
@@ -7,31 +7,30 @@ var test = require("../testing").test;
 describe('xmlreader.readString', function() {
     test('should read self-closing element', function() {
         return xmlreader.readString("<body/>").then(function(result) {
-            assert.deepEqual({type: "element", name: "body", attributes: {}, children: []}, result.root);
+            assert.deepEqual({type: "element", name: "body", attributes: {}, children: []}, result);
         });
     });
     
     test('should read empty element with separate closing tag', function() {
         return xmlreader.readString("<body></body>").then(function(result) {
-            assert.deepEqual({type: "element", name: "body", attributes: {}, children: []}, result.root);
+            assert.deepEqual({type: "element", name: "body", attributes: {}, children: []}, result);
         });
     });
     
     test('should read attributes of tags', function() {
         return xmlreader.readString('<body name="bob"/>').then(function(result) {
-            assert.deepEqual({name: "bob"}, result.root.attributes);
+            assert.deepEqual({name: "bob"}, result.attributes);
         });
     });
     
     test('can read text element', function() {
         return xmlreader.readString('<body>Hello!</body>').then(function(result) {
-            assert.deepEqual({type: "text", value: "Hello!"}, result.root.children[0]);
+            assert.deepEqual({type: "text", value: "Hello!"}, result.children[0]);
         });
     });
     
     test('should read element with children', function() {
-        return xmlreader.readString("<body><a/><b/></body>").then(function(result) {
-            var root = result.root;
+        return xmlreader.readString("<body><a/><b/></body>").then(function(root) {
             assert.equal(2, root.children.length);
             assert.equal("a", root.children[0].name);
             assert.equal("b", root.children[1].name);
@@ -40,7 +39,7 @@ describe('xmlreader.readString', function() {
 
     test('unmapped namespaces URIs are included in braces as prefix', function() {
         return xmlreader.readString('<w:body xmlns:w="word"/>').then(function(result) {
-            assert.deepEqual(result.root.name, "{word}body");
+            assert.deepEqual(result.name, "{word}body");
         });
     });
 
@@ -50,7 +49,7 @@ describe('xmlreader.readString', function() {
         };
         
         return xmlreader.readString('<w:body xmlns:w="word"/>', namespaceMap).then(function(result) {
-            assert.deepEqual(result.root.name, "x:body");
+            assert.deepEqual(result.name, "x:body");
         });
     });
 
@@ -60,20 +59,20 @@ describe('xmlreader.readString', function() {
         };
         var xmlString = '<w:body xmlns:w="word" w:val="Hello!"/>';
         return xmlreader.readString(xmlString, namespaceMap).then(function(result) {
-            assert.deepEqual(result.root.attributes["x:val"], "Hello!");
+            assert.deepEqual(result.attributes["x:val"], "Hello!");
         });
     });
     
     test('can find first element with name', function() {
         return xmlreader.readString('<body><a/><b index="1"/><b index="2"/></body>').then(function(result) {
-            var first = result.root.first("b");
+            var first = result.first("b");
             assert.equal("1", first.attributes.index);
         });
     });
     
     test('whitespace between xml declaration and root tag is ignored', function() {
         return xmlreader.readString('<?xml version="1.0" ?>\n<body/>').then(function(result) {
-            assert.deepEqual("body", result.root.name);
+            assert.deepEqual("body", result.name);
         });
     });