elm-pages 3.0.0-beta.13 → 3.0.0-beta.15

package/src/Query/Extra.elm

@@ -1,55 +0,0 @@
-module Query.Extra exposing (oneOf)
-
-import Html
-import Test.Html.Query as Query
-import Test.Html.Selector as Selector
-import Test.Runner
-
-
-{-| This is a hack for the fact that elm-html-test does not provide a way to force a `Query.Single` into an error state.
--}
-fail : String -> Query.Single msg -> Query.Single msg
-fail message _ =
-    Html.text ("ERROR: " ++ message)
-        |> Query.fromHtml
-        |> Query.find [ Selector.text "SHOULD NOT HAVE ERROR" ]
-
-
-{-| Determines whether the given `Query.Single` is an error (failed to match a node)
--}
-isFailed : Query.Single msg -> Bool
-isFailed single =
-    case single |> Query.has [] |> Test.Runner.getFailureReason of
-        Just _ ->
-            True
-
-        Nothing ->
-            False
-
-
-{-| TODO: Is it strange that this takes a `List (Single -> Single)`? Is it safer or more sensible to take `List (List Selector)` and then implicily only work with `Query.find`?
--}
-oneOf : List (Query.Single msg -> Query.Single msg) -> Query.Single msg -> Query.Single msg
-oneOf options single =
-    if isFailed single then
-        -- the input single is an error, so just return that
-        single
-
-    else
-        case options of
-            [] ->
-                fail "Query.Extra.oneOf was given an empty list of options" single
-
-            [ last ] ->
-                -- this is the last option, so if it fails, we want to return that failure
-                -- TODO: if the all failed, give a better error message about everything that failed
-                single |> last
-
-            next :: rest1 :: rest ->
-                if isFailed (next single) then
-                    -- this option failed, so try the remaining ones
-                    oneOf (rest1 :: rest) single
-
-                else
-                    -- this option passed, so return success
-                    next single

package/src/SimulatedEffect/Cmd.elm

@@ -1,69 +0,0 @@
-module SimulatedEffect.Cmd exposing
-    ( none, batch
-    , map
-    )
-
-{-| This module parallels [elm/core's `Platform.Cmd` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Platform-Cmd).
-
-The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
-to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
-
-@docs none, batch
-
-@docs map
-
--}
-
-import ProgramTest exposing (SimulatedEffect)
-import SimulatedEffect
-import SimulatedEffect.Task as Task
-
-
-{-| Tell the runtime that there are no commands.
--}
-none : SimulatedEffect msg
-none =
-    SimulatedEffect.None
-
-
-{-| When you need the runtime system to perform a couple commands, you can batch them together.
--}
-batch : List (SimulatedEffect msg) -> SimulatedEffect msg
-batch =
-    SimulatedEffect.Batch
-
-
-{-| Transform the messages produced by a command.
--}
-map : (a -> msg) -> SimulatedEffect a -> SimulatedEffect msg
-map f effect =
-    case effect of
-        SimulatedEffect.None ->
-            SimulatedEffect.None
-
-        SimulatedEffect.Batch effects ->
-            SimulatedEffect.Batch (List.map (map f) effects)
-
-        SimulatedEffect.Task t ->
-            t
-                |> Task.map f
-                |> Task.mapError f
-                |> SimulatedEffect.Task
-
-        SimulatedEffect.PortEffect portName value ->
-            SimulatedEffect.PortEffect portName value
-
-        SimulatedEffect.PushUrl url ->
-            SimulatedEffect.PushUrl url
-
-        SimulatedEffect.ReplaceUrl url ->
-            SimulatedEffect.ReplaceUrl url
-
-        SimulatedEffect.Back n ->
-            SimulatedEffect.Back n
-
-        SimulatedEffect.Load url ->
-            SimulatedEffect.Load url
-
-        SimulatedEffect.Reload skipCache ->
-            SimulatedEffect.Reload skipCache

package/src/SimulatedEffect/Http.elm

@@ -1,330 +0,0 @@
-module SimulatedEffect.Http exposing
-    ( get, post, request
-    , Header, header
-    , Body, emptyBody, stringBody, jsonBody
-    , Expect, expectString, expectJson, expectWhatever, Error
-    , expectStringResponse, Response
-    , task, Resolver, stringResolver
-    )
-
-{-| This module parallels [elm/http's `Http` module](https://package.elm-lang.org/packages/elm/http/2.0.0/Http).
-_Pull requests are welcome to add any functions that are missing._
-
-The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
-to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
-
-
-# Requests
-
-@docs get, post, request
-
-
-# Header
-
-@docs Header, header
-
-
-# Body
-
-@docs Body, emptyBody, stringBody, jsonBody
-
-
-# Expect
-
-@docs Expect, expectString, expectJson, expectWhatever, Error
-
-
-# Elaborate Expectations
-
-@docs expectStringResponse, Response
-
-
-# Tasks
-
-@docs task, Resolver, stringResolver
-
--}
-
-import Http
-import Json.Decode exposing (Decoder)
-import Json.Encode
-import ProgramTest exposing (SimulatedEffect, SimulatedTask)
-import SimulatedEffect
-
-
-{-| Create a `GET` request.
--}
-get :
-    { url : String
-    , expect : Expect msg
-    }
-    -> SimulatedEffect msg
-get r =
-    request
-        { method = "GET"
-        , headers = []
-        , url = r.url
-        , body = emptyBody
-        , expect = r.expect
-        , timeout = Nothing
-        , tracker = Nothing
-        }
-
-
-{-| Create a `POST` request.
--}
-post :
-    { url : String
-    , body : Body
-    , expect : Expect msg
-    }
-    -> SimulatedEffect msg
-post r =
-    request
-        { method = "POST"
-        , headers = []
-        , url = r.url
-        , body = r.body
-        , expect = r.expect
-        , timeout = Nothing
-        , tracker = Nothing
-        }
-
-
-{-| Create a custom request.
--}
-request :
-    { method : String
-    , headers : List Header
-    , url : String
-    , body : Body
-    , expect : Expect msg
-    , timeout : Maybe Float
-    , tracker : Maybe String
-    }
-    -> SimulatedEffect msg
-request r =
-    let
-        (Expect onResult) =
-            r.expect
-    in
-    SimulatedEffect.HttpTask
-        { method = r.method
-        , url = r.url
-        , headers =
-            case r.body of
-                EmptyBody ->
-                    r.headers
-
-                StringBody body ->
-                    header "Content-Type" body.contentType :: r.headers
-        , body =
-            case r.body of
-                EmptyBody ->
-                    ""
-
-                StringBody body ->
-                    body.content
-        , onRequestComplete = onResult >> SimulatedEffect.Succeed
-        }
-        |> SimulatedEffect.Task
-
-
-{-| An HTTP header for configuring requests.
--}
-type alias Header =
-    ( String, String )
-
-
-{-| Create a `Header`.
--}
-header : String -> String -> Header
-header =
-    Tuple.pair
-
-
-{-| Represents the body of a `Request`.
--}
-type Body
-    = EmptyBody
-    | StringBody
-        { contentType : String
-        , content : String
-        }
-
-
-{-| Create an empty body for your `Request`.
--}
-emptyBody : Body
-emptyBody =
-    EmptyBody
-
-
-{-| Put some JSON value in the body of your `Request`. This will automatically
-add the `Content-Type: application/json` header.
--}
-jsonBody : Json.Encode.Value -> Body
-jsonBody value =
-    StringBody
-        { contentType = "application/json"
-        , content = Json.Encode.encode 0 value
-        }
-
-
-{-| Put some string in the body of your `Request`.
--}
-stringBody : String -> String -> Body
-stringBody contentType content =
-    StringBody
-        { contentType = contentType
-        , content = content
-        }
-
-
-{-| Logic for interpreting a response body.
--}
-type Expect msg
-    = Expect (Http.Response String -> msg)
-
-
-{-| Expect the response body to be a `String`.
--}
-expectString : (Result Http.Error String -> msg) -> Expect msg
-expectString onResult =
-    Expect <|
-        \response ->
-            case response of
-                Http.BadUrl_ s ->
-                    onResult (Err <| Http.BadUrl s)
-
-                Http.Timeout_ ->
-                    onResult (Err Http.Timeout)
-
-                Http.NetworkError_ ->
-                    onResult (Err Http.NetworkError)
-
-                Http.BadStatus_ metadata body ->
-                    onResult (Err <| Http.BadStatus metadata.statusCode)
-
-                Http.GoodStatus_ _ body ->
-                    onResult (Ok body)
-
-
-{-| Expect a Response with a String body.
--}
-expectStringResponse : (Result x a -> msg) -> (Response String -> Result x a) -> Expect msg
-expectStringResponse toMsg onResponse =
-    Expect (onResponse >> toMsg)
-
-
-{-| Expect the response body to be JSON.
--}
-expectJson : (Result Http.Error a -> msg) -> Decoder a -> Expect msg
-expectJson onResult decoder =
-    Expect <|
-        \response ->
-            case response of
-                Http.BadUrl_ s ->
-                    onResult (Err <| Http.BadUrl s)
-
-                Http.Timeout_ ->
-                    onResult (Err Http.Timeout)
-
-                Http.NetworkError_ ->
-                    onResult (Err Http.NetworkError)
-
-                Http.BadStatus_ metadata _ ->
-                    onResult (Err <| Http.BadStatus metadata.statusCode)
-
-                Http.GoodStatus_ _ body ->
-                    case Json.Decode.decodeString decoder body of
-                        Err jsonError ->
-                            onResult (Err <| Http.BadBody <| Json.Decode.errorToString jsonError)
-
-                        Ok value ->
-                            onResult (Ok value)
-
-
-{-| Expect the response body to be whatever.
--}
-expectWhatever : (Result Error () -> msg) -> Expect msg
-expectWhatever onResult =
-    Expect <|
-        \response ->
-            case response of
-                Http.BadUrl_ s ->
-                    onResult (Err <| Http.BadUrl s)
-
-                Http.Timeout_ ->
-                    onResult (Err Http.Timeout)
-
-                Http.NetworkError_ ->
-                    onResult (Err Http.NetworkError)
-
-                Http.BadStatus_ metadata _ ->
-                    onResult (Err <| Http.BadStatus metadata.statusCode)
-
-                Http.GoodStatus_ _ _ ->
-                    onResult (Ok ())
-
-
-{-| -}
-type alias Error =
-    Http.Error
-
-
-{-| -}
-type alias Response body =
-    Http.Response body
-
-
-{-| Just like [`request`](#request), but it creates a `Task`.
--}
-task :
-    { method : String
-    , headers : List Header
-    , url : String
-    , body : Body
-    , resolver : Resolver x a
-    , timeout : Maybe Float
-    }
-    -> SimulatedTask x a
-task r =
-    SimulatedEffect.HttpTask
-        { method = r.method
-        , url = r.url
-        , headers = r.headers
-        , body =
-            case r.body of
-                EmptyBody ->
-                    ""
-
-                StringBody body ->
-                    body.content
-        , onRequestComplete =
-            case r.resolver of
-                StringResolver f ->
-                    f
-        }
-
-
-{-| Describes how to resolve an HTTP task.
--}
-type Resolver x a
-    = StringResolver (Response String -> SimulatedTask x a)
-
-
-{-| Turn a response with a `String` body into a result.
--}
-stringResolver : (Response String -> Result x a) -> Resolver x a
-stringResolver f =
-    let
-        fromResult result =
-            case result of
-                Err x ->
-                    SimulatedEffect.Fail x
-
-                Ok a ->
-                    SimulatedEffect.Succeed a
-    in
-    StringResolver (f >> fromResult)

package/src/SimulatedEffect/Navigation.elm

@@ -1,69 +0,0 @@
-module SimulatedEffect.Navigation exposing
-    ( pushUrl, replaceUrl, back
-    , load, reload, reloadAndSkipCache
-    )
-
-{-| This module parallels [elm/browsers's `Browser.Navigation` module](https://package.elm-lang.org/packages/elm/browser/1.0.1/Browser-Navigation).
-_Pull requests are welcome to add any functions that are missing._
-
-The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
-to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
-
-
-# Navigate within Page
-
-@docs pushUrl, replaceUrl, back
-
-
-# Navigate to other Pages
-
-@docs load, reload, reloadAndSkipCache
-
--}
-
-import ProgramTest exposing (SimulatedEffect)
-import SimulatedEffect
-
-
-{-| Change the URL, but do not trigger a page load.
-This will add a new entry to the browser history.
--}
-pushUrl : String -> SimulatedEffect msg
-pushUrl =
-    SimulatedEffect.PushUrl
-
-
-{-| Change the URL, but do not trigger a page load.
-This _will not_ add a new entry to the browser history.
--}
-replaceUrl : String -> SimulatedEffect msg
-replaceUrl =
-    SimulatedEffect.ReplaceUrl
-
-
-{-| Go back some number of pages.
--}
-back : Int -> SimulatedEffect msg
-back =
-    SimulatedEffect.Back
-
-
-{-| Leave the current page and load the given URL.
--}
-load : String -> SimulatedEffect msg
-load =
-    SimulatedEffect.Load
-
-
-{-| Reload the current page.
--}
-reload : SimulatedEffect msg
-reload =
-    SimulatedEffect.Reload False
-
-
-{-| Reload the current page without using the browser cache.
--}
-reloadAndSkipCache : SimulatedEffect msg
-reloadAndSkipCache =
-    SimulatedEffect.Reload True

package/src/SimulatedEffect/Ports.elm

@@ -1,62 +0,0 @@
-module SimulatedEffect.Ports exposing (send, subscribe)
-
-{-| This module provides functions that allow you to create `SimulatedEffect`s
-that parallel [Elm ports](https://guide.elm-lang.org/interop/ports.html) used in your real program.
-This is meant to be used
-to help you implement the function to provide when using
-[`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects)
-and [`ProgramTest.withSimulatedSubscriptions`](ProgramTest#withSimulatedSubscriptions).
-
-For a detailed example, see the [“Testing programs with ports” guidebook](https://elm-program-test.netlify.com/ports.html).
-
-@docs send, subscribe
-
--}
-
-import Json.Decode
-import Json.Encode
-import ProgramTest exposing (SimulatedEffect, SimulatedSub)
-import SimulatedEffect
-
-
-{-| Creates a `SimulatedEffect` that parallels using an outgoing Elm port.
-
-For example, if your production code uses a port like this:
-
-    port logMessage : String -> Cmd msg
-
-    logMessage "hello"
-
-Then the corresponding `SimulatedEffect` would be:
-
-    SimulatedEffect.Ports.send "logMessage" (Json.Encode.string "hello")
-
--}
-send : String -> Json.Encode.Value -> SimulatedEffect msg
-send =
-    SimulatedEffect.PortEffect
-
-
-{-| Creates a `SimulatedSub` that parallels using an incoming Elm port.
-
-For example, if your production code uses a port like this:
-
-    port activeUsers : (List String -> msg) -> Sub msg
-
-    subscriptions : Model -> Sub Msg
-    subscriptions model =
-        activeUsers OnActiveUsersLoaded
-
-Then the corresponding `SimulatedSub` would be:
-
-    simulatedSubscriptions : Model -> SimulatedSub Msg
-    simulatedSubscriptions model =
-        SimulatedEffect.Ports.subscribe
-            "activeUsers"
-            (Json.Decode.list Json.Decode.string)
-            OnActiveUsersLoaded
-
--}
-subscribe : String -> Json.Decode.Decoder a -> (a -> msg) -> SimulatedSub msg
-subscribe portName decoder toMsg =
-    SimulatedEffect.PortSub portName (Json.Decode.map toMsg decoder)

package/src/SimulatedEffect/Process.elm

@@ -1,24 +0,0 @@
-module SimulatedEffect.Process exposing (sleep)
-
-{-| This module parallels [elm/core's `Process` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Process).
-_Pull requests are welcome to add any functions that are missing._
-
-The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
-to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
-
-
-# Processes
-
-@docs sleep
-
--}
-
-import ProgramTest exposing (SimulatedTask)
-import SimulatedEffect
-
-
-{-| Block progress on the current process for the given number of milliseconds.
--}
-sleep : Float -> SimulatedTask x ()
-sleep delay =
-    SimulatedEffect.SleepTask delay SimulatedEffect.Succeed

package/src/SimulatedEffect/Sub.elm

@@ -1,48 +0,0 @@
-module SimulatedEffect.Sub exposing
-    ( none, batch
-    , map
-    )
-
-{-| This module parallels [elm/core's `Platform.Sub` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Platform-Sub).
-
-The functions here produce `SimulatedSub`s instead of `Sub`s, which are meant to be used
-to help you implement the function to provide when using [`ProgramTest.withSimulatedSubscriptions`](ProgramTest#withSimulatedSubscriptions).
-
-@docs none, batch
-
-@docs map
-
--}
-
-import Json.Decode
-import ProgramTest exposing (SimulatedEffect, SimulatedSub)
-import SimulatedEffect
-
-
-{-| Tell the runtime that there are no subscriptions.
--}
-none : SimulatedSub msg
-none =
-    SimulatedEffect.NoneSub
-
-
-{-| When you need to subscribe to multiple things, you can create a `batch` of subscriptions.
--}
-batch : List (SimulatedSub msg) -> SimulatedSub msg
-batch =
-    SimulatedEffect.BatchSub
-
-
-{-| Transform the messages produced by a subscription.
--}
-map : (a -> msg) -> SimulatedSub a -> SimulatedSub msg
-map f effect =
-    case effect of
-        SimulatedEffect.NoneSub ->
-            SimulatedEffect.NoneSub
-
-        SimulatedEffect.BatchSub effects ->
-            SimulatedEffect.BatchSub (List.map (map f) effects)
-
-        SimulatedEffect.PortSub name decoder ->
-            SimulatedEffect.PortSub name (Json.Decode.map f decoder)