@hyperlex/mammoth 1.4.9-beta

package/test/style-reader.tests.js

@@ -0,0 +1,256 @@
+var assert = require("assert");
+var htmlPaths = require("../lib/styles/html-paths");
+var documentMatchers = require("../lib/styles/document-matchers");
+var styleReader = require("../lib/style-reader");
+var results = require("../lib/results");
+var test = require("./test")(module);
+
+
+var readHtmlPath = styleReader.readHtmlPath;
+var readDocumentMatcher = styleReader.readDocumentMatcher;
+var readStyle = styleReader.readStyle;
+
+
+test('styleReader.readHtmlPath', {
+    'reads empty path': function() {
+        assertHtmlPath("", htmlPaths.empty);
+    },
+    
+    'reads single element': function() {
+        assertHtmlPath("p", htmlPaths.elements(["p"]));
+    },
+    
+    'reads choice of elements': function() {
+        assertHtmlPath(
+            "ul|ol",
+            htmlPaths.elements([
+                htmlPaths.element(["ul", "ol"])
+            ])
+        );
+    },
+    
+    'reads nested elements': function() {
+        assertHtmlPath("ul > li", htmlPaths.elements(["ul", "li"]));
+    },
+    
+    'reads class on element': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {"class": "tip"})
+        ]);
+        assertHtmlPath("p.tip", expected);
+    },
+    
+    'reads class with escaped colon': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {"class": "a:b"})
+        ]);
+        assertHtmlPath("p.a\\:b", expected);
+    },
+
+    'reads multiple classes on element': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {"class": "tip help"})
+        ]);
+        assertHtmlPath("p.tip.help", expected);
+    },
+    
+    'reads when element must be fresh': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {}, {"fresh": true})
+        ]);
+        assertHtmlPath("p:fresh", expected);
+    },
+    
+    'reads separator for elements': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {}, {separator: "x"})
+        ]);
+        assertHtmlPath("p:separator('x')", expected);
+    },
+    
+    'reads separator with escape sequence': function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {}, {separator: "\r\n\t\'\\"})
+        ]);
+        assertHtmlPath("p:separator('\\r\\n\\t\\'\\\\')", expected);
+    },
+
+    'reads ignore element': function() {
+        assertHtmlPath("!", htmlPaths.ignore);
+    }
+});
+
+function assertHtmlPath(input, expected) {
+    assert.deepEqual(readHtmlPath(input), results.success(expected));
+}
+
+test("styleReader.readDocumentMatcher", {
+    "reads plain paragraph": function() {
+        assertDocumentMatcher("p", documentMatchers.paragraph());
+    },
+    
+    "reads paragraph with style ID": function() {
+        assertDocumentMatcher(
+            "p.Heading1",
+            documentMatchers.paragraph({styleId: "Heading1"})
+        );
+    },
+    
+    "reads paragraph with exact style name": function() {
+        assertDocumentMatcher(
+            "p[style-name='Heading 1']",
+            documentMatchers.paragraph({styleName: documentMatchers.equalTo("Heading 1")})
+        );
+    },
+    
+    "reads paragraph with style name prefix": function() {
+        assertDocumentMatcher(
+            "p[style-name^='Heading']",
+            documentMatchers.paragraph({styleName: documentMatchers.startsWith("Heading")})
+        );
+    },
+
+    "reads p:ordered-list(1) as ordered list with index of 0": function() {
+        assertDocumentMatcher(
+            "p:ordered-list(1)",
+            documentMatchers.paragraph({list: {isOrdered: true, levelIndex: 0}})
+        );
+    },
+    
+    "reads p:unordered-list(1) as unordered list with index of 0": function() {
+        assertDocumentMatcher(
+            "p:unordered-list(1)",
+            documentMatchers.paragraph({list: {isOrdered: false, levelIndex: 0}})
+        );
+    },
+    
+    "reads plain run": function() {
+        assertDocumentMatcher(
+            "r",
+            documentMatchers.run()
+        );
+    },
+
+    "reads plain table": function() {
+        assertDocumentMatcher("table", documentMatchers.table());
+    },
+
+    "reads table with style ID": function() {
+        assertDocumentMatcher(
+            "table.TableNormal",
+            documentMatchers.table({
+                styleId: "TableNormal"
+            })
+        );
+    },
+
+    "reads table with style name": function() {
+        assertDocumentMatcher(
+            "table[style-name='Normal Table']",
+            documentMatchers.table({
+                styleName: documentMatchers.equalTo("Normal Table")
+            })
+        );
+    },
+    
+    "reads bold": function() {
+        assertDocumentMatcher(
+            "b",
+            documentMatchers.bold
+        );
+    },
+    
+    "reads italic": function() {
+        assertDocumentMatcher(
+            "i",
+            documentMatchers.italic
+        );
+    },
+    
+    "reads underline": function() {
+        assertDocumentMatcher(
+            "u",
+            documentMatchers.underline
+        );
+    },
+    
+    "reads strikethrough": function() {
+        assertDocumentMatcher(
+            "strike",
+            documentMatchers.strikethrough
+        );
+    },
+    
+    "reads smallcaps": function() {
+        assertDocumentMatcher(
+            "small-caps",
+            documentMatchers.smallCaps
+        );
+    },
+
+    "reads comment-reference": function() {
+        assertDocumentMatcher(
+            "comment-reference",
+            documentMatchers.commentReference
+        );
+    },
+    
+    "reads line breaks": function() {
+        assertDocumentMatcher(
+            "br[type='line']",
+            documentMatchers.lineBreak
+        );
+    },
+    
+    "reads page breaks": function() {
+        assertDocumentMatcher(
+            "br[type='page']",
+            documentMatchers.pageBreak
+        );
+    },
+    
+    "reads column breaks": function() {
+        assertDocumentMatcher(
+            "br[type='column']",
+            documentMatchers.columnBreak
+        );
+    }
+
+});
+    
+function assertDocumentMatcher(input, expected) {
+    assert.deepEqual(readDocumentMatcher(input), results.success(expected));
+}
+
+test("styleReader.read", {
+    "document matcher is mapped to HTML path using arrow": function() {
+        assertStyleMapping(
+            "p => h1",
+            {
+                from: documentMatchers.paragraph(),
+                to: htmlPaths.elements(["h1"])
+            }
+        );
+    },
+    
+    "reads style mapping with no HTML path": function() {
+        assertStyleMapping(
+            "r =>",
+            {
+                from: documentMatchers.run(),
+                to: htmlPaths.empty
+            }
+        );
+    },
+    
+    "error when not all input is consumed": function() {
+        assert.deepEqual(
+            readStyle("r => span a"),
+            new results.Result(null, [results.warning("Did not understand this style mapping, so ignored it: r => span a\nError was at character number 10: Expected end but got whitespace")])
+        );
+    }
+});
+
+function assertStyleMapping(input, expected) {
+    assert.deepEqual(readStyle(input), results.success(expected));
+}

package/test/styles/document-matchers.tests.js

@@ -0,0 +1,71 @@
+var assert = require("assert");
+
+var test = require("../test")(module);
+var documentMatchers = require("../../lib/styles/document-matchers");
+var documents = require("../../lib/documents");
+var Paragraph = documents.Paragraph;
+
+test("paragraph with no options matches any paragraph", function() {
+    var matcher = documentMatchers.paragraph();
+    assert.ok(matcher.matches(new Paragraph()));
+    assert.ok(matcher.matches(paragraphWithStyle("Heading1", "Heading 1")));
+});
+
+test("paragraph style ID only matches paragraphs with that style ID", function() {
+    var matcher = documentMatchers.paragraph({styleId: "Heading1"});
+    assert.ok(!matcher.matches(new Paragraph()));
+    assert.ok(matcher.matches(paragraphWithStyle("Heading1", "Heading 1")));
+    assert.ok(!matcher.matches(paragraphWithStyle("Heading2", "Heading 2")));
+});
+
+test("paragraph style name only matches paragraphs with that style name", function() {
+    var matcher = documentMatchers.paragraph({styleName: documentMatchers.equalTo("Heading 1")});
+    assert.ok(!matcher.matches(new Paragraph()));
+    assert.ok(matcher.matches(paragraphWithStyle("Heading1", "Heading 1")));
+    assert.ok(!matcher.matches(paragraphWithStyle("Heading2", "Heading 2")));
+});
+
+test("ordered-list(index) matches an ordered list with specified level index", function() {
+    var matcher = documentMatchers.paragraph({list: {isOrdered: true, levelIndex: 1}});
+    assert.ok(!matcher.matches(new Paragraph()));
+    assert.ok(matcher.matches(new Paragraph([], {numbering: {level: 1, isOrdered: true}})));
+    assert.ok(!matcher.matches(new Paragraph([], {numbering: {level: 0, isOrdered: true}})));
+    assert.ok(!matcher.matches(new Paragraph([], {numbering: {level: 1, isOrdered: false}})));
+});
+
+test("unordered-list(index) matches an unordered list with specified level index", function() {
+    var matcher = documentMatchers.paragraph({list: {isOrdered: false, levelIndex: 1}});
+    assert.ok(!matcher.matches(new Paragraph()));
+    assert.ok(matcher.matches(new Paragraph([], {numbering: {level: 1, isOrdered: false}})));
+    assert.ok(!matcher.matches(new Paragraph([], {numbering: {level: 1, isOrdered: true}})));
+});
+
+test("matchers for lists with index 0 do not match elements that are not lists", function() {
+    var matcher = documentMatchers.paragraph({list: {isOrdered: true, levelIndex: 0}});
+    assert.ok(!matcher.matches(new Paragraph()));
+});
+
+function paragraphWithStyle(styleId, styleName) {
+    return new Paragraph([], {styleId: styleId, styleName: styleName});
+}
+
+
+test("equalTo matcher is case insensitive", function() {
+    var matcher = documentMatchers.equalTo("Heading 1");
+    assert.ok(matcher.operator(matcher.operand, "heaDING 1"));
+    assert.ok(!matcher.operator(matcher.operand, "heaDING 2"));
+});
+
+test("startsWith matches strings with prefix", function() {
+    var matcher = documentMatchers.startsWith("Heading");
+    assert.ok(matcher.operator(matcher.operand, "Heading"));
+    assert.ok(matcher.operator(matcher.operand, "Heading 1"));
+    assert.ok(!matcher.operator(matcher.operand, "Custom Heading"));
+    assert.ok(!matcher.operator(matcher.operand, "Head"));
+    assert.ok(!matcher.operator(matcher.operand, "Header 2"));
+});
+
+test("startsWith matcher is case insensitive", function() {
+    var matcher = documentMatchers.startsWith("Heading");
+    assert.ok(matcher.operator(matcher.operand, "heaDING"));
+});

package/test/styles/html-paths.tests.js

@@ -0,0 +1,20 @@
+var assert = require("assert");
+
+var test = require("../test")(module);
+var htmlPaths = require("../../lib/styles/html-paths");
+
+
+test("element can match multiple tag names", function() {
+    var pathPart = htmlPaths.element(["ul", "ol"]);
+    assert.ok(pathPart.matchesElement({tagName: "ul"}));
+    assert.ok(pathPart.matchesElement({tagName: "ol"}));
+    assert.ok(!pathPart.matchesElement({tagName: "p"}));
+});
+
+test("element matches if attributes are the same", function() {
+    var pathPart = htmlPaths.element(["p"], {"class": "tip"});
+    assert.ok(!pathPart.matchesElement({tagName: "p"}));
+    assert.ok(!pathPart.matchesElement({tagName: "p", attributes: {"class": "tip help"}}));
+    assert.ok(pathPart.matchesElement({tagName: "p", attributes: {"class": "tip"}}));
+});
+

package/test/styles/parser/tokeniser.tests.js

@@ -0,0 +1,104 @@
+var hamjest = require("hamjest");
+var assertThat = hamjest.assertThat;
+var contains = hamjest.contains;
+var hasProperties = hamjest.hasProperties;
+
+var tokenise = require("../../../lib/styles/parser/tokeniser").tokenise;
+var test = require("../../test")(module);
+
+
+test("unknown tokens are tokenised", function() {
+    assertTokens("~", [isToken("unrecognisedCharacter", "~")]);
+});
+
+test("empty string is tokenised to end of file token", function() {
+    assertTokens("", []);
+});
+
+test("whitespace is tokenised", function() {
+    assertTokens(" \t\t  ", [isToken("whitespace")]);
+});
+
+test("identifiers are tokenised", function() {
+    assertTokens("Overture", [isToken("identifier", "Overture")]);
+});
+
+test("integers are tokenised", function() {
+    assertTokens("123", [isToken("integer", "123")]);
+});
+
+test("strings are tokenised", function() {
+    assertTokens("'Tristan'", [isToken("string", "Tristan")]);
+});
+
+test("unterminated strings are tokenised", function() {
+    assertTokens("'Tristan", [isToken("unterminated-string", "Tristan")]);
+});
+
+test("arrows are tokenised", function() {
+    assertTokens("=>", [isToken("arrow")]);
+});
+
+test("classes are tokenised", function() {
+    assertTokens(".overture", [isToken("dot"), isToken("identifier", "overture")]);
+});
+
+test("colons are tokenised", function() {
+    assertTokens("::", [isToken("colon"), isToken("colon")]);
+});
+
+test("greater thans are tokenised", function() {
+    assertTokens(">>", [isToken("gt"), isToken("gt")]);
+});
+
+test("equals are tokenised", function() {
+    assertTokens("==", [isToken("equals"), isToken("equals")]);
+});
+
+test("startsWith symbols are tokenised", function() {
+    assertTokens("^=^=", [isToken("startsWith"), isToken("startsWith")]);
+});
+
+test("open parens are tokenised", function() {
+    assertTokens("((", [isToken("open-paren"), isToken("open-paren")]);
+});
+
+test("close parens are tokenised", function() {
+    assertTokens("))", [isToken("close-paren"), isToken("close-paren")]);
+});
+
+test("open square brackets are tokenised", function() {
+    assertTokens("[[", [isToken("open-square-bracket"), isToken("open-square-bracket")]);
+});
+
+test("close square brackets are tokenised", function() {
+    assertTokens("]]", [isToken("close-square-bracket"), isToken("close-square-bracket")]);
+});
+
+test("choices are tokenised", function() {
+    assertTokens("||", [isToken("choice"), isToken("choice")]);
+});
+
+test("can tokenise multiple tokens", function() {
+    assertTokens("The Magic Position", [
+        isToken("identifier", "The"),
+        isToken("whitespace"),
+        isToken("identifier", "Magic"),
+        isToken("whitespace"),
+        isToken("identifier", "Position")
+    ]);
+});
+
+function assertTokens(input, expectedTokens) {
+    assertThat(
+        tokenise(input),
+        contains.apply(null, expectedTokens.concat([isToken("end", null)]))
+    );
+}
+
+function isToken(tokenType, value) {
+    return hasProperties({
+        name: tokenType,
+        value: value
+    });
+}

package/test/test-data/hyperlinks/word/_rels/document.xml.rels

@@ -0,0 +1,10 @@
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId8" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml" /> 
+  <Relationship Id="rId3" Type="http://schemas.microsoft.com/office/2007/relationships/stylesWithEffects" Target="stylesWithEffects.xml" /> 
+  <Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable" Target="fontTable.xml" /> 
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml" /> 
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml" /> 
+  <Relationship Id="rId6" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="http://www.example.com" TargetMode="External" /> 
+  <Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings" Target="webSettings.xml" /> 
+  <Relationship Id="rId4" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings" Target="settings.xml" /> 
+</Relationships>

package/test/test-data/hyperlinks/word/document.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" ?>
+<w:document mc:Ignorable="w14 wp14" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape">
+  <w:body>
+    <w:p w:rsidR="00E01ECE" w:rsidRDefault="000636A7">
+      <w:hyperlink r:id="rId6" w:history="1">
+        <w:r>
+          <w:t>coconuts</w:t> 
+        </w:r>
+      </w:hyperlink>
+    </w:p>
+    <w:sectPr w:rsidR="00E01ECE">
+      <w:pgSz w:h="16838" w:w="11906"/>
+      <w:pgMar w:bottom="1440" w:footer="708" w:gutter="0" w:header="708" w:left="1440" w:right="1440" w:top="1440"/>
+      <w:cols w:space="708"/>
+      <w:docGrid w:linePitch="360"/>
+    </w:sectPr>
+  </w:body>
+</w:document>

package/test/test-data/simple/word/document.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" ?>
+<w:document mc:Ignorable="w14 wp14" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape">
+  <w:body>
+    <w:p w:rsidR="00E01ECE" w:rsidRDefault="000636A7">
+      <w:r>
+        <w:t>Hello.</w:t>
+      </w:r>
+      <w:bookmarkStart w:id="0" w:name="_GoBack"/>
+      <w:bookmarkEnd w:id="0"/>
+    </w:p>
+    <w:sectPr w:rsidR="00E01ECE">
+      <w:pgSz w:h="16838" w:w="11906"/>
+      <w:pgMar w:bottom="1440" w:footer="708" w:gutter="0" w:header="708" w:left="1440" w:right="1440" w:top="1440"/>
+      <w:cols w:space="708"/>
+      <w:docGrid w:linePitch="360"/>
+    </w:sectPr>
+  </w:body>
+</w:document>

package/test/test.js

@@ -0,0 +1,11 @@
+var path = require("path");
+
+
+var root = path.dirname(__dirname);
+    
+module.exports = function(testModule) {
+    var tests = testModule.exports[path.relative(root, testModule.filename)] = {};
+    return function(name, func) {
+        tests[name] = func;
+    };
+};

package/test/testing.js

@@ -0,0 +1,55 @@
+var path = require("path");
+var fs = require("fs");
+var promises = require("../lib/promises");
+var _ = require("underscore");
+
+exports.testPath = testPath;
+exports.testData = testData;
+exports.createFakeDocxFile = createFakeDocxFile;
+exports.createFakeFiles = createFakeFiles;
+
+
+function testPath(filename) {
+    return path.join(__dirname, "test-data", filename);
+}
+
+function testData(testDataPath) {
+    var fullPath = testPath(testDataPath);
+    return promises.nfcall(fs.readFile, fullPath, "utf-8");
+}
+
+function createFakeDocxFile(files) {
+    function exists(path) {
+        return !!files[path];
+    }
+    
+    return {
+        read: createRead(files),
+        exists: exists
+    };
+}
+
+function createFakeFiles(files) {
+    return {
+        read: createRead(files)
+    };
+}
+
+function createRead(files) {
+    function read(path, encoding) {
+        return promises.when(files[path], function(buffer) {
+            if (_.isString(buffer)) {
+                buffer = new Buffer(buffer);
+            }
+            
+            if (!Buffer.isBuffer(buffer)) {
+                return promises.reject(new Error("file was not a buffer"));
+            } else if (encoding) {
+                return promises.when(buffer.toString(encoding));
+            } else {
+                return promises.when(buffer);
+            }
+        });
+    }
+    return read;
+}