regexp_parser 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a48ea55ff32a9a023b9f07c13590acbafa412fbb4e8289f4ac8b825c37f9dc5
-  data.tar.gz: 5fd466646d0e9cfc22cae4f4d4dce1e2647d066d49ad230d6f09a98f790c2be6
+  metadata.gz: 467bef34ff29198ccbde0063f1b2f62f03cf8237c46fe59be8f06e974c00c367
+  data.tar.gz: b876e662f889449954f0beeddedded8e462b4daec5fbb4692b65f9f7a012fec8
 SHA512:
-  metadata.gz: b1b26d0a1431ebd9a00423a98f58abfd5098e5f625b075270b13ed34c73e9b0bc74cdb6fb5b50ca84f6aad2786df86d2128ace3a7e645571a11656580ca64dfe
-  data.tar.gz: 1536cf6aaa222823fc5319a03aa67a7cc157d60a47ce41e70384d86a986c42de2f252a0c9ca7088b87cb1dd4d89a666d0d7080bf5e9d18e0c3e54b20aa9f5606
+  metadata.gz: b2064de034cf83f157da79225fc587374f744884f37934fd1828e4f3127bc45f899d62986495d9344fd4a5f2e96f7b2cf90c7961c0895fd0ee52ab8e24428d67
+  data.tar.gz: 146440a8fc9e2c48bb1bdedad539f6883ecbc5874276eb3e56876df7b74e42630ec789f6cc6b4ca7e79d5e6b2e986b5a2f5b2fc0be4d273c02d8ff62fa2cd35c

data/CHANGELOG.md

@@ -1,54 +1,71 @@
-## [Unreleased]
+## [1.1.0] - 2018-09-17 - [Janosch Müller](mailto:janosch84@gmail.com)
+
+### Added
+
+- Added `Quantifier` methods `#greedy?`, `#possessive?`, `#reluctant?`/`#lazy?`
+- Added `Group::Options#option_changes`
+  - shows the options enabled or disabled by the given options group
+  - as with all other expressions, `#options` shows the overall active options
+- Added `Conditional#reference` and `Condition#reference`, indicating the determinative group
+- Added `Subexpression#dig`, acts like [`Array#dig`](http://ruby-doc.org/core-2.5.0/Array.html#method-i-dig)
+
+### Fixed
+
+- Fixed parsing of quantified conditional expressions (quantifiers were assigned to the wrong expression)
+- Fixed scanning and parsing of forward-referring subexpression calls (e.g. `\g<+1>`)
+- `Root` and `Sequence` expressions now support the same constructor signature as all other expressions
+
+## [1.0.0] - 2018-09-01 - [Janosch Müller](mailto:janosch84@gmail.com)
 
 This release includes several breaking changes, mostly to character sets, #map and properties.
 
 ### Changed
 
 - Changed handling of sets (a.k.a. character classes or "bracket expressions")
-  * see PR #55 / issue #47 for details
+  * see PR [#55](https://github.com/ammar/regexp_parser/pull/55) / issue [#47](https://github.com/ammar/regexp_parser/issues/47) for details
   * sets are now parsed to expression trees like other nestable expressions
-  * #scan now emits the same tokens as outside sets (no longer :set, :member)
-  * CharacterSet#members has been removed
-  * new Range and Intersection classes represent corresponding syntax features
-  * a new PosixClass expression class represents e.g. [[:ascii:]]
-    * PosixClass instances behave like Property ones, e.g. support #negative?
-    * #scan emits :(non)posixclass, :<type> instead of :set, :char_(non)<type>
-- Changed Subexpression#map to act like regular Enumerable#map
-  * the old behavior is available as Subexpression#flat_map
-  * e.g. parse(/[a]/).map(&:to_s) == ["[a]"]; used to be ["[a]", "a"]
-- Changed Expression emissions for some escape sequences
-  * EscapeSequence::Codepoint, CodepointList, Hex and Octal are now all used
-  * they already existed, but were all parsed as EscapeSequence::Literal
-  * e.g. \x97 is now EscapeSequence::Hex instead of EscapeSequence::Literal
-- Changed naming of many property tokens (emitted for \p{...})
-  * if you work with these tokens, see PR #56 for details
-  * e.g. :punct_dash is now :dash_punctuation
-- Changed (?m) and the likes to emit as :options_switch token (@4ade4d1)
-  * allows differentiating from group-local :options, e.g. (?m:.)
-- Changed name of Backreference::..NestLevel to ..RecursionLevel (@4184339)
-- Changed Backreference::Number#number from String to Integer (@40a2231)
+  * `#scan` now emits the same tokens as outside sets (no longer `:set, :member`)
+  * `CharacterSet#members` has been removed
+  * new `Range` and `Intersection` classes represent corresponding syntax features
+  * a new `PosixClass` expression class represents e.g. `[[:ascii:]]`
+    * `PosixClass` instances behave like `Property` ones, e.g. support `#negative?`
+    * `#scan` emits `:(non)posixclass, :<type>` instead of `:set, :char_(non)<type>`
+- Changed `Subexpression#map` to act like regular `Enumerable#map`
+  * the old behavior is available as `Subexpression#flat_map`
+  * e.g. `parse(/[a]/).map(&:to_s) == ["[a]"]`; used to be `["[a]", "a"]`
+- Changed expression emissions for some escape sequences
+  * `EscapeSequence::Codepoint`, `CodepointList`, `Hex` and `Octal` are now all used
+  * they already existed, but were all parsed as `EscapeSequence::Literal`
+  * e.g. `\x97` is now `EscapeSequence::Hex` instead of `EscapeSequence::Literal`
+- Changed naming of many property tokens (emitted for `\p{...}`)
+  * if you work with these tokens, see PR [#56](https://github.com/ammar/regexp_parser/pull/56) for details
+  * e.g. `:punct_dash` is now `:dash_punctuation`
+- Changed `(?m)` and the likes to emit as `:options_switch` token (@4ade4d1)
+  * allows differentiating from group-local `:options`, e.g. `(?m:.)`
+- Changed name of `Backreference::..NestLevel` to `..RecursionLevel` (@4184339)
+- Changed B`ackreference::Number#number` from `String` to `Integer` (@40a2231)
 
 ### Added
 
 - Added support for all previously missing properties (about 250)
-- Added Expression::UnicodeProperty#shortcut (e.g. returns "m" for "\p{mark}")
-- Added #char(s) and #codepoint(s) methods to all EscapeSequence expressions
-- Added #number/#name/#recursion_level to all backref/call expressions (@174bf21)
-- Added #number and #number_at_level to capturing group expressions (@40a2231)
+- Added `Expression::UnicodeProperty#shortcut` (e.g. returns "m" for `\p{mark}`)
+- Added `#char(s)` and `#codepoint(s)` methods to all `EscapeSequence` expressions
+- Added `#number`/`#name`/`#recursion_level` to all backref/call expressions (@174bf21)
+- Added `#number` and `#number_at_level` to capturing group expressions (@40a2231)
 
 ### Fixed
 
-- Fixed ruby version mapping of some properties
+- Fixed Ruby version mapping of some properties
 - Fixed scanning of some property spellings, e.g. with dashes
 - Fixed some incorrect property alias normalizations
-- Fixed scanning of codepoint escapes with 6 digits (e.g. \u{10FFFF})
-- Fixed scanning of \R and \X within sets; they act as literals there
+- Fixed scanning of codepoint escapes with 6 digits (e.g. `\u{10FFFF}`)
+- Fixed scanning of `\R` and `\X` within sets; they act as literals there
 
 ## [0.5.0] - 2018-04-29 - [Janosch Müller](mailto:janosch84@gmail.com)
 
 ### Changed
 
-- Changed handling of Ruby versions (PR #53)
+- Changed handling of Ruby versions (PR [#53](https://github.com/ammar/regexp_parser/pull/53))
   * New Ruby versions are now supported by default
   * Some deep-lying APIs have changed, which should not affect most users:
     * `Regexp::Syntax::VERSIONS` is gone

data/README.md

@@ -317,7 +317,7 @@ _Note that not all of these are available in all versions of Ruby_
 | Syntax Feature                        | Examples                                                | ⋯ |
 | ------------------------------------- | ------------------------------------------------------- |:--------:|
 | **Alternation**                       | `a\|b\|c`                                               | ✓ |
-| **Anchors**                           | `^`, `$`, `\b`                                          | ✓ |
+| **Anchors**                           | `\A`, `^`, `\b`                                         | ✓ |
 | **Character Classes**                 | `[abc]`, `[^\\]`, `[a-d&&g-h]`, `[a=e=b]`               | ✓ |
 | **Character Types**                   | `\d`, `\H`, `\s`                                        | ✓ |
 | **Cluster Types**                     | `\R`, `\X`                                              | ✓ |
@@ -341,7 +341,7 @@ _Note that not all of these are available in all versions of Ruby_
 |   _**Capturing**_           | `(abc)`                                                 | ✓ |
 |   _**Comments**_            | `(?# comment text)`                                     | ✓ |
 | &emsp;&nbsp;_**Named**_               | `(?<name>abc)`, `(?'name'abc)`                          | &#x2713; |
-| &emsp;&nbsp;_**Options**_             | `(?mi-x:abc)`, `(?a:\s\w+)`                             | &#x2713; |
+| &emsp;&nbsp;_**Options**_             | `(?mi-x:abc)`, `(?a:\s\w+)`, `(?i)`                     | &#x2713; |
 | &emsp;&nbsp;_**Passive**_             | `(?:abc)`                                               | &#x2713; |
 | &emsp;&nbsp;_**Subexp. Calls**_       | `\g<name>`, `\g<1>`                                     | &#x2713; |
 | **Keep**                              | `\K`, `(ab\Kc\|d\Ke)f`                                  | &#x2713; |
@@ -357,14 +357,14 @@ _Note that not all of these are available in all versions of Ruby_
 | &emsp;&nbsp;_**Meta**_                | `\M-c`, `\M-\C-C`, `\M-\cC`, `\C-\M-C`, `\c\M-C`        | &#x2713; |
 | &emsp;&nbsp;_**Octal**_               | `\0`, `\01`, `\012`                                     | &#x2713; |
 | &emsp;&nbsp;_**Unicode**_             | `\uHHHH`, `\u{H+ H+}`                                   | &#x2713; |
-| **Unicode Properties**                | _<sub>([Unicode 7.0.0](http://www.unicode.org/versions/Unicode7.0.0/))</sub>_ | &#x22f1; |
-| &emsp;&nbsp;_**Age**_                 | `\p{Age=5.2}`, `\P{age=7.0}`                            | &#x2713; |
-| &emsp;&nbsp;_**Blocks**_              | `\p{InArmenian}`, `\P{InKhmer}`                         | &#x2713; |
-| &emsp;&nbsp;_**Classes**_             | `\p{Alpha}`, `\P{Space}`                                | &#x2713; |
-| &emsp;&nbsp;_**Derived**_             | `\p{Math}`, `\P{Lowercase}`                             | &#x2713; |
-| &emsp;&nbsp;_**General Categories**_  | `\p{Lu}`, `\P{Cs}`                                      | &#x2713; |
-| &emsp;&nbsp;_**Scripts**_             | `\p{Arabic}`, `\P{Hiragana}`                            | &#x2713; |
-| &emsp;&nbsp;_**Simple**_              | `\p{Dash}`, `\p{Extender}`                              | &#x2713; |
+| **Unicode Properties**                | _<sub>([Unicode 10.0.0](http://www.unicode.org/versions/Unicode10.0.0/))</sub>_ | &#x22f1; |
+| &emsp;&nbsp;_**Age**_                 | `\p{Age=5.2}`, `\P{age=7.0}`, `\p{^age=8.0}`            | &#x2713; |
+| &emsp;&nbsp;_**Blocks**_              | `\p{InArmenian}`, `\P{InKhmer}`, `\p{^InThai}`          | &#x2713; |
+| &emsp;&nbsp;_**Classes**_             | `\p{Alpha}`, `\P{Space}`, `\p{^Alnum}`                  | &#x2713; |
+| &emsp;&nbsp;_**Derived**_             | `\p{Math}`, `\P{Lowercase}`, `\p{^Cased}`               | &#x2713; |
+| &emsp;&nbsp;_**General Categories**_  | `\p{Lu}`, `\P{Cs}`, \p{^sc}                             | &#x2713; |
+| &emsp;&nbsp;_**Scripts**_             | `\p{Arabic}`, `\P{Hiragana}`, \p{^Greek}                | &#x2713; |
+| &emsp;&nbsp;_**Simple**_              | `\p{Dash}`, `\p{Extender}`, \p{^Hyphen}                 | &#x2713; |
 
 ##### Inapplicable Features
 

data/lib/regexp_parser/expression.rb

@@ -72,16 +72,16 @@ module Regexp::Expression
     end
 
     def greedy?
-      quantified? and quantifier.mode == :greedy
+      quantified? and quantifier.greedy?
     end
 
     def reluctant?
-      quantified? and quantifier.mode == :reluctant
+      quantified? and quantifier.reluctant?
     end
     alias :lazy? :reluctant?
 
     def possessive?
-      quantified? and quantifier.mode == :possessive
+      quantified? and quantifier.possessive?
     end
 
     def multiline?

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

@@ -1,5 +1,4 @@
 module Regexp::Expression
-
   module Conditional
     class TooManyBranches < StandardError
       def initialize
@@ -7,16 +6,19 @@ module Regexp::Expression
       end
     end
 
-    class Condition < Regexp::Expression::Base; end
-    class Branch    < Regexp::Expression::Sequence; end
+    class Condition < Regexp::Expression::Base
+      # 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
+    end
 
-    class Expression < Regexp::Expression::Subexpression
-      attr_reader :branches, :condition
+    class Branch < Regexp::Expression::Sequence; end
 
-      def initialize(token, options = {})
-        super
-        @branches  = []
-      end
+    class Expression < Regexp::Expression::Subexpression
+      attr_reader :condition
 
       def condition=(exp)
         @condition = exp
@@ -27,17 +29,18 @@ module Regexp::Expression
         expressions.last << exp
       end
 
-      def branch(exp = nil)
+      def add_sequence
         raise TooManyBranches.new if branches.length == 2
+        Branch.add_to(self, { conditional_level: conditional_level + 1 })
+      end
+      alias :branch :add_sequence
 
-        sequence = Branch.new(level, set_level, conditional_level + 1)
-
-        expressions << sequence
-        branches << expressions.last
+      def branches
+        expressions - [condition]
       end
 
-      def quantify(token, text, min = nil, max = nil, mode = :greedy)
-        branches.last.last.quantify(token, text, min, max, mode)
+      def reference
+        condition.reference
       end
 
       def to_s(_format = :full)
@@ -45,5 +48,4 @@ module Regexp::Expression
       end
     end
   end
-
 end

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

@@ -12,8 +12,10 @@ module Regexp::Expression
 
     class Atomic  < Group::Base; end
     class Passive < Group::Base; end
-    class Options < Group::Base; end
     class Absence < Group::Base; end
+    class Options < Group::Base
+      attr_accessor :option_changes
+    end
 
     class Capture < Group::Base
       attr_accessor :number, :number_at_level

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

@@ -1,12 +1,24 @@
 module Regexp::Expression
 
   class Root < Regexp::Expression::Subexpression
-    def initialize(options = {})
-      super(Regexp::Token.new(:expression, :root, '', 0), options)
+    # TODO: this override is here for backwards compatibility, remove in 2.0.0
+    def initialize(*args)
+      unless args.first.is_a?(Regexp::Token)
+        warn('WARNING: Root.new without a Token argument is deprecated and '\
+             'will be removed in 2.0.0. Use Root.build for the old behavior.')
+        return super(self.class.build_token, *args)
+      end
+      super
     end
 
-    alias ignore_case? case_insensitive?
-    alias extended?    free_spacing?
-  end
+    class << self
+      def build(options = {})
+        new(build_token, options)
+      end
 
+      def build_token
+        Regexp::Token.new(:expression, :root, '', 0)
+      end
+    end
+  end
 end

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

@@ -58,6 +58,5 @@ module Regexp::Expression
 
       result
     end
-
   end
 end

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

@@ -25,8 +25,18 @@ module Regexp::Expression
     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) }
+       fetch find first index join last length map 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

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.1.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,30 @@ 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
+    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 +183,4 @@ class TestParserConditionals < Test::Unit::TestCase
       RP.parse(regexp, 'ruby/2.0')
     }
   end
-
 end

data/test/parser/test_groups.rb

@@ -19,6 +19,9 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal true,  t.expressions[0].m?
     assert_equal false, t.expressions[0].i?
     assert_equal false, t.expressions[0].x?
+
+    assert_equal true,  t.expressions[0].option_changes[:m]
+    assert_equal nil,   t.expressions[0].option_changes[:i]
   end
 
   def test_parse_self_defeating_option_group
@@ -27,6 +30,9 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal false, t.expressions[0].m?
     assert_equal false, t.expressions[0].i?
     assert_equal false, t.expressions[0].x?
+
+    assert_equal false, t.expressions[0].option_changes[:m]
+    assert_equal nil,   t.expressions[0].option_changes[:i]
   end
 
   def test_parse_nested_options_activate_one
@@ -39,6 +45,10 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal true,  t.expressions[0].expressions[1].m?
     assert_equal false, t.expressions[0].expressions[1].i?
     assert_equal true,  t.expressions[0].expressions[1].x?
+
+    assert_equal true,  t.expressions[0].expressions[1].option_changes[:m]
+    assert_equal nil,   t.expressions[0].expressions[1].option_changes[:i]
+    assert_equal nil,   t.expressions[0].expressions[1].option_changes[:x]
   end
 
   def test_parse_nested_options_deactivate_one
@@ -51,6 +61,10 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal false, t.expressions[0].expressions[1].m?
     assert_equal false, t.expressions[0].expressions[1].i?
     assert_equal true,  t.expressions[0].expressions[1].x?
+
+    assert_equal false, t.expressions[0].expressions[1].option_changes[:i]
+    assert_equal nil,   t.expressions[0].expressions[1].option_changes[:m]
+    assert_equal nil,   t.expressions[0].expressions[1].option_changes[:x]
   end
 
   def test_parse_nested_options_invert_all
@@ -63,6 +77,10 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal true,  t.expressions[0].expressions[1].m?
     assert_equal false, t.expressions[0].expressions[1].i?
     assert_equal false, t.expressions[0].expressions[1].x?
+
+    assert_equal true,  t.expressions[0].expressions[1].option_changes[:m]
+    assert_equal false, t.expressions[0].expressions[1].option_changes[:i]
+    assert_equal false, t.expressions[0].expressions[1].option_changes[:x]
   end
 
   def test_parse_nested_options_affect_literal_subexpressions
@@ -88,6 +106,10 @@ class TestParserGroups < Test::Unit::TestCase
     assert_equal false, t.expressions[1].m?
     assert_equal true,  t.expressions[1].i?
     assert_equal false, t.expressions[1].x?
+
+    assert_equal true,  t.expressions[1].option_changes[:i]
+    assert_equal false, t.expressions[1].option_changes[:m]
+    assert_equal nil,   t.expressions[1].option_changes[:x]
   end
 
   def test_parse_option_switch_affects_following_expressions

data/test/parser/test_quantifiers.rb

@@ -12,6 +12,13 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal 1,             exp.quantifier.max
     assert_equal :greedy,       exp.quantifier.mode
+    assert_equal true,          exp.quantifier.greedy?
+    assert_equal true,          exp.greedy?
+
+    assert_equal false,         exp.quantifier.reluctant?
+    assert_equal false,         exp.reluctant?
+    assert_equal false,         exp.quantifier.possessive?
+    assert_equal false,         exp.possessive?
   end
 
   def test_parse_zero_or_one_reluctant
@@ -23,7 +30,13 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal 1,             exp.quantifier.max
     assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.quantifier.reluctant?
     assert_equal true,          exp.reluctant?
+
+    assert_equal false,         exp.quantifier.greedy?
+    assert_equal false,         exp.greedy?
+    assert_equal false,         exp.quantifier.possessive?
+    assert_equal false,         exp.possessive?
   end
 
   def test_parse_zero_or_one_possessive
@@ -35,7 +48,13 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal 1,             exp.quantifier.max
     assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.quantifier.possessive?
     assert_equal true,          exp.possessive?
+
+    assert_equal false,         exp.quantifier.greedy?
+    assert_equal false,         exp.greedy?
+    assert_equal false,         exp.quantifier.reluctant?
+    assert_equal false,         exp.reluctant?
   end
 
   # *: zero-or-more
@@ -48,6 +67,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :greedy,       exp.quantifier.mode
+    assert_equal true,          exp.quantifier.greedy?
+    assert_equal true,          exp.greedy?
   end
 
   def test_parse_zero_or_more_reluctant
@@ -59,6 +80,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.quantifier.reluctant?
     assert_equal true,          exp.reluctant?
   end
 
@@ -71,6 +93,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.quantifier.possessive?
     assert_equal true,          exp.possessive?
   end
 
@@ -84,6 +107,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 1,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :greedy,       exp.quantifier.mode
+    assert_equal true,          exp.quantifier.greedy?
+    assert_equal true,          exp.greedy?
   end
 
   def test_parse_one_or_more_reluctant
@@ -95,6 +120,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 1,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.quantifier.reluctant?
     assert_equal true,          exp.reluctant?
   end
 
@@ -107,6 +133,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 1,             exp.quantifier.min
     assert_equal(-1,            exp.quantifier.max)
     assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.quantifier.possessive?
     assert_equal true,          exp.possessive?
   end
 
@@ -120,6 +147,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 2,         exp.quantifier.min
     assert_equal 4,         exp.quantifier.max
     assert_equal :greedy,   exp.quantifier.mode
+    assert_equal true,      exp.quantifier.greedy?
+    assert_equal true,      exp.greedy?
   end
 
   def test_parse_intervals_min_max_reluctant
@@ -131,6 +160,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 3,           exp.quantifier.min
     assert_equal 5,           exp.quantifier.max
     assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.quantifier.reluctant?
     assert_equal true,        exp.reluctant?
   end
 
@@ -143,6 +173,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 2,           exp.quantifier.min
     assert_equal 4,           exp.quantifier.max
     assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.quantifier.possessive?
     assert_equal true,        exp.possessive?
   end
 
@@ -156,6 +187,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 2,         exp.quantifier.min
     assert_equal(-1,        exp.quantifier.max)
     assert_equal :greedy,   exp.quantifier.mode
+    assert_equal true,      exp.quantifier.greedy?
+    assert_equal true,      exp.greedy?
   end
 
   def test_parse_intervals_min_only_reluctant
@@ -168,6 +201,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 2,           exp.quantifier.min
     assert_equal(-1,          exp.quantifier.max)
     assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.quantifier.reluctant?
     assert_equal true,        exp.reluctant?
   end
 
@@ -181,6 +215,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 3,           exp.quantifier.min
     assert_equal(-1,          exp.quantifier.max)
     assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.quantifier.possessive?
     assert_equal true,        exp.possessive?
   end
 
@@ -194,6 +229,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,         exp.quantifier.min
     assert_equal 2,         exp.quantifier.max
     assert_equal :greedy,   exp.quantifier.mode
+    assert_equal true,      exp.quantifier.greedy?
+    assert_equal true,      exp.greedy?
   end
 
   def test_parse_intervals_max_only_reluctant
@@ -205,6 +242,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,           exp.quantifier.min
     assert_equal 4,           exp.quantifier.max
     assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.quantifier.reluctant?
     assert_equal true,        exp.reluctant?
   end
 
@@ -217,6 +255,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 0,           exp.quantifier.min
     assert_equal 3,           exp.quantifier.max
     assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.quantifier.possessive?
     assert_equal true,        exp.possessive?
   end
 
@@ -230,6 +269,8 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 2,         exp.quantifier.min
     assert_equal 2,         exp.quantifier.max
     assert_equal :greedy,   exp.quantifier.mode
+    assert_equal true,      exp.quantifier.greedy?
+    assert_equal true,      exp.greedy?
   end
 
   def test_parse_intervals_exact_reluctant
@@ -241,6 +282,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 3,           exp.quantifier.min
     assert_equal 3,           exp.quantifier.max
     assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.quantifier.reluctant?
     assert_equal true,        exp.reluctant?
   end
 
@@ -253,7 +295,7 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
     assert_equal 3,           exp.quantifier.min
     assert_equal 3,           exp.quantifier.max
     assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.quantifier.possessive?
     assert_equal true,        exp.possessive?
   end
-
 end

data/test/parser/test_refcalls.rb

@@ -3,7 +3,7 @@ require File.expand_path("../../helpers", __FILE__)
 class TestParserRefcalls < Test::Unit::TestCase
   def test_parse_traditional_number_backref
     root = RP.parse('(abc)\1', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::Number, exp
     assert_equal 1,    exp.number
@@ -11,7 +11,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_named_ab
     root = RP.parse('(?<X>abc)\k<X>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::Name, exp
     assert_equal 'X',  exp.name
@@ -19,7 +19,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_named_sq
     root = RP.parse("(?<X>abc)\\k'X'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::Name, exp
     assert_equal 'X',  exp.name
@@ -27,7 +27,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_ab
     root = RP.parse('(abc)\k<1>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::Number, exp
     assert_equal 1,    exp.number
@@ -35,7 +35,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_sq
     root = RP.parse("(abc)\\k'1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::Number, exp
     assert_equal 1,    exp.number
@@ -43,7 +43,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_relative_ab
     root = RP.parse('(abc)\k<-1>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRelative, exp
     assert_equal(-1,   exp.number)
@@ -51,7 +51,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_relative_sq
     root = RP.parse("(abc)\\k'-1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRelative, exp
     assert_equal(-1,   exp.number)
@@ -59,7 +59,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_name_call_ab
     root = RP.parse('(?<X>abc)\g<X>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NameCall, exp
     assert_equal 'X',  exp.name
@@ -67,7 +67,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_name_call_sq
     root = RP.parse("(?<X>abc)\\g'X'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NameCall, exp
     assert_equal 'X',  exp.name
@@ -75,7 +75,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_call_ab
     root = RP.parse('(abc)\g<1>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberCall, exp
     assert_equal 1,    exp.number
@@ -83,7 +83,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_call_sq
     root = RP.parse("(abc)\\g'1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberCall, exp
     assert_equal 1,    exp.number
@@ -91,7 +91,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_relative_call_ab
     root = RP.parse('(abc)\g<-1>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberCallRelative, exp
     assert_equal(-1,   exp.number)
@@ -99,15 +99,31 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_relative_call_sq
     root = RP.parse("(abc)\\g'-1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberCallRelative, exp
     assert_equal(-1,   exp.number)
   end
 
+  def test_parse_backref_number_relative_forward_call_ab
+    root = RP.parse('\g<+1>(abc)', 'ruby/1.9')
+    exp  = root[0]
+
+    assert_instance_of Backreference::NumberCallRelative, exp
+    assert_equal 1,    exp.number
+  end
+
+  def test_parse_backref_number_relative_forward_call_sq
+    root = RP.parse("\\g'+1'(abc)", 'ruby/1.9')
+    exp  = root[0]
+
+    assert_instance_of Backreference::NumberCallRelative, exp
+    assert_equal 1,    exp.number
+  end
+
   def test_parse_backref_name_recursion_level_ab
     root = RP.parse('(?<X>abc)\k<X-0>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NameRecursionLevel, exp
     assert_equal 'X',  exp.name
@@ -116,7 +132,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_name_recursion_level_sq
     root = RP.parse("(?<X>abc)\\k'X-0'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NameRecursionLevel, exp
     assert_equal 'X',  exp.name
@@ -125,7 +141,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_recursion_level_ab
     root = RP.parse('(abc)\k<1-0>', 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRecursionLevel, exp
     assert_equal 1,    exp.number
@@ -134,7 +150,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_recursion_level_sq
     root = RP.parse("(abc)\\k'1-0'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRecursionLevel, exp
     assert_equal 1,    exp.number
@@ -143,7 +159,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_negative_number_recursion_level
     root = RP.parse("(abc)\\k'-1+0'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRecursionLevel, exp
     assert_equal(-1,   exp.number)
@@ -152,7 +168,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_positive_recursion_level
     root = RP.parse("(abc)\\k'1+1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRecursionLevel, exp
     assert_equal 1,    exp.number
@@ -161,7 +177,7 @@ class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_number_negative_recursion_level
     root = RP.parse("(abc)\\k'1-1'", 'ruby/1.9')
-    exp  = root.expressions.at(1)
+    exp  = root[1]
 
     assert_instance_of Backreference::NumberRecursionLevel, exp
     assert_equal 1,    exp.number

data/test/scanner/test_all.rb

@@ -1,9 +1,9 @@
 require File.expand_path("../../helpers", __FILE__)
 
-%w{
-  anchors errors escapes free_space groups literals
-  meta properties quantifiers scripts sets types unicode_blocks
-}.each do|tc|
+%w[
+  anchors errors escapes free_space groups literals meta
+  properties quantifiers refcalls scripts sets types unicode_blocks
+].each do |tc|
   require File.expand_path("../test_#{tc}", __FILE__)
 end
 

data/test/scanner/test_refcalls.rb

@@ -1,7 +1,6 @@
 require File.expand_path("../../helpers", __FILE__)
 
 class ScannerRefCalls < Test::Unit::TestCase
-
   tests = {
     # Traditional numerical group back-reference
     '(abc)\1'           => [3, :backref, :number,                  '\1',         5, 7],
@@ -26,6 +25,9 @@ class ScannerRefCalls < Test::Unit::TestCase
     '(abc)\g<-1>'       => [3, :backref, :number_rel_call_ab,      '\g<-1>',     5, 11],
     "(abc)\\g'-1'"      => [3, :backref, :number_rel_call_sq,      "\\g'-1'",    5, 11],
 
+    '\g<+1>(abc)'       => [0, :backref, :number_rel_call_ab,      '\g<+1>',     0, 6],
+    "\\g'+1'(abc)"      => [0, :backref, :number_rel_call_sq,      "\\g'+1'",    0, 6],
+
     # Group back-references, with recursion level
     '(?<X>abc)\k<X-0>'  => [3, :backref, :name_recursion_ref_ab,   '\k<X-0>',    9, 16],
     "(?<X>abc)\\k'X-0'" => [3, :backref, :name_recursion_ref_sq,   "\\k'X-0'",   9, 16],
@@ -47,5 +49,4 @@ class ScannerRefCalls < Test::Unit::TestCase
       assert_equal text,  pattern[ts, te]
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Ammar Ali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-01 00:00:00.000000000 Z
+date: 2018-09-17 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email: