regexp_parser 2.1.1 → 2.5.0

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

@@ -1,7 +1,3 @@
 module Regexp::Expression
-
-  class Literal < Regexp::Expression::Base
-    # Obviously nothing special here, yet.
-  end
-
+  class Literal < Regexp::Expression::Base; end
 end

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

@@ -1,12 +1,9 @@
 module Regexp::Expression
-
   class Root < Regexp::Expression::Subexpression
     def self.build(options = {})
-      new(build_token, options)
-    end
-
-    def self.build_token
-      Regexp::Token.new(:expression, :root, '', 0)
+      warn "`#{self.class}.build(options)` is deprecated and will raise in "\
+           "regexp_parser v3.0.0. Please use `.construct(options: options)`."
+      construct(options: options)
     end
   end
 end

data/lib/regexp_parser/expression/classes/{property.rb → unicode_property.rb}

@@ -1,5 +1,5 @@
 module Regexp::Expression
-
+  # TODO: unify name with token :property, on way or the other, in v3.0.0
   module UnicodeProperty
     class Base < Regexp::Expression::Base
       def negative?
@@ -116,5 +116,4 @@ module Regexp::Expression
     class Script  < UnicodeProperty::Base; end
     class Block   < UnicodeProperty::Base; end
   end
-
 end # module Regexp::Expression

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

@@ -0,0 +1,43 @@
+module Regexp::Expression
+  module Shared
+    module ClassMethods
+      # Convenience method to init a valid Expression without a Regexp::Token
+      def construct(params = {})
+        attrs = construct_defaults.merge(params)
+        options = attrs.delete(:options)
+        token_args = Regexp::TOKEN_KEYS.map { |k| attrs.delete(k) }
+        token = Regexp::Token.new(*token_args)
+        raise ArgumentError, "unsupported attribute(s): #{attrs}" if attrs.any?
+
+        new(token, options)
+      end
+
+      def construct_defaults
+        if self == Root
+          { type: :expression, token: :root, ts: 0 }
+        elsif self < Sequence
+          { type: :expression, token: :sequence }
+        else
+          { type: token_class::Type }
+        end.merge(level: 0, set_level: 0, conditional_level: 0, text: '')
+      end
+
+      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
+          Regexp::Syntax::Token::Meta
+        elsif self <= EscapeSequence::Base
+          Regexp::Syntax::Token::Escape
+        else
+          Regexp::Syntax::Token.const_get(name.split('::')[2])
+        end
+      end
+    end
+
+    def token_class
+      self.class.token_class
+    end
+  end
+end

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

@@ -112,7 +112,7 @@ module Regexp::Expression
     end
 
     def inner_match_length
-      dummy = Regexp::Expression::Root.build
+      dummy = Regexp::Expression::Root.construct
       dummy.expressions = expressions.map(&:clone)
       dummy.quantifier = quantifier && quantifier.clone
       dummy.match_length

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

@@ -43,7 +43,7 @@ module Regexp::Expression
 
       # Order is important! Fields that use other fields in their
       # definition must appear before the fields they use.
-      part_keys = %w{a m b o i l x s e S y k c q Q z Z t ~t T >}
+      part_keys = %w[a m b o i l x s e S y k c q Q z Z t ~t T >]
       part.keys.each {|k| part[k] = "<?#{k}?>"}
 
       part['>'] = print_level ? ('  ' * (print_level + indent_offset)) : ''

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

@@ -1,5 +1,5 @@
 module Regexp::Expression
-  class Base
+  module Shared
 
     # Test if this expression has the given test_type, which can be either
     # a symbol or an array of symbols to check against the expression's type.
@@ -93,5 +93,14 @@ module Regexp::Expression
               "Array, Hash, or Symbol expected, #{scope.class.name} given"
       end
     end
+
+    # Deep-compare two expressions for equality.
+    def ==(other)
+      other.class == self.class &&
+        other.to_s == to_s &&
+        other.options == options
+    end
+    alias :=== :==
+    alias :eql? :==
   end
 end

data/lib/regexp_parser/expression/quantifier.rb

@@ -1,26 +1,24 @@
 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
+    attr_reader :min, :max, :mode
 
-    def initialize_copy(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)
+      @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
-    alias :to_str :to_s
 
     def to_h
       {
@@ -41,13 +39,33 @@ module Regexp::Expression
     end
     alias :lazy? :reluctant?
 
-    def ==(other)
-      other.class == self.class &&
-        other.token == token &&
-        other.mode == mode &&
-        other.min == min &&
-        other.max == max
+    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
+      @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)]
+      end
     end
-    alias :eq :==
   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.
@@ -8,31 +7,17 @@ module Regexp::Expression
   # branches, and CharacterSet::Intersection intersected sequences.
   class Sequence < Regexp::Expression::Subexpression
     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,
         )
-        sequence.nesting_level = subexpression.nesting_level + 1
+        sequence.nesting_level = exp.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
@@ -40,12 +25,12 @@ module Regexp::Expression
     end
     alias :ts :starts_at
 
-    def quantify(token, text, min = nil, max = nil, mode = :greedy)
+    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(token, text, min, max, mode)
+      target.quantify(*args)
     end
   end
 end

data/lib/regexp_parser/expression/sequence_operation.rb

@@ -18,8 +18,8 @@ module Regexp::Expression
       self.class::OPERAND.add_to(self, {}, active_opts)
     end
 
-    def to_s(format = :full)
-      sequences.map { |e| e.to_s(format) }.join(text)
+    def parts
+      intersperse(expressions, text.dup)
     end
   end
 end

data/lib/regexp_parser/expression/shared.rb

@@ -0,0 +1,85 @@
+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, :quantifier
+
+        attr_reader   :nesting_level
+      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
+      super
+    end
+
+    def starts_at
+      ts
+    end
+
+    def base_length
+      to_s(:base).length
+    end
+
+    def full_length
+      to_s.length
+    end
+
+    def to_s(format = :full)
+      "#{parts.join}#{quantifier_affix(format)}"
+    end
+    alias :to_str :to_s
+
+    def parts
+      [text.dup]
+    end
+
+    def quantifier_affix(expression_format)
+      quantifier.to_s if quantified? && expression_format != :base
+    end
+
+    def quantified?
+      !quantifier.nil?
+    end
+
+    def offset
+      [starts_at, full_length]
+    end
+
+    def coded_offset
+      '@%d+%d' % offset
+    end
+
+    def terminal?
+      !respond_to?(:expressions)
+    end
+
+    def nesting_level=(lvl)
+      @nesting_level = lvl
+      quantifier && quantifier.nesting_level = lvl
+      terminal? || each { |subexp| subexp.nesting_level = lvl + 1 }
+    end
+  end
+end

data/lib/regexp_parser/expression/subexpression.rb

@@ -1,14 +1,12 @@
 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.
@@ -44,16 +42,21 @@ module Regexp::Expression
       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)}"
+    def parts
+      expressions
     end
 
     def to_h
-      attributes.merge({
+      attributes.merge(
         text:        to_s(:base),
         expressions: expressions.map(&:to_h)
-      })
+      )
+    end
+
+    private
+
+    def intersperse(expressions, separator)
+      expressions.flat_map { |exp| [exp, separator] }.slice(0...-1)
     end
   end
 end

data/lib/regexp_parser/expression.rb

@@ -1,130 +1,7 @@
 require 'regexp_parser/error'
 
-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_copy(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 base_length
-      to_s(:base).length
-    end
-
-    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
-      range = min..max
-      # fix Range#minmax on old Rubies - https://bugs.ruby-lang.org/issues/15807
-      if RUBY_VERSION.to_f < 2.7
-        range.define_singleton_method(:minmax) { [min, max] }
-      end
-      range
-    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
-
-end # module Regexp::Expression
-
+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'
@@ -132,21 +9,22 @@ 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/match'
 require 'regexp_parser/expression/methods/match_length'
 require 'regexp_parser/expression/methods/options'

data/lib/regexp_parser/lexer.rb

@@ -4,19 +4,21 @@
 # given syntax flavor.
 class Regexp::Lexer
 
-  OPENING_TOKENS = [
-    :capture, :passive, :lookahead, :nlookahead, :lookbehind, :nlookbehind,
-    :atomic, :options, :options_switch, :named, :absence
+  OPENING_TOKENS = %i[
+    capture passive lookahead nlookahead lookbehind nlookbehind
+    atomic options options_switch named absence
   ].freeze
 
-  CLOSING_TOKENS = [:close].freeze
+  CLOSING_TOKENS = %i[close].freeze
+
+  CONDITION_TOKENS = %i[condition condition_close].freeze
 
   def self.lex(input, syntax = "ruby/#{RUBY_VERSION}", options: nil, &block)
     new.lex(input, syntax, options: options, &block)
   end
 
   def lex(input, syntax = "ruby/#{RUBY_VERSION}", options: nil, &block)
-    syntax = Regexp::Syntax.new(syntax)
+    syntax = Regexp::Syntax.for(syntax)
 
     self.tokens = []
     self.nesting = 0
@@ -40,7 +42,7 @@ class Regexp::Lexer
                                   nesting, set_nesting, conditional_nesting)
 
       current = merge_condition(current) if type == :conditional and
-        [:condition, :condition_close].include?(token)
+        CONDITION_TOKENS.include?(token)
 
       last.next = current if last
       current.previous = last if last