l43_peg 0.1.8 → 0.2.1

data/lib/l43_peg/parsers/rgx_parser.rb

@@ -6,41 +6,56 @@ module L43Peg
 
       private
 
-      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)
+      def initialize(*regexen, name: nil, capture: nil, warn_on_empty: true, grouped: false)
+        name ||= "rgx_parser(#{regexen.inspect})"
+        rgx = _mk_regexen(regexen.flatten, grouped:)
+
+        super(name) do |input|
+          case rgx.match(input.src)
           in MatchData => md
-            ast = _from_match(md, options) 
+            ast = _from_match(md, capture:, grouped:)
             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)
+            L43Peg::Success.new(ast:, parsed: md[0], 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})")
+            L43Peg::Failure.new(parsed_by: self, reason: "input does not match", name:)
           end
         end
       end
 
-      def _from_match(md, options)
-        case options[:capture]
-        in NilClass
-          md[1] || md[0]
-        in Integer => n
-          md[n]
-        in :all
-          md.to_a
+      def _from_match(md, capture:, grouped:)
+        if grouped
+          md.captures
+        else
+          case capture
+          in NilClass
+            md[1] || md[0]
+          in Integer => n
+            md[n]
+          in :all
+            md.to_a
+          end
         end
       end
 
-      def _mk_rgx(rgx)
+      def _maybe_grouped(src, grouped:) = grouped ? "(#{src})" : src
+
+      def _mk_regexen(regexen, grouped:)
+        src = ["\\A", *regexen.map { _mk_rgx(it, grouped:) }].join
+        Regexp.compile(src)
+      end
+
+      def _mk_rgx(rgx, grouped:)
         case rgx
         when String
-          Regexp.compile("\\A#{rgx}")
+          _maybe_grouped rgx, grouped:
+        when Symbol
+          _maybe_grouped "[[:#{rgx}:]]+", grouped:
+        when Regexp
+          _maybe_grouped rgx.source, grouped:
         else
-         rgx
+          raise ArgumentError, "#[rgx.inspect} is not a Regexp, String or Symbol"
         end
       end
     end

data/lib/l43_peg/parsers/string_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module StringParser extend self
+      include Combinators
+      include Parsers
+      def string_parser(name: nil, escape: "\\", double_escape: false, quote: '"')
+        name = name || "string_parser(escape: #{escape}, double_escape: #{double_escape})"
+        choices = [
+          (literal_parser(quote + quote).map { quote } if double_escape),
+          escape_parser(escape),
+          char_parser.satisfy { |ast| ast != quote }
+        ].compact
+
+        parser = sequence(
+          char_parser(quote).ignore,
+          many(
+            choice(choices)
+          ),
+          char_parser(quote).ignore).map(&:join)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/success_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class SuccessParser < L43Peg::Parser
+
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      private
+
+      def initialize
+        super('success_parser') do |input|
+          L43Peg::Success.new(ast: nil, parsed: '', rest: input)
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/symbol_parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module SymbolParser extend self
+      include Combinators
+      include Parsers
+      def symbol_parser(name: nil, symbol_head: ':')
+        name = name || "symbole_parser(symbol_head: #{symbol_head})"
+        sequence(
+          char_parser(symbol_head).ignore,
+          name_parser,
+          name:)
+        .boxed('Sym', &:first)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/ws_parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module WsParser extend self
+      def ws_parser(name:, min:, skip_lines: false, ignore: true)
+        name = name || "ws_parser(min: #{min})"
+        charset = " \t"
+        charset << "\n" if skip_lines
+        parser = Combinators.many(Parsers.char_parser(charset), min:, name:)
+        if ignore
+          parser.ignore
+        else
+          parser
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers.rb

@@ -1,22 +1,59 @@
 # frozen_string_literal: true
 
-require_relative 'combinators'
-require_subdir {}
+require 'l43_peg/parsers/char_parser'
+require 'l43_peg/parsers/eol_parser'
+require 'l43_peg/parsers/end_parser'
+require 'l43_peg/parsers/escape_parser'
+require 'l43_peg/parsers/failure_parser'
+require 'l43_peg/parsers/int_parser'
+require 'l43_peg/parsers/list_parser'
+require 'l43_peg/parsers/literal_parser'
+require 'l43_peg/parsers/name_parser'
+require 'l43_peg/parsers/rgx_parser'
+require 'l43_peg/parsers/string_parser'
+require 'l43_peg/parsers/success_parser'
+require 'l43_peg/parsers/symbol_parser'
+require 'l43_peg/parsers/ws_parser'
 
 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 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)
-    def verb_parser(verb, name: nil)      = L43Peg::Parsers::VerbParser.new(verb, name:)
+
+      def char_parser (charset=nil, name: nil, allow_eol: false) =
+        CharParser.new(charset, name:, allow_eol:)
+
+      def eol_parser(succeed_at_end: false) =
+        EolParser.eol_parser(succeed_at_end:)
+
+      def end_parser = EndParser.instance
+
+      def escape_parser(escape_char_set, escapees=nil, name: nil, with_box: nil) =
+        EscapeParser.escape_parser(escape_char_set, escapees, name:, with_box:)
+
+      def failure_parser = FailureParser.instance
+
+      def int_parser = IntParser.instance
+
+      def list_parser(**options) = ListParser.list_parser(**options)
+
+      def literal_parser(verb, name: nil) = LiteralParser.new(verb, name:)
+
+      def name_parser(name: nil, begin_rgx: :alpha, inner_rgx: /[_[:alnum:]]*/, with_box: nil) =
+        NameParser.name_parser(name:, begin_rgx:, inner_rgx:, with_box:)
+
+      def rgx_parser(*regexen, name: nil, capture: nil, warn_on_empty: true, grouped: false) =
+        RgxParser.new(*regexen, name:, capture:, warn_on_empty:, grouped:)
+
+      def string_parser(escape: "\\", double_escape: false, name: nil, quote: '"') =
+        StringParser.string_parser(escape:, double_escape:, name:, quote:)
+
+      def success_parser = SuccessParser.instance
+
+      def symbol_parser(name: nil, symbol_head: ':') =
+        SymbolParser.symbol_parser(name:, symbol_head:)
+
+      def ws_parser(name: nil, min: 0, skip_lines: false) =
+        WsParser.ws_parser(name:, min:, skip_lines:)
+
   end
 end
 # SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/stop.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-module L43Peg
-  class Stop
-    extend L43::OpenObject
-    attributes
-    # A placeholder to halt many
-  end
-end
+# module L43Peg
+#   class Stop
+#     extend L43::OpenObject
+#     attributes
+#     # A placeholder to halt many
+#   end
+# end
 # SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/success.rb

@@ -4,31 +4,29 @@ module L43Peg
   class Success
     extend L43::OpenObject
 
-    attributes ast: nil, cache: nil, position: nil, rest: nil do
+    attributes ast: nil, parsed: '', position: nil, rest: nil, ok: true do
       @position ||= _position
     end
 
     def debug
       "Success<" +
         [
-          "ast:#{ast.inspect}", "cache:#{cache.cache.inspect}", "rest:#{rest.input.inspect}"
+          "ast:#{ast.inspect}", "parsed:#{parsed.inspect}", "rest:#{rest.src.inspect}"
         ].join(" ") + ">"
     end
-    def map(&mapper)
+
+    def map(box: nil, &mapper)
       update_attribute(:ast, &mapper)
-      # self.class.new(ast: mapper.(ast), cache:, position:, rest:)
+        .update_attribute_if(:ast, box) do |ast|
+          Box.make(box).new(ast)
+        end
     end
 
+    def deconstruct(*) = [:ok, ast, rest]
+
     private
 
-    def _position
-      case @rest
-      when Tokens
-        1
-      else
-        [1, 1]
-      end
-    end
+    def _position = [1, 1]
   end
 end
 # SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module L43Peg
+  VERSION = '0.2.1'
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg.rb

@@ -2,31 +2,23 @@
 
 require 'l43/open_object'
 
-require_relative 'l43/require_helper'
-require_subdir {}
+require 'l43_peg/errors'
+require 'l43_peg/failure'
+require 'l43_peg/input'
+require 'l43_peg/mappers'
+require 'l43_peg/parser'
+require 'l43_peg/success'
 
-module L43Peg extend self
-  VERSION = "0.1.8"
-
-  def parse_string(parser, input, lnb: 1, col: 1, context: {})
-    input = Input.new(input:, col:, lnb:, context:)
-    _parse(parser, input)
-  end
+require 'l43_peg/combinators'
+require 'l43_peg/parsers'
 
-  def parse_tokens(parser, tokens, tnb: 1, context: {})
-    tokens = Tokens.new(tokens:, tnb:, context:)
-    _parse(parser, tokens)
-  end
-
-  private
+module L43Peg extend self
+  include Combinators, Parsers
 
-  def _parse(parser, input)
-    case parser.(input)
-    in Success => success
-      [:ok, success.ast]
-    in Failure => failure
-      [:error, failure.reason]
-    end
+  def parse(input, with: parser, col: 1, lnb: 1)
+    input = Input.new(src: input, col:, lnb:) unless Input === input
+    with = Parsers.send with if Symbol === with
+    with.(input)
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: l43_peg
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Robert Dober
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-15 00:00:00.000000000 Z
+date: 2026-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: l43_open_object
@@ -16,14 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: l43_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 description: |
   A (still incomplete) PEG Library
 
@@ -36,38 +49,47 @@ files:
 - LICENSE
 - README.md
 - lib/l43/match_data_extenstion.rb
-- lib/l43/require_helper.rb
 - lib/l43_peg.rb
-- lib/l43_peg/cache.rb
+- lib/l43_peg/box.rb
 - lib/l43_peg/combinators.rb
+- lib/l43_peg/combinators/boxed.rb
+- lib/l43_peg/combinators/choice.rb
 - lib/l43_peg/combinators/debug_parser.rb
+- lib/l43_peg/combinators/ignore.rb
+- lib/l43_peg/combinators/lazy.rb
 - lib/l43_peg/combinators/many.rb
-- lib/l43_peg/combinators/sel.rb
-- lib/l43_peg/combinators/seq.rb
+- lib/l43_peg/combinators/map.rb
+- lib/l43_peg/combinators/map_error.rb
+- lib/l43_peg/combinators/satisfy.rb
+- lib/l43_peg/combinators/sequence.rb
+- lib/l43_peg/errors.rb
 - lib/l43_peg/failure.rb
-- lib/l43_peg/helper.rb
 - lib/l43_peg/input.rb
 - lib/l43_peg/mappers.rb
 - lib/l43_peg/parser.rb
 - lib/l43_peg/parsers.rb
 - lib/l43_peg/parsers/char_parser.rb
 - lib/l43_peg/parsers/end_parser.rb
+- lib/l43_peg/parsers/eol_parser.rb
+- lib/l43_peg/parsers/escape_parser.rb
 - lib/l43_peg/parsers/failure_parser.rb
 - lib/l43_peg/parsers/int_parser.rb
+- lib/l43_peg/parsers/list_parser.rb
+- lib/l43_peg/parsers/literal_parser.rb
+- lib/l43_peg/parsers/name_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
+- lib/l43_peg/parsers/string_parser.rb
+- lib/l43_peg/parsers/success_parser.rb
+- lib/l43_peg/parsers/symbol_parser.rb
+- lib/l43_peg/parsers/ws_parser.rb
 - lib/l43_peg/stop.rb
 - lib/l43_peg/success.rb
 - lib/l43_peg/tokens.rb
+- lib/l43_peg/version.rb
 homepage: https://codeberg.org/lab419/l43_peg
 licenses:
 - AGPL-3.0-or-later
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -75,15 +97,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 4.0.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.8
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A (still incomplete) PEG Library
 test_files: []

data/lib/l43/require_helper.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def require_subdir(path=nil, &blk)
-    Dir.glob(File.join([File.dirname(blk.source_location.first), path, '/**/*.rb'].compact)).each { require _1}
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/cache.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module L43Peg
-  class Cache
-    extend L43::OpenObject
-    attributes cache: {}
-  end
-end
-# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/combinators/sel.rb

@@ -1,24 +0,0 @@
-# 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/seq.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../helper"
-module L43Peg
-  module Combinators
-    module Seq extend self
-
-      include L43Peg::Helper
-      def seq(input:, cache:, name:, parsers:)
-        curr_input = input
-        curr_cache = cache
-        ast = []
-        parsers.each do |parser|
-          case parser.(curr_input, cache: curr_cache)
-          in L43Peg::Failure => failure
-            return L43Peg::Failure.new(reason: "#{failure.reason} in (#{name})", position: failure.position, input:)
-          in L43Peg::Success => success
-            ast.push(success.ast)
-            curr_input = success.rest
-            curr_cache = success.cache
-          end
-        end
-        succeed_parser(ast, curr_input, cache: curr_cache) 
-      end
-
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module L43Peg
-  module Helper
-    def fail_parser(reason, input: nil)
-      L43Peg::Failure.new(reason:, input:)
-    end
-    def succeed_parser(ast, input, cache: nil)
-      L43Peg::Success.new(ast:, rest: input, cache: cache || input.cache)
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/rgx_tokenizer.rb

@@ -1,24 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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/token_parser.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module L43Peg
-  module Parsers
-    class TokenParser < L43Peg::Parser
-
-      private
-
-      def initialize(token_spec, name: nil, **options)
-        _check_arg!(token_spec)
-        name = name || "token_parser(#{token_spec.inspect})"
-        super(name) do |tokens, cache, _name|
-          if result = tokens.match(token_spec, options[:capture])
-            L43Peg::Success.new(ast: result, cache:, rest: tokens.drop(1), position: tokens.position)
-          else
-            reason = "token #{tokens.head.inspect} does not match #{token_spec.inspect} (in #{name})"
-            L43Peg::Failure.new(cache:, input: tokens, parsed_by: self, reason:)
-          end
-        end
-      end
-
-      def _check_arg!(token_spec)
-        case token_spec
-        when Regexp, String
-        else
-          raise ArgumentError, "#{token_spec.inspect} must be a regular expression or a string"
-        end
-      end
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later