puglite 1.0.0

package/lib/code-gen.js

@@ -0,0 +1,769 @@
+'use strict';
+
+var doctypes = require('doctypes');
+var makeError = require('./error');
+var buildRuntime = require('./runtime-build');
+var runtime = require('./runtime');
+var compileAttrs = require('./attrs');
+var selfClosing = require('void-elements');
+var constantinople = require('constantinople');
+var stringify = require('js-stringify');
+var addWith = require('with');
+
+// This is used to prevent pretty printing inside certain tags
+var WHITE_SPACE_SENSITIVE_TAGS = {
+  pre: true,
+  textarea: true,
+};
+
+var INTERNAL_VARIABLES = [
+  'pug',
+  'pug_interp',
+  'pug_debug_filename',
+  'pug_debug_line',
+  'pug_debug_sources',
+  'pug_html',
+];
+
+module.exports = generateCode;
+module.exports.CodeGenerator = Compiler;
+function generateCode(ast, options) {
+  return new Compiler(ast, options).compile();
+}
+
+function isConstant(src) {
+  return constantinople(src, {pug: runtime, pug_interp: undefined});
+}
+function toConstant(src) {
+  return constantinople.toConstant(src, {pug: runtime, pug_interp: undefined});
+}
+
+function isIdentifier(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+
+/**
+ * Initialize `Compiler` with the given `node`.
+ *
+ * @param {Node} node
+ * @param {Object} options
+ * @api public
+ */
+
+function Compiler(node, options) {
+  this.options = options = options || {};
+  this.node = node;
+  this.bufferedConcatenationCount = 0;
+  this.hasCompiledDoctype = false;
+  this.hasCompiledTag = false;
+  this.pp = options.pretty || false;
+  if (this.pp && typeof this.pp !== 'string') {
+    this.pp = '  ';
+  }
+  if (this.pp && !/^\s+$/.test(this.pp)) {
+    throw new Error(
+      'The pretty parameter should either be a boolean or whitespace only string'
+    );
+  }
+  if (this.options.templateName && !isIdentifier(this.options.templateName)) {
+    throw new Error(
+      'The templateName parameter must be a valid JavaScript identifier if specified.'
+    );
+  }
+  if (
+    this.doctype &&
+    (this.doctype.includes('<') || this.doctype.includes('>'))
+  ) {
+    throw new Error('Doctype can not contain "<" or ">"');
+  }
+  if (this.options.globals && !this.options.globals.every(isIdentifier)) {
+    throw new Error(
+      'The globals option must be an array of valid JavaScript identifiers if specified.'
+    );
+  }
+
+  this.debug = false !== options.compileDebug;
+  this.indents = 0;
+  this.parentIndents = 0;
+  this.terse = false;
+  this.eachCount = 0;
+  if (options.doctype) this.setDoctype(options.doctype);
+  this.runtimeFunctionsUsed = [];
+  this.inlineRuntimeFunctions = options.inlineRuntimeFunctions || false;
+  if (this.debug && this.inlineRuntimeFunctions) {
+    this.runtimeFunctionsUsed.push('rethrow');
+  }
+}
+
+/**
+ * Compiler prototype.
+ */
+
+Compiler.prototype = {
+  runtime: function(name) {
+    if (this.inlineRuntimeFunctions) {
+      this.runtimeFunctionsUsed.push(name);
+      return 'pug_' + name;
+    } else {
+      return 'pug.' + name;
+    }
+  },
+
+  error: function(message, code, node) {
+    var err = makeError(code, message, {
+      line: node.line,
+      column: node.column,
+      filename: node.filename,
+    });
+    throw err;
+  },
+
+  /**
+   * Compile parse tree to JavaScript.
+   *
+   * @api public
+   */
+
+  compile: function() {
+    this.buf = [];
+    if (this.pp) this.buf.push('var pug_indent = [];');
+    this.lastBufferedIdx = -1;
+    this.visit(this.node);
+    var js = this.buf.join('\n');
+    var globals = this.options.globals
+      ? this.options.globals.concat(INTERNAL_VARIABLES)
+      : INTERNAL_VARIABLES;
+    if (this.options.self) {
+      js = 'var self = locals || {};' + js;
+    } else {
+      js = addWith(
+        'locals || {}',
+        js,
+        globals.concat(
+          this.runtimeFunctionsUsed.map(function(name) {
+            return 'pug_' + name;
+          })
+        )
+      );
+    }
+    if (this.debug) {
+      if (this.options.includeSources) {
+        js =
+          'var pug_debug_sources = ' +
+          stringify(this.options.includeSources) +
+          ';\n' +
+          js;
+      }
+      js =
+        'var pug_debug_filename, pug_debug_line;' +
+        'try {' +
+        js +
+        '} catch (err) {' +
+        (this.inlineRuntimeFunctions ? 'pug_rethrow' : 'pug.rethrow') +
+        '(err, pug_debug_filename, pug_debug_line' +
+        (this.options.includeSources
+          ? ', pug_debug_sources[pug_debug_filename]'
+          : '') +
+        ');' +
+        '}';
+    }
+
+    return (
+      buildRuntime(this.runtimeFunctionsUsed) +
+      'function ' +
+      (this.options.templateName || 'template') +
+      '(locals) {var pug_html = "", pug_interp;' +
+      js +
+      ';return pug_html;}'
+    );
+  },
+
+  /**
+   * Sets the default doctype `name`. Sets terse mode to `true` when
+   * html 5 is used, causing self-closing tags to end with ">" vs "/>",
+   * and boolean attributes are not mirrored.
+   *
+   * @param {string} name
+   * @api public
+   */
+
+  setDoctype: function(name) {
+    this.doctype = doctypes[name.toLowerCase()] || '<!DOCTYPE ' + name + '>';
+    this.terse = this.doctype.toLowerCase() == '<!doctype html>';
+    this.xml = 0 == this.doctype.indexOf('<?xml');
+  },
+
+  /**
+   * Buffer the given `str` exactly as is or with interpolation
+   *
+   * @param {String} str
+   * @param {Boolean} interpolate
+   * @api public
+   */
+
+  buffer: function(str) {
+    var self = this;
+
+    str = stringify(str);
+    str = str.substr(1, str.length - 2);
+
+    if (
+      this.lastBufferedIdx == this.buf.length &&
+      this.bufferedConcatenationCount < 100
+    ) {
+      if (this.lastBufferedType === 'code') {
+        this.lastBuffered += ' + "';
+        this.bufferedConcatenationCount++;
+      }
+      this.lastBufferedType = 'text';
+      this.lastBuffered += str;
+      this.buf[this.lastBufferedIdx - 1] =
+        'pug_html = pug_html + ' +
+        this.bufferStartChar +
+        this.lastBuffered +
+        '";';
+    } else {
+      this.bufferedConcatenationCount = 0;
+      this.buf.push('pug_html = pug_html + "' + str + '";');
+      this.lastBufferedType = 'text';
+      this.bufferStartChar = '"';
+      this.lastBuffered = str;
+      this.lastBufferedIdx = this.buf.length;
+    }
+  },
+
+  /**
+   * Buffer the given `src` so it is evaluated at run time
+   *
+   * @param {String} src
+   * @api public
+   */
+
+  bufferExpression: function(src) {
+    if (isConstant(src)) {
+      return this.buffer(toConstant(src) + '');
+    }
+    if (
+      this.lastBufferedIdx == this.buf.length &&
+      this.bufferedConcatenationCount < 100
+    ) {
+      this.bufferedConcatenationCount++;
+      if (this.lastBufferedType === 'text') this.lastBuffered += '"';
+      this.lastBufferedType = 'code';
+      this.lastBuffered += ' + (' + src + ')';
+      this.buf[this.lastBufferedIdx - 1] =
+        'pug_html = pug_html + (' +
+        this.bufferStartChar +
+        this.lastBuffered +
+        ');';
+    } else {
+      this.bufferedConcatenationCount = 0;
+      this.buf.push('pug_html = pug_html + (' + src + ');');
+      this.lastBufferedType = 'code';
+      this.bufferStartChar = '';
+      this.lastBuffered = '(' + src + ')';
+      this.lastBufferedIdx = this.buf.length;
+    }
+  },
+
+  /**
+   * Buffer an indent based on the current `indent`
+   * property and an additional `offset`.
+   *
+   * @param {Number} offset
+   * @param {Boolean} newline
+   * @api public
+   */
+
+  prettyIndent: function(offset, newline) {
+    offset = offset || 0;
+    newline = newline ? '\n' : '';
+    this.buffer(newline + Array(this.indents + offset).join(this.pp));
+    if (this.parentIndents)
+      this.buf.push('pug_html = pug_html + pug_indent.join("");');
+  },
+
+  /**
+   * Visit `node`.
+   *
+   * @param {Node} node
+   * @api public
+   */
+
+  visit: function(node, parent) {
+    var debug = this.debug;
+
+    if (!node) {
+      var msg;
+      if (parent) {
+        msg =
+          'A child of ' +
+          parent.type +
+          ' (' +
+          (parent.filename || 'Pug') +
+          ':' +
+          parent.line +
+          ')';
+      } else {
+        msg = 'A top-level node';
+      }
+      msg += ' is ' + node + ', expected a Pug AST Node.';
+      throw new TypeError(msg);
+    }
+
+    if (debug && node.debug !== false && node.type !== 'Block') {
+      if (node.line) {
+        var js = ';pug_debug_line = ' + node.line;
+        if (node.filename)
+          js += ';pug_debug_filename = ' + stringify(node.filename);
+        this.buf.push(js + ';');
+      }
+    }
+
+    if (!this['visit' + node.type]) {
+      var msg;
+      if (parent) {
+        msg = 'A child of ' + parent.type;
+      } else {
+        msg = 'A top-level node';
+      }
+      msg +=
+        ' (' +
+        (node.filename || 'Pug') +
+        ':' +
+        node.line +
+        ')' +
+        ' is of type ' +
+        node.type +
+        ',' +
+        ' which is not supported by pug-code-gen.';
+      switch (node.type) {
+        case 'Filter':
+          msg += ' Filters are not supported in puglite.';
+          break;
+        case 'Extends':
+        case 'Include':
+        case 'NamedBlock':
+        case 'FileReference': // unlikely but for the sake of completeness
+          msg += ' Extends and includes are not supported in puglite.';
+          break;
+      }
+      throw new TypeError(msg);
+    }
+
+    this.visitNode(node);
+  },
+
+  /**
+   * Visit `node`.
+   *
+   * @param {Node} node
+   * @api public
+   */
+
+  visitNode: function(node) {
+    return this['visit' + node.type](node);
+  },
+
+  /**
+   * Visit case `node`.
+   *
+   * @param {Literal} node
+   * @api public
+   */
+
+  visitCase: function(node) {
+    throw new Error('Case statements are not supported in puglite. Use your framework for logic.');
+  },
+
+  /**
+   * Visit when `node`.
+   *
+   * @param {Literal} node
+   * @api public
+   */
+
+  visitWhen: function(node) {
+    throw new Error('Case/when statements are not supported in puglite. Use your framework for logic.');
+  },
+
+  /**
+   * Visit literal `node`.
+   *
+   * @param {Literal} node
+   * @api public
+   */
+
+  visitLiteral: function(node) {
+    this.buffer(node.str);
+  },
+
+  visitNamedBlock: function(block) {
+    return this.visitBlock(block);
+  },
+  /**
+   * Visit all nodes in `block`.
+   *
+   * @param {Block} block
+   * @api public
+   */
+
+  visitBlock: function(block) {
+    var escapePrettyMode = this.escapePrettyMode;
+    var pp = this.pp;
+
+    // Pretty print multi-line text
+    if (
+      pp &&
+      block.nodes.length > 1 &&
+      !escapePrettyMode &&
+      block.nodes[0].type === 'Text' &&
+      block.nodes[1].type === 'Text'
+    ) {
+      this.prettyIndent(1, true);
+    }
+    for (var i = 0; i < block.nodes.length; ++i) {
+      // Pretty print text
+      if (
+        pp &&
+        i > 0 &&
+        !escapePrettyMode &&
+        block.nodes[i].type === 'Text' &&
+        block.nodes[i - 1].type === 'Text' &&
+        /\n$/.test(block.nodes[i - 1].val)
+      ) {
+        this.prettyIndent(1, false);
+      }
+      this.visit(block.nodes[i], block);
+    }
+  },
+
+  /**
+   * Visit a mixin's `block` keyword.
+   *
+   * @param {MixinBlock} block
+   * @api public
+   */
+
+  visitMixinBlock: function(block) {
+    throw new Error('Mixins are not supported in puglite. Please remove mixin usage.');
+  },
+
+  /**
+   * Visit `doctype`. Sets terse mode to `true` when html 5
+   * is used, causing self-closing tags to end with ">" vs "/>",
+   * and boolean attributes are not mirrored.
+   *
+   * @param {Doctype} doctype
+   * @api public
+   */
+
+  visitDoctype: function(doctype) {
+    if (doctype && (doctype.val || !this.doctype)) {
+      this.setDoctype(doctype.val || 'html');
+    }
+
+    if (this.doctype) this.buffer(this.doctype);
+    this.hasCompiledDoctype = true;
+  },
+
+  /**
+   * Visit `mixin`, generating a function that
+   * may be called within the template.
+   *
+   * @param {Mixin} mixin
+   * @api public
+   */
+
+  visitMixin: function(mixin) {
+    throw new Error('Mixins are not supported in puglite. Please remove mixin usage.');
+  },
+
+  /**
+   * Visit `tag` buffering tag markup, generating
+   * attributes, visiting the `tag`'s code and block.
+   *
+   * @param {Tag} tag
+   * @param {boolean} interpolated
+   * @api public
+   */
+
+  visitTag: function(tag, interpolated) {
+    this.indents++;
+    var name = tag.name,
+      pp = this.pp,
+      self = this;
+
+    function bufferName() {
+      if (interpolated) self.bufferExpression(tag.expr);
+      else self.buffer(name);
+    }
+
+    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true)
+      this.escapePrettyMode = true;
+
+    if (!this.hasCompiledTag) {
+      if (!this.hasCompiledDoctype && 'html' == name) {
+        this.visitDoctype();
+      }
+      this.hasCompiledTag = true;
+    }
+
+    // pretty print
+    if (pp && !tag.isInline) this.prettyIndent(0, true);
+    if (tag.selfClosing || (!this.xml && selfClosing[tag.name])) {
+      this.buffer('<');
+      bufferName();
+      this.visitAttributes(
+        tag.attrs,
+        this.attributeBlocks(tag.attributeBlocks)
+      );
+      if (this.terse && !tag.selfClosing) {
+        this.buffer('>');
+      } else {
+        this.buffer('/>');
+      }
+      // if it is non-empty throw an error
+      if (
+        tag.code ||
+        (tag.block &&
+          !(tag.block.type === 'Block' && tag.block.nodes.length === 0) &&
+          tag.block.nodes.some(function(tag) {
+            return tag.type !== 'Text' || !/^\s*$/.test(tag.val);
+          }))
+      ) {
+        this.error(
+          name +
+            ' is a self closing element: <' +
+            name +
+            '/> but contains nested content.',
+          'SELF_CLOSING_CONTENT',
+          tag
+        );
+      }
+    } else {
+      // Optimize attributes buffering
+      this.buffer('<');
+      bufferName();
+      this.visitAttributes(
+        tag.attrs,
+        this.attributeBlocks(tag.attributeBlocks)
+      );
+      this.buffer('>');
+      if (tag.code) this.visitCode(tag.code);
+      this.visit(tag.block, tag);
+
+      // pretty print
+      if (
+        pp &&
+        !tag.isInline &&
+        WHITE_SPACE_SENSITIVE_TAGS[tag.name] !== true &&
+        !tagCanInline(tag)
+      )
+        this.prettyIndent(0, true);
+
+      this.buffer('</');
+      bufferName();
+      this.buffer('>');
+    }
+
+    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true)
+      this.escapePrettyMode = false;
+
+    this.indents--;
+  },
+
+  /**
+   * Visit InterpolatedTag.
+   *
+   * @param {InterpolatedTag} tag
+   * @api public
+   */
+
+  visitInterpolatedTag: function(tag) {
+    throw new Error('Interpolation (#{var}) is not supported in puglite. Use your framework for data binding.');
+  },
+
+  /**
+   * Visit `text` node.
+   *
+   * @param {Text} text
+   * @api public
+   */
+
+  visitText: function(text) {
+    this.buffer(text.val);
+  },
+
+  /**
+   * Visit a `comment`, only buffering when the buffer flag is set.
+   *
+   * @param {Comment} comment
+   * @api public
+   */
+
+  visitComment: function(comment) {
+    if (!comment.buffer) return;
+    if (this.pp) this.prettyIndent(1, true);
+    this.buffer('<!--' + comment.val + '-->');
+  },
+
+  /**
+   * Visit a `YieldBlock`.
+   *
+   * This is necessary since we allow compiling a file with `yield`.
+   *
+   * @param {YieldBlock} block
+   * @api public
+   */
+
+  visitYieldBlock: function(block) {},
+
+  /**
+   * Visit a `BlockComment`.
+   *
+   * @param {Comment} comment
+   * @api public
+   */
+
+  visitBlockComment: function(comment) {
+    if (!comment.buffer) return;
+    if (this.pp) this.prettyIndent(1, true);
+    this.buffer('<!--' + (comment.val || ''));
+    this.visit(comment.block, comment);
+    if (this.pp) this.prettyIndent(1, true);
+    this.buffer('-->');
+  },
+
+  /**
+   * Visit `code`, respecting buffer / escape flags.
+   * If the code is followed by a block, wrap it in
+   * a self-calling function.
+   *
+   * @param {Code} code
+   * @api public
+   */
+
+  visitCode: function(code) {
+    throw new Error('Code blocks (= and -) are not supported in puglite. Use your framework for logic and data binding.');
+  },
+
+  /**
+   * Visit `Conditional`.
+   *
+   * @param {Conditional} cond
+   * @api public
+   */
+
+  visitConditional: function(cond) {
+    throw new Error('Conditionals (if/else/unless) are not supported in puglite. Use your framework for logic.');
+  },
+
+  /**
+   * Visit `While`.
+   *
+   * @param {While} loop
+   * @api public
+   */
+
+  visitWhile: function(loop) {
+    throw new Error('While loops are not supported in puglite. Use your framework for logic.');
+  },
+
+  /**
+   * Visit `each` block.
+   *
+   * @param {Each} each
+   * @api public
+   */
+
+  visitEach: function(each) {
+    throw new Error('Each loops are not supported in puglite. Use your framework for iteration.');
+  },
+
+  visitEachOf: function(each) {
+    throw new Error('Each loops are not supported in puglite. Use your framework for iteration.');
+  },
+
+  /**
+   * Visit `attrs`.
+   *
+   * @param {Array} attrs
+   * @api public
+   */
+
+  visitAttributes: function(attrs, attributeBlocks) {
+    if (attributeBlocks.length) {
+      if (attrs.length) {
+        var val = this.attrs(attrs);
+        attributeBlocks.unshift(val);
+      }
+      if (attributeBlocks.length > 1) {
+        this.bufferExpression(
+          this.runtime('attrs') +
+            '(' +
+            this.runtime('merge') +
+            '([' +
+            attributeBlocks.join(',') +
+            ']), ' +
+            stringify(this.terse) +
+            ')'
+        );
+      } else {
+        this.bufferExpression(
+          this.runtime('attrs') +
+            '(' +
+            attributeBlocks[0] +
+            ', ' +
+            stringify(this.terse) +
+            ')'
+        );
+      }
+    } else if (attrs.length) {
+      this.attrs(attrs, true);
+    }
+  },
+
+  /**
+   * Compile attributes.
+   */
+
+  attrs: function(attrs, buffer) {
+    var res = compileAttrs(attrs, {
+      terse: this.terse,
+      format: buffer ? 'html' : 'object',
+      runtime: this.runtime.bind(this),
+    });
+    if (buffer) {
+      this.bufferExpression(res);
+    }
+    return res;
+  },
+
+  /**
+   * Compile attribute blocks.
+   */
+
+  attributeBlocks: function(attributeBlocks) {
+    return (
+      attributeBlocks &&
+      attributeBlocks.slice().map(function(attrBlock) {
+        return attrBlock.val;
+      })
+    );
+  },
+};
+
+function tagCanInline(tag) {
+  function isInline(node) {
+    // Recurse if the node is a block
+    if (node.type === 'Block') return node.nodes.every(isInline);
+    // When there is a YieldBlock here, it is an indication that the file is
+    // expected to be included but is not. If this is the case, the block
+    // must be empty.
+    if (node.type === 'YieldBlock') return true;
+    return (node.type === 'Text' && !/\n/.test(node.val)) || node.isInline;
+  }
+
+  return tag.block.nodes.every(isInline);
+}