| 'use strict'; |
| |
| var isObject = require('isobject'); |
| var define = require('define-property'); |
| var utils = require('snapdragon-util'); |
| var ownNames; |
| |
| /** |
| * Create a new AST `Node` with the given `val` and `type`. |
| * |
| * ```js |
| * var node = new Node('*', 'Star'); |
| * var node = new Node({type: 'star', val: '*'}); |
| * ``` |
| * @name Node |
| * @param {String|Object} `val` Pass a matched substring, or an object to merge onto the node. |
| * @param {String} `type` The node type to use when `val` is a string. |
| * @return {Object} node instance |
| * @api public |
| */ |
| |
| function Node(val, type, parent) { |
| if (typeof type !== 'string') { |
| parent = type; |
| type = null; |
| } |
| |
| define(this, 'parent', parent); |
| define(this, 'isNode', true); |
| define(this, 'expect', null); |
| |
| if (typeof type !== 'string' && isObject(val)) { |
| lazyKeys(); |
| var keys = Object.keys(val); |
| for (var i = 0; i < keys.length; i++) { |
| var key = keys[i]; |
| if (ownNames.indexOf(key) === -1) { |
| this[key] = val[key]; |
| } |
| } |
| } else { |
| this.type = type; |
| this.val = val; |
| } |
| } |
| |
| /** |
| * Returns true if the given value is a node. |
| * |
| * ```js |
| * var Node = require('snapdragon-node'); |
| * var node = new Node({type: 'foo'}); |
| * console.log(Node.isNode(node)); //=> true |
| * console.log(Node.isNode({})); //=> false |
| * ``` |
| * @param {Object} `node` |
| * @returns {Boolean} |
| * @api public |
| */ |
| |
| Node.isNode = function(node) { |
| return utils.isNode(node); |
| }; |
| |
| /** |
| * Define a non-enumberable property on the node instance. |
| * Useful for adding properties that shouldn't be extended |
| * or visible during debugging. |
| * |
| * ```js |
| * var node = new Node(); |
| * node.define('foo', 'something non-enumerable'); |
| * ``` |
| * @param {String} `name` |
| * @param {any} `val` |
| * @return {Object} returns the node instance |
| * @api public |
| */ |
| |
| Node.prototype.define = function(name, val) { |
| define(this, name, val); |
| return this; |
| }; |
| |
| /** |
| * Returns true if `node.val` is an empty string, or `node.nodes` does |
| * not contain any non-empty text nodes. |
| * |
| * ```js |
| * var node = new Node({type: 'text'}); |
| * node.isEmpty(); //=> true |
| * node.val = 'foo'; |
| * node.isEmpty(); //=> false |
| * ``` |
| * @param {Function} `fn` (optional) Filter function that is called on `node` and/or child nodes. `isEmpty` will return false immediately when the filter function returns false on any nodes. |
| * @return {Boolean} |
| * @api public |
| */ |
| |
| Node.prototype.isEmpty = function(fn) { |
| return utils.isEmpty(this, fn); |
| }; |
| |
| /** |
| * Given node `foo` and node `bar`, push node `bar` onto `foo.nodes`, and |
| * set `foo` as `bar.parent`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * foo.push(bar); |
| * ``` |
| * @param {Object} `node` |
| * @return {Number} Returns the length of `node.nodes` |
| * @api public |
| */ |
| |
| Node.prototype.push = function(node) { |
| assert(Node.isNode(node), 'expected node to be an instance of Node'); |
| define(node, 'parent', this); |
| |
| this.nodes = this.nodes || []; |
| return this.nodes.push(node); |
| }; |
| |
| /** |
| * Given node `foo` and node `bar`, unshift node `bar` onto `foo.nodes`, and |
| * set `foo` as `bar.parent`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * foo.unshift(bar); |
| * ``` |
| * @param {Object} `node` |
| * @return {Number} Returns the length of `node.nodes` |
| * @api public |
| */ |
| |
| Node.prototype.unshift = function(node) { |
| assert(Node.isNode(node), 'expected node to be an instance of Node'); |
| define(node, 'parent', this); |
| |
| this.nodes = this.nodes || []; |
| return this.nodes.unshift(node); |
| }; |
| |
| /** |
| * Pop a node from `node.nodes`. |
| * |
| * ```js |
| * var node = new Node({type: 'foo'}); |
| * node.push(new Node({type: 'a'})); |
| * node.push(new Node({type: 'b'})); |
| * node.push(new Node({type: 'c'})); |
| * node.push(new Node({type: 'd'})); |
| * console.log(node.nodes.length); |
| * //=> 4 |
| * node.pop(); |
| * console.log(node.nodes.length); |
| * //=> 3 |
| * ``` |
| * @return {Number} Returns the popped `node` |
| * @api public |
| */ |
| |
| Node.prototype.pop = function() { |
| return this.nodes && this.nodes.pop(); |
| }; |
| |
| /** |
| * Shift a node from `node.nodes`. |
| * |
| * ```js |
| * var node = new Node({type: 'foo'}); |
| * node.push(new Node({type: 'a'})); |
| * node.push(new Node({type: 'b'})); |
| * node.push(new Node({type: 'c'})); |
| * node.push(new Node({type: 'd'})); |
| * console.log(node.nodes.length); |
| * //=> 4 |
| * node.shift(); |
| * console.log(node.nodes.length); |
| * //=> 3 |
| * ``` |
| * @return {Object} Returns the shifted `node` |
| * @api public |
| */ |
| |
| Node.prototype.shift = function() { |
| return this.nodes && this.nodes.shift(); |
| }; |
| |
| /** |
| * Remove `node` from `node.nodes`. |
| * |
| * ```js |
| * node.remove(childNode); |
| * ``` |
| * @param {Object} `node` |
| * @return {Object} Returns the removed node. |
| * @api public |
| */ |
| |
| Node.prototype.remove = function(node) { |
| assert(Node.isNode(node), 'expected node to be an instance of Node'); |
| this.nodes = this.nodes || []; |
| var idx = node.index; |
| if (idx !== -1) { |
| node.index = -1; |
| return this.nodes.splice(idx, 1); |
| } |
| return null; |
| }; |
| |
| /** |
| * Get the first child node from `node.nodes` that matches the given `type`. |
| * If `type` is a number, the child node at that index is returned. |
| * |
| * ```js |
| * var child = node.find(1); //<= index of the node to get |
| * var child = node.find('foo'); //<= node.type of a child node |
| * var child = node.find(/^(foo|bar)$/); //<= regex to match node.type |
| * var child = node.find(['foo', 'bar']); //<= array of node.type(s) |
| * ``` |
| * @param {String} `type` |
| * @return {Object} Returns a child node or undefined. |
| * @api public |
| */ |
| |
| Node.prototype.find = function(type) { |
| return utils.findNode(this.nodes, type); |
| }; |
| |
| /** |
| * Return true if the node is the given `type`. |
| * |
| * ```js |
| * var node = new Node({type: 'bar'}); |
| * cosole.log(node.isType('foo')); // false |
| * cosole.log(node.isType(/^(foo|bar)$/)); // true |
| * cosole.log(node.isType(['foo', 'bar'])); // true |
| * ``` |
| * @param {String} `type` |
| * @return {Boolean} |
| * @api public |
| */ |
| |
| Node.prototype.isType = function(type) { |
| return utils.isType(this, type); |
| }; |
| |
| /** |
| * Return true if the `node.nodes` has the given `type`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * foo.push(bar); |
| * |
| * cosole.log(foo.hasType('qux')); // false |
| * cosole.log(foo.hasType(/^(qux|bar)$/)); // true |
| * cosole.log(foo.hasType(['qux', 'bar'])); // true |
| * ``` |
| * @param {String} `type` |
| * @return {Boolean} |
| * @api public |
| */ |
| |
| Node.prototype.hasType = function(type) { |
| return utils.hasType(this, type); |
| }; |
| |
| /** |
| * Get the siblings array, or `null` if it doesn't exist. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * |
| * console.log(bar.siblings.length) // 2 |
| * console.log(baz.siblings.length) // 2 |
| * ``` |
| * @return {Array} |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'siblings', { |
| set: function() { |
| throw new Error('node.siblings is a getter and cannot be defined'); |
| }, |
| get: function() { |
| return this.parent ? this.parent.nodes : null; |
| } |
| }); |
| |
| /** |
| * Get the node's current index from `node.parent.nodes`. |
| * This should always be correct, even when the parent adds nodes. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * var qux = new Node({type: 'qux'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * foo.unshift(qux); |
| * |
| * console.log(bar.index) // 1 |
| * console.log(baz.index) // 2 |
| * console.log(qux.index) // 0 |
| * ``` |
| * @return {Number} |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'index', { |
| set: function(index) { |
| define(this, 'idx', index); |
| }, |
| get: function() { |
| if (!Array.isArray(this.siblings)) { |
| return -1; |
| } |
| var tok = this.idx !== -1 ? this.siblings[this.idx] : null; |
| if (tok !== this) { |
| this.idx = this.siblings.indexOf(this); |
| } |
| return this.idx; |
| } |
| }); |
| |
| /** |
| * Get the previous node from the siblings array or `null`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * |
| * console.log(baz.prev.type) // 'bar' |
| * ``` |
| * @return {Object} |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'prev', { |
| set: function() { |
| throw new Error('node.prev is a getter and cannot be defined'); |
| }, |
| get: function() { |
| if (Array.isArray(this.siblings)) { |
| return this.siblings[this.index - 1] || this.parent.prev; |
| } |
| return null; |
| } |
| }); |
| |
| /** |
| * Get the siblings array, or `null` if it doesn't exist. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * |
| * console.log(bar.siblings.length) // 2 |
| * console.log(baz.siblings.length) // 2 |
| * ``` |
| * @return {Object} |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'next', { |
| set: function() { |
| throw new Error('node.next is a getter and cannot be defined'); |
| }, |
| get: function() { |
| if (Array.isArray(this.siblings)) { |
| return this.siblings[this.index + 1] || this.parent.next; |
| } |
| return null; |
| } |
| }); |
| |
| /** |
| * Get the first node from `node.nodes`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * var qux = new Node({type: 'qux'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * foo.push(qux); |
| * |
| * console.log(foo.first.type) // 'bar' |
| * ``` |
| * @return {Object} The first node, or undefiend |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'first', { |
| get: function() { |
| return this.nodes ? this.nodes[0] : null; |
| } |
| }); |
| |
| /** |
| * Get the last node from `node.nodes`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * var qux = new Node({type: 'qux'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * foo.push(qux); |
| * |
| * console.log(foo.last.type) // 'qux' |
| * ``` |
| * @return {Object} The last node, or undefiend |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'last', { |
| get: function() { |
| return this.nodes ? utils.last(this.nodes) : null; |
| } |
| }); |
| |
| /** |
| * Get the last node from `node.nodes`. |
| * |
| * ```js |
| * var foo = new Node({type: 'foo'}); |
| * var bar = new Node({type: 'bar'}); |
| * var baz = new Node({type: 'baz'}); |
| * var qux = new Node({type: 'qux'}); |
| * foo.push(bar); |
| * foo.push(baz); |
| * foo.push(qux); |
| * |
| * console.log(foo.last.type) // 'qux' |
| * ``` |
| * @return {Object} The last node, or undefiend |
| * @api public |
| */ |
| |
| Object.defineProperty(Node.prototype, 'scope', { |
| get: function() { |
| if (this.isScope !== true) { |
| return this.parent ? this.parent.scope : this; |
| } |
| return this; |
| } |
| }); |
| |
| /** |
| * Get own property names from Node prototype, but only the |
| * first time `Node` is instantiated |
| */ |
| |
| function lazyKeys() { |
| if (!ownNames) { |
| ownNames = Object.getOwnPropertyNames(Node.prototype); |
| } |
| } |
| |
| /** |
| * Simplified assertion. Throws an error is `val` is falsey. |
| */ |
| |
| function assert(val, message) { |
| if (!val) throw new Error(message); |
| } |
| |
| /** |
| * Expose `Node` |
| */ |
| |
| exports = module.exports = Node; |