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

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

@@ -1,7 +1,11 @@
 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 Review.Fix
 import Review.ModuleNameLookupTable as ModuleNameLookupTable exposing (ModuleNameLookupTable)
@@ -9,7 +13,50 @@ import Review.Rule as Rule exposing (Error, Rule)
 
 
 type alias Context =
-    { lookupTable : ModuleNameLookupTable }
+    { lookupTable : ModuleNameLookupTable
+    , importContext : Dict (List String) ImportContext
+    }
+
+
+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
@@ -17,6 +64,7 @@ rule =
     Rule.newModuleRuleSchemaUsingContextCreator "Pages.Review.DeadCodeEliminateData" initialContext
         |> Rule.withExpressionEnterVisitor expressionVisitor
         |> Rule.withDeclarationEnterVisitor declarationVisitor
+        |> Rule.withImportVisitor importVisitor
         |> Rule.fromModuleRuleSchema
 
 
@@ -25,11 +73,27 @@ initialContext =
     Rule.initContextCreator
         (\lookupTable () ->
             { lookupTable = lookupTable
+            , importContext = Dict.empty
             }
         )
         |> 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
+      }
+    )
+
+
 declarationVisitor : Node Declaration -> Context -> ( List (Error {}), Context )
 declarationVisitor node context =
     case Node.value node of
@@ -47,7 +111,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 +130,12 @@ 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 ( [ "DataSource" ], "fail" )
+                                                    ++ " \"\"\n    "
+                                                  )
+                                                    |> Review.Fix.replaceRangeBy (Node.range dataValue)
                                                 ]
                                           ]
                                         , context
@@ -99,7 +166,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
@@ -122,16 +189,23 @@ expressionVisitor node context =
                                             ++ " = "
                                             ++ (case pageBuilderName of
                                                     "preRender" ->
-                                                        "\\_ -> DataSource.fail \"\""
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "DataSource" ], "fail" )
+                                                            ++ " \"\""
 
                                                     "preRenderWithFallback" ->
-                                                        "\\_ -> DataSource.fail \"\""
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "DataSource" ], "fail" )
+                                                            ++ " \"\""
 
                                                     "serverRender" ->
-                                                        "\\_ -> Request.oneOf []\n        "
+                                                        "\\_ -> "
+                                                            ++ referenceFunction context.importContext ( [ "Server", "Request" ], "oneOf" )
+                                                            ++ " []\n        "
 
                                                     "single" ->
-                                                        "DataSource.fail \"\"\n       "
+                                                        referenceFunction context.importContext ( [ "DataSource" ], "fail" )
+                                                            ++ " \"\"\n       "
 
                                                     _ ->
                                                         "data"
@@ -150,18 +224,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 == [ "DataSource" ]
 
-                        (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 +283,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 == [ "DataSource" ]
 
                 _ ->
                     False

package/generator/dead-code-review/tests/Pages/Review/DeadCodeEliminateDataTest.elm

@@ -12,6 +12,8 @@ all =
             \() ->
                 """module Route.Index exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 import DataSource exposing (DataSource)
 import RouteBuilder exposing (Page, StaticPayload, single)
 import Pages.PageUrl exposing (PageUrl)
@@ -64,6 +66,8 @@ data =
                             |> Review.Test.whenFixed
                                 """module Route.Index exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 import DataSource exposing (DataSource)
 import RouteBuilder exposing (Page, StaticPayload, single)
 import Pages.PageUrl exposing (PageUrl)
@@ -99,6 +103,104 @@ route =
        |> RouteBuilder.buildNoState { view = view }
 
 
+data : DataSource Data
+data =
+    DataSource.succeed ()
+"""
+                        ]
+        , test "supports aliased DataSource module import" <|
+            \() ->
+                """module Route.Index exposing (Data, Model, Msg, route)
+
+import Server.Request as Request
+import DataSource as DS
+import RouteBuilder exposing (Page, StaticPayload, single)
+import Pages.PageUrl exposing (PageUrl)
+import Pages.Url
+import Path
+import Route exposing (Route)
+import Shared
+import View exposing (View)
+
+
+type alias Model =
+   {}
+
+
+type alias Msg =
+   ()
+
+
+type alias RouteParams =
+   {}
+
+
+type alias Data =
+   ()
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+   single
+       { head = head
+       , data = data
+       }
+       |> RouteBuilder.buildNoState { view = view }
+
+
+data : DataSource Data
+data =
+    DataSource.succeed ()
+"""
+                    |> Review.Test.run rule
+                    |> Review.Test.expectErrors
+                        [ Review.Test.error
+                            { message = "Codemod"
+                            , details =
+                                [ "" ]
+                            , under =
+                                """data = data
+       }"""
+                            }
+                            |> Review.Test.whenFixed
+                                """module Route.Index exposing (Data, Model, Msg, route)
+
+import Server.Request as Request
+import DataSource as DS
+import RouteBuilder exposing (Page, StaticPayload, single)
+import Pages.PageUrl exposing (PageUrl)
+import Pages.Url
+import Path
+import Route exposing (Route)
+import Shared
+import View exposing (View)
+
+
+type alias Model =
+   {}
+
+
+type alias Msg =
+   ()
+
+
+type alias RouteParams =
+   {}
+
+
+type alias Data =
+   ()
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+   single
+       { head = head
+       , data = DS.fail ""
+       }
+       |> RouteBuilder.buildNoState { view = view }
+
+
 data : DataSource Data
 data =
     DataSource.succeed ()
@@ -108,6 +210,8 @@ data =
             \() ->
                 """module Route.Blog.Slug_ exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 import DataSource exposing (DataSource)
 import RouteBuilder exposing (Page, StaticPayload)
 import Pages.PageUrl exposing (PageUrl)
@@ -160,6 +264,8 @@ data =
                             |> Review.Test.whenFixed
                                 """module Route.Blog.Slug_ exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 import DataSource exposing (DataSource)
 import RouteBuilder exposing (Page, StaticPayload)
 import Pages.PageUrl exposing (PageUrl)
@@ -205,6 +311,8 @@ data =
             \() ->
                 """module Route.Login exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 type alias Model =
     {}
 
@@ -239,6 +347,8 @@ route =
                             |> Review.Test.whenFixed
                                 """module Route.Login exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 type alias Model =
     {}
 
@@ -271,6 +381,8 @@ route =
                             |> Review.Test.whenFixed
                                 """module Route.Login exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 type alias Model =
     {}
 
@@ -291,12 +403,112 @@ route =
         , action = \\_ -> Request.oneOf []
         }
         |> RouteBuilder.buildNoState { view = view }
+"""
+                        ]
+        , test "uses appropriate import alias for Server.Request module" <|
+            \() ->
+                """module Route.Login exposing (Data, Model, Msg, route)
+
+import Server.Request
+
+type alias Model =
+    {}
+
+
+type alias Msg =
+    ()
+
+
+type alias RouteParams =
+    {}
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+    RouteBuilder.serverRender
+        { head = head
+        , data = data
+        , action = action
+        }
+        |> RouteBuilder.buildNoState { view = view }
+"""
+                    |> Review.Test.run rule
+                    |> Review.Test.expectErrors
+                        [ Review.Test.error
+                            { message = "Codemod"
+                            , details =
+                                [ "" ]
+                            , under =
+                                """data = data
+        ,"""
+                            }
+                            |> Review.Test.whenFixed
+                                """module Route.Login exposing (Data, Model, Msg, route)
+
+import Server.Request
+
+type alias Model =
+    {}
+
+
+type alias Msg =
+    ()
+
+
+type alias RouteParams =
+    {}
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+    RouteBuilder.serverRender
+        { head = head
+        , data = \\_ -> Server.Request.oneOf []
+        , action = action
+        }
+        |> RouteBuilder.buildNoState { view = view }
+"""
+                        , Review.Test.error
+                            { message = "Codemod"
+                            , details =
+                                [ "" ]
+                            , under =
+                                """action = action
+        }"""
+                            }
+                            |> Review.Test.whenFixed
+                                """module Route.Login exposing (Data, Model, Msg, route)
+
+import Server.Request
+
+type alias Model =
+    {}
+
+
+type alias Msg =
+    ()
+
+
+type alias RouteParams =
+    {}
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+    RouteBuilder.serverRender
+        { head = head
+        , data = data
+        , action = \\_ -> Server.Request.oneOf []
+        }
+        |> RouteBuilder.buildNoState { view = view }
 """
                         ]
         , test "no Request.oneOf fix after replacement is made" <|
             \() ->
                 """module Route.Login exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 type alias Model =
     {}
 
@@ -323,6 +535,8 @@ route =
             \() ->
                 """module Route.Index exposing (Data, Model, Msg, route)
 
+import Server.Request as Request
+
 import DataSource exposing (DataSource)
 import RouteBuilder exposing (Page, StaticPayload)
 import Pages.PageUrl exposing (PageUrl)
@@ -368,6 +582,8 @@ data =
             \() ->
                 """module Shared exposing (Data, Model, Msg, template)
 
+import Server.Request as Request
+
 import Browser.Navigation
 import DataSource
 import Html exposing (Html)
@@ -416,6 +632,8 @@ type alias Model =
                             |> Review.Test.whenFixed
                                 """module Shared exposing (Data, Model, Msg, template)
 
+import Server.Request as Request
+
 import Browser.Navigation
 import DataSource
 import Html exposing (Html)

package/generator/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: 2471752417, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 1646606691, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/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: 2471752417,
+  initialSeed: 1646606691,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/src/generate-template-module-connector.js

@@ -82,12 +82,10 @@ async function runElmCodegenCli(templates, basePath, phase) {
     }
   });
   const filesToGenerate = await promise;
-  console.dir(filesToGenerate.map((file) => file.path));
 
   return filesToGenerate;
 }
 
-
 /**
  *
  * @param {string[][]} templates
@@ -153,8 +151,6 @@ function sortScore(name) {
   );
 }
 
-
-
 function fetcherModule(name) {
   let moduleName = name.join(".");
   // TODO need to account for splat routes/etc.
@@ -226,7 +222,6 @@ submit toMsg options =
 `;
 }
 
-
 /**
  * Convert Strings from camelCase to kebab-case
  * @param {string} input
@@ -236,5 +231,4 @@ function camelToKebab(input) {
   return input.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 
-
 module.exports = { generateTemplateModuleConnector, sortTemplates };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-pages",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.4",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -10,7 +10,6 @@
     "test": "./test.sh",
     "test:snapshot": "(cd examples/escaping && npm install && npm test) && (cd examples/base-path && npm install && npm test)",
     "cypress": "npm start & cypress run",
-    "prepare": "npm run build:generator",
     "build:generator": "elm-codegen install && (cd codegen && lamdera make Generate.elm --output elm-pages-codegen.js)",
     "review": "elm-review"
   },

package/src/Form/Field.elm

@@ -6,7 +6,7 @@ module Form.Field exposing
     , required, withClientValidation, withInitialValue, map
     , email, password, search, telephone, url, textarea
     , withMax, withMin, withStep, withMinLength, withMaxLength
-    , No(..), Yes(..)
+    , No, Yes
     )
 
 {-|

package/src/Head/Seo.elm

@@ -455,9 +455,9 @@ tags (Content common details) =
                     -}
                     [ ( "og:type", "article" |> Head.raw |> Just )
                     , ( "article:section", articleDetails.section |> Maybe.map Head.raw )
-                    , ( "article:published_time", articleDetails.publishedTime |> Maybe.map (DateOrDateTime.dateOrDateTimeToIso8601String >> Head.raw) )
-                    , ( "article:modified_time", articleDetails.modifiedTime |> Maybe.map (DateOrDateTime.dateOrDateTimeToIso8601String >> Head.raw) )
-                    , ( "article:expiration_time", articleDetails.expirationTime |> Maybe.map (DateOrDateTime.dateOrDateTimeToIso8601String >> Head.raw) )
+                    , ( "article:published_time", articleDetails.publishedTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
+                    , ( "article:modified_time", articleDetails.modifiedTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
+                    , ( "article:expiration_time", articleDetails.expirationTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
                     ]
                         ++ List.map
                             (\tag -> ( "article:tag", tag |> Head.raw |> Just ))
@@ -466,7 +466,7 @@ tags (Content common details) =
                 Book bookDetails ->
                     [ ( "og:type", "book" |> Head.raw |> Just )
                     , ( "og:isbn", bookDetails.isbn |> Maybe.map Head.raw )
-                    , ( "og:release_date", bookDetails.releaseDate |> Maybe.map (DateOrDateTime.dateOrDateTimeToIso8601String >> Head.raw) )
+                    , ( "og:release_date", bookDetails.releaseDate |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
                     ]
                         ++ List.map
                             (\tag -> ( "book:tag", tag |> Head.raw |> Just ))