Getting parser error

src_v2/org/org_builder_paragraph.nim

@@ -8,7 +8,8 @@ import fp/[
 ]
 import ./org_types
 import ./org_builder_api
-import ./org_builder_link.nim
+import ./org_builder_link
+import ./org_builder_inline_text
 import ../parser/parser
 import ../utils/fp
 
@@ -44,12 +45,9 @@ let listStartParser = manyUntil(space, listTypesParser)
 let listTypeParser = listTypesParser + ignore(space)
 let listContentParser = anyUntil(newlineOrEol) + ignore(newlineOrEol)
 
-proc buildListItem(builder: OrgBuilder): OrgBuilderResult =
-
+let buildListItem = proc(builder: OrgBuilder): OrgBuilderResult {.closure.} =
   let (parser, tree) = builder
 
-  # let initialParser = ParserResult.ok(parser)
-
   let beforeSpaces = ParserResult.ok(parser)
   .flatMap(listStartParser)
   .map(flattenTokens)
@@ -64,43 +62,62 @@ proc buildListItem(builder: OrgBuilder): OrgBuilderResult =
   .flatMap(listContentParser)
   .map(flattenTokens)
 
-  let y = case (beforeSpaces, listType, listContent):
-    of (Some(@a), Some(@b), Some(@c)): c.tokens.tokensToString()
-    else: ""
-  echo y
+  case (beforeSpaces, listType, listContent):
+    of (Some(@space), Some(@symbol), Some(@content)):
+      let treeResult = tree &
+        OrgBlock(
+          kind: orgList,
+          listIndentation: 1,
+          listBulletType: '-',
+          listContent: tryTokenizeInline(content.tokens.tokensToString()).unsafeGet().tree
+        )
+      # echo treeResult
 
-  builder.ok()
+      OrgBuilderResult.ok(OrgBuilder((
+        parser: content,
+        tree: treeResult,
+      )))
+    else: OrgBuilderResult.err(OrgBuilderError(
+      kind: parserError,
+      parser: listContent.error,
+      tree: tree,
+    ))
 
-discard initOrgBuilder("  1. foo bar").map(buildListItem)
+proc buildParagraph*(
+  builder: OrgBuilder,
+  builderFns: seq[proc (builder: OrgBuilder): OrgBuilderResult],
+  stopAtParserFn = endOfStream,
+): OrgBuilderResult =
 
+  var builderAcc: OrgBuilderResult = OrgBuilderResult.ok(builder)
 
-# proc buildParagraph*(
-#   builder: OrgBuilder,
-#   builderFns: seq[tuple[
-#     builderFn: OrgBuilder -> OrgBuilderResult,
-#     concatFn: OrgBuilder -> OrgBuilder,
-#   ]],
-#   stopAtParserFn = endOfStream,
-# ): OrgBuilderResult =
+  while builderAcc.isOk() and builderAcc.tryParserResult(stopAtParserFn).isErr():
+    var found = false
 
-#   var builderAcc = OrgBuilderResult.ok(builder)
+    for builderFn in builderFns:
+      # let (builderFn) = fn
+      let builderResult: OrgBuilderResult = builderAcc.flatMap(builderFn)
 
-#   while builderAcc.isOk() and builderAcc.applyParser(stopAtParserFn).isErr():
-#     var found = false
+      if builderResult.isOk():
+        found = true
 
-#     for fn in builderFns:
-#       let builderResult = builderAcc.flatMap(fn)
+        builderAcc = builderResult
+        break
 
-#       if builderResult.isOk():
-#         found = true
+    if not found:
+      builderAcc = OrgBuilderResult.err(OrgBuilderError(
+        kind: parserError,
+        tree: builder.tree,
+      ))
+      break
 
-#         builderAcc = builderAcc.map((x: OrgBuilder) => x.concat(builderResult.unsafeGet()))
-#         break
+  builderAcc
 
-# when isMainModule:
-#   block testParsers:
-#     proc testParser(str: string, parser: parserFnT): string =
-#       initParserResult(str).flatMap(parser).tokensToString()
+let paragraphBuilders: seq[proc (builder: OrgBuilder): OrgBuilderResult] = @[buildListItem]
 
-#     assert testParser("- List item", listItemParser) == "- List item"
-#     assert testParser("  - List item", listItemParser) == "  - List item"
+when isMainModule:
+  block testParsers:
+    let test = initOrgBuilder("""- List item
+1. List item
+random stuff""").flatMap((builder: OrgBuilder) => builder.buildParagraph(paragraphBuilders))
+    echo test.isOk()