elm-rails 0.1.2 → 0.2.0

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Task.elm

@@ -0,0 +1,278 @@
+effect module Task where { command = MyCmd } exposing
+  ( Task
+  , succeed, fail
+  , map, map2, map3, map4, map5
+  , sequence
+  , andThen
+  , onError, mapError
+  , perform, attempt
+  )
+
+{-| Tasks make it easy to describe asynchronous operations that may fail, like
+HTTP requests or writing to a database. For more information, see the [Elm
+documentation on Tasks](http://guide.elm-lang.org/error_handling/task.html).
+
+# Basics
+@docs Task, succeed, fail
+
+# Mapping
+@docs map, map2, map3, map4, map5
+
+# Chaining
+@docs andThen, sequence
+
+# Errors
+@docs onError, mapError
+
+# Commands
+@docs perform, attempt
+
+-}
+
+import Basics exposing (Never, (|>), (<<))
+import List exposing ((::))
+import Maybe exposing (Maybe(Just,Nothing))
+import Native.Scheduler
+import Platform
+import Platform.Cmd exposing (Cmd)
+import Result exposing (Result(Ok,Err))
+
+
+
+{-| Represents asynchronous effects that may fail. It is useful for stuff like
+HTTP.
+
+For example, maybe we have a task with the type (`Task String User`). This means
+that when we perform the task, it will either fail with a `String` message or
+succeed with a `User`. So this could represent a task that is asking a server
+for a certain user.
+-}
+type alias Task err ok =
+  Platform.Task err ok
+
+
+
+-- BASICS
+
+
+{-| A task that succeeds immediately when run.
+
+    succeed 42    -- results in 42
+-}
+succeed : a -> Task x a
+succeed =
+  Native.Scheduler.succeed
+
+
+{-| A task that fails immediately when run.
+
+    fail "file not found" : Task String a
+-}
+fail : x -> Task x a
+fail =
+  Native.Scheduler.fail
+
+
+
+-- MAPPING
+
+
+{-| Transform a task.
+
+    map sqrt (succeed 9) -- succeed 3
+-}
+map : (a -> b) -> Task x a -> Task x b
+map func taskA =
+  taskA
+    |> andThen (\a -> succeed (func a))
+
+
+{-| Put the results of two tasks together. If either task fails, the whole
+thing fails. It also runs in order so the first task will be completely
+finished before the second task starts.
+
+    map2 (+) (succeed 9) (succeed 3) -- succeed 12
+-}
+map2 : (a -> b -> result) -> Task x a -> Task x b -> Task x result
+map2 func taskA taskB =
+  taskA
+    |> andThen (\a -> taskB
+    |> andThen (\b -> succeed (func a b)))
+
+
+{-|-}
+map3 : (a -> b -> c -> result) -> Task x a -> Task x b -> Task x c -> Task x result
+map3 func taskA taskB taskC =
+  taskA
+    |> andThen (\a -> taskB
+    |> andThen (\b -> taskC
+    |> andThen (\c -> succeed (func a b c))))
+
+
+{-|-}
+map4 : (a -> b -> c -> d -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x result
+map4 func taskA taskB taskC taskD =
+  taskA
+    |> andThen (\a -> taskB
+    |> andThen (\b -> taskC
+    |> andThen (\c -> taskD
+    |> andThen (\d -> succeed (func a b c d)))))
+
+
+{-|-}
+map5 : (a -> b -> c -> d -> e -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x e -> Task x result
+map5 func taskA taskB taskC taskD taskE =
+  taskA
+    |> andThen (\a -> taskB
+    |> andThen (\b -> taskC
+    |> andThen (\c -> taskD
+    |> andThen (\d -> taskE
+    |> andThen (\e -> succeed (func a b c d e))))))
+
+
+{-| Start with a list of tasks, and turn them into a single task that returns a
+list. The tasks will be run in order one-by-one and if any task fails the whole
+sequence fails.
+
+    sequence [ succeed 1, succeed 2 ] -- succeed [ 1, 2 ]
+
+This can be useful if you need to make a bunch of HTTP requests one-by-one.
+-}
+sequence : List (Task x a) -> Task x (List a)
+sequence tasks =
+  case tasks of
+    [] ->
+      succeed []
+
+    task :: remainingTasks ->
+      map2 (::) task (sequence remainingTasks)
+
+
+
+-- CHAINING
+
+
+{-| Chain together a task and a callback. The first task will run, and if it is
+successful, you give the result to the callback resulting in another task. This
+task then gets run.
+
+    succeed 2
+      |> andThen (\n -> succeed (n + 2))
+      -- succeed 4
+
+This is useful for chaining tasks together. Maybe you need to get a user from
+your servers *and then* lookup their picture once you know their name.
+-}
+andThen : (a -> Task x b) -> Task x a -> Task x b
+andThen =
+  Native.Scheduler.andThen
+
+
+-- ERRORS
+
+{-| Recover from a failure in a task. If the given task fails, we use the
+callback to recover.
+
+    fail "file not found"
+      |> onError (\msg -> succeed 42)
+      -- succeed 42
+
+    succeed 9
+      |> onError (\msg -> succeed 42)
+      -- succeed 9
+-}
+onError : (x -> Task y a) -> Task x a -> Task y a
+onError =
+  Native.Scheduler.onError
+
+
+{-| Transform the error value. This can be useful if you need a bunch of error
+types to match up.
+
+    type Error = Http Http.Error | WebGL WebGL.Error
+
+    getResources : Task Error Resource
+    getResources =
+      sequence [ mapError Http serverTask, mapError WebGL textureTask ]
+-}
+mapError : (x -> y) -> Task x a -> Task y a
+mapError convert task =
+  task
+    |> onError (fail << convert)
+
+
+
+-- COMMANDS
+
+
+type MyCmd msg =
+  Perform (Task Never msg)
+
+
+{-| The only way to *do* things in Elm is to give commands to the Elm runtime.
+So we describe some complex behavior with a `Task` and then command the runtime
+to `perform` that task. For example, getting the current time looks like this:
+
+    import Task
+    import Time exposing (Time)
+
+    type Msg = Click | NewTime Time
+
+    update : Msg -> Model -> Model
+    update msg model =
+      case msg of
+        Click ->
+          ( model, Task.perform NewTime Time.now )
+
+        NewTime time ->
+          ...
+-}
+perform : (a -> msg) -> Task Never a -> Cmd msg
+perform toMessage task =
+  command (Perform (map toMessage task))
+
+
+{-| Command the Elm runtime to attempt a task that might fail!
+-}
+attempt : (Result x a -> msg) -> Task x a -> Cmd msg
+attempt resultToMessage task =
+  command (Perform (
+    task
+      |> andThen (succeed << resultToMessage << Ok)
+      |> onError (succeed << resultToMessage << Err)
+  ))
+
+
+cmdMap : (a -> b) -> MyCmd a -> MyCmd b
+cmdMap tagger (Perform task) =
+  Perform (map tagger task)
+
+
+
+-- MANAGER
+
+
+init : Task Never ()
+init =
+  succeed ()
+
+
+onEffects : Platform.Router msg Never -> List (MyCmd msg) -> () -> Task Never ()
+onEffects router commands state =
+  map
+    (\_ -> ())
+    (sequence (List.map (spawnCmd router) commands))
+
+
+onSelfMsg : Platform.Router msg Never -> Never -> () -> Task Never ()
+onSelfMsg _ _ _ =
+  succeed ()
+
+
+spawnCmd : Platform.Router msg Never -> MyCmd msg -> Task x ()
+spawnCmd router (Perform task) =
+  Native.Scheduler.spawn (
+    task
+      |> andThen (Platform.sendToApp router)
+  )
+

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Time.elm

@@ -0,0 +1,243 @@
+effect module Time where { subscription = MySub } exposing
+  ( Time
+  , now, every
+  , millisecond, second, minute, hour
+  , inMilliseconds, inSeconds, inMinutes, inHours
+  )
+
+{-| Library for working with time.
+
+# Time
+@docs Time, now, every
+
+# Units
+@docs millisecond, second, minute, hour,
+  inMilliseconds, inSeconds, inMinutes, inHours
+
+-}
+
+
+import Basics exposing (..)
+import Dict
+import List exposing ((::))
+import Maybe exposing (Maybe(..))
+import Native.Scheduler
+import Native.Time
+import Platform
+import Platform.Sub exposing (Sub)
+import Task exposing (Task)
+
+
+
+-- TIMES
+
+
+{-| Type alias to make it clearer when you are working with time values.
+Using the `Time` helpers like `second` and `inSeconds` instead of raw numbers
+is very highly recommended.
+-}
+type alias Time = Float
+
+
+{-| Get the `Time` at the moment when this task is run.
+-}
+now : Task x Time
+now =
+  Native.Time.now
+
+
+{-| Subscribe to the current time. First you provide an interval describing how
+frequently you want updates. Second, you give a tagger that turns a time into a
+message for your `update` function. So if you want to hear about the current
+time every second, you would say something like this:
+
+    type Msg = Tick Time | ...
+
+    subscriptions model =
+      every second Tick
+
+Check out the [Elm Architecture Tutorial][arch] for more info on how
+subscriptions work.
+
+[arch]: https://github.com/evancz/elm-architecture-tutorial/
+
+**Note:** this function is not for animation! You need to use something based
+on `requestAnimationFrame` to get smooth animations. This is based on
+`setInterval` which is better for recurring tasks like “check on something
+every 30 seconds”.
+-}
+every : Time -> (Time -> msg) -> Sub msg
+every interval tagger =
+  subscription (Every interval tagger)
+
+
+
+-- UNITS
+
+
+{-| Units of time, making it easier to specify things like a half-second
+`(500 * millisecond)` without remembering Elm’s underlying units of time.
+-}
+millisecond : Time
+millisecond =
+  1
+
+
+{-|-}
+second : Time
+second =
+  1000 * millisecond
+
+
+{-|-}
+minute : Time
+minute =
+  60 * second
+
+
+{-|-}
+hour : Time
+hour =
+  60 * minute
+
+
+{-|-}
+inMilliseconds : Time -> Float
+inMilliseconds t =
+  t
+
+
+{-|-}
+inSeconds : Time -> Float
+inSeconds t =
+  t / second
+
+
+{-|-}
+inMinutes : Time -> Float
+inMinutes t =
+  t / minute
+
+
+{-|-}
+inHours : Time -> Float
+inHours t =
+  t / hour
+
+
+
+-- SUBSCRIPTIONS
+
+
+type MySub msg =
+  Every Time (Time -> msg)
+
+
+subMap : (a -> b) -> MySub a -> MySub b
+subMap f (Every interval tagger) =
+  Every interval (f << tagger)
+
+
+
+-- EFFECT MANAGER
+
+
+type alias State msg =
+  { taggers : Taggers msg
+  , processes : Processes
+  }
+
+
+type alias Processes =
+  Dict.Dict Time Platform.ProcessId
+
+
+type alias Taggers msg =
+  Dict.Dict Time (List (Time -> msg))
+
+
+init : Task Never (State msg)
+init =
+  Task.succeed (State Dict.empty Dict.empty)
+
+
+onEffects : Platform.Router msg Time -> List (MySub msg) -> State msg -> Task Never (State msg)
+onEffects router subs {processes} =
+  let
+    newTaggers =
+      List.foldl addMySub Dict.empty subs
+
+    leftStep interval taggers (spawnList, existingDict, killTask) =
+      (interval :: spawnList, existingDict, killTask)
+
+    bothStep interval taggers id (spawnList, existingDict, killTask) =
+      (spawnList, Dict.insert interval id existingDict, killTask)
+
+    rightStep _ id (spawnList, existingDict, killTask) =
+      ( spawnList
+      , existingDict
+      , Native.Scheduler.kill id
+          |> Task.andThen (\_ -> killTask)
+      )
+
+    (spawnList, existingDict, killTask) =
+      Dict.merge
+        leftStep
+        bothStep
+        rightStep
+        newTaggers
+        processes
+        ([], Dict.empty, Task.succeed ())
+  in
+    killTask
+      |> Task.andThen (\_ -> spawnHelp router spawnList existingDict)
+      |> Task.andThen (\newProcesses -> Task.succeed (State newTaggers newProcesses))
+
+
+addMySub : MySub msg -> Taggers msg -> Taggers msg
+addMySub (Every interval tagger) state =
+  case Dict.get interval state of
+    Nothing ->
+      Dict.insert interval [tagger] state
+
+    Just taggers ->
+      Dict.insert interval (tagger :: taggers) state
+
+
+spawnHelp : Platform.Router msg Time -> List Time -> Processes -> Task.Task x Processes
+spawnHelp router intervals processes =
+  case intervals of
+    [] ->
+      Task.succeed processes
+
+    interval :: rest ->
+      let
+        spawnTimer =
+          Native.Scheduler.spawn (setInterval interval (Platform.sendToSelf router interval))
+
+        spawnRest id =
+          spawnHelp router rest (Dict.insert interval id processes)
+      in
+        spawnTimer
+          |> Task.andThen spawnRest
+
+
+onSelfMsg : Platform.Router msg Time -> Time -> State msg -> Task Never (State msg)
+onSelfMsg router interval state =
+  case Dict.get interval state.taggers of
+    Nothing ->
+      Task.succeed state
+
+    Just taggers ->
+      let
+        tellTaggers time =
+          Task.sequence (List.map (\tagger -> Platform.sendToApp router (tagger time)) taggers)
+      in
+        now
+          |> Task.andThen tellTaggers
+          |> Task.andThen (\_ -> Task.succeed state)
+
+
+setInterval : Time -> Task Never () -> Task x Never
+setInterval =
+  Native.Time.setInterval_

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Tuple.elm

@@ -0,0 +1,61 @@
+module Tuple exposing
+  ( first, second
+  , mapFirst, mapSecond
+  )
+
+{-| Some helpers for working with 2-tuples.
+
+**Note:** For larger chunks of data, it is best to switch to using records. So
+instead of representing a 3D point as `(3,4,5)` and wondering why there are no
+helper functions, represent it as `{ x = 3, y = 4, z = 5 }` and use all the
+built-in syntax for records.
+
+@docs first, second, mapFirst, mapSecond
+
+-}
+
+
+
+{-| Extract the first value from a tuple.
+
+    first (3, 4) == 3
+    first ("john", "doe") == "john"
+-}
+first : (a1, a2) -> a1
+first (x,_) =
+  x
+
+
+{-| Extract the second value from a tuple.
+
+    second (3, 4) == 4
+    second ("john", "doe") == "doe"
+-}
+second : (a1, a2) -> a2
+second (_,y) =
+  y
+
+
+{-| Transform the first value in a tuple.
+
+    import String
+
+    mapFirst String.reverse ("stressed", 16) == ("desserts", 16)
+    mapFirst String.length  ("stressed", 16) == (8, 16)
+-}
+mapFirst : (a -> b) -> (a, a2) -> (b, a2)
+mapFirst func (x,y) =
+  (func x, y)
+
+
+{-| Transform the second value in a tuple.
+
+    import String
+
+    mapSecond sqrt          ("stressed", 16) == ("stressed", 4)
+    mapSecond (\x -> x + 1) ("stressed", 16) == ("stressed", 17)
+-}
+mapSecond : (a -> b) -> (a1, a) -> (a1, b)
+mapSecond func (x,y) =
+  (x, func y)
+

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Array.elm

@@ -0,0 +1,90 @@
+module Test.Array exposing (tests)
+
+import Array
+import Basics exposing (..)
+import List
+import List exposing ((::))
+import Maybe exposing (..)
+import Native.Array
+
+import ElmTest exposing (..)
+
+mergeSplit : Int -> Array.Array a -> Array.Array a
+mergeSplit n arr =
+  let left = Array.slice 0 n arr
+      right = Array.slice n (Array.length arr) arr
+  in Array.append left right
+
+holeArray : Array.Array Int
+holeArray = List.foldl mergeSplit (Array.fromList [0..100]) [0..100]
+
+mapArray: Array.Array a -> Array.Array a
+mapArray array =
+    Array.indexedMap (\i el ->
+        case (Array.get i array) of
+            Just x -> x
+            Nothing -> el
+    ) array
+
+tests : Test
+tests =
+  let creationTests = suite "Creation"
+        [ test "empty" <| assertEqual Array.empty (Array.fromList [])
+        , test "initialize" <| assertEqual (Array.initialize 4 identity) (Array.fromList [0,1,2,3])
+        , test "initialize 2" <| assertEqual (Array.initialize 4 (\n -> n*n)) (Array.fromList [0,1,4,9])
+        , test "initialize 3" <| assertEqual (Array.initialize 4 (always 0)) (Array.fromList [0,0,0,0])
+        , test "initialize Empty" <| assertEqual (Array.initialize 0 identity) Array.empty
+        , test "initialize 4" <| assertEqual (Array.initialize 2 (always 0)) (Array.fromList [0,0])
+        , test "initialize negative" <| assertEqual (Array.initialize -1 identity) Array.empty
+        , test "repeat" <| assertEqual (Array.repeat 5 40) (Array.fromList [40,40,40,40,40])
+        , test "repeat 2" <| assertEqual (Array.repeat 5 0) (Array.fromList [0,0,0,0,0])
+        , test "repeat 3" <| assertEqual (Array.repeat 3 "cat") (Array.fromList ["cat","cat","cat"])
+        , test "fromList" <| assertEqual (Array.fromList []) Array.empty
+        ]
+      basicsTests = suite "Basics"
+        [ test "length" <| assertEqual 3 (Array.length (Array.fromList [1,2,3]))
+        , test "length - Long" <| assertEqual 10000 (Array.length (Array.repeat 10000 0))
+        , test "push" <| assertEqual (Array.fromList [1,2,3]) (Array.push 3 (Array.fromList [1,2]))
+        , test "append" <| assertEqual [42,42,81,81,81] (Array.toList (Array.append (Array.repeat 2 42) (Array.repeat 3 81)))
+        , test "appendEmpty 1" <| assertEqual [1..33] (Array.toList (Array.append Array.empty (Array.fromList [1..33])))
+        , test "appendEmpty 2" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..33]) Array.empty))
+        , test "appendSmall 1" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..30]) (Array.fromList [31..33])))
+        , test "appendSmall 2" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..3]) (Array.fromList [4..33])))
+        , test "appendAndSlice" <| assertEqual [0..100] (Array.toList holeArray)
+        ]
+      getAndSetTests = suite "Get and Set"
+        [ test "get" <| assertEqual (Just 2) (Array.get 1 (Array.fromList [3,2,1]))
+        , test "get 2" <| assertEqual Nothing (Array.get 5 (Array.fromList [3,2,1]))
+        , test "get 3" <| assertEqual Nothing (Array.get -1 (Array.fromList [3,2,1]))
+        , test "set" <| assertEqual (Array.fromList [1,7,3]) (Array.set 1 7 (Array.fromList [1,2,3]))
+        ]
+      takingArraysApartTests = suite "Taking Arrays Apart"
+        [ test "toList" <| assertEqual [3,5,8] (Array.toList (Array.fromList [3,5,8]))
+        , test "toIndexedList" <| assertEqual [(0,"cat"), (1,"dog")] (Array.toIndexedList (Array.fromList ["cat","dog"]))
+        , test "slice 1" <| assertEqual (Array.fromList [0,1,2]) (Array.slice  0  3 (Array.fromList [0,1,2,3,4]))
+        , test "slice 2" <| assertEqual (Array.fromList [1,2,3]) (Array.slice  1  4 (Array.fromList [0,1,2,3,4]))
+        , test "slice 3" <| assertEqual (Array.fromList [1,2,3]) (Array.slice  1 -1 (Array.fromList [0,1,2,3,4]))
+        , test "slice 4" <| assertEqual (Array.fromList [2])     (Array.slice -3 -2 (Array.fromList [0,1,2,3,4]))
+        , test "slice 5" <| assertEqual 63 (Array.length <| Array.slice 65 (65 + 63) <| Array.fromList [1..200])
+        ]
+      mappingAndFoldingTests = suite "Mapping and Folding"
+        [ test "map" <| assertEqual (Array.fromList [1,2,3]) (Array.map sqrt (Array.fromList [1,4,9]))
+        , test "indexedMap 1" <| assertEqual (Array.fromList [0,5,10]) (Array.indexedMap (*) (Array.fromList [5,5,5]))
+        , test "indexedMap 2" <| assertEqual [0..99] (Array.toList (Array.indexedMap always (Array.repeat 100 0)))
+        , test "large indexed map" <| assertEqual [0..32768 - 1] (Array.toList <| mapArray <| Array.initialize 32768 identity)
+        , test "foldl 1" <| assertEqual [3,2,1] (Array.foldl (::) [] (Array.fromList [1,2,3]))
+        , test "foldl 2" <| assertEqual 33 (Array.foldl (+) 0 (Array.repeat 33 1))
+        , test "foldr 1" <| assertEqual 15 (Array.foldr (+) 0 (Array.repeat 3 5))
+        , test "foldr 2" <| assertEqual [1,2,3] (Array.foldr (::) [] (Array.fromList [1,2,3]))
+        , test "foldr 3" <| assertEqual 53 (Array.foldr (-) 54 (Array.fromList [10,11]))
+        , test "filter" <| assertEqual (Array.fromList [2,4,6]) (Array.filter (\x -> x % 2 == 0) (Array.fromList [1..6]))
+        ]
+
+      nativeTests = suite "Conversion to JS Arrays"
+        [ test "jsArrays" <| assertEqual (Array.fromList [1..1100]) (Native.Array.fromJSArray (Native.Array.toJSArray (Array.fromList [1..1100])))
+        ]
+  in
+      suite "Array"
+        [ creationTests, basicsTests, getAndSetTests
+        , takingArraysApartTests, mappingAndFoldingTests, nativeTests
+        ]