elm-pages 3.0.0-beta.10 → 3.0.0-beta.13

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

@@ -0,0 +1,294 @@
+// @flow
+
+const chalk = require('chalk');
+const child_process = require('child_process');
+const fs = require('fs');
+const net = require('net');
+const split = require('split');
+const XmlBuilder = require('xmlbuilder');
+const Report = require('./Report');
+
+function run(
+  elmTestVersion /*: string */,
+  pipeFilename /*: string */,
+  report /*: typeof Report.Report */,
+  processes /*: number */,
+  dest /*: string */,
+  watch /*: boolean */
+) /*: Promise<number> */ {
+  return new Promise(function (resolve) {
+    var nextResultToPrint = null;
+    var finishedWorkers = 0;
+    var closedWorkers = 0;
+    var results = new Map();
+    var failures = 0;
+    var todos = [];
+    var testsToRun = -1;
+    var initializedWorkers = -1;
+    var startingTime = Date.now();
+    var workers = [];
+
+    function printResult(result) {
+      switch (report) {
+        case 'console':
+          // todos are objects, and will be shown in the SUMMARY only.
+          // passed tests are nulls, and should not be printed.
+          // failed tests are strings.
+          if (typeof result === 'string') {
+            console.log(makeWindowsSafe(result));
+          }
+          break;
+
+        case 'json':
+          console.log(JSON.stringify(result));
+          break;
+
+        case 'junit':
+          // JUnit does everything at once in SUMMARY, elsewhere
+          break;
+      }
+    }
+
+    function flushResults() {
+      // Only print any results if we're ready - that is, nextResultToPrint
+      // is no longer null. (BEGIN changes it from null to 0.)
+      if (nextResultToPrint !== null) {
+        var result = results.get(nextResultToPrint);
+
+        while (
+          // If there are no more results to print, then we're done.
+          nextResultToPrint < testsToRun &&
+          // Otherwise, keep going until we have no result available to print.
+          typeof result !== 'undefined'
+        ) {
+          printResult(result);
+          nextResultToPrint++;
+          result = results.get(nextResultToPrint);
+        }
+      }
+    }
+    function reportRuntimeException() {
+      console.error(
+        chalk.red(
+          '\n\nThere was an unexpected runtime exception while running tests\n\n'
+        )
+      );
+    }
+
+    function handleResults(response) {
+      // TODO print progress bar - e.g. "Running test 5 of 20" on a bar!
+      // -- yikes, be careful though...test the scenario where test
+      // authors put Debug.log in their tests - does that mess
+      // everything up re: the line feed? Seems like it would...
+      // ...so maybe a bar is not best. Can we do better? Hm.
+      // Maybe the answer is to print the thing, then Immediately
+      // backtrack the line feed, so that if someone else does more
+      // logging, it will overwrite our status update and that's ok?
+
+      Object.keys(response.results).forEach(function (index) {
+        var result = response.results[index];
+        results.set(parseInt(index), result);
+
+        switch (report) {
+          case 'console':
+            if (result === null) {
+              // It's a PASS; no need to take any action.
+            } else if (typeof result.todo !== 'undefined') {
+              todos.push(result);
+            } else {
+              failures++;
+            }
+            break;
+          case 'junit':
+            if (typeof result.failure !== 'undefined') {
+              failures++;
+            }
+            break;
+          case 'json':
+            if (result.status === 'fail') {
+              failures++;
+            } else if (result.status === 'todo') {
+              todos.push({ labels: result.labels, todo: result.failures[0] });
+            }
+            break;
+        }
+      });
+
+      flushResults();
+    }
+
+    function initWorker(socket) {
+      socket.setEncoding('utf8');
+      socket.setNoDelay(true);
+
+      // See the long note near client.write() in worker.js for why we do this.
+      // It fixes a nasty bug!
+      var stream = socket.pipe(split());
+
+      stream.on('data', function (data) {
+        // In watch mode, the socket is drained which results in an extraneous
+        // message being sent. If we receive no data, ignore it.
+        if (!data) {
+          return;
+        }
+
+        var response = JSON.parse(data);
+
+        switch (response.type) {
+          case 'FINISHED':
+            handleResults(response);
+
+            // This worker found no tests remaining to run; it's finished!
+            finishedWorkers++;
+
+            // If all the workers have finished, print the summmary.
+            if (finishedWorkers === workers.length) {
+              socket.write(
+                JSON.stringify({
+                  type: 'SUMMARY',
+                  duration: Date.now() - startingTime,
+                  failures: failures,
+                  todos: todos,
+                })
+              );
+            }
+            break;
+          case 'SUMMARY':
+            flushResults();
+
+            if (response.exitCode === 1) {
+              // The tests could not even run. At the time of this writing, the
+              // only case is “No exposed values of type Test found”. That
+              // _could_ have been caught at compile time, but the current
+              // architecture needs to actually run the JS to figure out which
+              // exposed values are of type Test. That’s why this type of
+              // response is handled differently than others.
+              console.error(response.message);
+            } else {
+              printResult(response.message);
+
+              if (report === 'junit') {
+                var xml = response.message;
+                var values = Array.from(results.values());
+
+                xml.testsuite.testcase = xml.testsuite.testcase.concat(values);
+
+                console.log(XmlBuilder.create(xml).end());
+              }
+            }
+
+            // Close all the workers.
+            workers.forEach(function (worker) {
+              worker.kill();
+            });
+            resolve(response.exitCode);
+            break;
+          case 'BEGIN':
+            testsToRun = response.testCount;
+
+            if (!Report.isMachineReadable(report)) {
+              var headline = 'elm-test ' + elmTestVersion;
+              var bar = '-'.repeat(headline.length);
+
+              console.log('\n' + headline + '\n' + bar + '\n');
+            }
+
+            printResult(response.message);
+
+            // Now we're ready to print results!
+            nextResultToPrint = 0;
+
+            flushResults();
+
+            break;
+          case 'RESULTS':
+            handleResults(response);
+
+            break;
+          case 'ERROR':
+            throw new Error(response.message);
+          default:
+            throw new Error(
+              'Unrecognized message from worker:' + response.type
+            );
+        }
+      });
+
+      socket.write(JSON.stringify({ type: 'TEST', index: initializedWorkers }));
+
+      initializedWorkers++;
+    }
+
+    var pendingException = false,
+      server = net.createServer(initWorker);
+
+    server.on('error', function (err) {
+      console.error(err.stack);
+      server.close();
+    });
+
+    server.on('listening', function () {
+      workers = Array.from({ length: processes }).map(() => {
+        var worker = child_process.fork(dest);
+
+        worker.on('close', function (code) {
+          // code can be null.
+          var hasNonZeroExitCode = typeof code === 'number' && code !== 0;
+
+          if (watch && !Report.isMachineReadable(report)) {
+            if (hasNonZeroExitCode) {
+              // Queue up complaining about an exception.
+              // Don't print it immediately, or else it might print N times
+              // where N is the number of cores.
+              pendingException = true;
+            }
+            closedWorkers++;
+            // If all the workers have closed, we're done! Continue watching.
+            if (closedWorkers === workers.length) {
+              if (pendingException) {
+                // If we had an exception pending, print it and clear pending flag.
+                reportRuntimeException();
+                pendingException = false;
+              }
+              resolve(1);
+            }
+          } else if (hasNonZeroExitCode) {
+            reportRuntimeException();
+            resolve(1);
+          }
+        });
+
+        return worker;
+      });
+    });
+
+    if (fs.existsSync(pipeFilename) && process.platform !== 'win32') {
+      // Never remove named pipes on Windows. The OS will clean them up when
+      // nothing has a handle to them anymore.
+      fs.unlinkSync(pipeFilename);
+    }
+
+    server.listen(pipeFilename);
+  });
+}
+
+function makeWindowsSafe(text) {
+  return process.platform === 'win32' ? windowsify(text) : text;
+}
+
+// Fix Windows Unicode problems. Credit to https://github.com/sindresorhus/figures for the Windows compat idea!
+var windowsSubstitutions = [
+  [/[↓✗►]/g, '>'],
+  [/╵│╷╹┃╻/g, '|'],
+  [/═/g, '='],
+  [/▔/g, '-'],
+  [/✔/g, '√'],
+];
+
+function windowsify(str) {
+  return windowsSubstitutions.reduce(function (result /*: string */, sub) {
+    return result.replace(sub[0], sub[1]);
+  }, str);
+}
+
+module.exports = { run: run };

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

@@ -0,0 +1,45 @@
+// @flow
+
+const path = require('path');
+const {
+  Worker,
+  MessageChannel,
+  receiveMessageOnPort,
+  // $FlowFixMe[cannot-resolve-module]: Flow doesn’t seem to know about the `worker_threads` module yet.
+} = require('worker_threads');
+
+// Start a worker thread and return a `syncGetWorker`
+// capable of making sync requests until shut down.
+function startWorker() /*: {
+  get: (string) => string,
+  shutDown: () => void,
+} */ {
+  const { port1: localPort, port2: workerPort } = new MessageChannel();
+  const sharedLock = new SharedArrayBuffer(4);
+  // $FlowFixMe[incompatible-call]: Flow is wrong and says `sharedLock` is not an accepted parameter here.
+  const sharedLockArray = new Int32Array(sharedLock);
+  const workerPath = path.resolve(__dirname, 'SyncGetWorker.js');
+  const worker = new Worker(workerPath, {
+    workerData: { sharedLock, requestPort: workerPort },
+    transferList: [workerPort],
+  });
+  function get(url) {
+    worker.postMessage(url);
+    Atomics.wait(sharedLockArray, 0, 0); // blocks until notified at index 0.
+    const response = receiveMessageOnPort(localPort);
+    if (response.message.error) {
+      throw response.message.error;
+    } else {
+      return response.message;
+    }
+  }
+  function shutDown() {
+    localPort.close();
+    worker.terminate();
+  }
+  return { get, shutDown };
+}
+
+module.exports = {
+  startWorker,
+};

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

@@ -0,0 +1,36 @@
+// @flow
+
+// $FlowFixMe[cannot-resolve-module]: Flow doesn’t seem to know about the `worker_threads` module yet.
+const { parentPort, workerData } = require('worker_threads');
+const https = require('https');
+
+const { sharedLock, requestPort } = workerData;
+const sharedLockArray = new Int32Array(sharedLock);
+
+parentPort.on('message', async (url) => {
+  try {
+    const response = await getBody(url);
+    requestPort.postMessage(response);
+  } catch (error) {
+    requestPort.postMessage({ error });
+  }
+  Atomics.notify(sharedLockArray, 0, Infinity);
+});
+
+async function getBody(url /*: string */) /*: Promise<string> */ {
+  return new Promise(function (resolve, reject) {
+    https
+      .get(url, function (res) {
+        let body = '';
+        res.on('data', function (chunk) {
+          body += chunk;
+        });
+        res.on('end', function () {
+          resolve(body);
+        });
+      })
+      .on('error', function (err) {
+        reject(err);
+      });
+  });
+}

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

@@ -0,0 +1,318 @@
+// @flow
+
+const { InvalidOptionArgumentError, Option, program } = require('commander');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const which = require('which');
+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 Install = require('./Install');
+const Project = require('./Project');
+const Report = require('./Report');
+const RunTests = require('./RunTests');
+
+void Report;
+
+const parsePositiveInteger =
+  (minimum /*: number */) =>
+  (string /*: string */) /*: number */ => {
+    const number = Number(string);
+    if (!/^\d+$/.test(string)) {
+      throw new InvalidOptionArgumentError('Expected one or more digits.');
+    } else if (!Number.isFinite(number)) {
+      throw new InvalidOptionArgumentError('Expected a finite number.');
+    } else if (number < minimum) {
+      throw new InvalidOptionArgumentError(`Expected at least ${minimum}.`);
+    } else {
+      return number;
+    }
+  };
+
+function findClosestElmJson(dir /*: string */) /*: string | void */ {
+  const entry = ElmJson.getPath(dir);
+  return fs.existsSync(entry)
+    ? entry
+    : dir === path.parse(dir).root
+    ? undefined
+    : findClosestElmJson(path.dirname(dir));
+}
+
+function getProjectRootDir(subcommand /*: string */) /*: string */ {
+  const elmJsonPath = findClosestElmJson(process.cwd());
+  if (elmJsonPath === undefined) {
+    const command =
+      subcommand === 'tests' ? 'elm-test' : `elm-test ${subcommand}`;
+    console.error(
+      `\`${command}\` requires an elm.json up the directory tree, but none could be found! To make one: elm init`
+    );
+    throw process.exit(1);
+  }
+  return path.dirname(elmJsonPath);
+}
+
+function getProject(subcommand /*: string */) /*: typeof Project.Project */ {
+  try {
+    return Project.init(getProjectRootDir(subcommand), packageInfo.version);
+  } catch (error) {
+    console.error(error.message);
+    throw process.exit(1);
+  }
+}
+
+function getPathToElmBinary(compiler /*: string | void */) /*: string */ {
+  const name = compiler === undefined ? 'elm' : compiler;
+  try {
+    return path.resolve(which.sync(name));
+  } catch (_error) {
+    console.error(
+      compiler === undefined
+        ? `Cannot find elm executable, make sure it is installed.
+(If elm is not on your path or is called something different the --compiler flag might help.)`
+        : `The elm executable passed to --compiler must exist and be exectuble. Got: ${compiler}`
+    );
+    throw process.exit(1);
+  }
+}
+
+function outputOptionError() {
+  return `
+Only /dev/null is allowed.
+
+NOTE: Including this option will not have any effect, as \`elm-test\` does not
+produce any output files. It is meant to improve compatibility with editor
+plugins explicitly setting the --output flag to /dev/null when using
+\`elm-test make\` as a drop-in replacement for \`elm make\`.'
+  `.trim();
+}
+
+const examples = `
+elm-test
+  Run tests in the tests/ folder
+
+elm-test "src/**/*Tests.elm"
+  Run tests in files matching the glob
+`.trim();
+
+function main() {
+  const dependencyProvider = new DependencyProvider();
+
+  process.title = 'elm-test';
+
+  program
+    .allowExcessArguments(false)
+    .name('elm-test')
+    .usage('[options] [globs...]')
+    .description(examples)
+    .option('--watch', 'Run tests on file changes', false)
+    // For example `--seed` and `--fuzz` only make sense for the “tests” command
+    // and could be specified for that command only, but then they won’t show up
+    // in `--help`.
+    .addOption(
+      new Option('--seed <int>', 'Run with a specific fuzzer seed')
+        .default(Math.floor(Math.random() * 407199254740991) + 1000, 'random')
+        .argParser(parsePositiveInteger(0))
+    )
+    .option(
+      '--fuzz <int>',
+      'Define how many times each fuzz-test should run',
+      parsePositiveInteger(1),
+      100
+    )
+    .addOption(
+      new Option(
+        '--report <format>',
+        'Specify which format to use for reporting test results'
+      )
+        .default('console')
+        .choices(Report.all)
+    )
+    // `chalk.supportsColor` looks at `process.argv` for these flags.
+    // We still need to define them so they appear in `--help` and aren’t
+    // treated as unknown flags.
+    .option(
+      '--no-color',
+      'Disable colored console output (setting FORCE_COLOR=0 also works)'
+    )
+    .option(
+      '--color',
+      'Force colored console output (setting FORCE_COLOR to anything but 0 also works)'
+    )
+    .option(
+      '--compiler <path>',
+      'Use a custom path to an Elm executable (default: elm)',
+      undefined
+    )
+    // Ensure compatibility with editor plugins setting --output=/dev/null when
+    // running `make`. This has caused issues with Emacs' flycheck-elm package.
+    .addOption(
+      new Option('--output <output>')
+        .argParser((value) => {
+          if (value !== '/dev/null') {
+            throw new InvalidOptionArgumentError(outputOptionError());
+          }
+        })
+        .hideHelp()
+    )
+    .version(packageInfo.version, '--version', 'Print version and exit')
+    .helpOption('-h, --help', 'Show help')
+    .addHelpCommand('help [command]', 'Show help');
+
+  program
+    .command('init')
+    .description('Install elm-explorations/test and create tests/Example.elm')
+    .action(() => {
+      const options = program.opts();
+      const pathToElmBinary = getPathToElmBinary(options.compiler);
+      const project = getProject('init');
+      try {
+        Install.install(project, pathToElmBinary, 'elm-explorations/test');
+        fs.mkdirSync(project.testsDir, { recursive: true });
+        fs.copyFileSync(
+          path.join(__dirname, '..', 'templates', 'tests', 'Example.elm'),
+          path.join(project.testsDir, 'Example.elm')
+        );
+      } catch (error) {
+        console.error(error.message);
+        throw process.exit(1);
+      }
+      console.log(
+        '\nCheck out the documentation for getting started at https://package.elm-lang.org/packages/elm-explorations/test/latest'
+      );
+      process.exit(0);
+    });
+
+  program
+    .command('install <package>')
+    .description(
+      'Like `elm install package`, except it installs to "test-dependencies" in your elm.json'
+    )
+    .action((packageName) => {
+      const options = program.opts();
+      const pathToElmBinary = getPathToElmBinary(options.compiler);
+      const project = getProject('install');
+      try {
+        const result = Install.install(project, pathToElmBinary, packageName);
+        // This mirrors the behavior of `elm install` passing a package that is
+        // already installed. Say it's already installed, then exit 0.
+        if (result === 'AlreadyInstalled') {
+          console.log('It is already installed!');
+        }
+        process.exit(0);
+      } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('make [globs...]')
+    .description('Check files matching the globs for compilation errors')
+    .action((testFileGlobs) => {
+      const options = program.opts();
+      const pathToElmBinary = getPathToElmBinary(options.compiler);
+      const project = getProject('make');
+      const make = async () => {
+        Generate.generateElmJson(dependencyProvider, project);
+        await Compile.compileSources(
+          FindTests.resolveGlobs(
+            testFileGlobs.length === 0 ? [project.testsDir] : testFileGlobs,
+            project.rootDir
+          ),
+          project.generatedCodeDir,
+          pathToElmBinary,
+          options.report
+        );
+      };
+      make().then(
+        () => process.exit(0),
+        // `elm-test make` has never logged errors it seems.
+        () => process.exit(1)
+      );
+    });
+
+  program
+    // Hack: This command has a name that isn’t likely to exist as a directory
+    // containing tests. If the command were instead called "tests" then
+    // commander would interpret the `tests` in `elm-test tests src` as a
+    // command and only run tests in `src/`, ignoring all files in `tests/`.
+    .command('__elmTestCommand__ [globs...]', { hidden: true, isDefault: true })
+    .action((testFileGlobs) => {
+      const options = program.opts();
+      const pathToElmBinary = getPathToElmBinary(options.compiler);
+      const projectRootDir = getProjectRootDir('tests');
+      const processes = Math.max(1, os.cpus().length);
+      RunTests.runTests(
+        dependencyProvider,
+        projectRootDir,
+        pathToElmBinary,
+        testFileGlobs,
+        processes,
+        options
+      ).then(
+        (code) => process.exit(code),
+        (error) => {
+          console.error(error.message);
+          process.exit(1);
+        }
+      );
+    });
+
+  program
+    .command('install-unstable-test-master')
+    .description(
+      'Use the `master` version of the elm-explorations/test library'
+    )
+    .action(() => {
+      const project = getProject('install-unstable-test-master');
+      Install.installUnstableTestMaster(project).then(
+        () => process.exit(0),
+        (error) => {
+          console.error(error.message);
+          process.exit(1);
+        }
+      );
+    });
+
+  program
+    .command('uninstall-unstable-test-master')
+    .description(
+      'Stop using the `master` version of the elm-explorations/test library'
+    )
+    .action(() => {
+      const options = program.opts();
+      const pathToElmBinary = getPathToElmBinary(options.compiler);
+      const project = getProject('uninstall-unstable-test-master');
+      const run = async () => {
+        Install.uninstallUnstableTestMaster(project);
+        // Install project elm-explorations/test again. This is based on the `make` command.
+        Generate.generateElmJson(dependencyProvider, project);
+        const dummyFile = path.join(project.generatedCodeDir, 'Dummy.elm');
+        fs.writeFileSync(
+          dummyFile,
+          `module Dummy exposing (dummy)\ndummy = ()`
+        );
+        await Compile.compileSources(
+          [dummyFile],
+          project.generatedCodeDir,
+          pathToElmBinary,
+          options.report
+        );
+      };
+      run().then(
+        () => process.exit(0),
+        (error) => {
+          console.error(error.message);
+          process.exit(1);
+        }
+      );
+    });
+
+  program.parse(process.argv);
+}
+
+main();