@hyperlex/mammoth 1.4.9-beta

package/test/docx/comments-reader.tests.js

@@ -0,0 +1,52 @@
+var assert = require("assert");
+
+var createCommentsReader = require("../../lib/docx/comments-reader").createCommentsReader;
+var createBodyReader = require("../../lib/docx/body-reader").createBodyReader;
+var documents = require("../../lib/documents");
+var xml = require("../../lib/xml");
+var test = require("../test")(module);
+
+
+function readComment(element) {
+    var bodyReader = createBodyReader({});
+    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 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 comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1"})
+    ]));
+    assert.strictEqual(comment.authorName, null);
+    assert.strictEqual(comment.authorInitials, null);
+});
+
+
+test('when optional attributes of comment are blank then they are read as null', function() {
+    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 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");
+});

package/test/docx/content-types-reader.tests.js

@@ -0,0 +1,45 @@
+var assert = require("assert");
+
+var readContentTypesFromXml = require("../../lib/docx/content-types-reader").readContentTypesFromXml;
+var XmlElement = require("../../lib/xml").Element;
+var test = require("../test")(module);
+
+
+test('reads default-per-extension from XML', function() {
+    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(
+        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(
+        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");
+    assert.equal(contentTypes.findContentType("word/media/hat.jpeg"), "image/jpeg");
+    assert.equal(contentTypes.findContentType("word/media/hat.bmp"), "image/bmp");
+    assert.equal(contentTypes.findContentType("word/media/hat.tif"), "image/tiff");
+    assert.equal(contentTypes.findContentType("word/media/hat.tiff"), "image/tiff");
+});
+
+test('fallback content types are case insensitive on extension', function() {
+    var contentTypes = readContentTypesFromXml(
+        new XmlElement("content-types:Types", {}, [])
+    );
+    assert.equal(contentTypes.findContentType("word/media/hat.PnG"), "image/png");
+});

package/test/docx/document-matchers.js

@@ -0,0 +1,37 @@
+var hamjest = require("hamjest");
+var _ = require("underscore");
+
+var documents = require("../../lib/documents");
+
+
+exports.isEmptyRun = isRun({children: []});
+exports.isRun = isRun;
+exports.isText = isText;
+exports.isHyperlink = isHyperlink;
+exports.isTable = isTable;
+exports.isRow = isRow;
+
+
+function isRun(properties) {
+    return isDocumentElement(documents.types.run, properties);
+}
+
+function isText(text) {
+    return isDocumentElement(documents.types.text, {value: text});
+}
+
+function isHyperlink(properties) {
+    return isDocumentElement(documents.types.hyperlink, properties);
+}
+
+function isTable(options) {
+    return isDocumentElement(documents.types.table, options);
+}
+
+function isRow(options) {
+    return isDocumentElement(documents.types.tableRow, options);
+}
+
+function isDocumentElement(type, properties) {
+    return hamjest.hasProperties(_.extend({type: hamjest.equalTo(type)}, properties));
+}

package/test/docx/docx-reader.tests.js

@@ -0,0 +1,179 @@
+var assert = require("assert");
+
+var docxReader = require("../../lib/docx/docx-reader");
+var documents = require("../../lib/documents");
+var xml = require("../../lib/xml");
+
+var testing = require("../testing");
+var test = require("../test")(module);
+var testData = testing.testData;
+var createFakeDocxFile = testing.createFakeDocxFile;
+
+
+test("can read document with single paragraph with single run of text", function() {
+    var expectedDocument = documents.Document([
+        documents.Paragraph([
+            documents.Run([
+                documents.Text("Hello.")
+            ])
+        ])
+    ]);
+    var docxFile = createFakeDocxFile({
+        "word/document.xml": testData("simple/word/document.xml")
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        assert.deepEqual(expectedDocument, result.value);
+    });
+});
+
+test("hyperlink hrefs are read from relationships file", function() {
+    var docxFile = createFakeDocxFile({
+        "word/document.xml": testData("hyperlinks/word/document.xml"),
+        "word/_rels/document.xml.rels": testData("hyperlinks/word/_rels/document.xml.rels")
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        var paragraph = result.value.children[0];
+        assert.equal(1, paragraph.children.length);
+        var hyperlink = paragraph.children[0];
+        assert.equal(hyperlink.href, "http://www.example.com");
+        assert.equal(hyperlink.children.length, 1);
+    });
+});
+
+var relationshipNamespaces = {
+    "r": "http://schemas.openxmlformats.org/package/2006/relationships"
+};
+
+test("main document is found using _rels/.rels", function() {
+    var relationships = xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": "/word/document2.xml"
+        })
+    ]);
+    
+    var docxFile = createFakeDocxFile({
+        "word/document2.xml": testData("simple/word/document.xml"),
+        "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+    });
+    var expectedDocument = documents.Document([
+        documents.Paragraph([
+            documents.Run([
+                documents.Text("Hello.")
+            ])
+        ])
+    ]);
+    return docxReader.read(docxFile).then(function(result) {
+        assert.deepEqual(expectedDocument, result.value);
+    });
+});
+
+
+test("error is thrown when main document part does not exist", function() {
+    var relationships = xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": "/word/document2.xml"
+        })
+    ]);
+    
+    var docxFile = createFakeDocxFile({
+        "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        assert.ok(false, "Expected error");
+    }, function(error) {
+        assert.equal(error.message, "Could not find main document part. Are you sure this is a valid .docx file?");
+    });
+});
+
+
+test("part paths", {
+    "main document part is found using package relationships": function() {
+        var relationships = xml.element("r:Relationships", {}, [
+            xml.element("r:Relationship", {
+                "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+                "Target": "/word/document2.xml"
+            })
+        ]);
+        
+        var docxFile = createFakeDocxFile({
+            "word/document2.xml": " ",
+            "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths.mainDocument, "word/document2.xml");
+        });
+    },
+    
+    "word/document.xml is used as fallback location for main document part": function() {
+        var docxFile = createFakeDocxFile({
+            "word/document.xml": " "
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths.mainDocument, "word/document.xml");
+        });
+    }
+});
+
+[
+    {
+        name: "comments",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
+    },
+    {
+        name: "endnotes",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes"
+    },
+    {
+        name: "footnotes",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes"
+    },
+    {
+        name: "numbering",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering"
+    },
+    {
+        name: "styles",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
+    }
+].forEach(function(options) {
+    test(options.name + " part is found using main document relationships", function() {
+        var docxFile = createFakeDocxFile({
+            "_rels/.rels": createPackageRelationships("word/document.xml"),
+            "word/document.xml": " ",
+            "word/_rels/document.xml.rels": xml.writeString(xml.element("r:Relationships", {}, [
+                xml.element("r:Relationship", {
+                    "Type": options.type,
+                    "Target": "target-path.xml"
+                })
+            ]), relationshipNamespaces),
+            "word/target-path.xml": " "
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths[options.name], "word/target-path.xml");
+        });
+    });
+
+    test("word/" + options.name + ".xml is used as fallback location for " + options.name + " part", function() {
+        var zipContents = {
+            "_rels/.rels": createPackageRelationships("word/document.xml"),
+            "word/document.xml": " "
+        };
+        zipContents["word/" + options.name + ".xml"] = " ";
+        var docxFile = createFakeDocxFile(zipContents);
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths[options.name], "word/" + options.name + ".xml");
+        });
+    });
+});
+
+
+function createPackageRelationships(mainDocumentPath) {
+    return xml.writeString(xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": mainDocumentPath
+        })
+    ]), relationshipNamespaces);
+}

package/test/docx/files.tests.js

@@ -0,0 +1,94 @@
+var path = require("path");
+var fs = require("fs");
+var assert = require("assert");
+
+var promises = require("../../lib/promises");
+var Files = require("../../lib/docx/files").Files;
+var uriToPath = require("../../lib/docx/files").uriToPath;
+
+var testing = require("../testing");
+var test = require("../test")(module);
+
+var readFile = promises.promisify(fs.readFile.bind(fs));
+
+
+test("Files", {
+    "can open files with file URI": function() {
+        var filePath = path.resolve(testing.testPath("tiny-picture.png"));
+        var files = new Files(null);
+        return files.read("file:///" + filePath.replace(/^\//, ""), "base64").then(function(contents) {
+            return readFile(filePath, "base64").then(function(expectedContents) {
+                assert.deepEqual(contents, expectedContents);
+            });
+        });
+    },
+    
+    "can open files with relative URI": function() {
+        var filePath = path.resolve(testing.testPath("tiny-picture.png"));
+        var files = new Files(testing.testPath("."));
+        return files.read("tiny-picture.png", "base64").then(function(contents) {
+            return readFile(filePath, "base64").then(function(expectedContents) {
+                assert.deepEqual(contents, expectedContents);
+            });
+        });
+    },
+    
+    "given base is not set when opening relative uri then error is raised": function() {
+        var files = new Files(null);
+        return assertError(files.read("not-a-real-file.png", "base64"), function(err) {
+            assert.equal(err.message, "could not find external image 'not-a-real-file.png', path of input document is unknown");
+        });
+    },
+    
+    "error if relative uri cannot be opened": function() {
+        var files = new Files("/tmp");
+        return assertError(files.read("not-a-real-file.png", "base64"), function(err) {
+            assertRegex(err.message, /could not open external image: 'not-a-real-file.png' \(document directory: '\/tmp'\)\nENOENT.*\/tmp\/not-a-real-file.png.*/);
+        });
+    }
+});
+
+function assertError(promise, func) {
+    return promise.then(function() {
+        assert(false, "Expected error");
+    }, func);
+}
+
+function assertRegex(actual, expected) {
+    assert.ok(expected.test(actual), "Expected regex: " + expected + "\nbut was: " + actual);
+}
+
+
+test("uriToPath", {
+    "leading slash is retained on non-Windows file URIs": function() {
+        assert.equal(uriToPath("file:///a/b/c", "linux"), "/a/b/c");
+        assert.equal(uriToPath("file:///a/b/c", "win32"), "/a/b/c");
+    },
+    
+    "URI is unquoted": function() {
+        assert.equal(uriToPath("file:///a%20b"), "/a b");
+    },
+    
+    "when host is set to localhost then path can be found": function() {
+        assert.equal(uriToPath("file://localhost/a/b/c"), "/a/b/c");
+    },
+    
+    "when host is set but not localhost then path cannot be found": function() {
+        assert.throws(function() {
+            uriToPath("file://example/a/b/c");
+        }, /Could not convert URI to path: file:\/\/example\/a\/b\/c/);
+    },
+    
+    "leading slash is not dropped on Windows file URIs when platform is not Windows": function() {
+        assert.equal(uriToPath("file:///c:/a", "linux"), "/c:/a");
+    },
+    
+    "leading slash is dropped on Windows file URIs when platform is Windows": function() {
+        assert.equal(uriToPath("file:///c:/a", "win32"), "c:/a");
+        assert.equal(uriToPath("file:///C:/a", "win32"), "C:/a");
+    },
+    
+    "relative URI is unquoted": function() {
+        assert.equal(uriToPath("a%20b/c"), "a b/c");
+    }
+});

package/test/docx/notes-reader.tests.js

@@ -0,0 +1,35 @@
+var assert = require("assert");
+
+var createFootnotesReader = require("../../lib/docx/notes-reader").createFootnotesReader;
+var createBodyReader = require("../../lib/docx/body-reader").createBodyReader;
+var documents = require("../../lib/documents");
+var XmlElement = require("../../lib/xml").Element;
+var test = require("../test")(module);
+
+
+test('ID and body of footnote are read', function() {
+    var bodyReader = new createBodyReader({});
+    var footnoteBody = [new XmlElement("w:p", {}, [])];
+    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");
+});
+
+footnoteTypeIsIgnored('continuationSeparator');
+footnoteTypeIsIgnored('separator');
+
+function footnoteTypeIsIgnored(type) {
+    test('footnotes of type ' + type + ' are ignored', function() {
+        var footnotes = createFootnotesReader()(
+            new XmlElement("w:footnotes", {}, [
+                new XmlElement("w:footnote", {"w:id": "1", "w:type": type}, [])
+            ])
+        );
+        assert.equal(footnotes.value.length, 0);
+    });
+}

package/test/docx/numbering-xml.tests.js

@@ -0,0 +1,65 @@
+var assert = require("assert");
+var duck = require("duck");
+
+var readNumberingXml = require("../../lib/docx/numbering-xml").readNumberingXml;
+var stylesReader = require("../../lib/docx/styles-reader");
+var XmlElement = require("../../lib/xml").Element;
+var test = require("../test")(module);
+
+
+test('w:num element inherits levels from w:abstractNum', function() {
+    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"})
+                ]),
+                new XmlElement("w:lvl", {"w:ilvl": "1"}, [
+                    new XmlElement("w:numFmt", {"w:val": "decimal"})
+                ])
+            ]),
+            new XmlElement("w:num", {"w:numId": "47"}, [
+                new XmlElement("w:abstractNumId", {"w:val": "42"})
+            ])
+        ]),
+        {styles: stylesReader.defaultStyles}
+    );
+    duck.assertThat(numbering.findLevel("47", "0"), duck.hasProperties({
+        isOrdered: false
+    }));
+    duck.assertThat(numbering.findLevel("47", "1"), duck.hasProperties({
+        isOrdered: true
+    }));
+});
+
+
+test('when w:abstractNum has w:numStyleLink then style is used to find w:num', function() {
+    var numbering = readNumberingXml(
+        new XmlElement("w:numbering", {}, [
+            new XmlElement("w:abstractNum", {"w:abstractNumId": "100"}, [
+                new XmlElement("w:lvl", {"w:ilvl": "0"}, [
+                    new XmlElement("w:numFmt", {"w:val": "decimal"})
+                ])
+            ]),
+            new XmlElement("w:abstractNum", {"w:abstractNumId": "101"}, [
+                new XmlElement("w:numStyleLink", {"w:val": "List1"})
+            ]),
+            new XmlElement("w:num", {"w:numId": "200"}, [
+                new XmlElement("w:abstractNumId", {"w:val": "100"})
+            ]),
+            new XmlElement("w:num", {"w:numId": "201"}, [
+                new XmlElement("w:abstractNumId", {"w:val": "101"})
+            ])
+        ]),
+        {styles: new stylesReader.Styles({}, {}, {}, {"List1": {numId: "200"}})}
+    );
+    duck.assertThat(numbering.findLevel("201", "0"), duck.hasProperties({
+        isOrdered: true
+    }));
+});
+
+test('when styles is missing then error is thrown', function() {
+    assert.throws(function() {
+        readNumberingXml(new XmlElement("w:numbering", {}, []));
+    }, /styles is missing/);
+});

package/test/docx/office-xml-reader.tests.js

@@ -0,0 +1,24 @@
+var assert = require("assert");
+
+var xml = require("../../lib/xml");
+var officeXmlReader = require("../../lib/docx/office-xml-reader");
+var test = require("../test")(module);
+
+
+test("mc:AlternateContent is replaced by contents of mc:Fallback", function() {
+    var xmlString =
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+        '<numbering xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">' +
+        '<mc:AlternateContent>' +
+        '<mc:Choice Requires="w14">' +
+        '<choice/>' +
+        '</mc:Choice>' +
+        '<mc:Fallback>' +
+        '<fallback/>' +
+        '</mc:Fallback>' +
+        '</mc:AlternateContent>' +
+        '</numbering>';
+    return officeXmlReader.read(xmlString).then(function(element) {
+        assert.deepEqual(element.children, [xml.element("fallback")]);
+    });
+});

package/test/docx/relationships-reader.tests.js

@@ -0,0 +1,65 @@
+var assert = require("assert");
+
+var readRelationships = require("../../lib/docx/relationships-reader").readRelationships;
+var xml = require("../../lib/xml");
+var test = require("../test")(module);
+
+
+test("relationships can be found by ID", function() {
+    var relationships = readRelationships(relationshipsElement([
+        relationshipElement({
+            "Id": "rId1",
+            "Target": "http://example.com/",
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+        }),
+        relationshipElement({
+            "Id": "rId2",
+            "Target": "http://example.net/",
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+        })
+    ]));
+    assert.equal(relationships.findTargetByRelationshipId("rId1"), "http://example.com/");
+});
+
+
+test("relationships can be found by type", function() {
+    var relationships = readRelationships(relationshipsElement([
+        relationshipElement({
+            "Id": "rId2",
+            "Target": "docProps/core.xml",
+            "Type": "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"
+        }),
+        relationshipElement({
+            "Id": "rId1",
+            "Target": "word/document.xml",
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+        }),
+        relationshipElement({
+            "Id": "rId3",
+            "Target": "word/document2.xml",
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+        })
+    ]));
+    assert.deepEqual(
+        relationships.findTargetsByType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"),
+        ["word/document.xml", "word/document2.xml"]
+    );
+});
+
+
+test("when there are no relationships of requested type then empty array is returned", function() {
+    var relationships = readRelationships(relationshipsElement([]));
+    assert.deepEqual(
+        relationships.findTargetsByType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"),
+        []
+    );
+});
+
+
+function relationshipsElement(children) {
+    return xml.element("{http://schemas.openxmlformats.org/package/2006/relationships}Relationships", {}, children);
+}
+
+function relationshipElement(attributes) {
+    return xml.element("{http://schemas.openxmlformats.org/package/2006/relationships}Relationship", attributes, []);
+}