Code coverage report for 6to5/transform.js

Statements: 87.27% (48 / 55)      Branches: 71.43% (20 / 28)      Functions: 100% (8 / 8)      Lines: 86.27% (44 / 51)      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 1131 1 1 1 1   1 102 102   102               102 101       1 101 1202         101   101 1629 1629   1628 1628   1612     94         94           94   94             94       1 1612   1609 29792 29792   1077       1 102 102   102 102 94 94   94 94 94   94     1                                      
var traverse = require("./traverse");
var assert   = require("assert");
var path     = require("path");
var util     = require("./util");
var _        = require("lodash");
 
var transform = module.exports = function (code, opts) {
  opts = opts || {};
  code = (code || "") + "";
 
  _.defaults(opts, {
    blacklist: [],
    whitelist: [],
    sourceMap: false,
    filename:  "unknown",
    format:    {}
  });
 
  return util.parse(opts.filename, code, function (tree) {
    return transform._run(code, tree, opts);
  });
};
 
transform._run = function (code, tree, opts) {
  traverse.replace(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 genOpts = {
    file: path.basename(opts.filename),
    format: opts.format
  };
 
  Iif (opts.sourceMap) {
    genOpts.sourceMap = genOpts.file;
    genOpts.sourceContent = code;
    genOpts.sourceMapWithCode = true;
  }
 
  var result = util.generate(tree, genOpts);
 
  Iif (opts.sourceMap) {
    if (opts.sourceMap === "inline") {
      result.code += "\n" + util.sourceMapToComment(result.map);
    }
 
    return result;
  } else {
    return { code: result, map: null };
  }
};
 
transform._runTransformer = function (transformer, tree, opts, generateUid) {
  if (transformer.Program) transformer.Program(tree, opts);
 
  traverse.replace(tree, function (node, parent) {
    var fn = transformer[node.type] || transformer.all;
    if (!fn) return;
 
    return fn(node, parent, opts, generateUid);
  });
};
 
transform.test = function (actual, expect, opts) {
  opts = opts || {};
  _.defaults(opts, { filename: "test" });
 
  var actualCode = actual.code.trim();
  var transformedCode = transform(actualCode, opts).code;
  var actualAst = util.parse(actual.filename, transformedCode);
  actualCode = util.generate(actualAst);
 
  var expectCode = expect.code.trim();
  var expectAst = util.parse(expect.filename, expectCode);
  expectCode = util.generate(expectAst);
 
  assert.equal(actualCode, expectCode);
};
 
transform.transformers = {
  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"),
  destructuring:            require("./transformers/destructuring"),
  generators:               require("./transformers/generators"),
  blockBinding:             require("./transformers/block-binding"),
  modules:                  require("./transformers/modules"),
  restParameters:           require("./transformers/rest-parameters"),
  forOf:                    require("./transformers/for-of"),
  unicodeRegex:             require("./transformers/unicode-regex")
};