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

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

@@ -0,0 +1,276 @@
+// @flow
+
+const gracefulFs = require('graceful-fs');
+const fs = require('fs');
+const glob = require('glob');
+const path = require('path');
+const Parser = require('./Parser');
+const Project = require('./Project');
+
+void Project;
+
+// Double stars at the start and end is the correct way to ignore directories in
+// the `glob` package.
+// https://github.com/isaacs/node-glob/issues/270#issuecomment-273949982
+// https://github.com/isaacs/node-glob/blob/f5a57d3d6e19b324522a3fa5bdd5075fd1aa79d1/common.js#L222-L231
+const ignoredDirsGlobs = ['**/elm-stuff/**', '**/node_modules/**'];
+
+function resolveGlobs(
+  fileGlobs /*: Array<string> */,
+  projectRootDir /*: string */
+) /*: Array<string> */ {
+  return Array.from(
+    new Set(
+      fileGlobs.flatMap((fileGlob) => {
+        const absolutePath = path.resolve(fileGlob);
+        try {
+          const stat = fs.statSync(absolutePath);
+          // If the CLI arg exists…
+          return stat.isDirectory()
+            ? // …and it’s a directory, find all .elm files in there…
+              findAllElmFilesInDir(absolutePath)
+            : // …otherwise use it as-is.
+              [absolutePath];
+        } catch (error) {
+          // If the CLI arg does not exist…
+          return error.code === 'ENOENT'
+            ? // …resolve it as a glob for shells that don’t support globs.
+              resolveCliArgGlob(absolutePath, projectRootDir)
+            : // The glob package ignores other types of stat errors.
+              [];
+        }
+      })
+    ),
+    // The `glob` package returns absolute paths with slashes always, even on
+    // Windows. All other paths in elm-test use the native directory separator
+    // so normalize here.
+    (filePath) => path.normalize(filePath)
+  );
+}
+
+function resolveCliArgGlob(
+  fileGlob /*: string */,
+  projectRootDir /*: string */
+) /*: Array<string> */ {
+  // Globs passed as CLI arguments are relative to CWD, while elm-test
+  // operates from the project root dir.
+  const globRelativeToProjectRoot = path.relative(
+    projectRootDir,
+    path.resolve(fileGlob)
+  );
+
+  // glob@8 (via minimatch@5) had a breaking change where you _have_ to use
+  // forwards slash as path separator, regardless of platform, making it
+  // unambiguous which characters are separators and which are escapes. This
+  // restores the previous behavior, avoiding a breaking change in elm-test.
+  // Note: As far I can tell, escaping glob syntax has _never_ worked on
+  // Windows. In Elm, needing to escape glob syntax should be very rare, since
+  // Elm file paths must match the module name (letters only). So it’s probably
+  // more worth supporting `some\folder\*Test.elm` rather than escaping.
+  // https://github.com/isaacs/node-glob/issues/468
+  // https://github.com/isaacs/minimatch/commit/9104d8d175bdd8843338103be1401f80774d2a10#diff-f41746899d033115e03bebe4fbde76acf2de4bf261bfb221744808f4c8a286cf
+  const pattern =
+    process.platform === 'win32'
+      ? globRelativeToProjectRoot.replace(/\\/g, '/')
+      : globRelativeToProjectRoot;
+
+  return glob
+    .sync(pattern, {
+      cwd: projectRootDir,
+      nocase: true,
+      absolute: true,
+      ignore: ignoredDirsGlobs,
+      // Match directories as well and mark them with a trailing slash.
+      nodir: false,
+      mark: true,
+    })
+    .flatMap((filePath) =>
+      filePath.endsWith('/') ? findAllElmFilesInDir(filePath) : filePath
+    );
+}
+
+// Recursively search for *.elm files.
+function findAllElmFilesInDir(dir /*: string */) /*: Array<string> */ {
+  return glob.sync('**/*.elm', {
+    cwd: dir,
+    nocase: true,
+    absolute: true,
+    ignore: ignoredDirsGlobs,
+    nodir: true,
+  });
+}
+
+function findTests(
+  testFilePaths /*: Array<string> */,
+  project /*: typeof Project.Project */
+) /*: Promise<Array<{ moduleName: string, possiblyTests: Array<string> }>> */ {
+  return Promise.all(
+    testFilePaths.map((filePath) => {
+      const matchingSourceDirs = project.testsSourceDirs.filter((dir) =>
+        filePath.startsWith(`${dir}${path.sep}`)
+      );
+
+      // Tests must be in tests/ or in source-directories – otherwise they won’t
+      // compile. Elm won’t be able to find imports.
+      switch (matchingSourceDirs.length) {
+        case 0:
+          return Promise.reject(
+            Error(
+              missingSourceDirectoryError(
+                filePath,
+                project.elmJson.type === 'package'
+              )
+            )
+          );
+
+        case 1:
+          // Keep going.
+          break;
+
+        default:
+          // This shouldn’t be possible for package projects.
+          return Promise.reject(
+            new Error(
+              multipleSourceDirectoriesError(
+                filePath,
+                matchingSourceDirs,
+                project.testsDir
+              )
+            )
+          );
+      }
+
+      // By finding the module name from the file path we can import it even if
+      // the file is full of errors. Elm will then report what’s wrong.
+      const moduleNameParts = path
+        .relative(matchingSourceDirs[0], filePath)
+        .replace(/\.elm$/, '')
+        .split(path.sep);
+      const moduleName = moduleNameParts.join('.');
+
+      if (!moduleNameParts.every(Parser.isUpperName)) {
+        return Promise.reject(
+          new Error(
+            badModuleNameError(filePath, matchingSourceDirs[0], moduleName)
+          )
+        );
+      }
+
+      return Parser.extractExposedPossiblyTests(
+        filePath,
+        // We’re reading files asynchronously in a loop here, so it makes sense
+        // to use graceful-fs to avoid “too many open files” errors.
+        gracefulFs.createReadStream
+      ).then((possiblyTests) => ({
+        moduleName,
+        possiblyTests,
+      }));
+    })
+  );
+}
+
+function missingSourceDirectoryError(filePath, isPackageProject) {
+  return `
+This file:
+
+${filePath}
+
+…matches no source directory! Imports won't work then.
+
+${
+  isPackageProject
+    ? 'Move it to tests/ or src/ in your project root.'
+    : 'Move it to tests/ in your project root, or make sure it is covered by "source-directories" in your elm.json.'
+}
+  `.trim();
+}
+
+function multipleSourceDirectoriesError(
+  filePath,
+  matchingSourceDirs,
+  testsDir
+) {
+  const note = matchingSourceDirs.includes(testsDir)
+    ? "Note: The tests/ folder counts as a source directory too (even if it isn't listed in your elm.json)!"
+    : '';
+
+  return `
+This file:
+
+${filePath}
+
+…matches more than one source directory:
+
+${matchingSourceDirs.join('\n')}
+
+Edit "source-directories" in your elm.json and try to make it so no source directory contains another source directory!
+
+${note}
+  `.trim();
+}
+
+function badModuleNameError(filePath, sourceDir, moduleName) {
+  return `
+This file:
+
+${filePath}
+
+…located in this directory:
+
+${sourceDir}
+
+…is problematic. Trying to construct a module name from the parts after the directory gives:
+
+${moduleName}
+
+…but module names need to look like for example:
+
+Main
+Http.Helpers
+
+Make sure that all parts start with an uppercase letter and don't contain any spaces or anything like that.
+  `.trim();
+}
+
+function noFilesFoundError(
+  projectRootDir /*: string */,
+  testFileGlobs /*: Array<string> */
+) /*: string */ {
+  return testFileGlobs.length === 0
+    ? `
+${noFilesFoundInTestsDir(projectRootDir)}
+
+To generate some initial tests to get things going: elm-test init
+
+Alternatively, if your project has tests in a different directory,
+try calling elm-test with a glob such as: elm-test "src/**/*Tests.elm"
+      `.trim()
+    : `
+No files found matching:
+
+${testFileGlobs.join('\n')}
+
+Are the above patterns correct? Maybe try running elm-test with no arguments?
+      `.trim();
+}
+
+function noFilesFoundInTestsDir(projectRootDir) {
+  const testsDir = path.join(projectRootDir, 'tests');
+  try {
+    const stats = fs.statSync(testsDir);
+    return stats.isDirectory()
+      ? 'No .elm files found in the tests/ directory.'
+      : `Expected a directory but found something else at: ${testsDir}\nCheck it out! Could you remove it?`;
+  } catch (error) {
+    return error.code === 'ENOENT'
+      ? 'The tests/ directory does not exist.'
+      : `Failed to read the tests/ directory: ${error.message}`;
+  }
+}
+
+module.exports = {
+  findTests,
+  ignoredDirsGlobs,
+  noFilesFoundError,
+  resolveGlobs,
+};

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

@@ -0,0 +1,294 @@
+// @flow
+
+const { supportsColor } = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const DependencyProvider = require('./DependencyProvider.js');
+const ElmJson = require('./ElmJson');
+const Project = require('./Project');
+const Report = require('./Report');
+const Solve = require('./Solve');
+
+// These values are used _only_ in flow types. 'use' them with the javascript
+// void operator to keep eslint happy.
+void DependencyProvider;
+void Project;
+void Report;
+
+const before = fs.readFileSync(
+  path.join(__dirname, '..', 'templates', 'before.js'),
+  'utf8'
+);
+
+const after = fs.readFileSync(
+  path.join(__dirname, '..', 'templates', 'after.js'),
+  'utf8'
+);
+
+function prepareCompiledJsFile(
+  pipeFilename /*: string */,
+  dest /*: string */
+) /*: void */ {
+  const content = fs.readFileSync(dest, 'utf8');
+  const finalContent = `
+${before}
+var Elm = (function(module) {
+${addKernelTestChecking(content)}
+return this.Elm;
+})({});
+var pipeFilename = ${JSON.stringify(pipeFilename)};
+${after}
+  `.trim();
+  fs.writeFileSync(dest, finalContent);
+
+  // Needed when the user has `"type": "module"` in their package.json.
+  // Our output is CommonJS.
+  fs.writeFileSync(
+    path.join(path.dirname(dest), 'package.json'),
+    JSON.stringify({ type: 'commonjs' })
+  );
+}
+
+// For older versions of elm-explorations/test we need to list every single
+// variant of the `Test` type. To avoid having to update this regex if a new
+// variant is added, newer versions of elm-explorations/test have prefixed all
+// variants with `ElmTestVariant__` so we can match just on that.
+const testVariantDefinition =
+  /^var\s+\$elm_explorations\$test\$Test\$Internal\$(?:ElmTestVariant__\w+|UnitTest|FuzzTest|Labeled|Skipped|Only|Batch)\s*=\s*(?:\w+\(\s*)?function\s*\([\w, ]*\)\s*\{\s*return *\{/gm;
+
+const checkDefinition =
+  /^(var\s+\$author\$project\$Test\$Runner\$Node\$check)\s*=\s*\$author\$project\$Test\$Runner\$Node\$checkHelperReplaceMe___;?$/m;
+
+// Create a symbol, tag all `Test` constructors with it and make the `check`
+// function look for it.
+function addKernelTestChecking(content) {
+  return (
+    'var __elmTestSymbol = Symbol("elmTestSymbol");\n' +
+    content
+      .replace(testVariantDefinition, '$&__elmTestSymbol: __elmTestSymbol, ')
+      .replace(
+        checkDefinition,
+        '$1 = value => value && value.__elmTestSymbol === __elmTestSymbol ? $elm$core$Maybe$Just(value) : $elm$core$Maybe$Nothing;'
+      )
+  );
+}
+
+function getGeneratedSrcDir(generatedCodeDir /*: string */) /*: string */ {
+  return path.join(generatedCodeDir, 'src');
+}
+
+function generateElmJson(
+  dependencyProvider /*: DependencyProvider */,
+  project /*: typeof Project.Project */
+) /*: void */ {
+  const generatedSrc = getGeneratedSrcDir(project.generatedCodeDir);
+
+  fs.mkdirSync(generatedSrc, { recursive: true });
+
+  const sourceDirs = [
+    // Include the generated test application.
+    generatedSrc,
+
+    // NOTE: we must include node-test-runner's Elm source as a source-directory
+    // instead of adding it as a dependency so that it can include port modules
+    path.join(__dirname, '..', 'elm', 'src'),
+  ]
+    .concat(project.testsSourceDirs)
+    .filter(
+      // When running node-test-runner's own test suite, the node-test-runner/src folder
+      // will get added twice: once because it's the source-directory of the packge being tested,
+      // and once because elm-test will always add it.
+      // To prevent elm from being confused, we need to remove the duplicate when this happens.
+      (value, index, self) => self.indexOf(value) === index
+    )
+    .map((absolutePath) =>
+      // Relative paths have the nice benefit that if the user moves their
+      // directory, this doesn't break.
+      path.relative(project.generatedCodeDir, absolutePath)
+    );
+
+  const testElmJson = {
+    type: 'application',
+    'source-directories': sourceDirs,
+    'elm-version': '0.19.1',
+    dependencies: Solve.getDependenciesCached(dependencyProvider, project),
+    'test-dependencies': {
+      direct: {},
+      indirect: {},
+    },
+  };
+
+  // Generate the new elm.json, if necessary.
+  const generatedContents = JSON.stringify(testElmJson, null, 4);
+  const generatedPath = ElmJson.getPath(project.generatedCodeDir);
+
+  // Don't write a fresh elm.json if it's going to be the same. If we do,
+  // it will update the timestamp on the file, which will cause `elm make`
+  // to do a bunch of unnecessary work.
+  if (
+    !fs.existsSync(generatedPath) ||
+    generatedContents !== fs.readFileSync(generatedPath, 'utf8')
+  ) {
+    // package projects don't explicitly list their transitive dependencies,
+    // to we have to figure out what they are.  We write the elm.json that
+    // we have so far, and run elm to see what it thinks is missing.
+    fs.writeFileSync(generatedPath, generatedContents);
+  }
+}
+
+function getMainModule(generatedCodeDir /*: string */) /*: {
+  moduleName: string,
+  path: string,
+} */ {
+  const moduleName = ['Test', 'Generated', 'Main'];
+  return {
+    moduleName: moduleName.join('.'),
+    path:
+      // We'll be putting the generated Main in something like this:
+      //
+      // my-project-name/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revisionX/src/Test/Generated/Main.elm
+      path.join(getGeneratedSrcDir(generatedCodeDir), ...moduleName) + '.elm',
+  };
+}
+
+function generateMainModule(
+  fuzz /*: number */,
+  seed /*: number */,
+  report /*: typeof Report.Report */,
+  testFileGlobs /*: Array<string> */,
+  testFilePaths /*: Array<string> */,
+  testModules /*: Array<{
+    moduleName: string,
+    possiblyTests: Array<string>,
+  }> */,
+  mainModule /*: { moduleName: string, path: string } */,
+  processes /*: number */
+) /*: void */ {
+  const testFileBody = makeTestFileBody(
+    testModules,
+    makeOptsCode(fuzz, seed, report, testFileGlobs, testFilePaths, processes)
+  );
+
+  const testFileContents = `module ${mainModule.moduleName} exposing (main)\n\n${testFileBody}`;
+
+  fs.mkdirSync(path.dirname(mainModule.path), { recursive: true });
+
+  fs.writeFileSync(mainModule.path, testFileContents);
+}
+
+function makeTestFileBody(
+  testModules /*: Array<{
+    moduleName: string,
+    possiblyTests: Array<string>,
+  }> */,
+  optsCode /*: string */
+) /*: string */ {
+  const imports = testModules.map((mod) => `import ${mod.moduleName}`);
+
+  const possiblyTestsList = makeList(testModules.map(makeModuleTuple));
+
+  return `
+${imports.join('\n')}
+
+import Test.Reporter.Reporter exposing (Report(..))
+import Console.Text exposing (UseColor(..))
+import Test.Runner.Node
+import Test
+
+main : Test.Runner.Node.TestProgram
+main =
+    Test.Runner.Node.run
+        ${indentAllButFirstLine('        ', optsCode)}
+        ${indentAllButFirstLine('        ', possiblyTestsList)}
+  `.trim();
+}
+
+function makeModuleTuple(mod /*: {
+  moduleName: string,
+  possiblyTests: Array<string>,
+} */) /*: string */ {
+  const list = mod.possiblyTests.map(
+    (test) => `Test.Runner.Node.check ${mod.moduleName}.${test}`
+  );
+
+  return `
+( "${mod.moduleName}"
+, ${indentAllButFirstLine('  ', makeList(list))}
+)
+  `.trim();
+}
+
+function makeList(parts /*: Array<string> */) /*: string */ {
+  if (parts.length === 0) {
+    return '[]';
+  }
+
+  const list = parts.map(
+    (part, index) =>
+      `${index === 0 ? '' : ', '}${indentAllButFirstLine('  ', part)}`
+  );
+
+  return `
+[ ${list.join('\n')}
+]
+  `.trim();
+}
+
+function indentAllButFirstLine(indent, string) {
+  return string
+    .split('\n')
+    .map((line, index) => (index === 0 ? line : indent + line))
+    .join('\n');
+}
+
+function makeOptsCode(
+  fuzz /*: number */,
+  seed /*: number */,
+  report /*: typeof Report.Report */,
+  testFileGlobs /*: Array<string> */,
+  testFilePaths /*: Array<string> */,
+  processes /*: number */
+) /*: string */ {
+  return `
+{ runs = ${fuzz}
+, report = ${generateElmReportVariant(report)}
+, seed = ${seed}
+, processes = ${processes}
+, globs =
+    ${indentAllButFirstLine('    ', makeList(testFileGlobs.map(makeElmString)))}
+, paths =
+    ${indentAllButFirstLine('    ', makeList(testFilePaths.map(makeElmString)))}
+}
+  `.trim();
+}
+
+function generateElmReportVariant(
+  report /*: typeof Report.Report */
+) /*: string */ {
+  switch (report) {
+    case 'json':
+      return 'JsonReport';
+    case 'junit':
+      return 'JUnitReport';
+    case 'console':
+      if (supportsColor) {
+        return 'ConsoleReport UseColor';
+      } else {
+        return 'ConsoleReport Monochrome';
+      }
+  }
+}
+
+function makeElmString(string) {
+  return `"${string
+    .replace(/[\\"]/g, '\\$&')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')}"`;
+}
+
+module.exports = {
+  generateElmJson,
+  generateMainModule,
+  getMainModule,
+  prepareCompiledJsFile,
+};