| 'use strict'; |
| |
| var Base = require('base'); |
| var define = require('define-property'); |
| var Compiler = require('./lib/compiler'); |
| var Parser = require('./lib/parser'); |
| var utils = require('./lib/utils'); |
| var regexCache = {}; |
| var cache = {}; |
| |
| /** |
| * Create a new instance of `Snapdragon` with the given `options`. |
| * |
| * ```js |
| * var snapdragon = new Snapdragon(); |
| * ``` |
| * |
| * @param {Object} `options` |
| * @api public |
| */ |
| |
| function Snapdragon(options) { |
| Base.call(this, null, options); |
| this.options = utils.extend({source: 'string'}, this.options); |
| this.compiler = new Compiler(this.options); |
| this.parser = new Parser(this.options); |
| |
| Object.defineProperty(this, 'compilers', { |
| get: function() { |
| return this.compiler.compilers; |
| } |
| }); |
| |
| Object.defineProperty(this, 'parsers', { |
| get: function() { |
| return this.parser.parsers; |
| } |
| }); |
| |
| Object.defineProperty(this, 'regex', { |
| get: function() { |
| return this.parser.regex; |
| } |
| }); |
| } |
| |
| /** |
| * Inherit Base |
| */ |
| |
| Base.extend(Snapdragon); |
| |
| /** |
| * Add a parser to `snapdragon.parsers` for capturing the given `type` using |
| * the specified regex or parser function. A function is useful if you need |
| * to customize how the token is created and/or have access to the parser |
| * instance to check options, etc. |
| * |
| * ```js |
| * snapdragon |
| * .capture('slash', /^\//) |
| * .capture('dot', function() { |
| * var pos = this.position(); |
| * var m = this.match(/^\./); |
| * if (!m) return; |
| * return pos({ |
| * type: 'dot', |
| * val: m[0] |
| * }); |
| * }); |
| * ``` |
| * @param {String} `type` |
| * @param {RegExp|Function} `regex` |
| * @return {Object} Returns the parser instance for chaining |
| * @api public |
| */ |
| |
| Snapdragon.prototype.capture = function() { |
| return this.parser.capture.apply(this.parser, arguments); |
| }; |
| |
| /** |
| * Register a plugin `fn`. |
| * |
| * ```js |
| * var snapdragon = new Snapdgragon([options]); |
| * snapdragon.use(function() { |
| * console.log(this); //<= snapdragon instance |
| * console.log(this.parser); //<= parser instance |
| * console.log(this.compiler); //<= compiler instance |
| * }); |
| * ``` |
| * @param {Object} `fn` |
| * @api public |
| */ |
| |
| Snapdragon.prototype.use = function(fn) { |
| fn.call(this, this); |
| return this; |
| }; |
| |
| /** |
| * Parse the given `str`. |
| * |
| * ```js |
| * var snapdragon = new Snapdgragon([options]); |
| * // register parsers |
| * snapdragon.parser.use(function() {}); |
| * |
| * // parse |
| * var ast = snapdragon.parse('foo/bar'); |
| * console.log(ast); |
| * ``` |
| * @param {String} `str` |
| * @param {Object} `options` Set `options.sourcemap` to true to enable source maps. |
| * @return {Object} Returns an AST. |
| * @api public |
| */ |
| |
| Snapdragon.prototype.parse = function(str, options) { |
| this.options = utils.extend({}, this.options, options); |
| var parsed = this.parser.parse(str, this.options); |
| |
| // add non-enumerable parser reference |
| define(parsed, 'parser', this.parser); |
| return parsed; |
| }; |
| |
| /** |
| * Compile the given `AST`. |
| * |
| * ```js |
| * var snapdragon = new Snapdgragon([options]); |
| * // register plugins |
| * snapdragon.use(function() {}); |
| * // register parser plugins |
| * snapdragon.parser.use(function() {}); |
| * // register compiler plugins |
| * snapdragon.compiler.use(function() {}); |
| * |
| * // parse |
| * var ast = snapdragon.parse('foo/bar'); |
| * |
| * // compile |
| * var res = snapdragon.compile(ast); |
| * console.log(res.output); |
| * ``` |
| * @param {Object} `ast` |
| * @param {Object} `options` |
| * @return {Object} Returns an object with an `output` property with the rendered string. |
| * @api public |
| */ |
| |
| Snapdragon.prototype.compile = function(ast, options) { |
| this.options = utils.extend({}, this.options, options); |
| var compiled = this.compiler.compile(ast, this.options); |
| |
| // add non-enumerable compiler reference |
| define(compiled, 'compiler', this.compiler); |
| return compiled; |
| }; |
| |
| /** |
| * Expose `Snapdragon` |
| */ |
| |
| module.exports = Snapdragon; |
| |
| /** |
| * Expose `Parser` and `Compiler` |
| */ |
| |
| module.exports.Compiler = Compiler; |
| module.exports.Parser = Parser; |