performance upgrade

src/luma_markdown.gleam

@@ -11,39 +11,66 @@ pub fn luma_markdown(
   information: helpers.Information,
   contents: String,
 ) -> String {
-  let lines = string.split(contents, "\n")
+  let parsed = parse_lines(contents)
+  render_lines(information, parsed)
+}
 
-  let parsed =
+fn parse_lines(contents: String) -> List(List(definition.Instruction)) {
-    list.map(lines, fn(line) -> String {
+  contents
+  |> string.split("\n")
+  |> list.map(parse_line)
+}
+
+fn parse_line(line: String) -> List(definition.Instruction) {
+  case
+    string.contains(line, "#")
+    || string.contains(line, "@")
+    || string.contains(line, "!")
+    || string.contains(line, ">")
+  {
+    True ->
       case parser.handler(line) {
-        definition.TextInstructions(instruction) ->
+        definition.TextInstructions(instructions) -> instructions
-          string.join(
+      }
-            list.map(instruction, fn(instruction) -> String {
+    False ->
+      case string.trim(line) {
+        "" -> []
+        text -> [definition.Text(text)]
+      }
+  }
+}
+
+fn render_lines(
+  information: helpers.Information,
+  parsed: List(List(definition.Instruction)),
+) -> String {
+  parsed
+  |> list.map(fn(instructions) {
+    render_instructions(information, instructions)
+  })
+  |> string.join("\n")
+}
+
+fn render_instructions(
+  information: helpers.Information,
+  instructions: List(definition.Instruction),
+) -> String {
+  instructions
+  |> list.map(fn(instruction) {
     case instruction {
       definition.Text(instruction) -> instruction
       definition.Push(instruction) ->
         case instruction {
           definition.Hirachy(instruction) ->
-                      string.repeat(
+            string.repeat("#", instruction - information.lowesthirachy + 1)
-                        "#",
+          definition.Marking(instruction) -> string.repeat("*", instruction)
-                        instruction - information.lowesthirachy + 1,
+          definition.Quote(instruction) -> string.repeat(">", instruction)
-                      )
+          definition.Truth(instruction) -> string.repeat("__", instruction)
-                    definition.Marking(instruction) ->
-                      string.repeat("*", instruction)
-                    definition.Quote(instruction) ->
-                      string.repeat(">", instruction)
-                    definition.Truth(instruction) ->
-                      string.repeat("__", instruction)
         }
       definition.Pop(_) -> "##"
     }
-            }),
-            "",
-          )
-      }
   })
-
+  |> string.join("")
-  string.join(parsed, "\n")
 }
 
 pub fn main() -> Nil {
@@ -59,7 +86,7 @@ pub fn main() -> Nil {
         }
       }
     }
-    [] -> render(read_stdin([]))
+    [] -> render(read_input())
     _ -> {
       io.println("Usage: luma_markdown [file]")
       Nil
@@ -68,20 +95,14 @@ pub fn main() -> Nil {
 }
 
 fn render(contents: String) -> Nil {
-  let information = case parser.handler(contents) {
+  let parsed = parse_lines(contents)
-    definition.TextInstructions(instructions) -> helpers.gather(instructions)
+  let information =
-  }
+    parsed
-  let result = luma_markdown(information, contents)
+    |> list.flatten
+    |> helpers.gather
+  let result = render_lines(information, parsed)
   io.println(result)
 }
 
-@external(erlang, "luma_stdin", "read_line")
+@external(erlang, "luma_stdin", "read_all")
-fn read_line() -> String
+fn read_input() -> String
-
-fn read_stdin(lines: List(String)) -> String {
-  let line = read_line()
-  case line {
-    "" -> lines |> list.reverse |> string.join("")
-    _ -> read_stdin([line, ..lines])
-  }
-}

src/luma_stdin.erl

@@ -1,9 +1,12 @@
 -module(luma_stdin).
 
--export([read_line/0]).
+-export([read_all/0]).
 
-read_line() ->
+read_all() ->
-    case io:get_line("") of
+    read_all([]).
-        eof -> <<>>;
+
-        Line -> unicode:characters_to_binary(Line)
+read_all(Chunks) ->
+    case io:get_chars("", 65536) of
+        eof -> unicode:characters_to_binary(lists:reverse(Chunks));
+        Chunk -> read_all([Chunk | Chunks])
     end.

test/luma_markdown_test.gleam

@@ -1,4 +1,6 @@
 import gleeunit
+import helpers
+import luma_markdown
 
 pub fn main() -> Nil {
   gleeunit.main()
@@ -11,3 +13,10 @@ pub fn hello_world_test() {
 
   assert greeting == "Hello, Joe!"
 }
+
+pub fn renders_plain_and_marked_lines_test() {
+  let information = helpers.Information(1, 1)
+
+  assert luma_markdown.luma_markdown(information, "  plain text  \n!2 marked")
+    == "plain text\n**marked"
+}