elm-pages 3.0.0-beta.14 → 3.0.0-beta.15

package/src/ProgramTest/TestHtmlHacks.elm

@@ -1,132 +0,0 @@
-module ProgramTest.TestHtmlHacks exposing (getPassingSelectors, parseFailureReport, parseFailureReportWithoutHtml, parseSimulateFailure, renderHtml)
-
-import Html.Parser
-import Parser
-import Parser.Extra
-import ProgramTest.HtmlHighlighter as HtmlHighlighter
-import ProgramTest.HtmlRenderer as HtmlRenderer
-import ProgramTest.TestHtmlParser as TestHtmlParser exposing (Assertion(..), FailureReport(..))
-import Test.Html.Query as Query
-import Test.Html.Selector as Selector exposing (Selector)
-import Test.Runner
-
-
-pleaseReport description =
-    "PLEASE REPORT THIS AT <https://github.com/avh4/elm-program-test/issues>: " ++ description
-
-
-renderHtml : (String -> String) -> (String -> List Html.Parser.Attribute -> List Html.Parser.Node -> Bool) -> Query.Single any -> String
-renderHtml colorHidden highlightPredicate single =
-    case forceFailureReport [] single of
-        Ok (QueryFailure node _ _) ->
-            let
-                tryHighlight =
-                    HtmlHighlighter.highlight highlightPredicate
-                        node
-
-                finalHighlighted =
-                    if HtmlHighlighter.isNonHiddenElement tryHighlight then
-                        tryHighlight
-
-                    else
-                        HtmlHighlighter.highlight (\_ _ _ -> True)
-                            node
-            in
-            "▼ Query.fromHtml\n\n"
-                ++ HtmlRenderer.render colorHidden 4 [ finalHighlighted ]
-
-        Ok (EventFailure name _) ->
-            pleaseReport ("renderHtml: unexpected EventFailure: \"" ++ name ++ "\"")
-
-        Err err ->
-            pleaseReport ("renderHtml: couldn't parse failure report: " ++ err)
-
-
-getPassingSelectors : List Selector -> Query.Single msg -> List String
-getPassingSelectors selectors single =
-    case forceFailureReportWithoutHtml selectors single of
-        Ok (QueryFailure _ _ (Has _ results)) ->
-            case List.reverse results of
-                (Ok _) :: _ ->
-                    [ pleaseReport "getPassingSelectors: forced selector didn't fail" ]
-
-                _ ->
-                    List.filterMap Result.toMaybe results
-
-        Ok (EventFailure name _) ->
-            [ pleaseReport ("getPassingSelectors: got unexpected EventFailure \"" ++ name ++ "\"") ]
-
-        Err err ->
-            [ pleaseReport ("getPassingSelectors: couldn't parse failure report: " ++ err) ]
-
-
-forceFailureReport : List Selector -> Query.Single any -> Result String (FailureReport Html.Parser.Node)
-forceFailureReport selectors =
-    forceFailureReport_ parseFailureReport selectors "ProgramTest.TestHtmlHacks is trying to force a failure to collect the error message %%"
-
-
-forceFailureReportWithoutHtml : List Selector -> Query.Single any -> Result String (FailureReport ())
-forceFailureReportWithoutHtml selectors =
-    forceFailureReport_ parseFailureReportWithoutHtml selectors "ProgramTest.TestHtmlHacks is trying to force a failure to collect the error message %%"
-
-
-forceFailureReport_ : (String -> result) -> List Selector -> String -> Query.Single any -> result
-forceFailureReport_ parseFailure selectors unique single =
-    case
-        single
-            |> Query.has (selectors ++ [ Selector.text unique ])
-            |> Test.Runner.getFailureReason
-    of
-        Nothing ->
-            -- We expect the fake query to fail -- if it doesn't for some reason, just try recursing with a different fake matching string until it does fail
-            forceFailureReport_ parseFailure selectors (unique ++ "_") single
-
-        Just reason ->
-            parseFailure reason.description
-
-
-parseFailureReport : String -> Result String (FailureReport Html.Parser.Node)
-parseFailureReport string =
-    Parser.run TestHtmlParser.parser string
-        |> Result.mapError Parser.Extra.deadEndsToString
-
-
-parseFailureReportWithoutHtml : String -> Result String (FailureReport ())
-parseFailureReportWithoutHtml string =
-    Parser.run TestHtmlParser.parserWithoutHtml string
-        |> Result.mapError Parser.Extra.deadEndsToString
-
-
-partitionSections_ : List String -> List (List String) -> List String -> List (List String)
-partitionSections_ accLines accSections remaining =
-    case remaining of
-        [] ->
-            case List.reverse (List.reverse accLines :: accSections) of
-                [] :: rest ->
-                    rest
-
-                all ->
-                    all
-
-        next :: rest ->
-            if String.startsWith "▼ " next then
-                partitionSections_ [ next ] (List.reverse accLines :: accSections) rest
-
-            else
-                partitionSections_ (next :: accLines) accSections rest
-
-
-parseSimulateFailure : String -> String
-parseSimulateFailure string =
-    let
-        simpleFailure result =
-            case result of
-                EventFailure name html ->
-                    Ok ("Event.expectEvent: I found a node, but it does not listen for \"" ++ name ++ "\" events like I expected it would.")
-
-                _ ->
-                    Err (pleaseReport "Got a failure message from Test.Html.Query that we couldn't parse: " ++ string)
-    in
-    parseFailureReport string
-        |> Result.andThen simpleFailure
-        |> Result.withDefault (pleaseReport "Got a failure message from Test.Html.Query that we couldn't parse: " ++ string)

package/src/ProgramTest/TestHtmlParser.elm

@@ -1,201 +0,0 @@
-module ProgramTest.TestHtmlParser exposing (Assertion(..), FailureReport(..), Selector(..), Step(..), parser, parserWithoutHtml)
-
-import Html.Parser
-import Parser exposing ((|.), (|=), Parser)
-import Parser.Extra.String
-import ProgramTest.HtmlParserHacks as HtmlParserHacks
-
-
-type FailureReport html
-    = QueryFailure html (List (Step html)) Assertion
-    | EventFailure String html
-
-
-type Step html
-    = FindStep (List Selector) html
-
-
-type Selector
-    = Tag String
-    | Containing (List Selector)
-    | Text String
-    | Attribute String String
-    | All (List Selector)
-
-
-type Assertion
-    = Has (List Selector) (List (Result String String))
-
-
-parser_ : Parser html -> Parser (FailureReport html)
-parser_ parseHtml =
-    Parser.oneOf
-        [ Parser.succeed QueryFailure
-            |. Parser.keyword "▼ Query.fromHtml"
-            |. Parser.symbol "\n\n    "
-            |= parseHtml
-            |= stepsParser parseHtml
-            |= assertionParser
-            |. Parser.end
-        , Parser.succeed EventFailure
-            |. Parser.keyword "Event.expectEvent:"
-            |. Parser.symbol " I found a node, but it does not listen for \""
-            |= (Parser.getChompedString <| Parser.chompUntil "\"")
-            |. Parser.symbol "\" events like I expected it would.\n\n"
-            |= parseHtml
-            |. Parser.end
-        ]
-
-
-parser : Parser (FailureReport Html.Parser.Node)
-parser =
-    parser_ trimmedHtml
-
-
-trimmedHtml : Parser Html.Parser.Node
-trimmedHtml =
-    Parser.map HtmlParserHacks.trimText Html.Parser.node
-        |. Parser.oneOf
-            [ Parser.symbol "\n\n\n"
-            , Parser.end
-            ]
-
-
-parserWithoutHtml : Parser (FailureReport ())
-parserWithoutHtml =
-    parser_ ignoreHtml
-
-
-ignoreHtml : Parser ()
-ignoreHtml =
-    Parser.chompUntilEndOr "▼"
-
-
-stepsParser : Parser html -> Parser (List (Step html))
-stepsParser parseHtml =
-    Parser.loop [] <|
-        \acc ->
-            Parser.oneOf
-                [ Parser.succeed (\stmt -> Parser.Loop (stmt :: acc))
-                    |= stepParser parseHtml
-                , Parser.succeed ()
-                    |> Parser.map (\_ -> Parser.Done (List.reverse acc))
-                ]
-
-
-stepParser : Parser html -> Parser (Step html)
-stepParser parseHtml =
-    Parser.oneOf
-        [ Parser.succeed FindStep
-            |. Parser.keyword "▼ Query.find "
-            |= selectorsParser
-            |. Parser.symbol "\n\n    1)  "
-            |= parseHtml
-        ]
-
-
-selectorsParser : Parser (List Selector)
-selectorsParser =
-    Parser.sequence
-        { start = "[ "
-        , separator = ", "
-        , end = " ]"
-        , spaces = Parser.succeed ()
-        , item = selectorParser
-        , trailing = Parser.Forbidden
-        }
-
-
-selectorParser : Parser Selector
-selectorParser =
-    -- As of elm-explorations/test 1.2.2, `Selector.all` renders simply as a space-separated sequence of selectors
-    let
-        done acc =
-            case acc of
-                [ single ] ->
-                    single
-
-                more ->
-                    All (List.reverse more)
-    in
-    singleSelectorParser
-        |> Parser.andThen
-            (\first ->
-                Parser.loop [ first ] <|
-                    \acc ->
-                        Parser.oneOf
-                            [ Parser.succeed (\stmt -> Parser.Loop (stmt :: acc))
-                                |. Parser.backtrackable (Parser.symbol " ")
-                                |= singleSelectorParser
-                            , Parser.succeed ()
-                                |> Parser.map (\_ -> Parser.Done (done acc))
-                            ]
-            )
-
-
-singleSelectorParser : Parser Selector
-singleSelectorParser =
-    Parser.oneOf
-        [ Parser.succeed Tag
-            |. Parser.keyword "tag "
-            |= Parser.Extra.String.string
-        , Parser.succeed Text
-            |. Parser.keyword "text "
-            |= Parser.Extra.String.string
-        , Parser.succeed Attribute
-            |. Parser.keyword "attribute "
-            |= Parser.Extra.String.string
-            |. Parser.symbol " "
-            |= Parser.oneOf
-                [ Parser.Extra.String.string
-                , Parser.succeed "true"
-                    |. Parser.keyword "True"
-                , Parser.succeed "false"
-                    |. Parser.keyword "False"
-                ]
-        , Parser.succeed Containing
-            |. Parser.keyword "containing "
-            |= Parser.lazy (\() -> selectorsParser)
-            |. Parser.symbol " "
-        ]
-
-
-assertionParser : Parser Assertion
-assertionParser =
-    Parser.oneOf
-        [ Parser.succeed Has
-            |. Parser.keyword "▼ Query.has "
-            |= selectorsParser
-            |. Parser.symbol "\n\n"
-            |= selectorResultsParser
-        ]
-
-
-selectorResultsParser : Parser (List (Result String String))
-selectorResultsParser =
-    let
-        help acc =
-            Parser.oneOf
-                [ Parser.succeed (\stmt -> Parser.Loop (stmt :: acc))
-                    |= selectorResultParser
-                , Parser.succeed ()
-                    |> Parser.map (\_ -> Parser.Done (List.reverse acc))
-                ]
-    in
-    Parser.loop [] help
-
-
-selectorResultParser : Parser (Result String String)
-selectorResultParser =
-    Parser.oneOf
-        [ Parser.succeed (Ok << String.trim)
-            |. Parser.symbol "✓ "
-            |. Parser.commit ()
-            |= (Parser.getChompedString <| Parser.chompUntilEndOr "\n")
-            |. Parser.chompWhile ((==) '\n')
-        , Parser.succeed (Err << String.trim)
-            |. Parser.symbol "✗ "
-            |. Parser.commit ()
-            |= (Parser.getChompedString <| Parser.chompUntilEndOr "\n")
-            |. Parser.chompWhile ((==) '\n')
-        ]