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

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -0,0 +1,110 @@
+const { parentPort } = require("worker_threads");
+const { performance } = require("perf_hooks");
+
+// From templates/polyfills.js
+// Apply Node polyfills as necessary.
+var window = {
+  Date: Date,
+  addEventListener: function () {},
+  removeEventListener: function () {},
+};
+
+var location = {
+  href: "",
+  host: "",
+  hostname: "",
+  protocol: "",
+  origin: "",
+  port: "",
+  pathname: "",
+  search: "",
+  hash: "",
+  username: "",
+  password: "",
+};
+
+var document = {
+  body: {},
+  createTextNode: function () {},
+  location: location,
+};
+
+var oldConsoleWarn = console.warn;
+console.warn = function () {
+  if (
+    arguments.length === 1 &&
+    arguments[0].indexOf("Compiled in DEV mode") === 0
+  )
+    return;
+  return oldConsoleWarn.apply(console, arguments);
+};
+
+if (typeof FileList === "undefined") {
+  var FileList = function () {};
+}
+
+if (typeof File === "undefined") {
+  var File = function () {};
+}
+
+if (typeof XMLHttpRequest === "undefined") {
+  var XMLHttpRequest = function () {
+    return {
+      addEventListener: function () {},
+      open: function () {},
+      send: function () {},
+    };
+  };
+}
+
+if (typeof FormData === "undefined") {
+  var FormData = function () {
+    this._data = [];
+  };
+  FormData.prototype.append = function () {
+    this._data.push(Array.prototype.slice.call(arguments));
+  };
+}
+
+
+// Capture Debug.log from elm code
+let logs = [];
+console.elmlog = (str) => logs.push(str + "\n");
+
+// Compiled by elm-test-rs from templates/Runner.elm
+const { Elm } = require("./Runner.elm.js");
+
+// Start the Elm app
+const flags = { initialSeed: 1130841854, fuzzRuns: 100, filter: null };
+const app = Elm.Runner.init({ flags: flags });
+
+// Record the timing at which we received the last "runTest" message
+let startTime;
+
+// Communication from Supervisor to Elm runner via port
+parentPort.on("message", (msg) => {
+  if (msg.type_ == "askTestsCount") {
+    app.ports.askTestsCount.send();
+  } else if (msg.type_ == "runTest") {
+    startTime = performance.now();
+    app.ports.receiveRunTest.send(msg.id);
+  } else {
+    console.error("Invalid supervisor msg.type_:", msg.type_);
+  }
+});
+
+// Communication from Elm runner to Supervisor via port
+// Subscribe to outgoing Elm ports defined in templates/Runner.elm
+app.ports.sendResult.subscribe((msg) => {
+  msg.type_ = "testResult";
+  msg.duration = performance.now() - startTime;
+  msg.logs = logs;
+  parentPort.postMessage(msg);
+  logs.length = 0;
+});
+app.ports.sendTestsCount.subscribe((msg) => {
+  msg.type_ = "testsCount";
+  msg.logs = logs;
+  parentPort.postMessage(msg);
+  logs.length = 0;
+});

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -0,0 +1,187 @@
+process.chdir(__dirname);
+
+// From templates/polyfills.js
+// Apply Node polyfills as necessary.
+var window = {
+  Date: Date,
+  addEventListener: function () {},
+  removeEventListener: function () {},
+};
+
+var location = {
+  href: "",
+  host: "",
+  hostname: "",
+  protocol: "",
+  origin: "",
+  port: "",
+  pathname: "",
+  search: "",
+  hash: "",
+  username: "",
+  password: "",
+};
+
+var document = {
+  body: {},
+  createTextNode: function () {},
+  location: location,
+};
+
+var oldConsoleWarn = console.warn;
+console.warn = function () {
+  if (
+    arguments.length === 1 &&
+    arguments[0].indexOf("Compiled in DEV mode") === 0
+  )
+    return;
+  return oldConsoleWarn.apply(console, arguments);
+};
+
+if (typeof FileList === "undefined") {
+  var FileList = function () {};
+}
+
+if (typeof File === "undefined") {
+  var File = function () {};
+}
+
+if (typeof XMLHttpRequest === "undefined") {
+  var XMLHttpRequest = function () {
+    return {
+      addEventListener: function () {},
+      open: function () {},
+      send: function () {},
+    };
+  };
+}
+
+if (typeof FormData === "undefined") {
+  var FormData = function () {
+    this._data = [];
+  };
+  FormData.prototype.append = function () {
+    this._data.push(Array.prototype.slice.call(arguments));
+  };
+}
+
+
+const { Worker } = require("worker_threads");
+const readline = require("readline");
+const { performance } = require("perf_hooks");
+
+// Global variables
+let testsCount, todoTests;
+let reporter;
+let runners = [];
+let working = false;
+let workersCount = 2;
+let startWorkCallback = function(){};
+const verbosity = 0;
+
+// Create a long lived reporter worker
+const { Elm } = require("./Reporter.elm.js");
+const flags = {
+  initialSeed: 1130841854,
+  fuzzRuns: 100,
+  mode: "consoleNoColor",
+  verbosity: verbosity,
+  globs: [],
+  paths: ["/home/runner/work/elm-pages-v3-beta/elm-pages-v3-beta/generator/dead-code-review/tests/Pages/Review/DeadCodeEliminateDataTest.elm"],
+};
+reporter = Elm.Reporter.init({ flags: flags });
+
+// Pipe the Elm stdout port to stdout
+reporter.ports.stdout.subscribe((str) => process.stdout.write(str));
+
+// When the reporter has finished clean runners
+reporter.ports.signalFinished.subscribe(async ({ exitCode, testsCount }) => {
+  await Promise.all(runners.map((runner) => runner.terminate()));
+  working = false;
+  startWorkCallback();
+  if (verbosity >= 1) {
+    console.warn("Running duration (since Node.js start):", Math.round(performance.now()), "ms\n");
+  }
+  process.exit(exitCode);
+});
+
+// When receiving a CLI message, start test workers
+// The message is a string containing "/path/to/node_runner.js"
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (runnerFile) => {
+  working ? registerWork(runnerFile) : startWork(runnerFile);
+});
+
+function registerWork(runnerFile) {
+  startWorkCallback = () => startWork(runnerFile);
+}
+
+function startWork(runnerFile) {
+  startWorkCallback = function(){};
+  working = true;
+  // Start first runner worker and prevent piped stdout and sdterr
+  runners[0] = new Worker(runnerFile, { stdout: true }); //, stderr: true });
+  runners[0].on("message", (msg) =>
+    handleRunnerMsg(runners[0], runnerFile, msg)
+  );
+  runners[0].on("online", () =>
+    runners[0].postMessage({ type_: "askTestsCount" })
+  );
+}
+
+// Handle a test result
+function handleRunnerMsg(runner, runnerFile, msg) {
+  if (msg.type_ == "testsCount") {
+    if (msg.logs.length > 0) {
+      console.warn("Debug logs captured when setting up tests: -----------\n");
+      msg.logs.forEach((str) => process.stderr.write(str));
+      console.warn("\n------------------------------------------------------\n");
+    }
+    setupWithTestsCount(runnerFile, msg);
+  } else if (msg.type_ == "testResult") {
+    dispatchWork(runner, todoTests.pop());
+    reporter.ports.incomingResult.send(msg);
+  } else {
+    console.error("Invalid runner msg.type_:", msg.type_);
+  }
+}
+
+// Reset supervisor tests count and reporter
+// Start work on all runners
+function setupWithTestsCount(runnerFile, msg) {
+  // Reset supervisor tests
+  testsCount = msg.testsCount;
+  todoTests = Array(testsCount)
+    .fill(0)
+    .map((_, id) => id)
+    .reverse();
+
+  // Reset reporter
+  reporter.ports.restart.send(msg);
+
+  // Send first runner job
+  if (testsCount == 0) {
+    console.error("No exposed values of type Test was found. Did you forget to expose them?");
+    return;
+  } else {
+    runners[0].postMessage({ type_: "runTest", id: todoTests.pop() });
+  }
+
+  // Create and send work to all other workers.
+  let max_workers = Math.min(workersCount, testsCount);
+  for (let i = 1; i < max_workers; i++) {
+    let runner = new Worker(runnerFile); //, { stdout: true, stderr: true });
+    runners[i] = runner;
+    runner.on("message", (msg) =>
+      handleRunnerMsg(runner, runnerFile, msg)
+    );
+    runner.on("online", () => dispatchWork(runner, todoTests.pop()));
+  }
+}
+
+// Ask runner to run some test.
+function dispatchWork(runner, testId) {
+  if (testId != undefined) {
+    runner.postMessage({ type_: "runTest", id: testId });
+  }
+}

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/generator/dead-code-review/elm-stuff/tests-0.19.1/src/Reporter.elm

@@ -0,0 +1,26 @@
+port module Reporter exposing (main)
+
+import ElmTestRunner.Reporter exposing (Flags, Model, Msg)
+import Json.Decode exposing (Value)
+
+
+port restart : ({ kind : String, testsCount : Int } -> msg) -> Sub msg
+
+
+port incomingResult : ({ duration : Float, result : Value, logs : List String } -> msg) -> Sub msg
+
+
+port signalFinished : { exitCode : Int, testsCount : Int } -> Cmd msg
+
+
+port stdout : String -> Cmd msg
+
+
+main : Program Flags Model Msg
+main =
+    ElmTestRunner.Reporter.worker
+        { restart = restart
+        , incomingResult = incomingResult
+        , stdout = stdout
+        , signalFinished = signalFinished
+        }

package/generator/dead-code-review/elm-stuff/tests-0.19.1/src/Runner.elm

@@ -0,0 +1,62 @@
+port module Runner exposing (main)
+
+import Pages.Review.DeadCodeEliminateDataTest
+
+import ElmTestRunner.Runner exposing (Flags, Model, Msg)
+import Json.Encode exposing (Value)
+import Test exposing (Test)
+
+
+port askTestsCount : (Value -> msg) -> Sub msg
+
+
+port sendTestsCount : { kind : String, testsCount : Int } -> Cmd msg
+
+
+port receiveRunTest : (Int -> msg) -> Sub msg
+
+
+port sendResult : { id : Int, result : Value } -> Cmd msg
+
+
+{-| The implementation of this function will be replaced in the generated JS
+with a version that returns `Just value` if `value` is a `Test`, otherwise `Nothing`.
+If you rename or change this function you also need to update the regex that looks for it.
+-}
+check : a -> Maybe Test
+check =
+    checkHelperReplaceMe___
+
+
+checkHelperReplaceMe___ : a -> b
+checkHelperReplaceMe___ _ =
+    Debug.todo """The regex for replacing this Debug.todo with some real code must have failed since you see this message!
+
+Please report this bug: https://github.com/mpizenberg/elm-test-rs/issues/new
+"""
+
+
+tests : List Test
+tests =
+    [ check Pages.Review.DeadCodeEliminateDataTest.all ]
+        |> List.filterMap identity
+
+
+main : Program Flags Model Msg
+main =
+    let
+        concatenatedTest =
+            case tests of
+                [] ->
+                    Nothing
+
+                _ ->
+                    Just (Test.concat tests)
+    in
+    concatenatedTest
+        |> ElmTestRunner.Runner.worker
+            { askTestsCount = askTestsCount
+            , sendTestsCount = sendTestsCount
+            , receiveRunTest = receiveRunTest
+            , sendResult = sendResult
+            }

package/generator/dead-code-review/elm.json

@@ -0,0 +1,35 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src",
+        "../../src"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "elm/core": "1.0.5",
+            "elm-community/result-extra": "2.4.0",
+            "jfmengels/elm-review": "2.4.2",
+            "stil4m/elm-syntax": "7.2.5"
+        },
+        "indirect": {
+            "elm/html": "1.0.0",
+            "elm/json": "1.1.3",
+            "elm/parser": "1.1.0",
+            "elm/project-metadata-utils": "1.0.2",
+            "elm/random": "1.0.0",
+            "elm/time": "1.0.0",
+            "elm/virtual-dom": "1.0.2",
+            "elm-community/list-extra": "8.3.0",
+            "miniBill/elm-unicode": "1.0.2",
+            "rtfeldman/elm-hex": "1.0.0",
+            "stil4m/structured-writer": "1.0.3"
+        }
+    },
+    "test-dependencies": {
+        "direct": {
+            "elm-explorations/test": "1.2.2"
+        },
+        "indirect": {}
+    }
+}

package/generator/dead-code-review/src/Pages/Review/DeadCodeEliminateData.elm

@@ -0,0 +1,181 @@
+module Pages.Review.DeadCodeEliminateData exposing (rule)
+
+import Elm.Syntax.Declaration as Declaration exposing (Declaration)
+import Elm.Syntax.Expression as Expression exposing (Expression)
+import Elm.Syntax.Node as Node exposing (Node)
+import Review.Fix
+import Review.ModuleNameLookupTable as ModuleNameLookupTable exposing (ModuleNameLookupTable)
+import Review.Rule as Rule exposing (Error, Rule)
+
+
+type alias Context =
+    { lookupTable : ModuleNameLookupTable }
+
+
+rule : Rule
+rule =
+    Rule.newModuleRuleSchemaUsingContextCreator "Pages.Review.DeadCodeEliminateData" initialContext
+        |> Rule.withExpressionEnterVisitor expressionVisitor
+        |> Rule.withDeclarationEnterVisitor declarationVisitor
+        |> Rule.fromModuleRuleSchema
+
+
+initialContext : Rule.ContextCreator () Context
+initialContext =
+    Rule.initContextCreator
+        (\lookupTable () ->
+            { lookupTable = lookupTable
+            }
+        )
+        |> Rule.withModuleNameLookupTable
+
+
+declarationVisitor : Node Declaration -> Context -> ( List (Error {}), Context )
+declarationVisitor node context =
+    case Node.value node of
+        Declaration.FunctionDeclaration { declaration } ->
+            case Node.value declaration of
+                { name, expression } ->
+                    case ( Node.value name, Node.value expression ) of
+                        ( "template", Expression.RecordExpr setters ) ->
+                            let
+                                dataFieldValue : Maybe (Node ( Node String, Node Expression ))
+                                dataFieldValue =
+                                    setters
+                                        |> List.filterMap
+                                            (\recordSetter ->
+                                                case Node.value recordSetter of
+                                                    ( keyNode, valueNode ) ->
+                                                        if Node.value keyNode == "data" || Node.value keyNode == "action" then
+                                                            if isAlreadyApplied (Node.value valueNode) then
+                                                                Nothing
+
+                                                            else
+                                                                recordSetter |> Just
+
+                                                        else
+                                                            Nothing
+                                            )
+                                        |> List.head
+                            in
+                            dataFieldValue
+                                |> Maybe.map
+                                    (\dataValue ->
+                                        ( [ Rule.errorWithFix
+                                                { message = "Codemod"
+                                                , details = [ "" ]
+                                                }
+                                                (Node.range dataValue)
+                                                -- TODO need to check the right way to refer to `DataSource.fail` based on imports
+                                                -- TODO need to replace `action` as well
+                                                [ Review.Fix.replaceRangeBy (Node.range dataValue) "data = DataSource.fail \"\"\n    "
+                                                ]
+                                          ]
+                                        , context
+                                        )
+                                    )
+                                |> Maybe.withDefault
+                                    ( [], context )
+
+                        _ ->
+                            ( [], context )
+
+        _ ->
+            ( [], context )
+
+
+expressionVisitor : Node Expression -> Context -> ( List (Error {}), Context )
+expressionVisitor node context =
+    case Node.value node of
+        Expression.Application applicationExpressions ->
+            case applicationExpressions |> List.map (\applicationNode -> ( ModuleNameLookupTable.moduleNameFor context.lookupTable applicationNode, Node.value applicationNode )) of
+                [ ( Just [ "RouteBuilder" ], Expression.FunctionOrValue _ pageBuilderName ), ( _, Expression.RecordExpr fields ) ] ->
+                    let
+                        dataFieldValue : List ( String, Node ( Node String, Node Expression ) )
+                        dataFieldValue =
+                            fields
+                                |> List.filterMap
+                                    (\recordSetter ->
+                                        case Node.value recordSetter of
+                                            ( keyNode, valueNode ) ->
+                                                if Node.value keyNode == "data" || Node.value keyNode == "action" then
+                                                    if isAlreadyApplied (Node.value valueNode) then
+                                                        Nothing
+
+                                                    else
+                                                        ( Node.value keyNode, recordSetter ) |> Just
+
+                                                else
+                                                    Nothing
+                                    )
+                    in
+                    ( dataFieldValue
+                        |> List.concatMap
+                            (\( key, dataValue ) ->
+                                [ Rule.errorWithFix
+                                    { message = "Codemod"
+                                    , details = [ "" ]
+                                    }
+                                    (Node.range dataValue)
+                                    [ Review.Fix.replaceRangeBy (Node.range dataValue)
+                                        (key
+                                            ++ " = "
+                                            ++ (case pageBuilderName of
+                                                    "preRender" ->
+                                                        "\\_ -> DataSource.fail \"\""
+
+                                                    "preRenderWithFallback" ->
+                                                        "\\_ -> DataSource.fail \"\""
+
+                                                    "serverRender" ->
+                                                        "\\_ -> Request.oneOf []\n        "
+
+                                                    "single" ->
+                                                        "DataSource.fail \"\"\n       "
+
+                                                    _ ->
+                                                        "data"
+                                               )
+                                        )
+                                    ]
+                                ]
+                            )
+                    , context
+                    )
+
+                _ ->
+                    ( [], context )
+
+        _ ->
+            ( [], context )
+
+
+isAlreadyApplied : Expression -> Bool
+isAlreadyApplied expression =
+    case expression of
+        Expression.LambdaExpression info ->
+            case Node.value info.expression of
+                Expression.Application applicationNodes ->
+                    case applicationNodes |> List.map Node.value of
+                        (Expression.FunctionOrValue [ "DataSource" ] "fail") :: _ ->
+                            True
+
+                        (Expression.FunctionOrValue [ "Request" ] "oneOf") :: (Expression.ListExpr []) :: _ ->
+                            True
+
+                        _ ->
+                            False
+
+                _ ->
+                    False
+
+        Expression.Application applicationNodes ->
+            case applicationNodes |> List.map Node.value of
+                (Expression.FunctionOrValue [ "DataSource" ] "fail") :: _ ->
+                    True
+
+                _ ->
+                    False
+
+        _ ->
+            False

package/generator/dead-code-review/src/ReviewConfig.elm

@@ -0,0 +1,9 @@
+module ReviewConfig exposing (config)
+
+import Pages.Review.DeadCodeEliminateData
+import Review.Rule as Rule exposing (Rule)
+
+
+config : List Rule
+config =
+    [ Pages.Review.DeadCodeEliminateData.rule ]