Restore InlineBuilder

src_v2/org/org_builder.nim

@@ -22,7 +22,7 @@ func initOrgInlineBuilder*(content: string): OrgInlineBuilderResult =
     tree: newSeq[OrgInlineBuilderT](),
   )))
 
-func convertTokens*(kind: orgInlineBlockKind): seq[ParserToken] -> seq[OrgInlineBuilderT] =
+func tokenizeInlineTokens*(kind: orgInlineBlockKind): seq[ParserToken] -> seq[OrgInlineBuilderT] =
   return func(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
     return @[
       OrgInlineBuilderT(
@@ -31,12 +31,12 @@ func convertTokens*(kind: orgInlineBlockKind): seq[ParserToken] -> seq[OrgInline
       )
     ]
 
-# func rawTextTokenizer*(kind: orgInlineBlockKind): string -> OrgInlineBuilderT =
+func tokenizeRawText*(kind: orgInlineBlockKind): string -> OrgInlineBuilderT =
-#   return func(content: string): OrgInlineBuilderT =
+  return func(content: string): OrgInlineBuilderT =
-#     return OrgInlineBuilderT(
+    return OrgInlineBuilderT(
-#       kind: kind,
+      kind: kind,
-#       content: content,
+      content: content,
-#     )
+    )
 
 # ## Blocks
 # type OrgBuilderT* = OrgBlock

src_v2/org/org_text_delimiter.nim

@@ -1,7 +1,5 @@
 import std/[
   collections/sequtils,
-  strformat,
-  strutils,
   sugar,
 ]
 import fp/[
@@ -11,10 +9,6 @@ import ./org_types
 import ./org_builder
 import ../parser/parser
 # import ./org_text_link
-# import ../utils/fp
-# import ../parser/parser_internals
-# import ../parser/parser_types
-# import ../parser/builder_api
 
 # -- Parsers
 
@@ -25,47 +19,44 @@ let verbatimParser* =           anyBetweenPair(ch('='))
 let codeParser* =             anyBetweenPair(ch('~'))
 let strikeThroughParser* =    anyBetweenPair(ch('+'))
 
-# let rawTokenizer* =           rawTextTokenizer(orgRawText)
+# -- Tokenizers
-# let boldTokenizer* =          textTokenizer(orgBoldText)
-# let italicTokenizer* =        textTokenizer(orgItalicText)
-# let underlineTokenizer* =     textTokenizer(orgUnderlineText)
-# let verbatimTokenizer* =      textTokenizer(orgVerbatimText)
-# let codeTokenizer* =          textTokenizer(orgCodeText)
-# let strikeThroughTokenizer* = textTokenizer(orgStrikeThroughText)
 
-# let tok = linkTokenizerSeq
+let rawTextTokenizer* =       tokenizeRawText(orgRawText)
 
-# let orgStyledTextBuilders = @[
+let boldTokenizer* =          tokenizeInlineTokens(orgBoldText)
-#   (boldParser,          boldTokenizer),
+let italicTokenizer* =        tokenizeInlineTokens(orgItalicText)
-#   (italicParser,        italicTokenizer),
+let underlineTokenizer* =     tokenizeInlineTokens(orgUnderlineText)
-#   (underlineParser,     underlineTokenizer),
+let verbatimTokenizer* =      tokenizeInlineTokens(orgVerbatimText)
-#   (verbatimParser,      verbatimTokenizer),
+let codeTokenizer* =          tokenizeInlineTokens(orgCodeText)
-#   (codeParser,          codeTokenizer),
+let strikeThroughTokenizer* = tokenizeInlineTokens(orgStrikeThroughText)
-#   (strikeThroughParser, strikeThroughTokenizer),
-#   (linkParser,          linkTokenizerSeq),
-# ]
 
-# proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
+let styledTextTokenizers = @[
-#   ## Merge all parser `tokens` into a string to tokenize for the builder.
+  (boldParser,          boldTokenizer),
-#   ## Unless the string is empty, in this case return an empty list.
+  (italicParser,        italicTokenizer),
-#   let str = tokens.foldl(a & b.tokenStringValue(), "")
+  (underlineParser,     underlineTokenizer),
-#   if str.len == 0: @[]
+  (verbatimParser,      verbatimTokenizer),
-#   else: @[rawTokenizer(str)]
+  (codeParser,          codeTokenizer),
+  (strikeThroughParser, strikeThroughTokenizer),
+  # (linkParser,          linkTokenizerSeq),
+]
 
-# proc tryBuildInline*(content: string): OrgInlineBuilderResult =
+proc tryTokenizeRawText(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
-#   initOrgInlineBuilder(content)
+  ## Merge all parser `tokens` into a string to tokenize for the builder.
-#   .flatMap((builder: OrgInlineBuilder) => tryParseBuild(
+  ## Unless the string is empty, in this case return an empty list.
-#     builder = builder,
+  let str = tokens.foldl(a & b.toString(), "")
-#     builderFns = orgStyledTextBuilders,
+  if str.len == 0: @[]
-#     defaultBuilderFn = makeRawTokenOrEmpty,
+  else: @[rawTextTokenizer(str)]
-#   ))
 
-# when isMainModule:
+proc tryTokenizeInline*(content: string): OrgInlineBuilderResult =
-#   let test = tryBuildInline(
+  initOrgInlineBuilder(content)
-#     "Regular *bold* [[placeholder.com]] /italic/ _underline_ =verbatim= ~code~ +strikethrough+ [[https://placeholder.com][title]]"
+  .flatMap((builder: OrgInlineBuilder) => tryTokenize(
-#   )
+    builder = builder,
+    builderFns = styledTextTokenizers,
+    defaultTokenizerFn = tryTokenizeRawText,
+  ))
 
-#   echo test
+
+# -- Tests
 
 when isMainModule:
   block testParsers:
@@ -78,3 +69,9 @@ when isMainModule:
     assert testParser("=verbatim=", verbatimParser) == "verbatim"
     assert testParser("~code~", codeParser) == "code"
     assert testParser("+strikeThrough+", strikeThroughParser) == "strikeThrough"
+
+  block testTokenizers:
+    let test = tryTokenizeInline(
+        "Regular *bold* [[placeholder.com]] /italic/ _underline_ =verbatim= ~code~ +strikethrough+ [[https://placeholder.com][title]]"
+    )
+    echo test.unsafeGet()