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

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Highlightable.elm

@@ -1,48 +0,0 @@
-module Test.Reporter.Highlightable exposing (Highlightable, diffLists, map, resolve)
-
-import Test.Runner.Node.Vendor.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 ]

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/JUnit.elm

@@ -1,161 +0,0 @@
-module Test.Reporter.JUnit exposing (reportBegin, reportComplete, reportSummary)
-
-import Json.Encode as Encode exposing (Value)
-import Test.Reporter.TestResults exposing (Failure, Outcome(..), SummaryInfo, TestResult)
-import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
-
-
-reportBegin : runInfo -> Maybe Value
-reportBegin _ =
-    Nothing
-
-
-encodeOutcome : Outcome -> List ( String, Value )
-encodeOutcome outcome =
-    case outcome of
-        Passed ->
-            []
-
-        Failed failures ->
-            let
-                message =
-                    failures
-                        |> List.map formatFailure
-                        |> String.join "\n\n\n"
-            in
-            [ encodeFailureTuple message ]
-
-        Todo message ->
-            [ encodeFailureTuple ("TODO: " ++ message) ]
-
-
-encodeFailureTuple : String -> ( String, Value )
-encodeFailureTuple message =
-    ( "failure", Encode.string message )
-
-
-formatFailure : Failure -> String
-formatFailure { given, description, reason } =
-    let
-        message =
-            reasonToString description reason
-    in
-    case given of
-        Just str ->
-            "Given " ++ str ++ "\n\n" ++ message
-
-        Nothing ->
-            message
-
-
-formatClassAndName : List String -> ( String, String )
-formatClassAndName labels =
-    case labels of
-        head :: rest ->
-            ( String.join " " (List.reverse rest), head )
-
-        _ ->
-            ( "", "" )
-
-
-encodeDuration : Int -> Value
-encodeDuration time =
-    (toFloat time / 1000)
-        |> String.fromFloat
-        |> Encode.string
-
-
-reportComplete : TestResult -> Value
-reportComplete { labels, duration, outcome } =
-    let
-        ( classname, name ) =
-            formatClassAndName labels
-    in
-    Encode.object
-        ([ ( "@classname", Encode.string classname )
-         , ( "@name", Encode.string name )
-         , ( "@time", encodeDuration duration )
-         ]
-            ++ encodeOutcome outcome
-        )
-
-
-encodeExtraFailure : String -> Value
-encodeExtraFailure _ =
-    reportComplete { labels = [], duration = 0, outcome = Failed [] }
-
-
-reportSummary : SummaryInfo -> Maybe String -> Value
-reportSummary { testCount, duration, failed } autoFail =
-    let
-        -- JUnit doesn't have a notion of "everything passed, but you left
-        -- a Test.only in there, so it's a failure overall." In that case
-        -- we'll tack on an extra failed test, so the overall suite fails.
-        -- Another option would be to report it as an Error, but that would
-        -- make JUnit have different semantics from the other reporters.
-        -- Also, there wasn't really an error. Nothing broke.
-        extraFailures =
-            case ( failed, autoFail ) of
-                ( 0, Just failure ) ->
-                    [ encodeExtraFailure failure ]
-
-                _ ->
-                    []
-    in
-    Encode.object
-        [ ( "testsuite"
-          , Encode.object
-                [ ( "@name", Encode.string "elm-test" )
-                , ( "@package", Encode.string "elm-test" )
-
-                -- Would be nice to have this provided from elm-package.json of tests
-                , ( "@tests", Encode.int testCount )
-                , ( "@failures", Encode.int failed )
-                , ( "@errors", Encode.int 0 )
-                , ( "@time", Encode.float duration )
-                , ( "testcase", Encode.list identity extraFailures )
-                ]
-          )
-        ]
-
-
-reasonToString : String -> Reason -> String
-reasonToString description reason =
-    case reason of
-        Custom ->
-            description
-
-        Equality expected actual ->
-            expected ++ "\n\nwas not equal to\n\n" ++ actual
-
-        Comparison first second ->
-            first ++ "\n\nfailed when compared with " ++ description ++ " on\n\n" ++ second
-
-        TODO ->
-            "TODO: " ++ description
-
-        Invalid BadDescription ->
-            let
-                explanation =
-                    if description == "" then
-                        "The empty string is not a valid test description."
-
-                    else
-                        "This is an invalid test description: " ++ description
-            in
-            "Invalid test: " ++ explanation
-
-        Invalid _ ->
-            "Invalid test: " ++ description
-
-        ListDiff expected actual ->
-            String.join ", " expected ++ "\n\nhad different elements than\n\n" ++ String.join ", " actual
-
-        CollectionDiff { expected, actual, extra, missing } ->
-            expected
-                ++ "\n\nhad different contents than\n\n"
-                ++ actual
-                ++ "\n\nthese were extra:\n\n"
-                ++ String.join "\n" extra
-                ++ "\n\nthese were missing:\n\n"
-                ++ String.join "\n" missing

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/Json.elm

@@ -1,158 +0,0 @@
-module Test.Reporter.Json exposing (reportBegin, reportComplete, reportSummary)
-
-import Json.Encode as Encode exposing (Value)
-import Test.Reporter.TestResults as TestResults exposing (Failure, Outcome(..), SummaryInfo)
-import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
-
-
-reportBegin : { globs : List String, paths : List String, fuzzRuns : Int, testCount : Int, initialSeed : Int } -> Maybe Value
-reportBegin { globs, paths, fuzzRuns, testCount, initialSeed } =
-    Encode.object
-        [ ( "event", Encode.string "runStart" )
-        , ( "testCount", Encode.string <| String.fromInt testCount )
-        , ( "fuzzRuns", Encode.string <| String.fromInt fuzzRuns )
-        , ( "globs", Encode.list Encode.string globs )
-        , ( "paths", Encode.list Encode.string paths )
-        , ( "initialSeed", Encode.string <| String.fromInt initialSeed )
-        ]
-        |> Just
-
-
-reportComplete : TestResults.TestResult -> Value
-reportComplete { duration, labels, outcome } =
-    Encode.object
-        [ ( "event", Encode.string "testCompleted" )
-        , ( "status", Encode.string (getStatus outcome) )
-        , ( "labels", encodeLabels labels )
-        , ( "failures", Encode.list identity (encodeFailures outcome) )
-        , ( "duration", Encode.string <| String.fromInt duration )
-        ]
-
-
-encodeFailures : Outcome -> List Value
-encodeFailures outcome =
-    case outcome of
-        Failed failures ->
-            List.map encodeFailure failures
-
-        Todo str ->
-            [ Encode.string str ]
-
-        _ ->
-            []
-
-
-{-| Algorithm:
-
-  - If any fail, return "fail"
-  - Otherwise, if any are todo, return "todo"
-  - Otherwise, return "pass"
-
--}
-getStatus : Outcome -> String
-getStatus outcome =
-    case outcome of
-        Failed _ ->
-            "fail"
-
-        Todo _ ->
-            "todo"
-
-        Passed ->
-            "pass"
-
-
-encodeLabels : List String -> Value
-encodeLabels labels =
-    List.reverse labels
-        |> Encode.list Encode.string
-
-
-reportSummary : SummaryInfo -> Maybe String -> Value
-reportSummary { duration, passed, failed } autoFail =
-    Encode.object
-        [ ( "event", Encode.string "runComplete" )
-        , ( "passed", Encode.string <| String.fromInt passed )
-        , ( "failed", Encode.string <| String.fromInt failed )
-        , ( "duration", Encode.string <| String.fromFloat duration )
-        , ( "autoFail"
-          , autoFail
-                |> Maybe.map Encode.string
-                |> Maybe.withDefault Encode.null
-          )
-        ]
-
-
-encodeFailure : Failure -> Value
-encodeFailure { given, description, reason } =
-    Encode.object
-        [ ( "given", Maybe.withDefault Encode.null (Maybe.map Encode.string given) )
-        , ( "message", Encode.string description )
-        , ( "reason", encodeReason description reason )
-        ]
-
-
-encodeReasonType : String -> Value -> Value
-encodeReasonType reasonType data =
-    Encode.object
-        [ ( "type", Encode.string reasonType ), ( "data", data ) ]
-
-
-encodeReason : String -> Reason -> Value
-encodeReason description reason =
-    case reason of
-        Custom ->
-            Encode.string description
-                |> encodeReasonType "Custom"
-
-        Equality expected actual ->
-            [ ( "expected", Encode.string expected )
-            , ( "actual", Encode.string actual )
-            , ( "comparison", Encode.string description )
-            ]
-                |> Encode.object
-                |> encodeReasonType "Equality"
-
-        Comparison first second ->
-            [ ( "first", Encode.string first )
-            , ( "second", Encode.string second )
-            , ( "comparison", Encode.string description )
-            ]
-                |> Encode.object
-                |> encodeReasonType "Comparison"
-
-        TODO ->
-            Encode.string description
-                |> encodeReasonType "TODO"
-
-        Invalid BadDescription ->
-            let
-                explanation =
-                    if description == "" then
-                        "The empty string is not a valid test description."
-
-                    else
-                        "This is an invalid test description: " ++ description
-            in
-            Encode.string explanation
-                |> encodeReasonType "Invalid"
-
-        Invalid _ ->
-            Encode.string description
-                |> encodeReasonType "Invalid"
-
-        ListDiff expected actual ->
-            [ ( "expected", Encode.list Encode.string expected )
-            , ( "actual", Encode.list Encode.string actual )
-            ]
-                |> Encode.object
-                |> encodeReasonType "ListDiff"
-
-        CollectionDiff { expected, actual, extra, missing } ->
-            [ ( "expected", Encode.string expected )
-            , ( "actual", Encode.string actual )
-            , ( "extra", Encode.list Encode.string extra )
-            , ( "missing", Encode.list Encode.string missing )
-            ]
-                |> Encode.object
-                |> encodeReasonType "CollectionDiff"

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

@@ -1,53 +0,0 @@
-module Test.Reporter.Reporter exposing (Report(..), RunInfo, TestReporter, createReporter)
-
-import Console.Text exposing (UseColor)
-import Json.Encode exposing (Value)
-import Test.Reporter.Console as ConsoleReporter
-import Test.Reporter.JUnit as JUnitReporter
-import Test.Reporter.Json as JsonReporter
-import Test.Reporter.TestResults exposing (SummaryInfo, TestResult)
-
-
-type Report
-    = ConsoleReport UseColor
-    | JsonReport
-    | JUnitReport
-
-
-type alias TestReporter =
-    { format : String
-    , reportBegin : RunInfo -> Maybe Value
-    , reportComplete : TestResult -> Value
-    , reportSummary : SummaryInfo -> Maybe String -> Value
-    }
-
-
-type alias RunInfo =
-    { globs : List String
-    , paths : List String
-    , fuzzRuns : Int
-    , testCount : Int
-    , initialSeed : Int
-    }
-
-
-createReporter : Report -> TestReporter
-createReporter report =
-    case report of
-        JsonReport ->
-            TestReporter "JSON"
-                JsonReporter.reportBegin
-                JsonReporter.reportComplete
-                JsonReporter.reportSummary
-
-        ConsoleReport useColor ->
-            TestReporter "CHALK"
-                (ConsoleReporter.reportBegin useColor)
-                (ConsoleReporter.reportComplete useColor)
-                (ConsoleReporter.reportSummary useColor)
-
-        JUnitReport ->
-            TestReporter "JUNIT"
-                JUnitReporter.reportBegin
-                JUnitReporter.reportComplete
-                JUnitReporter.reportSummary

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Reporter/TestResults.elm

@@ -1,113 +0,0 @@
-module Test.Reporter.TestResults exposing
-    ( Failure
-    , Outcome(..)
-    , SummaryInfo
-    , TestResult
-    , isFailure
-    , outcomesFromExpectations
-    )
-
-import Expect exposing (Expectation)
-import Test.Runner
-import Test.Runner.Failure exposing (Reason)
-
-
-type Outcome
-    = Passed
-    | Todo String
-    | Failed (List Failure)
-
-
-type alias TestResult =
-    { labels : List String
-    , outcome : Outcome
-    , duration : Int -- in milliseconds
-    }
-
-
-type alias SummaryInfo =
-    { testCount : Int
-    , passed : Int
-    , failed : Int
-    , todos : List ( List String, String )
-    , duration : Float
-    }
-
-
-type alias Failure =
-    { given : Maybe String
-    , description : String
-    , reason : Reason
-    }
-
-
-isFailure : Outcome -> Bool
-isFailure outcome =
-    case outcome of
-        Failed _ ->
-            True
-
-        _ ->
-            False
-
-
-outcomesFromExpectations : List Expectation -> List Outcome
-outcomesFromExpectations expectations =
-    case expectations of
-        expectation :: [] ->
-            -- Most often we'll get exactly 1 pass, so try that case first!
-            case Test.Runner.getFailureReason expectation of
-                Nothing ->
-                    [ Passed ]
-
-                Just failure ->
-                    if Test.Runner.isTodo expectation then
-                        [ Todo failure.description ]
-
-                    else
-                        [ Failed [ failure ] ]
-
-        _ :: _ ->
-            let
-                builder =
-                    List.foldl outcomesFromExpectationsHelp
-                        { passes = 0, todos = [], failures = [] }
-                        expectations
-
-                failuresList =
-                    case builder.failures of
-                        [] ->
-                            []
-
-                        failures ->
-                            [ Failed failures ]
-            in
-            List.concat
-                [ List.repeat builder.passes Passed
-                , List.map Todo builder.todos
-                , failuresList
-                ]
-
-        [] ->
-            []
-
-
-type alias OutcomeBuilder =
-    { passes : Int
-    , todos : List String
-    , failures : List Failure
-    }
-
-
-outcomesFromExpectationsHelp : Expectation -> OutcomeBuilder -> OutcomeBuilder
-outcomesFromExpectationsHelp expectation builder =
-    case Test.Runner.getFailureReason expectation of
-        Just failure ->
-            if Test.Runner.isTodo expectation then
-                { builder | todos = failure.description :: builder.todos }
-
-            else
-                { builder | failures = failure :: builder.failures }
-
-        Nothing ->
-            { builder | passes = builder.passes + 1 }

package/generator/dead-code-review/node_modules/elm-test/elm/src/Test/Runner/JsMessage.elm

@@ -1,38 +0,0 @@
-module Test.Runner.JsMessage exposing (JsMessage(..), decoder)
-
-import Json.Decode as Decode exposing (Decoder)
-
-
-type JsMessage
-    = Test Int
-    | Summary Float Int (List ( List String, String ))
-
-
-decoder : Decoder JsMessage
-decoder =
-    Decode.field "type" Decode.string
-        |> Decode.andThen decodeMessageFromType
-
-
-decodeMessageFromType : String -> Decoder JsMessage
-decodeMessageFromType messageType =
-    case messageType of
-        "TEST" ->
-            Decode.field "index" Decode.int
-                |> Decode.map Test
-
-        "SUMMARY" ->
-            Decode.map3 Summary
-                (Decode.field "duration" Decode.float)
-                (Decode.field "failures" Decode.int)
-                (Decode.field "todos" (Decode.list todoDecoder))
-
-        _ ->
-            Decode.fail ("Unrecognized message type: " ++ messageType)
-
-
-todoDecoder : Decoder ( List String, String )
-todoDecoder =
-    Decode.map2 (\a b -> ( a, b ))
-        (Decode.field "labels" (Decode.list Decode.string))
-        (Decode.field "todo" Decode.string)