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

package/src/Vendored/Diff.elm

@@ -0,0 +1,321 @@
+-- NOTE: This is copy/pasted from https://github.com/jinjor/elm-diff
+-- 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.
+
+-}
+
+
+module Vendored.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
+
+-}
+
+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 )

package/src/Vendored/Failure.elm

@@ -0,0 +1,217 @@
+-- Copied from rtfeldman/node-test-runner : elm/src/Test/Reporter/Console/Format.elm
+-- https://github.com/rtfeldman/node-test-runner/blob/master/elm/src/Test/Reporter/Console/Format.elm
+-- Published under BSD-3-Clause license, see LICENSE_node-test-runner
+
+
+module Vendored.Failure exposing (format)
+
+import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
+import Vendored.Highlightable as Highlightable exposing (Highlightable)
+
+
+format :
+    (List (Highlightable String) -> List (Highlightable String) -> ( String, String ))
+    -> String
+    -> Reason
+    -> String
+format formatEquality description reason =
+    case reason of
+        Custom ->
+            description
+
+        Equality expected actual ->
+            case highlightEqual expected actual of
+                Nothing ->
+                    verticalBar description expected actual
+
+                Just ( highlightedExpected, highlightedActual ) ->
+                    let
+                        ( formattedExpected, formattedActual ) =
+                            formatEquality highlightedExpected highlightedActual
+                    in
+                    verticalBar description formattedExpected formattedActual
+
+        Comparison first second ->
+            verticalBar description first second
+
+        TODO ->
+            description
+
+        Invalid BadDescription ->
+            if description == "" then
+                "The empty string is not a valid test description."
+
+            else
+                "This is an invalid test description: " ++ description
+
+        Invalid _ ->
+            description
+
+        ListDiff expected actual ->
+            listDiffToString 0
+                description
+                { expected = expected
+                , actual = actual
+                }
+                { originalExpected = expected
+                , originalActual = actual
+                }
+
+        CollectionDiff { expected, actual, extra, missing } ->
+            let
+                extraStr =
+                    if List.isEmpty extra then
+                        ""
+
+                    else
+                        "\nThese keys are extra: "
+                            ++ (extra |> String.join ", " |> (\d -> "[ " ++ d ++ " ]"))
+
+                missingStr =
+                    if List.isEmpty missing then
+                        ""
+
+                    else
+                        "\nThese keys are missing: "
+                            ++ (missing |> String.join ", " |> (\d -> "[ " ++ d ++ " ]"))
+            in
+            String.join ""
+                [ verticalBar description expected actual
+                , "\n"
+                , extraStr
+                , missingStr
+                ]
+
+
+highlightEqual : String -> String -> Maybe ( List (Highlightable String), List (Highlightable String) )
+highlightEqual expected actual =
+    if expected == "\"\"" || actual == "\"\"" then
+        -- Diffing when one is the empty string looks silly. Don't bother.
+        Nothing
+
+    else if isFloat expected && isFloat actual then
+        -- Diffing numbers looks silly. Don't bother.
+        Nothing
+
+    else
+        let
+            isHighlighted =
+                Highlightable.resolve
+                    { fromHighlighted = always True
+                    , fromPlain = always False
+                    }
+
+            edgeCount highlightedString =
+                let
+                    highlights =
+                        List.map isHighlighted highlightedString
+                in
+                highlights
+                    |> List.map2 Tuple.pair (List.drop 1 highlights)
+                    |> List.filter (\( lhs, rhs ) -> lhs /= rhs)
+                    |> List.length
+
+            expectedChars =
+                String.toList expected
+
+            actualChars =
+                String.toList actual
+
+            highlightedExpected =
+                Highlightable.diffLists expectedChars actualChars
+                    |> List.map (Highlightable.map String.fromChar)
+
+            highlightedActual =
+                Highlightable.diffLists actualChars expectedChars
+                    |> List.map (Highlightable.map String.fromChar)
+
+            plainCharCount =
+                highlightedExpected
+                    |> List.filter (not << isHighlighted)
+                    |> List.length
+        in
+        if edgeCount highlightedActual > plainCharCount || edgeCount highlightedExpected > plainCharCount then
+            -- Large number of small highlighted blocks. Diff is too messy to be useful.
+            Nothing
+
+        else
+            Just
+                ( highlightedExpected
+                , highlightedActual
+                )
+
+
+isFloat : String -> Bool
+isFloat str =
+    case String.toFloat str of
+        Just _ ->
+            True
+
+        Nothing ->
+            False
+
+
+listDiffToString :
+    Int
+    -> String
+    -> { expected : List String, actual : List String }
+    -> { originalExpected : List String, originalActual : List String }
+    -> String
+listDiffToString index description { expected, actual } originals =
+    case ( expected, actual ) of
+        ( [], [] ) ->
+            [ "Two lists were unequal previously, yet ended up equal later."
+            , "This should never happen!"
+            , "Please report this bug to https://github.com/elm-community/elm-test/issues - and include these lists: "
+            , "\n"
+            , String.join ", " originals.originalExpected
+            , "\n"
+            , String.join ", " originals.originalActual
+            ]
+                |> String.join ""
+
+        ( _ :: _, [] ) ->
+            verticalBar (description ++ " was shorter than")
+                (String.join ", " originals.originalExpected)
+                (String.join ", " originals.originalActual)
+
+        ( [], _ :: _ ) ->
+            verticalBar (description ++ " was longer than")
+                (String.join ", " originals.originalExpected)
+                (String.join ", " originals.originalActual)
+
+        ( firstExpected :: restExpected, firstActual :: restActual ) ->
+            if firstExpected == firstActual then
+                -- They're still the same so far; keep going.
+                listDiffToString (index + 1)
+                    description
+                    { expected = restExpected
+                    , actual = restActual
+                    }
+                    originals
+
+            else
+                -- We found elements that differ; fail!
+                String.join ""
+                    [ verticalBar description
+                        (String.join ", " originals.originalExpected)
+                        (String.join ", " originals.originalActual)
+                    , "\n\nThe first diff is at index "
+                    , String.fromInt index
+                    , ": it was `"
+                    , firstActual
+                    , "`, but `"
+                    , firstExpected
+                    , "` was expected."
+                    ]
+
+
+verticalBar : String -> String -> String -> String
+verticalBar comparison expected actual =
+    [ actual
+    , "╷"
+    , "│ " ++ comparison
+    , "╵"
+    , expected
+    ]
+        |> String.join "\n"

package/src/Vendored/FormatMonochrome.elm

@@ -0,0 +1,44 @@
+-- Copied from rtfeldman/node-test-runner : elm/src/Test/Reporter/Console/Format/Monochrome.elm
+-- https://github.com/rtfeldman/node-test-runner/blob/master/elm/src/Test/Reporter/Console/Format/Monochrome.elm
+-- Published under BSD-3-Clause license, see LICENSE_node-test-runner
+
+
+module Vendored.FormatMonochrome exposing (formatEquality)
+
+import Vendored.Highlightable as Highlightable exposing (Highlightable(..))
+
+
+formatEquality : List (Highlightable String) -> List (Highlightable String) -> ( String, String )
+formatEquality highlightedExpected highlightedActual =
+    let
+        ( formattedExpected, expectedIndicators ) =
+            highlightedExpected
+                |> List.map (fromHighlightable "▲")
+                |> List.unzip
+
+        ( formattedActual, actualIndicators ) =
+            highlightedActual
+                |> List.map (fromHighlightable "▼")
+                |> List.unzip
+
+        combinedExpected =
+            String.join "\n"
+                [ String.join "" formattedExpected
+                , String.join "" expectedIndicators
+                ]
+
+        combinedActual =
+            String.join "\n"
+                [ String.join "" actualIndicators
+                , String.join "" formattedActual
+                ]
+    in
+    ( combinedExpected, combinedActual )
+
+
+fromHighlightable : String -> Highlightable String -> ( String, String )
+fromHighlightable indicator =
+    Highlightable.resolve
+        { fromHighlighted = \char -> ( char, indicator )
+        , fromPlain = \char -> ( char, " " )
+        }

package/src/Vendored/Highlightable.elm

@@ -0,0 +1,53 @@
+-- Copied from rtfeldman/node-test-runner : elm/src/Test/Reporter/Highlightable.elm
+-- https://github.com/rtfeldman/node-test-runner/blob/master/elm/src/Test/Reporter/Highlightable.elm
+-- Published under BSD-3-Clause license, see LICENSE_node-test-runner
+
+
+module Vendored.Highlightable exposing (Highlightable, diffLists, map, resolve)
+
+import Vendored.Diff as Diff exposing (Change(..))
+
+
+type Highlightable a
+    = Highlighted a
+    | Plain a
+
+
+resolve : { fromHighlighted : a -> b, fromPlain : a -> b } -> Highlightable a -> b
+resolve { fromHighlighted, fromPlain } highlightable =
+    case highlightable of
+        Highlighted val ->
+            fromHighlighted val
+
+        Plain val ->
+            fromPlain val
+
+
+diffLists : List a -> List a -> List (Highlightable a)
+diffLists expected actual =
+    -- TODO make sure this looks reasonable for multiline strings
+    Diff.diff expected actual
+        |> List.concatMap fromDiff
+
+
+map : (a -> b) -> Highlightable a -> Highlightable b
+map transform highlightable =
+    case highlightable of
+        Highlighted val ->
+            Highlighted (transform val)
+
+        Plain val ->
+            Plain (transform val)
+
+
+fromDiff : Change a -> List (Highlightable a)
+fromDiff diff =
+    case diff of
+        Added _ ->
+            []
+
+        Removed char ->
+            [ Highlighted char ]
+
+        NoChange char ->
+            [ Plain char ]