Code coverage report for 6to5/transform.js

Statements: 95.77% (68 / 71)      Branches: 85.29% (29 / 34)      Functions: 100% (12 / 12)      Lines: 95.45% (63 / 66)      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 139 140 1411 1 1 1 1   1 228 2           1 114 114   114               114         114 114   114 113       1 113 1956         113   113 1860 1860   1859 1859   1843     108   108       108 108   108     1 1843 3686 99501 99501   4329 4329 4329   2225       1843           1 114 114 114   114   114   114 108 108   108 108 108 108   108   108 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) {
    Iif (!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) {
  traverse(tree, function (node) {
    Iif (node.type === "EmptyStatement") {
      return traverse.Delete;
    }
  });
 
  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);
 
  Iif (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.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")
};