@aofl/aofljs-cli/src/translate/impeller.js

/**
 * @file Module to replace translatable strings in HTML and JS files with
 *       translated strings. Adapted from angular-gettext-tools/extract.js.
 *
 * @version 0.1
 * @since 0.1
 * @author Sergey Popov <sergey.popov@aofl.com>
 * @module lib/translate/impeller
 */

'use strict';

var cheerio = require('cheerio');
var espree = require('espree');
var _ = require('lodash');

var escapeRegex = /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g;

function mkAttrRegex(startDelim, endDelim) {
  var start = startDelim.replace(escapeRegex, '\\$&');
  var end = endDelim.replace(escapeRegex, '\\$&');

  if (start === '' && end === '') {
    start = '^';
  } else {
    // match optional :: (Angular 1.3's bind once syntax) without capturing
    start += '(?:\\s*\\:\\:\\s*)?';
  }

  return new RegExp(start +
    '\\s*(\'|"|&quot;|&#39;)(.*?)\\1\\s*\\|\\s*translate\\s*(' +
    end + '|\\|)', 'g');
}

var noDelimRegex = mkAttrRegex('', '');

function walkJs(node, fn, parentComment) {
  fn(node, parentComment);
  for (var key in node) {
    if (node.hasOwnProperty(key)) {
      var obj = node[key];
      if (node && node.leadingComments) {
        parentComment = node;
      }
      if (typeof obj === 'object') {
        walkJs(obj, fn, parentComment);
      }
    }
  }
}

function getJSExpression(node) {
  var res = '';
  if (node.type === 'Literal') {
    res = node.value;
  }
  return res;
}

function getJSExpressionString(node) {
  var res = '';
  if (node.type === 'Literal') {
    res = node.raw;
  }
  return res;
}

var Impeller = (function () {
  function Impeller(options) {
    this.options = _.extend({
      startDelim: '{{',
      endDelim: '}}',
      markerName: 'gettext',
      markerNames: [],
      attribute: 'translate',
      attributes: [],
      lineNumbers: true,
      extensions: {
        htm: 'html',
        html: 'html',
        php: 'html',
        phtml: 'html',
        tml: 'html',
        ejs: 'html',
        erb: 'html',
        js: 'js'
      },
      postProcess: function () {}
    }, options);
    this.options.markerNames.unshift(this.options.markerName);
    this.options.attributes.unshift(this.options.attribute);

    this.strings = {};
    this.attrRegex = mkAttrRegex(this.options.startDelim,
      this.options.endDelim);
  }

  Impeller.isValidStrategy = function (strategy) {
    return strategy === 'html' || strategy === 'js';
  };

  Impeller.mkAttrRegex = mkAttrRegex;

  /**
   * Replaces an original string with a translated one.
   *
   * @param {String} origString  The phrase to be replaced
   * @param {String} origNode    The original node text; contains origString.
   *                             In HTML, this is a tag.
   *                             In JS, it's a string literal.
   * @param {Object} jsonData    Dictionary for searching
   * @param {String} context     The third argument of gettext as a key to
   *                             choose which translation of the first argument
   *                             to use for replacement
   */
  Impeller.prototype.translateReplace = function (origString, origNode,
      jsonData, context, jsFuncName) {
    origString = origString.trim();

    if (typeof jsonData[origString] !== 'undefined') {
      var newString = '';
      if (context && typeof jsonData[origString] === 'object' &&
          typeof jsonData[origString][context] !== 'undefined') {
        newString = jsonData[origString][context];
      } else {
        newString = jsonData[origString];
      }
      var newNode = origNode.replace(origString, newString);
      var origRegex;
      if (jsFuncName) {
        var escapedNode = origNode.replace(/([\^\$\.\|\?\*\+\(\)\[\{])/g, '\\$1');
        origRegex = new RegExp(jsFuncName + ' *\\( *' + escapedNode + ' *\\)');
        this.newSrc = this.newSrc.replace(origRegex, function () {
          return jsFuncName + '(' + newNode + ')';
        });
      } else {
        this.newSrc = this.newSrc.replace(origNode, newNode);
      }
      this.replaceCount++;
    }
  };

  Impeller.prototype.translateTextNode = function (node, jsonData, context) {
    var trimmedOriginal = node.data.trim();
    var translation = jsonData[trimmedOriginal];
    if (typeof translation !== 'undefined') {
      var translatedString = '';
      if (context && _typeof(translation) === 'object' &&
        typeof translation[context] !== 'undefined') {
        translatedString = translation[context];
      } else {
        translatedString = translation;
      }
      node.data = node.data.replace(trimmedOriginal, translatedString);
      this.replaceCount++;
    }
  };

  Impeller.prototype.translateInnerHTML = function (node, jsonData, context) {
    var _this = this;
    var trimmedHTML = node.html().trim();
    var translation = jsonData[trimmedHTML];
    if (typeof translation !== 'undefined') {
      var translatedString = '';
      if (context && _typeof(translation) === 'object' &&
        typeof translation[context] !== 'undefined') {
        translatedString = translation[context];
      } else {
        translatedString = translation;
      }
      node.html(node.html().replace(trimmedHTML, translatedString));
      this.replaceCount++;
    }
  };

  Impeller.prototype.replaceHtml = function (filename, src, jsonData) {
    var replaceHtml = function (src) {
      var $ = cheerio.load(src, {
        decodeEntities: false,
        withStartIndices: true
      });
      var _this = this;
      var matches;
      var newlines = function (index) {
        return src.substr(0, index).match(/\n/g) || [];
      };

      $('*').each(function (index, n) {
        var node = $(n);
        var getAttr = function (attr) {
          return node.attr(attr) || node.data(attr);
        };
        var str = node.html();
        var extracted = {};
        var possibleAttributes = _this.options.attributes;

        possibleAttributes.forEach(function (attr) {
          extracted[attr] = {
            plural: getAttr(attr + '-plural'),
            extractedComment: getAttr(attr + '-comment'),
            context: getAttr(attr + '-context')
          };
        });

        if (n.name === 'script') {
          if (n.attribs.type === 'text/ng-template') {
            replaceHtml(node.text(), newlines(n.startIndex).length);
            return;
          }

          // In HTML5, type defaults to text/javascript.
          // In HTML4, it's required, so if it's not there, just assume it's JS
          if (!n.attribs.type || n.attribs.type === 'text/javascript') {
            _this.replaceJs(filename, node.text(), jsonData,
              newlines(n.startIndex).length);
            return;
          }
        }

        if (node.is('translate')) {
          _this.translateInnerHTML(node, jsonData);
          return;
        }


        var attrs = node.attr();
        for (var attr in attrs) {
          if (attrs.hasOwnProperty(attr)) {
            attr = attr.replace(/^data-/, '');
            if (possibleAttributes.indexOf(attr) > -1) {
              var attrValue = extracted[attr];
              // TODO: support plurals, comments
              _this.translateInnerHTML(node, jsonData,
                attrValue.context);
            } else if (matches = noDelimRegex.exec(node.attr(attr))) {
              str = matches[2].replace(/\\\'/g, '\'');
              noDelimRegex.lastIndex = 0;
            }
          }
        }
      });

      _this.newSrc = $.html();

      while (matches = this.attrRegex.exec(src)) {
        var str = matches[2].replace(/\\\'/g, '\'');
        _this.translateReplace(str, matches[0], jsonData);
      }
    }.bind(this);

    replaceHtml(src, 0);
  };

  Impeller.prototype.replaceJs =
  function (filename, src, jsonData, lineNumber) {
    // used for line number of JS in HTML <script> tags
    lineNumber = lineNumber || 0;
    var _this = this;
    var syntax;
    try {
      syntax = espree.parse(src, {
        tolerant: true,
        range: true,
        attachComment: true,
        loc: true,
        token: true,
        ecmaFeatures: {
          arrowFunctions: true,
          blockBindings: true,
          destructuring: true,
          regexYFlag: true,
          regexUFlag: true,
          templateStrings: true,
          binaryLiterals: true,
          octalLiterals: true,
          unicodeCodePointEscapes: true,
          defaultParams: true,
          restParams: true,
          forOf: true,
          objectLiteralComputedProperties: true,
          objectLiteralShorthandMethods: true,
          objectLiteralShorthandProperties: true,
          objectLiteralDuplicateProperties: true,
          generators: true,
          spread: true,
          classes: true,
          modules: true,
          jsx: true,
          globalReturn: true
        }
      });
    } catch (err) {
      console.log("Error of parsing js file: ", filename);
      return;
    }

    _this.newSrc = src;

    function isGettext(node) {
      return node !== null &&
        node.type === 'CallExpression' &&
        node.callee !== null &&
        (_this.options.markerNames.indexOf(node.callee.name) > -1 || (
          node.callee.property &&
          _this.options.markerNames.indexOf(node.callee.property.name) > -1
        )) &&
        node.arguments !== null &&
        node.arguments.length;
    }

    function isGetString(node) {
      return node !== null &&
        node.type === 'CallExpression' &&
        node.callee !== null &&
        node.callee.type === 'MemberExpression' &&
        node.callee.object !== null && (
          node.callee.object.name === 'gettextCatalog' || (
            // also allow gettextCatalog calls on objects like
            // this.gettextCatalog.getString()
            node.callee.object.property &&
            node.callee.object.property.name === 'gettextCatalog')) &&
        node.callee.property !== null &&
        node.callee.property.name === 'getString' &&
        node.arguments !== null &&
        node.arguments.length;
    }

    walkJs(syntax, function (node) {
      var phrase, nodeStr, context;
      if (isGettext(node) || isGetString(node)) {
        phrase = getJSExpression(node.arguments[0]);
        nodeStr = getJSExpressionString(node.arguments[0]);

        if (node.arguments[2]) {
          context = getJSExpression(node.arguments[2]);
        }
        _this.translateReplace(phrase, nodeStr, jsonData, context);
      }
    });
  };

  Impeller.prototype.isSupportedByStrategy = function (strategy, extension) {
    return (extension in this.options.extensions) &&
      (this.options.extensions[extension] === strategy);
  };

  Impeller.prototype.processFile = function (filename, content, jsonData) {
    var extension = filename.split('.').pop();
    delete this.newSrc;
    this.replaceCount = 0;
    if (this.isSupportedByStrategy('html', extension)) {
      this.replaceHtml(filename, content, jsonData);
    }
    if (this.isSupportedByStrategy('js', extension)) {
      this.replaceJs(filename, content, jsonData);
    }
    return this.replaceCount;
  };

  Impeller.prototype.toString = function () {
    return this.newSrc
      .replace(/ translate\=""/g, ' translate');
  };

  return Impeller;
})();

module.exports = Impeller;