elm-pages 3.0.0-beta.23 → 3.0.0-beta.25

package/generator/dead-code-review/node_modules/elm-test/lib/Project.js

@@ -1,117 +0,0 @@
-// @flow
-
-const fs = require('fs');
-const path = require('path');
-const ElmJson = require('./ElmJson');
-
-// Poor man’s type alias. We can’t use /*:: type Project = ... */ because of:
-// https://github.com/prettier/prettier/issues/2597
-const Project /*: {
-  rootDir: string,
-  testsDir: string,
-  generatedCodeDir: string,
-  testsSourceDirs: Array<string>,
-  elmJson: typeof ElmJson.ElmJson,
-} */ = {
-  rootDir: '',
-  testsDir: '',
-  generatedCodeDir: '',
-  testsSourceDirs: [],
-  elmJson: ElmJson.ElmJson,
-};
-
-function getTestsDir(rootDir /*: string */) /*: string */ {
-  return path.join(rootDir, 'tests');
-}
-
-function init(
-  rootDir /*: string */,
-  version /*: string */
-) /*: typeof Project */ {
-  const testsDir = getTestsDir(rootDir);
-
-  // The tests/ directory is not required. You can also co-locate tests with
-  // their source files.
-  const shouldAddTestsDirAsSource = fs.existsSync(testsDir);
-
-  const elmJson = ElmJson.read(rootDir);
-
-  const projectSourceDirs =
-    elmJson.type === 'package' ? ['src'] : elmJson['source-directories'];
-
-  const testsSourceDirs /*: Array<string> */ = projectSourceDirs
-    .map((src) => path.resolve(rootDir, src))
-    .concat(shouldAddTestsDirAsSource ? [testsDir] : []);
-
-  const generatedCodeDir = path.join(
-    rootDir,
-    'elm-stuff',
-    'generated-code',
-    'elm-community',
-    'elm-test',
-    version
-  );
-
-  return {
-    rootDir,
-    testsDir,
-    generatedCodeDir,
-    testsSourceDirs,
-    elmJson,
-  };
-}
-
-/* We do this validation ourselves to avoid the ../../../../../ in Elm’s error message:
-
--- MISSING SOURCE DIRECTORY ------------------------------------------- elm.json
-
-I need a valid elm.json file, but the "source-directories" field lists the
-following directory:
-
-    ../../../../../app
-
-I cannot find it though. Is it missing? Is there a typo?
-*/
-function validateTestsSourceDirs(project /*: typeof Project */) /*: void */ {
-  for (const dir of project.testsSourceDirs) {
-    const fullDir = path.resolve(project.rootDir, dir);
-    let stats;
-    try {
-      stats = fs.statSync(fullDir);
-    } catch (error) {
-      throw new Error(
-        validateTestsSourceDirsError(
-          fullDir,
-          error.code === 'ENOENT'
-            ? "It doesn't exist though. Is it missing? Is there a typo?"
-            : `Failed to read that directory: ${error.message}`
-        )
-      );
-    }
-    if (!stats.isDirectory()) {
-      throw new Error(
-        validateTestsSourceDirsError(
-          fullDir,
-          `It exists but isn't a directory!`
-        )
-      );
-    }
-  }
-}
-
-function validateTestsSourceDirsError(dir, message) {
-  return `
-The "source-directories" field in your elm.json lists the following directory:
-
-${dir}
-
-${message}
-  `.trim();
-}
-
-module.exports = {
-  Project,
-  getTestsDir,
-  init,
-  validateTestsSourceDirs,
-};

package/generator/dead-code-review/node_modules/elm-test/lib/Report.js

@@ -1,23 +0,0 @@
-// @flow
-
-// Poor man’s type alias. We can’t use /*:: type Report = ... */ because of:
-// https://github.com/prettier/prettier/issues/2597
-const Report /*: 'console' | 'json' | 'junit' */ = 'console';
-
-const all = ['json', 'junit', 'console'];
-
-function isMachineReadable(report /*: typeof Report */) /*: boolean */ {
-  switch (report) {
-    case 'json':
-    case 'junit':
-      return true;
-    case 'console':
-      return false;
-  }
-}
-
-module.exports = {
-  Report,
-  all,
-  isMachineReadable,
-};

package/generator/dead-code-review/node_modules/elm-test/lib/RunTests.js

@@ -1,322 +0,0 @@
-// @flow
-
-const chalk = require('chalk');
-const chokidar = require('chokidar');
-const path = require('path');
-const readline = require('readline');
-const packageInfo = require('../package.json');
-const Compile = require('./Compile');
-const DependencyProvider = require('./DependencyProvider.js');
-const ElmJson = require('./ElmJson');
-const FindTests = require('./FindTests');
-const Generate = require('./Generate');
-const Project = require('./Project');
-const Report = require('./Report');
-const Supervisor = require('./Supervisor');
-
-// This value is used _only_ in flow types. 'use' it with the javascript
-// void operator to keep eslint happy.
-void DependencyProvider;
-
-// Incorporate the process PID into the socket name, so elm-test processes can
-// be run parallel without accidentally sharing each others' sockets.
-//
-// See https://github.com/rtfeldman/node-test-runner/pull/231
-// Also incorporate a salt number into it on Windows, to avoid EADDRINUSE -
-// see https://github.com/rtfeldman/node-test-runner/issues/275 - because the
-// alternative approach of deleting the file before creating a new one doesn't
-// work on Windows. We have to let Windows clean up the named pipe. This is
-// essentially a band-aid fix. The alternative is to rewrite a ton of stuff.
-function getPipeFilename(runsExecuted /*: number */) /*: string */ {
-  return process.platform === 'win32'
-    ? `\\\\.\\pipe\\elm_test-${process.pid}-${runsExecuted}`
-    : `/tmp/elm_test-${process.pid}.sock`;
-}
-
-// This could have been a class, but I couldn’t figure out how to type it with
-// Flow comments and Prettier.
-// This lets you log something like `elm.json changed > Compiling > Starting tests`
-// where each segment appears over time.
-// `\r` moves the cursor to the start of the line. This is important when there
-// are Elm compilation errors - they overwrite the progress text rather than
-// weirdly ending up with stuff like:
-// `elm.json changed > Compiling-- NAMING ERROR - File.elm`
-// Also note that using too much `clearLine` or `clearConsole` causes flickering
-// on Windows, so it's nicer to cleverly overwrite old output when possible.
-function makeProgressLogger(report /*: typeof Report.Report */) {
-  const items = [];
-  return {
-    log(message) {
-      items.push(message);
-      if (!Report.isMachineReadable(report)) {
-        process.stdout.write(`${items.join(' > ')}\r`);
-      }
-    },
-    newLine() {
-      items.length = 0;
-      if (!Report.isMachineReadable(report)) {
-        process.stdout.write('\n');
-      }
-    },
-    overwrite(message) {
-      items.length = 0;
-      items.push(message);
-      if (!Report.isMachineReadable(report)) {
-        process.stdout.write(`${message}\r`);
-      }
-    },
-    clearLine() {
-      items.length = 0;
-      if (!Report.isMachineReadable(report)) {
-        readline.clearLine(process.stdout, 0);
-      }
-    },
-    clearConsole() {
-      items.length = 0;
-      if (!Report.isMachineReadable(report)) {
-        process.stdout.write(
-          process.platform === 'win32'
-            ? '\x1B[2J\x1B[0f'
-            : '\x1B[2J\x1B[3J\x1B[H'
-        );
-      }
-    },
-  };
-}
-
-function diffArrays/*:: <T> */(
-  from /*: Array<T> */,
-  to /*: Array<T> */
-) /*: { added: Array<T>, removed: Array<T> } */ {
-  return {
-    added: to.filter((item) => !from.includes(item)),
-    removed: from.filter((item) => !to.includes(item)),
-  };
-}
-
-function delay(ms /*: number */) /*: Promise<void> */ {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-const Queue /*: Array<{
-  event: 'added' | 'changed' | 'removed',
-  filePath: string,
-}> */ = [];
-void Queue;
-
-function watcherEventMessage(queue /*: typeof Queue */) /*: string */ {
-  const filePaths = Array.from(new Set(queue.map(({ filePath }) => filePath)));
-  if (filePaths.length === 1) {
-    const { event, filePath } = queue[0];
-    return `${filePath} ${event}`;
-  }
-
-  const events = Array.from(new Set(queue.map(({ event }) => event))).sort();
-  return `${filePaths.length} files ${events.join('/')}`;
-}
-
-function runTests(
-  dependencyProvider /*: DependencyProvider */,
-  projectRootDir /*: string */,
-  pathToElmBinary /*: string */,
-  testFileGlobs /*: Array<string> */,
-  processes /*: number */,
-  {
-    watch,
-    report,
-    seed,
-    fuzz,
-  } /*: {
-    watch: boolean,
-    report: typeof Report.Report,
-    seed: number,
-    fuzz: number,
-  } */
-) /*: Promise<number> */ {
-  let watcher = undefined;
-  let watchedPaths /*: Array<string> */ = [];
-  let runsExecuted /*: number */ = 0;
-  let currentRun /*: Promise<void> | void */ = undefined;
-  let queue /*: typeof Queue */ = [];
-
-  const progressLogger = makeProgressLogger(report);
-
-  async function run() /*: Promise<number> */ {
-    try {
-      // Don’t delay the first run (that’s the only time the queue is empty).
-      // Otherwise, wait for a little bit to batch events that happened roughly
-      // at the same time. The chokidar docs also mention that by default, the
-      // add event will fire when a file first appears on disk, before the
-      // entire file has been written. They have a `awaitWriteFinish` option for
-      // that, with a `stabilityThreshold` that is an amount of time in
-      // milliseconds for a file size to remain constant before emitting its
-      // event. Elm files aren’t that huge so it should be fine to just wait a
-      // fixed amount of time here instead. I tried it with a 378 MB file. That
-      // resulted in first a "added" event and then a "changed" event a little
-      // later. So the worst thing that can happen is that you get one run with
-      // half a file immediately followed by another run with the whole file.
-      // I tested touching 100 files at a time. All of them produced events
-      // within 60 ms on Windows, and faster on Mac and Linux. So 100 ms sounds
-      // like a reasonable number – not too short, not too long of a wait.
-      const queueLengthBeforeWaiting = queue.length;
-      if (queueLengthBeforeWaiting > 0) {
-        await delay(100);
-        // Re-print the message in case the queue has become longer while waiting.
-        if (queue.length > queueLengthBeforeWaiting) {
-          progressLogger.clearLine();
-          progressLogger.log(watcherEventMessage(queue));
-        }
-      }
-
-      queue = [];
-
-      // All operations down to `Generate.generateElmJson(project)` could
-      // potentially be avoided depending on what changed (checking what’s
-      // inside `queue`). But at the time of this writing all of them are fast
-      // (less than 20 ms, often less than 1 ms) so it’s not worth bothering.
-
-      // Files may be changed, added or removed so always re-create project info
-      // from disk to stay fresh.
-      const project = Project.init(projectRootDir, packageInfo.version);
-      Project.validateTestsSourceDirs(project);
-
-      const testFilePaths = FindTests.resolveGlobs(
-        testFileGlobs.length === 0 ? [project.testsDir] : testFileGlobs,
-        project.rootDir
-      );
-
-      if (testFilePaths.length === 0) {
-        throw new Error(
-          FindTests.noFilesFoundError(project.rootDir, testFileGlobs)
-        );
-      }
-
-      if (watcher !== undefined) {
-        const diff = diffArrays(watchedPaths, project.testsSourceDirs);
-        watchedPaths = project.testsSourceDirs;
-        watcher.add(diff.added);
-        watcher.unwatch(diff.removed);
-      }
-
-      runsExecuted++;
-      const pipeFilename = getPipeFilename(runsExecuted);
-      const testModules = await FindTests.findTests(testFilePaths, project);
-      const mainModule = Generate.getMainModule(project.generatedCodeDir);
-      const dest = path.join(project.generatedCodeDir, 'elmTestOutput.js');
-
-      await Generate.generateElmJson(dependencyProvider, project);
-
-      progressLogger.log('Compiling');
-
-      Generate.generateMainModule(
-        fuzz,
-        seed,
-        report,
-        testFileGlobs,
-        testFilePaths,
-        testModules,
-        mainModule,
-        processes
-      );
-
-      await Compile.compile(
-        project.generatedCodeDir,
-        mainModule.path,
-        dest,
-        pathToElmBinary,
-        report
-      );
-
-      Generate.prepareCompiledJsFile(pipeFilename, dest);
-
-      progressLogger.log('Starting tests');
-      progressLogger.newLine();
-
-      return await Supervisor.run(
-        packageInfo.version,
-        pipeFilename,
-        report,
-        processes,
-        dest,
-        watch
-      );
-    } catch (err) {
-      progressLogger.newLine();
-      console.error(err.message);
-      return 1;
-    }
-  }
-
-  if (watch) {
-    progressLogger.clearConsole();
-
-    const onRunFinish = () => {
-      if (queue.length > 0) {
-        progressLogger.clearConsole();
-        progressLogger.log(watcherEventMessage(queue));
-        currentRun = run().then(onRunFinish);
-      } else {
-        if (!Report.isMachineReadable(report)) {
-          console.log(chalk.blue('Watching for changes...'));
-        }
-        currentRun = undefined;
-      }
-    };
-
-    // The directories to watch change over time and are added and removed as
-    // needed in `run`. We should always watch `elm.json` and `tests/`, though
-    // (see the 'addDir' event below).
-    const alwaysWatched = [
-      ElmJson.getPath(projectRootDir),
-      Project.getTestsDir(projectRootDir),
-    ];
-
-    const rerun = (event) => (absoluteFilePath) => {
-      if (
-        absoluteFilePath.endsWith('.elm') ||
-        alwaysWatched.includes(absoluteFilePath)
-      ) {
-        queue.push({
-          event,
-          filePath: path.relative(projectRootDir, absoluteFilePath),
-        });
-        if (currentRun === undefined) {
-          progressLogger.clearConsole();
-          progressLogger.log(watcherEventMessage(queue));
-          currentRun = run().then(onRunFinish);
-        }
-      }
-    };
-
-    watcher = chokidar.watch(alwaysWatched, {
-      ignoreInitial: true,
-      ignored: FindTests.ignoredDirsGlobs,
-      disableGlobbing: true,
-    });
-
-    watcher.on('add', rerun('added'));
-    watcher.on('change', rerun('changed'));
-    watcher.on('unlink', rerun('removed'));
-
-    // The only time this event is interesting is when the `tests/` directory is
-    // created after the watcher was started. There’s no need to listen for
-    // 'unlinkDir' – that makes no difference.
-    watcher.on('addDir', rerun('added'));
-
-    // It’s unclear when this event occurrs.
-    watcher.on('error', (error) => console.error('Watcher error:', error));
-
-    currentRun = run().then(onRunFinish);
-
-    // A promise that never resolves. We’ll watch until killed.
-    return new Promise(() => {});
-  } else {
-    return run();
-  }
-}
-
-module.exports = {
-  runTests,
-};

package/generator/dead-code-review/node_modules/elm-test/lib/Solve.js

@@ -1,76 +0,0 @@
-// @flow
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const ElmJson = require('./ElmJson');
-const Project = require('./Project');
-const DependencyProvider = require('./DependencyProvider.js');
-
-// These value are used _only_ in flow types. 'use' them with the javascript
-// void operator to keep eslint happy.
-void Project;
-void DependencyProvider;
-
-function sha256(string) {
-  return crypto.createHash('sha256').update(string).digest('hex');
-}
-
-function getDependenciesCached(
-  dependencyProvider /*: DependencyProvider */,
-  project /*: typeof Project.Project */
-) /*: typeof ElmJson.DirectAndIndirectDependencies */ {
-  const hash = sha256(
-    JSON.stringify({
-      dependencies: project.elmJson.dependencies,
-      'test-dependencies': project.elmJson['test-dependencies'],
-    })
-  );
-
-  const cacheFile = path.join(
-    project.generatedCodeDir,
-    `dependencies.${hash}.json`
-  );
-
-  try {
-    return JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-  } catch (error) {
-    if (error.code !== 'ENOENT') {
-      console.warn(
-        `Ignoring bad dependencies cache file:\n\n${error.message}\n\nPlease report this issue: https://github.com/rtfeldman/node-test-runner/issues/new`
-      );
-    }
-  }
-
-  const dependencies = getDependencies(dependencyProvider, project.elmJson);
-
-  fs.writeFileSync(cacheFile, dependencies);
-
-  return ElmJson.parseDirectAndIndirectDependencies(
-    JSON.parse(dependencies),
-    'cached solved dependencies'
-  );
-}
-
-function getDependencies(
-  dependencyProvider /*: DependencyProvider */,
-  elmJson /*: typeof ElmJson.ElmJson */
-) /*: string */ {
-  const useTest = true;
-  const extra = {
-    'elm/core': '1.0.0 <= v < 2.0.0',
-    'elm/json': '1.0.0 <= v < 2.0.0',
-    'elm/time': '1.0.0 <= v < 2.0.0',
-    'elm/random': '1.0.0 <= v < 2.0.0',
-  };
-  const elmJsonStr = JSON.stringify(elmJson);
-  try {
-    return dependencyProvider.solveOffline(elmJsonStr, useTest, extra);
-  } catch (_) {
-    return dependencyProvider.solveOnline(elmJsonStr, useTest, extra);
-  }
-}
-
-module.exports = {
-  getDependenciesCached,
-};