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

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

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 1130841854, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 3129741668, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

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

@@ -82,7 +82,7 @@ const verbosity = 0;
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 1130841854,
+  initialSeed: 3129741668,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

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

@@ -8,19 +8,21 @@
     "dependencies": {
         "direct": {
             "elm/core": "1.0.5",
+            "elm/json": "1.1.3",
             "elm-community/result-extra": "2.4.0",
-            "jfmengels/elm-review": "2.4.2",
-            "stil4m/elm-syntax": "7.2.5"
+            "jfmengels/elm-review": "2.10.0",
+            "stil4m/elm-syntax": "7.2.9"
         },
         "indirect": {
+            "elm/bytes": "1.0.8",
             "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",
+            "elm/virtual-dom": "1.0.3",
+            "elm-community/list-extra": "8.7.0",
+            "elm-explorations/test": "2.1.0",
             "miniBill/elm-unicode": "1.0.2",
             "rtfeldman/elm-hex": "1.0.0",
             "stil4m/structured-writer": "1.0.3"
@@ -28,7 +30,7 @@
     },
     "test-dependencies": {
         "direct": {
-            "elm-explorations/test": "1.2.2"
+            "elm-explorations/test": "2.1.0"
         },
         "indirect": {}
     }

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

@@ -1,37 +1,136 @@
 module Pages.Review.DeadCodeEliminateData exposing (rule)
 
+import Dict exposing (Dict)
 import Elm.Syntax.Declaration as Declaration exposing (Declaration)
+import Elm.Syntax.Exposing exposing (Exposing)
 import Elm.Syntax.Expression as Expression exposing (Expression)
+import Elm.Syntax.Import exposing (Import)
+import Elm.Syntax.ModuleName exposing (ModuleName)
 import Elm.Syntax.Node as Node exposing (Node)
+import Elm.Syntax.Range exposing (Range)
 import Review.Fix
 import Review.ModuleNameLookupTable as ModuleNameLookupTable exposing (ModuleNameLookupTable)
 import Review.Rule as Rule exposing (Error, Rule)
 
 
 type alias Context =
-    { lookupTable : ModuleNameLookupTable }
+    { lookupTable : ModuleNameLookupTable
+    , importContext : Dict (List String) ImportContext
+    , firstImport : Maybe Range
+    }
+
+
+type ImportReference
+    = QualifiedReference
+    | UnqualifiedReference (List String)
+
+
+type alias ImportContext =
+    { moduleName : ModuleName
+    , moduleAlias : Maybe ModuleName
+    , exposedFunctions : Exposed
+
+    --Maybe Exposing
+    }
+
+
+type Exposed
+    = AllExposed
+    | SomeExposed (List String)
+
+
+toImportContext : Import -> ( List String, ImportContext )
+toImportContext import_ =
+    ( import_.moduleName |> Node.value
+    , { moduleName = import_.moduleName |> Node.value
+      , moduleAlias = import_.moduleAlias |> Maybe.map Node.value
+      , exposedFunctions =
+            import_.exposingList
+                |> Maybe.map Node.value
+                |> Maybe.map
+                    (\exposingList ->
+                        case exposingList of
+                            Elm.Syntax.Exposing.All _ ->
+                                AllExposed
+
+                            Elm.Syntax.Exposing.Explicit nodes ->
+                                AllExposed
+                    )
+                |> Maybe.withDefault (SomeExposed [])
+      }
+    )
 
 
 rule : Rule
 rule =
     Rule.newModuleRuleSchemaUsingContextCreator "Pages.Review.DeadCodeEliminateData" initialContext
+        |> Rule.providesFixesForModuleRule
         |> Rule.withExpressionEnterVisitor expressionVisitor
         |> Rule.withDeclarationEnterVisitor declarationVisitor
+        |> Rule.withImportVisitor importVisitor
+        |> Rule.withFinalModuleEvaluation finalEvaluation
         |> Rule.fromModuleRuleSchema
 
 
+finalEvaluation : Context -> List (Rule.Error {})
+finalEvaluation context =
+    case Dict.get [ "FatalError" ] context.importContext of
+        Nothing ->
+            let
+                importAddRange : { start : { row : Int, column : Int }, end : { row : Int, column : Int } }
+                importAddRange =
+                    context.firstImport |> Maybe.withDefault { start = { row = 0, column = 0 }, end = { row = 0, column = 0 } }
+            in
+            [ Rule.errorWithFix
+                { message = "Codemod"
+                , details = [ "" ]
+                }
+                importAddRange
+                [ Review.Fix.insertAt importAddRange.end "\nimport FatalError\n"
+                ]
+            ]
+
+        _ ->
+            []
+
+
 initialContext : Rule.ContextCreator () Context
 initialContext =
     Rule.initContextCreator
         (\lookupTable () ->
             { lookupTable = lookupTable
+            , importContext = Dict.empty
+            , firstImport = Nothing
             }
         )
         |> Rule.withModuleNameLookupTable
 
 
+importVisitor : Node Import -> Context -> ( List (Rule.Error {}), Context )
+importVisitor node context =
+    let
+        ( key, value ) =
+            Node.value node
+                |> toImportContext
+    in
+    ( []
+    , { context
+        | importContext =
+            context.importContext |> Dict.insert key value
+        , firstImport = context.firstImport |> Maybe.withDefault (Node.range node) |> Just
+      }
+    )
+
+
 declarationVisitor : Node Declaration -> Context -> ( List (Error {}), Context )
 declarationVisitor node context =
+    let
+        exceptionFromString : String
+        exceptionFromString =
+            "("
+                ++ referenceFunction context.importContext ( [ "FatalError" ], "fromString" )
+                ++ " \"\")"
+    in
     case Node.value node of
         Declaration.FunctionDeclaration { declaration } ->
             case Node.value declaration of
@@ -47,7 +146,7 @@ declarationVisitor node context =
                                                 case Node.value recordSetter of
                                                     ( keyNode, valueNode ) ->
                                                         if Node.value keyNode == "data" || Node.value keyNode == "action" then
-                                                            if isAlreadyApplied (Node.value valueNode) then
+                                                            if isAlreadyApplied context.lookupTable (Node.value valueNode) then
                                                                 Nothing
 
                                                             else
@@ -66,9 +165,15 @@ declarationVisitor node context =
                                                 , 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    "
+                                                [ ("data = "
+                                                    ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                    -- TODO add `import FatalError` if not present (and use alias if present)
+                                                    ++ " "
+                                                    ++ exceptionFromString
+                                                    ++ "\n    "
+                                                  )
+                                                    |> Review.Fix.replaceRangeBy (Node.range dataValue)
                                                 ]
                                           ]
                                         , context
@@ -99,7 +204,7 @@ expressionVisitor node context =
                                         case Node.value recordSetter of
                                             ( keyNode, valueNode ) ->
                                                 if Node.value keyNode == "data" || Node.value keyNode == "action" then
-                                                    if isAlreadyApplied (Node.value valueNode) then
+                                                    if isAlreadyApplied context.lookupTable (Node.value valueNode) then
                                                         Nothing
 
                                                     else
@@ -112,6 +217,13 @@ expressionVisitor node context =
                     ( dataFieldValue
                         |> List.concatMap
                             (\( key, dataValue ) ->
+                                let
+                                    exceptionFromString : String
+                                    exceptionFromString =
+                                        "("
+                                            ++ referenceFunction context.importContext ( [ "FatalError" ], "fromString" )
+                                            ++ " \"\")"
+                                in
                                 [ Rule.errorWithFix
                                     { message = "Codemod"
                                     , details = [ "" ]
@@ -122,16 +234,27 @@ expressionVisitor node context =
                                             ++ " = "
                                             ++ (case pageBuilderName of
                                                     "preRender" ->
-                                                        "\\_ -> DataSource.fail \"\""
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                            ++ " "
+                                                            ++ exceptionFromString
 
                                                     "preRenderWithFallback" ->
-                                                        "\\_ -> DataSource.fail \"\""
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                            ++ " "
+                                                            ++ exceptionFromString
 
                                                     "serverRender" ->
-                                                        "\\_ -> Request.oneOf []\n        "
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "Server", "Request" ], "oneOf" )
+                                                            ++ " []\n        "
 
                                                     "single" ->
-                                                        "DataSource.fail \"\"\n       "
+                                                        referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                            ++ " "
+                                                            ++ exceptionFromString
+                                                            ++ "\n       "
 
                                                     _ ->
                                                         "data"
@@ -150,18 +273,56 @@ expressionVisitor node context =
             ( [], context )
 
 
-isAlreadyApplied : Expression -> Bool
-isAlreadyApplied expression =
+referenceFunction : Dict (List String) ImportContext -> ( List String, String ) -> String
+referenceFunction dict ( rawModuleName, rawFunctionName ) =
+    let
+        ( moduleName, functionName ) =
+            case dict |> Dict.get rawModuleName of
+                Just import_ ->
+                    ( import_.moduleAlias |> Maybe.withDefault rawModuleName
+                    , rawFunctionName
+                    )
+
+                Nothing ->
+                    ( rawModuleName, rawFunctionName )
+    in
+    moduleName ++ [ functionName ] |> String.join "."
+
+
+isAlreadyApplied : ModuleNameLookupTable -> Expression -> Bool
+isAlreadyApplied lookupTable 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 _ "fail") :: _ ->
+                            let
+                                resolvedModuleName : ModuleName
+                                resolvedModuleName =
+                                    applicationNodes
+                                        |> List.head
+                                        |> Maybe.andThen
+                                            (\functionNode ->
+                                                ModuleNameLookupTable.moduleNameFor lookupTable functionNode
+                                            )
+                                        |> Maybe.withDefault []
+                            in
+                            resolvedModuleName == [ "BackendTask" ]
 
-                        (Expression.FunctionOrValue [ "Request" ] "oneOf") :: (Expression.ListExpr []) :: _ ->
-                            True
+                        (Expression.FunctionOrValue _ "oneOf") :: (Expression.ListExpr []) :: _ ->
+                            let
+                                resolvedModuleName : ModuleName
+                                resolvedModuleName =
+                                    applicationNodes
+                                        |> List.head
+                                        |> Maybe.andThen
+                                            (\functionNode ->
+                                                ModuleNameLookupTable.moduleNameFor lookupTable functionNode
+                                            )
+                                        |> Maybe.withDefault []
+                            in
+                            resolvedModuleName == [ "Server", "Request" ]
 
                         _ ->
                             False
@@ -171,8 +332,19 @@ isAlreadyApplied expression =
 
         Expression.Application applicationNodes ->
             case applicationNodes |> List.map Node.value of
-                (Expression.FunctionOrValue [ "DataSource" ] "fail") :: _ ->
-                    True
+                (Expression.FunctionOrValue _ "fail") :: _ ->
+                    let
+                        resolvedModuleName : ModuleName
+                        resolvedModuleName =
+                            applicationNodes
+                                |> List.head
+                                |> Maybe.andThen
+                                    (\functionNode ->
+                                        ModuleNameLookupTable.moduleNameFor lookupTable functionNode
+                                    )
+                                |> Maybe.withDefault []
+                    in
+                    resolvedModuleName == [ "BackendTask" ]
 
                 _ ->
                     False