Add support for triple-quoted strings with more than 3 quotes

src/pearl.gleam

···
   lexer: Lexer,
   sigil: Option(String),
 ) -> #(Lexer, Token) {
+  let #(lexer, extra_quotes) = count_extra_quotes(lexer, 0)
+
   let #(lexer, beginning_whitespace) = case
     splitter.split(lexer.splitters.until_end_of_line, lexer.source)
   {
···
   }
 
   let #(lexer, lines, end_indentation) =
-    lex_triple_quoted_string_contents(lexer, [], "")
+    lex_triple_quoted_string_contents(lexer, [], "", extra_quotes)
 
   case strip_line_prefixes(lines, end_indentation, []) {
     Error(line) -> {
···
       lexer,
       token.TripleQuotedString(
         sigil:,
+        number_of_quotes: extra_quotes + 3,
         beginning_whitespace:,
         lines:,
         end_indentation:,
···
   }
 }
 
+fn count_extra_quotes(lexer: Lexer, extra: Int) -> #(Lexer, Int) {
+  case lexer.source {
+    "\"" <> source -> count_extra_quotes(advance(lexer, source), extra + 1)
+    _ -> #(lexer, extra)
+  }
+}
+
 fn is_whitespace(string: String) -> Bool {
   case string {
     "" -> True
···
   lexer: Lexer,
   lines: List(String),
   current_line: String,
+  extra_quotes: Int,
 ) -> #(Lexer, List(String), String) {
   let #(before, split, after) =
     splitter.split(lexer.splitters.triple_quoted_string, lexer.source)
···
   let before = current_line <> before
 
   case split {
-    "\"\"\"" ->
+    "\"\"\"" -> {
+      let lexer = advance(lexer, after)
       case is_whitespace(before) {
         False ->
           lex_triple_quoted_string_contents(
-            advance(lexer, after),
+            lexer,
             lines,
             before <> "\"\"\"",
+            extra_quotes,
           )
-        True -> #(advance(lexer, after), lines, before)
+        True if extra_quotes == 0 -> #(lexer, lines, before)
+        True ->
+          case consume_extra_quotes(lexer, extra_quotes) {
+            Ok(lexer) -> #(lexer, lines, before)
+            Error(Nil) ->
+              lex_triple_quoted_string_contents(
+                lexer,
+                lines,
+                before <> "\"\"\"",
+                extra_quotes,
+              )
+          }
       }
+    }
 
     "\n" | "\r\n" ->
       lex_triple_quoted_string_contents(
         advance(lexer, after),
         [before, ..lines],
         "",
+        extra_quotes,
       )
 
     _ -> #(error(lexer, UnterminatedString), [before, ..lines], "")
+  }
+}
+
+fn consume_extra_quotes(lexer: Lexer, extra_quotes: Int) -> Result(Lexer, Nil) {
+  case extra_quotes, lexer.source {
+    0, _ -> Ok(lexer)
+    _, "\"" <> source ->
+      consume_extra_quotes(advance(lexer, source), extra_quotes - 1)
+    _, _ -> Error(Nil)
   }
 }
 

src/pearl/token.gleam

···
   String(String)
   TripleQuotedString(
     sigil: option.Option(String),
+    number_of_quotes: Int,
     beginning_whitespace: String,
     lines: List(String),
     end_indentation: String,
···
     Atom(name:, quoted: True) -> "'" <> name <> "'"
     Atom(name:, quoted: False) -> name
     String(contents) -> "\"" <> contents <> "\""
-    TripleQuotedString(sigil:, beginning_whitespace:, lines:, end_indentation:) ->
+    TripleQuotedString(
+      sigil:,
+      number_of_quotes:,
+      beginning_whitespace:,
+      lines:,
+      end_indentation:,
+    ) ->
       case sigil {
         option.None -> ""
         option.Some(sigil) -> "~" <> sigil
       }
-      <> "\"\"\""
+      <> string.repeat("\"", number_of_quotes)
       <> beginning_whitespace
       <> string.join(
         list.map(lines, fn(line) { end_indentation <> line }),
···
       )
       <> "\n"
       <> end_indentation
-      <> "\"\"\""
+      <> string.repeat("\"", number_of_quotes)
     Sigil(sigil:, delimiter:, contents:) -> {
       let #(opening, closing) = sigil_delimiters(delimiter)
       "~" <> sigil <> opening <> contents <> closing

test/pearl_test.gleam

···
   assert_tokens(src, [
     token.TripleQuotedString(
       sigil: None,
+      number_of_quotes: 3,
       beginning_whitespace: "  \n",
       lines: [
         "Hello, this is triple-quoted!",
···
   assert_tokens(src, [
     token.TripleQuotedString(
       sigil: Some("b"),
+      number_of_quotes: 3,
       beginning_whitespace: "\n",
       lines: ["Hello", "This is a triple-quoted sigil"],
       end_indentation: "  ",
+    ),
+  ])
+}
+
+pub fn triple_quoted_string_more_quotes_test() {
+  let src =
+    "
+\"\"\"\"\"
+   This string has five quotes
+   so four are allowed:
+   \"\"\"\"
+   \"\"\"\"\"
+"
+
+  assert_tokens(src, [
+    token.TripleQuotedString(
+      sigil: None,
+      number_of_quotes: 5,
+      beginning_whitespace: "\n",
+      lines: ["This string has five quotes", "so four are allowed:", "\"\"\"\""],
+      end_indentation: "   ",
     ),
   ])
 }

test/tokens.txt

···
   bye
   """
 
+""""""
+  This string has six (6) quotes!
+  That means you can have five quotes just fine:
+  """""
+  And it's still valid. Six can also be here: """"""
+  """"""
+
+~""""
+  Here's a sigil with more than 3 quotes
+  It works fine
+  """"
+
 after
 begin
 case