Code coverage report for 6to5/transform.js

Statements: 94.52% (69 / 73)      Branches: 83.33% (30 / 36)      Functions: 100% (12 / 12)      Lines: 94.12% (64 / 68)      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 141 142 1431 1 1 1 1   1 224 2           1 112 112   112                 112 112   112 111       1 111 1791         111   111 1826 1826   1825 1825   1809     106   106       106   106 106         106     1 1809 3618 87427 87427   3838 3838 3838   1984       1809           1 112 112 112   112 112   112   112 106 106   106 106 106 106   106   106 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:    {},
    ast:       false
  });
 
  ensureTransformerNames("blacklist", opts.blacklist);
  ensureTransformerNames("whitelist", opts.whitelist);
 
  return util.parse(opts.filename, 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;
 
  Eif (opts.ast) {
    result.ast = tree;
  } else {
    result.ast = null;
  }
 
  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;
  opts.ast      = true;
 
  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.filename, 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")
};