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

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

@@ -0,0 +1,343 @@
+// @flow
+
+const fs = require('fs');
+const path = require('path');
+const wasm = require('elm-solve-deps-wasm');
+const ElmHome = require('./ElmHome.js');
+const SyncGet = require('./SyncGet.js');
+const collator = new Intl.Collator('en', { numeric: true }); // for sorting SemVer strings
+
+// Initialization work done only once.
+wasm.init();
+const syncGetWorker /*: {| get: (string) => string, shutDown: () => void |} */ =
+  SyncGet.startWorker();
+
+// Cache of existing versions according to the package website.
+class OnlineVersionsCache {
+  map /*: Map<string, Array<string>> */ = new Map();
+
+  update() {
+    const pubgrubHome = path.join(ElmHome.elmHome(), 'pubgrub');
+    fs.mkdirSync(pubgrubHome, { recursive: true });
+    const cachePath = path.join(pubgrubHome, 'versions_cache.json');
+    const remotePackagesUrl = 'https://package.elm-lang.org/all-packages';
+    if (this.map.size === 0) {
+      let cacheFile;
+      try {
+        // Read from disk existing versions which are already cached.
+        cacheFile = fs.readFileSync(cachePath, 'utf8');
+      } catch (_) {
+        // The cache file does not exist so let's reset it.
+        this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
+        return;
+      }
+      try {
+        this.map = parseOnlineVersions(JSON.parse(cacheFile));
+      } catch (error) {
+        throw new Error(
+          `Failed to parse the cache file ${cachePath}.\n${error.message}`
+        );
+      }
+    }
+    this.updateWithRequestSince(cachePath, remotePackagesUrl);
+  }
+
+  // Update the cache with a request to the package server.
+  updateWithRequestSince(
+    cachePath /*: string */,
+    remotePackagesUrl /*: string */
+  ) /*: void */ {
+    // Count existing versions.
+    let versionsCount = 0;
+    for (const versions of this.map.values()) {
+      versionsCount += versions.length;
+    }
+
+    // Complete cache with a remote call to the package server.
+    const remoteUrl = remotePackagesUrl + '/since/' + (versionsCount - 1); // -1 to check if no package was deleted.
+    const newVersions = JSON.parse(syncGetWorker.get(remoteUrl));
+    if (newVersions.length === 0) {
+      // Reload from scratch since it means at least one package was deleted from the registry.
+      this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
+      return;
+    }
+    // Check that the last package in the list was already in cache
+    // since the list returned by the package server is sorted newest first.
+    const { pkg, version } = splitPkgVersion(newVersions.pop());
+    const cachePkgVersions = this.map.get(pkg);
+    if (
+      cachePkgVersions !== undefined &&
+      cachePkgVersions[cachePkgVersions.length - 1] === version
+    ) {
+      // Insert (in reverse) newVersions into onlineVersionsCache map.
+      for (const pkgVersion of newVersions.reverse()) {
+        const { pkg, version } = splitPkgVersion(pkgVersion);
+        const versionsOfPkg = this.map.get(pkg);
+        if (versionsOfPkg === undefined) {
+          this.map.set(pkg, [version]);
+        } else {
+          versionsOfPkg.push(version);
+        }
+      }
+      // Save the updated onlineVersionsCache to disk.
+      const onlineVersions = Object.fromEntries(this.map.entries());
+      fs.writeFileSync(cachePath, JSON.stringify(onlineVersions));
+    } else {
+      // There was a problem and a package got deleted from the server.
+      this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
+    }
+  }
+
+  getVersions(pkg /*: string */) /*: Array<string> */ {
+    const versions = this.map.get(pkg);
+    return versions === undefined ? [] : versions;
+  }
+}
+
+class OnlineAvailableVersionLister {
+  // Memoization cache to avoid doing the same work twice in list.
+  memoCache /*: Map<string, Array<string>> */ = new Map();
+  onlineCache /*: OnlineVersionsCache */;
+
+  constructor(onlineCache /*: OnlineVersionsCache */) {
+    onlineCache.update();
+    this.onlineCache = onlineCache;
+  }
+
+  list(pkg /*: string */) /*: Array<string> */ {
+    const memoVersions = this.memoCache.get(pkg);
+    if (memoVersions !== undefined) {
+      return memoVersions;
+    }
+    const offlineVersions = readVersionsInElmHomeAndSort(pkg);
+    const allVersionsSet = new Set(this.onlineCache.getVersions(pkg));
+    // Combine local and online versions.
+    for (const version of offlineVersions) {
+      allVersionsSet.add(version);
+    }
+    const allVersions = [...allVersionsSet].sort(flippedSemverCompare);
+    this.memoCache.set(pkg, allVersions);
+    return allVersions;
+  }
+}
+
+class OfflineAvailableVersionLister {
+  // Memoization cache to avoid doing the same work twice in list.
+  cache /*: Map<string, Array<string>> */ = new Map();
+
+  list(pkg /*: string */) /*: Array<string> */ {
+    const memoVersions = this.cache.get(pkg);
+    if (memoVersions !== undefined) {
+      return memoVersions;
+    }
+
+    const offlineVersions = readVersionsInElmHomeAndSort(pkg);
+
+    this.cache.set(pkg, offlineVersions);
+    return offlineVersions;
+  }
+}
+
+function readVersionsInElmHomeAndSort(pkg /*: string */) /*: Array<string> */ {
+  const pkgPath = ElmHome.packagePath(pkg);
+  let offlineVersions;
+  try {
+    offlineVersions = fs.readdirSync(pkgPath);
+  } catch (_) {
+    // The directory doesn't exist or we don't have permissions.
+    // It's fine to catch all cases and return an empty list.
+    offlineVersions = [];
+  }
+
+  return offlineVersions.sort(flippedSemverCompare);
+}
+
+class DependencyProvider {
+  cache /*: OnlineVersionsCache */ = new OnlineVersionsCache();
+
+  // Solve dependencies completely offline, without any http request.
+  solveOffline(
+    elmJson /*: string */,
+    useTest /*: boolean */,
+    extra /*: { [string]: string } */
+  ) /*: string */ {
+    const lister = new OfflineAvailableVersionLister();
+    try {
+      return wasm.solve_deps(
+        elmJson,
+        useTest,
+        extra,
+        fetchElmJsonOffline,
+        (pkg) => lister.list(pkg)
+      );
+    } catch (errorMessage) {
+      throw new Error(errorMessage);
+    }
+  }
+
+  // Solve dependencies with http requests when required.
+  solveOnline(
+    elmJson /*: string */,
+    useTest /*: boolean */,
+    extra /*: { [string]: string } */
+  ) /*: string */ {
+    const lister = new OnlineAvailableVersionLister(this.cache);
+    try {
+      return wasm.solve_deps(
+        elmJson,
+        useTest,
+        extra,
+        fetchElmJsonOnline,
+        (pkg) => lister.list(pkg)
+      );
+    } catch (errorMessage) {
+      throw new Error(errorMessage);
+    }
+  }
+}
+
+function fetchElmJsonOnline(
+  pkg /*: string */,
+  version /*: string */
+) /*: string */ {
+  try {
+    return fetchElmJsonOffline(pkg, version);
+  } catch (_) {
+    // `fetchElmJsonOffline` can only fail in ways that are either expected
+    // (such as file does not exist or no permissions)
+    // or because there was an error parsing `pkg` and `version`.
+    // In such case, this will throw again with `cacheElmJsonPath()` so it's fine.
+    const remoteUrl = remoteElmJsonUrl(pkg, version);
+    const elmJson = syncGetWorker.get(remoteUrl);
+    const cachePath = cacheElmJsonPath(pkg, version);
+    const parentDir = path.dirname(cachePath);
+    fs.mkdirSync(parentDir, { recursive: true });
+    fs.writeFileSync(cachePath, elmJson);
+    return elmJson;
+  }
+}
+
+function fetchElmJsonOffline(
+  pkg /*: string */,
+  version /*: string */
+) /*: string */ {
+  try {
+    return fs.readFileSync(homeElmJsonPath(pkg, version), 'utf8');
+  } catch (_) {
+    // The read can only fail if the elm.json file does not exist
+    // or if we don't have the permissions to read it so it's fine to catch all.
+    // Otherwise, it means that `homeElmJsonPath()` failed while processing `pkg` and `version`.
+    // In such case, again, it's fine to catch all since the next call to `cacheElmJsonPath()`
+    // will fail the same anyway.
+    return fs.readFileSync(cacheElmJsonPath(pkg, version), 'utf8');
+  }
+}
+
+// Reset the cache of existing versions from scratch
+// with a request to the package server.
+function onlineVersionsFromScratch(
+  cachePath /*: string */,
+  remotePackagesUrl /*: string */
+) /*: Map<string, Array<string>> */ {
+  const onlineVersionsJson = syncGetWorker.get(remotePackagesUrl);
+  fs.writeFileSync(cachePath, onlineVersionsJson);
+  const onlineVersions = JSON.parse(onlineVersionsJson);
+  try {
+    return parseOnlineVersions(onlineVersions);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse the response from the request to ${remotePackagesUrl}.\n${error.message}`
+    );
+  }
+}
+
+// Helper functions ##################################################
+
+/* Compares two versions so that newer versions appear first when sorting with this function. */
+function flippedSemverCompare(a /*: string */, b /*: string */) /*: number */ {
+  return collator.compare(b, a);
+}
+
+function parseOnlineVersions(
+  json /*: mixed */
+) /*: Map<string, Array<string>> */ {
+  if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+    throw new Error(
+      `Expected an object, but got: ${
+        json === null ? 'null' : Array.isArray(json) ? 'Array' : typeof json
+      }`
+    );
+  }
+
+  const result = new Map();
+
+  for (const [key, value] of Object.entries(json)) {
+    result.set(key, parseVersions(key, value));
+  }
+
+  return result;
+}
+
+function parseVersions(
+  key /*: string */,
+  json /*: mixed */
+) /*: Array<string> */ {
+  if (!Array.isArray(json)) {
+    throw new Error(
+      `Expected ${JSON.stringify(key)} to be an array, but got: ${typeof json}`
+    );
+  }
+
+  for (const [index, item] of json.entries()) {
+    if (typeof item !== 'string') {
+      throw new Error(
+        `Expected${JSON.stringify(
+          key
+        )}->${index} to be a string, but got: ${typeof item}`
+      );
+    }
+  }
+
+  // $FlowFixMe[incompatible-return]: We dynamically checked that `json` is an `Array<string>`.
+  return json;
+}
+
+function remoteElmJsonUrl(
+  pkg /*: string */,
+  version /*: string */
+) /*: string */ {
+  return `https://package.elm-lang.org/packages/${pkg}/${version}/elm.json`;
+}
+
+function cacheElmJsonPath(
+  pkg /*: string */,
+  version /*: string */
+) /*: string */ {
+  const parts = ElmHome.splitAuthorPkg(pkg);
+  return path.join(
+    ElmHome.elmHome(),
+    'pubgrub',
+    'elm_json_cache',
+    parts.author,
+    parts.pkg,
+    version,
+    'elm.json'
+  );
+}
+
+function homeElmJsonPath(
+  pkg /*: string */,
+  version /*: string */
+) /*: string */ {
+  return path.join(ElmHome.packagePath(pkg), version, 'elm.json');
+}
+
+function splitPkgVersion(str /*: string */) /*: {
+  pkg: string,
+  version: string,
+} */ {
+  const parts = str.split('@');
+  return { pkg: parts[0], version: parts[1] };
+}
+
+module.exports = DependencyProvider;

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

@@ -0,0 +1,109 @@
+// @flow
+
+'use strict';
+
+var spawn = require('cross-spawn');
+
+var defaultOptions = {
+  spawn: spawn,
+  cwd: undefined,
+  pathToElm: 'elm',
+  output: undefined,
+  report: undefined,
+  processOpts: undefined,
+};
+
+// Converts an object of key/value pairs to an array of arguments suitable
+// to be passed to child_process.spawn for elm-make.
+function compilerArgsFromOptions(options) {
+  var args = [];
+
+  if (options.output != null) {
+    args.push('--output', options.output);
+  }
+
+  if (options.report != null) {
+    args.push('--report', options.report);
+  }
+
+  return args;
+}
+
+function runCompiler(sources, options) {
+  var pathToElm = options.pathToElm;
+  var processArgs = ['make'].concat(sources, compilerArgsFromOptions(options));
+
+  var processOpts = Object.assign(
+    {},
+    {
+      env: Object.assign({ LANG: 'en_US.UTF-8' }, process.env),
+      stdio: 'inherit',
+      cwd: options.cwd,
+    },
+    options.processOpts
+  );
+
+  return options.spawn(pathToElm, processArgs, processOpts);
+}
+
+function compilerErrorToString(err, pathToElm) {
+  if (typeof err === 'object' && typeof err.code === 'string') {
+    switch (err.code) {
+      case 'ENOENT':
+        return (
+          'Could not find Elm compiler "' + pathToElm + '". Is it installed?'
+        );
+
+      case 'EACCES':
+        return (
+          'Elm compiler "' +
+          pathToElm +
+          '" did not have permission to run. Do you need to give it executable permissions?'
+        );
+
+      default:
+        return (
+          'Error attempting to run Elm compiler "' + pathToElm + '":\n' + err
+        );
+    }
+  } else if (typeof err === 'object' && typeof err.message === 'string') {
+    return JSON.stringify(err.message);
+  } else {
+    return (
+      'Exception thrown when attempting to run Elm compiler ' +
+      JSON.stringify(pathToElm)
+    );
+  }
+}
+
+function compile(
+  sources /*: Array<string> */,
+  options /*: {|
+    spawn?: (
+      string,
+      Array<string>,
+      child_process$spawnOpts
+    ) => child_process$ChildProcess,
+    cwd?: string,
+    pathToElm?: string,
+    output?: string,
+    report?: 'json',
+    processOpts?: child_process$spawnOpts,
+  |} */
+) /*: child_process$ChildProcess */ {
+  var optionsWithDefaults = Object.assign({}, defaultOptions, options);
+  try {
+    return runCompiler(sources, optionsWithDefaults).on(
+      'error',
+      function (err) {
+        throw err;
+      }
+    );
+  } catch (err) {
+    throw new Error(compilerErrorToString(err, optionsWithDefaults.pathToElm));
+  }
+}
+
+module.exports = {
+  compile: compile,
+};

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

@@ -0,0 +1,47 @@
+// @flow
+
+const path = require('path');
+const os = require('os');
+
+function elmHome() /*: string */ {
+  const elmHomeEnv = process.env['ELM_HOME'];
+  return elmHomeEnv === undefined ? defaultElmHome() : elmHomeEnv;
+}
+
+function defaultElmHome() /*: string */ {
+  return process.platform === 'win32'
+    ? defaultWindowsElmHome()
+    : defaultUnixElmHome();
+}
+
+function defaultUnixElmHome() /*: string */ {
+  return path.join(os.homedir(), '.elm');
+}
+
+function defaultWindowsElmHome() /*: string */ {
+  const appData = process.env.APPDATA;
+  const dir =
+    appData === undefined
+      ? path.join(os.homedir(), 'AppData', 'Roaming')
+      : appData;
+  return path.join(dir, 'elm');
+}
+
+function packagePath(pkg /*: string */) /*: string */ {
+  const parts = splitAuthorPkg(pkg);
+  return path.join(elmHome(), '0.19.1', 'packages', parts.author, parts.pkg);
+}
+
+function splitAuthorPkg(pkgIdentifier /*: string */) /*: {
+  author: string,
+  pkg: string,
+} */ {
+  const parts = pkgIdentifier.split('/');
+  return { author: parts[0], pkg: parts[1] };
+}
+
+module.exports = {
+  elmHome,
+  packagePath,
+  splitAuthorPkg,
+};

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

@@ -0,0 +1,194 @@
+// @flow
+
+const fs = require('fs');
+const path = require('path');
+
+// Poor man’s type alias. We can’t use /*:: type Dependencies = ... */ because of:
+// https://github.com/prettier/prettier/issues/2597
+const Dependencies /*: { [string]: string } */ = {};
+
+const DirectAndIndirectDependencies /*: {
+  direct: typeof Dependencies,
+  indirect: typeof Dependencies,
+} */ = { direct: {}, indirect: {} };
+
+const ElmJson /*:
+  | {
+      type: 'application',
+      'source-directories': Array<string>,
+      dependencies: typeof DirectAndIndirectDependencies,
+      'test-dependencies': typeof DirectAndIndirectDependencies,
+      [string]: mixed,
+    }
+  | {
+      type: 'package',
+      dependencies: typeof Dependencies,
+      'test-dependencies': typeof Dependencies,
+      [string]: mixed,
+    } */ = {
+  type: 'package',
+  dependencies: Dependencies,
+  'test-dependencies': Dependencies,
+};
+
+function getPath(dir /*: string */) /*: string */ {
+  return path.join(dir, 'elm.json');
+}
+
+function write(dir /*: string */, elmJson /*: typeof ElmJson */) /*: void */ {
+  const elmJsonPath = getPath(dir);
+
+  try {
+    fs.writeFileSync(elmJsonPath, JSON.stringify(elmJson, null, 4) + '\n');
+  } catch (error) {
+    throw new Error(
+      `${elmJsonPath}\nFailed to write elm.json:\n${error.message}`
+    );
+  }
+}
+
+function read(dir /*: string */) /*: typeof ElmJson */ {
+  const elmJsonPath = getPath(dir);
+
+  try {
+    return readHelper(elmJsonPath);
+  } catch (error) {
+    throw new Error(
+      `${elmJsonPath}\nFailed to read elm.json:\n${error.message}`
+    );
+  }
+}
+
+function readHelper(elmJsonPath /*: string */) /*: typeof ElmJson */ {
+  const json = parseObject(
+    JSON.parse(fs.readFileSync(elmJsonPath, 'utf8')),
+    'the file'
+  );
+
+  switch (json.type) {
+    case 'application':
+      return {
+        ...json,
+        type: 'application',
+        'source-directories': parseSourceDirectories(
+          json['source-directories']
+        ),
+        dependencies: parseDirectAndIndirectDependencies(
+          json.dependencies,
+          'dependencies'
+        ),
+        'test-dependencies': parseDirectAndIndirectDependencies(
+          json['test-dependencies'],
+          'test-dependencies'
+        ),
+      };
+
+    case 'package':
+      return {
+        ...json,
+        type: 'package',
+        dependencies: parseDependencies(json.dependencies, 'dependencies'),
+        'test-dependencies': parseDependencies(
+          json['test-dependencies'],
+          'test-dependencies'
+        ),
+      };
+
+    default:
+      throw new Error(
+        `Expected "type" to be "application" or "package", but got: ${stringify(
+          json.type
+        )}`
+      );
+  }
+}
+
+function parseSourceDirectories(json /*: mixed */) /*: Array<string> */ {
+  if (!Array.isArray(json)) {
+    throw new Error(
+      `Expected "source-directories" to be an array, but got: ${stringify(
+        json
+      )}`
+    );
+  }
+
+  const result = [];
+
+  for (const [index, item] of json.entries()) {
+    if (typeof item !== 'string') {
+      throw new Error(
+        `Expected "source-directories"->${index} to be a string, but got: ${stringify(
+          item
+        )}`
+      );
+    }
+    result.push(item);
+  }
+
+  if (result.length === 0) {
+    throw new Error(
+      'Expected "source-directories" to contain at least one item, but it is empty.'
+    );
+  }
+
+  return result;
+}
+
+function parseDirectAndIndirectDependencies(
+  json /*: mixed */,
+  what /*: string */
+) /*: typeof DirectAndIndirectDependencies */ {
+  const jsonObject = parseObject(json, what);
+  return {
+    direct: parseDependencies(jsonObject.direct, `${what}->"direct"`),
+    indirect: parseDependencies(jsonObject.indirect, `${what}->"indirect"`),
+  };
+}
+
+function parseDependencies(
+  json /*: mixed */,
+  what /*: string */
+) /*: typeof Dependencies */ {
+  const jsonObject = parseObject(json, what);
+  const result = {};
+
+  for (const [key, value] of Object.entries(jsonObject)) {
+    if (typeof value !== 'string') {
+      throw new Error(
+        `Expected ${what}->${stringify(
+          key
+        )} to be a string, but got: ${stringify(value)}`
+      );
+    }
+    result[key] = value;
+  }
+
+  return result;
+}
+
+function parseObject(
+  json /*: mixed */,
+  what /*: string */
+) /*: { +[string]: mixed } */ {
+  if (json == null || typeof json !== 'object' || Array.isArray(json)) {
+    throw new Error(
+      `Expected ${what} to be an object, but got: ${stringify(json)}`
+    );
+  }
+  return json;
+}
+
+function stringify(json /*: mixed */) /*: string */ {
+  const maybeString = JSON.stringify(json);
+  return maybeString === undefined ? 'undefined' : maybeString;
+}
+
+module.exports = {
+  Dependencies,
+  DirectAndIndirectDependencies,
+  ElmJson,
+  getPath,
+  parseDirectAndIndirectDependencies,
+  read,
+  write,
+};