@hyperlex/mammoth 1.4.9-beta

package/test/transforms.tests.js

@@ -0,0 +1,125 @@
+var assert = require("assert");
+
+var _ = require("underscore");
+
+var documents = require("../lib/documents");
+var transforms = require("../lib/transforms");
+var test = require("./test")(module);
+
+
+test("paragraph()", {
+    "paragraph is transformed": function() {
+        var paragraph = documents.paragraph([]);
+        var result = transforms.paragraph(function() {
+            return documents.tab();
+        })(paragraph);
+        assert.deepEqual(result, documents.tab());
+    },
+    
+    "non-paragraph elements are not transformed": function() {
+        var run = documents.run([]);
+        var result = transforms.paragraph(function() {
+            return documents.tab();
+        })(run);
+        assert.deepEqual(result, documents.run([]));
+    }
+});
+
+
+test("run()", {
+    "run is transformed": function() {
+        var run = documents.run([]);
+        var result = transforms.run(function() {
+            return documents.tab();
+        })(run);
+        assert.deepEqual(result, documents.tab());
+    },
+    
+    "non-run elements are not transformed": function() {
+        var paragraph = documents.paragraph([]);
+        var result = transforms.run(function() {
+            return documents.tab();
+        })(paragraph);
+        assert.deepEqual(result, documents.paragraph([]));
+    }
+});
+
+
+test("elements()", {
+    "all descendants are transformed": function() {
+        var root = {
+            children: [
+                {
+                    children: [
+                        {}
+                    ]
+                }
+            ]
+        };
+        var currentCount = 0;
+        function setCount(node) {
+            currentCount++;
+            return _.extend(node, {count: currentCount});
+        }
+        
+        var result = transforms._elements(setCount)(root);
+        
+        assert.deepEqual(result, {
+            count: 3,
+            children: [
+                {
+                    count: 2,
+                    children: [
+                        {count: 1}
+                    ]
+                }
+            ]
+        });
+    }
+});
+
+
+test("getDescendants()", {
+    "returns nothing if element has no children property": function() {
+        assert.deepEqual(transforms.getDescendants({}), []);
+    },
+    
+    "returns nothing if element has empty children": function() {
+        assert.deepEqual(transforms.getDescendants({children: []}), []);
+    },
+    
+    "includes children": function() {
+        var element = {
+            children: [{name: "child 1"}, {name: "child 2"}]
+        };
+        assert.deepEqual(
+            transforms.getDescendants(element),
+            [{name: "child 1"}, {name: "child 2"}]
+        );
+    },
+    
+    "includes indirect descendants": function() {
+        var grandchild = {name: "grandchild"};
+        var child = {name: "child", children: [grandchild]};
+        var element = {children: [child]};
+        assert.deepEqual(
+            transforms.getDescendants(element),
+            [grandchild, child]
+        );
+    }
+});
+
+
+test("getDescendantsOfType()", {
+    "filters descendants to type": function() {
+        var paragraph = {type: "paragraph"};
+        var run = {type: "run"};
+        var element = {
+            children: [paragraph, run]
+        };
+        assert.deepEqual(
+            transforms.getDescendantsOfType(element, "run"),
+            [run]
+        );
+    }
+});

package/test/unzip.tests.js

@@ -0,0 +1,38 @@
+var fs = require("fs");
+var assert = require("assert");
+var path = require("path");
+
+var test = require("./test")(module);
+var unzip = require("../lib/unzip");
+var promises = require("../lib/promises");
+
+test("unzip fails if given empty object", function() {
+    return unzip.openZip({}).then(function() {
+        assert.ok(false, "Expected failure");
+    }, function(error) {
+        assert.equal("Could not find file in options", error.message);
+    });
+});
+
+test("unzip can open local zip file", function() {
+    var zipPath = path.join(__dirname, "test-data/hello.zip");
+    return unzip.openZip({path: zipPath}).then(function(zipFile) {
+        return zipFile.read("hello", "utf8");
+    }).then(function(contents) {
+        assert.equal(contents, "Hello world\n");
+    });
+});
+
+test('unzip can open Buffer', function() {
+    var zipPath = path.join(__dirname, "test-data/hello.zip");
+    return promises.nfcall(fs.readFile, zipPath)
+        .then(function(buffer) {
+            return unzip.openZip({buffer: buffer});
+        })
+        .then(function(zipFile) {
+            return zipFile.read("hello", "utf8");
+        })
+        .then(function(contents) {
+            assert.equal(contents, "Hello world\n");
+        });
+});

package/test/writers/html-writer.tests.js

@@ -0,0 +1,133 @@
+var assert = require("assert");
+var test = require("../test")(module);
+
+var htmlWriter = require("../../lib/writers/html-writer");
+
+
+test('can generate simple paragraph', function() {
+    var writer = htmlWriter.writer();
+    writer.open("p");
+    writer.text("Hello");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>Hello</p>");
+});
+
+test('can nest elements', function() {
+    var writer = htmlWriter.writer();
+    writer.open("ul");
+    writer.open("li");
+    writer.text("One");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Two");
+    writer.close("li");
+    writer.close("ul");
+    return assert.equal(writer.asString(), "<ul><li>One</li><li>Two</li></ul>");
+});
+
+test('indents text if prettyPrint is true', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One");
+    writer.close("p");
+    writer.open("p");
+    writer.text("Two");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  One\n</p>\n<p>\n  Two\n</p>");
+});
+
+test('indents element if prettyPrint is true', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("ul");
+    writer.open("li");
+    writer.text("One");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Two");
+    writer.close("li");
+    writer.close("ul");
+    return assert.equal(writer.asString(), "<ul>\n  <li>\n    One\n  </li>\n  <li>\n    Two\n  </li>\n</ul>");
+});
+
+test('when prettyPrint is true inner elements do not have new lines', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One");
+    writer.open("em");
+    writer.text("Two");
+    writer.close("em");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  One<em>Two</em>\n</p>");
+});
+
+test('indents closing element correctly when nested inside another indented element', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("div");
+    writer.open("div");
+    writer.open("div");
+    writer.text("Hello");
+    writer.close("div");
+    writer.close("div");
+    writer.close("div");
+    return assert.equal(writer.asString(), "<div>\n  <div>\n    <div>\n      Hello\n    </div>\n  </div>\n</div>");
+});
+
+test('newlines in text are indented', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One\nTwo");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  One\n  Two\n</p>");
+});
+
+test('run of text has only one new line', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One");
+    writer.text("Two");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  OneTwo\n</p>");
+});
+
+test('run of html has only one new line', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One");
+    writer.text("Two");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  OneTwo\n</p>");
+});
+
+test('self closing elements are indented', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.selfClosing("br");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  <br />\n</p>");
+});
+
+test('newlines in appended HTML are indented', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("p");
+    writer.text("One\nTwo");
+    writer.close("p");
+    return assert.equal(writer.asString(), "<p>\n  One\n  Two\n</p>");
+});
+
+test('newlines in <pre> are not indented', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("pre");
+    writer.text("One\nTwo");
+    writer.close("pre");
+    return assert.equal(writer.asString(), "<pre>One\nTwo</pre>");
+});
+
+test('newlines in element in <pre> are not indented', function() {
+    var writer = htmlWriter.writer({prettyPrint: true});
+    writer.open("pre");
+    writer.open("p");
+    writer.text("One\nTwo");
+    writer.close("p");
+    writer.close("pre");
+    return assert.equal(writer.asString(), "<pre><p>One\nTwo</p></pre>");
+});

package/test/writers/markdown-writer.tests.js

@@ -0,0 +1,304 @@
+var assert = require("assert");
+var test = require("../test")(module);
+
+var mdWriter = require("../../lib/writers/markdown-writer");
+
+test('special markdown characters are escaped', function() {
+    var writer = mdWriter.writer();
+    writer.text("\\*");
+    return assert.equal(writer.asString(), "\\\\\\*");
+});
+
+test('unrecognised elements are treated as normal text', function() {
+    var writer = mdWriter.writer();
+    writer.open("blah");
+    writer.text("Hello");
+    writer.close("blah");
+    return assert.equal(writer.asString(), "Hello");
+});
+
+test('paragraphs are terminated with double new line', function() {
+    var writer = mdWriter.writer();
+    writer.open("p");
+    writer.text("Hello");
+    writer.close("p");
+    return assert.equal(writer.asString(), "Hello\n\n");
+});
+
+test('h1 elements are converted to heading with leading hash', function() {
+    var writer = mdWriter.writer();
+    writer.open("h1");
+    writer.text("Hello");
+    writer.close("h1");
+    return assert.equal(writer.asString(), "# Hello\n\n");
+});
+
+test('h6 elements are converted to heading with six leading hashes', function() {
+    var writer = mdWriter.writer();
+    writer.open("h6");
+    writer.text("Hello");
+    writer.close("h6");
+    return assert.equal(writer.asString(), "###### Hello\n\n");
+});
+
+test('br is written as two spaces followed by new line', function() {
+    var writer = mdWriter.writer();
+    writer.text("Hello World");
+    writer.selfClosing("br");
+    return assert.equal(writer.asString(), "Hello World  \n");
+});
+
+test('strong text is surrounded by two underscores', function() {
+    var writer = mdWriter.writer();
+    writer.text("Hello ");
+    writer.open("strong");
+    writer.text("World");
+    writer.close("strong");
+    return assert.equal(writer.asString(), "Hello __World__");
+});
+
+test('emphasised text is surrounded by one asterix', function() {
+    var writer = mdWriter.writer();
+    writer.text("Hello ");
+    writer.open("em");
+    writer.text("World");
+    writer.close("em");
+    return assert.equal(writer.asString(), "Hello *World*");
+});
+
+test('anchor tags are written as hyperlinks', function() {
+    var writer = mdWriter.writer();
+    writer.open("a", {"href": "http://example.com"});
+    writer.text("Hello");
+    writer.close("a");
+    return assert.equal(writer.asString(), "[Hello](http://example.com)");
+});
+
+test('anchor tags without href attribute are treated as ordinary text', function() {
+    var writer = mdWriter.writer();
+    writer.open("a");
+    writer.text("Hello");
+    writer.close("a");
+    return assert.equal(writer.asString(), "Hello");
+});
+
+test('elements with IDs have anchor tags with IDs appended to start of markdown element', function() {
+    var writer = mdWriter.writer();
+    writer.open("h1", {id: "start"});
+    writer.text("Hello");
+    writer.close("h1");
+    return assert.equal(writer.asString(), '# <a id="start"></a>Hello\n\n');
+});
+
+test('links have anchors before opening square bracket', function() {
+    var writer = mdWriter.writer();
+    writer.open("a", {href: "http://example.com", id: "start"});
+    writer.text("Hello");
+    writer.close("a");
+    return assert.equal(writer.asString(), '<a id="start"></a>[Hello](http://example.com)');
+});
+
+test('can generate images', function() {
+    var writer = mdWriter.writer();
+    writer.selfClosing("img", {"src": "http://example.com/image.jpg", "alt": "Alt Text"});
+    return assert.equal(writer.asString(), "![Alt Text](http://example.com/image.jpg)");
+});
+
+test('can generate images with missing alt attribute', function() {
+    var writer = mdWriter.writer();
+    writer.selfClosing("img", {"src": "http://example.com/image.jpg"});
+    return assert.equal(writer.asString(), "![](http://example.com/image.jpg)");
+});
+
+test('can generate images with missing src attribute', function() {
+    var writer = mdWriter.writer();
+    writer.selfClosing("img", {"alt": "Alt Text"});
+    return assert.equal(writer.asString(), "![Alt Text]()");
+});
+
+test("doesn't display empty images", function() {
+    var writer = mdWriter.writer();
+    writer.selfClosing("img");
+    return assert.equal(writer.asString(), "");
+});
+
+test('list item outside of list is treated as unordered list', function() {
+    var writer = mdWriter.writer();
+    writer.open("li");
+    writer.text("Hello");
+    writer.close("li");
+    return assert.equal(writer.asString(), "- Hello\n");
+});
+
+test('can generate an ordered list', function() {
+    var writer = mdWriter.writer();
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Hello");
+    writer.close("li");
+    writer.open("li");
+    writer.text("World");
+    writer.close("li");
+    writer.close("ol");
+    return assert.equal(writer.asString(), "1. Hello\n2. World\n\n");
+});
+
+test('can generate an unordered list', function() {
+    var writer = mdWriter.writer();
+    writer.open("ul");
+    writer.open("li");
+    writer.text("Hello");
+    writer.close("li");
+    writer.open("li");
+    writer.text("World");
+    writer.close("li");
+    writer.close("ul");
+    return assert.equal(writer.asString(), "- Hello\n- World\n\n");
+});
+
+test('can generate a nested ordered list with correct numbering', function() {
+    var writer = mdWriter.writer();
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Outer One");
+
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Nested One");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Nested Two");
+    writer.close("li");
+    writer.close("ol");
+
+    writer.close("li");
+    writer.open("li");
+    writer.text("Outer Two");
+    writer.close("li");
+    writer.close("ol");
+    return assert.equal(writer.asString(), "1. Outer One\n\t1. Nested One\n\t2. Nested Two\n2. Outer Two\n\n");
+});
+
+test('can generate a multi-level nested ordered list', function() {
+    var writer = mdWriter.writer();
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Outer One");
+
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Nested One");
+
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Inner One");
+    writer.close("li");
+    writer.close("ol");
+
+    writer.close("li");
+    writer.close("ol");
+
+    writer.close("li");
+    writer.close("ol");
+    return assert.equal(writer.asString(), "1. Outer One\n\t1. Nested One\n\t\t1. Inner One\n\n");
+});
+
+test('new ordered list resets numbering', function() {
+    var writer = mdWriter.writer();
+    writer.open("ol");
+    writer.open("li");
+    writer.text("First");
+    writer.close("li");
+    writer.close("ol");
+
+    writer.open("p");
+    writer.text("Hello");
+    writer.close("p");
+
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Second");
+    writer.close("li");
+    writer.close("ol");
+
+    return assert.equal(writer.asString(), "1. First\n\nHello\n\n1. Second\n\n");
+});
+
+test('can generate a nested unordered list', function() {
+    var writer = mdWriter.writer();
+    writer.open("ul");
+    writer.open("li");
+    writer.text("Outer One");
+
+    writer.open("ul");
+    writer.open("li");
+    writer.text("Nested One");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Nested Two");
+    writer.close("li");
+    writer.close("ul");
+
+    writer.close("li");
+    writer.open("li");
+    writer.text("Outer Two");
+    writer.close("li");
+    writer.close("ul");
+    return assert.equal(writer.asString(), "- Outer One\n\t- Nested One\n\t- Nested Two\n- Outer Two\n\n");
+});
+
+test('can nest inline elements', function() {
+    var writer = mdWriter.writer();
+    writer.open("p");
+    writer.text("Lorem ");
+    writer.open("strong");
+    writer.text("ipsum ");
+    writer.open("em");
+    writer.text("dolor");
+    writer.close("em");
+    writer.text(" sit");
+    writer.close("strong");
+    writer.text(" amet");
+    writer.close("p");
+    return assert.equal(writer.asString(), "Lorem __ipsum *dolor* sit__ amet\n\n");
+});
+
+test('can emphasise list text', function() {
+    var writer = mdWriter.writer();
+    writer.open("ol");
+    writer.open("li");
+    writer.text("Hello ");
+    writer.open("strong");
+    writer.text("Strong");
+    writer.close("strong");
+    writer.text(" World");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Hello ");
+    writer.open("em");
+    writer.text("Emphasis");
+    writer.close("em");
+    writer.text(" World");
+    writer.close("li");
+    writer.close("ol");
+    return assert.equal(writer.asString(), "1. Hello __Strong__ World\n2. Hello *Emphasis* World\n\n");
+});
+
+test('generates correct spacing between paragraphs and lists', function() {
+    var writer = mdWriter.writer();
+    writer.open("p");
+    writer.text("Hello World");
+    writer.close("p");
+    writer.open("ul");
+    writer.open("li");
+    writer.text("First Item");
+    writer.close("li");
+    writer.open("li");
+    writer.text("Second Item");
+    writer.close("li");
+    writer.close("ul");
+    writer.open("p");
+    writer.text("Hello World");
+    writer.close("p");
+    return assert.equal(writer.asString(), "Hello World\n\n- First Item\n- Second Item\n\nHello World\n\n");
+});

package/test/xml/reader.tests.js

@@ -0,0 +1,85 @@
+var assert = require("assert");
+
+var xmlreader = require("../../lib/xml/reader");
+var test = require("../test")(module);
+
+
+test('should read self-closing element', function() {
+    return xmlreader.readString("<body/>").then(function(result) {
+        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);
+    });
+});
+
+test('should read attributes of tags', function() {
+    return xmlreader.readString('<body name="bob"/>').then(function(result) {
+        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.children[0]);
+    });
+});
+
+test('should read element with children', function() {
+    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);
+    });
+});
+
+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.name, "{word}body");
+    });
+});
+
+test('mapped namespaces URIs are translated using map', function() {
+    var namespaceMap = {
+        "word": "x"
+    };
+    
+    return xmlreader.readString('<w:body xmlns:w="word"/>', namespaceMap).then(function(result) {
+        assert.deepEqual(result.name, "x:body");
+    });
+});
+
+test('namespace of attributes is mapped to prefix', function() {
+    var namespaceMap = {
+        "word": "x"
+    };
+    var xmlString = '<w:body xmlns:w="word" w:val="Hello!"/>';
+    return xmlreader.readString(xmlString, namespaceMap).then(function(result) {
+        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.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.name);
+    });
+});
+
+test('error if XML is badly formed', function() {
+    return xmlreader.readString("<bo").then(function(result) {
+        throw new Error("Expected failure");
+    }, function(error) {
+        assert.ok(error);
+        return 1;
+    });
+});