l43_rgx 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01a532b87cd5cfd3a0f06d773bbd556168b9548bd081b7ae22df35f6f2adcdba
-  data.tar.gz: a7784b4825e708af44f2703d643b0f08bd46d84f6b78d452e02ceacd8668bbd6
+  metadata.gz: e701126bd544a239a2fdb2c5afa73a405b6cffa998fb1fffae151b6d0d6c93fc
+  data.tar.gz: f2c7b9e91c0c21af9dbb2b541b096a7cf46bb516635e93451412ad5a420cb7db
 SHA512:
-  metadata.gz: 7d1f476ba49438a5db986e2cc607308aaa85857e31f779ea136395edd4b65800ae67d36885dac3e5e7e1e24d16f510a7e9c5252940c6b9f90d32c2f9129074b2
-  data.tar.gz: 0e7c86b2ca3c2da91acc7b97c2e0315897c146888532280709cfbdf8cd76f911325ed0f0deaf044588fff2c4cb0a5d31c7c4956dc0370bf3680143da9bac6d85
+  metadata.gz: 1c9c95914e349bf0caa5bee8c36def1d3c38dd31a18a2d6fb8d2be694decaa4735deadd2e346e7fa7b0207ed7e8def8c1522f7801f97819f03342a3c0a718d55
+  data.tar.gz: d777ce962ad1a77a3277f92b3176a20b1baa70e3086138d6a41eda8cc4fddf5869f4a634351d07e0d39674e6a8c7274c712cd7cbf6ec03ebeff102b1a939ee0e

data/lib/l43/rgx/all.rb

@@ -3,5 +3,6 @@
 require_relative '../rgx'
 def Rgx(*parts, **options, &callback) = L43::Rgx.new(*parts, **options, &callback)
 Rgx = L43::Rgx
+R = Rgx::R
 Result = Rgx::Result
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/compile.rb

@@ -4,6 +4,15 @@ module L43
   class Rgx
     module Compile
 
+      PredefinedSymbols = {
+        any: ".",
+        end: "\\z",
+        star: "*",
+        plus: "+",
+        option: "?",
+        ws: "[[:blank:]]*",
+      }.freeze
+
       private
       def _a_anchor
         "\\A" if [:begin, :both].member?(anchored)
@@ -26,20 +35,17 @@ module L43
       def _compile_part(part)
         case part
         in String
-          part
+          escape_strings ? Regexp.escape(part) : part
         in Symbol
-          repr = part.to_s
-          if repr.end_with?("s")
-            "[[:#{repr[0...-1]}:]]+"
-          else
-            "[[:#{repr}:]]"
-          end
+          _compile_symbol(part)
         in Integer
           "{#{part}}"
         in Range
           "{#{part.first},#{part.last}}"
         in Array
           "(#{part.map { _compile_part(it) }.join})"
+        in Regexp
+          part
         else
           if self.class === part
             raise CompilationError, "part is anchored, only use unanchored instances of #{self.class}" if part.anchored?
@@ -54,6 +60,17 @@ module L43
         parts.map { _compile_part it }.join
       end
 
+      def _compile_symbol(part)
+        PredefinedSymbols.fetch(part) do
+          repr = part.to_s
+          if repr.end_with?("s")
+            "[[:#{repr[0...-1]}:]]+"
+          else
+            "[[:#{repr}:]]"
+          end
+        end
+      end
+
       def _look_ahead
         if followed_by
           followed = self.class.new(*Array(followed_by)).source

data/lib/l43/rgx/errors.rb

@@ -3,6 +3,7 @@
 module L43
   class Rgx
     CompilationError = Class.new(RuntimeError)
+    InternalError = Class.new(RuntimeError)
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/and.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      class And < R
+        attr_reader :parsers
+
+        def name
+          @name || ["(", parsers.map(&:name).join(" && "), ")"].join(" ")
+        end
+
+        def _parse(input)
+          mapped_ast = @parsers.map do |parser|
+            result = parser.parse(input)
+            case result
+            in ast, input
+              parser.ignore ? nil : ast
+            else
+              return nil
+            end
+          rescue NoMethodError => nme
+          # require "debug"; binding.break
+            raise
+          end
+          [_apply_callbacks(mapped_ast.compact), input]
+        end
+
+        private
+        def initialize(*parsers, name: nil, &blk)
+          @parsers = parsers
+          callbacks << [blk, :all] if blk
+          @name = name
+        end
+          
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/ast.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+module L43
+  class Rgx
+    class R
+      Ast = OpenObject.def_class :value do
+        def deconstruct(*) = Array(value)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/class_methods.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'l43/core/enum/hash'
+module L43
+  class Rgx
+    class R
+      module ClassMethods
+        define_method :end do |&blk|
+          R.new(:end, capture_rest: false, &blk)
+        end
+
+        def fail
+          R::Fail.new
+        end
+
+        def from_regexp(part, name: nil, &blk)
+          name ||= part.inspect
+          R.new(part, name:, escape_strings: false, &blk)
+        end
+
+        def literals(*literals, name: nil, &blk)
+          name ||= "or(#{literals.join(", ")})"
+          self.or(*literals.map { R.new(it) }, name:, &blk)
+        end
+
+        def make(*parts, **options, &blk)
+          case parts
+          in [R => r]
+            raise ArgumentError, "must not provide a blk with an R instance" if blk
+            r
+          in [R => _, _, *]
+            raise ArgumentError, "must only use one instance of R as or argument"
+          in []
+            raise ArgumentError, "need at least one argument"
+          else
+            _make_from_parts(parts, options, blk)
+          end
+        end
+
+        def many(*parts, min: 1, name: nil, **options, &blk) =
+          R::Many.new(*parts, min: 1, name: nil, **options, &blk)
+
+        def reduce(*parts, value:, min: 1, name: nil, **options, &blk) =
+          R::Reduce.new(*parts, min: 1, name: nil, **options, &blk)
+
+        def and(*rs, name: nil, &blk) = R::And.new(*rs, name:, &blk)
+        def or(*rs, name: nil, &blk) = R::Or.new(*rs, name:, &blk)
+
+        private
+        def _make_from_parts(parts, options, blk)
+          if options[:capture_all]
+            R.new(*parts.flatten.map { [it] }, **options.without(:capture_all), &blk)
+          else
+            R.new(*parts, **options.without(:capture_all), &blk)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/fail.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      class Fail < R
+
+        def and(*parts, name: nil, ignore: false, &blk)
+          self
+        end
+
+        def or(*parts, name: nil, &blk)
+          case parts
+          in [R => r]
+            r
+          in [R => _, _, *]
+            raise ArgumentError, "must only use one instance of R as or argument"
+          in []
+            raise ArgumentError, "need at least one argument"
+          else
+            R.new(*parts, name:, ignore:, &blk)
+          end
+        end
+
+        def name = "Fail"
+
+        def parse(_input) = nil
+
+        private
+        def initialize(*, **) = nil
+          
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/many.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      class Many < R
+        attr_reader :min, :name, :parser, :rgx
+
+        private
+        def initialize(*parts, min: 1, name: nil, **options, &callback)
+          @min = min
+          @name = name || "many(#{parts.inspect}, min: #{min})"
+          case parts.first
+          when R
+            @parser = parts.first
+          else
+            @parser = R.new(*parts, name:, **options)
+          end
+          _map_by_arity(callback) if callback
+        end
+
+        def _parse(input)
+          needed = min
+          ast = []
+          loop do
+            case parser.parse(input)
+            in nil
+              if needed.positive?
+                return nil
+              else
+                return [_apply_callbacks(ast), input]
+              end
+            in captured, input
+              needed -= 1
+              ast = ast << captured
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/methods.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      module InstanceMethods
+        def and(*parts, name: nil, **options, &blk)
+          R.and(self, R.make(*parts, **options, &blk), name:)
+        end
+
+        def flattened(&callback)
+          callbacks << [-> { it.flatten }, :all]
+          _map_by_arity(callback) if callback
+          self
+        end
+
+        def joined(by='', name: nil, &blk)
+          @name ||= "joined(#{@name}"
+          callbacks << [->{ it.join(by) }, :all]
+          callbacks << [blk, :all] if blk
+          self
+        end
+
+        def many(name: nil, min: 1, **options, &blk)
+          R.many(self, name:, min:, **options, &blk)
+        end
+
+        def reduce(value, name: nil, min: 1, **options, &blk)
+          Reducer.new(self, value:, name:, min:, **options, &blk)
+        end
+
+        def map(*args, name: nil, &blk)
+          raise ArgumentError, "must not provide arguments and a blk" if blk && !args.empty? 
+
+          @name = name || "map(#{@name})"
+          args = [:itself] if args.empty? && blk.nil?
+
+          return _map_by_arity(blk) if args.empty?
+
+          callback = -> result do
+            result.send(*args)
+          end
+          callbacks << [callback, :all]
+          self
+        end
+
+        def map_capture(n, *args, name: nil, &blk)
+          raise ArgumentError, "#{n} is not an Integer" unless Integer === n
+          raise ArgumentError, "must not provide arguments and a blk" if blk && !args.empty? 
+
+          @name = name || "map_capture(#{n})(#{@name})"
+          args = [:itself] if args.empty? && blk.nil?
+
+          if args.empty?
+            callbacks << [blk, n]
+          else
+            callback = -> result do
+              result.send(*args)
+            end
+            callbacks << [callback, n]
+          end
+          self
+        end
+
+        def map_first(*args, name: nil, &blk)
+          name ||= "map_first(#{name})"
+          map_capture(0, *args, name:, &blk)
+        end
+
+        def or(*parts, name: nil, **options, &blk)
+          R.or(self, R.make(*parts, **options, &blk), name:)
+        end
+
+        private
+        def _apply_callbacks(matches)
+          # p(matches:) if $debug_r
+          callbacks.inject(matches) do |result, callback|
+            # p(result:) if $debug_r
+            case callback
+            in blk, :all
+              blk.(result)
+            in blk, :splat
+              blk.(*result)
+            in blk, :first
+              blk.(result.first)
+            in blk, Integer => n
+              blk.(result[n])
+            else
+              raise InternalError, "undefined action type #{callback}"
+            end
+          end
+        end
+
+        def _map_by_arity(blk)
+          calling_type = blk.arity < 0 ? :splat : :all
+          callbacks << [blk, calling_type]
+          self
+        end
+
+        def mkrgx(*parts, **options)
+          case parts
+          in [Rgx => rgx, *]
+            rgx
+          in [Regexp => regexp, *]
+            rgx
+          in [Array, *]
+            Rgx(*parts, **{anchored: :begin, capture_rest: true, escape_strings: true}.merge(options))
+          in [head, *rest]
+            Rgx([head], *rest, **{anchored: :begin, capture_rest: true, escape_strings: true}.merge(options))
+          end
+        end
+      end
+
+      # module UniversalMethods
+      # end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/or.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      class Or < R
+        attr_reader :alternatives
+
+        def name
+          @name || ["(", alternatives.map(&:name).join(" || "), ")"].join(" ")
+        end
+
+        private
+        def initialize(*alternatives, name: nil, &blk)
+          @alternatives = alternatives
+          @name = name
+          _map_by_arity(blk) if blk
+        end
+
+        def _parse(input)
+          alternatives.find_value do |alternative|
+            case alternative.parse(input)
+            in nil
+              nil
+            in ast, rest
+              [_apply_callbacks(ast), rest]
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r/reducer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class R
+      class Reducer < R
+
+        attr_reader :name
+
+        private
+        attr_reader :min, :parser, :reducer
+
+        def initialize(*parts, value:, min: 1, name: nil, **options, &reducer)
+          @min = min
+          @name = name || "reducer(#{parts.inspect}, min: #{min})"
+          case parts.first
+          when R
+            @parser = parts.first
+          else
+            @parser = R.new(*parts, name:, **options)
+          end
+          @reducer = reducer
+          @value = value
+        end
+
+        def _parse(input)
+          needed = min
+          value = @value
+          loop do
+            case parser.parse(input)
+            in nil
+              if needed.positive?
+                return nil
+              else
+                return [_apply_callbacks(value), input]
+              end
+            in captured, input
+              needed -= 1
+              value = reducer.(value, *captured)
+            end
+          end
+        end
+          
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/r.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'l43/core/enum/enumerable'
+
+require_relative 'r/ast'
+require_relative 'r/and'
+require_relative 'r/fail'
+require_relative 'r/many'
+require_relative 'r/or'
+require_relative 'r/reducer'
+require_relative 'r/class_methods'
+require_relative 'r/methods'
+module L43
+  class Rgx
+    class R
+      include InstanceMethods
+      # include UniversalMethods
+      extend ClassMethods
+      # extend UniversalMethods
+
+      attr_reader :ignore, :name, :parts, :rgx
+
+      def ignore!
+        @ignore = true
+        self
+      end
+
+      def parse(input)
+        # p(enter: name) if $debug_r
+        result = _parse(input)
+        # p(name:) if $debug_r
+        # p(result: result) if $debug_r
+        result
+      end
+
+      def _parse(input)
+        case rgx.regexp.match(input)
+        in nil
+          nil
+        in mdata
+          result = [_apply_callbacks(mdata.captures[0...-1]), mdata.captures.last]
+          # p(result_after_apply_cb: result)
+          result
+        end
+      end
+
+      private
+      def initialize(*parts, name: nil, ignore: false, **options, &callback)
+        @options = options
+        @ignore = ignore
+        @name = name || parts.inspect
+        @parts = parts
+        @rgx = mkrgx(*parts, **options)
+        _map_by_arity(callback) if callback
+      end
+
+      def callbacks =  @__callbacks__ ||= []
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/version.rb

@@ -2,7 +2,7 @@
 
 module L43
   class Rgx
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx.rb

@@ -4,6 +4,7 @@ require_relative 'rgx/errors'
 require_relative 'rgx/compile'
 require_relative 'rgx/methods'
 require_relative 'rgx/result'
+require_relative 'rgx/r'
 require 'l43/core/forwarder'
 
 module L43
@@ -15,7 +16,7 @@ module L43
 
     LegalAnchors = [nil, :begin, :both, :end].freeze
 
-    attr_reader :regexp, :source
+    attr_reader :escape_strings, :regexp, :source
     forward :match, to: :regexp
 
     def anchored? = anchored || capture_rest
@@ -48,6 +49,7 @@ module L43
                    anchored: nil,
                    capture: false,
                    capture_rest: false,
+                   escape_strings: false,
                    followed_by: nil,
                    not_followed_by: nil,
                    not_preceded_by: nil,
@@ -74,6 +76,7 @@ module L43
       @callback = callback
       @capture = capture
       @capture_rest = capture_rest
+      @escape_strings = escape_strings
       @followed_by = followed_by
       @not_followed_by = not_followed_by
       @not_preceded_by = not_preceded_by

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: l43_rgx
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
-date: 2026-09-10 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -29,14 +29,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.11
+- !ruby/object:Gem::Dependency
+  name: l43_open_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: 'Human Readable Regexp Wrapper and Tools
 
   '
@@ -50,6 +64,15 @@ files:
 - lib/l43/rgx/compile.rb
 - lib/l43/rgx/errors.rb
 - lib/l43/rgx/methods.rb
+- lib/l43/rgx/r.rb
+- lib/l43/rgx/r/and.rb
+- lib/l43/rgx/r/ast.rb
+- lib/l43/rgx/r/class_methods.rb
+- lib/l43/rgx/r/fail.rb
+- lib/l43/rgx/r/many.rb
+- lib/l43/rgx/r/methods.rb
+- lib/l43/rgx/r/or.rb
+- lib/l43/rgx/r/reducer.rb
 - lib/l43/rgx/result.rb
 - lib/l43/rgx/version.rb
 homepage: https://codeberg.org/lab419/l43_rgx