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

package/generator/dead-code-review/node_modules/elm-test/elm/src/Console/Text.elm

@@ -0,0 +1,217 @@
+module Console.Text exposing
+    ( Color
+    , ColorModifier
+    , Style
+    , Text
+    , UseColor(..)
+    , concat
+    , dark
+    , green
+    , plain
+    , red
+    , render
+    , underline
+    , yellow
+    )
+
+import Test.Runner.Node.Vendor.Console as Console
+
+
+type Text
+    = Text { background : Color, foreground : Color, style : Style, modifiers : List ColorModifier } String
+    | Texts (List Text)
+
+
+type UseColor
+    = UseColor
+    | Monochrome
+
+
+type Color
+    = Default
+    | Red
+    | Green
+    | Yellow
+    | Black
+    | Blue
+    | Magenta
+    | Cyan
+    | White
+
+
+type ColorModifier
+    = Inverted
+    | Dark
+
+
+type Style
+    = Normal
+    | Bold
+    | Underline
+
+
+render : UseColor -> Text -> String
+render useColor txt =
+    case txt of
+        Text attrs str ->
+            case useColor of
+                UseColor ->
+                    str
+                        |> colorizeBackground attrs.background
+                        |> colorizeForeground attrs.foreground
+                        |> applyModifiers attrs.modifiers
+                        |> applyStyle attrs.style
+
+                Monochrome ->
+                    str
+
+        Texts texts ->
+            List.map (render useColor) texts
+                |> String.join ""
+
+
+concat : List Text -> Text
+concat =
+    Texts
+
+
+plain : String -> Text
+plain =
+    Text { foreground = Default, background = Default, style = Normal, modifiers = [] }
+
+
+
+-- FOREGROUND COLORS --
+
+
+red : String -> Text
+red =
+    Text { foreground = Red, background = Default, style = Normal, modifiers = [] }
+
+
+green : String -> Text
+green =
+    Text { foreground = Green, background = Default, style = Normal, modifiers = [] }
+
+
+yellow : String -> Text
+yellow =
+    Text { foreground = Yellow, background = Default, style = Normal, modifiers = [] }
+
+
+dark : Text -> Text
+dark txt =
+    case txt of
+        Text styles str ->
+            Text { styles | modifiers = Dark :: styles.modifiers } str
+
+        Texts texts ->
+            Texts (List.map dark texts)
+
+
+
+-- STYLES --
+
+
+underline : Text -> Text
+underline txt =
+    case txt of
+        Text styles str ->
+            Text { styles | style = Underline } str
+
+        Texts texts ->
+            Texts (List.map dark texts)
+
+
+
+-- INTERNAL HELPERS --
+
+
+colorizeForeground : Color -> String -> String
+colorizeForeground color str =
+    case color of
+        Default ->
+            str
+
+        Red ->
+            Console.red str
+
+        Green ->
+            Console.green str
+
+        Yellow ->
+            Console.yellow str
+
+        Black ->
+            Console.black str
+
+        Blue ->
+            Console.blue str
+
+        Magenta ->
+            Console.magenta str
+
+        Cyan ->
+            Console.cyan str
+
+        White ->
+            Console.white str
+
+
+colorizeBackground : Color -> String -> String
+colorizeBackground color str =
+    case color of
+        Default ->
+            str
+
+        Red ->
+            Console.bgRed str
+
+        Green ->
+            Console.bgGreen str
+
+        Yellow ->
+            Console.bgYellow str
+
+        Black ->
+            Console.bgBlack str
+
+        Blue ->
+            Console.bgBlue str
+
+        Magenta ->
+            Console.bgMagenta str
+
+        Cyan ->
+            Console.bgCyan str
+
+        White ->
+            Console.bgWhite str
+
+
+applyStyle : Style -> String -> String
+applyStyle style str =
+    case style of
+        Normal ->
+            str
+
+        Bold ->
+            Console.bold str
+
+        Underline ->
+            Console.underline str
+
+
+applyModifiers : List ColorModifier -> String -> String
+applyModifiers modifiers str =
+    List.foldl applyModifiersHelp str modifiers
+
+
+applyModifiersHelp : ColorModifier -> String -> String
+applyModifiersHelp modifier str =
+    case modifier of
+        Inverted ->
+            Console.colorsInverted str
+
+        Dark ->
+            Console.dark str

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Console/Format/Color.elm

@@ -0,0 +1,30 @@
+module Test.Reporter.Console.Format.Color exposing (formatEquality)
+
+import Test.Reporter.Highlightable as Highlightable exposing (Highlightable)
+import Test.Runner.Node.Vendor.Console as Console
+
+
+formatEquality : List (Highlightable String) -> List (Highlightable String) -> ( String, String )
+formatEquality highlightedExpected highlightedActual =
+    let
+        formattedExpected =
+            highlightedExpected
+                |> List.map fromHighlightable
+                |> String.join ""
+
+        formattedActual =
+            highlightedActual
+                |> List.map fromHighlightable
+                |> String.join ""
+    in
+    ( formattedExpected, formattedActual )
+
+
+fromHighlightable : Highlightable String -> String
+fromHighlightable =
+    Highlightable.resolve
+        -- Cyan seems to look readable with both white and black text on top,
+        -- so it should work with both dark and light console themes
+        { fromHighlighted = Console.colorsInverted
+        , fromPlain = identity
+        }

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Console/Format/Monochrome.elm

@@ -0,0 +1,39 @@
+module Test.Reporter.Console.Format.Monochrome exposing (formatEquality)
+
+import Test.Reporter.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/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Console/Format.elm

@@ -0,0 +1,212 @@
+module Test.Reporter.Console.Format exposing (format, highlightEqual)
+
+import Test.Reporter.Highlightable as Highlightable exposing (Highlightable)
+import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
+
+
+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/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Console.elm

@@ -0,0 +1,207 @@
+module Test.Reporter.Console exposing (reportBegin, reportComplete, reportSummary)
+
+import Console.Text as Text exposing (..)
+import Json.Encode as Encode exposing (Value)
+import Test.Reporter.Console.Format exposing (format)
+import Test.Reporter.Console.Format.Color as FormatColor
+import Test.Reporter.Console.Format.Monochrome as FormatMonochrome
+import Test.Reporter.TestResults as Results exposing (Failure, Outcome(..), SummaryInfo)
+import Test.Runner exposing (formatLabels)
+
+
+formatDuration : Float -> String
+formatDuration time =
+    String.fromFloat time ++ " ms"
+
+
+indent : String -> String
+indent str =
+    str
+        |> String.split "\n"
+        |> List.map ((++) "    ")
+        |> String.join "\n"
+
+
+pluralize : String -> String -> Int -> String
+pluralize singular plural count =
+    let
+        suffix =
+            if count == 1 then
+                singular
+
+            else
+                plural
+    in
+    String.join " " [ String.fromInt count, suffix ]
+
+
+todosToText : ( List String, String ) -> Text
+todosToText ( labels, failure ) =
+    Text.concat [ todoLabelsToText labels, todoToChalk failure ]
+
+
+todoLabelsToText : List String -> Text
+todoLabelsToText =
+    formatLabels (dark << plain << withChar '↓') (dark << plain << withChar '↓') >> Text.concat
+
+
+todoToChalk : String -> Text
+todoToChalk message =
+    plain ("◦ TODO: " ++ message ++ "\n\n")
+
+
+failuresToText : UseColor -> List String -> List Failure -> Text
+failuresToText useColor labels failures =
+    Text.concat (failureLabelsToText labels :: List.map (failureToText useColor) failures)
+
+
+failureLabelsToText : List String -> Text
+failureLabelsToText =
+    formatLabels (dark << plain << withChar '↓') (red << withChar '✗') >> Text.concat
+
+
+failureToText : UseColor -> Results.Failure -> Text
+failureToText useColor { given, description, reason } =
+    let
+        formatEquality =
+            case useColor of
+                Monochrome ->
+                    FormatMonochrome.formatEquality
+
+                UseColor ->
+                    FormatColor.formatEquality
+
+        messageText =
+            plain ("\n" ++ indent (format formatEquality description reason) ++ "\n\n")
+    in
+    case given of
+        Nothing ->
+            messageText
+
+        Just givenStr ->
+            [ dark (plain ("\nGiven " ++ givenStr ++ "\n"))
+            , messageText
+            ]
+                |> Text.concat
+
+
+textToValue : UseColor -> Text -> Value
+textToValue useColor txt =
+    txt
+        |> Text.render useColor
+        |> Encode.string
+
+
+reportBegin : UseColor -> { r | globs : List String, fuzzRuns : Int, testCount : Int, initialSeed : Int } -> Maybe Value
+reportBegin useColor { globs, fuzzRuns, testCount, initialSeed } =
+    let
+        prefix =
+            "Running "
+                ++ pluralize "test" "tests" testCount
+                ++ ". To reproduce these results, run: elm-test --fuzz "
+                ++ String.fromInt fuzzRuns
+                ++ " --seed "
+                ++ String.fromInt initialSeed
+    in
+    (String.join " " (prefix :: globs) ++ "\n")
+        |> plain
+        |> textToValue useColor
+        |> Just
+
+
+reportComplete : UseColor -> Results.TestResult -> Value
+reportComplete useColor { labels, outcome } =
+    case outcome of
+        Passed ->
+            -- No failures of any kind.
+            Encode.null
+
+        Failed failures ->
+            -- We have non-TODOs still failing; report them, not the TODOs.
+            failures
+                |> failuresToText useColor labels
+                |> textToValue useColor
+
+        Todo str ->
+            Encode.object
+                [ ( "todo", Encode.string str )
+                , ( "labels", Encode.list Encode.string labels )
+                ]
+
+
+summarizeTodos : List ( List String, String ) -> Text
+summarizeTodos =
+    List.map todosToText >> Text.concat
+
+
+reportSummary : UseColor -> SummaryInfo -> Maybe String -> Value
+reportSummary useColor { todos, passed, failed, duration } autoFail =
+    let
+        headlineResult =
+            case ( autoFail, failed, List.length todos ) of
+                ( Nothing, 0, 0 ) ->
+                    Ok "TEST RUN PASSED"
+
+                ( Nothing, 0, 1 ) ->
+                    Err ( yellow, "TEST RUN INCOMPLETE", " because there is 1 TODO remaining" )
+
+                ( Nothing, 0, numTodos ) ->
+                    Err ( yellow, "TEST RUN INCOMPLETE", " because there are " ++ String.fromInt numTodos ++ " TODOs remaining" )
+
+                ( Just failure, 0, _ ) ->
+                    Err ( yellow, "TEST RUN INCOMPLETE", " because " ++ failure )
+
+                _ ->
+                    Err ( red, "TEST RUN FAILED", "" )
+
+        headline =
+            case headlineResult of
+                Ok str ->
+                    underline (green ("\n" ++ str ++ "\n\n"))
+
+                Err ( colorize, str, suffix ) ->
+                    [ underline (colorize ("\n" ++ str))
+                    , colorize (suffix ++ "\n\n")
+                    ]
+                        |> Text.concat
+
+        todoStats =
+            -- Print stats for Todos if there are any,
+            --but don't print details unless only Todos remain
+            case List.length todos of
+                0 ->
+                    plain ""
+
+                numTodos ->
+                    stat "Todo:     " (String.fromInt numTodos)
+
+        individualTodos =
+            if failed > 0 then
+                plain ""
+
+            else
+                summarizeTodos (List.reverse todos)
+    in
+    [ headline
+    , stat "Duration: " (formatDuration duration)
+    , stat "Passed:   " (String.fromInt passed)
+    , stat "Failed:   " (String.fromInt failed)
+    , todoStats
+    , individualTodos
+    ]
+        |> Text.concat
+        |> Text.render useColor
+        |> Encode.string
+
+
+stat : String -> String -> Text
+stat label value =
+    Text.concat
+        [ dark (plain label)
+        , plain (value ++ "\n")
+        ]
+
+
+withChar : Char -> String -> String
+withChar icon str =
+    String.fromChar icon ++ " " ++ str ++ "\n"