Code coverage report for 6to5/transform.js

Statements: 100% (70 / 70)      Branches: 97.06% (33 / 34)      Functions: 100% (11 / 11)      Lines: 100% (65 / 65)      Ignored: none     

All files » 6to5/ » transform.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 1391 1 1 1 1   1 244 3 1         1 122 122   122               122         122 122   121 120       1 120   120 1962 1962   1961 1961   1945     113   113 1     113 113   113     1 1945 3890 105849 105849   4622 4622 4622   2376       1945           1 122 122 122   122   122   122 113 113   113 113 113 113   113   113 1     113 2   2 2 2 2         1                                      
var sourceMap = require("source-map");
var traverse  = require("./traverse");
var recast    = require("recast");
var util      = require("./util");
var _         = require("lodash");
 
var ensureTransformerNames = function (type, keys) {
  _.each(keys, function (key) {
    if (!transform.transformers[key]) {
      throw new ReferenceError("unknown transformer " + key + " specified in " + type);
    }
  });
};
 
var transform = module.exports = function (code, opts) {
  opts = opts || {};
  code = (code || "") + "";
 
  _.defaults(opts, {
    blacklist: [],
    whitelist: [],
    sourceMap: false,
    filename:  "unknown",
    format:    {}
  });
 
  _.defaults(opts, {
    sourceFileName: opts.filename,
    sourceMapName:  opts.filename
  });
 
  ensureTransformerNames("blacklist", opts.blacklist);
  ensureTransformerNames("whitelist", opts.whitelist);
 
  return util.parse(opts, code, function (tree) {
    return transform._run(code, tree, opts);
  });
};
 
transform._run = function (code, tree, opts) {
  var generateUid = util.buildUidGenerator();
 
  _.each(transform.transformers, function (transformer, name) {
    var blacklist = opts.blacklist;
    if (blacklist.length && _.contains(blacklist, name)) return;
 
    var whitelist = opts.whitelist;
    if (whitelist.length && !_.contains(whitelist, name)) return;
 
    transform._runTransformer(transformer, tree, opts, generateUid);
  });
 
  var result = util.generate(tree, opts);
 
  if (opts.sourceMap === "inline") {
    result.code += "\n" + util.sourceMapToComment(result.map);
  }
 
  result.map = result.map || null;
  result.ast = tree;
 
  return result;
};
 
transform._runTransformer = function (transformer, tree, opts, generateUid) {
  var build = function (exit) {
    return function (node, parent) {
      var fns = transformer[node.type] || transformer.all;
      if (!fns) return;
 
      var fn = fns.enter || fns;
      if (exit) fn = fns.exit;
      if (!fn || !_.isFunction(fn)) return;
 
      return fn(node, parent, opts, generateUid);
    };
  };
 
  traverse(tree, {
    enter: build(),
    exit:  build(true)
  });
};
 
transform.test = function (task, assert) {
  var actual = task.actual;
  var expect = task.expect;
  var opts   = task.options;
 
  opts.filename = actual.filename;
 
  var actualCode = actual.code.trim();
 
  var actualResult = transform(actualCode, opts);
  var actualAst    = actualResult.ast;
  actualCode       = recast.prettyPrint(actualAst).code;
 
  var expectCode   = expect.code.trim();
  var expectAst    = util.parse(expect, expectCode);
  var expectResult = recast.prettyPrint(expectAst);
  expectCode       = expectResult.code;
 
  assert.equal(actualCode, expectCode);
 
  if (task.sourceMap) {
    assert.deepEqual(task.sourceMap, actualResult.map);
  }
 
  if (task.sourceMappings) {
    var consumer = new sourceMap.SourceMapConsumer(actualResult.map);
 
    _.each(task.sourceMappings, function (mapping, i) {
      var pos = consumer.originalPositionFor(mapping.generated);
      var msg = "source mapping " + ++i + " - generated: " + mapping.generated.line + ":" + mapping.generated.column;
      assert.equal(pos.line + ":" + pos.column, mapping.original.line + ":" + mapping.original.column, msg);
    });
  }
};
 
transform.transformers = {
  modules:                  require("./transformers/modules"),
  computedPropertyNames:    require("./transformers/computed-property-names"),
  propertyNameShorthand:    require("./transformers/property-name-shorthand"),
  constants:                require("./transformers/constants"),
  arrayComprehension:       require("./transformers/array-comprehension"),
  arrowFunctions:           require("./transformers/arrow-functions"),
  classes:                  require("./transformers/classes"),
  spread:                   require("./transformers/spread"),
  templateLiterals:         require("./transformers/template-literals"),
  propertyMethodAssignment: require("./transformers/property-method-assignment"),
  defaultParameters:        require("./transformers/default-parameters"),
  generators:               require("./transformers/generators"),
  blockBinding:             require("./transformers/block-binding"),
  restParameters:           require("./transformers/rest-parameters"),
  destructuring:            require("./transformers/destructuring"),
  forOf:                    require("./transformers/for-of"),
  unicodeRegex:             require("./transformers/unicode-regex")
};