elm-pages 3.0.12 → 3.0.14

package/src/BackendTask/Glob.elm

@@ -1,9 +1,11 @@
 module BackendTask.Glob exposing
     ( Glob
     , capture, match
+    , fromString, fromStringWithOptions
     , captureFilePath
     , wildcard, recursiveWildcard
     , int, digits
+    , FileStats, captureStats
     , expectUniqueMatch, expectUniqueMatchFromList
     , literal
     , map, succeed
@@ -97,7 +99,8 @@ Let's try our blogPostsGlob from before, but change every `match` to `capture`.
     import BackendTask exposing (BackendTask)
 
     blogPostsGlob :
-        BackendTask error
+        BackendTask
+            error
             (List
                 { filePath : String
                 , slug : String
@@ -136,6 +139,12 @@ and error prone. That's what the [`captureFilePath`](#captureFilePath) helper is
 
 ## Reading matching files
 
+You can use the less powerful but more familiar and terse `fromString` helpers if you only need to find matching file paths
+(but don't care about parsing out parts of the paths). This is helpful when you need a reference to matching files and
+you are only using the file paths to then read or do scripting tasks with those paths.
+
+@docs fromString, fromStringWithOptions
+
 @docs captureFilePath
 
 In many cases you will want to take the matching files from a `Glob` and then read the body or frontmatter from matching files.
@@ -198,6 +207,13 @@ That will give us
 @docs int, digits
 
 
+## Capturing File Stats
+
+You can access a file's stats including timestamps when the file was created and modified, and file size.
+
+@docs FileStats, captureStats
+
+
 ## Matching a Specific Number of Files
 
 @docs expectUniqueMatch, expectUniqueMatchFromList
@@ -235,6 +251,7 @@ import FatalError exposing (FatalError)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import List.Extra
+import Time
 
 
 {-| A pattern to match local files and capture parts of the path into a nice Elm data type.
@@ -296,9 +313,9 @@ For example, you could take a date and parse it.
 map : (a -> b) -> Glob a -> Glob b
 map mapFn (Glob pattern applyCapture) =
     Glob pattern
-        (\fullPath captures ->
+        (\fileStats fullPath captures ->
             captures
-                |> applyCapture fullPath
+                |> applyCapture fileStats fullPath
                 |> Tuple.mapFirst mapFn
         )
 
@@ -307,13 +324,13 @@ map mapFn (Glob pattern applyCapture) =
 -}
 succeed : constructor -> Glob constructor
 succeed constructor =
-    Glob "" (\_ captures -> ( constructor, captures ))
+    Glob "" (\_ _ captures -> ( constructor, captures ))
 
 
 fullFilePath : Glob String
 fullFilePath =
     Glob ""
-        (\fullPath captures ->
+        (\_ fullPath captures ->
             ( fullPath, captures )
         )
 
@@ -324,7 +341,8 @@ fullFilePath =
     import BackendTask.Glob as Glob
 
     blogPosts :
-        BackendTask error
+        BackendTask
+            error
             (List
                 { filePath : String
                 , slug : String
@@ -354,6 +372,75 @@ captureFilePath =
     capture fullFilePath
 
 
+{-| The information about a file that you can access when you use [`captureStats`](#captureStats).
+-}
+type alias FileStats =
+    { fullPath : String
+    , sizeInBytes : Int
+    , lastContentChange : Time.Posix
+    , lastAccess : Time.Posix
+    , lastFileChange : Time.Posix
+    , createdAt : Time.Posix
+    , isDirectory : Bool
+    }
+
+
+{-|
+
+    import BackendTask.Glob as Glob
+
+    recentlyChangedRouteModules : BackendTask error (List ( Time.Posix, List String ))
+    recentlyChangedRouteModules =
+        Glob.succeed
+            (\fileStats directoryName fileName ->
+                ( fileStats.lastContentChange
+                , directoryName ++ [ fileName ]
+                )
+            )
+            |> Glob.captureStats
+            |> Glob.match (Glob.literal "app/Route/")
+            |> Glob.capture Glob.recursiveWildcard
+            |> Glob.match (Glob.literal "/")
+            |> Glob.capture Glob.wildcard
+            |> Glob.match (Glob.literal ".elm")
+            |> Glob.toBackendTask
+            |> BackendTask.map
+                (\entries ->
+                    entries
+                        |> List.sortBy (\( lastChanged, _ ) -> Time.posixToMillis lastChanged)
+                        |> List.reverse
+                )
+
+-}
+captureStats : Glob (FileStats -> value) -> Glob value
+captureStats =
+    capture
+        (Glob ""
+            (\fileStats _ captures ->
+                ( fileStats
+                    |> Maybe.withDefault
+                        { fullPath = "ERROR"
+                        , sizeInBytes = -1
+                        , lastContentChange = Time.millisToPosix 0
+                        , lastAccess = Time.millisToPosix 0
+                        , lastFileChange = Time.millisToPosix 0
+                        , createdAt = Time.millisToPosix 0
+                        , isDirectory = True
+                        }
+                , captures
+                )
+            )
+        )
+
+
+fullStats : Glob String
+fullStats =
+    Glob ""
+        (\_ fullPath captures ->
+            ( fullPath, captures )
+        )
+
+
 {-| Matches anything except for a `/` in a file path. You may be familiar with this syntax from shells like bash
 where you can run commands like `rm client/*.js` to remove all `.js` files in the `client` directory.
 
@@ -410,7 +497,7 @@ will match _within_ a path part (think between the slashes of a file path). `rec
 wildcard : Glob String
 wildcard =
     Glob "*"
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 first :: rest ->
                     ( first, rest )
@@ -428,7 +515,7 @@ See [`int`](#int) for a convenience function to get an Int value instead of a St
 digits : Glob String
 digits =
     Glob "([0-9]+)"
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 first :: rest ->
                     ( first, rest )
@@ -573,7 +660,7 @@ This is usually not what is intended. Using `recursiveWildcard` is usually follo
 recursiveWildcard : Glob (List String)
 recursiveWildcard =
     Glob "**"
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 first :: rest ->
                     ( first, rest )
@@ -593,7 +680,7 @@ zeroOrMore matchers =
             ++ (matchers |> String.join "|")
             ++ ")"
         )
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 first :: rest ->
                     ( if first == "" then
@@ -636,7 +723,7 @@ blogPosts =
 -}
 literal : String -> Glob String
 literal string =
-    Glob string (\_ captures -> ( string, captures ))
+    Glob string (\_ _ captures -> ( string, captures ))
 
 
 {-| Adds on to the glob pattern, but does not capture it in the resulting Elm match value. That means this changes which
@@ -649,17 +736,17 @@ match : Glob a -> Glob value -> Glob value
 match (Glob matcherPattern apply1) (Glob pattern apply2) =
     Glob
         (pattern ++ matcherPattern)
-        (\fullPath captures ->
+        (\fileStats_ fullPath captures ->
             let
                 ( _, captured1 ) =
                     -- apply to make sure we drop from the captures list for all capturing patterns
                     -- but don't change the return value
                     captures
-                        |> apply1 fullPath
+                        |> apply1 fileStats_ fullPath
 
                 ( applied2, captured2 ) =
                     captured1
-                        |> apply2 fullPath
+                        |> apply2 fileStats_ fullPath
             in
             ( applied2
             , captured2
@@ -717,15 +804,15 @@ capture : Glob a -> Glob (a -> value) -> Glob value
 capture (Glob matcherPattern apply1) (Glob pattern apply2) =
     Glob
         (pattern ++ matcherPattern)
-        (\fullPath captures ->
+        (\fileStats fullPath captures ->
             let
                 ( applied1, captured1 ) =
                     captures
-                        |> apply1 fullPath
+                        |> apply1 fileStats fullPath
 
                 ( applied2, captured2 ) =
                     captured1
-                        |> apply2 fullPath
+                        |> apply2 fileStats fullPath
             in
             ( applied1 |> applied2
             , captured2
@@ -828,7 +915,7 @@ oneOf ( defaultMatch, otherMatchers ) =
             ++ (allMatchers |> List.map Tuple.first |> String.join ",")
             ++ "}"
         )
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 match_ :: rest ->
                     ( allMatchers
@@ -862,7 +949,7 @@ atLeastOne ( defaultMatch, otherMatchers ) =
             ++ (allMatchers |> List.map Tuple.first |> String.join "|")
             ++ ")"
         )
-        (\_ captures ->
+        (\_ _ captures ->
             case captures of
                 match_ :: rest ->
                     ( --( allMatchers
@@ -956,8 +1043,27 @@ encodeOptions options =
     , ( "caseSensitiveMatch", Encode.bool options.caseSensitiveMatch ) |> Just
     , ( "gitignore", Encode.bool options.gitignore ) |> Just
     , options.maxDepth |> Maybe.map (\depth -> ( "deep", Encode.int depth ))
-    , ( "onlyFiles", options.include == OnlyFiles || options.include == FilesAndFolders |> Encode.bool ) |> Just
-    , ( "onlyDirectories", options.include == OnlyFolders || options.include == FilesAndFolders |> Encode.bool ) |> Just
+    , ( "onlyFiles"
+      , (if options.include == FilesAndFolders then
+            False
+
+         else
+            options.include == OnlyFiles
+        )
+            |> Encode.bool
+      )
+        |> Just
+    , ( "onlyDirectories"
+      , (if options.include == FilesAndFolders then
+            False
+
+         else
+            options.include == OnlyFolders
+        )
+            |> Encode.bool
+      )
+        |> Just
+    , ( "stats", Encode.bool True ) |> Just
     ]
         |> List.filterMap identity
         |> Encode.object
@@ -975,16 +1081,30 @@ encodeOptions options =
 -}
 toBackendTaskWithOptions : Options -> Glob a -> BackendTask error (List a)
 toBackendTaskWithOptions options glob =
+    let
+        pattern : String
+        pattern =
+            BackendTask.Internal.Glob.toPattern glob
+    in
     BackendTask.Internal.Request.request
         { name = "glob"
         , body =
             Encode.object
-                [ ( "pattern", Encode.string <| BackendTask.Internal.Glob.toPattern glob )
+                [ ( "pattern"
+                  , Encode.string <|
+                        -- workaround for https://github.com/micromatch/micromatch/issues/217
+                        if String.startsWith "./" pattern then
+                            String.dropLeft 2 pattern
+
+                        else
+                            pattern
+                  )
                 , ( "options", encodeOptions options )
                 ]
                 |> BackendTask.Http.jsonBody
         , expect =
-            Decode.map2 (\fullPath captures -> { fullPath = fullPath, captures = captures })
+            Decode.map3 (\fileStats fullPath captures -> { fileStats = fileStats, fullPath = fullPath, captures = captures })
+                (Decode.field "fileStats" (Decode.maybe fileStatsDecoder))
                 (Decode.field "fullPath" Decode.string)
                 (Decode.field "captures" (Decode.list Decode.string))
                 |> Decode.list
@@ -992,8 +1112,8 @@ toBackendTaskWithOptions options glob =
                     (\rawGlob ->
                         rawGlob
                             |> List.map
-                                (\{ fullPath, captures } ->
-                                    BackendTask.Internal.Glob.run fullPath captures glob
+                                (\{ fileStats, fullPath, captures } ->
+                                    BackendTask.Internal.Glob.run fileStats fullPath captures glob
                                         |> .match
                                 )
                     )
@@ -1003,6 +1123,18 @@ toBackendTaskWithOptions options glob =
             (\_ -> BackendTask.succeed [])
 
 
+fileStatsDecoder : Decode.Decoder FileStats
+fileStatsDecoder =
+    Decode.map7 FileStats
+        (Decode.field "fullPath" Decode.string)
+        (Decode.field "size" Decode.int)
+        (Decode.field "mtime" Decode.int |> Decode.map Time.millisToPosix)
+        (Decode.field "atime" Decode.int |> Decode.map Time.millisToPosix)
+        (Decode.field "ctime" Decode.int |> Decode.map Time.millisToPosix)
+        (Decode.field "birthtime" Decode.int |> Decode.map Time.millisToPosix)
+        (Decode.field "isDirectory" Decode.bool)
+
+
 {-| Sometimes you want to make sure there is a unique file matching a particular pattern.
 This is a simple helper that will give you a `BackendTask` error if there isn't exactly 1 matching file.
 If there is exactly 1, then you successfully get back that single match.
@@ -1108,3 +1240,54 @@ toPatternString glob =
     case glob of
         Glob pattern_ _ ->
             pattern_
+
+
+{-| Runs a glob string directly, with `include = FilesAndFolders`. Behavior is similar to using glob patterns in a shell.
+
+If you need to capture specific parts of the path, you can use `capture` and `match` functions instead. `fromString`
+only allows you to capture a list of matching file paths.
+
+The following glob syntax is supported:
+
+  - `*` matches any number of characters except for `/`
+  - `**` matches any number of characters including `/`
+
+For example, if we have the following files:
+
+```shell
+- src/
+    - Main.elm
+    - Ui/
+        - Icon.elm
+- content/
+    - blog/
+        - first-post.md
+        - second-post.md
+```
+
+    import BackendTask.Glob as Glob
+
+    blogPosts : BackendTask error (List String)
+    blogPosts =
+        Glob.fromString "content/blog/*.md"
+
+    --> BackendTask.succeed [ "content/blog/first-post.md", "content/blog/second-post.md" ]
+    elmFiles : BackendTask error (List String)
+    elmFiles =
+        Glob.fromString "src/**/*.elm"
+
+    --> BackendTask.succeed [ "src/Main.elm", "src/Ui", "src/Ui/Icon.elm" ]
+
+-}
+fromString : String -> BackendTask error (List String)
+fromString pattern_ =
+    fromStringWithOptions { defaultOptions | include = FilesAndFolders } pattern_
+
+
+{-| Same as [`fromString`](#fromString), but with custom [`Options`](#Options).
+-}
+fromStringWithOptions : Options -> String -> BackendTask error (List String)
+fromStringWithOptions options pattern_ =
+    Glob pattern_ (\_ _ _ -> ( identity, [] ))
+        |> captureFilePath
+        |> toBackendTaskWithOptions options

package/src/BackendTask/Http.elm

@@ -240,6 +240,9 @@ getWithOptions request__ =
             , headers = request__.headers
             , body = emptyBody
             , method = "GET"
+            , dir = []
+            , env = Dict.empty
+            , quiet = False
             , cacheOptions =
                 { cacheStrategy = request__.cacheStrategy
                 , retries = request__.retries
@@ -406,6 +409,9 @@ request request__ expect =
             , headers = request__.headers
             , method = request__.method
             , body = request__.body
+            , dir = []
+            , env = Dict.empty
+            , quiet = False
             , cacheOptions =
                 { cacheStrategy = Nothing -- cache strategy only applies to GET and HEAD, need to use getWithOptions to customize
                 , cachePath = Nothing
@@ -486,6 +492,9 @@ requestRaw request__ expect =
                     :: request__.headers
             , method = request__.method
             , body = request__.body
+            , dir = []
+            , env = Dict.empty
+            , quiet = False
             , cacheOptions = request__.cacheOptions
             }
     in
@@ -506,7 +515,7 @@ requestRaw request__ expect =
 
                             Nothing ->
                                 --Err (Pages.StaticHttpRequest.UserCalledStaticHttpFail ("INTERNAL ERROR - expected request" ++ request_.url))
-                                Err (BadBody Nothing ("INTERNAL ERROR - expected request" ++ request_.url))
+                                Err (BadBody Nothing ("INTERNAL ERROR - expected request " ++ request_.url))
 
                             Just (Err RequestsAndPending.NetworkError) ->
                                 Err NetworkError
@@ -632,6 +641,24 @@ toResultThing ( expect, body, maybeResponse ) =
             Err (BadBody Nothing "Unexpected combination, internal error")
 
 
+{-| -}
+type alias Metadata =
+    { url : String
+    , statusCode : Int
+    , statusText : String
+    , headers : Dict String String
+    }
+
+
+{-| -}
+type Error
+    = BadUrl String
+    | Timeout
+    | NetworkError
+    | BadStatus Metadata String
+    | BadBody (Maybe Json.Decode.Error) String
+
+
 errorToString : Error -> { title : String, body : String }
 errorToString error =
     { title = "HTTP Error"
@@ -649,8 +676,10 @@ errorToString error =
                 [ TerminalText.text "NetworkError"
                 ]
 
-            BadStatus _ string ->
-                [ TerminalText.text ("BadStatus: " ++ string)
+            BadStatus metadata _ ->
+                [ TerminalText.text "BadStatus: "
+                , TerminalText.red (String.fromInt metadata.statusCode)
+                , TerminalText.text (" " ++ metadata.statusText)
                 ]
 
             BadBody _ string ->
@@ -659,21 +688,3 @@ errorToString error =
         )
             |> TerminalText.toString
     }
-
-
-{-| -}
-type alias Metadata =
-    { url : String
-    , statusCode : Int
-    , statusText : String
-    , headers : Dict String String
-    }
-
-
-{-| -}
-type Error
-    = BadUrl String
-    | Timeout
-    | NetworkError
-    | BadStatus Metadata String
-    | BadBody (Maybe Json.Decode.Error) String

package/src/BackendTask/Internal/Glob.elm

@@ -6,19 +6,31 @@ module BackendTask.Internal.Glob exposing
     )
 
 import List.Extra
+import Time
 
 
 {-| -}
 type Glob a
-    = Glob String (String -> List String -> ( a, List String ))
+    = Glob String (Maybe FileStats -> String -> List String -> ( a, List String ))
 
 
-run : String -> List String -> Glob a -> { match : a, pattern : String }
-run rawInput captures (Glob pattern applyCapture) =
+type alias FileStats =
+    { fullPath : String
+    , sizeInBytes : Int
+    , lastContentChange : Time.Posix
+    , lastAccess : Time.Posix
+    , lastFileChange : Time.Posix
+    , createdAt : Time.Posix
+    , isDirectory : Bool
+    }
+
+
+run : Maybe FileStats -> String -> List String -> Glob a -> { match : a, pattern : String }
+run fileStats rawInput captures (Glob pattern applyCapture) =
     { match =
         captures
             |> List.reverse
-            |> applyCapture rawInput
+            |> applyCapture fileStats rawInput
             |> Tuple.first
     , pattern = pattern
     }