4chan-XZ/tools/template.js

/* jshint evil: true */
var fs = require('fs');
var path = require('path');
var _template = require('lodash.template');
var esprima = require('esprima');

// disable ES6 delimiters
var _templateSettings = { interpolate: /<%=([\s\S]+?)%>/g };

// Functions used in templates.
var tools = {};

var read = (tools.read = filename =>
  fs.readFileSync(filename, 'utf8').replace(/\r\n/g, '\n'));
var readJSON = (tools.readJSON = filename => JSON.parse(read(filename)));
tools.readBase64 = filename => fs.readFileSync(filename).toString('base64');

tools.readHTML = function (filename) {
  var text = read(filename).replace(/^ +/gm, '').replace(/\r?\n/g, '');
  text = _template(text, _templateSettings)(pkg); // package.json data only; no recursive imports
  return tools.html(text);
};

tools.multiline = function (text) {
  return text
    .replace(/\n+/g, '\n')
    .split(/^/m)
    .map(JSON.stringify)
    .join('+')
    .replace(/"\+"/g, '\\\n');
};

// Convert JSONify-able object to Javascript expression.
var constExpression = data => JSON.stringify(data).replace(/`/g, '\\`');

function TextStream(text) {
  this.text = text;
}

TextStream.prototype.eat = function (regexp) {
  var match = regexp.exec(this.text);
  if (match && match.index === 0) {
    this.text = this.text.slice(match[0].length);
  }
  return match;
};

function parseHTMLTemplate(stream, context) {
  var template = stream.text; // text from beginning, for error messages
  var expression = new HTMLExpression(context);
  var match;

  try {
    while (stream.text) {
      // Literal HTML
      if (
        (match = stream.eat(
          // characters not indicating start or end of placeholder, using backslash as escape
          /^(?:[^\\{}]|\\.)+(?!{)/
        ))
      ) {
        var unescaped = match[0].replace(/\\(.)/g, '$1');
        expression.addLiteral(unescaped);

        // Placeholder
      } else if (
        (match = stream.eat(
          // symbol identifying placeholder type and first argument (enclosed by {})
          // backtick not allowed in arguments as it can end embedded JS in Coffeescript
          /^([^}]){([^}`]*)}/
        ))
      ) {
        var type = match[1];
        var args = [match[2]];
        if (type === '?') {
          // conditional expression can take up to two subtemplate arguments
          for (var i = 0; i < 2 && stream.eat(/^{/); i++) {
            var subtemplate = parseHTMLTemplate(stream, context);
            args.push(subtemplate);
            if (!stream.eat(/^}/)) {
              throw new Error(
                `Unexpected characters in subtemplate (${stream.text})`
              );
            }
          }
        }
        expression.addPlaceholder(new Placeholder(type, args));

        // No match: end of subtemplate (} next) or error
      } else {
        break;
      }
    }

    return expression.build();
  } catch (err) {
    throw new Error(`${err.message}: ${template}`);
  }
}

function HTMLExpression(context) {
  this.parts = [];
  this.startContext = this.endContext = context || '';
}

HTMLExpression.prototype.addLiteral = function (text) {
  this.parts.push(constExpression(text));
  this.endContext = this.endContext
    .replace(/(=['"])[^'"<>]*/g, '$1') // remove values from quoted attributes (no '"<> allowed)
    .replace(/(<\w+)( [\w-]+((?=[ >])|=''|=""))*/g, '$1') // remove attributes from tags
    .replace(/^([^'"<>]+|<\/?\w+>)*/, ''); // remove text (no '"<> allowed) and tags
};

HTMLExpression.prototype.addPlaceholder = function (placeholder) {
  if (!placeholder.allowed(this.endContext)) {
    throw new Error(
      `Illegal insertion of placeholder (type ${placeholder.type}) into HTML template (at ${this.endContext})`
    );
  }
  this.parts.push(placeholder.build());
};

HTMLExpression.prototype.build = function () {
  if (this.startContext !== this.endContext) {
    throw new Error(`HTML template is ill-formed (at ${this.endContext})`);
  }
  return this.parts.length === 0 ? '""' : this.parts.join(' + ');
};

function Placeholder(type, args) {
  this.type = type;
  this.args = args;
}

Placeholder.prototype.allowed = function (context) {
  switch (this.type) {
    case '$':
      // escaped text allowed outside tags or in quoted attributes
      return context === '' || /\=['"]$/.test(context);
    case '&':
    case '@':
      // contents of one/many HTML element or template allowed outside tags only
      return context === '';
    case '?':
      // conditionals allowed anywhere so long as their contents don't change context (checked by HTMLExpression.prototype.build)
      return true;
  }
  throw new Error(`Unrecognized placeholder type (${this.type})`);
};

Placeholder.prototype.build = function () {
  // first argument is always JS expression; validate it so we don't accidentally break out of placeholders
  var expr = this.args[0];
  var ast;
  try {
    ast = esprima.parse(expr);
  } catch (err) {
    throw new Error(`Invalid JavaScript in template (${expr})`);
  }
  if (
    !(
      ast.type === 'Program' &&
      ast.body.length == 1 &&
      ast.body[0].type === 'ExpressionStatement'
    )
  ) {
    throw new Error(`JavaScript in template is not an expression (${expr})`);
  }
  switch (this.type) {
    case '$':
      return `E(${expr})`; // $ : escaped text
    case '&':
      return `(${expr}).innerHTML`; // & : contents of HTML element or template (of form {innerHTML: "safeHTML"})
    case '@':
      return `E.cat(${expr})`; // @ : contents of array of HTML elements or templates (see src/General/Globals.coffee for E.cat)
    case '?':
      return `((${expr}) ? ${this.args[1] || '""'} : ${this.args[2] || '""'})`; // ? : conditional expression
  }
  throw new Error(`Unrecognized placeholder type (${this.type})`);
};

// HTML template generator with placeholders of forms ${}, &{}, @{}, and ?{}{}{} (see Placeholder.prototype.build)
// that checks safety of generated expressions at compile time.
tools.html = function (template) {
  var stream = new TextStream(template);
  var output = parseHTMLTemplate(stream);
  if (stream.text) {
    throw new Error(
      `Unexpected characters in template (${stream.text}): ${template}`
    );
  }
  return `{innerHTML: ${output}}`;
};

function includesDir(templateName) {
  var dir = path.dirname(templateName);
  var subdir = path.basename(templateName).replace(/\.[^.]+$/, '');
  if (fs.readdirSync(dir).indexOf(subdir) >= 0) {
    return path.join(dir, subdir);
  } else {
    return dir;
  }
}

function resolvePath(includeName, templateName) {
  var dir;
  if (includeName[0] === '/') {
    dir = process.cwd();
  } else {
    dir = includesDir(templateName);
  }
  return path.join(dir, includeName);
}

function wrapTool(tool, templateName) {
  return function (includeName) {
    return tool(resolvePath(includeName, templateName));
  };
}

function loadModules(templateName) {
  var dir = includesDir(templateName);
  var moduleNames = fs.readdirSync(dir).filter(f => /\.inc$/.test(f));
  var modules = {};
  for (var name of moduleNames) {
    var code = read(path.join(dir, name));
    modules[name.replace(/\.inc$/, '')] = new Function(code)();
  }
  return modules;
}

// Import variables from package.json.
var pkg = readJSON('package.json');

function interpolate(text, data, filename) {
  var context = {},
    key;
  for (key in tools) {
    context[key] = /^read/.test(key)
      ? wrapTool(tools[key], filename)
      : tools[key];
  }
  for (key in pkg) {
    context[key] = pkg[key];
  }
  if (data) {
    for (key in data) {
      context[key] = data[key];
    }
  }
  context.files = fs.readdirSync(includesDir(filename));
  context.require = loadModules(filename);
  return _template(text, _templateSettings)(context);
}

module.exports = interpolate;

if (require.main === module) {
  (function () {
    // Take variables from command line.
    var data = {};
    for (var i = 4; i < process.argv.length; i++) {
      var m = process.argv[i].match(/(.*?)=(.*)/);
      data[m[1]] = m[2];
    }

    var text = read(process.argv[2]);
    text = interpolate(text, data, process.argv[2]);
    fs.writeFileSync(process.argv[3], text);
  })();
}