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

package/src/Pages/Manifest.elm

@@ -2,6 +2,7 @@ module Pages.Manifest exposing
     ( Config, Icon
     , init
     , withBackgroundColor, withCategories, withDisplayMode, withIarcRatingId, withLang, withOrientation, withShortName, withThemeColor
+    , withField
     , DisplayMode(..), Orientation(..), IconPurpose(..)
     , generator
     , toJson
@@ -41,6 +42,11 @@ You pass your `Pages.Manifest.Config` record into the `Pages.application` functi
 @docs withBackgroundColor, withCategories, withDisplayMode, withIarcRatingId, withLang, withOrientation, withShortName, withThemeColor
 
 
+## Arbitrary Fields Escape Hatch
+
+@docs withField
+
+
 ## Config options
 
 @docs DisplayMode, Orientation, IconPurpose
@@ -61,6 +67,7 @@ import ApiRoute
 import Color exposing (Color)
 import Color.Convert
 import DataSource exposing (DataSource)
+import Dict exposing (Dict)
 import Head
 import Json.Encode as Encode
 import LanguageTag exposing (LanguageTag, emptySubtags)
@@ -123,6 +130,7 @@ init options =
     , shortName = Nothing
     , icons = options.icons
     , lang = usEnglish
+    , otherFields = Dict.empty
     }
 
 
@@ -191,6 +199,17 @@ withLang languageTag config =
     { config | lang = languageTag }
 
 
+{-| Escape hatch for specifying fields that aren't exposed through this module otherwise. The possible supported properties
+in a manifest file can change over time, so see [MDN manifest.json docs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json)
+for a full listing of the current supported properties.
+-}
+withField : String -> Encode.Value -> Config -> Config
+withField name value config =
+    { config
+        | otherFields = config.otherFields |> Dict.insert name value
+    }
+
+
 orientationToString : Orientation -> String
 orientationToString orientation =
     case orientation of
@@ -239,6 +258,7 @@ type alias Config =
     , shortName : Maybe String
     , icons : List Icon
     , lang : LanguageTag
+    , otherFields : Dict String Encode.Value
     }
 
 
@@ -420,6 +440,10 @@ toJson canonicalSiteUrl config =
       , Encode.string "/" |> Just
       )
     ]
+        ++ (config.otherFields
+                |> Dict.toList
+                |> List.map (Tuple.mapSecond Just)
+           )
         |> encodeMaybeObject
 
 

package/src/Pages/Script.elm

@@ -0,0 +1,100 @@
+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 Html exposing (Html)
+import Json.Decode as Decode
+import Json.Encode as Encode
+
+
+{-| -}
+type Script
+    = Generator
+        ((Maybe { indent : Int, newLines : Bool }
+          -> Html Never
+          -> String
+         )
+         -> Program.Config (DataSource ())
+        )
+
+
+{-| -}
+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 =
+    Generator
+        (\_ ->
+            Program.config
+                |> Program.add
+                    (OptionsParser.build ())
+                |> Program.mapConfig
+                    (\() ->
+                        execute
+                    )
+        )
+
+
+{-| -}
+withCliOptions : Program.Config cliOptions -> (cliOptions -> DataSource ()) -> Script
+withCliOptions config execute =
+    Generator
+        (\_ ->
+            config
+                |> Program.mapConfig execute
+        )

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