regexp_parser 2.6.0 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cadf1761e17469c6bf76db652a4f6fc97a3d33b7eaa46e6ea16f95ee6661743d
-  data.tar.gz: 3d6252f67f201b3cb6a3b94721c65b39abfe7b13bf0097fc9144498f6fdf8837
+  metadata.gz: c88d5bc178e9bf95a8a008d9d5e9d8cf1b4a8bb0d65310901a995daa448a28f4
+  data.tar.gz: 47c1ed4782981f5cc2a0bb7bd8f402e360cd60ebeba33615df0c94dd3842b48c
 SHA512:
-  metadata.gz: 3fb24f56b5d8da354aa5825dc2e9432c7e8bd836c9c2a7009c8883e367fb8ca61020a04854c714cacff913281b1156b4663334696edcb1d7e9239d8c8184d439
-  data.tar.gz: e793b72a9394e26bf0b9e6cb58c7536b72c30562382713f8b60735969f3b3b9b3aea78bf45efa661397d7141c2684a6df2b32cc8b449c413ea9d11c90c5396db
+  metadata.gz: 5dc1bf229c259b762ea38f459f70a9a04e5ee08207fbae04bdf9045f9f2b1c0f0b6a716a3e08fda55ca0b769ef55f480f7f0e19f3412175fdc7a475362889ab3
+  data.tar.gz: 5de692c1cce8f2436936752d0cf6c5ea51d84bb9c63110dcc49621a476b47800300911952f4d4a687c81f151886bc5570b14af559d74b5196b63e13c684ab7c5

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,11 +1,22 @@
 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
+        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
@@ -15,7 +26,7 @@ module Regexp::Expression
       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 +69,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

@@ -31,9 +31,9 @@ module Regexp::Expression
         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
@@ -55,10 +55,6 @@ module Regexp::Expression
         condition.reference
       end
 
-      def parts
-        [text.dup, condition, *intersperse(branches, '|'), ')']
-      end
-
       def initialize_copy(orig)
         self.referenced_expression = orig.referenced_expression.dup
         super

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

@@ -1,5 +1,4 @@
 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
@@ -97,4 +96,7 @@ module Regexp::Expression
       end
     end
   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/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/tests.rb

@@ -95,12 +95,49 @@ module Regexp::Expression
     end
 
     # Deep-compare two expressions for equality.
+    #
+    # When changing the conditions, please make sure to update
+    # #pretty_print_instance_variables so that it includes all relevant values.
     def ==(other)
-      other.class == self.class &&
-        other.to_s == to_s &&
-        other.options == options
+      self.class   == other.class &&
+        text       == other.text &&
+        quantifier == other.quantifier &&
+        options    == other.options &&
+        (terminal? || expressions == other.expressions)
     end
     alias :=== :==
     alias :eql? :==
+
+    def optional?
+      quantified? && quantifier.min == 0
+    end
+
+    def quantified?
+      !quantifier.nil?
+    end
   end
+
+  Shared.class_eval                     { def terminal?; self.class.terminal? end }
+  Shared::ClassMethods.class_eval       { def terminal?; true  end }
+  Subexpression.instance_eval           { def terminal?; false end }
+
+  Shared.class_eval                     { def capturing?; self.class.capturing? end }
+  Shared::ClassMethods.class_eval       { def capturing?; false end }
+  Group::Capture.instance_eval          { def capturing?; true  end }
+
+  Shared.class_eval                     { def comment?; self.class.comment? end }
+  Shared::ClassMethods.class_eval       { def comment?; false end }
+  Comment.instance_eval                 { def comment?; true  end }
+  Group::Comment.instance_eval          { def comment?; true  end }
+
+  Shared.class_eval                     { def decorative?; self.class.decorative? end }
+  Shared::ClassMethods.class_eval       { def decorative?; false end }
+  FreeSpace.instance_eval               { def decorative?; true  end }
+  Group::Comment.instance_eval          { def decorative?; true  end }
+
+  Shared.class_eval                     { def referential?; self.class.referential? end }
+  Shared::ClassMethods.class_eval       { def referential?; false end }
+  Backreference::Base.instance_eval     { def referential?; true  end }
+  Conditional::Condition.instance_eval  { def referential?; true  end }
+  Conditional::Expression.instance_eval { def referential?; true  end }
 end

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

@@ -1,6 +1,22 @@
 module Regexp::Expression
   class Subexpression < Regexp::Expression::Base
 
+    # Traverses the expression, passing each recursive child to the
+    # given block.
+    # If the block takes two arguments, the indices of the children within
+    # their parents are also passed to it.
+    def each_expression(include_self = false, &block)
+      return enum_for(__method__, include_self) unless block
+
+      if block.arity == 1
+        block.call(self) if include_self
+        each_expression_without_index(&block)
+      else
+        block.call(self, 0) if include_self
+        each_expression_with_index(&block)
+      end
+    end
+
     # Traverses the subexpression (depth-first, pre-order) and calls the given
     # block for each expression with three arguments; the traversal event,
     # the expression, and the index of the expression within its parent.
@@ -34,31 +50,31 @@ module Regexp::Expression
     end
     alias :walk :traverse
 
-    # Iterates over the expressions of this expression as an array, passing
-    # the expression and its index within its parent to the given block.
-    def each_expression(include_self = false)
-      return enum_for(__method__, include_self) unless block_given?
-
-      traverse(include_self) do |event, exp, index|
-        yield(exp, index) unless event == :exit
-      end
-    end
-
     # Returns a new array with the results of calling the given block once
     # for every expression. If a block is not given, returns an array with
     # each expression and its level index as an array.
-    def flat_map(include_self = false)
-      result = []
+    def flat_map(include_self = false, &block)
+      case block && block.arity
+      when nil then each_expression(include_self).to_a
+      when 2   then each_expression(include_self).map(&block)
+      else          each_expression(include_self).map { |exp| block.call(exp) }
+      end
+    end
 
-      each_expression(include_self) do |exp, index|
-        if block_given?
-          result << yield(exp, index)
-        else
-          result << [exp, index]
-        end
+    protected
+
+    def each_expression_with_index(&block)
+      each_with_index do |exp, index|
+        block.call(exp, index)
+        exp.each_expression_with_index(&block) unless exp.terminal?
       end
+    end
 
-      result
+    def each_expression_without_index(&block)
+      each do |exp|
+        block.call(exp)
+        exp.each_expression_without_index(&block) unless exp.terminal?
+      end
     end
   end
 end

data/lib/regexp_parser/expression/quantifier.rb

@@ -8,14 +8,10 @@ module Regexp::Expression
 
     MODES = %i[greedy possessive reluctant]
 
-    attr_reader :min, :max, :mode
-
     def initialize(*args)
       deprecated_old_init(*args) and return if args.count == 4 || args.count == 5
 
       init_from_token_and_options(*args)
-      @mode = (token.to_s[/greedy|reluctant|possessive/] || :greedy).to_sym
-      @min, @max = minmax
       # TODO: remove in v3.0.0, stop removing parts of #token (?)
       self.token = token.to_s.sub(/_(greedy|possessive|reluctant)/, '').to_sym
     end
@@ -39,9 +35,21 @@ module Regexp::Expression
     end
     alias :lazy? :reluctant?
 
+    def min
+      derived_data[:min]
+    end
+
+    def max
+      derived_data[:max]
+    end
+
+    def mode
+      derived_data[:mode]
+    end
+
     private
 
-    def deprecated_old_init(token, text, min, max, mode = :greedy)
+    def deprecated_old_init(token, text, _min, _max, _mode = :greedy)
       warn "Calling `Expression::Base#quantify` or `#{self.class}.new` with 4+ arguments "\
            "is deprecated.\nIt will no longer be supported in regexp_parser v3.0.0.\n"\
            "Please pass a Regexp::Token instead, e.g. replace `token, text, min, max, mode` "\
@@ -51,20 +59,25 @@ module Regexp::Expression
            "This is consistent with how Expression::Base instances are created. "
       @token = token
       @text  = text
-      @min   = min
-      @max   = max
-      @mode  = mode
     end
 
-    def minmax
-      case token
-      when /zero_or_one/  then [0, 1]
-      when /zero_or_more/ then [0, -1]
-      when /one_or_more/  then [1, -1]
-      when :interval
-        int_min = text[/\{(\d*)/, 1]
-        int_max = text[/,?(\d*)\}/, 1]
-        [int_min.to_i, (int_max.empty? ? -1 : int_max.to_i)]
+    def derived_data
+      @derived_data ||= begin
+        min, max =
+          case text[0]
+          when '?'; [0, 1]
+          when '*'; [0, -1]
+          when '+'; [1, -1]
+          else
+            int_min = text[/\{(\d*)/, 1]
+            int_max = text[/,?(\d*)\}/, 1]
+            [int_min.to_i, (int_max.empty? ? -1 : int_max.to_i)]
+          end
+
+        mod = text[/.([?+])/, 1]
+        mode = (mod == '?' && :reluctant) || (mod == '+' && :possessive) || :greedy
+
+        { min: min, max: max, mode: mode }
       end
     end
   end

data/lib/regexp_parser/expression/sequence.rb

@@ -12,25 +12,20 @@ module Regexp::Expression
           level:             exp.level,
           set_level:         exp.set_level,
           conditional_level: params[:conditional_level] || exp.conditional_level,
+          ts:                params[:ts],
         )
-        sequence.nesting_level = exp.nesting_level + 1
         sequence.options = active_opts
         exp.expressions << sequence
         sequence
       end
     end
 
-    def starts_at
-      expressions.first.starts_at
+    def ts
+      (head = expressions.first) ? head.ts : @ts
     end
-    alias :ts :starts_at
 
-    def quantify(*args)
-      target = expressions.reverse.find { |exp| !exp.is_a?(FreeSpace) }
-      target or raise Regexp::Parser::Error,
-        "No valid target found for '#{text}' quantifier"
-
-      target.quantify(*args)
+    def quantify(token, *args)
+      extract_quantifier_target(token.text).quantify(token, *args)
     end
   end
 end