puglite 1.0.0

package/lib/error.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = makeError;
+function makeError(code, message, options) {
+    var line = options.line;
+    var column = options.column;
+    var filename = options.filename;
+    var src = options.src;
+    var fullMessage;
+    var location = line + (column ? ':' + column : '');
+    if (src && line >= 1 && line <= src.split('\n').length) {
+        var lines = src.split('\n');
+        var start_1 = Math.max(line - 3, 0);
+        var end = Math.min(lines.length, line + 3);
+        // Error context
+        var context = lines
+            .slice(start_1, end)
+            .map(function (text, i) {
+            var curr = i + start_1 + 1;
+            var preamble = (curr == line ? '  > ' : '    ') + curr + '| ';
+            var out = preamble + text;
+            if (curr === line && column > 0) {
+                out += '\n';
+                out += Array(preamble.length + column).join('-') + '^';
+            }
+            return out;
+        })
+            .join('\n');
+        fullMessage =
+            (filename || 'Pug') + ':' + location + '\n' + context + '\n\n' + message;
+    }
+    else {
+        fullMessage = (filename || 'Pug') + ':' + location + '\n\n' + message;
+    }
+    var err = new Error(fullMessage);
+    err.code = 'PUG:' + code;
+    err.msg = message;
+    err.line = line;
+    err.column = column;
+    err.filename = filename;
+    err.src = src;
+    err.toJSON = function () {
+        return {
+            code: this.code,
+            msg: this.msg,
+            line: this.line,
+            column: this.column,
+            filename: this.filename,
+        };
+    };
+    return err;
+}
+// Make this easier to use from CommonJS
+module.exports = makeError;
+module.exports.default = makeError;
+//# sourceMappingURL=index.js.map

package/lib/index.js

@@ -0,0 +1,416 @@
+'use strict';
+
+/*!
+ * Pug
+ * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs');
+var path = require('path');
+var lex = require('./lexer');
+var stripComments = require('./strip-comments');
+var parse = require('./parser');
+var generateCode = require('./code-gen');
+var runtime = require('./runtime');
+var runtimeWrap = require('./runtime-wrap');
+
+/**
+ * Name for detection
+ */
+
+exports.name = 'Pug';
+
+/**
+ * Pug runtime helpers.
+ */
+
+exports.runtime = runtime;
+
+/**
+ * Template function cache.
+ */
+
+exports.cache = {};
+
+function applyPlugins(value, options, plugins, name) {
+  return plugins.reduce(function(value, plugin) {
+    return plugin[name] ? plugin[name](value, options) : value;
+  }, value);
+}
+
+function findReplacementFunc(plugins, name) {
+  var eligiblePlugins = plugins.filter(function(plugin) {
+    return plugin[name];
+  });
+
+  if (eligiblePlugins.length > 1) {
+    throw new Error('Two or more plugins all implement ' + name + ' method.');
+  } else if (eligiblePlugins.length) {
+    return eligiblePlugins[0][name].bind(eligiblePlugins[0]);
+  }
+  return null;
+}
+
+
+/**
+ * Compile the given `str` of pug and return a function body.
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @return {Object}
+ * @api private
+ */
+
+function compileBody(str, options) {
+  var debug_sources = {};
+  debug_sources[options.filename] = str;
+  var dependencies = [];
+  var plugins = options.plugins || [];
+  // Lex
+  var lexOptions = {
+    filename: options.filename,
+    plugins: plugins
+      .filter(function(plugin) {
+        return !!plugin.lex;
+      })
+      .map(function(plugin) {
+        return plugin.lex;
+      })
+  };
+  var contents = applyPlugins(
+    str,
+    {filename: options.filename},
+    plugins,
+    'preLex'
+  );
+  var tokens = applyPlugins(
+    lex(contents, lexOptions),
+    {filename: options.filename},
+    plugins,
+    'postLex'
+  );
+
+  // Parse
+  tokens = stripComments(tokens, {filename: options.filename});
+  tokens = applyPlugins(tokens, {filename: options.filename}, plugins, 'preParse');
+  var parseOptions = {
+    filename: options.filename,
+    src: str,
+    plugins: plugins
+      .filter(function(plugin) {
+        return !!plugin.parse;
+      })
+      .map(function(plugin) {
+        return plugin.parse;
+      })
+  };
+  var ast = applyPlugins(
+    applyPlugins(
+      parse(tokens, parseOptions),
+      {filename: options.filename},
+      plugins,
+      'postParse'
+    ),
+    {filename: options.filename},
+    plugins,
+    'preLoad'
+  );
+  ast = applyPlugins(ast, options, plugins, 'postLoad');
+
+  // Compile
+  ast = applyPlugins(ast, options, plugins, 'preCodeGen');
+  var js = (findReplacementFunc(plugins, 'generateCode') || generateCode)(ast, {
+    pretty: options.pretty,
+    compileDebug: options.compileDebug,
+    doctype: options.doctype,
+    inlineRuntimeFunctions: options.inlineRuntimeFunctions,
+    globals: options.globals,
+    self: options.self,
+    includeSources: options.includeSources ? debug_sources : false,
+    templateName: options.templateName,
+  });
+  js = applyPlugins(js, options, plugins, 'postCodeGen');
+
+  // Debug compiler
+  if (options.debug) {
+    console.error(
+      '\nCompiled Function:\n\n\u001b[90m%s\u001b[0m',
+      js.replace(/^/gm, '  ')
+    );
+  }
+
+  return {body: js, dependencies: dependencies};
+}
+
+/**
+ * Get the template from a string or a file, either compiled on-the-fly or
+ * read from cache (if enabled), and cache the template if needed.
+ *
+ * If `str` is not set, the file specified in `options.filename` will be read.
+ *
+ * If `options.cache` is true, this function reads the file from
+ * `options.filename` so it must be set prior to calling this function.
+ *
+ * @param {Object} options
+ * @param {String=} str
+ * @return {Function}
+ * @api private
+ */
+function handleTemplateCache(options, str) {
+  var key = options.filename;
+  if (options.cache && exports.cache[key]) {
+    return exports.cache[key];
+  } else {
+    if (str === undefined) str = fs.readFileSync(options.filename, 'utf8');
+    var templ = exports.compile(str, options);
+    if (options.cache) exports.cache[key] = templ;
+    return templ;
+  }
+}
+
+/**
+ * Compile a `Function` representation of the given pug `str`.
+ *
+ * Options:
+ *
+ *   - `compileDebug` when `false` debugging code is stripped from the compiled
+       template, when it is explicitly `true`, the source code is included in
+       the compiled template for better accuracy.
+ *   - `filename` used to improve errors when `compileDebug` is not `false` and to resolve imports/extends
+ *
+ * @param {String} str
+ * @param {Options} options
+ * @return {Function}
+ * @api public
+ */
+
+exports.compile = function(str, options) {
+  var options = options || {};
+
+  str = String(str);
+
+  var parsed = compileBody(str, {
+    compileDebug: options.compileDebug !== false,
+    filename: options.filename,
+    basedir: options.basedir,
+    pretty: options.pretty,
+    doctype: options.doctype,
+    inlineRuntimeFunctions: options.inlineRuntimeFunctions,
+    globals: options.globals,
+    self: options.self,
+    includeSources: options.compileDebug === true,
+    debug: options.debug,
+    templateName: 'template',
+    plugins: options.plugins,
+  });
+
+  var res = options.inlineRuntimeFunctions
+    ? new Function('', parsed.body + ';return template;')()
+    : runtimeWrap(parsed.body);
+
+  res.dependencies = parsed.dependencies;
+
+  return res;
+};
+
+/**
+ * Compile a JavaScript source representation of the given pug `str`.
+ *
+ * Options:
+ *
+ *   - `compileDebug` When it is `true`, the source code is included in
+ *     the compiled template for better error messages.
+ *   - `filename` used to improve errors when `compileDebug` is not `true` and to resolve imports/extends
+ *   - `name` the name of the resulting function (defaults to "template")
+ *   - `module` when it is explicitly `true`, the source code include export module syntax
+ *
+ * @param {String} str
+ * @param {Options} options
+ * @return {Object}
+ * @api public
+ */
+
+exports.compileClientWithDependenciesTracked = function(str, options) {
+  var options = options || {};
+
+  str = String(str);
+  var parsed = compileBody(str, {
+    compileDebug: options.compileDebug,
+    filename: options.filename,
+    basedir: options.basedir,
+    pretty: options.pretty,
+    doctype: options.doctype,
+    inlineRuntimeFunctions: options.inlineRuntimeFunctions !== false,
+    globals: options.globals,
+    self: options.self,
+    includeSources: options.compileDebug,
+    debug: options.debug,
+    templateName: options.name || 'template',
+    plugins: options.plugins,
+  });
+
+  var body = parsed.body;
+
+  if (options.module) {
+    if (options.inlineRuntimeFunctions === false) {
+      body = 'var pug = require("pug-runtime");' + body;
+    }
+    body += ' module.exports = ' + (options.name || 'template') + ';';
+  }
+
+  return {body: body, dependencies: parsed.dependencies};
+};
+
+/**
+ * Compile a JavaScript source representation of the given pug `str`.
+ *
+ * Options:
+ *
+ *   - `compileDebug` When it is `true`, the source code is included in
+ *     the compiled template for better error messages.
+ *   - `filename` used to improve errors when `compileDebug` is not `true` and to resolve imports/extends
+ *   - `name` the name of the resulting function (defaults to "template")
+ *
+ * @param {String} str
+ * @param {Options} options
+ * @return {String}
+ * @api public
+ */
+exports.compileClient = function(str, options) {
+  return exports.compileClientWithDependenciesTracked(str, options).body;
+};
+
+/**
+ * Compile a `Function` representation of the given pug file.
+ *
+ * Options:
+ *
+ *   - `compileDebug` when `false` debugging code is stripped from the compiled
+       template, when it is explicitly `true`, the source code is included in
+       the compiled template for better accuracy.
+ *
+ * @param {String} path
+ * @param {Options} options
+ * @return {Function}
+ * @api public
+ */
+exports.compileFile = function(path, options) {
+  options = options || {};
+  options.filename = path;
+  return handleTemplateCache(options);
+};
+
+/**
+ * Render the given `str` of pug.
+ *
+ * Options:
+ *
+ *   - `cache` enable template caching
+ *   - `filename` filename required for `include` / `extends` and caching
+ *
+ * @param {String} str
+ * @param {Object|Function} options or fn
+ * @param {Function|undefined} fn
+ * @returns {String}
+ * @api public
+ */
+
+exports.render = function(str, options, fn) {
+  // support callback API
+  if ('function' == typeof options) {
+    (fn = options), (options = undefined);
+  }
+  if (typeof fn === 'function') {
+    var res;
+    try {
+      res = exports.render(str, options);
+    } catch (ex) {
+      return fn(ex);
+    }
+    return fn(null, res);
+  }
+
+  options = options || {};
+
+  // cache requires .filename
+  if (options.cache && !options.filename) {
+    throw new Error('the "filename" option is required for caching');
+  }
+
+  return handleTemplateCache(options, str)(options);
+};
+
+/**
+ * Render a Pug file at the given `path`.
+ *
+ * @param {String} path
+ * @param {Object|Function} options or callback
+ * @param {Function|undefined} fn
+ * @returns {String}
+ * @api public
+ */
+
+exports.renderFile = function(path, options, fn) {
+  // support callback API
+  if ('function' == typeof options) {
+    (fn = options), (options = undefined);
+  }
+  if (typeof fn === 'function') {
+    var res;
+    try {
+      res = exports.renderFile(path, options);
+    } catch (ex) {
+      return fn(ex);
+    }
+    return fn(null, res);
+  }
+
+  options = options || {};
+
+  options.filename = path;
+  return handleTemplateCache(options)(options);
+};
+
+/**
+ * Compile a Pug file at the given `path` for use on the client.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @returns {String}
+ * @api public
+ */
+
+exports.compileFileClient = function(path, options) {
+  var key = path + ':client';
+  options = options || {};
+
+  options.filename = path;
+
+  if (options.cache && exports.cache[key]) {
+    return exports.cache[key];
+  }
+
+  var str = fs.readFileSync(options.filename, 'utf8');
+  var out = exports.compileClient(str, options);
+  if (options.cache) exports.cache[key] = out;
+  return out;
+};
+
+/**
+ * Express support.
+ */
+
+exports.__express = function(path, options, fn) {
+  if (
+    options.compileDebug == undefined &&
+    process.env.NODE_ENV === 'production'
+  ) {
+    options.compileDebug = false;
+  }
+  exports.renderFile(path, options, fn);
+};