regexp_parser 1.0.0 → 1.2.0

data/lib/regexp_parser/expression/quantifier.rb

@@ -1,6 +1,7 @@
 module Regexp::Expression
-
   class Quantifier
+    MODES = [:greedy, :possessive, :reluctant]
+
     attr_reader :token, :text, :min, :max, :mode
 
     def initialize(token, text, min, max, mode)
@@ -30,6 +31,14 @@ module Regexp::Expression
         max:   max,
       }
     end
-  end
 
+    MODES.each do |mode|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{mode}?
+          mode.equal?(:#{mode})
+        end
+      RUBY
+    end
+    alias :lazy? :reluctant?
+  end
 end

data/lib/regexp_parser/expression/sequence.rb

@@ -4,20 +4,44 @@ module Regexp::Expression
   # quantifiers, as it applies them to its last element instead of itself as
   # a whole subexpression.
   #
-  # Used as the base class for the Alternation alternatives and Conditional
-  # branches.
+  # Used as the base class for the Alternation alternatives, Conditional
+  # branches, and CharacterSet::Intersection intersected sequences.
   class Sequence < Regexp::Expression::Subexpression
-    def initialize(level, set_level, conditional_level)
-      super Regexp::Token.new(
-        :expression,
-        :sequence,
-        '',
-        nil, # ts
-        nil, # te
-        level,
-        set_level,
-        conditional_level
-      )
+    # 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, options = {})
+        sequence = at_levels(
+          subexpression.level,
+          subexpression.set_level,
+          options[:conditional_level] || subexpression.conditional_level
+        )
+        sequence.nesting_level = subexpression.nesting_level + 1
+        subexpression.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 text

data/lib/regexp_parser/expression/sequence_operation.rb

@@ -15,20 +15,15 @@ module Regexp::Expression
     end
 
     def add_sequence
-      exp = self.class::OPERAND.new(level, set_level, conditional_level)
-      exp.nesting_level = nesting_level + 1
-      expressions << exp
-      exp
+      self.class::OPERAND.add_to(self)
     end
 
     def quantify(token, text, min = nil, max = nil, mode = :greedy)
       sequences.last.last.quantify(token, text, min, max, mode)
-      sequences.last.last.quantify(token, text, min, max, mode)
     end
 
     def to_s(format = :full)
       sequences.map { |e| e.to_s(format) }.join(text)
-      sequences.map { |e| e.to_s(format) }.join(text)
     end
   end
 end

data/lib/regexp_parser/expression/subexpression.rb

@@ -1,6 +1,8 @@
 module Regexp::Expression
 
   class Subexpression < Regexp::Expression::Base
+    include Enumerable
+
     attr_accessor :expressions
 
     def initialize(token, options = {})
@@ -24,9 +26,18 @@ module Regexp::Expression
       end
     end
 
-    %w[[] all? any? at collect count each each_with_index empty?
-       fetch find first index join last length map values_at].each do |m|
-      define_method(m) { |*args, &block| expressions.send(m, *args, &block) }
+    %w[[] at each empty? fetch index join last length values_at].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          expressions.#{method}(*args, &block)
+        end
+      RUBY
+    end
+
+    def dig(*indices)
+      exp = self
+      indices.each { |idx| exp = exp.nil? || exp.terminal? ? nil : exp[idx] }
+      exp
     end
 
     def te
@@ -41,7 +52,7 @@ module Regexp::Expression
     end
 
     def to_h
-      super.merge({
+      attributes.merge({
         text:        to_s(:base),
         expressions: expressions.map(&:to_h)
       })

data/lib/regexp_parser/parser.rb

@@ -23,7 +23,7 @@ class Regexp::Parser
   end
 
   def parse(input, syntax = "ruby/#{RUBY_VERSION}", &block)
-    root = Root.new(options_from_input(input))
+    root = Root.build(options_from_input(input))
 
     self.root = root
     self.node = root
@@ -89,8 +89,7 @@ class Regexp::Parser
 
   def nest_conditional(exp)
     conditional_nesting.push(exp)
-    node << exp
-    self.node = exp
+    nest(exp)
   end
 
   def parse_token(token)
@@ -216,6 +215,7 @@ class Regexp::Parser
       self.node = conditional_nesting.last.branches.last
     when :close
       conditional_nesting.pop
+      decrease_nesting
 
       self.node =
         if conditional_nesting.empty?
@@ -496,25 +496,34 @@ class Regexp::Parser
     negative ||= ''
     self.switching_options = token.token.equal?(:options_switch)
 
-    new_options = active_opts.dup
+    opt_changes = {}
+    new_active_opts = active_opts.dup
 
     # Negative options have precedence. E.g. /(?i-i)a/ is case-sensitive.
     %w[i m x].each do |flag|
-      new_options[flag.to_sym] = true if positive.include?(flag)
-      new_options.delete(flag.to_sym) if negative.include?(flag)
+      if positive.include?(flag)
+        opt_changes[flag.to_sym] = new_active_opts[flag.to_sym] = true
+      end
+      if negative.include?(flag)
+        opt_changes[flag.to_sym] = false
+        new_active_opts.delete(flag.to_sym)
+      end
     end
 
     # Any encoding flag overrides all previous encoding flags. If there are
     # multiple encoding flags in an options string, the last one wins.
     # E.g. /(?dau)\w/ matches UTF8 chars but /(?dua)\w/ only ASCII chars.
     if (flag = positive.reverse[/[adu]/])
-      %w[a d u].each { |key| new_options.delete(key.to_sym) }
-      new_options[flag.to_sym] = true
+      %w[a d u].each { |key| new_active_opts.delete(key.to_sym) }
+      opt_changes[flag.to_sym] = new_active_opts[flag.to_sym] = true
     end
 
-    options_stack << new_options
+    options_stack << new_active_opts
+
+    options_group = Group::Options.new(token, active_opts)
+    options_group.option_changes = opt_changes
 
-    nest(Group::Options.new(token, active_opts))
+    nest(options_group)
   end
 
   def open_group(token)

data/lib/regexp_parser/scanner.rb

@@ -2131,14 +2131,14 @@ te = p+1
       when /^\\([gk])''/ # single quotes
         empty_backref_error("ref/call (sq)")
 
-      when /^\\([gk])<[^\d-](\w+)?>/ # angle-brackets
+      when /^\\([gk])<[^\d+-]\w*>/ # angle-brackets
         if $1 == 'k'
           emit(:backref, :name_ref_ab, text, ts, te)
         else
           emit(:backref, :name_call_ab, text, ts, te)
         end
 
-      when /^\\([gk])'[^\d-](\w+)?'/ #single quotes
+      when /^\\([gk])'[^\d+-]\w*'/ #single quotes
         if $1 == 'k'
           emit(:backref, :name_ref_sq, text, ts, te)
         else
@@ -2159,30 +2159,30 @@ te = p+1
           emit(:backref, :number_call_sq, text, ts, te)
         end
 
-      when /^\\([gk])<-\d+>/ # angle-brackets
+      when /^\\(?:g<\+|g<-|(k)<-)\d+>/ # angle-brackets
         if $1 == 'k'
           emit(:backref, :number_rel_ref_ab, text, ts, te)
         else
           emit(:backref, :number_rel_call_ab, text, ts, te)
         end
 
-      when /^\\([gk])'-\d+'/ # single quotes
+      when /^\\(?:g'\+|g'-|(k)'-)\d+'/ # single quotes
         if $1 == 'k'
           emit(:backref, :number_rel_ref_sq, text, ts, te)
         else
           emit(:backref, :number_rel_call_sq, text, ts, te)
         end
 
-      when /^\\k<[^\d-](\w+)?[+\-]\d+>/ # angle-brackets
+      when /^\\k<[^\d+\-]\w*[+\-]\d+>/ # angle-brackets
         emit(:backref, :name_recursion_ref_ab, text, ts, te)
 
-      when /^\\k'[^\d-](\w+)?[+\-]\d+'/ # single-quotes
+      when /^\\k'[^\d+\-]\w*[+\-]\d+'/ # single-quotes
         emit(:backref, :name_recursion_ref_sq, text, ts, te)
 
-      when /^\\([gk])<-?\d+[+\-]\d+>/ # angle-brackets
+      when /^\\([gk])<[+\-]?\d+[+\-]\d+>/ # angle-brackets
         emit(:backref, :number_recursion_ref_ab, text, ts, te)
 
-      when /^\\([gk])'-?\d+[+\-]\d+'/ # single-quotes
+      when /^\\([gk])'[+\-]?\d+[+\-]\d+'/ # single-quotes
         emit(:backref, :number_recursion_ref_sq, text, ts, te)
 
       else

data/lib/regexp_parser/scanner/scanner.rl

@@ -582,14 +582,14 @@
       when /^\\([gk])''/ # single quotes
         empty_backref_error("ref/call (sq)")
 
-      when /^\\([gk])<[^\d-](\w+)?>/ # angle-brackets
+      when /^\\([gk])<[^\d+-]\w*>/ # angle-brackets
         if $1 == 'k'
           emit(:backref, :name_ref_ab, text, ts, te)
         else
           emit(:backref, :name_call_ab, text, ts, te)
         end
 
-      when /^\\([gk])'[^\d-](\w+)?'/ #single quotes
+      when /^\\([gk])'[^\d+-]\w*'/ #single quotes
         if $1 == 'k'
           emit(:backref, :name_ref_sq, text, ts, te)
         else
@@ -610,30 +610,30 @@
           emit(:backref, :number_call_sq, text, ts, te)
         end
 
-      when /^\\([gk])<-\d+>/ # angle-brackets
+      when /^\\(?:g<\+|g<-|(k)<-)\d+>/ # angle-brackets
         if $1 == 'k'
           emit(:backref, :number_rel_ref_ab, text, ts, te)
         else
           emit(:backref, :number_rel_call_ab, text, ts, te)
         end
 
-      when /^\\([gk])'-\d+'/ # single quotes
+      when /^\\(?:g'\+|g'-|(k)'-)\d+'/ # single quotes
         if $1 == 'k'
           emit(:backref, :number_rel_ref_sq, text, ts, te)
         else
           emit(:backref, :number_rel_call_sq, text, ts, te)
         end
 
-      when /^\\k<[^\d-](\w+)?[+\-]\d+>/ # angle-brackets
+      when /^\\k<[^\d+\-]\w*[+\-]\d+>/ # angle-brackets
         emit(:backref, :name_recursion_ref_ab, text, ts, te)
 
-      when /^\\k'[^\d-](\w+)?[+\-]\d+'/ # single-quotes
+      when /^\\k'[^\d+\-]\w*[+\-]\d+'/ # single-quotes
         emit(:backref, :name_recursion_ref_sq, text, ts, te)
 
-      when /^\\([gk])<-?\d+[+\-]\d+>/ # angle-brackets
+      when /^\\([gk])<[+\-]?\d+[+\-]\d+>/ # angle-brackets
         emit(:backref, :number_recursion_ref_ab, text, ts, te)
 
-      when /^\\([gk])'-?\d+[+\-]\d+'/ # single-quotes
+      when /^\\([gk])'[+\-]?\d+[+\-]\d+'/ # single-quotes
         emit(:backref, :number_recursion_ref_sq, text, ts, te)
 
       else

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.0.0'
+    VERSION = '1.2.0'
   end
 end

data/test/expression/test_subexpression.rb

@@ -46,4 +46,13 @@ class ExpressionSubexpression < Test::Unit::TestCase
 
     assert tests.empty?
   end
+
+  def test_subexpression_dig
+    root = RP.parse(/(((a)))/)
+
+    assert_equal '(((a)))', root.dig(0).to_s
+    assert_equal 'a',       root.dig(0, 0, 0, 0).to_s
+    assert_nil              root.dig(0, 0, 0, 0, 0)
+    assert_nil              root.dig(3, 7)
+  end
 end

data/test/lexer/test_refcalls.rb

@@ -26,6 +26,9 @@ class LexerRefCalls < Test::Unit::TestCase
     '(abc)\g<-1>'     => [3, :backref, :number_rel_call,    '\g<-1>',     5, 11, 0, 0, 0],
     "(abc)\\g'-1'"    => [3, :backref, :number_rel_call,    "\\g'-1'",    5, 11, 0, 0, 0],
 
+    '(abc)\g<+1>'     => [3, :backref, :number_rel_call,    '\g<+1>',     5, 11, 0, 0, 0],
+    "(abc)\\g'+1'"    => [3, :backref, :number_rel_call,    "\\g'+1'",    5, 11, 0, 0, 0],
+
     # Group back-references, with nesting level
     '(?<X>abc)\k<X-0>'  => [3, :backref, :name_recursion_ref,    '\k<X-0>',    9, 16, 0, 0, 0],
     "(?<X>abc)\\k'X-0'" => [3, :backref, :name_recursion_ref,    "\\k'X-0'",   9, 16, 0, 0, 0],

data/test/parser/test_all.rb

@@ -1,9 +1,9 @@
 require File.expand_path("../../helpers", __FILE__)
 
-%w{
+%w[
   alternation anchors errors escapes free_space groups
   posix_classes properties quantifiers refcalls sets types
-}.each do|tc|
+].each do |tc|
   require File.expand_path("../test_#{tc}", __FILE__)
 end
 
@@ -11,7 +11,7 @@ require File.expand_path('../set/test_ranges.rb', __FILE__)
 require File.expand_path('../set/test_intersections.rb', __FILE__)
 
 if RUBY_VERSION >= '2.0.0'
-  %w{conditionals keep}.each do|tc|
+  %w[conditionals keep].each do |tc|
     require File.expand_path("../test_#{tc}", __FILE__)
   end
 end

data/test/parser/test_conditionals.rb

@@ -11,12 +11,12 @@ class TestParserConditionals < Test::Unit::TestCase
     assert exp.is_a?(Conditional::Expression),
            "Expected Condition, but got #{exp.class.name}"
 
-    assert_equal exp.type,   :conditional
-    assert_equal exp.token,  :open
-    assert_equal exp.text,   '(?'
+    assert_equal exp.type,      :conditional
+    assert_equal exp.token,     :open
+    assert_equal exp.text,      '(?'
+    assert_equal exp.reference, 'A'
   end
 
-
   def test_parse_conditional_condition
     regexp = /(?<A>a)(?(<A>)T|F)/
 
@@ -26,11 +26,26 @@ class TestParserConditionals < Test::Unit::TestCase
     assert exp.is_a?(Conditional::Condition),
            "Expected Condition, but got #{exp.class.name}"
 
-    assert_equal exp.type,   :conditional
-    assert_equal exp.token,  :condition
-    assert_equal exp.text,   '(<A>)'
+    assert_equal exp.type,      :conditional
+    assert_equal exp.token,     :condition
+    assert_equal exp.text,      '(<A>)'
+    assert_equal exp.reference, 'A'
   end
 
+  def test_parse_conditional_condition_with_number_ref
+    regexp = /(a)(?(1)T|F)/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    exp  = root[1].condition
+
+    assert exp.is_a?(Conditional::Condition),
+           "Expected Condition, but got #{exp.class.name}"
+
+    assert_equal exp.type,      :conditional
+    assert_equal exp.token,     :condition
+    assert_equal exp.text,      '(1)'
+    assert_equal exp.reference, 1
+  end
 
   def test_parse_conditional_nested_groups
     regexp = /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/
@@ -91,7 +106,6 @@ class TestParserConditionals < Test::Unit::TestCase
     end
   end
 
-
   def test_parse_conditional_nested_alternation
     regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
 
@@ -114,7 +128,6 @@ class TestParserConditionals < Test::Unit::TestCase
     end
   end
 
-
   def test_parse_conditional_extra_separator
     regexp = /(?<A>a)(?(<A>)T|)/
 
@@ -137,6 +150,31 @@ class TestParserConditionals < Test::Unit::TestCase
     assert_equal '',  seq_2.to_s
   end
 
+  def test_parse_conditional_quantified
+    regexp = /(foo)(?(1)\d|(\w)){42}/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    conditional = root[1]
+
+    assert conditional.quantified?
+    assert_equal '{42}',              conditional.quantifier.text
+    assert_equal '(?(1)\d|(\w)){42}', conditional.to_s
+    refute conditional.branches.any?(&:quantified?)
+  end
+
+  def test_parse_conditional_branch_content_quantified
+    regexp = /(foo)(?(1)\d{23}|(\w){42})/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    conditional = root[1]
+
+    refute conditional.quantified?
+    refute conditional.branches.any?(&:quantified?)
+    assert conditional.branches[0][0].quantified?
+    assert_equal '{23}', conditional.branches[0][0].quantifier.text
+    assert conditional.branches[1][0].quantified?
+    assert_equal '{42}', conditional.branches[1][0].quantifier.text
+  end
 
   # For source (text) expressions only, ruby raises an error otherwise.
   def test_parse_conditional_excessive_branches
@@ -146,5 +184,4 @@ class TestParserConditionals < Test::Unit::TestCase
       RP.parse(regexp, 'ruby/2.0')
     }
   end
-
 end