Code coverage report for 6to5/lib/6to5/transformation/transformer.js

Statements: 98.48% (65 / 66)      Branches: 97.5% (39 / 40)      Functions: 100% (9 / 9)      Lines: 98.21% (55 / 56)      Ignored: none     

All files » 6to5/lib/6to5/transformation/ » transformer.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 991   1 1 1   1 40 40 40 40 40 40 40     1 40   40       40   103 4 4     99   99   86   86 86 6 20         40     1 46963   46963 1509       1 11710   11710 23420 1058001 1058001   42242 42242 42242   21527       11710   11710         11692     1 16379 16379 16379   14779 14779   14752 14752   14716   12339   10514    
module.exports = Transformer;
 
var traverse = require("../traverse");
var t        = require("../types");
var _        = require("lodash");
 
function Transformer(key, transformer, opts) {
  this.manipulateOptions = transformer.manipulateOptions;
  this.experimental      = !!transformer.experimental;
  this.secondPass        = !!transformer.secondPass;
  this.transformer       = this.normalise(transformer);
  this.optional          = !!transformer.optional;
  this.opts              = opts || {};
  this.key               = key;
}
 
Transformer.prototype.normalise = function (transformer) {
  var self = this;
 
  Iif (_.isFunction(transformer)) {
    transformer = { ast: transformer };
  }
 
  _.each(transformer, function (fns, type) {
    // hidden property
    if (type[0] === "_") {
      self[type] = fns;
      return;
    }
 
    if (_.isFunction(fns)) fns = { enter: fns };
 
    if (!_.isObject(fns)) return;
 
    transformer[type] = fns;
 
    var aliases = t.FLIPPED_ALIAS_KEYS[type];
    if (aliases) {
      _.each(aliases, function (alias) {
        transformer[alias] = fns;
      });
    }
  });
 
  return transformer;
};
 
Transformer.prototype.astRun = function (file, key) {
  var transformer = this.transformer;
 
  if (transformer.ast && transformer.ast[key]) {
    transformer.ast[key](file.ast, file);
  }
};
 
Transformer.prototype.transform = function (file) {
  var transformer = this.transformer;
 
  var build = function (exit) {
    return function (node, parent, scope) {
      var fns = transformer[node.type];
      if (!fns) return;
 
      var fn = fns.enter;
      if (exit) fn = fns.exit;
      if (!fn) return;
 
      return fn(node, parent, file, scope);
    };
  };
 
  this.astRun(file, "before");
 
  traverse(file.ast, {
    enter: build(),
    exit:  build(true)
  });
 
  this.astRun(file, "after");
};
 
Transformer.prototype.canRun = function (file) {
  var opts = file.opts;
  var key  = this.key;
  if (key[0] === "_") return true;
 
  var blacklist = opts.blacklist;
  if (blacklist.length && _.contains(blacklist, key)) return false;
 
  var whitelist = opts.whitelist;
  if (whitelist.length && !_.contains(whitelist, key)) return false;
 
  if (this.optional && !_.contains(opts.optional, key)) return false;
 
  if (this.experimental && !opts.experimental) return false;
 
  return true;
};