regexp_parser 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cc1826647cde51d6d1b5a5a58fb005efd2a38a85fa0e817616591ee2fad7862
-  data.tar.gz: 572a6203741b9970bcedc1ace243ea0b9c300ca60b71ac263036eb0f4222dd50
+  metadata.gz: f6ed5457d89738fa1076cf3875cd2d009973f02857ea68e055ef3ef74a78dc91
+  data.tar.gz: d67eb5f0cb37ad106574b2ae327eefcfc13c9d585cddec6661898f4d8166ebcc
 SHA512:
-  metadata.gz: 3521fe6dab4be0c0db3c37f3f8d196fc754ff72937336a73ef5547a15ae4f2d366aa28e73d6e5756920d610b943ee51cb2db8e51e53ccb19c1c235a8c45da708
-  data.tar.gz: d05b7babb79c118bdc36ae168d8199ee3500b0cff33cb00ed46d51a4a88725130e931c588146a3f989dd87778b1f39684b2c8a5541c9ac8f91427fc31b1ec97a
+  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/classes/keep.rb

@@ -1,6 +1,6 @@
 module Regexp::Expression
   module Keep
-    # TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression
+    # TODO: in regexp_parser v3.0.0 this should possibly be a Subexpression
     #       that contains all expressions to its left.
     class Mark < Regexp::Expression::Base; end
   end

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

@@ -1,37 +1,40 @@
-require 'regexp_parser/error'
+require_relative 'error'
 
-require 'regexp_parser/expression/shared'
-require 'regexp_parser/expression/base'
-require 'regexp_parser/expression/quantifier'
-require 'regexp_parser/expression/subexpression'
-require 'regexp_parser/expression/sequence'
-require 'regexp_parser/expression/sequence_operation'
+require_relative 'expression/shared'
+require_relative 'expression/base'
+require_relative 'expression/quantifier'
+require_relative 'expression/subexpression'
+require_relative 'expression/sequence'
+require_relative 'expression/sequence_operation'
 
-require 'regexp_parser/expression/classes/alternation'
-require 'regexp_parser/expression/classes/anchor'
-require 'regexp_parser/expression/classes/backreference'
-require 'regexp_parser/expression/classes/character_set'
-require 'regexp_parser/expression/classes/character_set/intersection'
-require 'regexp_parser/expression/classes/character_set/range'
-require 'regexp_parser/expression/classes/character_type'
-require 'regexp_parser/expression/classes/conditional'
-require 'regexp_parser/expression/classes/escape_sequence'
-require 'regexp_parser/expression/classes/free_space'
-require 'regexp_parser/expression/classes/group'
-require 'regexp_parser/expression/classes/keep'
-require 'regexp_parser/expression/classes/literal'
-require 'regexp_parser/expression/classes/posix_class'
-require 'regexp_parser/expression/classes/root'
-require 'regexp_parser/expression/classes/unicode_property'
+require_relative 'expression/classes/alternation'
+require_relative 'expression/classes/anchor'
+require_relative 'expression/classes/backreference'
+require_relative 'expression/classes/character_set'
+require_relative 'expression/classes/character_set/intersection'
+require_relative 'expression/classes/character_set/range'
+require_relative 'expression/classes/character_type'
+require_relative 'expression/classes/conditional'
+require_relative 'expression/classes/escape_sequence'
+require_relative 'expression/classes/free_space'
+require_relative 'expression/classes/group'
+require_relative 'expression/classes/keep'
+require_relative 'expression/classes/literal'
+require_relative 'expression/classes/posix_class'
+require_relative 'expression/classes/root'
+require_relative 'expression/classes/unicode_property'
 
-require 'regexp_parser/expression/methods/construct'
-require 'regexp_parser/expression/methods/human_name'
-require 'regexp_parser/expression/methods/match'
-require 'regexp_parser/expression/methods/match_length'
-require 'regexp_parser/expression/methods/negative'
-require 'regexp_parser/expression/methods/options'
-require 'regexp_parser/expression/methods/parts'
-require 'regexp_parser/expression/methods/printing'
-require 'regexp_parser/expression/methods/strfregexp'
-require 'regexp_parser/expression/methods/tests'
-require 'regexp_parser/expression/methods/traverse'
+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'
+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

@@ -1,5 +1,5 @@
-require 'regexp_parser/error'
-require 'regexp_parser/expression'
+require_relative 'error'
+require_relative 'expression'
 
 class Regexp::Parser
   include Regexp::Expression
@@ -575,21 +575,24 @@ class Regexp::Parser
     options_stack.last
   end
 
-  # Assigns referenced expressions to refering expressions, e.g. if there is
+  # Assigns referenced expressions to referring expressions, e.g. if there is
   # an instance of Backreference::Number, its #referenced_expression is set to
   # the instance of Group::Capture that it refers to via its number.
   def assign_referenced_expressions
-    # find all referencable and refering expressions
-    targets = { 0 => root }
+    # find all referenceable and referring expressions
+    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 refering 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/scanner/errors/scanner_error.rb

@@ -1,4 +1,4 @@
-require 'regexp_parser/error'
+require_relative '../../../regexp_parser/error'
 
 class Regexp::Scanner
   # General scanner error (catch all)

data/lib/regexp_parser/scanner/scanner.rl

@@ -78,8 +78,8 @@
   # try to treat every other group head as options group, like Ruby
   group_options         = '?' . ( [^!#'():<=>~]+ . ':'? ) ?;
 
-  group_name_id_ab      = ([^!0-9\->] | utf8_multibyte) . ([^>] | utf8_multibyte)*;
-  group_name_id_sq      = ([^0-9\-']  | utf8_multibyte) . ([^'] | utf8_multibyte)*;
+  group_name_id_ab      = ([^!=0-9\->] | utf8_multibyte) . ([^>] | utf8_multibyte)*;
+  group_name_id_sq      = ([^0-9\-']   | utf8_multibyte) . ([^'] | utf8_multibyte)*;
   group_number          = '-'? . [0-9]+;
   group_level           = [+\-] . [0-9]+;
 
@@ -640,9 +640,9 @@
   *|;
 }%%
 
-require 'regexp_parser/scanner/errors/scanner_error'
-require 'regexp_parser/scanner/errors/premature_end_error'
-require 'regexp_parser/scanner/errors/validation_error'
+require_relative 'scanner/errors/scanner_error'
+require_relative 'scanner/errors/premature_end_error'
+require_relative 'scanner/errors/validation_error'
 
 class Regexp::Scanner
   # Scans the given regular expression text, or Regexp object and collects the