regexp_parser 1.7.0 → 2.8.1

data/lib/regexp_parser/expression/quantifier.rb

@@ -1,26 +1,20 @@
 module Regexp::Expression
+  # TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
+  # call super in #initialize, but raise in #quantifier= and #quantify,
+  # or introduce an Expression::Quantifiable intermediate class.
+  # Or actually allow chaining as a more concise but tricky solution than PR#69.
   class Quantifier
-    MODES = [:greedy, :possessive, :reluctant]
+    include Regexp::Expression::Shared
 
-    attr_reader :token, :text, :min, :max, :mode
+    MODES = %i[greedy possessive reluctant]
 
-    def initialize(token, text, min, max, mode)
-      @token = token
-      @text  = text
-      @mode  = mode
-      @min   = min
-      @max   = max
-    end
-
-    def initialize_clone(orig)
-      @text = orig.text.dup
-      super
-    end
+    def initialize(*args)
+      deprecated_old_init(*args) and return if args.count == 4 || args.count == 5
 
-    def to_s
-      text.dup
+      init_from_token_and_options(*args)
+      # TODO: remove in v3.0.0, stop removing parts of #token (?)
+      self.token = token.to_s.sub(/_(greedy|possessive|reluctant)/, '').to_sym
     end
-    alias :to_str :to_s
 
     def to_h
       {
@@ -40,5 +34,51 @@ module Regexp::Expression
       RUBY
     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)
+      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` "\
+           "with `::Regexp::Token.new(:quantifier, token, text)`. min, max, and mode "\
+           "will be derived automatically.\n"\
+           "Or do `exp.quantifier = #{self.class}.construct(token: token, text: str)`.\n"\
+           "This is consistent with how Expression::Base instances are created. "
+      @token = token
+      @text  = text
+    end
+
+    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
 end

data/lib/regexp_parser/expression/sequence.rb

@@ -1,5 +1,4 @@
 module Regexp::Expression
-
   # A sequence of expressions. Differs from a Subexpressions by how it handles
   # quantifiers, as it applies them to its last element instead of itself as
   # a whole subexpression.
@@ -7,61 +6,26 @@ module Regexp::Expression
   # Used as the base class for the Alternation alternatives, Conditional
   # branches, and CharacterSet::Intersection intersected sequences.
   class Sequence < Regexp::Expression::Subexpression
-    # TODO: this override is here for backwards compatibility, remove in 2.0.0
-    def initialize(*args)
-      if args.count == 3
-        warn('WARNING: Sequence.new without a Regexp::Token argument is '\
-             'deprecated and will be removed in 2.0.0.')
-        return self.class.at_levels(*args)
-      end
-      super
-    end
-
     class << self
-      def add_to(subexpression, params = {}, active_opts = {})
-        sequence = at_levels(
-          subexpression.level,
-          subexpression.set_level,
-          params[:conditional_level] || subexpression.conditional_level
+      def add_to(exp, params = {}, active_opts = {})
+        sequence = construct(
+          level:             exp.level,
+          set_level:         exp.set_level,
+          conditional_level: params[:conditional_level] || exp.conditional_level,
+          ts:                params[:ts],
         )
-        sequence.nesting_level = subexpression.nesting_level + 1
         sequence.options = active_opts
-        subexpression.expressions << sequence
+        exp.expressions << sequence
         sequence
       end
-
-      def at_levels(level, set_level, conditional_level)
-        token = Regexp::Token.new(
-          :expression,
-          :sequence,
-          '',
-          nil, # ts
-          nil, # te
-          level,
-          set_level,
-          conditional_level
-        )
-        new(token)
-      end
     end
 
-    def starts_at
-      expressions.first.starts_at
+    def ts
+      (head = expressions.first) ? head.ts : @ts
     end
-    alias :ts :starts_at
-
-    def quantify(token, text, min = nil, max = nil, mode = :greedy)
-      offset = -1
-      target = expressions[offset]
-      while target.is_a?(FreeSpace)
-        target = expressions[offset -= 1]
-      end
 
-      target || raise(ArgumentError, "No valid target found for '#{text}' "\
-                                     'quantifier')
-
-      target.quantify(token, text, min, max, mode)
+    def quantify(token, *args)
+      extract_quantifier_target(token.text).quantify(token, *args)
     end
   end
-
 end

data/lib/regexp_parser/expression/sequence_operation.rb

@@ -5,21 +5,16 @@ module Regexp::Expression
     alias :operands :expressions
     alias :operator :text
 
-    def starts_at
-      expressions.first.starts_at
+    def ts
+      (head = expressions.first) ? head.ts : @ts
     end
-    alias :ts :starts_at
 
     def <<(exp)
       expressions.last << exp
     end
 
-    def add_sequence(active_opts = {})
-      self.class::OPERAND.add_to(self, {}, active_opts)
-    end
-
-    def to_s(format = :full)
-      sequences.map { |e| e.to_s(format) }.join(text)
+    def add_sequence(active_opts = {}, params = { ts: 0 })
+      self.class::OPERAND.add_to(self, params, active_opts)
     end
   end
 end

data/lib/regexp_parser/expression/shared.rb

@@ -0,0 +1,111 @@
+module Regexp::Expression
+  module Shared
+    module ClassMethods; end # filled in ./methods/*.rb
+
+    def self.included(mod)
+      mod.class_eval do
+        extend Shared::ClassMethods
+
+        attr_accessor :type, :token, :text, :ts, :te,
+                      :level, :set_level, :conditional_level,
+                      :options, :parent,
+                      :custom_to_s_handling, :pre_quantifier_decorations
+
+        attr_reader   :nesting_level, :quantifier
+      end
+    end
+
+    def init_from_token_and_options(token, options = {})
+      self.type              = token.type
+      self.token             = token.token
+      self.text              = token.text
+      self.ts                = token.ts
+      self.te                = token.te
+      self.level             = token.level
+      self.set_level         = token.set_level
+      self.conditional_level = token.conditional_level
+      self.nesting_level     = 0
+      self.options           = options || {}
+    end
+    private :init_from_token_and_options
+
+    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
+      self.parent     = nil # updated by Subexpression#initialize_copy
+      if orig.pre_quantifier_decorations
+        self.pre_quantifier_decorations = orig.pre_quantifier_decorations.map(&:dup)
+      end
+      super
+    end
+
+    def starts_at
+      ts
+    end
+
+    def ends_at(include_quantifier = true)
+      ts + (include_quantifier ? full_length : base_length)
+    end
+
+    def base_length
+      to_s(:base).length
+    end
+
+    def full_length
+      to_s(:original).length
+    end
+
+    # #to_s reproduces the original source, as an unparser would.
+    #
+    # It takes an optional format argument.
+    #
+    # Example:
+    #
+    # lit = Regexp::Parser.parse(/a +/x)[0]
+    #
+    # lit.to_s            # => 'a+'  # default; with quantifier
+    # lit.to_s(:full)     # => 'a+'  # default; with quantifier
+    # lit.to_s(:base)     # => 'a'   # without quantifier
+    # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
+    #
+    def to_s(format = :full)
+      base = parts.each_with_object(''.dup) do |part, buff|
+        if part.instance_of?(String)
+          buff << part
+        elsif !part.custom_to_s_handling
+          buff << part.to_s(:original)
+        end
+      end
+      "#{base}#{pre_quantifier_decoration(format)}#{quantifier_affix(format)}"
+    end
+    alias :to_str :to_s
+
+    def pre_quantifier_decoration(expression_format = :original)
+      pre_quantifier_decorations.to_a.join if expression_format == :original
+    end
+
+    def quantifier_affix(expression_format = :full)
+      quantifier.to_s if quantified? && expression_format != :base
+    end
+
+    def offset
+      [starts_at, full_length]
+    end
+
+    def coded_offset
+      '@%d+%d' % offset
+    end
+
+    def nesting_level=(lvl)
+      @nesting_level = lvl
+      quantifier && quantifier.nesting_level = lvl
+      terminal? || each { |subexp| subexp.nesting_level = lvl + 1 }
+    end
+
+    def quantifier=(qtf)
+      @quantifier = qtf
+      @repetitions = nil # clear memoized value
+    end
+  end
+end

data/lib/regexp_parser/expression/subexpression.rb

@@ -1,29 +1,25 @@
 module Regexp::Expression
-
   class Subexpression < Regexp::Expression::Base
     include Enumerable
 
     attr_accessor :expressions
 
     def initialize(token, options = {})
-      super
-
       self.expressions = []
+      super
     end
 
     # Override base method to clone the expressions as well.
-    def initialize_clone(orig)
-      self.expressions = orig.expressions.map(&:clone)
+    def initialize_copy(orig)
+      self.expressions = orig.expressions.map do |exp|
+        exp.clone.tap { |copy| copy.parent = self }
+      end
       super
     end
 
     def <<(exp)
-      if exp.is_a?(WhiteSpace) && last && last.is_a?(WhiteSpace)
-        last.merge(exp)
-      else
-        exp.nesting_level = nesting_level + 1
-        expressions << exp
-      end
+      exp.parent = self
+      expressions << exp
     end
 
     %w[[] at each empty? fetch index join last length values_at].each do |method|
@@ -41,19 +37,31 @@ module Regexp::Expression
     end
 
     def te
-      ts + to_s.length
-    end
-
-    def to_s(format = :full)
-      # Note: the format does not get passed down to subexpressions.
-      "#{expressions.join}#{quantifier_affix(format)}"
+      ts + base_length
     end
 
     def to_h
-      attributes.merge({
+      attributes.merge(
         text:        to_s(:base),
         expressions: expressions.map(&:to_h)
-      })
+      )
+    end
+
+    def extract_quantifier_target(quantifier_description)
+      pre_quantifier_decorations = []
+      target = expressions.reverse.find do |exp|
+        if exp.decorative?
+          exp.custom_to_s_handling = true
+          pre_quantifier_decorations << exp.text
+          next
+        end
+        exp
+      end
+      target or raise Regexp::Parser::ParserError,
+        "No valid target found for '#{quantifier_description}' quantifier"
+
+      target.pre_quantifier_decorations = pre_quantifier_decorations
+      target
     end
   end
 end

data/lib/regexp_parser/expression.rb

@@ -1,138 +1,7 @@
-module Regexp::Expression
-
-  class Base
-    attr_accessor :type, :token
-    attr_accessor :text, :ts
-    attr_accessor :level, :set_level, :conditional_level, :nesting_level
-
-    attr_accessor :quantifier
-    attr_accessor :options
-
-    def initialize(token, options = {})
-      self.type              = token.type
-      self.token             = token.token
-      self.text              = token.text
-      self.ts                = token.ts
-      self.level             = token.level
-      self.set_level         = token.set_level
-      self.conditional_level = token.conditional_level
-      self.nesting_level     = 0
-      self.quantifier        = nil
-      self.options           = options
-    end
-
-    def initialize_clone(orig)
-      self.text       = (orig.text       ? orig.text.dup         : nil)
-      self.options    = (orig.options    ? orig.options.dup      : nil)
-      self.quantifier = (orig.quantifier ? orig.quantifier.clone : nil)
-      super
-    end
-
-    def to_re(format = :full)
-      ::Regexp.new(to_s(format))
-    end
-
-    alias :starts_at :ts
-
-    def full_length
-      to_s.length
-    end
-
-    def offset
-      [starts_at, full_length]
-    end
-
-    def coded_offset
-      '@%d+%d' % offset
-    end
-
-    def to_s(format = :full)
-      "#{text}#{quantifier_affix(format)}"
-    end
-
-    def quantifier_affix(expression_format)
-      quantifier.to_s if quantified? && expression_format != :base
-    end
-
-    def terminal?
-      !respond_to?(:expressions)
-    end
-
-    def quantify(token, text, min = nil, max = nil, mode = :greedy)
-      self.quantifier = Quantifier.new(token, text, min, max, mode)
-    end
-
-    def unquantified_clone
-      clone.tap { |exp| exp.quantifier = nil }
-    end
-
-    def quantified?
-      !quantifier.nil?
-    end
-
-    # Deprecated. Prefer `#repetitions` which has a more uniform interface.
-    def quantity
-      return [nil,nil] unless quantified?
-      [quantifier.min, quantifier.max]
-    end
-
-    def repetitions
-      return 1..1 unless quantified?
-      min = quantifier.min
-      max = quantifier.max < 0 ? Float::INFINITY : quantifier.max
-      # fix Range#minmax - https://bugs.ruby-lang.org/issues/15807
-      (min..max).tap { |r| r.define_singleton_method(:minmax) { [min, max] } }
-    end
-
-    def greedy?
-      quantified? and quantifier.greedy?
-    end
-
-    def reluctant?
-      quantified? and quantifier.reluctant?
-    end
-    alias :lazy? :reluctant?
-
-    def possessive?
-      quantified? and quantifier.possessive?
-    end
-
-    def attributes
-      {
-        type:              type,
-        token:             token,
-        text:              to_s(:base),
-        starts_at:         ts,
-        length:            full_length,
-        level:             level,
-        set_level:         set_level,
-        conditional_level: conditional_level,
-        options:           options,
-        quantifier:        quantified? ? quantifier.to_h : nil,
-      }
-    end
-    alias :to_h :attributes
-  end
-
-  def self.parsed(exp)
-    warn('WARNING: Regexp::Expression::Base.parsed is buggy and '\
-         'will be removed in 2.0.0. Use Regexp::Parser.parse instead.')
-    case exp
-    when String
-      Regexp::Parser.parse(exp)
-    when Regexp
-      Regexp::Parser.parse(exp.source) # <- causes loss of root options
-    when Regexp::Expression            # <- never triggers
-      exp
-    else
-      raise ArgumentError, 'Expression.parsed accepts a String, Regexp, or '\
-                           'a Regexp::Expression as a value for exp, but it '\
-                           "was given #{exp.class.name}."
-    end
-  end
-
-end # module Regexp::Expression
+require 'regexp_parser/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'
@@ -140,24 +9,28 @@ require 'regexp_parser/expression/sequence_operation'
 
 require 'regexp_parser/expression/classes/alternation'
 require 'regexp_parser/expression/classes/anchor'
-require 'regexp_parser/expression/classes/backref'
+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'
+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/property'
 require 'regexp_parser/expression/classes/root'
-require 'regexp_parser/expression/classes/set'
-require 'regexp_parser/expression/classes/set/intersection'
-require 'regexp_parser/expression/classes/set/range'
-require 'regexp_parser/expression/classes/type'
+require 'regexp_parser/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/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'