From ff1d6845eb580ff1f687894a6d8d48573d81c563 Mon Sep 17 00:00:00 2001 From: Florian Schroedl Date: Thu, 20 Jan 2022 17:00:00 +0100 Subject: [PATCH] Remove concatination from the builder, it's now the duty of the internal method --- src/org/org_builder.nim | 17 +++++++++---- src/org/org_text_delimiter.nim | 45 +++++++++++++++++----------------- src/parser/builder_api.nim | 22 ++++++++++------- 3 files changed, 47 insertions(+), 37 deletions(-) diff --git a/src/org/org_builder.nim b/src/org/org_builder.nim index 86e1655..7b749bc 100644 --- a/src/org/org_builder.nim +++ b/src/org/org_builder.nim @@ -8,12 +8,19 @@ type OrgBuilder* = Builder[OrgBuilderT] type OrgBuilderResult* = BuilderResult[OrgBuilderT] func makeOrgBuilderToken*(kind: orgElementKind): string -> OrgBuilderT = + +func textTokenizer*(kind: orgElementKind): seq[ParserToken] -> seq[OrgBuilderT] = + return func(tokens: seq[ParserToken]): seq[OrgBuilderT] = + return @[ + OrgBuilderT( + kind: kind, + content: tokens.tokensToString(), + ) + ] + +func rawTextTokenizer*(kind: orgElementKind): string -> OrgBuilderT = return func(content: string): OrgBuilderT = return OrgBuilderT( - kind: orgRawText, + kind: kind, content: content, ) - -proc mergeOrgTokens*(tokenizer: string -> OrgBuilderT): (seq[ParserToken], seq[OrgBuilderT]) -> seq[OrgBuilderT] = - return proc(parserTokens: seq[ParserToken], builderTokens: seq[OrgBuilderT]): seq[OrgBuilderT] = - return builderTokens & tokenizer(parserTokens.tokensToString()) diff --git a/src/org/org_text_delimiter.nim b/src/org/org_text_delimiter.nim index 3c2736f..b7c5069 100644 --- a/src/org/org_text_delimiter.nim +++ b/src/org/org_text_delimiter.nim @@ -11,28 +11,28 @@ import ../parser/parser_internals import ../parser/parser_types import ../parser/builder_api -let boldParser* = parseBetweenPair(ch('*')) -let italicParser* = parseBetweenPair(ch('/')) -let underlineParser* = parseBetweenPair(ch('_')) -let verbatimParser* = parseBetweenPair(ch('=')) -let codeParser* = parseBetweenPair(ch('~')) -let strikeThroughParser* = parseBetweenPair(ch('+')) +let boldParser* = parseBetweenPair(ch('*')) +let italicParser* = parseBetweenPair(ch('/')) +let underlineParser* = parseBetweenPair(ch('_')) +let verbatimParser* = parseBetweenPair(ch('=')) +let codeParser* = parseBetweenPair(ch('~')) +let strikeThroughParser* = parseBetweenPair(ch('+')) -let rawTokenizer* = makeOrgBuilderToken(orgRawText) -let boldTokenizer* = makeOrgBuilderToken(orgBoldText) -let italicTokenizer* = makeOrgBuilderToken(orgItalicText) -let underlineTokenizer* = makeOrgBuilderToken(orgUnderlineText) -let verbatimTokenizer* = makeOrgBuilderToken(orgVerbatimText) -let codeTokenizer* = makeOrgBuilderToken(orgCodeText) -let strikeThroughTokenizer* = makeOrgBuilderToken(orgStrikeThroughText) +let rawTokenizer* = rawTextTokenizer(orgRawText) +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 orgStyledTextBuilders = @[ - (boldParser, mergeOrgTokens(boldTokenizer)), - (italicParser, mergeOrgTokens(italicTokenizer)), - (underlineParser, mergeOrgTokens(underlineTokenizer)), - (verbatimParser, mergeOrgTokens(verbatimTokenizer)), - (codeParser, mergeOrgTokens(codeTokenizer)), - (strikeThroughParser, mergeOrgTokens(strikeThroughTokenizer)), + (boldParser, boldTokenizer), + (italicParser, italicTokenizer), + (underlineParser, underlineTokenizer), + (verbatimParser, verbatimTokenizer), + (codeParser, codeTokenizer), + (strikeThroughParser, strikeThroughTokenizer), ] proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgBuilderT] = @@ -43,10 +43,9 @@ proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgBuilderT] = else: @[rawTokenizer(str)] when isMainModule: - let test = OrgBuilderResult.ok(OrgBuilder(( - parser: initParser("Regular *bold* /italic/ _underline_ =verbatim= ~code~ +strikethrough+"), - tree: newSeq[OrgBuilderT](), - ))) + let test = initOrgBuilder( + "Regular *bold* /italic/ _underline_ =verbatim= ~code~ +strikethrough+" + ) .flatMap((builder: OrgBuilder) => tryParseBuild( builder = builder, builderFns = orgStyledTextBuilders, diff --git a/src/parser/builder_api.nim b/src/parser/builder_api.nim index 69c0582..f4523fb 100644 --- a/src/parser/builder_api.nim +++ b/src/parser/builder_api.nim @@ -11,9 +11,9 @@ proc tryParseBuild*[T]( builder: Builder[T], builderFns: seq[tuple[ parserFn: Parser -> ParserResult, - concatFn: (seq[ParserToken], seq[T]) -> seq[T], + builderFn: seq[ParserToken] -> seq[T], ]], - defaultBuilderFn: (seq[ParserToken]) -> seq[T], + defaultBuilderFn: seq[ParserToken] -> seq[T], stopAtParserFn = newline, ): BuilderResult[T] = ## Parse remaining text in `builder` by going checking in the `builderFns` list for a sucessful `parserFn`. @@ -32,8 +32,8 @@ proc tryParseBuild*[T]( # Find the first matching parser and convert its tokens var found = false - for builderFn in builderFns: - let (parserFn, concatFn) = builderFn + for fn in builderFns: + let (parserFn, builderFn) = fn let parseResult = emptyParser.flatMap(parserFn) if parseResult.isOk(): @@ -50,10 +50,11 @@ proc tryParseBuild*[T]( parserAcc = parseResult.map(emptyTokens) builderAcc = builder.initBuilder( okParser, - concatFn( - okParser.tokens, - builderAcc[1] & defaultBuilderTokens, - ), + concat( + builderAcc[1], + defaultBuilderTokens, + builderFn(okParser.tokens), + ) ) break @@ -68,5 +69,8 @@ proc tryParseBuild*[T]( BuilderResult[T].ok(builder.initBuilder( builderAcc[0], - builderAcc[1] & defaultBuilderTokens, + concat( + builderAcc[1], + defaultBuilderTokens, + ), ))