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

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

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

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

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

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

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

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