Extract properties block parser to file

src/org/org_parser_properties_block.nim

@@ -0,0 +1,59 @@
+import std/sugar
+import std/strformat
+import std/collections/sequtils
+import std/strutils
+import results
+import fusion/matching
+
+import ../utils/fp
+import ../parser/parser
+import ../parser/utils
+
+{.experimental: "caseStmtMacros".}
+
+
+let propertiesKeyParser* = ignore(ch(':')) + anyUntil(choice(@[str(": "), newline]))
+let propertiesValueParser* = ignore(str(": ")) + anyUntil(newline) + ignore(newline)
+
+let propertiesParser* = proc(parser: Parser): ParserResult {.closure.} =
+  let keyTokenParser = parser
+  .propertiesKeyParser()
+  .flatMap(flattenParserTokens)
+
+  let valueTokenParser = keyTokenParser
+  .map(emptyTokens)
+  .flatMap(propertiesValueParser)
+  .flatMap(flattenParserTokens)
+
+  case (keyTokenParser, valueTokenParser):
+    of (Some(@key), Some(@value)):
+      ok(Parser(
+        state: value.state,
+        tokens: @[
+          key.tokens[0],
+          value.tokens[0],
+        ]
+      ))
+    else: valueTokenParser
+
+let propertiesStartParser* = str(":PROPERTIES_START:") + newline
+let propertiesEndParser* = str(":PROPERTIES_END:") + newline
+
+let parseProperties* = @[
+  ignore(propertiesStartParser),
+  manyUntil(
+    propertiesParser,
+    propertiesEndParser,
+  ),
+  ignore(propertiesEndParser),
+]
+
+when isMainModule:
+  let example = initParserResult(""":PROPERTIES:
+:PROP_NAME: Value
+:PROP_NAME: Value
+:PROP_NAME: Value
+:PROP_NAME: Value
+:PROPERTIES_END:""").parseSeq(parseProperties)
+
+  echo example

src/org_parser.nim

@@ -3,104 +3,43 @@ import std/strformat
 import std/collections/sequtils
 import std/strutils
 import parser/parser
+import parser/utils
 import results
 import utils/fp
 import fusion/matching
 
 {.experimental: "caseStmtMacros".}
 
-type StringBuilderT = string
-type StringBuilder = Builder[StringBuilderT]
-type StringBuilderResult = BuilderResult[StringBuilderT]
-proc stringConcat(typeInfo: StringBuilderT):
-                  (seq[ParserToken], seq[StringBuilderT]) -> seq[StringBuilderT] =
+let parseHeadingStars = @[
+  manyUntil(ch('*'), ch(' ')),
+  ignore(ch(' '))
+]
 
-  return proc(xs: seq[ParserToken], ys: seq[StringBuilderT]): seq[StringBuilderT] =
-    return ys & xs.foldl(a & b.tokenStringValue(), typeInfo)
+proc createTodoKeywordParser(xs: seq[string]): (Parser -> ParserResult) =
+  choice(xs.map((x: string) => str(x) + ignore(ch(' '))))
 
+let todoKeywords = @["TODO"]
+let doneKeywords = @["DONE"]
 
-proc initStringBuilder(str: string): StringBuilderResult =
-  StringBuilderResult
-  .ok(StringBuilder((
-    parser: initParser(str),
-    tree: newSeq[StringBuilderT](),
-  )))
+let parseTodoKeyword = todoKeywords.createTodoKeywordParser()
+let parseDoneKeyword = doneKeywords.createTodoKeywordParser()
+
+let parseHeadingText = @[
+  anyUntil(newline),
+  ignore(newline),
+]
 
 when isMainModule:
-  let parseHeadingStars = @[
-    manyUntil(ch('*'), ch(' ')),
-    ignore(ch(' '))
-  ]
-
-  proc createTodoKeywordParser(xs: seq[string]): (Parser -> ParserResult) =
-    choice(xs.map((x: string) => str(x) + ignore(ch(' '))))
-
-  let todoKeywords = @["TODO"]
-  let doneKeywords = @["DONE"]
-
-  let parseTodoKeyword = todoKeywords.createTodoKeywordParser()
-  let parseDoneKeyword = doneKeywords.createTodoKeywordParser()
-
-  let propertiesKeyParser = ignore(ch(':')) + anyUntil(choice(@[str(": "), newline]))
-  let propertiesValueParser = ignore(str(": ")) + anyUntil(newline) + ignore(newline)
-  let propertiesParser = proc(parser: Parser): ParserResult {.closure.} =
-    let keyTokenParser = parser
-    .propertiesKeyParser()
-    .flatMap(flattenParserTokens)
-
-
-    let valueTokenParser = keyTokenParser
-    .map(emptyTokens)
-    .flatMap(propertiesValueParser)
-    .flatMap(flattenParserTokens)
-
-    case (keyTokenParser, valueTokenParser):
-      of (Some(@key), Some(@value)):
-        ok(Parser(
-          state: value.state,
-          tokens: @[
-            key.tokens[0],
-            value.tokens[0],
-          ]
-        ))
-      else: valueTokenParser
-
-  let propertiesStartParser = str(":PROPERTIES_START:") + newline
-  let propertiesEndParser = str(":PROPERTIES_END:") + newline
-
-  let parseProperties = @[
-    ignore(propertiesStartParser),
-    manyUntil(
-      propertiesParser,
-      propertiesEndParser,
-    ),
-    ignore(propertiesEndParser),
-  ]
-
-
-  echo initParserResult(""":PROPERTIES:
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROPERTIES_END:
-""").parseSeq(parseProperties)
-
-  let parseHeadingText = @[
-    anyUntil(newline),
-    ignore(newline),
-  ]
-
   let sampleBuilder = StringBuilderResult
   .ok(StringBuilder((
     parser: initParser("""**** TODO Some stars
-:PROPERTIES:
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROP_NAME: Value
-:PROPERTIES_END:
-"""),
+  :PROPERTIES:
+  :PROP_NAME: Value
+  :PROP_NAME: Value
+  :PROP_NAME: Value
+  :PROP_NAME: Value
+  :PROPERTIES_END:
+  """),
     tree: newSeq[StringBuilderT](),
   )))
   .applyParsersSeq(@[
@@ -118,4 +57,4 @@ when isMainModule:
     xs => "Parser Succesfull:\n" & xs.join("\n"),
   )
 
-  # echo sampleBuilder
+  echo sampleBuilder

src/parser/parser.nim

@@ -33,8 +33,8 @@ type
       #   keyValuePairValue*: parserTokenKeyValuePairValueT
 
   Parser* = ref object
-    state: ParserState
-    tokens: seq[ParserToken]
+    state*: ParserState
+    tokens*: seq[ParserToken]
 
   ParseErrorKind = enum
     choiceMismatchErr
@@ -238,6 +238,26 @@ func ignore*(parserFn: Parser -> ParserResult): (Parser -> ParserResult) {.inlin
       tokens: parser.tokens,
     ))
 
+
+func flattenParserTokens*(parser: Parser): ParserResult =
+  return ParserResult.ok(
+    Parser(
+      state: parser.state,
+      tokens: @[
+        ParserToken(
+          kind: parserTokenString,
+          stringValue: parser.tokens.foldl(a & b.tokenStringValue(), "")
+        )
+      ]
+    )
+  )
+
+func emptyTokens*(parser: Parser): Parser =
+  Parser(
+    state: parser.state,
+    tokens: newSeq[ParserToken](),
+  )
+
 func optional*(parserFn: Parser -> ParserResult): (Parser -> ParserResult) {.inline.} =
   ## Parse characters and ignore failure
   return proc(parser: Parser): ParserResult =
@@ -293,8 +313,8 @@ proc `+`*(parserFnA: Parser -> ParserResult, parserFnB: Parser -> ParserResult):
 
 
 let newlineParser = choice(@[
+  ch(NewLines),
   endOfStream,
-  ch(NewLines)
 ])
 proc newline*(parser: Parser): ParserResult = newlineParser(parser)
 

src/parser/utils.nim

@@ -0,0 +1,21 @@
+import std/sugar
+import std/collections/sequtils
+import ./parser
+import results
+
+type StringBuilderT* = string
+type StringBuilder* = Builder[StringBuilderT]
+type StringBuilderResult* = BuilderResult[StringBuilderT]
+
+proc stringConcat*(typeInfo: StringBuilderT):
+                  (seq[ParserToken], seq[StringBuilderT]) -> seq[StringBuilderT] =
+
+  return proc(xs: seq[ParserToken], ys: seq[StringBuilderT]): seq[StringBuilderT] =
+    return ys & xs.foldl(a & b.tokenStringValue(), typeInfo)
+
+proc initStringBuilder*(str: string): StringBuilderResult =
+  StringBuilderResult
+  .ok(StringBuilder((
+    parser: initParser(str),
+    tree: newSeq[StringBuilderT](),
+  )))

src/utils/fp.nim

@@ -1,5 +1,9 @@
 import std/sugar
 import fp/maybe
+import results
+
+template isSome*(self: Result): bool = self.isOk()
+template isNone*(self: Result): bool = self.isErr()
 
 proc findMaybe*[T](xs: seq[T], fn: T -> bool): Maybe[T] =
   for x in xs: