elm-pages 3.0.0-beta.20 → 3.0.0-beta.21

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

@@ -0,0 +1,117 @@
+// @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

@@ -0,0 +1,23 @@
+// @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

@@ -0,0 +1,322 @@
+// @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

@@ -0,0 +1,76 @@
+// @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,
+};