elm-pages 3.0.0-beta.20 → 3.0.0-beta.21

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Runner/Node/Vendor/Console.elm

@@ -0,0 +1,230 @@
+module Test.Runner.Node.Vendor.Console exposing (bgBlack, bgBlue, bgCyan, bgGreen, bgMagenta, bgRed, bgWhite, bgYellow, black, blue, bold, colorsInverted, cyan, dark, green, magenta, red, underline, white, yellow)
+
+{-| -}
+
+-- NOTE: This is copy/pasted from https://github.com/rtfeldman/console-print
+-- It's inlined to avoid having to call elm-package install on the end user's
+-- system - the approach this library took prior to
+-- commit 19047f01d460739bfe7f16466bc60b41430a8f09 - because it assumes
+-- the end user has the correct elm-package on their PATH, which is not a
+-- safe assumption.
+--
+-- License:
+{-
+   BSD 3-Clause License
+
+   Copyright (c) 2017, Richard Feldman
+   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 the copyright holder nor the names of its
+     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 HOLDER 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.
+-}
+
+
+{-| Make the text darker.
+
+This can be used with other text modifiers, such as color.
+
+    import Console exposing (dark, green)
+
+
+    -- "Hello, dark green world!" with "dark green" in dark green
+    greeting : String
+    greeting =
+        "Hello, " ++ (dark << green) "dark green" ++ " world!"
+
+Not all terminals support this.
+
+-}
+dark : String -> String
+dark str =
+    String.join "" [ "\u{001B}[2m", str, "\u{001B}[22m" ]
+
+
+{-| Make the text bold.
+
+This can be used with other text modifiers, such as color.
+
+    import Console exposing (blue, bold)
+
+
+    -- "Hello, bold blue world!" with "bold blue" in bold and blue
+    greeting : String
+    greeting =
+        "Hello, " ++ (bold << blue) "bold blue" ++ " world!"
+
+Some terminals implement this as a color change rather than a boldness change.
+
+-}
+bold : String -> String
+bold str =
+    String.join "" [ "\u{001B}[1m", str, "\u{001B}[22m" ]
+
+
+{-| Make the text underlined.
+
+This can be used with other text modifiers, such as color.
+
+    import Console exposing (underline)
+
+
+    -- "This will look like a hyperlink" with "hyperlink" underlined
+    example : String
+    example =
+        "This will look like a " ++ underline "hyperlink"
+
+Not all terminals support this.
+
+-}
+underline : String -> String
+underline str =
+    String.join "" [ "\u{001B}[4m", str, "\u{001B}[24m" ]
+
+
+{-| Invert the foreground and background colors from what they would otherwise be.
+-}
+colorsInverted : String -> String
+colorsInverted str =
+    String.join "" [ "\u{001B}[7m", str, "\u{001B}[27m" ]
+
+
+
+-- Foreground Colors
+
+
+{-| Make the foreground text black.
+-}
+black : String -> String
+black str =
+    String.join "" [ "\u{001B}[30m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text red.
+-}
+red : String -> String
+red str =
+    String.join "" [ "\u{001B}[31m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text green.
+-}
+green : String -> String
+green str =
+    String.join "" [ "\u{001B}[32m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text yellow.
+-}
+yellow : String -> String
+yellow str =
+    String.join "" [ "\u{001B}[33m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text blue.
+-}
+blue : String -> String
+blue str =
+    String.join "" [ "\u{001B}[34m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text magenta.
+-}
+magenta : String -> String
+magenta str =
+    String.join "" [ "\u{001B}[35m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text cyan.
+-}
+cyan : String -> String
+cyan str =
+    String.join "" [ "\u{001B}[36m", str, "\u{001B}[39m" ]
+
+
+{-| Make the foreground text white.
+-}
+white : String -> String
+white str =
+    String.join "" [ "\u{001B}[37m", str, "\u{001B}[39m" ]
+
+
+
+-- Background Colors
+
+
+{-| Make the background black.
+-}
+bgBlack : String -> String
+bgBlack str =
+    String.join "" [ "\u{001B}[40m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background red.
+-}
+bgRed : String -> String
+bgRed str =
+    String.join "" [ "\u{001B}[41m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background green.
+-}
+bgGreen : String -> String
+bgGreen str =
+    String.join "" [ "\u{001B}[42m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background yellow.
+-}
+bgYellow : String -> String
+bgYellow str =
+    String.join "" [ "\u{001B}[43m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background blue.
+-}
+bgBlue : String -> String
+bgBlue str =
+    String.join "" [ "\u{001B}[44m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background magenta.
+-}
+bgMagenta : String -> String
+bgMagenta str =
+    String.join "" [ "\u{001B}[45m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background cyan.
+-}
+bgCyan : String -> String
+bgCyan str =
+    String.join "" [ "\u{001B}[46m", str, "\u{001B}[49m" ]
+
+
+{-| Make the background white.
+-}
+bgWhite : String -> String
+bgWhite str =
+    String.join "" [ "\u{001B}[47m", str, "\u{001B}[49m" ]

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Runner/Node/Vendor/Diff.elm

@@ -0,0 +1,326 @@
+module Test.Runner.Node.Vendor.Diff exposing
+    ( Change(..)
+    , diff
+    )
+
+{-| Compares two list and returns how they have changed.
+Each function internally uses Wu's [O(NP) algorithm](http://myerslab.mpi-cbg.de/wp-content/uploads/2014/06/np_diff.pdf).
+
+
+# Types
+
+@docs Change
+
+
+# Diffing
+
+@docs diff, diffLines
+
+-}
+
+-- NOTE: This is copy/pasted from https://github.com/jinjor/elm-diff
+-- It's inlined to avoid having to call elm-package install on the end user's
+-- system - the approach this library took prior to
+-- commit 19047f01d460739bfe7f16466bc60b41430a8f09 - because it assumes
+-- the end user has the correct elm-package on their PATH, which is not a
+-- safe assumption.
+--
+-- License:
+{-
+   Copyright (c) 2016, Yosuke Torii
+   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 elm-diff nor the names of its
+     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 HOLDER 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.
+
+-}
+
+import Array exposing (Array)
+
+
+{-| This describes how each line has changed and also contains its value.
+-}
+type Change a
+    = Added a
+    | Removed a
+    | NoChange a
+
+
+type StepResult
+    = Continue (Array (List ( Int, Int )))
+    | Found (List ( Int, Int ))
+
+
+type BugReport
+    = CannotGetA Int
+    | CannotGetB Int
+    | UnexpectedPath ( Int, Int ) (List ( Int, Int ))
+
+
+{-| Compares general lists.
+
+    diff [ 1, 3 ] [ 2, 3 ] == [ Removed 1, Added 2, NoChange 3 ] -- True
+
+-}
+diff : List a -> List a -> List (Change a)
+diff a b =
+    case testDiff a b of
+        Ok changes ->
+            changes
+
+        Err _ ->
+            []
+
+
+{-| Test the algolithm itself.
+If it returns Err, it should be a bug.
+-}
+testDiff : List a -> List a -> Result BugReport (List (Change a))
+testDiff a b =
+    let
+        arrA =
+            Array.fromList a
+
+        arrB =
+            Array.fromList b
+
+        m =
+            Array.length arrA
+
+        n =
+            Array.length arrB
+
+        -- Elm's Array doesn't allow null element,
+        -- so we'll use shifted index to access source.
+        getA =
+            \x -> Array.get (x - 1) arrA
+
+        getB =
+            \y -> Array.get (y - 1) arrB
+
+        path =
+            -- Is there any case ond is needed?
+            -- ond getA getB m n
+            onp getA getB m n
+    in
+    makeChanges getA getB path
+
+
+makeChanges :
+    (Int -> Maybe a)
+    -> (Int -> Maybe a)
+    -> List ( Int, Int )
+    -> Result BugReport (List (Change a))
+makeChanges getA getB path =
+    case path of
+        [] ->
+            Ok []
+
+        latest :: tail ->
+            makeChangesHelp [] getA getB latest tail
+
+
+makeChangesHelp :
+    List (Change a)
+    -> (Int -> Maybe a)
+    -> (Int -> Maybe a)
+    -> ( Int, Int )
+    -> List ( Int, Int )
+    -> Result BugReport (List (Change a))
+makeChangesHelp changes getA getB ( x, y ) path =
+    case path of
+        [] ->
+            Ok changes
+
+        ( prevX, prevY ) :: tail ->
+            let
+                change =
+                    if x - 1 == prevX && y - 1 == prevY then
+                        case getA x of
+                            Just a ->
+                                Ok (NoChange a)
+
+                            Nothing ->
+                                Err (CannotGetA x)
+
+                    else if x == prevX then
+                        case getB y of
+                            Just b ->
+                                Ok (Added b)
+
+                            Nothing ->
+                                Err (CannotGetB y)
+
+                    else if y == prevY then
+                        case getA x of
+                            Just a ->
+                                Ok (Removed a)
+
+                            Nothing ->
+                                Err (CannotGetA x)
+
+                    else
+                        Err (UnexpectedPath ( x, y ) path)
+            in
+            case change of
+                Err err ->
+                    Err err
+
+                Ok c ->
+                    makeChangesHelp (c :: changes) getA getB ( prevX, prevY ) tail
+
+
+
+-- Wu's O(NP) algorithm (http://myerslab.mpi-cbg.de/wp-content/uploads/2014/06/np_diff.pdf)
+
+
+onp : (Int -> Maybe a) -> (Int -> Maybe a) -> Int -> Int -> List ( Int, Int )
+onp getA getB m n =
+    let
+        v =
+            Array.initialize (m + n + 1) (always [])
+
+        delta =
+            n - m
+    in
+    onpLoopP (snake getA getB) delta m 0 v
+
+
+onpLoopP :
+    (Int -> Int -> List ( Int, Int ) -> ( List ( Int, Int ), Bool ))
+    -> Int
+    -> Int
+    -> Int
+    -> Array (List ( Int, Int ))
+    -> List ( Int, Int )
+onpLoopP snake_ delta offset p v =
+    let
+        ks =
+            if delta > 0 then
+                List.reverse (List.range (delta + 1) (delta + p))
+                    ++ List.range -p delta
+
+            else
+                List.reverse (List.range (delta + 1) p)
+                    ++ List.range (-p + delta) delta
+    in
+    case onpLoopK snake_ offset ks v of
+        Found path ->
+            path
+
+        Continue v_ ->
+            onpLoopP snake_ delta offset (p + 1) v_
+
+
+onpLoopK :
+    (Int -> Int -> List ( Int, Int ) -> ( List ( Int, Int ), Bool ))
+    -> Int
+    -> List Int
+    -> Array (List ( Int, Int ))
+    -> StepResult
+onpLoopK snake_ offset ks v =
+    case ks of
+        [] ->
+            Continue v
+
+        k :: ks_ ->
+            case step snake_ offset k v of
+                Found path ->
+                    Found path
+
+                Continue v_ ->
+                    onpLoopK snake_ offset ks_ v_
+
+
+step :
+    (Int -> Int -> List ( Int, Int ) -> ( List ( Int, Int ), Bool ))
+    -> Int
+    -> Int
+    -> Array (List ( Int, Int ))
+    -> StepResult
+step snake_ offset k v =
+    let
+        fromLeft =
+            Maybe.withDefault [] (Array.get (k - 1 + offset) v)
+
+        fromTop =
+            Maybe.withDefault [] (Array.get (k + 1 + offset) v)
+
+        ( path, ( x, y ) ) =
+            case ( fromLeft, fromTop ) of
+                ( [], [] ) ->
+                    ( [], ( 0, 0 ) )
+
+                ( [], ( topX, topY ) :: _ ) ->
+                    ( fromTop, ( topX + 1, topY ) )
+
+                ( ( leftX, leftY ) :: _, [] ) ->
+                    ( fromLeft, ( leftX, leftY + 1 ) )
+
+                ( ( leftX, leftY ) :: _, ( topX, topY ) :: _ ) ->
+                    -- this implies "remove" comes always earlier than "add"
+                    if leftY + 1 >= topY then
+                        ( fromLeft, ( leftX, leftY + 1 ) )
+
+                    else
+                        ( fromTop, ( topX + 1, topY ) )
+
+        ( newPath, goal ) =
+            snake_ (x + 1) (y + 1) (( x, y ) :: path)
+    in
+    if goal then
+        Found newPath
+
+    else
+        Continue (Array.set (k + offset) newPath v)
+
+
+snake :
+    (Int -> Maybe a)
+    -> (Int -> Maybe a)
+    -> Int
+    -> Int
+    -> List ( Int, Int )
+    -> ( List ( Int, Int ), Bool )
+snake getA getB nextX nextY path =
+    case ( getA nextX, getB nextY ) of
+        ( Just a, Just b ) ->
+            if a == b then
+                snake
+                    getA
+                    getB
+                    (nextX + 1)
+                    (nextY + 1)
+                    (( nextX, nextY ) :: path)
+
+            else
+                ( path, False )
+
+        -- reached bottom-right corner
+        ( Nothing, Nothing ) ->
+            ( path, True )
+
+        _ ->
+            ( path, False )