immosquare-cleaner 0.1.65 → 0.1.67

data/node_modules/jscodeshift/dist/collections/Node.js

@@ -0,0 +1,187 @@
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const Collection = require('../Collection');
+
+const matchNode = require('../matchNode');
+const once = require('../utils/once');
+const recast = require('recast');
+
+const Node = recast.types.namedTypes.Node;
+var types = recast.types.namedTypes;
+
+/**
+* @mixin
+*/
+const traversalMethods = {
+
+  /**
+   * Find nodes of a specific type within the nodes of this collection.
+   *
+   * @param {type}
+   * @param {filter}
+   * @return {Collection}
+   */
+  find: function(type, filter) {
+    const paths = [];
+    const visitorMethodName = 'visit' + type;
+
+    const visitor = {};
+    function visit(path) {
+      /*jshint validthis:true */
+      if (!filter || matchNode(path.value, filter)) {
+        paths.push(path);
+      }
+      this.traverse(path);
+    }
+    this.__paths.forEach(function(p, i) {
+      const self = this;
+      visitor[visitorMethodName] = function(path) {
+        if (self.__paths[i] === path) {
+          this.traverse(path);
+        } else {
+          return visit.call(this, path);
+        }
+      };
+      recast.visit(p, visitor);
+    }, this);
+
+    return Collection.fromPaths(paths, this, type);
+  },
+
+  /**
+   * Returns a collection containing the paths that create the scope of the
+   * currently selected paths. Dedupes the paths.
+   *
+   * @return {Collection}
+   */
+  closestScope: function() {
+    return this.map(path => path.scope && path.scope.path);
+  },
+
+  /**
+   * Traverse the AST up and finds the closest node of the provided type.
+   *
+   * @param {Collection}
+   * @param {filter}
+   * @return {Collection}
+   */
+  closest: function(type, filter) {
+    return this.map(function(path) {
+      let parent = path.parent;
+      while (
+        parent &&
+        !(
+          type.check(parent.value) &&
+          (!filter || matchNode(parent.value, filter))
+        )
+      ) {
+        parent = parent.parent;
+      }
+      return parent || null;
+    });
+  },
+
+  /**
+   * Finds the declaration for each selected path. Useful for member expressions
+   * or JSXElements. Expects a callback function that maps each path to the name
+   * to look for.
+   *
+   * If the callback returns a falsey value, the element is skipped.
+   *
+   * @param {function} nameGetter
+   *
+   * @return {Collection}
+   */
+  getVariableDeclarators: function(nameGetter) {
+    return this.map(function(path) {
+      /*jshint curly:false*/
+      let scope = path.scope;
+      if (!scope) return;
+      const name = nameGetter.apply(path, arguments);
+      if (!name) return;
+      scope = scope.lookup(name);
+      if (!scope) return;
+      const bindings = scope.getBindings()[name];
+      if (!bindings) return;
+      const decl = Collection.fromPaths(bindings)
+        .closest(types.VariableDeclarator);
+      if (decl.length === 1) {
+        return decl.paths()[0];
+      }
+    }, types.VariableDeclarator);
+  },
+};
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+/**
+* @mixin
+*/
+const mutationMethods = {
+  /**
+   * Simply replaces the selected nodes with the provided node. If a function
+   * is provided it is executed for every node and the node is replaced with the
+   * functions return value.
+   *
+   * @param {Node|Array<Node>|function} nodes
+   * @return {Collection}
+   */
+  replaceWith: function(nodes) {
+    return this.forEach(function(path, i) {
+      const newNodes =
+        (typeof nodes === 'function') ? nodes.call(path, path, i) : nodes;
+      path.replace.apply(path, toArray(newNodes));
+    });
+  },
+
+  /**
+   * Inserts a new node before the current one.
+   *
+   * @param {Node|Array<Node>|function} insert
+   * @return {Collection}
+   */
+  insertBefore: function(insert) {
+    return this.forEach(function(path, i) {
+      const newNodes =
+        (typeof insert === 'function') ? insert.call(path, path, i) : insert;
+      path.insertBefore.apply(path, toArray(newNodes));
+    });
+  },
+
+  /**
+   * Inserts a new node after the current one.
+   *
+   * @param {Node|Array<Node>|function} insert
+   * @return {Collection}
+   */
+  insertAfter: function(insert) {
+    return this.forEach(function(path, i) {
+      const newNodes =
+        (typeof insert === 'function') ? insert.call(path, path, i) : insert;
+      path.insertAfter.apply(path, toArray(newNodes));
+    });
+  },
+
+  remove: function() {
+    return this.forEach(path => path.prune());
+  }
+
+};
+
+function register() {
+  Collection.registerMethods(traversalMethods, Node);
+  Collection.registerMethods(mutationMethods, Node);
+  Collection.setDefaultCollectionType(Node);
+}
+
+exports.register = once(register);

data/node_modules/jscodeshift/dist/collections/VariableDeclarator.js

@@ -0,0 +1,210 @@
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const Collection = require('../Collection');
+const NodeCollection = require('./Node');
+const once = require('../utils/once');
+const recast = require('recast');
+
+const astNodesAreEquivalent = recast.types.astNodesAreEquivalent;
+const b = recast.types.builders;
+var types = recast.types.namedTypes;
+
+const VariableDeclarator = recast.types.namedTypes.VariableDeclarator;
+
+/**
+* @mixin
+*/
+const globalMethods = {
+  /**
+   * Finds all variable declarators, optionally filtered by name.
+   *
+   * @param {string} name
+   * @return {Collection}
+   */
+  findVariableDeclarators: function(name) {
+    const filter = name ? {id: {name: name}} : null;
+    return this.find(VariableDeclarator, filter);
+  }
+};
+
+const filterMethods = {
+  /**
+   * Returns a function that returns true if the provided path is a variable
+   * declarator and requires one of the specified module names.
+   *
+   * @param {string|Array} names A module name or an array of module names
+   * @return {Function}
+   */
+  requiresModule: function(names) {
+    if (names && !Array.isArray(names)) {
+      names = [names];
+    }
+    const requireIdentifier = b.identifier('require');
+    return function(path) {
+      const node = path.value;
+      if (!VariableDeclarator.check(node) ||
+          !types.CallExpression.check(node.init) ||
+          !astNodesAreEquivalent(node.init.callee, requireIdentifier)) {
+        return false;
+      }
+      return !names ||
+        names.some(
+          n => astNodesAreEquivalent(node.init.arguments[0], b.literal(n))
+        );
+    };
+  }
+};
+
+/**
+* @mixin
+*/
+const transformMethods = {
+  /**
+   * Renames a variable and all its occurrences.
+   *
+   * @param {string} newName
+   * @return {Collection}
+   */
+  renameTo: function(newName) {
+    // TODO: Include JSXElements
+    return this.forEach(function(path) {
+      const node = path.value;
+      const oldName = node.id.name;
+      const rootScope = path.scope;
+      const rootPath = rootScope.path;
+      Collection.fromPaths([rootPath])
+        .find(types.Identifier, {name: oldName})
+        .filter(function(path) { // ignore non-variables
+          const parent = path.parent.node;
+
+          if (
+            types.MemberExpression.check(parent) &&
+            parent.property === path.node &&
+            !parent.computed
+          ) {
+            // obj.oldName
+            return false;
+          }
+
+          if (
+            types.Property.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // { oldName: 3 }
+            return false;
+          }
+
+          if (
+            types.ObjectProperty.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // { oldName: 3 }
+            return false;
+          }
+
+          if (
+            types.ObjectMethod.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // { oldName() {} }
+            return false;
+          }
+
+          if (
+            types.MethodDefinition.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // class A { oldName() {} }
+            return false;
+          }
+
+          if (
+            types.ClassMethod.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // class A { oldName() {} }
+            return false;
+          }
+
+          if (
+            types.ClassProperty.check(parent) &&
+            parent.key === path.node &&
+            !parent.computed
+          ) {
+            // class A { oldName = 3 }
+            return false;
+          }
+
+          if (
+            types.JSXAttribute.check(parent) &&
+            parent.name === path.node &&
+            !parent.computed
+          ) {
+            // <Foo oldName={oldName} />
+            return false;
+          }
+
+          if (
+            (types.JSXOpeningElement.check(parent) || types.JSXClosingElement.check(parent)) &&
+            parent.name === path.node &&
+            /^[a-z]/.test(path.node.name)
+          ) {
+            // <oldName></oldName>
+            return false;
+          }
+
+          return true;
+        })
+        .forEach(function(path) {
+          let scope = path.scope;
+          while (scope && scope !== rootScope) {
+            if (scope.declares(oldName)) {
+              return;
+            }
+            scope = scope.parent;
+          }
+          if (scope) { // identifier must refer to declared variable
+
+            // It may look like we filtered out properties,
+            // but the filter only ignored property "keys", not "value"s
+            // In shorthand properties, "key" and "value" both have an
+            // Identifier with the same structure.
+            const parent = path.parent.node;
+            if (
+              types.Property.check(parent) &&
+              parent.shorthand &&
+              !parent.method
+            )  {
+
+              path.parent.get('shorthand').replace(false);
+            }
+
+            path.get('name').replace(newName);
+          }
+        });
+    });
+  }
+};
+
+
+function register() {
+  NodeCollection.register();
+  Collection.registerMethods(globalMethods);
+  Collection.registerMethods(transformMethods, VariableDeclarator);
+}
+
+exports.register = once(register);
+exports.filters = filterMethods;

data/node_modules/jscodeshift/dist/collections/index.js

@@ -0,0 +1,14 @@
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+module.exports = {
+  Node: require('./Node'),
+  JSXElement: require('./JSXElement'),
+  VariableDeclarator: require('./VariableDeclarator'),
+  ImportDeclaration: require('./ImportDeclaration'),
+};

data/node_modules/jscodeshift/dist/core.js

@@ -0,0 +1,183 @@
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+const Collection = require('./Collection');
+
+const collections = require('./collections');
+const getParser = require('./getParser');
+const matchNode = require('./matchNode');
+const recast = require('recast');
+const template = require('./template');
+
+const Node = recast.types.namedTypes.Node;
+const NodePath = recast.types.NodePath;
+
+// Register all built-in collections
+for (var name in collections) {
+  collections[name].register();
+}
+
+/**
+ * Main entry point to the tool. The function accepts multiple different kinds
+ * of arguments as a convenience. In particular the function accepts either
+ *
+ * - a string containing source code
+ *   The string is parsed with Recast
+ * - a single AST node
+ * - a single node path
+ * - an array of nodes
+ * - an array of node paths
+ *
+ * @exports jscodeshift
+ * @param {Node|NodePath|Array|string} source
+ * @param {Object} options Options to pass to Recast when passing source code
+ * @return {Collection}
+ */
+function core(source, options) {
+  return typeof source === 'string' ?
+    fromSource(source, options) :
+    fromAST(source);
+}
+
+/**
+ * Returns a collection from a node, node path, array of nodes or array of node
+ * paths.
+ *
+ * @ignore
+ * @param {Node|NodePath|Array} source
+ * @return {Collection}
+ */
+function fromAST(ast) {
+  if (Array.isArray(ast)) {
+    if (ast[0] instanceof NodePath || ast.length === 0) {
+      return Collection.fromPaths(ast);
+    } else if (Node.check(ast[0])) {
+      return Collection.fromNodes(ast);
+    }
+  } else {
+    if (ast instanceof NodePath) {
+      return Collection.fromPaths([ast]);
+    } else if (Node.check(ast)) {
+      return Collection.fromNodes([ast]);
+    }
+  }
+  throw new TypeError(
+    'Received an unexpected value ' + Object.prototype.toString.call(ast)
+  );
+}
+
+function fromSource(source, options) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.parser) {
+    options.parser = getParser();
+  }
+  return fromAST(recast.parse(source, options));
+}
+
+/**
+ * Utility function to match a node against a pattern.
+ * @augments core
+ * @static
+ * @param {Node|NodePath|Object} path
+ * @parma {Object} filter
+ * @return boolean
+ */
+function match(path, filter) {
+  if (!(path instanceof NodePath)) {
+    if (typeof path.get === 'function') {
+      path = path.get();
+    } else {
+      path = {value: path};
+    }
+  }
+  return matchNode(path.value, filter);
+}
+
+const plugins = [];
+
+/**
+ * Utility function for registering plugins.
+ *
+ * Plugins are simple functions that are passed the core jscodeshift instance.
+ * They should extend jscodeshift by calling `registerMethods`, etc.
+ * This method guards against repeated registrations (the plugin callback will only be called once).
+ *
+ * @augments core
+ * @static
+ * @param {Function} plugin
+ */
+function use(plugin) {
+  if (plugins.indexOf(plugin) === -1) {
+    plugins.push(plugin);
+    plugin(core);
+  }
+}
+
+/**
+ * Returns a version of the core jscodeshift function "bound" to a specific
+ * parser.
+ *
+ * @augments core
+ * @static
+ */
+function withParser(parser) {
+  if (typeof parser === 'string') {
+    parser = getParser(parser);
+  }
+
+  const newCore = function(source, options) {
+    if (options && !options.parser) {
+      options.parser = parser;
+    } else {
+      options = {parser};
+    }
+    return core(source, options);
+  };
+
+  return enrichCore(newCore, parser);
+}
+
+/**
+* The ast-types library
+* @external astTypes
+* @see {@link https://github.com/benjamn/ast-types}
+*/
+
+function enrichCore(core, parser) {
+  // add builders and types to the function for simple access
+  Object.assign(core, recast.types.namedTypes);
+  Object.assign(core, recast.types.builders);
+  core.registerMethods = Collection.registerMethods;
+  /**
+  * @augments core
+  * @type external:astTypes
+  */
+  core.types = recast.types;
+  core.match = match;
+  core.template = template(parser);
+
+  // add mappings and filters to function
+  core.filters = {};
+  core.mappings = {};
+  for (const name in collections) {
+    if (collections[name].filters) {
+      core.filters[name] = collections[name].filters;
+    }
+    if (collections[name].mappings) {
+      core.mappings[name] = collections[name].mappings;
+    }
+  }
+  core.use = use;
+  core.withParser = withParser;
+  return core;
+}
+
+module.exports = enrichCore(core, getParser());

data/node_modules/jscodeshift/dist/getParser.js

@@ -0,0 +1,25 @@
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+module.exports = function getParser(parserName, options) {
+  switch (parserName) {
+    case 'babylon':
+      return require('../parser/babylon')(options);
+    case 'flow':
+      return require('../parser/flow')(options);
+    case 'ts':
+      return require('../parser/ts')(options);
+    case 'tsx':
+      return require('../parser/tsx')(options);
+    case 'babel':
+    default:
+      return require('../parser/babel5Compat')(options);
+  }
+};

data/node_modules/jscodeshift/dist/ignoreFiles.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('fs');
+const mm = require('micromatch');
+
+const matchers = [];
+
+/**
+ * Add glob patterns to ignore matched files and folders.
+ * Creates glob patterns to approximate gitignore patterns.
+ * @param {String} val - the glob or gitignore-style pattern to ignore
+ * @see {@linkplain https://git-scm.com/docs/gitignore#_pattern_format}
+ */
+function addIgnorePattern(val) {
+  if (val && typeof val === 'string' && val[0] !== '#') {
+    let pattern = val;
+    if (pattern.indexOf('/') === -1) {
+      matchers.push('**/' + pattern);
+    } else if (pattern[pattern.length-1] === '/') {
+      matchers.push('**/' + pattern + '**');
+      matchers.push(pattern + '**');
+    }
+    matchers.push(pattern);
+  }
+}
+
+/**
+ * Adds ignore patterns directly from function input
+ * @param {String|Array<String>} input - the ignore patterns
+ */
+function addIgnoreFromInput(input) {
+  let patterns = [];
+  if (input) {
+    patterns = patterns.concat(input);
+  }
+  patterns.forEach(addIgnorePattern);
+}
+
+/**
+ * Adds ignore patterns by reading files
+ * @param {String|Array<String>} input - the paths to the ignore config files
+ */
+function addIgnoreFromFile(input) {
+  let lines = [];
+  let files = [];
+  if (input) {
+    files = files.concat(input);
+  }
+
+  files.forEach(function(config) {
+    const stats = fs.statSync(config);
+    if (stats.isFile()) {
+      const content = fs.readFileSync(config, 'utf8');
+      lines = lines.concat(content.split(/\r?\n/));
+    }
+  });
+
+  lines.forEach(addIgnorePattern);
+}
+
+function shouldIgnore(path) {
+  const matched = matchers.length ? mm.isMatch(path, matchers, { dot:true }) : false;
+  return matched;
+}
+
+exports.add = addIgnoreFromInput;
+exports.addFromFile = addIgnoreFromFile;
+exports.shouldIgnore = shouldIgnore;