elm-pages 3.0.12 → 3.0.13

package/src/Pages/Script.elm

@@ -2,7 +2,8 @@ module Pages.Script exposing
     ( Script
     , withCliOptions, withoutCliOptions
     , writeFile
-    , log
+    , command, exec
+    , log, sleep, doThen, which, expectWhich, question
     , Error(..)
     )
 
@@ -23,9 +24,14 @@ Read more about using the `elm-pages` CLI to run (or bundle) scripts, plus a bri
 @docs writeFile
 
 
+## Shell Commands
+
+@docs command, exec
+
+
 ## Utilities
 
-@docs log
+@docs log, sleep, doThen, which, expectWhich, question
 
 
 ## Errors
@@ -37,6 +43,7 @@ Read more about using the `elm-pages` CLI to run (or bundle) scripts, plus a bri
 import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Request
+import BackendTask.Stream as Stream exposing (defaultCommandOptions)
 import Cli.OptionsParser as OptionsParser
 import Cli.Program as Program
 import FatalError exposing (FatalError)
@@ -61,6 +68,8 @@ type Error
 
 {-| Write a file to the file system.
 
+File paths are relative to the root of your `elm-pages` project (next to the `elm.json` file and `src/` directory), or you can pass in absolute paths beginning with a `/`.
+
     module MyScript exposing (run)
 
     import BackendTask
@@ -164,3 +173,191 @@ withCliOptions config execute =
             config
                 |> Program.mapConfig execute
         )
+
+
+{-| Sleep for a number of milliseconds.
+
+    module MyScript exposing (run)
+
+    import BackendTask
+    import Pages.Script as Script
+
+    run =
+        Script.withoutCliOptions
+            (Script.log "Hello..."
+                |> Script.doThen
+                    (Script.sleep 1000)
+                |> Script.doThen
+                    (Script.log "World!")
+            )
+
+-}
+sleep : Int -> BackendTask error ()
+sleep int =
+    BackendTask.Internal.Request.request
+        { name = "sleep"
+        , body =
+            BackendTask.Http.jsonBody
+                (Encode.object
+                    [ ( "milliseconds", Encode.int int )
+                    ]
+                )
+        , expect =
+            BackendTask.Http.expectJson (Decode.null ())
+        }
+
+
+{-| Run a command with no output, then run another command.
+
+    module MyScript exposing (run)
+
+    import BackendTask
+    import Pages.Script as Script
+
+    run =
+        Script.withoutCliOptions
+            (Script.log "Hello!"
+                |> Script.doThen
+                    (Script.log "World!")
+            )
+
+-}
+doThen : BackendTask error value -> BackendTask error () -> BackendTask error value
+doThen task1 task2 =
+    task2
+        |> BackendTask.andThen (\() -> task1)
+
+
+{-| Same as [`expectWhich`](#expectWhich), but returns `Nothing` if the command is not found instead of failing with a [`FatalError`](FatalError).
+-}
+which : String -> BackendTask error (Maybe String)
+which command_ =
+    BackendTask.Internal.Request.request
+        { body = BackendTask.Http.jsonBody (Encode.string command_)
+        , expect = BackendTask.Http.expectJson (Decode.nullable Decode.string)
+        , name = "which"
+        }
+
+
+{-| Check if a command is available on the system. If it is, return the full path to the command, otherwise fail with a [`FatalError`](FatalError).
+
+    module MyScript exposing (run)
+
+    import BackendTask
+    import Pages.Script as Script
+
+    run : Script
+    run =
+        Script.withoutCliOptions
+            (Script.expectWhich "elm-review"
+                |> BackendTask.andThen
+                    (\path ->
+                        Script.log ("The path to `elm-review` is: " ++ path)
+                    )
+            )
+
+If you run it with a command that is not available, you will see an error like this:
+
+    Script.expectWhich "hype-script"
+
+```shell
+-- COMMAND NOT FOUND ---------------
+I expected to find `hype-script`, but it was not on your PATH. Make sure it is installed and included in your PATH.
+```
+
+-}
+expectWhich : String -> BackendTask FatalError String
+expectWhich command_ =
+    which command_
+        |> BackendTask.andThen
+            (\maybePath ->
+                case maybePath of
+                    Just path ->
+                        BackendTask.succeed path
+
+                    Nothing ->
+                        BackendTask.fail
+                            (FatalError.build
+                                { title = "Command not found"
+                                , body = "I expected to find `" ++ command_ ++ "`, but it was not on your PATH. Make sure it is installed and included in your PATH."
+                                }
+                            )
+            )
+
+
+{-|
+
+    module QuestionDemo exposing (run)
+
+    import BackendTask
+
+    run : Script
+    run =
+        Script.withoutCliOptions
+            (Script.question "What is your name? "
+                |> BackendTask.andThen
+                    (\name ->
+                        Script.log ("Hello, " ++ name ++ "!")
+                    )
+            )
+
+-}
+question : String -> BackendTask error String
+question prompt =
+    BackendTask.Internal.Request.request
+        { body =
+            BackendTask.Http.jsonBody
+                (Encode.object [ ( "prompt", Encode.string prompt ) ])
+        , expect = BackendTask.Http.expectJson Decode.string
+        , name = "question"
+        }
+
+
+{-| Like [`command`](#command), but prints stderr and stdout to the console as the command runs instead of capturing them.
+
+    module MyScript exposing (run)
+
+    import BackendTask
+    import Pages.Script as Script exposing (Script)
+
+    run : Script
+    run =
+        Script.withoutCliOptions
+            (Script.exec "ls" [])
+
+-}
+exec : String -> List String -> BackendTask FatalError ()
+exec command_ args_ =
+    Stream.command command_ args_
+        |> Stream.run
+
+
+{-| Run a single command and return stderr and stdout combined as a single String.
+
+If you want to do more advanced things like piping together multiple commands in a pipeline, or piping in a file to a command, etc., see the [`Stream`](BackendTask-Stream) module.
+
+    module MyScript exposing (run)
+
+    import BackendTask
+    import Pages.Script as Script exposing (Script)
+
+    run : Script
+    run =
+        Script.withoutCliOptions
+            (Script.command "ls" []
+                |> BackendTask.andThen
+                    (\files ->
+                        Script.log ("Files: " ++ files)
+                    )
+            )
+
+-}
+command : String -> List String -> BackendTask FatalError String
+command command_ args_ =
+    Stream.commandWithOptions
+        (defaultCommandOptions |> Stream.withOutput Stream.MergeStderrAndStdout)
+        command_
+        args_
+        |> Stream.read
+        |> BackendTask.map .body
+        |> BackendTask.allowFatal

package/src/Pages/StaticHttp/Request.elm

@@ -1,6 +1,7 @@
 module Pages.StaticHttp.Request exposing (Request, codec, hash)
 
 import Codec exposing (Codec)
+import Dict exposing (Dict)
 import FNV1a
 import Json.Encode as Encode
 import Pages.Internal.StaticHttpBody as StaticHttpBody exposing (Body)
@@ -12,6 +13,9 @@ type alias Request =
     , headers : List ( String, String )
     , body : Body
     , cacheOptions : Maybe Encode.Value
+    , env : Dict String String
+    , dir : List String
+    , quiet : Bool
     }
 
 
@@ -41,4 +45,7 @@ codec =
         |> Codec.field "headers" .headers (Codec.list (Codec.tuple Codec.string Codec.string))
         |> Codec.field "body" .body StaticHttpBody.codec
         |> Codec.nullableField "cacheOptions" .cacheOptions Codec.value
+        |> Codec.field "env" .env (Codec.dict Codec.string)
+        |> Codec.field "dir" .dir (Codec.list Codec.string)
+        |> Codec.field "quiet" .quiet Codec.bool
         |> Codec.buildObject

package/src/RequestsAndPending.elm

@@ -1,4 +1,4 @@
-module RequestsAndPending exposing (HttpError(..), RawResponse, RequestsAndPending, Response(..), ResponseBody(..), bodyEncoder, get)
+module RequestsAndPending exposing (HttpError(..), RawResponse, RequestsAndPending, Response(..), ResponseBody(..), bodyEncoder, get, responseDecoder)
 
 import Base64
 import Bytes exposing (Bytes)

package/src/Scaffold/Form.elm

@@ -31,7 +31,7 @@ import Elm.Annotation as Type
 import Elm.Declare
 import Elm.Op
 import List.Extra
-import Result.Extra
+import Vendored.Result.Extra
 
 
 {-| -}
@@ -188,8 +188,7 @@ restArgsParser =
         |> Cli.Option.validateMap
             (\items ->
                 items
-                    |> List.map parseField
-                    |> Result.Extra.combine
+                    |> Vendored.Result.Extra.combineMap parseField
             )
 
 

package/src/TerminalText.elm

@@ -11,6 +11,7 @@ module TerminalText exposing
     , red
     , resetColors
     , text
+    , toPlainString
     , toString
     , toString_
     , yellow
@@ -109,6 +110,13 @@ toString_ (Style ansiStyle innerText) =
         ]
 
 
+toPlainString : List Text -> String
+toPlainString list =
+    list
+        |> List.map (\(Style _ inner) -> inner)
+        |> String.concat
+
+
 fromAnsiString : String -> List Text
 fromAnsiString ansiString =
     Ansi.parseInto ( blankStyle, [] ) parseInto ansiString

package/src/Vendored/Result/Extra.elm

@@ -0,0 +1,75 @@
+module Vendored.Result.Extra exposing (combine, combineMap, isOk, merge)
+
+
+isOk : Result x a -> Bool
+isOk result =
+    case result of
+        Ok _ ->
+            True
+
+        Err _ ->
+            False
+
+
+merge : Result a a -> a
+merge r =
+    case r of
+        Ok rr ->
+            rr
+
+        Err rr ->
+            rr
+
+
+
+-- https://github.com/elmcraft/core-extra/blob/2.0.0/src/Result/Extra.elm
+
+
+{-| Combine a list of results into a single result (holding a list).
+Also known as `sequence` on lists.
+-}
+combine : List (Result x a) -> Result x (List a)
+combine list =
+    combineHelp list []
+
+
+combineHelp : List (Result x a) -> List a -> Result x (List a)
+combineHelp list acc =
+    case list of
+        head :: tail ->
+            case head of
+                Ok a ->
+                    combineHelp tail (a :: acc)
+
+                Err x ->
+                    Err x
+
+        [] ->
+            Ok (List.reverse acc)
+
+
+{-| Map a function producing results on a list
+and combine those into a single result (holding a list).
+Also known as `traverse` on lists.
+
+    combineMap f xs == combine (List.map f xs)
+
+-}
+combineMap : (a -> Result x b) -> List a -> Result x (List b)
+combineMap f ls =
+    combineMapHelp f ls []
+
+
+combineMapHelp : (a -> Result x b) -> List a -> List b -> Result x (List b)
+combineMapHelp f list acc =
+    case list of
+        head :: tail ->
+            case f head of
+                Ok a ->
+                    combineMapHelp f tail (a :: acc)
+
+                Err x ->
+                    Err x
+
+        [] ->
+            Ok (List.reverse acc)

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

@@ -1 +0,0 @@
-{"type":"application","source-directories":["../../src","../../tests","../../../../src","src"],"elm-version":"0.19.1","dependencies":{"direct":{"elm/core":"1.0.5","elm/json":"1.1.3","elm-community/result-extra":"2.4.0","elm-explorations/test":"2.1.1","jfmengels/elm-review":"2.13.1","mpizenberg/elm-test-runner":"6.0.0","stil4m/elm-syntax":"7.3.2"},"indirect":{"elm/bytes":"1.0.8","elm/html":"1.0.0","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.3","miniBill/elm-unicode":"1.1.0","rtfeldman/elm-hex":"1.0.0","stil4m/structured-writer":"1.0.3"}},"test-dependencies":{"direct":{},"indirect":{}}}