elm-rails 0.1.2 → 0.2.0

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/List.elm

@@ -0,0 +1,165 @@
+module Test.List exposing (tests)
+
+import ElmTest exposing (..)
+
+import Basics exposing (..)
+import Maybe exposing (Maybe(Nothing, Just))
+import List exposing (..)
+
+
+tests : Test
+tests = suite "List Tests"
+  [ testListOfN 0
+  , testListOfN 1
+  , testListOfN 2
+  , testListOfN 5000
+  ]
+
+
+testListOfN : Int -> Test
+testListOfN n =
+  let xs = [1..n]
+      xsOpp = [(-n)..(-1)]
+      xsNeg = foldl (::) [] xsOpp -- assume foldl and (::) work
+      zs = [0..n]
+      sumSeq k = k * (k + 1) // 2
+      xsSum = sumSeq n
+      mid = n // 2
+  in
+      suite (toString n ++ " elements")
+        [ suite "foldl"
+            [ test "order" <| assertEqual (n) (foldl (\x acc -> x) 0 xs)
+            , test "total" <| assertEqual (xsSum) (foldl (+) 0 xs)
+            ]
+
+        , suite "foldr"
+            [ test "order" <| assertEqual (min 1 n) (foldr (\x acc -> x) 0 xs)
+            , test "total" <| assertEqual (xsSum) (foldl (+) 0 xs)
+            ]
+
+        , suite "map"
+            [ test "identity" <| assertEqual (xs) (map identity xs)
+            , test "linear" <| assertEqual ([2..(n + 1)]) (map ((+) 1) xs)
+            ]
+
+        , test "isEmpty" <| assertEqual (n == 0) (isEmpty xs)
+
+        , test "length" <| assertEqual (n) (length xs)
+
+        , test "reverse" <| assertEqual (xsOpp) (reverse xsNeg)
+
+        , suite "member"
+            [ test "positive" <| assertEqual (True) (member n zs)
+            , test "negative" <| assertEqual (False) (member (n + 1) xs)
+            ]
+
+        , test "head" <|
+            if n == 0
+            then assertEqual (Nothing) (head xs)
+            else assertEqual (Just 1) (head xs)
+
+        , suite "filter"
+            [ test "none" <| assertEqual ([]) (filter (\x -> x > n) xs)
+            , test "one" <| assertEqual ([n]) (filter (\z -> z == n) zs)
+            , test "all" <| assertEqual (xs) (filter (\x -> x <= n) xs)
+            ]
+
+        , suite "take"
+            [ test "none" <| assertEqual ([]) (take 0 xs)
+            , test "some" <| assertEqual ([0..(n - 1)]) (take n zs)
+            , test "all" <| assertEqual (xs) (take n xs)
+            , test "all+" <| assertEqual (xs) (take (n + 1) xs)
+            ]
+
+        , suite "drop"
+            [ test "none" <| assertEqual (xs) (drop 0 xs)
+            , test "some" <| assertEqual ([n]) (drop n zs)
+            , test "all" <| assertEqual ([]) (drop n xs)
+            , test "all+" <| assertEqual ([]) (drop (n + 1) xs)
+            ]
+
+        , test "repeat" <| assertEqual (map (\x -> -1) xs) (repeat n -1)
+
+        , test "append" <| assertEqual (xsSum * 2) (append xs xs |> foldl (+) 0)
+
+        , test "(::)" <| assertEqual (append [-1] xs) (-1 :: xs)
+
+        , test "concat" <| assertEqual (append xs (append zs xs)) (concat [xs, zs, xs])
+
+        , test "intersperse" <| assertEqual
+            (min -(n - 1) 0, xsSum)
+            (intersperse -1 xs |> foldl (\x (c1, c2) -> (c2, c1 + x)) (0, 0))
+
+        , suite "partition"
+            [ test "left" <| assertEqual (xs, []) (partition (\x -> x > 0) xs)
+            , test "right" <| assertEqual ([], xs) (partition (\x -> x < 0) xs)
+            , test "split" <| assertEqual ([mid + 1..n], [1..mid]) (partition (\x -> x > mid) xs)
+            ]
+
+        , suite "map2"
+            [ test "same length" <| assertEqual (map ((*) 2) xs) (map2 (+) xs xs)
+            , test "long first" <| assertEqual (map (\x -> x * 2 - 1) xs) (map2 (+) zs xs)
+            , test "short first" <| assertEqual (map (\x -> x * 2 - 1) xs) (map2 (+) xs zs)
+            ]
+
+        , test "unzip" <| assertEqual (xsNeg, xs) (map (\x -> (-x, x)) xs |> unzip)
+
+        , suite "filterMap"
+            [ test "none" <| assertEqual ([]) (filterMap (\x -> Nothing) xs)
+            , test "all" <| assertEqual (xsNeg) (filterMap (\x -> Just -x) xs)
+            , let halve x =
+                    if x % 2 == 0
+                      then Just (x // 2)
+                      else Nothing
+              in
+                  test "some" <| assertEqual ([1..mid]) (filterMap halve xs)
+            ]
+
+        , suite "concatMap"
+            [ test "none" <| assertEqual ([]) (concatMap (\x -> []) xs)
+            , test "all" <| assertEqual (xsNeg) (concatMap (\x -> [-x]) xs)
+            ]
+
+        , test "indexedMap" <| assertEqual (map2 (,) zs xsNeg) (indexedMap (\i x -> (i, -x)) xs)
+
+        , test "sum" <| assertEqual (xsSum) (sum xs)
+
+        , test "product" <| assertEqual (0) (product zs)
+
+        , test "maximum" <|
+            if n == 0
+            then assertEqual (Nothing) (maximum xs)
+            else assertEqual (Just n) (maximum xs)
+
+        , test "minimum" <|
+            if n == 0
+            then assertEqual (Nothing) (minimum xs)
+            else assertEqual (Just 1) (minimum xs)
+
+        , suite "all"
+            [ test "false" <| assertEqual (False) (all (\z -> z < n) zs)
+            , test "true" <| assertEqual (True) (all (\x -> x <= n) xs)
+            ]
+
+        , suite "any"
+            [ test "false" <| assertEqual (False) (any (\x -> x > n) xs)
+            , test "true" <| assertEqual (True) (any (\z -> z >= n) zs)
+            ]
+
+        , suite "sort"
+            [ test "sorted" <| assertEqual (xs) (sort xs)
+            , test "unsorted" <| assertEqual (xsOpp) (sort xsNeg)
+            ]
+
+        , suite "sortBy"
+            [ test "sorted" <| assertEqual (xsNeg) (sortBy negate xsNeg)
+            , test "unsorted" <| assertEqual (xsNeg) (sortBy negate xsOpp)
+            ]
+
+        , suite "sortWith"
+            [ test "sorted" <| assertEqual (xsNeg) (sortWith (flip compare) xsNeg)
+            , test "unsorted" <| assertEqual (xsNeg) (sortWith (flip compare) xsOpp)
+            ]
+
+        , test "scanl" <| assertEqual (0 :: map sumSeq xs) (scanl (+) 0 xs)
+        ]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Regex.elm

@@ -0,0 +1,46 @@
+module Test.Regex exposing (tests)
+
+import Basics exposing (..)
+
+import Regex exposing (..)
+
+import ElmTest exposing (..)
+
+
+tests : Test
+tests =
+  let simpleTests = suite "Simple Stuff"
+        [ test "split All" <| assertEqual ["a", "b"] (split All (regex ",") "a,b")
+        , test "split" <| assertEqual ["a","b,c"] (split (AtMost 1) (regex ",") "a,b,c")
+        , test "split idempotent" <|
+            let
+                findComma = regex ","
+            in
+                assertEqual
+                    (split (AtMost 1) findComma "a,b,c,d,e")
+                    (split (AtMost 1) findComma "a,b,c,d,e")
+
+        , test "find All" <| assertEqual
+            ([Match "a" [] 0 1, Match "b" [] 1 2])
+            (find All (regex ".") "ab")
+        , test "find All" <| assertEqual
+            ([Match "" [] 0 1])
+            (find All (regex ".*") "")
+
+        , test "replace AtMost 0" <| assertEqual             "The quick brown fox"
+            (replace (AtMost 0) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
+
+        , test "replace AtMost 1" <| assertEqual             "Th quick brown fox"
+            (replace (AtMost 1) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
+
+        , test "replace AtMost 2" <| assertEqual             "Th qick brown fox"
+            (replace (AtMost 2) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
+
+        , test "replace All" <| assertEqual           "Th qck brwn fx"
+            (replace All (regex "[aeiou]") (\_ -> "") "The quick brown fox")
+
+        , test "replace using index" <| assertEqual                   "a1b3c"
+            (replace All (regex ",") (\match -> toString match.index) "a,b,c")
+        ]
+  in
+      suite "Regex" [ simpleTests ]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Result.elm

@@ -0,0 +1,60 @@
+module Test.Result exposing (tests)
+
+import Basics exposing (..)
+import Result
+import Result exposing (Result(..))
+import String
+
+import ElmTest exposing (..)
+
+isEven n =
+  if n % 2 == 0
+    then Ok n
+    else Err "number is odd"
+
+add3 a b c =
+  a + b + c
+
+add4 a b c d =
+  a + b + c + d
+
+add5 a b c d e =
+  a + b + c + d + e
+
+tests : Test
+tests =
+  let mapTests = suite "map Tests"
+        [
+          test "map Ok" <| assertEqual (Ok 3) (Result.map ((+) 1) (Ok 2)),
+          test "map Err" <| assertEqual (Err "error") (Result.map ((+) 1) (Err "error"))
+        ]
+      mapNTests = suite "mapN Tests"
+        [
+          test "map2 Ok" <| assertEqual (Ok 3) (Result.map2 (+) (Ok 1) (Ok 2)),
+          test "map2 Err" <| assertEqual (Err "x") (Result.map2 (+) (Ok 1) (Err "x")),
+
+          test "map3 Ok" <| assertEqual (Ok 6) (Result.map3 add3 (Ok 1) (Ok 2) (Ok 3)),
+          test "map3 Err" <| assertEqual (Err "x") (Result.map3 add3 (Ok 1) (Ok 2) (Err "x")),
+
+          test "map4 Ok" <| assertEqual (Ok 10) (Result.map4 add4 (Ok 1) (Ok 2) (Ok 3) (Ok 4)),
+          test "map4 Err" <| assertEqual (Err "x") (Result.map4 add4 (Ok 1) (Ok 2) (Ok 3) (Err "x")),
+
+          test "map5 Ok" <| assertEqual (Ok 15) (Result.map5 add5 (Ok 1) (Ok 2) (Ok 3) (Ok 4) (Ok 5)),
+          test "map5 Err" <| assertEqual (Err "x") (Result.map5 add5 (Ok 1) (Ok 2) (Ok 3) (Ok 4) (Err "x"))
+        ]
+      andThenTests = suite "andThen Tests"
+        [
+          test "andThen Ok" <| assertEqual (Ok 42) ((String.toInt "42") `Result.andThen` isEven),
+          test "andThen first Err" <| assertEqual
+            (Err "could not convert string '4.2' to an Int")
+            (String.toInt "4.2" `Result.andThen` isEven),
+          test "andThen second Err" <| assertEqual
+            (Err "number is odd")
+            (String.toInt "41" `Result.andThen` isEven)
+        ]
+  in
+    suite "Result Tests"
+    [ mapTests
+    , mapNTests
+    , andThenTests
+    ]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Set.elm

@@ -0,0 +1,29 @@
+module Test.Set exposing (tests)
+
+import Basics exposing (..)
+
+import Set
+import Set exposing (Set)
+import List
+
+import ElmTest exposing (..)
+
+set : Set Int
+set = Set.fromList [1..100]
+
+setPart1 : Set Int
+setPart1 = Set.fromList [1..50]
+
+setPart2 : Set Int
+setPart2 = Set.fromList [51..100]
+
+pred : Int -> Bool
+pred x = x <= 50
+
+tests : Test
+tests =
+    let
+      queryTests = suite "query Tests" [test "size of set of 100 elements" <| assertEqual 100 (Set.size set)]
+      filterTests = suite "filter Tests" [test "Simple filter" <| assertEqual setPart1 <| Set.filter pred set]
+      partitionTests = suite "partition Tests" [test "Simple partition" <| assertEqual (setPart1, setPart2) <| Set.partition pred set]
+    in suite "Set Tests" [queryTests, partitionTests, filterTests]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/String.elm

@@ -0,0 +1,41 @@
+module Test.String exposing (tests)
+
+import Basics exposing (..)
+
+import List
+import Maybe exposing (..)
+import String
+
+import ElmTest exposing (..)
+
+tests : Test
+tests =
+  let simpleTests = suite "Simple Stuff"
+        [ test "is empty" <| assert (String.isEmpty "")
+        , test "is not empty" <| assert (not (String.isEmpty ("the world")))
+        , test "length" <| assertEqual 11 (String.length "innumerable")
+        , test "endsWith" (assert <| String.endsWith "ship" "spaceship")
+        , test "reverse" <| assertEqual "desserts" (String.reverse "stressed")
+        , test "repeat" <| assertEqual "hahaha" (String.repeat 3 "ha")
+        , test "indexes" <| assertEqual [ 0, 2 ] (String.indexes "a" "aha")
+        , test "empty indexes" <| assertEqual [] (String.indexes "" "aha")
+        ]
+
+      combiningTests = suite "Combining Strings"
+        [ test "uncons non-empty" <| assertEqual (Just ('a',"bc")) (String.uncons "abc")
+        , test "uncons empty" <| assertEqual Nothing (String.uncons "")
+        , test "append 1" <| assertEqual "butterfly" (String.append "butter" "fly")
+        , test "append 2" <| assertEqual "butter" (String.append "butter" "")
+        , test "append 3" <| assertEqual "butter" (String.append "" "butter")
+        , test "concat" <| assertEqual "nevertheless" (String.concat ["never","the","less"])
+        , test "split commas" <| assertEqual ["cat","dog","cow"] (String.split "," "cat,dog,cow")
+        , test "split slashes"<| assertEqual ["home","steve","Desktop", ""] (String.split "/" "home/steve/Desktop/")
+        , test "join spaces"  <| assertEqual "cat dog cow" (String.join " " ["cat","dog","cow"])
+        , test "join slashes" <| assertEqual "home/steve/Desktop" (String.join "/" ["home","steve","Desktop"])
+        , test "slice 1" <| assertEqual "c" (String.slice 2 3 "abcd")
+        , test "slice 2" <| assertEqual "abc" (String.slice 0 3 "abcd")
+        , test "slice 3" <| assertEqual "abc" (String.slice 0 -1 "abcd")
+        , test "slice 4" <| assertEqual "cd" (String.slice -2 4 "abcd")
+        ]
+  in
+      suite "String" [ simpleTests, combiningTests ]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test.elm

@@ -0,0 +1,40 @@
+module Main exposing (..)
+
+import Basics exposing (..)
+import ElmTest exposing (..)
+
+import Test.Array as Array
+import Test.Basics as Basics
+import Test.Bitwise as Bitwise
+import Test.Char as Char
+import Test.CodeGen as CodeGen
+import Test.Dict as Dict
+import Test.Equality as Equality
+import Test.Json as Json
+import Test.List as List
+import Test.Result as Result
+import Test.Set as Set
+import Test.String as String
+import Test.Regex as Regex
+
+tests : Test
+tests =
+    suite "Elm Standard Library Tests"
+        [ Array.tests
+        , Basics.tests
+        , Bitwise.tests
+        , Char.tests
+        , CodeGen.tests
+        , Dict.tests
+        , Equality.tests
+        , Json.tests
+        , List.tests
+        , Result.tests
+        , Set.tests
+        , String.tests
+        , Regex.tests
+        ]
+
+
+main =
+    runSuite tests

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/elm-package.json

@@ -0,0 +1,16 @@
+{
+    "version": "1.1.1",
+    "summary": "Tests for Elm's standard libraries",
+    "repository": "http://github.com/elm-lang/core.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        "../src"
+    ],
+    "exposed-modules": [ ],
+    "native-modules": true,
+    "dependencies": {
+        "elm-community/elm-test": "1.0.0 <= v < 2.0.0"
+    },
+    "elm-version": "0.17.0 <= v < 0.18.0"
+}

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/run-tests.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+cd "$(dirname "$0")"
+set -e
+
+
+elm-package install -y
+
+VERSION_DIR="$(ls elm-stuff/packages/elm-lang/core/)"
+CORE_PACKAGE_DIR="elm-stuff/packages/elm-lang/core/$VERSION_DIR"
+CORE_GIT_DIR="$(dirname $PWD)"
+
+echo "Linking $CORE_PACKAGE_DIR to $CORE_GIT_DIR"
+rm -rf $CORE_PACKAGE_DIR
+ln -s $CORE_GIT_DIR $CORE_PACKAGE_DIR
+
+elm-make --yes --output test.js Test.elm
+node test.js

data/test/rails5.0/elm-stuff/packages/elm-lang/html/2.0.0/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2014-present, Evan Czaplicki
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Evan Czaplicki nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/test/rails5.0/elm-stuff/packages/elm-lang/html/2.0.0/README.md

@@ -0,0 +1,5 @@
+# HTML for Elm
+
+The core HTML library for Elm. It is backed by [elm-lang/virtual-dom](http://package.elm-lang.org/packages/elm-lang/virtual-dom/latest/) which handles the dirty details of rendering things quickly.
+
+The best way to learn how to use this library is to read [guide.elm-lang.org](http://guide.elm-lang.org/), particularly the section on [The Elm Architecture](http://guide.elm-lang.org/architecture/index.html).

data/test/rails5.0/elm-stuff/packages/elm-lang/html/2.0.0/elm-package.json

@@ -0,0 +1,21 @@
+{
+    "version": "2.0.0",
+    "summary": "Fast HTML, rendered with virtual DOM diffing",
+    "repository": "https://github.com/elm-lang/html.git",
+    "license": "BSD3",
+    "source-directories": [
+        "src"
+    ],
+    "exposed-modules": [
+        "Html",
+        "Html.Attributes",
+        "Html.Events",
+        "Html.Keyed",
+        "Html.Lazy"
+    ],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0",
+        "elm-lang/virtual-dom": "2.0.0 <= v < 3.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/test/rails5.0/elm-stuff/packages/elm-lang/html/2.0.0/properties-vs-attributes.md

@@ -0,0 +1,15 @@
+# Properties vs. Attributes
+
+When you are working with HTML, you can have DOM nodes like `<div></div>`. And you can add *attributes* to those DOM nodes, like `<div class="user-info"></div>`.
+
+When you are creating DOM nodes in JavaScript, there are two ways to add attributes like this:
+
+  1. **Attributes** &mdash; You can use the `setAttribute` function. So adding a class attribute would look like this: `domNode.setAttribute('class', 'user-info')`.
+
+  2. **Properties** &mdash; JavaScript often exposes an alternate way to set these attributes. Another way to add a class attribute would be like this: `domNode.className = 'user-info'`
+
+Notice that the attribute is called `class` but the property is called `className`. This is because `class` is a reserved word in JavaScript. Point is, **attributes and properties do not always match up.**
+
+It is actually a bit crazier than that though. **Sometimes an attribute exists, but there is no corresponding property.** For example, as of this writing the `webkit-playsinline` can be added with `setAttribute`, but there is no corresponding property. And with SVG, you cannot use properties at all, you must to use `setAttributeNS` for everything.
+
+With all the corner cases here, it makes sense to have access to both approaches.