elm-pages 3.0.0-beta.24 → 3.0.0-beta.26

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

@@ -1,217 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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"