es-feature-detection/lib/detectFeatures.js

'use strict';

var fs = require('fs');
var globby = require('globby');

var acorn = require('acorn/dist/acorn_loose');
var walker = require('acorn/dist/walk');

// Prepare the walk visitors and handlers
var visitors = {};
var handlers = Object.assign({}, walker.base);
Object.keys(walker.base).forEach(function (key) {
  visitors[key] = visitNode;
});

// Get the browser test object
var featureParser = require('./featureTestParser');

// Declare the initial mappings
var featuresUsed = new Set();
var variables = new Map();
var objects = void 0;
var methods = void 0;

function flatten(arr) {
  return arr.reduce(function (a, v) {
    if (!Array.isArray(v)) {
      a.push(v);
    } else {
      a = a.concat(flatten(v));
    }

    return a;
  }, []);
}

function nodeName(node) {
  var name = null;

  if (node.name) {
    name = node.name;
  } else if (node.type === 'MemberExpression') {
    name = node.property ? node.property.name : null;
  }

  return name;
}

// We register an array of possible values for a given variable
// - This doesn't look at context or other as we just want potential object names
function registerVarVal(varNode, valNode) {
  if (!varNode || !valNode) {
    return;
  }

  var isNew = valNode.type === 'NewExpression';
  var isVar = valNode.type === 'Identifier';

  var varName = nodeName(varNode);
  var valName = nodeName(isNew ? valNode.callee : valNode);

  if (!(isVar || isNew) || !valName) {
    return;
  }

  var savedVals = variables.get(varName) || [];
  valName = (valName ? [valName] : []).filter(function (v) {
    return v !== varName;
  });
  variables.set(varName, savedVals.concat(valName));
}

// Get Variable values so we can match for object names
function getVarVal(varName) {
  var _var = variables.get(varName);
  if (!_var) {
    return null;
  }

  return flatten(_var.map(function (val) {
    if (!variables.has(val)) {
      return val;
    }
    return getVarVal(val);
  }));
}

// Parser methods that determines which methods we are actually using
// (compared to the features test defined in 'features')
function visitNode(node) {
  if (node.type === 'MemberExpression') {
    var propName = nodeName(node);
    if (!propName || !node.object || !objects.has(propName)) {
      return;
    }
    return featuresUsed.add(propName);
  }

  if (node.type === 'VariableDeclarator') {
    return registerVarVal(node.id, node.init);
  }

  // Log the various object assignments to determine the Object type of the variables
  if (node.type === 'AssignmentExpression') {
    return registerVarVal(node.left, node.right);
  }

  var caller = node.callee;

  // We only care about objects, method calls and some properties
  if (!caller || ['NewExpression', 'CallExpression'].indexOf(node.type) < 0) {
    return;
  }

  var obj = caller.object;
  var prop = caller.property;

  // Function call have neither object nor property
  if (!obj && !prop) {
    if (objects.has(caller.name)) {
      featuresUsed.add(caller.name);
    }
    return;
  }

  // If we need to test for the object, add it to the list
  if (objects.has(obj.name)) {
    featuresUsed.add(obj.name);
  }

  // If it is just a function call or if the property is not one we need to
  // check for, then just move on to the next node
  if (!prop || prop && !methods.has(prop.name)) {
    return;
  }

  var method = prop.name;

  // For arrays we need to test for the function
  if (obj.type === 'ArrayExpression') {
    if (objects.has('Array')) {
      featuresUsed.add('Array.' + method);
    }

    // If the determined object has the method in question, then add that check
  } else {
    var methodObjects = methods.get(method);
    var varObjects = getVarVal(obj.name) || obj.name;
    if (!varObjects) {
      return;
    }
    if (!Array.isArray(varObjects)) {
      varObjects = [varObjects];
    }

    varObjects.filter(function (objName) {
      return methodObjects.indexOf(objName) > -1;
    }).forEach(function (objName) {
      return featuresUsed.add(objName + '.' + method);
    });
  }
}

// Parse a given file for any features used
function parseFile(filePath) {
  return new Promise(function (resolve, reject) {
    // first read the file
    fs.readFile(filePath, function (err, content) {
      return err ? reject(err) : resolve(content);
    });
  }).
  // Then parse the content
  then(function (content) {
    return acorn.parse_dammit(content.toString(), {});
  })
  // Then walk the AST
  .then(function (ast) {
    return walker.simple(ast, visitors, handlers);
  });
}

module.exports = function detectFeatures(globs) {
  // Clear the tests before parsing the files
  featuresUsed.clear();

  return featureParser.read()
  // Get the files requested
  .then(function (feats) {
    objects = feats.objects;
    methods = feats.methods;

    return globby(globs);
  })
  // Parse them
  .then(function (files) {
    return Promise.all(files.map(function (file) {
      return parseFile(file);
    }));
  })
  // Return the test results
  .then(function () {
    return Array.from(featuresUsed);
  });
};