immosquare-cleaner 0.1.65 → 0.1.67

data/node_modules/jscodeshift/dist/Runner.js

@@ -0,0 +1,322 @@
+
+/**
+ * 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 child_process = require('child_process');
+const pc = require('picocolors');
+const fs = require('graceful-fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const ignores = require('./ignoreFiles');
+
+const tmp = require('tmp');
+tmp.setGracefulCleanup();
+
+const availableCpus = Math.max(require('os').cpus().length - 1, 1);
+const CHUNK_SIZE = 50;
+
+function lineBreak(str) {
+  return /\n$/.test(str) ? str : str + '\n';
+}
+
+const bufferedWrite = (function() {
+  const buffer = [];
+  let buffering = false;
+
+  process.stdout.on('drain', () => {
+    if (!buffering) return;
+    while (buffer.length > 0 && process.stdout.write(buffer.shift()) !== false);
+    if (buffer.length === 0) {
+      buffering = false;
+    }
+  });
+  return function write(msg) {
+    if (buffering) {
+      buffer.push(msg);
+    }
+    if (process.stdout.write(msg) === false) {
+      buffering = true;
+    }
+  };
+}());
+
+const log = {
+  ok(msg, verbose) {
+    verbose >= 2 && bufferedWrite(pc.bgGreen(pc.white(' OKK ')) + msg);
+  },
+  nochange(msg, verbose) {
+    verbose >= 1 && bufferedWrite(pc.bgYellow(pc.white(' NOC ')) + msg);
+  },
+  skip(msg, verbose) {
+    verbose >= 1 && bufferedWrite(pc.bgYellow(pc.white(' SKIP ')) + msg);
+  },
+  error(msg, verbose) {
+    verbose >= 0 && bufferedWrite(pc.bgRed(pc.white(' ERR ')) + msg);
+  },
+};
+
+function report({file, msg}) {
+  bufferedWrite(lineBreak(`${pc.bgBlue(pc.white(' REP '))}${file} ${msg}`));
+}
+
+function concatAll(arrays) {
+  const result = [];
+  for (const array of arrays) {
+    for (const element of array) {
+      result.push(element);
+    }
+  }
+  return result;
+}
+
+function showFileStats(fileStats) {
+  process.stdout.write(
+    'Results: \n'+
+    pc.red(fileStats.error + ' errors\n')+
+    pc.yellow(fileStats.nochange + ' unmodified\n')+
+    pc.yellow(fileStats.skip + ' skipped\n')+
+    pc.green(fileStats.ok + ' ok\n')
+  );
+}
+
+function showStats(stats) {
+  const names = Object.keys(stats).sort();
+  if (names.length) {
+    process.stdout.write(pc.blue('Stats: \n'));
+  }
+  names.forEach(name => process.stdout.write(name + ': ' + stats[name] + '\n'));
+}
+
+function dirFiles (dir, callback, acc) {
+  // acc stores files found so far and counts remaining paths to be processed
+  acc = acc || { files: [], remaining: 1 };
+
+  function done() {
+    // decrement count and return if there are no more paths left to process
+    if (!--acc.remaining) {
+      callback(acc.files);
+    }
+  }
+
+  fs.readdir(dir, (err, files) => {
+    // if dir does not exist or is not a directory, bail
+    // (this should not happen as long as calls do the necessary checks)
+    if (err) throw err;
+
+    acc.remaining += files.length;
+    files.forEach(file => {
+      let name = path.join(dir, file);
+      fs.stat(name, (err, stats) => {
+        if (err) {
+          // probably a symlink issue
+          process.stdout.write(
+            'Skipping path "' + name + '" which does not exist.\n'
+          );
+          done();
+        } else if (ignores.shouldIgnore(name)) {
+          // ignore the path
+          done();
+        } else if (stats.isDirectory()) {
+          dirFiles(name + '/', callback, acc);
+        } else {
+          acc.files.push(name);
+          done();
+        }
+      });
+    });
+    done();
+  });
+}
+
+function getAllFiles(paths, filter) {
+  return Promise.all(
+    paths.map(file => new Promise(resolve => {
+      fs.lstat(file, (err, stat) => {
+        if (err) {
+          process.stderr.write('Skipping path ' + file + ' which does not exist. \n');
+          resolve([]);
+          return;
+        }
+
+        if (stat.isDirectory()) {
+          dirFiles(
+            file,
+            list => resolve(list.filter(filter))
+          );
+        } else if (!filter(file) || ignores.shouldIgnore(file)) {
+          // ignoring the file
+          resolve([]);
+        } else {
+          resolve([file]);
+        }
+      })
+    }))
+  ).then(concatAll);
+}
+
+function run(transformFile, paths, options) {
+  const cpus = options.cpus ? Math.min(availableCpus, options.cpus) : availableCpus;
+  const extensions =
+    options.extensions && options.extensions.split(',').map(ext => '.' + ext);
+  const fileCounters = {error: 0, ok: 0, nochange: 0, skip: 0};
+  const statsCounter = {};
+  const startTime = process.hrtime();
+
+  ignores.add(options.ignoreSet);
+  ignores.add(options.ignorePattern);
+  ignores.addFromFile(options.ignoreConfig);
+
+  if (options.gitignore) {
+    let currDirectory = process.cwd();
+    let gitIgnorePath = path.join(currDirectory, '.gitignore');
+    ignores.addFromFile(gitIgnorePath);
+  }
+
+  if (/^http/.test(transformFile)) {
+    return new Promise((resolve, reject) => {
+      // call the correct `http` or `https` implementation
+      (transformFile.indexOf('https') !== 0 ?  http : https).get(transformFile, (res) => {
+        let contents = '';
+        res
+          .on('data', (d) => {
+            contents += d.toString();
+          })
+          .on('end', () => {
+            const ext = path.extname(transformFile);
+            tmp.file({ prefix: 'jscodeshift', postfix: ext }, (err, path, fd) => {
+              if (err) return reject(err);
+              fs.write(fd, contents, function (err) {
+                if (err) return reject(err);
+                fs.close(fd, function(err) {
+                  if (err) return reject(err);
+                  transform(path).then(resolve, reject);
+                });
+              });
+            });
+        })
+      })
+      .on('error', (e) => {
+        reject(e);
+      });
+    });
+  } else if (!fs.existsSync(transformFile)) {
+    process.stderr.write(
+      pc.bgRed(pc.white('ERROR')) + ' Transform file ' + transformFile + ' does not exist \n'
+    );
+    return;
+  } else {
+    return transform(transformFile);
+  }
+
+  function transform(transformFile) {
+    return getAllFiles(
+      paths,
+      name => !extensions || extensions.indexOf(path.extname(name)) != -1
+    ).then(files => {
+        const numFiles = files.length;
+
+        if (numFiles === 0) {
+          process.stdout.write('No files selected, nothing to do. \n');
+          return [];
+        }
+
+        const processes = options.runInBand ? 1 : Math.min(numFiles, cpus);
+        const chunkSize = processes > 1 ?
+          Math.min(Math.ceil(numFiles / processes), CHUNK_SIZE) :
+          numFiles;
+
+        let index = 0;
+        // return the next chunk of work for a free worker
+        function next() {
+          if (!options.silent && !options.runInBand && index < numFiles) {
+            process.stdout.write(
+              'Sending ' +
+              Math.min(chunkSize, numFiles-index) +
+              ' files to free worker...\n'
+            );
+          }
+          return files.slice(index, index += chunkSize);
+        }
+
+        if (!options.silent) {
+          process.stdout.write('Processing ' + files.length + ' files... \n');
+          if (!options.runInBand) {
+            process.stdout.write(
+              'Spawning ' + processes +' workers...\n'
+            );
+          }
+          if (options.dry) {
+            process.stdout.write(
+              pc.green('Running in dry mode, no files will be written! \n')
+            );
+          }
+        }
+
+        const args = [transformFile, options.babel ? 'babel' : 'no-babel'];
+
+        const workers = [];
+        for (let i = 0; i < processes; i++) {
+          workers.push(options.runInBand ?
+            require('./Worker')(args) :
+            child_process.fork(require.resolve('./Worker'), args)
+          );
+        }
+
+        return workers.map(child => {
+          child.send({files: next(), options});
+          child.on('message', message => {
+            switch (message.action) {
+              case 'status':
+                fileCounters[message.status] += 1;
+                log[message.status](lineBreak(message.msg), options.verbose);
+                break;
+              case 'update':
+                if (!statsCounter[message.name]) {
+                  statsCounter[message.name] = 0;
+                }
+                statsCounter[message.name] += message.quantity;
+                break;
+              case 'free':
+                child.send({files: next(), options});
+                break;
+              case 'report':
+                report(message);
+                break;
+            }
+          });
+          return new Promise(resolve => child.on('disconnect', resolve));
+        });
+      })
+      .then(pendingWorkers =>
+        Promise.all(pendingWorkers).then(() => {
+          const endTime = process.hrtime(startTime);
+          const timeElapsed = (endTime[0] + endTime[1]/1e9).toFixed(3);
+          if (!options.silent) {
+            process.stdout.write('All done. \n');
+            showFileStats(fileCounters);
+            showStats(statsCounter);
+            process.stdout.write(
+              'Time elapsed: ' + timeElapsed + 'seconds \n'
+            );
+
+            if (options.failOnError && fileCounters.error > 0) {
+              process.exit(1);
+            }
+          }
+          return Object.assign({
+            stats: statsCounter,
+            timeElapsed: timeElapsed
+          }, fileCounters);
+        })
+      );
+  }
+}
+
+exports.run = run;

data/node_modules/jscodeshift/dist/Worker.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 EventEmitter = require('events').EventEmitter;
+
+const async = require('neo-async');
+const fs = require('graceful-fs');
+const writeFileAtomic = require('write-file-atomic');
+const { DEFAULT_EXTENSIONS } = require('@babel/core');
+const getParser = require('./getParser');
+
+const jscodeshift = require('./core');
+
+let presetEnv;
+try {
+  presetEnv = require('@babel/preset-env');
+} catch (_) {}
+
+let emitter;
+let finish;
+let notify;
+let transform;
+let parserFromTransform;
+
+if (module.parent) {
+  emitter = new EventEmitter();
+  emitter.send = (data) => { run(data); };
+  finish = () => { emitter.emit('disconnect'); };
+  notify = (data) => { emitter.emit('message', data); };
+  module.exports = (args) => {
+    setup(args[0], args[1]);
+    return emitter;
+  };
+} else {
+  finish = () => setImmediate(() => process.disconnect());
+  notify = (data) => { process.send(data); };
+  process.on('message', (data) => { run(data); });
+  setup(process.argv[2], process.argv[3]);
+}
+
+function prepareJscodeshift(options) {
+  const parser = parserFromTransform ||
+    getParser(options.parser, options.parserConfig);
+  return jscodeshift.withParser(parser);
+}
+
+function setup(tr, babel) {
+  if (babel === 'babel') {
+    const presets = [];
+    if (presetEnv) {
+      presets.push([
+        presetEnv.default,
+        {targets: {node: true}},
+      ]);
+    }
+    presets.push(
+      /\.tsx?$/.test(tr) ?
+        require('@babel/preset-typescript').default :
+        require('@babel/preset-flow').default
+    );
+
+    require('@babel/register')({
+      configFile: false,
+      babelrc: false,
+      presets,
+      plugins: [
+        require('@babel/plugin-transform-class-properties').default,
+        require('@babel/plugin-transform-nullish-coalescing-operator').default,
+        require('@babel/plugin-transform-optional-chaining').default,
+        require('@babel/plugin-transform-modules-commonjs').default,
+        require('@babel/plugin-transform-private-methods').default,
+      ],
+      extensions: [...DEFAULT_EXTENSIONS, '.ts', '.tsx'],
+      // By default, babel register only compiles things inside the current working directory.
+      // https://github.com/babel/babel/blob/2a4f16236656178e84b05b8915aab9261c55782c/packages/babel-register/src/node.js#L140-L157
+      ignore: [
+        // Ignore parser related files
+        /@babel\/parser/,
+        /\/flow-parser\//,
+        /\/recast\//,
+        /\/ast-types\//,
+      ],
+    });
+  }
+
+  const module = require(tr);
+  transform = typeof module.default === 'function' ?
+    module.default :
+    module;
+  if (module.parser) {
+    parserFromTransform = typeof module.parser === 'string' ?
+      getParser(module.parser) :
+      module.parser;
+  }
+}
+
+function free() {
+  notify({action: 'free'});
+}
+
+function updateStatus(status, file, msg) {
+  msg = msg ? file + ' ' + msg : file;
+  notify({action: 'status', status: status, msg: msg});
+}
+
+function report(file, msg) {
+  notify({action: 'report', file, msg});
+}
+
+function empty() {}
+
+function stats(name, quantity) {
+  quantity = typeof quantity !== 'number' ? 1 : quantity;
+  notify({action: 'update', name: name, quantity: quantity});
+}
+
+function trimStackTrace(trace) {
+  if (!trace) {
+    return '';
+  }
+  // Remove this file from the stack trace of an error thrown in the transformer
+  const lines = trace.split('\n');
+  const result = [];
+  lines.every(function(line) {
+    if (line.indexOf(__filename) === -1) {
+      result.push(line);
+      return true;
+    }
+  });
+  return result.join('\n');
+}
+
+function run(data) {
+  const files = data.files;
+  const options = data.options || {};
+  if (!files.length) {
+    finish();
+    return;
+  }
+  async.each(
+    files,
+    function(file, callback) {
+      fs.readFile(file, async function(err, source) {
+        if (err) {
+          updateStatus('error', file, 'File error: ' + err);
+          callback();
+          return;
+        }
+        source = source.toString();
+        try {
+          const jscodeshift = prepareJscodeshift(options);
+          const out = await transform(
+            {
+              path: file,
+              source: source,
+            },
+            {
+              j: jscodeshift,
+              jscodeshift: jscodeshift,
+              stats: options.dry ? stats : empty,
+              report: msg => report(file, msg),
+            },
+            options
+          );
+          if (!out || out === source) {
+            updateStatus(out ? 'nochange' : 'skip', file);
+            callback();
+            return;
+          }
+          if (options.print) {
+            console.log(out); // eslint-disable-line no-console
+          }
+          if (!options.dry) {
+            writeFileAtomic(file, out, function(err) {
+              if (err) {
+                updateStatus('error', file, 'File writer error: ' + err);
+              } else {
+                updateStatus('ok', file);
+              }
+              callback();
+            });
+          } else {
+            updateStatus('ok', file);
+            callback();
+          }
+        } catch(err) {
+          updateStatus(
+            'error',
+            file,
+            'Transformation error ('+ err.message.replace(/\n/g, ' ') + ')\n' + trimStackTrace(err.stack)
+          );
+          callback();
+        }
+      });
+    },
+    function(err) {
+      if (err) {
+        updateStatus('error', '', 'This should never be shown!');
+      }
+      free();
+    }
+  );
+}

data/node_modules/jscodeshift/dist/__testfixtures__/test-async-transform.input.js

@@ -0,0 +1 @@
+export const sum = (a, b) => a + b;

data/node_modules/jscodeshift/dist/__testfixtures__/test-async-transform.js

@@ -0,0 +1,11 @@
+const synchronousTestTransform = (fileInfo, api, options) => {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve(api.jscodeshift(fileInfo.source)
+        .findVariableDeclarators('sum')
+        .renameTo('addition')
+        .toSource());
+    }, 100);
+  });
+}
+module.exports = synchronousTestTransform;

data/node_modules/jscodeshift/dist/__testfixtures__/test-async-transform.output.js

@@ -0,0 +1 @@
+export const addition = (a, b) => a + b;

data/node_modules/jscodeshift/dist/__testfixtures__/test-sync-transform.input.js

@@ -0,0 +1 @@
+export const sum = (a, b) => a + b;

data/node_modules/jscodeshift/dist/__testfixtures__/test-sync-transform.js

@@ -0,0 +1,7 @@
+const synchronousTestTransform = (fileInfo, api, options) => {
+  return api.jscodeshift(fileInfo.source)
+    .findVariableDeclarators('sum')
+    .renameTo('addition')
+    .toSource();
+}
+module.exports = synchronousTestTransform;

data/node_modules/jscodeshift/dist/__testfixtures__/test-sync-transform.output.js

@@ -0,0 +1 @@
+export const addition = (a, b) => a + b;