regexp_parser 2.6.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cadf1761e17469c6bf76db652a4f6fc97a3d33b7eaa46e6ea16f95ee6661743d
-  data.tar.gz: 3d6252f67f201b3cb6a3b94721c65b39abfe7b13bf0097fc9144498f6fdf8837
+  metadata.gz: f6ed5457d89738fa1076cf3875cd2d009973f02857ea68e055ef3ef74a78dc91
+  data.tar.gz: d67eb5f0cb37ad106574b2ae327eefcfc13c9d585cddec6661898f4d8166ebcc
 SHA512:
-  metadata.gz: 3fb24f56b5d8da354aa5825dc2e9432c7e8bd836c9c2a7009c8883e367fb8ca61020a04854c714cacff913281b1156b4663334696edcb1d7e9239d8c8184d439
-  data.tar.gz: e793b72a9394e26bf0b9e6cb58c7536b72c30562382713f8b60735969f3b3b9b3aea78bf45efa661397d7141c2684a6df2b32cc8b449c413ea9d11c90c5396db
+  metadata.gz: 6b8adbc3c4707fc4c823456ae1d7547f17568802de03008a17fef18a5f95af08b0e42d48ccdfab25a740603a58ab89c036d70cec94405701201e5a5af51ce392
+  data.tar.gz: 9bea98a42ab64a9b45ddc5564cd077d7eb6d2ddc293844759bb8001aa9fefd8aa26b0e03fff7a286ccde9f7aeacacda9fbb187fe04082749d3c2605e0cece7b9

data/Gemfile

@@ -3,13 +3,13 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'ice_nine', '~> 0.11.2'
-  gem 'rake', '~> 13.0'
-  gem 'regexp_property_values', '~> 1.3'
+  gem 'leto', '~> 2.1'
+  gem 'rake', '~> 13.1'
+  gem 'regexp_property_values', '~> 1.5'
   gem 'rspec', '~> 3.10'
   if RUBY_VERSION.to_f >= 2.7
     gem 'benchmark-ips', '~> 2.1'
-    gem 'gouteur'
-    gem 'rubocop', '~> 1.7'
+    gem 'gouteur', '~> 1.1'
+    gem 'rubocop', '~> 1.59'
   end
 end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010, 2012-2022,  Ammar Ali
+Copyright (c) 2010, 2012-2024,  Ammar Ali
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/lib/regexp_parser/expression/base.rb

@@ -6,13 +6,6 @@ module Regexp::Expression
       init_from_token_and_options(token, options)
     end
 
-    def initialize_copy(orig)
-      self.text       = orig.text.dup         if orig.text
-      self.options    = orig.options.dup      if orig.options
-      self.quantifier = orig.quantifier.clone if orig.quantifier
-      super
-    end
-
     def to_re(format = :full)
       if set_level > 0
         warn "Calling #to_re on character set members is deprecated - "\

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

@@ -1,5 +1,5 @@
 module Regexp::Expression
-  # A sequence of expressions, used by Alternation as one of its alternative.
+  # A sequence of expressions, used by Alternation as one of its alternatives.
   class Alternative < Regexp::Expression::Sequence; end
 
   class Alternation < Regexp::Expression::SequenceOperation

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

@@ -1,21 +1,13 @@
 module Regexp::Expression
-  # TODO: unify name with token :backref, one way or the other, in v3.0.0
   module Backreference
-    class Base < Regexp::Expression::Base
-      attr_accessor :referenced_expression
-
-      def initialize_copy(orig)
-        self.referenced_expression = orig.referenced_expression.dup
-        super
-      end
-    end
+    class Base < Regexp::Expression::Base; end
 
     class Number < Backreference::Base
       attr_reader :number
       alias reference number
 
       def initialize(token, options = {})
-        @number = token.text[token.token.equal?(:number) ? 1..-1 : 3..-2].to_i
+        @number = token.text[/-?\d+/].to_i
         super
       end
     end
@@ -58,4 +50,7 @@ module Regexp::Expression
       end
     end
   end
+
+  # alias for symmetry between token symbol and Expression class name
+  Backref = Backreference
 end

data/lib/regexp_parser/expression/classes/character_set/range.rb

@@ -1,10 +1,9 @@
 module Regexp::Expression
   class CharacterSet < Regexp::Expression::Subexpression
     class Range < Regexp::Expression::Subexpression
-      def starts_at
-        expressions.first.starts_at
+      def ts
+        (head = expressions.first) ? head.ts : @ts
       end
-      alias :ts :starts_at
 
       def <<(exp)
         complete? and raise Regexp::Parser::Error,
@@ -15,10 +14,6 @@ module Regexp::Expression
       def complete?
         count == 2
       end
-
-      def parts
-        intersperse(expressions, text.dup)
-      end
     end
   end
 end

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

@@ -1,10 +1,7 @@
 module Regexp::Expression
   class CharacterSet < Regexp::Expression::Subexpression
     attr_accessor :closed, :negative
-
-    alias :negative? :negative
-    alias :negated?  :negative
-    alias :closed?   :closed
+    alias :closed? :closed
 
     def initialize(token, options = {})
       self.negative = false
@@ -19,9 +16,8 @@ module Regexp::Expression
     def close
       self.closed = true
     end
-
-    def parts
-      ["#{text}#{'^' if negated?}", *expressions, ']']
-    end
   end
+
+  # alias for symmetry between token symbol and Expression class name
+  Set = CharacterSet
 end # module Regexp::Expression

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

@@ -7,33 +7,24 @@ 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
 
-      def add_sequence(active_opts = {})
+      def add_sequence(active_opts = {}, params = { ts: 0 })
         raise TooManyBranches.new if branches.length == 2
-        params = { conditional_level: conditional_level + 1 }
+        params = params.merge({ conditional_level: conditional_level + 1 })
         Branch.add_to(self, params, active_opts)
       end
       alias :branch :add_sequence
@@ -54,15 +45,6 @@ module Regexp::Expression
       def reference
         condition.reference
       end
-
-      def parts
-        [text.dup, condition, *intersperse(branches, '|'), ')']
-      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,30 @@
 module Regexp::Expression
-  # TODO: unify naming with Token::Escape, one way or the other, in v3.0.0
   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::*
+  Escape = EscapeSequence
 end

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

@@ -5,10 +5,12 @@ module Regexp::Expression
     end
   end
 
-  class Comment < Regexp::Expression::FreeSpace; end
+  class Comment < Regexp::Expression::FreeSpace
+  end
 
   class WhiteSpace < Regexp::Expression::FreeSpace
     def merge(exp)
+      warn("#{self.class}##{__method__} is deprecated and will be removed in v3.0.0.")
       text << exp.text
     end
   end

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

@@ -1,13 +1,6 @@
 module Regexp::Expression
   module Group
     class Base < Regexp::Expression::Subexpression
-      def parts
-        [text.dup, *expressions, ')']
-      end
-
-      def capturing?; false end
-
-      def comment?; false end
     end
 
     class Passive < Group::Base
@@ -18,14 +11,6 @@ module Regexp::Expression
         super
       end
 
-      def parts
-        if implicit?
-          expressions
-        else
-          super
-        end
-      end
-
       def implicit?
         @implicit
       end
@@ -55,8 +40,6 @@ module Regexp::Expression
     class Capture < Group::Base
       attr_accessor :number, :number_at_level
       alias identifier number
-
-      def capturing?; true end
     end
 
     class Named < Group::Capture
@@ -75,11 +58,6 @@ module Regexp::Expression
     end
 
     class Comment < Group::Base
-      def parts
-        [text.dup]
-      end
-
-      def comment?; true end
     end
   end
 

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/classes/posix_class.rb

@@ -1,11 +1,11 @@
 module Regexp::Expression
   class PosixClass < Regexp::Expression::Base
-    def negative?
-      type == :nonposixclass
-    end
-
     def name
-      token.to_s
+      text[/\w+/]
     end
   end
+
+  # alias for symmetry between token symbol and Expression class name
+  Posixclass    = PosixClass
+  Nonposixclass = PosixClass
 end

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

@@ -1,17 +1,12 @@
 module Regexp::Expression
-  # TODO: unify name with token :property, one way or the other, in v3.0.0
   module UnicodeProperty
     class Base < Regexp::Expression::Base
-      def negative?
-        type == :nonproperty
-      end
-
       def name
         text[/\A\\[pP]\{([^}]+)\}\z/, 1]
       end
 
       def shortcut
-        (Regexp::Scanner.short_prop_map.rassoc(token.to_s) || []).first
+        Regexp::Scanner.short_prop_map.key(token.to_s)
       end
     end
 
@@ -110,10 +105,15 @@ module Regexp::Expression
       class Unassigned  < Codepoint::Base; end
     end
 
-    class Age     < UnicodeProperty::Base; end
-    class Derived < UnicodeProperty::Base; end
-    class Emoji   < UnicodeProperty::Base; end
-    class Script  < UnicodeProperty::Base; end
-    class Block   < UnicodeProperty::Base; end
+    class Age        < UnicodeProperty::Base; end
+    class Block      < UnicodeProperty::Base; end
+    class Derived    < UnicodeProperty::Base; end
+    class Emoji      < UnicodeProperty::Base; end
+    class Enumerated < UnicodeProperty::Base; end
+    class Script     < UnicodeProperty::Base; end
   end
+
+  # alias for symmetry between token symbol and Expression class name
+  Property    = UnicodeProperty
+  Nonproperty = UnicodeProperty
 end # module Regexp::Expression

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

@@ -25,11 +25,9 @@ module Regexp::Expression
       def token_class
         if self == Root || self < Sequence
           nil # no token class because these objects are Parser-generated
-        # TODO: synch exp & token class names for alt., dot, escapes in v3.0.0
-        elsif self == Alternation || self == CharacterType::Any
+        # TODO: synch exp class, token class & type names for this in v3.0.0
+        elsif self == CharacterType::Any
           Regexp::Syntax::Token::Meta
-        elsif self <= EscapeSequence::Base
-          Regexp::Syntax::Token::Escape
         else
           Regexp::Syntax::Token.const_get(name.split('::')[2])
         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/match_length.rb

@@ -63,16 +63,20 @@ class Regexp::MatchLength
   end
 
   def to_re
-    "(?:#{reify.call}){#{min_rep},#{max_rep unless max_rep == Float::INFINITY}}"
+    /(?:#{reify.call}){#{min_rep},#{max_rep unless max_rep == Float::INFINITY}}/
   end
 
   private
 
   attr_accessor :base_min, :base_max, :min_rep, :max_rep, :exp_class, :reify
 
-  def test_regexp
-    @test_regexp ||= Regexp.new("^#{to_re}$").tap do |regexp|
-      regexp.respond_to?(:match?) || def regexp.match?(str); !!match(str) end
+  if Regexp.method_defined?(:match?) # ruby >= 2.4
+    def test_regexp
+      @test_regexp ||= /^#{to_re}$/
+    end
+  else
+    def test_regexp
+      @test_regexp ||= /^#{to_re}$/.tap { |r| def r.match?(s); !!match(s) end }
     end
   end
 end

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

@@ -0,0 +1,20 @@
+module Regexp::Expression
+  module Shared
+    def negative?
+      false
+    end
+
+    # not an alias so as to respect overrides of #negative?
+    def negated?
+      negative?
+    end
+  end
+
+  Anchor::NonWordBoundary.class_eval       { def negative?; true                          end }
+  Assertion::NegativeLookahead.class_eval  { def negative?; true                          end }
+  Assertion::NegativeLookbehind.class_eval { def negative?; true                          end }
+  CharacterSet.class_eval                  { def negative?; negative                      end }
+  CharacterType::Base.class_eval           { def negative?; token.to_s.start_with?('non') end }
+  PosixClass.class_eval                    { def negative?; type == :nonposixclass        end }
+  UnicodeProperty::Base.class_eval         { def negative?; type == :nonproperty          end }
+end

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

@@ -0,0 +1,23 @@
+module Regexp::Expression
+  module Shared
+    # default implementation
+    def parts
+      [text.dup]
+    end
+
+    private
+
+    def intersperse(expressions, separator)
+      expressions.flat_map { |exp| [exp, separator] }.slice(0...-1)
+    end
+  end
+
+  CharacterSet.class_eval            { def parts; ["#{text}#{'^' if negated?}", *expressions, ']']        end }
+  CharacterSet::Range.class_eval     { def parts; intersperse(expressions, text.dup)                      end }
+  Conditional::Expression.class_eval { def parts; [text.dup, condition, *intersperse(branches, '|'), ')'] end }
+  Group::Base.class_eval             { def parts; [text.dup, *expressions, ')']                           end }
+  Group::Passive.class_eval          { def parts; implicit? ? expressions : super                         end }
+  Group::Comment.class_eval          { def parts; [text.dup]                                              end }
+  Subexpression.class_eval           { def parts; expressions                                             end }
+  SequenceOperation.class_eval       { def parts; intersperse(expressions, text.dup)                      end }
+end

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

@@ -0,0 +1,26 @@
+module Regexp::Expression
+  module Shared
+    def inspect
+      [
+        "#<#{self.class}",
+        pretty_print_instance_variables.map { |v| " #{v}=#{instance_variable_get(v).inspect}" },
+        ">"
+      ].join
+    end
+
+    # Make pretty-print work despite #inspect implementation.
+    def pretty_print(q)
+      q.pp_object(self)
+    end
+
+    # Called by pretty_print (ruby/pp) and #inspect.
+    def pretty_print_instance_variables
+      [
+        (:@text unless text.to_s.empty?),
+        (:@quantifier if quantified?),
+        (:@options unless options.empty?),
+        (:@expressions unless terminal?),
+      ].compact
+    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