@marrs/sxml 0.3.0

package/src/processors/index.js

@@ -0,0 +1,186 @@
+// Pre-processors are prefixed with `pre_` by convention.
+
+import { resolve, dirname, basename, extname } from 'path';
+import { lstat, readdir } from 'fs';
+import { fileURLToPath } from 'url';
+
+function reduce_attr(acc, arr) {
+    var ws = (arr[0] || ' ');
+    if (arr[2]) {
+        return acc + ws + arr[1] + '=' + arr[2];
+    } else if (arr[1]) {
+        return acc + ws + arr[1];
+    }
+    return acc + (arr[0] || '');
+}
+
+
+const HTML_ENTITIES = {
+    rsquo: 0x2019, lsquo: 0x2018, rdquo: 0x201D, ldquo: 0x201C,
+    mdash: 0x2014, ndash: 0x2013, hellip: 0x2026, nbsp: 0x00A0,
+    amp: 0x0026, lt: 0x003C, gt: 0x003E, quot: 0x0022, apos: 0x0027,
+};
+
+export function pre_html_chars(event, stackFrame, content, state, data) {
+    if (event === 'content') {
+        content = content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    return [event, stackFrame, content, state, data];
+}
+
+export function pre_hex_chars(event, stackFrame, content, state, data) {
+    if (event === 'content') {
+        content = content.replace(/&/g, '&#x26;').replace(/</g, '&#x3C;').replace(/>/g, '&#x3E;');
+    }
+    return [event, stackFrame, content, state, data];
+}
+
+export function unqualified_xml(event, stackFrame, content, state, data) {
+    if (stackFrame) {
+        var ast = stackFrame.ast;
+    }
+    // Preserve whitespace for self-closing tags.
+    switch (event) {
+        case 'write-tag:no-children':
+            var attr = ast.slice(2);
+            var closingWs = attr.length && !attr[0][0]? ' ' : '';
+
+            return ast[0] +
+                '<' +
+                ast[1] +
+                attr.reduce(reduce_attr, '') +
+                closingWs +
+                '/>';
+
+        case 'open-tag':
+            return ast[0] +
+                '<' +
+                ast[1] +
+                ast.slice(2).reduce(reduce_attr, '') +
+                '>';
+        case 'begin-escape-bracket':
+            return '(';
+        case 'close-tag':
+            return ["</", ">"].join(ast[1]);
+        case 'end-escape-bracket':
+            return ')';
+        case 'content':
+            return content;
+        case 'entity':
+            return '&' + content + ';';
+    }
+}
+
+export function pre_html_entity(event, stackFrame, content, state, data) {
+    if ((event === 'open-tag' || event === 'write-tag:no-children') && stackFrame) {
+        var ast = stackFrame.ast;
+        var newAst = [ast[0], ast[1]];
+        for (var i = 2; i < ast.length; i++) {
+            var attr = ast[i];
+            if (attr[2] && attr[2][0] === '"') {
+                attr = [attr[0], attr[1], '"' + attr[2].slice(1, -1).replace(/(?<!\\)"/g, '&quot;') + '"'];
+            }
+            newAst.push(attr);
+        }
+        stackFrame = Object.assign({}, stackFrame, { ast: newAst });
+    }
+    return [event, stackFrame, content, state, data];
+}
+
+export function pre_hex_entity(event, stackFrame, content, state, data) {
+    if (event === 'entity') {
+        var code = HTML_ENTITIES[content];
+        var hex = code !== undefined ? '&#x' + code.toString(16) + ';' : '&' + content + ';';
+        return ['content', stackFrame, hex, state, data];
+    }
+    if (event === 'content') {
+        content = content.replace(/&([a-z]+);/g, (_, name) =>
+            HTML_ENTITIES[name] ? String.fromCodePoint(HTML_ENTITIES[name]) : `&${name};`);
+    }
+    if ((event === 'open-tag' || event === 'write-tag:no-children') && stackFrame) {
+        var ast = stackFrame.ast;
+        var newAst = [ast[0], ast[1]];
+        for (var i = 2; i < ast.length; i++) {
+            var attr = ast[i];
+            if (attr[2] && attr[2][0] === '"') {
+                attr = [attr[0], attr[1], '"' + attr[2].slice(1, -1).replace(/(?<!\\)"/g, '&#x22;') + '"'];
+            }
+            newAst.push(attr);
+        }
+        stackFrame = Object.assign({}, stackFrame, { ast: newAst });
+    }
+    return [event, stackFrame, content, state, data];
+}
+
+export function pre_qualified_ns(event, stackFrame, content, state, data) {
+    if (stackFrame && typeof stackFrame.ast[1] === 'string') {
+        var ast = stackFrame.ast;
+        var operator = ast[1] || '';
+        var colonIdx = operator.indexOf(':');
+        var ns = colonIdx > -1 ? operator.substring(0, colonIdx) : '';
+        var localName = colonIdx > -1 ? operator.substring(colonIdx + 1) : operator;
+        var tagName = ns ? operator : (stackFrame.namespace ? stackFrame.namespace + ':' + localName : localName);
+
+        if (event === 'open-tag' && ns) stackFrame.namespace = ns;
+
+        stackFrame = Object.assign({}, stackFrame, { ast: [ast[0], tagName, ...ast.slice(2)] });
+    }
+    return [event, stackFrame, content, state, data];
+}
+
+function attributes(arr) {
+    return arr.reduce(function(acc, val) {
+        if (val[1]) {
+            acc[val[1]] = val[2];
+        }
+        return acc;
+    }, {});
+}
+
+export function await_extensions() {
+    var dirPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../ext');
+    return new Promise(function(resolve, reject) {
+        lstat(dirPath, function(err, stat) {
+            if (err) { reject(err); }
+
+            if (stat.isDirectory()) {
+                readdir(dirPath, function(err, files) {
+                    if (err) { reject(err); }
+                    var extensions = {};
+                    Promise.all(files.map(function(filename) {
+                        return import(dirPath + '/' + filename).then(function(module) {
+                            var extName = basename(filename, extname(filename));
+                            extensions[extName] = function dispatch(event, stackFrame, content, processorState, data) {
+                                if (!data) {
+                                    console.trace()
+                                }
+                                var operatorName = stackFrame.operator.split(':')[1];
+                                if ('function' === typeof(module.default[operatorName])) {
+                                    module.default[operatorName](
+                                        event,
+                                        attributes(stackFrame.ast.slice(2)),
+                                        content,
+                                        processorState,    // processorState is mutable by the ext
+                                        {
+                                            ast: stackFrame.ast.slice(),
+                                            cursor: data.cursor,
+                                            lineCount: data.lineCount,
+                                            source: data.source
+                                        }
+                                    );
+                                } else {
+                                    console.error("Function not found for " + extName + ':' + operatorName);
+                                }
+                            }
+                        });
+                    })).then(function() {;
+                        resolve({extensions: extensions});
+                    });
+                });
+            } else {
+                reject(new Error("Not a directory: " + dirPath));
+            }
+        });
+    });
+}
+

package/src/util.js

@@ -0,0 +1,58 @@
+export function last(arr) {
+    return arr[arr.length -1];
+}
+
+export function last_but(num, arr, defaultReturnVal) {
+    return arr[arr.length - (num + 1)] || defaultReturnVal || null;
+}
+
+export function count_newlines(str) {
+    return (str.match(/\n/g) || []).length;
+}
+
+export function unquote(str) {
+    str = str.trim();
+    var ch1 = str[0];
+    if (('"' === ch1 || "'" === ch1) && ch1 === last(str)) {
+        return str.substring(1, str.length -1);
+    }
+    return str;
+}
+
+export const Interface = {
+    traits: {
+        new: function(data) {
+            data = data || {};
+            if (this.assertions) {
+                for (var x in this.assertions) {
+                    if (data.hasOwnProperty(x)) {
+                        if(!this.assertions[x](data[x])) {
+                            throw new Error({
+                                msg: "Object does not conform to interface",
+                                object: data,
+                                interface: this.assertions
+                            });
+                        }
+                    }
+                }
+            }
+            return Object.assign({}, this.defaults || {}, data);
+        }
+    },
+
+    isDefined: function(prop) {
+        return undefined !== prop;
+    },
+
+    isArray: function(prop) {
+        return Array.isArray(prop);
+    },
+
+    // Creates an interface that can be used to instantiate objects
+    // using its `new` method.  The interface will ensure tha the object's
+    // properties conform to the spec provided by the assertions.
+    create: function(data) {
+        return Object.assign(Object.create(Interface.traits), data);
+    }
+};
+