l43_peg 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 373ca9885275389a284235de2dc5f95eb2f470aeece99bf47e9b54ed6e3fdf60
-  data.tar.gz: 62ac1897c26b540da5205d7b0fcb6aa1ff472f036e36ca5389c3ac4767fbf926
+  metadata.gz: 0d386b9373423da69f7697e81bd02a011df1c36cc20ff6c861b3215a2081dea9
+  data.tar.gz: b82ba81e4372717f6603b6b41311d1ff2f608ce4a9cc7376c3242a65e3842432
 SHA512:
-  metadata.gz: b51cd93714348ba6be2394cd63543603af953820394a6cc201a39c4721d1a10a4ec4bf224ad84c3a9eae49f426126da35dcc0b8cd751f9d6e6265f0341172daf
-  data.tar.gz: edbcd0d28cedcb395a6721a28f5f2284fefdaa28c1d7eb6449d8f53a90a00219177aace6e15208f87bd12488ab01712aa015b75179d0195decc34b1d78bba1a7
+  metadata.gz: 265f550e6e956e85c5b0a39a5817ab13424e57d0da7d44ff9b946c318392421955292d7462b24a4a744c2f8361af10b627204800408fa500500c6779d359314b
+  data.tar.gz: 54eb3d55de2704d91c31d9fd31db3931fab1c5f614a005e11ca3efcafb854cf964f8b6a3e26bc43d93005065bc42dcdd517b6ef3d3284c3d205f93f7c9ccf466

data/README.md

@@ -6,91 +6,91 @@
 
 ### This Version (v0.1.x) is Alpha Quality (many PEG features are missing, like recursion and even alternatives.
 
-It is however released because it offers quite some nice parsing of ARGV which shall be demonstrated by the following
-[speculations](https://rubygems.org/gems/speculate_about)
+    It is however released because it offers quite some nice parsing of ARGV which shall be demonstrated by the following
+    [speculations](https://rubygems.org/gems/speculate_about)
 
-See [README_spec.rb](spec/speculations/README_spec.rb) for the generated code for details
+    See [README_spec.rb](spec/speculations/README_spec.rb) for the generated code for details
 
 ### Context: `arg_parser`
 
 Given the following argument specification
 
 ```ruby 
-  include L43Peg::Combinators
-   let :args_spec do
-       {
-          start: "--start=(.*)",
-          end: "(?:--end|-e)=(.*)",
-          kwd: "--(alpha|beta|gamma)"
-       }
-   end
+    include L43Peg::Combinators
+    let :args_spec do
+    {
+      start: "--start=(.*)",
+      end: "(?:--end|-e)=(.*)",
+      kwd: "--(alpha|beta|gamma)"
+    }
+    end
 ```
 
 And the assoicated parser
 
 ```ruby
-   let(:parser) { args_parser(args_spec) } 
+  let(:parser) { args_parser(args_spec) } 
 ```
 
 Then we can parse some input
 
 ```ruby
-    assert_parse_success(parser, %w[--start=42 --beta -e=44], ast: {start: "42", kwd: "beta", end: "44"}, rest: [])
+assert_parse_success(parser, %w[--start=42 --beta -e=44], ast: {start: "42", kwd: "beta", end: "44"}, rest: [])
 ```
 
 And we can get the rest in a list of tokens
 
 ```ruby
-    assert_parse_success(parser, %w[--start=42 --beta -e=44 -s=not_an_arg --end=too_late], ast: {start: "42", kwd: "beta", end: "44"}, rest: %w[-s=not_an_arg --end=too_late])
+assert_parse_success(parser, %w[--start=42 --beta -e=44 -s=not_an_arg --end=too_late], ast: {start: "42", kwd: "beta", end: "44"}, rest: %w[-s=not_an_arg --end=too_late])
 ```
 
 Also note that multiple values are passed into an array
 
 ```ruby
-    input = %w[--end=42 --beta -e=44 --beta --end=not_too_late --gamma]
-    ast   = {end: %w[42 44 not_too_late], kwd: %w[beta beta gamma]}
-    assert_parse_success(parser, input, ast:, rest: [])
-```
+input = %w[--end=42 --beta -e=44 --beta --end=not_too_late --gamma]
+ast   = {end: %w[42 44 not_too_late], kwd: %w[beta beta gamma]}
+assert_parse_success(parser, input, ast:, rest: [])
+  ```
 
 #### Context: Postprocessing
 
-When we map the parser
-
-```ruby
-   let :int_args do
-     {
-      start: "--start=(.*)",
-      end: "--end=(.*)",
-      inc: "--inc=(.*)"
-     }
-   end
-   let(:int_arg_parser) {args_parser(int_args, name: "int parser", &:to_i)}
+  When we map the parser
+
+  ```ruby
+  let :int_args do
+{
+start: "--start=(.*)",
+         end: "--end=(.*)",
+         inc: "--inc=(.*)"
+}
+end
+let(:int_arg_parser) {args_parser(int_args, name: "int parser", &:to_i)}
 ```
 
 Then we can convert the string valus
 
-```ruby
-    assert_parse_success(int_arg_parser, %w[--start=42 --end=44 --inc=2], ast: {start: 42, end: 44, inc: 2}, rest: [])
-```
+  ```ruby
+assert_parse_success(int_arg_parser, %w[--start=42 --end=44 --inc=2], ast: {start: 42, end: 44, inc: 2}, rest: [])
+  ```
 
 #### Context: Knowing When To Stop
 
-An argument parser that respects itself provides a means to _end_ argument parsing even if more matches follow.
-An exmaple for that is the posix argument `--`
+  An argument parser that respects itself provides a means to _end_ argument parsing even if more matches follow.
+  An exmaple for that is the posix argument `--`
 
-We can use whatever we want in `args_parser`, here is a variation:
+  We can use whatever we want in `args_parser`, here is a variation:
 
-Given the specification
+  Given the specification
 
-```ruby
-   let :args do
-   {
+  ```ruby
+  let :args do
+    {
       width: "w:(\\d+)",
       height: "h:(\\d+)",
-      __stop: "(::)"
+       __stop: "(::)"
     }
-   end
-   let(:wh_parser) {args_parser(args, stop: :__stop, &:to_i)}
+  end
+  let(:wh_parser) {args_parser(args, stop: :__stop, &:to_i)}
 ```
 
 Then parsing the following input
@@ -99,7 +99,7 @@ Then parsing the following input
     input = %w[h:42 w:73 :: w:74]
     ast   = {height: 42, width: 73}
     assert_parse_success(wh_parser, input, ast:, rest: %w[w:74])
-```
+  ```
 
 ### Context: User Interface
 
@@ -111,45 +111,205 @@ as module methods
 
 Given an _exposed_ `args_parser`
 ```ruby
-   let :parser do
-     L43Peg::Parsers.args_parser(
-       {
-          negative: "(-\\d+)",
-          positive: "\\+?(\\d+)"
-       },
-       &:to_i
-     )
-   end
+let :parser do
+L43Peg::Parsers.args_parser(
+  {
+    negative: "(-\\d+)",
+    positive: "\\+?(\\d+)"
+},
+&:to_i
+)
+end
 ```
 
 But we are also not interested in the internal representation of success and failure of parsing which was
 used in the speculations above. Nor do we want to transform our input into the internal representations
 as was done above by the helpers. (If you need to see the details of this you can inspect the
-file [`parser_test.rb` in `spec/support`](spec/support/parser_test.rb))
-   
+  file [`parser_test.rb` in `spec/support`](spec/support/parser_test.rb))
+
 Then we can uses the interface of `L43Peg`
 
 ```ruby
-   L43Peg.parse_tokens(parser, %w[43 -44 +45]) => :ok, result
-   expect(result).to eq(positive: [43, 45], negative: -44)
+  L43Peg.parse_tokens(parser, %w[43 -44 +45]) => :ok, result
+    expect(result).to eq(positive: [43, 45], negative: -44)
 ```
 
 And if we get an error the result is as follows
 
 ```ruby
-   parser = L43Peg::Parsers.char_parser('a') 
-   L43Peg.parse_string(parser, 'b') => :error, message
-   expect(message).to eq("char \"b\"")
+parser = L43Peg::Parsers.char_parser('a') 
+L43Peg.parse_string(parser, 'b') => :error, message
+expect(message).to eq("char \"b\"")
+```
+
+## Context: Regexp Parser
+
+The basic concept is the `rgx_parser`
+
+Given a `rgx_parser` for an identifier
+```ruby
+include L43Peg::Parsers
+let(:id_parser) { rgx_parser("[[:alpha:]][_[:alnum:]]*") } 
+```
+
+Then we can parse strings that start as such
+```ruby
+assert_parse_success(id_parser, "l43_peg", ast: "l43_peg")
+```
+
+And we can discard some input from the ast with the aid of captures
+```ruby
+sym_parser = rgx_parser(":([[:alpha:]][_[:alnum:]]*)")
+assert_parse_success(sym_parser, ":no_colon", ast: "no_colon")
+```
+
+But it can also fail
+```ruby
+reason = "input does not match /\\A[[:alpha:]][_[:alnum:]]*/ (in rgx_parser(\"[[:alpha:]][_[:alnum:]]*\"))"
+assert_parse_failure(id_parser, "42", reason:)
+```
+
+#### Context: Warnings on empty matches
+
+Oftentimes bugs in PEG parsing are caused by zero width matches, while this is quite obvious with the `many` and
+`opt` or `maybe` combinators (**N.B.** they are not yet implemented, use `many(max: 1)` instead)
+and they common use patterns with these combinators are safe.
+
+However regular expression parsing might hide zero width matches, and that's whey they will trigger a warning by default
+
+Given an empty match rgex parser
+```ruby
+    let(:empty_parser) { rgx_parser("a*") }
+```
+
+Then we get a warning when matching an empty string
+```ruby
+    expect { assert_parse_success(empty_parser, "", ast: "") }
+      .to output("Warning, parser rgx_parser(\"a*\") succeeds with empty match\n").to_stderr
+```
+
+However this behavior can also be disabled
+
+And therefore
+```ruby
+    parser = rgx_parser("a*", warn_on_empty: false)
+    expect { assert_parse_success(parser, "", ast: "") }
+      .not_to output.to_stderr
+```
+
+
+### Context: Tokenize Strings with Regexen
+
+Now we can use a list of `rgx_parsers` to _tokenize_ a string (in the same way can use `tokens_parser` to
+  quantify elements of an array, but with dynamic bounds)
+
+Given some regexen
+```ruby
+let :regexen do
+[
+[:verb, "<<", nil, ->(*){ [:verb, "<"] }],
+[:verb, "\\$(\\$)"],
+[:color_and_style, "<(.+?),(.+?)>", :all],
+[:color, "<(.+?)>", 1],
+[:reset, "\\$"],
+[:verb, "[^<$]+"],
+]
+end
+let(:tokenizer) { L43Peg::Combinators.rgx_tokenize(regexen) }
+```
+
+Then we can tokenize some inputs
+```ruby
+input = "<red,bold>HELLO$and<<<green>$$<reset>"
+ast = [ 
+[:color_and_style, ["<red,bold>", "red", "bold"]],
+[:verb, "HELLO"],
+[:reset, "$"],
+[:verb, "and"],
+[:verb, "<"],
+[:color, "green"],
+[:verb, "$"],
+[:color, "reset"]
+]
+assert_parse_success(tokenizer, input, ast:)
+```
+
+### Context: Debugging
+
+As parsers are by design imbricated functions debugging is not always simple.
+Enter the `debug_parser`, a parser that _debugs_  parsers by not changing their behavior
+by displaying more or less detailed information
+
+Given a parser
+```ruby
+  include L43Peg::Combinators
+  let :args do
+    {
+      lat: "lat:(\\d+)",
+      long: "long:(\\d+)",
+    }
+  end
+  let(:geo_parser) {args_parser(args, &:to_i)}
+```
+
+#### Context: Minimum level of information
+
+Given a minum debug parser
+```ruby
+  let(:debugger) {debug_parser(geo_parser, level: :min)}
+```
+
+Then we will get some output
+```ruby
+    expected =
+        "Tokens<[\"lat:43\", \"long:2\"]>\nSuccess: @1\n"
+    expect { parsed_success(debugger, ["lat:43", "long:2"]) }
+        .to output(expected).to_stderr
+```
+
+#### Context: Default level of information
+Given a default debug parser
+```ruby
+    let(:debugger) {debug_parser(char_parser("a"))}
+```
+
+Then we will get some output on errors
+```ruby
+    expected ="Input<\"b\"@1:1>\nFailure: char \"b\" @[1, 1]\n"
+    expect { parsed_failure(debugger, "b") }
+        .to output(expected).to_stderr
+```
+
+#### Context: Maximum level of information
+Given a maxium level parser
+```ruby
+    let(:max_debugger) { debug_parser(char_parser("b"), level: :max) }
+```
+
+Then we will get this output on errors
+```ruby
+expected = 
+    [ 
+      "================================================================================",
+      'Input<col:1 input:"bc" lnb:1 context:{}>',
+      "================================================================================",
+      'Success<ast:"b" cache:{} rest:"c">',
+      "================================================================================",
+      ""
+    ].join("\n")
+
+    expect { parsed_success(max_debugger,"bc") }
+      .to output(expected).to_stderr
 ```
 
 
 # Author
 
-Copyright © 2024 Robert Dober
-robert.dober@gmail.com
+  Copyright © 2024 Robert Dober
+  robert.dober@gmail.com
 
 # LICENSE
 
-GNU AFFERO GENERAL PUBLIC LICENSE, Version 3, 19 November 2007. Please refer to [LICENSE](LICENSE) for details.
+  GNU AFFERO GENERAL PUBLIC LICENSE, Version 3, 19 November 2007. Please refer to [LICENSE](LICENSE) for details.
 
-<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+  <!-- SPDX-License-Identifier: AGPL-3.0-or-later -->

data/lib/l43_peg/combinators/debug_parser.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Combinators
+    module DebugParser extend self
+      MIN_LEVEL = 1
+      DEFAULT_LEVEL = 5
+      MAX_LEVEL = 10
+
+      def parse_with_debug(parser:, name:, level:)
+        level = _normalize_level(level)
+        -> (input, cache, name1=nil) do
+          _report_input(input, cache:, level:, name: name1||name)
+          case parser.(input, cache:)
+          in Success => success
+            _report_success(success, name: name1||name, level:)
+          in Failure => failure
+            _report_failure(failure, name: name1||name, level:)
+          end
+        end
+      end
+
+      private
+
+      def _hl(level:)
+        _prt("="*80, level:, needed: 10)
+      end
+
+      def _normalize_level(level)
+        case level
+        when :min
+          MIN_LEVEL 
+        when :max
+          MAX_LEVEL 
+        when :default
+          DEFAULT_LEVEL
+        when MIN_LEVEL..MAX_LEVEL
+          level
+        else
+          raise ArgumentError, "bad level: #{level}, use a number between #{MIN_LEVEL} and #{MAX_LEVEL} or :min, :max, :default"
+        end
+      end
+
+      def _report_failure(failure, name:, level:)
+        _hl(level:)
+        _prt("Failure: #{failure.inspect}", level:, needed: MAX_LEVEL) ||
+          _prt("Failure: #{failure.reason} #{failure.position_hr}", level:, needed: DEFAULT_LEVEL) ||
+          _prt("Failure: #{failure.reason}")
+        failure
+      end
+
+      def _report_input(input, cache:, name:, level:)
+        _hl(level:)
+        _prt(input.debug, level:, needed: MAX_LEVEL) ||
+          _prt(input.head_hr(20, position: true), level:, needed: DEFAULT_LEVEL) ||
+          _prt(input.head_hr(5))
+      end
+
+      def _report_success(success, name:, level:)
+        _hl(level:)
+        _prt("#{success.debug}", level:, needed: MAX_LEVEL) ||
+          _prt("Success: #{success.ast.inspect} @#{success.position}", level:, needed: DEFAULT_LEVEL) ||
+          _prt("Success: @#{success.position}")
+        _hl(level:)
+
+        success
+      end
+
+      def _prt(message, level: MIN_LEVEL, needed: MIN_LEVEL, nl: true)
+        return unless level >= needed
+
+        $stderr.print(message)
+        $stderr.puts if nl
+        true
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/combinators/sel.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+module L43Peg
+  module Combinators
+    module Sel extend self
+      include L43Peg::Helper
+
+      def sel(input:, cache:, name:, parsers:)
+        parsers.each do |parser|
+          case parser.(input, cache:)
+          in L43Peg::Success => success
+            return success
+          else
+          end
+        end
+
+        fail_parser("sel #{name} could not match any option", input:)
+      end
+      
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/combinators.rb

@@ -20,10 +20,15 @@ module L43Peg
       map(inner, name:, fn: join_maps)
     end
 
+    def debug_parser(parser, name: nil, level: :default)
+      name ||= "debug_parser(#{parser.name})"
+      Parser.new(name, &DebugParser.parse_with_debug(parser:, level:, name:))
+    end
+
     def many(parser, name: nil, min: 0, max: nil)
       Parser.new(name || "many(#{parser.name})") {|input, cache, name1=nil| Many.many(input:, cache:, name: name1 || name, parser:, min:, max:)}
     end
-    
+
     def map(parser, name: nil, fn: nil, &mapper)
       raise ArgumentError, "must not provide keyword parameyer fn and a block" if fn && mapper
       mapper = fn || mapper
@@ -31,6 +36,22 @@ module L43Peg
       Parser.new(name || "map(#{parser.name})") {|input, cache, name=nil| _map(input:, cache:, name:, parser:, mapper:)}
     end
 
+    def rgx_tokenize(rgx_specs, name: nil)
+      name = name || "rgx_tokenize(#{rgx_specs.inspect})"
+      many(sel_rgx_parser(rgx_specs, name:))
+    end
+
+    def sel(parsers, name: nil)
+      name ||= "sel(#{parsers.map(&:name).join(", ")})"
+      Parser.new(name) { |input, cache, name1=nil| Sel.sel(input:, cache:, name: name1 || name, parsers:) }
+    end
+
+    def sel_rgx_parser(rgx_specs, name: nil)
+      name = name || "sel_rgx_parser(#{rgx_specs.inspect})"
+      parsers = rgx_specs.map(&_mk_rgx_parser)
+      sel(parsers, name:)
+    end
+
     def seq(*parsers, name: nil)
       name ||= "seq(#{parsers.map(&:name).join(", ")})"
       Parser.new(name) {|input, cache, _name=nil| Seq.seq(input:, cache:, name:, parsers:)}
@@ -46,6 +67,14 @@ module L43Peg
         success.map(&mapper)
       end
     end
+
+    def _mk_rgx_parser
+      -> rgxspec do
+        name, rgx, capture, fn = rgxspec
+        fn ||= -> (captures) { [name, captures] }
+        map(Parsers.rgx_parser(rgx, capture:), &fn)
+      end
+    end
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/failure.rb

@@ -4,6 +4,8 @@ module L43Peg
   class Failure
     extend L43::OpenObject
     attributes cache: nil, input: nil, parsed_by: nil, position: [1, 1], reason: ""
+
+    def position_hr = "@#{position}"
   end
 end
 # SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/input.rb

@@ -6,6 +6,12 @@ module L43Peg
 
     attributes col: 1, input: "", lnb: 1, context: {}
     
+    def debug
+      "Input<" +
+      ["col:#{col}", "input:#{input.inspect}", "lnb:#{lnb}", "context:#{context.inspect}"].join(" ") +
+      ">"
+    end
+
     def drop(by=nil)
       case by
       when nil
@@ -19,8 +25,18 @@ module L43Peg
 
     def empty? = input.empty?
 
+    def head_hr(n, position: false)
+      if position
+        "Input<#{input[0...n].inspect}@#{position_hr}>"
+      else
+        "Input<#{input[0...n].inspect}>"
+      end
+    end
+
     def position = [@col, @lnb]
 
+    def position_hr = [@col, @lnb].join(":")
+
     private
 
     def _drop_by_n(n)

data/lib/l43_peg/parser.rb

@@ -5,7 +5,9 @@ module L43Peg
 
     attr_reader :fn, :name
 
-    def call(input, cache: L43Peg::Cache.new) = fn.(input, cache, name)
+    def call(input, cache: L43Peg::Cache.new) 
+      fn.(input, cache, name)
+    end
 
     private
 

data/lib/l43_peg/parsers/rgx_parser.rb

@@ -9,10 +9,14 @@ module L43Peg
       def initialize(rgx, name: nil, **options)
         name = name || "rgx_parser(#{rgx.inspect})"
         rgx = _mk_rgx(rgx)
+        warn_on_empty = options.fetch(:warn_on_empty, true)
         super(name) do |input, cache, _name|
           case rgx.match(input.input)
           in MatchData => md
             ast = _from_match(md, options) 
+            if ast.empty? && warn_on_empty
+              $stderr.puts("Warning, parser #{name} succeeds with empty match")
+            end
             L43Peg::Success.new(ast:, cache:, rest: input.drop(md[0]), position: input.position)
           else
             L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "input does not match #{rgx.inspect} (in #{name})")

data/lib/l43_peg/parsers/rgx_tokenizer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# module L43Peg
+#   module Parsers
+#     class RgxTokenizer < L43Peg::Parser
+
+#       private
+
+#       def initialize(rgxen, name: nil, **options)
+#         name = name || "rgx_tokenizer(#{rgxen.inspect})"
+#         parsers = rgxen.map(&_mk_rgx_parser)
+#         Combinators.sel(parsers)
+#       end
+
+#       def _mk_rgx_parser
+#         -> rgxspec do
+#           name, rgx, capture = rgxspec
+#           Combinators.map(Parsers.rgx_parser(rgx, capture:)) { |captures| [name, captures] }
+#         end
+#       end
+#     end
+#   end
+# end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/sel_rgx_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# module L43Peg
+#   module Parsers
+#     class SelRgxParser < L43Peg::Parser
+
+#       private
+
+#       def initialize(rgxen, name: nil)
+#         name = name || "sel_rgx_parser(#{rgxen.inspect})"
+#         parsers = rgxen.map(&_mk_rgx_parser)
+#         Combinators.sel(parsers)
+#       end
+
+#       def _mk_rgx_parser
+#         -> rgxspec do
+#           name, rgx, capture, fn = rgxspec
+#           fn ||= (-> (captures) { [name, captures] })
+#           Combinators.map(Parsers.rgx_parser(rgx, capture:), &fn)
+#         end
+#       end
+#     end
+#   end
+# end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers.rb

@@ -7,11 +7,12 @@ module L43Peg
   module Parsers extend self
     def args_parser(args, name: nil, stop: nil, &blk) =
       L43Peg::Combinators.args_parser(args, name:, stop:, &blk)
-    def char_parser(charset = nil)        = L43Peg::Parsers::CharParser.new(charset)
-    def end_parser                        = L43Peg::Parsers::EndParser.instance
-    def failure_parser                    = L43Peg::Parsers::FailureParser.instance
-    def int_parser                        = L43Peg::Parsers::IntParser.instance
-    def rgx_parser(rgx, name: nil, **o)   = L43Peg::Parsers::RgxParser.new(rgx, name:, **o)
+    def char_parser(charset = nil)          = L43Peg::Parsers::CharParser.new(charset)
+    def end_parser                          = L43Peg::Parsers::EndParser.instance
+    def failure_parser                      = L43Peg::Parsers::FailureParser.instance
+    def int_parser                          = L43Peg::Parsers::IntParser.instance
+    def rgx_parser(rgx, name: nil, **o)     = L43Peg::Parsers::RgxParser.new(rgx, name:, **o)
+    # def rgx_tokenizer(rgxn, name: nil, **o) = L43Peg::Parsers::RgxTokenizer.new(rgxn, name:, **o)
     def token_parser(spc, name: nil, **o) = L43Peg::Parsers::TokenParser.new(spc, name:, **o)
     def tokens_parser(map, name: nil, stop: nil, &b) = 
       L43Peg::Parsers::TokensParser.new(map, name:, stop:, &b)

data/lib/l43_peg/success.rb

@@ -8,8 +8,15 @@ module L43Peg
       @position ||= _position
     end
 
+    def debug
+      "Success<" +
+        [
+          "ast:#{ast.inspect}", "cache:#{cache.cache.inspect}", "rest:#{rest.input.inspect}"
+        ].join(" ") + ">"
+    end
     def map(&mapper)
-      self.class.new(ast: mapper.(ast), cache:, position:, rest:)
+      update_attribute(:ast, &mapper)
+      # self.class.new(ast: mapper.(ast), cache:, position:, rest:)
     end
 
     private

data/lib/l43_peg/tokens.rb

@@ -11,9 +11,23 @@ module L43Peg
       return self if empty?
       self.class.new(tokens: input.drop(by), context:, tnb: tnb + by)
     end
+    
+    def debug
+      "Tokens<" +
+      ["tnb:#{tnb}", "tokens:#{tokens.inspect}", "context:#{context.inspect}"].join +
+      ">"
+    end
 
     def empty? = tokens.empty?
     def head = tokens.first
+    def head_hr(n, position: false)
+      if position
+        "Tokens<[#{tokens[0..n].map(&:inspect).join(", ")}]@#{position_hr}>"
+      else
+        "Tokens<[#{tokens[0..n].map(&:inspect).join(", ")}]>"
+      end
+    end
+    
     def input = tokens
 
     def match(str_or_rgx, option)
@@ -28,6 +42,7 @@ module L43Peg
     end
 
     def position = tnb
+    def position_hr = tnb.to_s
 
     private
 

data/lib/l43_peg.rb

@@ -6,7 +6,7 @@ require_relative 'l43/require_helper'
 require_subdir {}
 
 module L43Peg extend self
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 
   def parse_string(parser, input, lnb: 1, col: 1, context: {})
     input = Input.new(input:, col:, lnb:, context:)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: l43_peg
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Robert Dober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-27 00:00:00.000000000 Z
+date: 2024-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: l43_open_object
@@ -40,7 +40,9 @@ files:
 - lib/l43_peg.rb
 - lib/l43_peg/cache.rb
 - lib/l43_peg/combinators.rb
+- lib/l43_peg/combinators/debug_parser.rb
 - lib/l43_peg/combinators/many.rb
+- lib/l43_peg/combinators/sel.rb
 - lib/l43_peg/combinators/seq.rb
 - lib/l43_peg/failure.rb
 - lib/l43_peg/helper.rb
@@ -53,6 +55,8 @@ files:
 - lib/l43_peg/parsers/failure_parser.rb
 - lib/l43_peg/parsers/int_parser.rb
 - lib/l43_peg/parsers/rgx_parser.rb
+- lib/l43_peg/parsers/rgx_tokenizer.rb
+- lib/l43_peg/parsers/sel_rgx_parser.rb
 - lib/l43_peg/parsers/token_parser.rb
 - lib/l43_peg/parsers/tokens_parser.rb
 - lib/l43_peg/parsers/verb_parser.rb