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

package/src/Pages/Script.elm

@@ -0,0 +1,94 @@
+module Pages.Script exposing
+    ( Script
+    , withCliOptions, withoutCliOptions
+    , writeFile
+    , log
+    )
+
+{-|
+
+@docs Script
+
+@docs withCliOptions, withoutCliOptions
+
+
+## File System Utilities
+
+@docs writeFile
+
+
+## Utilities
+
+@docs log
+
+-}
+
+import Cli.OptionsParser as OptionsParser
+import Cli.Program as Program
+import DataSource exposing (DataSource)
+import DataSource.Http
+import DataSource.Internal.Request
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Pages.Internal.Script
+
+
+{-| -}
+type alias Script =
+    Pages.Internal.Script.Script
+
+
+{-| -}
+writeFile : { path : String, body : String } -> DataSource ()
+writeFile { path, body } =
+    DataSource.Internal.Request.request
+        { name = "write-file"
+        , body =
+            DataSource.Http.jsonBody
+                (Encode.object
+                    [ ( "path", Encode.string path )
+                    , ( "body", Encode.string body )
+                    ]
+                )
+        , expect = DataSource.Http.expectJson (Decode.succeed ())
+        }
+
+
+{-| -}
+log : String -> DataSource ()
+log message =
+    DataSource.Internal.Request.request
+        { name = "log"
+        , body =
+            DataSource.Http.jsonBody
+                (Encode.object
+                    [ ( "message", Encode.string message )
+                    ]
+                )
+        , expect = DataSource.Http.expectJson (Decode.succeed ())
+        }
+
+
+{-| -}
+withoutCliOptions : DataSource () -> Script
+withoutCliOptions execute =
+    Pages.Internal.Script.Script
+        (\_ ->
+            Program.config
+                |> Program.add
+                    (OptionsParser.build ())
+                |> Program.mapConfig
+                    (\() ->
+                        execute
+                    )
+        )
+
+
+{-| -}
+withCliOptions : Program.Config cliOptions -> (cliOptions -> DataSource ()) -> Script
+withCliOptions config execute =
+    Pages.Internal.Script.Script
+        (\_ ->
+            config
+                |> Program.mapConfig execute
+        )

package/src/Pages/StaticHttpRequest.elm

@@ -118,12 +118,12 @@ cacheRequestResolution :
     -> RequestsAndPending
     -> Status value
 cacheRequestResolution request rawResponses =
-    cacheRequestResolutionHelp [] rawResponses request
+    cacheRequestResolutionHelp [] rawResponses request request
 
 
 type Status value
-    = Incomplete (List Pages.StaticHttp.Request.Request)
-    | HasPermanentError Error
+    = Incomplete (List Pages.StaticHttp.Request.Request) (RawRequest value)
+    | HasPermanentError Error (RawRequest value)
     | Complete
 
 
@@ -131,24 +131,26 @@ cacheRequestResolutionHelp :
     List Pages.StaticHttp.Request.Request
     -> RequestsAndPending
     -> RawRequest value
+    -> RawRequest value
     -> Status value
-cacheRequestResolutionHelp foundUrls rawResponses request =
+cacheRequestResolutionHelp foundUrls rawResponses parentRequest request =
     case request of
         RequestError error ->
             case error of
                 MissingHttpResponse _ _ ->
                     -- TODO do I need to pass through continuation URLs here? -- Incomplete (urlList ++ foundUrls)
-                    Incomplete foundUrls
+                    Incomplete foundUrls parentRequest
 
                 DecoderError _ ->
-                    HasPermanentError error
+                    HasPermanentError error parentRequest
 
                 UserCalledStaticHttpFail _ ->
-                    HasPermanentError error
+                    HasPermanentError error parentRequest
 
         Request urlList lookupFn ->
             cacheRequestResolutionHelp urlList
                 rawResponses
+                request
                 (lookupFn Nothing rawResponses)
 
         ApiRoute _ ->

package/src/PairingHeap.elm

@@ -0,0 +1,137 @@
+module PairingHeap exposing
+    ( PairingHeap, empty
+    , insert, merge, findMin, deleteMin
+    , fromList, toSortedList
+    )
+
+{-| This is a simple pairing heap implementation written in Elm usable as a priority queue. This code is
+based heavily on the pseudocode available at [the Wikipedia page](https://en.wikipedia.org/wiki/Pairing_heap).
+
+
+# Type and Constructor
+
+@docs PairingHeap, empty
+
+
+# Operations
+
+@docs insert, merge, findMin, deleteMin
+
+
+# Convenience functions
+
+@docs fromList, toSortedList
+
+-}
+
+
+{-| A `PairingHeap` has comparable keys and values of an arbitrary type.
+-}
+type PairingHeap comparable a
+    = Empty
+    | Heap comparable a (List (PairingHeap comparable a))
+
+
+{-| Create an empty PairingHeap.
+-}
+empty : PairingHeap comparable a
+empty =
+    Empty
+
+
+{-| Find the minimum value in a heap returning Nothing if the heap is empty.
+Complexity: O(1)
+
+    findMin (fromList [ ( 10, () ), ( 3, () ), ( 8, () ) ]) == Just 3
+
+-}
+findMin : PairingHeap comparable a -> Maybe ( comparable, a )
+findMin x =
+    case x of
+        Empty ->
+            Nothing
+
+        Heap k v _ ->
+            Just ( k, v )
+
+
+{-| Merges two `PairingHeap`s together into one new heap containing all of the key-value pairs from both inputs.
+Complexity: O(1)
+-}
+merge : PairingHeap comparable a -> PairingHeap comparable a -> PairingHeap comparable a
+merge heap1 heap2 =
+    case ( heap1, heap2 ) of
+        ( Empty, _ ) ->
+            heap2
+
+        ( _, Empty ) ->
+            heap1
+
+        ( Heap k1 v1 hs1, Heap k2 v2 hs2 ) ->
+            if k1 < k2 then
+                Heap k1 v1 (heap2 :: hs1)
+
+            else
+                Heap k2 v2 (heap1 :: hs2)
+
+
+{-| Inserts a new element into a `PairingHeap`.
+Complexity: O(1)
+-}
+insert : comparable -> a -> PairingHeap comparable a -> PairingHeap comparable a
+insert k v heap =
+    merge (Heap k v []) heap
+
+
+{-| Removes the minimum element from a `PairingHeap` returning a new heap without that element.
+This will return an empty heap if given an empty heap as input.
+Complexity: O(log n)
+-}
+deleteMin : PairingHeap comparable a -> PairingHeap comparable a
+deleteMin heap =
+    case heap of
+        Empty ->
+            Empty
+
+        Heap k v heaps ->
+            mergePairs heaps
+
+
+{-| This is an internal function used by deleteMin.
+-}
+mergePairs : List (PairingHeap comparable a) -> PairingHeap comparable a
+mergePairs heaps =
+    case heaps of
+        [] ->
+            Empty
+
+        x :: [] ->
+            x
+
+        x :: (y :: xs) ->
+            merge (merge x y) (mergePairs xs)
+
+
+
+-- Extra convenience functions
+
+
+{-| This function turns a list of key-value pairs into a `PairingHeap`.
+Complexity: O(n)
+-}
+fromList : List ( comparable, a ) -> PairingHeap comparable a
+fromList =
+    List.foldl (\( k, v ) -> insert k v) empty
+
+
+{-| This function turns a `PairingHeap` into a sorted list of key-value pairs.
+Complexity: O(n log n)
+-}
+toSortedList : PairingHeap comparable a -> List ( comparable, a )
+toSortedList heap =
+    case heap of
+        Empty ->
+            []
+
+        Heap k v _ ->
+            ( k, v ) :: toSortedList (deleteMin heap)

package/src/Parser/Extra/String.elm

@@ -0,0 +1,33 @@
+module Parser.Extra.String exposing (string)
+
+import Parser exposing (..)
+
+
+string : Parser String
+string =
+    succeed identity
+        |. token "\""
+        |= loop [] stringHelp
+
+
+stringHelp : List String -> Parser (Step (List String) String)
+stringHelp revChunks =
+    oneOf
+        [ succeed (\chunk -> Loop (chunk :: revChunks))
+            |. token "\\"
+            |= oneOf
+                [ map (\_ -> "\n") (token "n")
+                , map (\_ -> "\t") (token "t")
+                , map (\_ -> "\u{000D}") (token "r")
+                ]
+        , token "\""
+            |> map (\_ -> Done (String.join "" (List.reverse revChunks)))
+        , chompWhile isUninteresting
+            |> getChompedString
+            |> map (\chunk -> Loop (chunk :: revChunks))
+        ]
+
+
+isUninteresting : Char -> Bool
+isUninteresting char =
+    char /= '\\' && char /= '"'

package/src/Parser/Extra.elm

@@ -0,0 +1,69 @@
+module Parser.Extra exposing (deadEndsToString)
+
+{-| [No implementation for deadEndsToString · Issue #9 · elm/parser](https://github.com/elm/parser/issues/9)
+-}
+
+import Parser exposing (DeadEnd, Problem(..))
+
+
+deadEndsToString : List DeadEnd -> String
+deadEndsToString deadEnds =
+    String.join "\n" (List.map deadEndToString deadEnds)
+
+
+deadEndToString : DeadEnd -> String
+deadEndToString deadEnd =
+    problemToString deadEnd.problem
+        ++ " at "
+        ++ deadEndToRowColString deadEnd
+
+
+problemToString : Problem -> String
+problemToString prob =
+    case prob of
+        Expecting s ->
+            "Expecting " ++ s
+
+        ExpectingInt ->
+            "Expecting Int"
+
+        ExpectingHex ->
+            "Expecting Hex"
+
+        ExpectingOctal ->
+            "Expecting Octal"
+
+        ExpectingBinary ->
+            "Expecting Binary"
+
+        ExpectingFloat ->
+            "Expecting Float"
+
+        ExpectingNumber ->
+            "Expecting Number"
+
+        ExpectingVariable ->
+            "Expecting Variable"
+
+        ExpectingSymbol s ->
+            "Expecting Symbol " ++ s
+
+        ExpectingKeyword s ->
+            "Expecting Keyword " ++ s
+
+        ExpectingEnd ->
+            "Expecting End"
+
+        UnexpectedChar ->
+            "Unexpected Char"
+
+        Problem s ->
+            "Problem: " ++ s
+
+        BadRepeat ->
+            "Bad Repeat"
+
+
+deadEndToRowColString : DeadEnd -> String
+deadEndToRowColString deadEnd =
+    "row " ++ String.fromInt deadEnd.row ++ ", " ++ "col " ++ String.fromInt deadEnd.col