--- /dev/null
+'use strict';
+
+var use = require('use');
+var util = require('util');
+var Cache = require('map-cache');
+var define = require('define-property');
+var debug = require('debug')('snapdragon:parser');
+var Position = require('./position');
+var utils = require('./utils');
+
+/**
+ * Create a new `Parser` with the given `input` and `options`.
+ * @param {String} `input`
+ * @param {Object} `options`
+ * @api public
+ */
+
+function Parser(options) {
+ debug('initializing', __filename);
+ this.options = utils.extend({source: 'string'}, options);
+ this.init(this.options);
+ use(this);
+}
+
+/**
+ * Prototype methods
+ */
+
+Parser.prototype = {
+ constructor: Parser,
+
+ init: function(options) {
+ this.orig = '';
+ this.input = '';
+ this.parsed = '';
+
+ this.column = 1;
+ this.line = 1;
+
+ this.regex = new Cache();
+ this.errors = this.errors || [];
+ this.parsers = this.parsers || {};
+ this.types = this.types || [];
+ this.sets = this.sets || {};
+ this.fns = this.fns || [];
+ this.currentType = 'root';
+
+ var pos = this.position();
+ this.bos = pos({type: 'bos', val: ''});
+
+ this.ast = {
+ type: 'root',
+ errors: this.errors,
+ nodes: [this.bos]
+ };
+
+ define(this.bos, 'parent', this.ast);
+ this.nodes = [this.ast];
+
+ this.count = 0;
+ this.setCount = 0;
+ this.stack = [];
+ },
+
+ /**
+ * Throw a formatted error with the cursor column and `msg`.
+ * @param {String} `msg` Message to use in the Error.
+ */
+
+ error: function(msg, node) {
+ var pos = node.position || {start: {column: 0, line: 0}};
+ var line = pos.start.line;
+ var column = pos.start.column;
+ var source = this.options.source;
+
+ var message = source + ' <line:' + line + ' column:' + column + '>: ' + msg;
+ var err = new Error(message);
+ err.source = source;
+ err.reason = msg;
+ err.pos = pos;
+
+ if (this.options.silent) {
+ this.errors.push(err);
+ } else {
+ throw err;
+ }
+ },
+
+ /**
+ * Define a non-enumberable property on the `Parser` instance.
+ *
+ * ```js
+ * parser.define('foo', 'bar');
+ * ```
+ * @name .define
+ * @param {String} `key` propery name
+ * @param {any} `val` property value
+ * @return {Object} Returns the Parser instance for chaining.
+ * @api public
+ */
+
+ define: function(key, val) {
+ define(this, key, val);
+ return this;
+ },
+
+ /**
+ * Mark position and patch `node.position`.
+ */
+
+ position: function() {
+ var start = { line: this.line, column: this.column };
+ var self = this;
+
+ return function(node) {
+ define(node, 'position', new Position(start, self));
+ return node;
+ };
+ },
+
+ /**
+ * Set parser `name` with the given `fn`
+ * @param {String} `name`
+ * @param {Function} `fn`
+ * @api public
+ */
+
+ set: function(type, fn) {
+ if (this.types.indexOf(type) === -1) {
+ this.types.push(type);
+ }
+ this.parsers[type] = fn.bind(this);
+ return this;
+ },
+
+ /**
+ * Get parser `name`
+ * @param {String} `name`
+ * @api public
+ */
+
+ get: function(name) {
+ return this.parsers[name];
+ },
+
+ /**
+ * Push a `token` onto the `type` stack.
+ *
+ * @param {String} `type`
+ * @return {Object} `token`
+ * @api public
+ */
+
+ push: function(type, token) {
+ this.sets[type] = this.sets[type] || [];
+ this.count++;
+ this.stack.push(token);
+ return this.sets[type].push(token);
+ },
+
+ /**
+ * Pop a token off of the `type` stack
+ * @param {String} `type`
+ * @returns {Object} Returns a token
+ * @api public
+ */
+
+ pop: function(type) {
+ this.sets[type] = this.sets[type] || [];
+ this.count--;
+ this.stack.pop();
+ return this.sets[type].pop();
+ },
+
+ /**
+ * Return true if inside a `stack` node. Types are `braces`, `parens` or `brackets`.
+ *
+ * @param {String} `type`
+ * @return {Boolean}
+ * @api public
+ */
+
+ isInside: function(type) {
+ this.sets[type] = this.sets[type] || [];
+ return this.sets[type].length > 0;
+ },
+
+ /**
+ * Return true if `node` is the given `type`.
+ *
+ * ```js
+ * parser.isType(node, 'brace');
+ * ```
+ * @param {Object} `node`
+ * @param {String} `type`
+ * @return {Boolean}
+ * @api public
+ */
+
+ isType: function(node, type) {
+ return node && node.type === type;
+ },
+
+ /**
+ * Get the previous AST node
+ * @return {Object}
+ */
+
+ prev: function(n) {
+ return this.stack.length > 0
+ ? utils.last(this.stack, n)
+ : utils.last(this.nodes, n);
+ },
+
+ /**
+ * Update line and column based on `str`.
+ */
+
+ consume: function(len) {
+ this.input = this.input.substr(len);
+ },
+
+ /**
+ * Update column based on `str`.
+ */
+
+ updatePosition: function(str, len) {
+ var lines = str.match(/\n/g);
+ if (lines) this.line += lines.length;
+ var i = str.lastIndexOf('\n');
+ this.column = ~i ? len - i : this.column + len;
+ this.parsed += str;
+ this.consume(len);
+ },
+
+ /**
+ * Match `regex`, return captures, and update the cursor position by `match[0]` length.
+ * @param {RegExp} `regex`
+ * @return {Object}
+ */
+
+ match: function(regex) {
+ var m = regex.exec(this.input);
+ if (m) {
+ this.updatePosition(m[0], m[0].length);
+ return m;
+ }
+ },
+
+ /**
+ * Capture `type` with the given regex.
+ * @param {String} `type`
+ * @param {RegExp} `regex`
+ * @return {Function}
+ */
+
+ capture: function(type, regex) {
+ if (typeof regex === 'function') {
+ return this.set.apply(this, arguments);
+ }
+
+ this.regex.set(type, regex);
+ this.set(type, function() {
+ var parsed = this.parsed;
+ var pos = this.position();
+ var m = this.match(regex);
+ if (!m || !m[0]) return;
+
+ var prev = this.prev();
+ var node = pos({
+ type: type,
+ val: m[0],
+ parsed: parsed,
+ rest: this.input
+ });
+
+ if (m[1]) {
+ node.inner = m[1];
+ }
+
+ define(node, 'inside', this.stack.length > 0);
+ define(node, 'parent', prev);
+ prev.nodes.push(node);
+ }.bind(this));
+ return this;
+ },
+
+ /**
+ * Create a parser with open and close for parens,
+ * brackets or braces
+ */
+
+ capturePair: function(type, openRegex, closeRegex, fn) {
+ this.sets[type] = this.sets[type] || [];
+
+ /**
+ * Open
+ */
+
+ this.set(type + '.open', function() {
+ var parsed = this.parsed;
+ var pos = this.position();
+ var m = this.match(openRegex);
+ if (!m || !m[0]) return;
+
+ var val = m[0];
+ this.setCount++;
+ this.specialChars = true;
+ var open = pos({
+ type: type + '.open',
+ val: val,
+ rest: this.input
+ });
+
+ if (typeof m[1] !== 'undefined') {
+ open.inner = m[1];
+ }
+
+ var prev = this.prev();
+ var node = pos({
+ type: type,
+ nodes: [open]
+ });
+
+ define(node, 'rest', this.input);
+ define(node, 'parsed', parsed);
+ define(node, 'prefix', m[1]);
+ define(node, 'parent', prev);
+ define(open, 'parent', node);
+
+ if (typeof fn === 'function') {
+ fn.call(this, open, node);
+ }
+
+ this.push(type, node);
+ prev.nodes.push(node);
+ });
+
+ /**
+ * Close
+ */
+
+ this.set(type + '.close', function() {
+ var pos = this.position();
+ var m = this.match(closeRegex);
+ if (!m || !m[0]) return;
+
+ var parent = this.pop(type);
+ var node = pos({
+ type: type + '.close',
+ rest: this.input,
+ suffix: m[1],
+ val: m[0]
+ });
+
+ if (!this.isType(parent, type)) {
+ if (this.options.strict) {
+ throw new Error('missing opening "' + type + '"');
+ }
+
+ this.setCount--;
+ node.escaped = true;
+ return node;
+ }
+
+ if (node.suffix === '\\') {
+ parent.escaped = true;
+ node.escaped = true;
+ }
+
+ parent.nodes.push(node);
+ define(node, 'parent', parent);
+ });
+
+ return this;
+ },
+
+ /**
+ * Capture end-of-string
+ */
+
+ eos: function() {
+ var pos = this.position();
+ if (this.input) return;
+ var prev = this.prev();
+
+ while (prev.type !== 'root' && !prev.visited) {
+ if (this.options.strict === true) {
+ throw new SyntaxError('invalid syntax:' + util.inspect(prev, null, 2));
+ }
+
+ if (!hasDelims(prev)) {
+ prev.parent.escaped = true;
+ prev.escaped = true;
+ }
+
+ visit(prev, function(node) {
+ if (!hasDelims(node.parent)) {
+ node.parent.escaped = true;
+ node.escaped = true;
+ }
+ });
+
+ prev = prev.parent;
+ }
+
+ var tok = pos({
+ type: 'eos',
+ val: this.append || ''
+ });
+
+ define(tok, 'parent', this.ast);
+ return tok;
+ },
+
+ /**
+ * Run parsers to advance the cursor position
+ */
+
+ next: function() {
+ var parsed = this.parsed;
+ var len = this.types.length;
+ var idx = -1;
+ var tok;
+
+ while (++idx < len) {
+ if ((tok = this.parsers[this.types[idx]].call(this))) {
+ define(tok, 'rest', this.input);
+ define(tok, 'parsed', parsed);
+ this.last = tok;
+ return tok;
+ }
+ }
+ },
+
+ /**
+ * Parse the given string.
+ * @return {Array}
+ */
+
+ parse: function(input) {
+ if (typeof input !== 'string') {
+ throw new TypeError('expected a string');
+ }
+
+ this.init(this.options);
+ this.orig = input;
+ this.input = input;
+ var self = this;
+
+ function parse() {
+ // check input before calling `.next()`
+ input = self.input;
+
+ // get the next AST ndoe
+ var node = self.next();
+ if (node) {
+ var prev = self.prev();
+ if (prev) {
+ define(node, 'parent', prev);
+ if (prev.nodes) {
+ prev.nodes.push(node);
+ }
+ }
+
+ if (self.sets.hasOwnProperty(prev.type)) {
+ self.currentType = prev.type;
+ }
+ }
+
+ // if we got here but input is not changed, throw an error
+ if (self.input && input === self.input) {
+ throw new Error('no parsers registered for: "' + self.input.slice(0, 5) + '"');
+ }
+ }
+
+ while (this.input) parse();
+ if (this.stack.length && this.options.strict) {
+ var node = this.stack.pop();
+ throw this.error('missing opening ' + node.type + ': "' + this.orig + '"');
+ }
+
+ var eos = this.eos();
+ var tok = this.prev();
+ if (tok.type !== 'eos') {
+ this.ast.nodes.push(eos);
+ }
+
+ return this.ast;
+ }
+};
+
+/**
+ * Visit `node` with the given `fn`
+ */
+
+function visit(node, fn) {
+ if (!node.visited) {
+ define(node, 'visited', true);
+ return node.nodes ? mapVisit(node.nodes, fn) : fn(node);
+ }
+ return node;
+}
+
+/**
+ * Map visit over array of `nodes`.
+ */
+
+function mapVisit(nodes, fn) {
+ var len = nodes.length;
+ var idx = -1;
+ while (++idx < len) {
+ visit(nodes[idx], fn);
+ }
+}
+
+function hasOpen(node) {
+ return node.nodes && node.nodes[0].type === (node.type + '.open');
+}
+
+function hasClose(node) {
+ return node.nodes && utils.last(node.nodes).type === (node.type + '.close');
+}
+
+function hasDelims(node) {
+ return hasOpen(node) && hasClose(node);
+}
+
+/**
+ * Expose `Parser`
+ */
+
+module.exports = Parser;
projects / dotfiles / .git / blobdiff