regexp_parser 2.9.3 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e429c2cc03b2c9c31e3bf5c3dc71ffc15c5032a35f52c3abae9134d02c45496f
-  data.tar.gz: 6a89f8618748c8ab479c4d81ff44c9fabfb461337993fcc641da23d6c349a1ec
+  metadata.gz: f6ed5457d89738fa1076cf3875cd2d009973f02857ea68e055ef3ef74a78dc91
+  data.tar.gz: d67eb5f0cb37ad106574b2ae327eefcfc13c9d585cddec6661898f4d8166ebcc
 SHA512:
-  metadata.gz: 8f9cb8133b24db6f8bb2199356101c234960839ae1251a77da6fe4faeaafc2ab1d6f679f5a6e081860d4a9137a91aeb7793dbc617f04c9747b9110d64134d45f
-  data.tar.gz: bdfe1c9a13fef4f891c28787588c92be37c1c8a61e0d473d05482a67207675be090ec5a74d12b46cf93c8d2565388c6680acd89ad65bc63454514ee720181c82
+  metadata.gz: 6b8adbc3c4707fc4c823456ae1d7547f17568802de03008a17fef18a5f95af08b0e42d48ccdfab25a740603a58ab89c036d70cec94405701201e5a5af51ce392
+  data.tar.gz: 9bea98a42ab64a9b45ddc5564cd077d7eb6d2ddc293844759bb8001aa9fefd8aa26b0e03fff7a286ccde9f7aeacacda9fbb187fe04082749d3c2605e0cece7b9

data/lib/regexp_parser/expression/classes/backreference.rb

@@ -1,25 +1,6 @@
 module Regexp::Expression
   module Backreference
-    class Base < Regexp::Expression::Base
-      attr_accessor :referenced_expression
-
-      def initialize_copy(orig)
-        exp_id = [self.class, self.starts_at]
-
-        # prevent infinite recursion for recursive subexp calls
-        copied = @@copied ||= {}
-        self.referenced_expression =
-          if copied[exp_id]
-            orig.referenced_expression
-          else
-            copied[exp_id] = true
-            orig.referenced_expression.dup
-          end
-        copied.clear
-
-        super
-      end
-    end
+    class Base < Regexp::Expression::Base; end
 
     class Number < Backreference::Base
       attr_reader :number

data/lib/regexp_parser/expression/classes/conditional.rb

@@ -7,26 +7,17 @@ module Regexp::Expression
     end
 
     class Condition < Regexp::Expression::Base
-      attr_accessor :referenced_expression
-
       # Name or number of the referenced capturing group that determines state.
       # Returns a String if reference is by name, Integer if by number.
       def reference
         ref = text.tr("'<>()", "")
         ref =~ /\D/ ? ref : Integer(ref)
       end
-
-      def initialize_copy(orig)
-        self.referenced_expression = orig.referenced_expression.dup
-        super
-      end
     end
 
     class Branch < Regexp::Expression::Sequence; end
 
     class Expression < Regexp::Expression::Subexpression
-      attr_accessor :referenced_expression
-
       def <<(exp)
         expressions.last << exp
       end
@@ -54,11 +45,6 @@ module Regexp::Expression
       def reference
         condition.reference
       end
-
-      def initialize_copy(orig)
-        self.referenced_expression = orig.referenced_expression.dup
-        super
-      end
     end
   end
 end

data/lib/regexp_parser/expression/classes/escape_sequence.rb

@@ -1,100 +1,28 @@
 module Regexp::Expression
   module EscapeSequence
-    class Base < Regexp::Expression::Base
-      def codepoint
-        char.ord
-      end
+    Base        = Class.new(Regexp::Expression::Base)
 
-      if ''.respond_to?(:undump)
-        def char
-          %("#{text}").undump
-        end
-      else
-        # poor man's unescape without using eval
-        require 'yaml'
-        def char
-          YAML.load(%Q(---\n"#{text}"\n))
-        end
-      end
-    end
+    AsciiEscape = Class.new(Base) # \e
+    Backspace   = Class.new(Base) # \b
+    Bell        = Class.new(Base) # \a
+    FormFeed    = Class.new(Base) # \f
+    Newline     = Class.new(Base) # \n
+    Return      = Class.new(Base) # \r
+    Tab         = Class.new(Base) # \t
+    VerticalTab = Class.new(Base) # \v
 
-    class Literal < EscapeSequence::Base
-      def char
-        text[1..-1]
-      end
-    end
+    Literal     = Class.new(Base) # e.g. \j, \@, \😀 (ineffectual escapes)
 
-    class AsciiEscape   < EscapeSequence::Base; end
-    class Backspace     < EscapeSequence::Base; end
-    class Bell          < EscapeSequence::Base; end
-    class FormFeed      < EscapeSequence::Base; end
-    class Newline       < EscapeSequence::Base; end
-    class Return        < EscapeSequence::Base; end
-    class Tab           < EscapeSequence::Base; end
-    class VerticalTab   < EscapeSequence::Base; end
+    Octal       = Class.new(Base) # e.g. \012
+    Hex         = Class.new(Base) # e.g. \x0A
+    Codepoint   = Class.new(Base) # e.g. \u000A
 
-    class Hex           < EscapeSequence::Base; end
-    class Codepoint     < EscapeSequence::Base; end
+    CodepointList = Class.new(Base) # e.g. \u{A B}
 
-    class CodepointList < EscapeSequence::Base
-      def char
-        raise NoMethodError, 'CodepointList responds only to #chars'
-      end
-
-      def codepoint
-        raise NoMethodError, 'CodepointList responds only to #codepoints'
-      end
-
-      def chars
-        codepoints.map { |cp| cp.chr('utf-8') }
-      end
-
-      def codepoints
-        text.scan(/\h+/).map(&:hex)
-      end
-    end
-
-    class Octal < EscapeSequence::Base
-      def char
-        text[1..-1].to_i(8).chr('utf-8')
-      end
-    end
-
-    class AbstractMetaControlSequence < EscapeSequence::Base
-      def char
-        codepoint.chr('utf-8')
-      end
-
-      private
-
-      def control_sequence_to_s(control_sequence)
-        five_lsb = control_sequence.unpack('B*').first[-5..-1]
-        ["000#{five_lsb}"].pack('B*')
-      end
-
-      def meta_char_to_codepoint(meta_char)
-        byte_value = meta_char.ord
-        byte_value < 128 ? byte_value + 128 : byte_value
-      end
-    end
-
-    class Control < AbstractMetaControlSequence
-      def codepoint
-        control_sequence_to_s(text).ord
-      end
-    end
-
-    class Meta < AbstractMetaControlSequence
-      def codepoint
-        meta_char_to_codepoint(text[-1])
-      end
-    end
-
-    class MetaControl < AbstractMetaControlSequence
-      def codepoint
-        meta_char_to_codepoint(control_sequence_to_s(text))
-      end
-    end
+    AbstractMetaControlSequence = Class.new(Base)
+    Control                     = Class.new(AbstractMetaControlSequence) # e.g. \cB
+    Meta                        = Class.new(AbstractMetaControlSequence) # e.g. \M-Z
+    MetaControl                 = Class.new(AbstractMetaControlSequence) # e.g. \M-\cX
   end
 
   # alias for symmetry between Token::* and Expression::*

data/lib/regexp_parser/expression/methods/escape_sequence_char.rb

@@ -0,0 +1,5 @@
+Regexp::Expression::EscapeSequence::Base.class_eval do
+  def char
+    codepoint.chr('utf-8')
+  end
+end

data/lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb

@@ -0,0 +1,68 @@
+module Regexp::Expression::EscapeSequence
+  AsciiEscape.class_eval { def codepoint; 0x1B end }
+  Backspace.class_eval   { def codepoint; 0x8  end }
+  Bell.class_eval        { def codepoint; 0x7  end }
+  FormFeed.class_eval    { def codepoint; 0xC  end }
+  Newline.class_eval     { def codepoint; 0xA  end }
+  Return.class_eval      { def codepoint; 0xD  end }
+  Tab.class_eval         { def codepoint; 0x9  end }
+  VerticalTab.class_eval { def codepoint; 0xB  end }
+
+  Literal.class_eval     { def codepoint; text[1].ord end }
+
+  Octal.class_eval       { def codepoint; text[/\d+/].to_i(8) end }
+
+  Hex.class_eval         { def codepoint; text[/\h+/].hex end }
+  Codepoint.class_eval   { def codepoint; text[/\h+/].hex end }
+
+  CodepointList.class_eval do
+    # Maybe this should be a unique top-level expression class?
+    def char
+      raise NoMethodError, 'CodepointList responds only to #chars'
+    end
+
+    def codepoint
+      raise NoMethodError, 'CodepointList responds only to #codepoints'
+    end
+
+    def chars
+      codepoints.map { |cp| cp.chr('utf-8') }
+    end
+
+    def codepoints
+      text.scan(/\h+/).map(&:hex)
+    end
+  end
+
+  AbstractMetaControlSequence.class_eval do
+    private
+
+    def control_sequence_to_s(control_sequence)
+      five_lsb = control_sequence.unpack('B*').first[-5..-1]
+      ["000#{five_lsb}"].pack('B*')
+    end
+
+    def meta_char_to_codepoint(meta_char)
+      byte_value = meta_char.ord
+      byte_value < 128 ? byte_value + 128 : byte_value
+    end
+  end
+
+  Control.class_eval do
+    def codepoint
+      control_sequence_to_s(text).ord
+    end
+  end
+
+  Meta.class_eval do
+    def codepoint
+      meta_char_to_codepoint(text[-1])
+    end
+  end
+
+  MetaControl.class_eval do
+    def codepoint
+      meta_char_to_codepoint(control_sequence_to_s(text))
+    end
+  end
+end

data/lib/regexp_parser/expression/methods/referenced_expressions.rb

@@ -0,0 +1,28 @@
+module Regexp::Expression
+  module ReferencedExpressions
+    attr_accessor :referenced_expressions
+
+    def referenced_expression
+      referenced_expressions && referenced_expressions.first
+    end
+
+    def initialize_copy(orig)
+      exp_id = [self.class, self.starts_at]
+
+      # prevent infinite recursion for recursive subexp calls
+      copied = self.class.instance_eval { @copied_ref_exps ||= {} }
+      self.referenced_expressions =
+        if copied[exp_id]
+          orig.referenced_expressions
+        else
+          copied[exp_id] = true
+          orig.referenced_expressions && orig.referenced_expressions.map(&:dup)
+        end
+      copied.clear
+
+      super
+    end
+  end
+
+  Base.include ReferencedExpressions
+end

data/lib/regexp_parser/expression.rb

@@ -25,6 +25,8 @@ require_relative 'expression/classes/root'
 require_relative 'expression/classes/unicode_property'
 
 require_relative 'expression/methods/construct'
+require_relative 'expression/methods/escape_sequence_char'
+require_relative 'expression/methods/escape_sequence_codepoint'
 require_relative 'expression/methods/human_name'
 require_relative 'expression/methods/match'
 require_relative 'expression/methods/match_length'
@@ -32,6 +34,7 @@ require_relative 'expression/methods/negative'
 require_relative 'expression/methods/options'
 require_relative 'expression/methods/parts'
 require_relative 'expression/methods/printing'
+require_relative 'expression/methods/referenced_expressions'
 require_relative 'expression/methods/strfregexp'
 require_relative 'expression/methods/tests'
 require_relative 'expression/methods/traverse'

data/lib/regexp_parser/parser.rb

@@ -580,16 +580,19 @@ class Regexp::Parser
   # the instance of Group::Capture that it refers to via its number.
   def assign_referenced_expressions
     # find all referenceable and referring expressions
-    targets = { 0 => root }
+    targets = { 0 => [root] }
     referrers = []
     root.each_expression do |exp|
-      exp.is_a?(Group::Capture) && targets[exp.identifier] = exp
-      referrers << exp if exp.referential?
+      if exp.referential?
+        referrers << exp
+      elsif exp.is_a?(Group::Capture)
+        (targets[exp.identifier] ||= []) << exp
+      end
     end
-    # assign reference expression to referring expressions
+    # assign referenced expressions to referring expressions
     # (in a second iteration because there might be forward references)
     referrers.each do |exp|
-      exp.referenced_expression = targets[exp.reference] ||
+      exp.referenced_expressions = targets[exp.reference] ||
         raise(ParserError, "Invalid reference #{exp.reference} at pos #{exp.ts}")
     end
   end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '2.9.3'
+    VERSION = '2.10.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 2.9.3
+  version: 2.10.0
 platform: ruby
 authors:
 - Ammar Ali
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email:
@@ -43,6 +43,8 @@ files:
 - lib/regexp_parser/expression/classes/root.rb
 - lib/regexp_parser/expression/classes/unicode_property.rb
 - lib/regexp_parser/expression/methods/construct.rb
+- lib/regexp_parser/expression/methods/escape_sequence_char.rb
+- lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb
 - lib/regexp_parser/expression/methods/human_name.rb
 - lib/regexp_parser/expression/methods/match.rb
 - lib/regexp_parser/expression/methods/match_length.rb
@@ -50,6 +52,7 @@ files:
 - lib/regexp_parser/expression/methods/options.rb
 - lib/regexp_parser/expression/methods/parts.rb
 - lib/regexp_parser/expression/methods/printing.rb
+- lib/regexp_parser/expression/methods/referenced_expressions.rb
 - lib/regexp_parser/expression/methods/strfregexp.rb
 - lib/regexp_parser/expression/methods/tests.rb
 - lib/regexp_parser/expression/methods/traverse.rb