Add support for multiline comments

Author: robinheghan

src/Compiler/Parse/Context.gren

@@ -33,4 +33,4 @@ type alias Comment =
 
 type CommentValue
     = Line String
-    | MultiLine String
+    | Block String

src/Compiler/Parse/Declaration.gren

@@ -105,6 +105,12 @@ docParser toErr =
                 Space.ExpectedLineComment ->
                     toErr "expected line comment"
 
+                Space.ExpectedMultiLineOpen ->
+                    toErr "expected {-"
+
+                Space.ExpectedMultiLineClose ->
+                    toErr "expected -}"
+
                 Space.InvalidWhiteSpace ->
                     toErr "expected white space character"
     in

src/Compiler/Parse/Space.gren

@@ -14,6 +14,8 @@ import Dict
 
 type Error
     = ExpectedLineComment
+    | ExpectedMultiLineOpen
+    | ExpectedMultiLineClose
     | InvalidWhiteSpace
 
 
@@ -22,6 +24,12 @@ errorToString error =
     when error is
         ExpectedLineComment ->
             "Expected line comment"
+
+        ExpectedMultiLineOpen ->
+            "Expected {-"
+
+        ExpectedMultiLineClose ->
+            "Expected -}"
 
         InvalidWhiteSpace ->
             "Invalid whitespace character"
@@ -78,6 +86,49 @@ parseLoop _state =
                         Parser.getPayload
                 )
             |> Parser.map (\_ -> Parser.Loop {})
+        , Parser.succeed
+            (\row col comment ->
+                { row = row
+                , col = col
+                , value =
+                    comment
+                        |> String.dropLast 2
+                        |> String.trim
+                        |> Context.Block
+                }
+            )
+            |> Parser.keep Parser.getRow
+            |> Parser.keep Parser.getCol
+            |> Parser.skip
+                (Parser.oneOf
+                    [ Parser.token "{-|" ExpectedMultiLineOpen
+                        |> Parser.andThen (\_ -> Parser.problem ExpectedMultiLineOpen)
+                    , Parser.token "{-" ExpectedMultiLineOpen
+                    ]
+                    |> Parser.backtrackable
+                )
+            |> Parser.keep
+                (Parser.chompUntil "-}" ExpectedMultiLineClose
+                    |> Parser.skip (Parser.token "-}" ExpectedMultiLineClose)
+                    |> Parser.getChompedString
+                )
+            |> Parser.andThen
+                (\value ->
+                    Parser.updatePayload
+                        (\payload  ->
+                            let
+                                commentsOnRow =
+                                    Dict.get value.row payload.comments
+                                        |> Maybe.withDefault []
+                                        |> Array.pushLast value
+                            in
+                            { payload
+                                | comments = Dict.set value.row commentsOnRow payload.comments
+                            }
+                        )
+                        Parser.getPayload
+                )
+            |> Parser.map (\_ -> Parser.Loop {})
         , Parser.succeed (Parser.Loop {})
             |> Parser.skip (Parser.chompIf validWhiteSpace InvalidWhiteSpace)
             |> Parser.skip (Parser.chompWhile validWhiteSpace)

tests/src/Test/Compiler/Parse/Space.gren

@@ -41,13 +41,18 @@ tests =
                 Parser.run setIndentParser Context.empty "    b"
                     |> Result.map .indent
                     |> Expect.equal (Ok 5)
-            , test "parses line comments" <| \_ ->
-                Parser.run payloadParser Context.empty "-- this is a line comment"
-                    |> expectLineComment 1 1 "this is a line comment"
-            , test "parses line comments even when prefixed with space" <| \_ ->
-                Parser.run payloadParser Context.empty "  -- this is a line comment"
-                    |> expectLineComment 1 3 "this is a line comment"
             ]
+    , describe "comments" <|
+        [ test "parses line comments" <| \_ ->
+            Parser.run (parseToEnd payloadParser) Context.empty "-- this is a line comment"
+                |> expectComment 1 1 (Context.Line "this is a line comment")
+        , test "parses line comments even when prefixed with space" <| \_ ->
+            Parser.run (parseToEnd payloadParser) Context.empty "  -- this is a line comment"
+                |> expectComment 1 3 (Context.Line "this is a line comment")
+        , test "block comments" <| \_ ->
+            Parser.run (parseToEnd payloadParser) Context.empty "{- this is a block comment -}"
+                |> expectComment 1 1 (Context.Block "this is a block comment")
+        ]
     , describe "checkIndent" <|
         let
             indentParser =
@@ -97,8 +102,13 @@ payloadParser =
         |> Parser.keep Parser.getPayload
 
 
-expectLineComment : Int -> Int -> String -> Result x Context -> Expectation
-expectLineComment row col comment resultContext =
+parseToEnd : Parser Context PS.Error a -> Parser Context PS.Error a
+parseToEnd p =
+    Parser.skip (Parser.end PS.InvalidWhiteSpace) p
+
+
+expectComment : Int -> Int -> Context.CommentValue -> Result x Context -> Expectation
+expectComment row col comment resultContext =
     when resultContext is
         Err err ->
             Expect.fail ("Failed to parse with error: " ++ Debug.toString err)
@@ -112,7 +122,7 @@ expectLineComment row col comment resultContext =
                     Expect.equal
                         [ { row = row
                           , col = col
-                          , value = Context.Line comment
+                          , value = comment
                           }
                         ]
                         commentsOnRow