l43_rgx 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16234666a82b0ee1a42c90674890ec10a4ae5e64ae38c067520e51c4bec64796
+  data.tar.gz: 2472f2c910a99c485b67c31c43012be28c6516b428c3d3a7dd87ec8754935586
+SHA512:
+  metadata.gz: 3d4d321341fa59397399d892a8e224999932534739b91aaa26925e0ee2d3e43aab8734fcb986fa4ceda8ba892d968b70fe80436532424787bb6bd911077b09b8
+  data.tar.gz: 916dc34de7fc7589c809ad916eed701798de220efbaf6478993bba32f78a11bcb941f13fefa75c23ef8ef0c17170b7454c17b2126b66a4e59ee5baeec43d5e5f

data/lib/l43/rgx/all.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../rgx'
+def Rgx(*parts, **options, &callback) = L43::Rgx.new(*parts, **options, &callback)
+Rgx = L43::Rgx
+Result = Rgx::Result
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/compile.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    module Compile
+
+      private
+      def _a_anchor
+        "\\A" if [:begin, :both].member?(anchored)
+      end
+
+      def _capture_rest 
+        @___capture_rest__ ||= "(.*)\\z" if capture_rest
+      end
+
+      def _compile
+        @source = [a_anchor, look_behind, compiled_parts, look_ahead, _capture_rest, z_anchor].join.freeze
+        @regexp = Regexp.compile(source).freeze
+      end
+
+      def _compile_part(part, level: 0)
+        case part
+        in String
+          part
+        in Symbol
+          repr = part.to_s
+          if repr.end_with?("s")
+            "[[:#{repr[0...-1]}:]]+"
+          else
+            "[[:#{repr}:]]"
+          end
+        in Integer
+          "{#{part}}"
+        in Range
+          "{#{part.first},#{part.last}}"
+        in Array
+          raise CompilationError, "nested groups are not allowed" if level.positive?
+          "(#{part.map { _compile_part(it, level: level.succ) }.join})"
+        else
+          if self.class === part
+            raise CompilationError, "part is anchored, only use unanchored instances of #{self.class}" if part.anchored?
+            part.source
+          else
+            raise CompilationError, "part: #{part.inspect} needs to be a string, symbol, integer or range"
+          end
+        end
+      end
+
+      def _compiled_parts
+        parts.map { _compile_part it }.join
+      end
+
+      def _look_ahead
+        if followed_by
+          followed = self.class.new(*Array(followed_by)).source
+          "(?=#{followed})"
+        elsif not_followed_by
+          followed = self.class.new(*Array(not_followed_by)).source
+          "(?!#{followed})"
+        end
+      end
+
+      def _look_behind
+        if preceded_by
+          preceded = self.class.new(*Array(preceded_by)).source
+          "(?<=#{preceded})"
+        elsif not_preceded_by
+          preceded = self.class.new(*Array(not_preceded_by)).source
+          "(?<!#{preceded})"
+        end
+      end
+
+      def _z_anchor
+        "\\z" if [:end, :both].member?(anchored)
+      end
+
+      def a_anchor =  @__a_anchor__ ||= _a_anchor
+      def compiled_parts =  @__compiled_parts__ ||= _compiled_parts
+      def look_ahead =  @___look_ahead__ ||= _look_ahead 
+      def look_behind =  @___look_behind__ ||= _look_behind 
+      def z_anchor =  @__z_anchor__ ||= _z_anchor
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    CompilationError = Class.new(RuntimeError)
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/methods.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    module Methods
+
+      def or(*parts, **options)
+        self.class.new(wrap, "|", self.class.new(*parts, **options).wrap)
+      end
+
+      def many(min: 0)
+        inner_part = wrap 
+        new_source =
+          case min
+          in 0
+            "#{inner_part}*"
+          in 1
+            "#{inner_part}+"
+          else
+            "#{inner_part}{#{min},}"
+          end
+        self.class.new(new_source)
+      end
+        
+      def wrap = _wrap(self)
+
+      private
+      def _wrap(part)
+        case part
+        when String
+          "(?:#{part})"
+        when Rgx
+          "(?:#{part.source})"
+        else
+          raise ArgumentError, "_wrap needs string or rgx, not #{part.inspect}"
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/result.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    class Result
+
+      attr_reader :captures
+
+      def deconstruct(*) = captures
+
+      def ==(other) 
+        self.class === other && captures == other.captures
+      end
+
+      private
+      def initialize(captures)
+        @captures = captures.freeze
+      end
+        
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module L43
+  class Rgx
+    VERSION = "0.1.0"
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/rgx.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'rgx/errors'
+require_relative 'rgx/compile'
+require_relative 'rgx/methods'
+require_relative 'rgx/result'
+require 'l43/core/forwarder'
+
+module L43
+  class Rgx
+    extend L43::Core::Forwarder
+    include Compile
+    include Methods
+
+    LegalAnchors = [nil, :begin, :both, :end].freeze
+
+    attr_reader :regexp, :source
+    forward :match, to: :regexp
+
+    def anchored? = anchored || capture_rest
+    def anchored_at_begin? = [:begin, :both].member?(anchored)
+    def anchored_at_end? = [:end, :both].member?(anchored)
+
+    def run(subject, include_match: false)
+      case regexp.match(subject)
+      in nil
+        nil
+      in md
+        if callback
+          Result.new(Array(callback.(*md.to_a)))
+        else
+          include_match ? Result.new(md.to_a) : Result.new(md.captures)
+        end
+      end
+    end
+
+    private
+    attr_reader \
+      :anchored,
+      :callback, :capture_rest,
+      :followed_by,
+      :not_followed_by, :not_preceded_by,
+      :parts, :preceded_by
+
+    def initialize(*parts,
+                   anchored: nil,
+                   capture_rest: false,
+                   followed_by: nil,
+                   not_followed_by: nil,
+                   not_preceded_by: nil,
+                   preceded_by: nil,
+                   &callback)
+
+      raise ArgumentError, "must not provide followed_by and not_followed_by at the same time" if followed_by && not_followed_by
+      raise ArgumentError, "must not provide preceded_by and not_preceded_by at the same time" if preceded_by && not_preceded_by
+      raise ArgumentError, "illegal value for keyword argument capture_rest, must be a boolean, but was #{capture_rest.inspect}" unless
+      [false, true].member?(capture_rest)
+      raise ArgumentError, "illegal value for keyword argument anchored, must be in #{LegalAnchors.inspect}, but was: #{anchored.inspect}" unless
+      LegalAnchors.member?(anchored)
+
+      @anchored = anchored
+      raise ArgumentError, "must not use capture_rest with anchored :end or :both" if anchored_at_end? && capture_rest
+      raise ArgumentError, "must not use lookahead assertion (followed_by) with anchored :end or :both" if anchored_at_end? && followed_by
+      raise ArgumentError, "must not use negative lookahead assertion (not_followed_by) with anchored :end or :both" if anchored_at_end? && not_followed_by
+      raise ArgumentError, "must not use negative lookahead assertion (not_followed_by) with capture_rest" if anchored_at_end? && capture_rest
+
+      raise ArgumentError, "must not use lookbehind assertion (preceded_by) with anchored :begin or :both" if anchored_at_begin? && preceded_by
+      raise ArgumentError, "must not use negative lookbehind assertion (not_preceded_by) with anchored :begin or :both" if anchored_at_begin? && not_preceded_by
+
+      @anchored = anchored
+      @callback = callback
+      @capture_rest = capture_rest
+      @followed_by = followed_by
+      @not_followed_by = not_followed_by
+      @not_preceded_by = not_preceded_by
+      @parts = parts.freeze
+      @preceded_by = preceded_by
+
+      _compile
+    end
+
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: l43_rgx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Dober
+bindir: bin
+cert_chain: []
+date: 2026-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: l43_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+description: 'Human Readable Regexp Wrapper and Tools
+
+  '
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/l43/rgx.rb
+- lib/l43/rgx/all.rb
+- lib/l43/rgx/compile.rb
+- lib/l43/rgx/errors.rb
+- lib/l43/rgx/methods.rb
+- lib/l43/rgx/result.rb
+- lib/l43/rgx/version.rb
+homepage: https://codeberg.org/lab419/l43_rgx
+licenses:
+- AGPL-3.0-or-later
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Human Readable Regexp Wrapper and Tools
+test_files: []