regexp_parser 0.4.13 → 0.5.0

data/lib/regexp_parser/expression/sequence.rb

@@ -25,18 +25,19 @@ module Regexp::Expression
     end
 
     def starts_at
-      @expressions.first.starts_at
+      expressions.first.starts_at
     end
+    alias :ts :starts_at
 
     def quantify(token, text, min = nil, max = nil, mode = :greedy)
       offset = -1
       target = expressions[offset]
-      while target and target.is_a?(FreeSpace)
+      while target.is_a?(FreeSpace)
         target = expressions[offset -= 1]
       end
 
-      raise ArgumentError.new("No valid target found for '#{text}' " +
-                              "quantifier") unless target
+      target || raise(ArgumentError, "No valid target found for '#{text}' "\
+                                     'quantifier')
 
       target.quantify(token, text, min, max, mode)
     end

data/lib/regexp_parser/expression/subexpression.rb

@@ -6,63 +6,31 @@ module Regexp::Expression
     def initialize(token, options = {})
       super
 
-      @expressions = []
+      self.expressions = []
     end
 
     # Override base method to clone the expressions as well.
     def clone
       copy = super
-      copy.expressions = @expressions.map {|e| e.clone }
+      copy.expressions = expressions.map(&:clone)
       copy
     end
 
     def <<(exp)
-      if exp.is_a?(WhiteSpace) and @expressions.last and
-        @expressions.last.is_a?(WhiteSpace)
-        @expressions.last.merge(exp)
+      if exp.is_a?(WhiteSpace) && last && last.is_a?(WhiteSpace)
+        last.merge(exp)
       else
-        @expressions << exp
+        expressions << exp
       end
     end
 
     def insert(exp)
-      @expressions.insert 0, exp
+      expressions.insert(0, exp)
     end
 
-    def each(&block)
-      @expressions.each {|e| yield e}
-    end
-
-    def each_with_index(&block)
-      @expressions.each_with_index {|e, i| yield e, i}
-    end
-
-    def first
-      @expressions.first
-    end
-
-    def last
-      @expressions.last
-    end
-
-    def [](index)
-      @expressions[index]
-    end
-
-    def length
-      @expressions.length
-    end
-
-    def empty?
-      @expressions.empty?
-    end
-
-    def all?(&block)
-      @expressions.all? {|exp| yield(exp) }
-    end
-
-    def ts
-      starts_at
+    %w[[] all? any? at count each each_with_index empty?
+       fetch find first index join last length values_at].each do |m|
+      define_method(m) { |*args, &block| expressions.send(m, *args, &block) }
     end
 
     def te
@@ -70,28 +38,17 @@ module Regexp::Expression
     end
 
     def to_s(format = :full)
-      s = ''
-
       # Note: the format does not get passed down to subexpressions.
-      case format
-      when :base
-        s << @text.dup
-        s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
-      else
-        s << @text.dup
-        s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
-        s << @quantifier if quantified?
-      end
-
-      s
+      # Note: cant use #text accessor, b/c it is overriden as def text; to_s end
+      # in Expression::Sequence, causing infinite recursion. Clean-up needed.
+      "#{@text}#{expressions.join}#{quantifier_affix(format)}"
     end
 
     def to_h
-      h = super
-      h[:text] = to_s(:base)
-      h[:expressions] = @expressions.map(&:to_h)
-      h
+      super.merge({
+        text:        to_s(:base),
+        expressions: expressions.map(&:to_h)
+      })
     end
   end
-
 end

data/lib/regexp_parser/lexer.rb

@@ -17,8 +17,10 @@ class Regexp::Lexer
   def lex(input, syntax = "ruby/#{RUBY_VERSION}", &block)
     syntax = Regexp::Syntax.new(syntax)
 
-    @tokens = []
-    @nesting, @set_nesting, @conditional_nesting = 0, 0, 0
+    self.tokens = []
+    self.nesting = 0
+    self.set_nesting = 0
+    self.conditional_nesting = 0
 
     last = nil
     Regexp::Scanner.scan(input) do |type, token, text, ts, te|
@@ -31,7 +33,7 @@ class Regexp::Lexer
         last and last.type == :literal
 
       current = Regexp::Token.new(type, token, text, ts, te,
-                @nesting, @set_nesting, @conditional_nesting)
+                nesting, set_nesting, conditional_nesting)
 
       current = merge_literal(current) if type == :literal and
         last and last.type == :literal
@@ -39,19 +41,19 @@ class Regexp::Lexer
       current = merge_condition(current) if type == :conditional and
         [:condition, :condition_close].include?(token)
 
-      last.next(current) if last
-      current.previous(last) if last
+      last.next = current if last
+      current.previous = last if last
 
-      @tokens << current
+      tokens << current
       last = current
 
       descend(type, token)
     end
 
     if block_given?
-      @tokens.map {|t| block.call(t)}
+      tokens.map { |t| block.call(t) }
     else
-      @tokens
+      tokens
     end
   end
 
@@ -59,33 +61,35 @@ class Regexp::Lexer
     alias :scan :lex
   end
 
-  protected
+  private
+
+  attr_accessor :tokens, :nesting, :set_nesting, :conditional_nesting
 
   def ascend(type, token)
     if type == :group or type == :assertion
-      @nesting -= 1 if CLOSING_TOKENS.include?(token)
+      self.nesting = nesting - 1 if CLOSING_TOKENS.include?(token)
     end
 
     if type == :set or type == :subset
-      @set_nesting -= 1 if token == :close
+      self.set_nesting = set_nesting - 1 if token == :close
     end
 
     if type == :conditional
-      @conditional_nesting -= 1 if token == :close
+      self.conditional_nesting = conditional_nesting - 1 if token == :close
     end
   end
 
   def descend(type, token)
     if type == :group or type == :assertion
-      @nesting += 1 if OPENING_TOKENS.include?(token)
+      self.nesting = nesting + 1 if OPENING_TOKENS.include?(token)
     end
 
     if type == :set or type == :subset
-      @set_nesting += 1 if token == :open
+      self.set_nesting = set_nesting + 1 if token == :open
     end
 
     if type == :conditional
-      @conditional_nesting += 1 if token == :open
+      self.conditional_nesting = conditional_nesting + 1 if token == :open
     end
   end
 
@@ -105,20 +109,20 @@ class Regexp::Lexer
         last_length = last.length
       end
 
-      @tokens.pop
-      @tokens << Regexp::Token.new(:literal, :literal, lead, token.ts,
-                  (token.te - last_length), @nesting, @set_nesting, @conditional_nesting)
+      tokens.pop
+      tokens << Regexp::Token.new(:literal, :literal, lead, token.ts,
+                (token.te - last_length), nesting, set_nesting, conditional_nesting)
 
-      @tokens << Regexp::Token.new(:literal, :literal, last,
-                  (token.ts + lead_length),
-                  token.te, @nesting, @set_nesting, @conditional_nesting)
+      tokens << Regexp::Token.new(:literal, :literal, last,
+                (token.ts + lead_length),
+                token.te, nesting, set_nesting, conditional_nesting)
     end
   end
 
   # called by scan to merge two consecutive literals. this happens when tokens
   # get normalized (as in the case of posix/bre) and end up becoming literals.
   def merge_literal(current)
-    last = @tokens.pop
+    last = tokens.pop
 
     Regexp::Token.new(
       :literal,
@@ -126,16 +130,16 @@ class Regexp::Lexer
       last.text + current.text,
       last.ts,
       current.te,
-      @nesting,
-      @set_nesting,
-      @conditional_nesting
+      nesting,
+      set_nesting,
+      conditional_nesting,
     )
   end
 
   def merge_condition(current)
-    last = @tokens.pop
+    last = tokens.pop
     Regexp::Token.new(:conditional, :condition, last.text + current.text,
-      last.ts, current.te, @nesting, @set_nesting, @conditional_nesting)
+      last.ts, current.te, nesting, set_nesting, conditional_nesting)
   end
 
 end # module Regexp::Lexer

data/lib/regexp_parser/parser.rb

@@ -23,25 +23,33 @@ class Regexp::Parser
   end
 
   def parse(input, syntax = "ruby/#{RUBY_VERSION}", &block)
-    @nesting = [@root = @node = Root.new(options_from_input(input))]
+    root = Root.new(options_from_input(input))
 
-    @options_stack = [@root.options]
-    @switching_options = false
-    @conditional_nesting = []
+    self.root = root
+    self.node = root
+    self.nesting = [root]
+
+    self.options_stack = [root.options]
+    self.switching_options = false
+    self.conditional_nesting = []
 
     Regexp::Lexer.scan(input, syntax) do |token|
-      parse_token token
+      parse_token(token)
     end
 
     if block_given?
-      block.call @root
+      block.call(root)
     else
-      @root
+      root
     end
   end
 
   private
 
+  attr_accessor :root, :node, :nesting,
+                :options_stack, :switching_options, :conditional_nesting,
+                :current_set
+
   def options_from_input(input)
     return {} unless input.is_a?(::Regexp)
 
@@ -53,17 +61,15 @@ class Regexp::Parser
   end
 
   def nest(exp)
-    @nesting.push exp
-
-    @node << exp
-    @node  = exp
+    nesting.push(exp)
+    node << exp
+    self.node = exp
   end
 
   def nest_conditional(exp)
-    @conditional_nesting.push exp
-
-    @node << exp
-    @node  = exp
+    conditional_nesting.push(exp)
+    node << exp
+    self.node = exp
   end
 
   def parse_token(token)
@@ -84,7 +90,7 @@ class Regexp::Parser
       property(token)
 
     when :literal
-      @node << Literal.new(token, active_opts)
+      node << Literal.new(token, active_opts)
     when :free_space
       free_space(token)
 
@@ -117,28 +123,21 @@ class Regexp::Parser
   def meta(token)
     case token.token
     when :dot
-      @node << CharacterType::Any.new(token, active_opts)
+      node << CharacterType::Any.new(token, active_opts)
     when :alternation
-      unless @node.token == :alternation
-        unless @node.last.is_a?(Alternation)
-          alt = Alternation.new(token, active_opts)
-          seq = Alternative.new(alt.level, alt.set_level, alt.conditional_level)
-
-          while @node.expressions.last
-            seq.insert @node.expressions.pop
-          end
-          alt.alternative(seq)
-
-          @node << alt
-          @node = alt
-          @node.alternative
-        else
-          @node = @node.last
-          @node.alternative
-        end
+      if node.token == :alternation
+      elsif node.last.is_a?(Alternation)
+        self.node = node.last
       else
-        @node.alternative
+        alt = Alternation.new(token, active_opts)
+        seq = Alternative.new(alt.level, alt.set_level, alt.conditional_level)
+        node.expressions.count.times { seq.insert(node.expressions.pop) }
+        alt.alternative(seq)
+
+        node << alt
+        self.node = alt
       end
+      node.alternative
     else
       raise UnknownTokenError.new('Meta', token)
     end
@@ -147,21 +146,21 @@ class Regexp::Parser
   def backref(token)
     case token.token
     when :name_ref
-      @node << Backreference::Name.new(token, active_opts)
+      node << Backreference::Name.new(token, active_opts)
     when :name_nest_ref
-      @node << Backreference::NameNestLevel.new(token, active_opts)
+      node << Backreference::NameNestLevel.new(token, active_opts)
     when :name_call
-      @node << Backreference::NameCall.new(token, active_opts)
+      node << Backreference::NameCall.new(token, active_opts)
     when :number, :number_ref
-      @node << Backreference::Number.new(token, active_opts)
+      node << Backreference::Number.new(token, active_opts)
     when :number_rel_ref
-      @node << Backreference::NumberRelative.new(token, active_opts)
+      node << Backreference::NumberRelative.new(token, active_opts)
     when :number_nest_ref
-      @node << Backreference::NumberNestLevel.new(token, active_opts)
+      node << Backreference::NumberNestLevel.new(token, active_opts)
     when :number_call
-      @node << Backreference::NumberCall.new(token, active_opts)
+      node << Backreference::NumberCall.new(token, active_opts)
     when :number_rel_call
-      @node << Backreference::NumberCallRelative.new(token, active_opts)
+      node << Backreference::NumberCallRelative.new(token, active_opts)
     else
       raise UnknownTokenError.new('Backreference', token)
     end
@@ -170,25 +169,25 @@ class Regexp::Parser
   def type(token)
     case token.token
     when :digit
-      @node << CharacterType::Digit.new(token, active_opts)
+      node << CharacterType::Digit.new(token, active_opts)
     when :nondigit
-      @node << CharacterType::NonDigit.new(token, active_opts)
+      node << CharacterType::NonDigit.new(token, active_opts)
     when :hex
-      @node << CharacterType::Hex.new(token, active_opts)
+      node << CharacterType::Hex.new(token, active_opts)
     when :nonhex
-      @node << CharacterType::NonHex.new(token, active_opts)
+      node << CharacterType::NonHex.new(token, active_opts)
     when :space
-      @node << CharacterType::Space.new(token, active_opts)
+      node << CharacterType::Space.new(token, active_opts)
     when :nonspace
-      @node << CharacterType::NonSpace.new(token, active_opts)
+      node << CharacterType::NonSpace.new(token, active_opts)
     when :word
-      @node << CharacterType::Word.new(token, active_opts)
+      node << CharacterType::Word.new(token, active_opts)
     when :nonword
-      @node << CharacterType::NonWord.new(token, active_opts)
+      node << CharacterType::NonWord.new(token, active_opts)
     when :linebreak
-      @node << CharacterType::Linebreak.new(token, active_opts)
+      node << CharacterType::Linebreak.new(token, active_opts)
     when :xgrapheme
-      @node << CharacterType::ExtendedGrapheme.new(token, active_opts)
+      node << CharacterType::ExtendedGrapheme.new(token, active_opts)
     else
       raise UnknownTokenError.new('CharacterType', token)
     end
@@ -199,20 +198,20 @@ class Regexp::Parser
     when :open
       nest_conditional(Conditional::Expression.new(token, active_opts))
     when :condition
-      @conditional_nesting.last.condition(Conditional::Condition.new(token, active_opts))
-      @conditional_nesting.last.branch
+      conditional_nesting.last.condition = Conditional::Condition.new(token, active_opts)
+      conditional_nesting.last.branch
     when :separator
-      @conditional_nesting.last.branch
-      @node = @conditional_nesting.last.branches.last
+      conditional_nesting.last.branch
+      self.node = conditional_nesting.last.branches.last
     when :close
-      @conditional_nesting.pop
-
-      @node = if @conditional_nesting.empty?
-        @nesting.last
-      else
-        @conditional_nesting.last
-      end
+      conditional_nesting.pop
 
+      self.node =
+        if conditional_nesting.empty?
+          nesting.last
+        else
+          conditional_nesting.last
+        end
     else
       raise UnknownTokenError.new('Conditional', token)
     end
@@ -222,86 +221,86 @@ class Regexp::Parser
 
   def property(token)
     case token.token
-    when :alnum;            @node << Alnum.new(token, active_opts)
-    when :alpha;            @node << Alpha.new(token, active_opts)
-    when :ascii;            @node << Ascii.new(token, active_opts)
-    when :blank;            @node << Blank.new(token, active_opts)
-    when :cntrl;            @node << Cntrl.new(token, active_opts)
-    when :digit;            @node << Digit.new(token, active_opts)
-    when :graph;            @node << Graph.new(token, active_opts)
-    when :lower;            @node << Lower.new(token, active_opts)
-    when :print;            @node << Print.new(token, active_opts)
-    when :punct;            @node << Punct.new(token, active_opts)
-    when :space;            @node << Space.new(token, active_opts)
-    when :upper;            @node << Upper.new(token, active_opts)
-    when :word;             @node << Word.new(token, active_opts)
-    when :xdigit;           @node << Xdigit.new(token, active_opts)
-    when :xposixpunct;      @node << XPosixPunct.new(token, active_opts)
+    when :alnum;            node << Alnum.new(token, active_opts)
+    when :alpha;            node << Alpha.new(token, active_opts)
+    when :ascii;            node << Ascii.new(token, active_opts)
+    when :blank;            node << Blank.new(token, active_opts)
+    when :cntrl;            node << Cntrl.new(token, active_opts)
+    when :digit;            node << Digit.new(token, active_opts)
+    when :graph;            node << Graph.new(token, active_opts)
+    when :lower;            node << Lower.new(token, active_opts)
+    when :print;            node << Print.new(token, active_opts)
+    when :punct;            node << Punct.new(token, active_opts)
+    when :space;            node << Space.new(token, active_opts)
+    when :upper;            node << Upper.new(token, active_opts)
+    when :word;             node << Word.new(token, active_opts)
+    when :xdigit;           node << Xdigit.new(token, active_opts)
+    when :xposixpunct;      node << XPosixPunct.new(token, active_opts)
 
     # only in Oniguruma (old rubies)
-    when :newline;          @node << Newline.new(token, active_opts)
-
-    when :any;              @node << Any.new(token, active_opts)
-    when :assigned;         @node << Assigned.new(token, active_opts)
-
-    when :letter_any;       @node << Letter::Any.new(token, active_opts)
-    when :letter_uppercase; @node << Letter::Uppercase.new(token, active_opts)
-    when :letter_lowercase; @node << Letter::Lowercase.new(token, active_opts)
-    when :letter_titlecase; @node << Letter::Titlecase.new(token, active_opts)
-    when :letter_modifier;  @node << Letter::Modifier.new(token, active_opts)
-    when :letter_other;     @node << Letter::Other.new(token, active_opts)
-
-    when :mark_any;         @node << Mark::Any.new(token, active_opts)
-    when :mark_nonspacing;  @node << Mark::Nonspacing.new(token, active_opts)
-    when :mark_spacing;     @node << Mark::Spacing.new(token, active_opts)
-    when :mark_enclosing;   @node << Mark::Enclosing.new(token, active_opts)
-
-    when :number_any;       @node << Number::Any.new(token, active_opts)
-    when :number_decimal;   @node << Number::Decimal.new(token, active_opts)
-    when :number_letter;    @node << Number::Letter.new(token, active_opts)
-    when :number_other;     @node << Number::Other.new(token, active_opts)
-
-    when :punct_any;        @node << Punctuation::Any.new(token, active_opts)
-    when :punct_connector;  @node << Punctuation::Connector.new(token, active_opts)
-    when :punct_dash;       @node << Punctuation::Dash.new(token, active_opts)
-    when :punct_open;       @node << Punctuation::Open.new(token, active_opts)
-    when :punct_close;      @node << Punctuation::Close.new(token, active_opts)
-    when :punct_initial;    @node << Punctuation::Initial.new(token, active_opts)
-    when :punct_final;      @node << Punctuation::Final.new(token, active_opts)
-    when :punct_other;      @node << Punctuation::Other.new(token, active_opts)
-
-    when :separator_any;    @node << Separator::Any.new(token, active_opts)
-    when :separator_space;  @node << Separator::Space.new(token, active_opts)
-    when :separator_line;   @node << Separator::Line.new(token, active_opts)
-    when :separator_para;   @node << Separator::Paragraph.new(token, active_opts)
-
-    when :symbol_any;       @node << Symbol::Any.new(token, active_opts)
-    when :symbol_math;      @node << Symbol::Math.new(token, active_opts)
-    when :symbol_currency;  @node << Symbol::Currency.new(token, active_opts)
-    when :symbol_modifier;  @node << Symbol::Modifier.new(token, active_opts)
-    when :symbol_other;     @node << Symbol::Other.new(token, active_opts)
-
-    when :other;            @node << Codepoint::Any.new(token, active_opts)
-    when :control;          @node << Codepoint::Control.new(token, active_opts)
-    when :format;           @node << Codepoint::Format.new(token, active_opts)
-    when :surrogate;        @node << Codepoint::Surrogate.new(token, active_opts)
-    when :private_use;      @node << Codepoint::PrivateUse.new(token, active_opts)
-    when :unassigned;       @node << Codepoint::Unassigned.new(token, active_opts)
+    when :newline;          node << Newline.new(token, active_opts)
+
+    when :any;              node << Any.new(token, active_opts)
+    when :assigned;         node << Assigned.new(token, active_opts)
+
+    when :letter_any;       node << Letter::Any.new(token, active_opts)
+    when :letter_uppercase; node << Letter::Uppercase.new(token, active_opts)
+    when :letter_lowercase; node << Letter::Lowercase.new(token, active_opts)
+    when :letter_titlecase; node << Letter::Titlecase.new(token, active_opts)
+    when :letter_modifier;  node << Letter::Modifier.new(token, active_opts)
+    when :letter_other;     node << Letter::Other.new(token, active_opts)
+
+    when :mark_any;         node << Mark::Any.new(token, active_opts)
+    when :mark_nonspacing;  node << Mark::Nonspacing.new(token, active_opts)
+    when :mark_spacing;     node << Mark::Spacing.new(token, active_opts)
+    when :mark_enclosing;   node << Mark::Enclosing.new(token, active_opts)
+
+    when :number_any;       node << Number::Any.new(token, active_opts)
+    when :number_decimal;   node << Number::Decimal.new(token, active_opts)
+    when :number_letter;    node << Number::Letter.new(token, active_opts)
+    when :number_other;     node << Number::Other.new(token, active_opts)
+
+    when :punct_any;        node << Punctuation::Any.new(token, active_opts)
+    when :punct_connector;  node << Punctuation::Connector.new(token, active_opts)
+    when :punct_dash;       node << Punctuation::Dash.new(token, active_opts)
+    when :punct_open;       node << Punctuation::Open.new(token, active_opts)
+    when :punct_close;      node << Punctuation::Close.new(token, active_opts)
+    when :punct_initial;    node << Punctuation::Initial.new(token, active_opts)
+    when :punct_final;      node << Punctuation::Final.new(token, active_opts)
+    when :punct_other;      node << Punctuation::Other.new(token, active_opts)
+
+    when :separator_any;    node << Separator::Any.new(token, active_opts)
+    when :separator_space;  node << Separator::Space.new(token, active_opts)
+    when :separator_line;   node << Separator::Line.new(token, active_opts)
+    when :separator_para;   node << Separator::Paragraph.new(token, active_opts)
+
+    when :symbol_any;       node << Symbol::Any.new(token, active_opts)
+    when :symbol_math;      node << Symbol::Math.new(token, active_opts)
+    when :symbol_currency;  node << Symbol::Currency.new(token, active_opts)
+    when :symbol_modifier;  node << Symbol::Modifier.new(token, active_opts)
+    when :symbol_other;     node << Symbol::Other.new(token, active_opts)
+
+    when :other;            node << Codepoint::Any.new(token, active_opts)
+    when :control;          node << Codepoint::Control.new(token, active_opts)
+    when :format;           node << Codepoint::Format.new(token, active_opts)
+    when :surrogate;        node << Codepoint::Surrogate.new(token, active_opts)
+    when :private_use;      node << Codepoint::PrivateUse.new(token, active_opts)
+    when :unassigned;       node << Codepoint::Unassigned.new(token, active_opts)
 
     when *Token::UnicodeProperty::Age
-      @node << Age.new(token, active_opts)
+      node << Age.new(token, active_opts)
 
     when *Token::UnicodeProperty::Derived
-      @node << Derived.new(token, active_opts)
+      node << Derived.new(token, active_opts)
 
     when *Token::UnicodeProperty::Emoji
-      @node << Emoji.new(token, active_opts)
+      node << Emoji.new(token, active_opts)
 
     when *Token::UnicodeProperty::Script
-      @node << Script.new(token, active_opts)
+      node << Script.new(token, active_opts)
 
     when *Token::UnicodeProperty::UnicodeBlock
-      @node << Block.new(token, active_opts)
+      node << Block.new(token, active_opts)
 
     else
       raise UnknownTokenError.new('UnicodeProperty', token)
@@ -311,21 +310,21 @@ class Regexp::Parser
   def anchor(token)
     case token.token
     when :bol
-      @node << Anchor::BeginningOfLine.new(token, active_opts)
+      node << Anchor::BeginningOfLine.new(token, active_opts)
     when :eol
-      @node << Anchor::EndOfLine.new(token, active_opts)
+      node << Anchor::EndOfLine.new(token, active_opts)
     when :bos
-      @node << Anchor::BOS.new(token, active_opts)
+      node << Anchor::BOS.new(token, active_opts)
     when :eos
-      @node << Anchor::EOS.new(token, active_opts)
+      node << Anchor::EOS.new(token, active_opts)
     when :eos_ob_eol
-      @node << Anchor::EOSobEOL.new(token, active_opts)
+      node << Anchor::EOSobEOL.new(token, active_opts)
     when :word_boundary
-      @node << Anchor::WordBoundary.new(token, active_opts)
+      node << Anchor::WordBoundary.new(token, active_opts)
     when :nonword_boundary
-      @node << Anchor::NonWordBoundary.new(token, active_opts)
+      node << Anchor::NonWordBoundary.new(token, active_opts)
     when :match_start
-      @node << Anchor::MatchStart.new(token, active_opts)
+      node << Anchor::MatchStart.new(token, active_opts)
     else
       raise UnknownTokenError.new('Anchor', token)
     end
@@ -335,58 +334,58 @@ class Regexp::Parser
     case token.token
 
     when :backspace
-      @node << EscapeSequence::Backspace.new(token, active_opts)
+      node << EscapeSequence::Backspace.new(token, active_opts)
 
     when :escape
-      @node << EscapeSequence::AsciiEscape.new(token, active_opts)
+      node << EscapeSequence::AsciiEscape.new(token, active_opts)
     when :bell
-      @node << EscapeSequence::Bell.new(token, active_opts)
+      node << EscapeSequence::Bell.new(token, active_opts)
     when :form_feed
-      @node << EscapeSequence::FormFeed.new(token, active_opts)
+      node << EscapeSequence::FormFeed.new(token, active_opts)
     when :newline
-      @node << EscapeSequence::Newline.new(token, active_opts)
+      node << EscapeSequence::Newline.new(token, active_opts)
     when :carriage
-      @node << EscapeSequence::Return.new(token, active_opts)
+      node << EscapeSequence::Return.new(token, active_opts)
     when :space
-      @node << EscapeSequence::Space.new(token, active_opts)
+      node << EscapeSequence::Space.new(token, active_opts)
     when :tab
-      @node << EscapeSequence::Tab.new(token, active_opts)
+      node << EscapeSequence::Tab.new(token, active_opts)
     when :vertical_tab
-      @node << EscapeSequence::VerticalTab.new(token, active_opts)
+      node << EscapeSequence::VerticalTab.new(token, active_opts)
 
     when :control
       if token.text =~ /\A(?:\\C-\\M|\\c\\M)/
-        @node << EscapeSequence::MetaControl.new(token, active_opts)
+        node << EscapeSequence::MetaControl.new(token, active_opts)
       else
-        @node << EscapeSequence::Control.new(token, active_opts)
+        node << EscapeSequence::Control.new(token, active_opts)
       end
 
     when :meta_sequence
       if token.text =~ /\A\\M-\\[Cc]/
-        @node << EscapeSequence::MetaControl.new(token, active_opts)
+        node << EscapeSequence::MetaControl.new(token, active_opts)
       else
-        @node << EscapeSequence::Meta.new(token, active_opts)
+        node << EscapeSequence::Meta.new(token, active_opts)
       end
 
     else
       # treating everything else as a literal
-      @node << EscapeSequence::Literal.new(token, active_opts)
+      node << EscapeSequence::Literal.new(token, active_opts)
     end
   end
 
   def keep(token)
-    @node << Keep::Mark.new(token, active_opts)
+    node << Keep::Mark.new(token, active_opts)
   end
 
   def free_space(token)
     case token.token
     when :comment
-      @node << Comment.new(token, active_opts)
+      node << Comment.new(token, active_opts)
     when :whitespace
-      if @node.last and @node.last.is_a?(WhiteSpace)
-        @node.last.merge(WhiteSpace.new(token, active_opts))
+      if node.last.is_a?(WhiteSpace)
+        node.last.merge(WhiteSpace.new(token, active_opts))
       else
-        @node << WhiteSpace.new(token, active_opts)
+        node << WhiteSpace.new(token, active_opts)
       end
     else
       raise UnknownTokenError.new('FreeSpace', token)
@@ -395,13 +394,13 @@ class Regexp::Parser
 
   def quantifier(token)
     offset = -1
-    target_node = @node.expressions[offset]
-    while target_node and target_node.is_a?(FreeSpace)
-      target_node = @node.expressions[offset -= 1]
+    target_node = node.expressions[offset]
+    while target_node.is_a?(FreeSpace)
+      target_node = node.expressions[offset -= 1]
     end
 
-    raise ArgumentError.new("No valid target found for '#{token.text}' "+
-                            "quantifier") unless target_node
+    target_node || raise(ArgumentError, 'No valid target found for '\
+                                        "'#{token.text}' ")
 
     case token.token
     when :zero_or_one
@@ -462,7 +461,7 @@ class Regexp::Parser
     when :close
       close_group
     when :comment
-      @node << Group::Comment.new(token, active_opts)
+      node << Group::Comment.new(token, active_opts)
     else
       open_group(token)
     end
@@ -471,7 +470,7 @@ class Regexp::Parser
   def options_group(token)
     positive, negative = token.text.split('-', 2)
     negative ||= ''
-    @switching_options = !token.text.include?(':')
+    self.switching_options = !token.text.include?(':')
     # TODO: change this -^ to token.type == :options_switch in v1.0.0
 
     new_options = active_opts.dup
@@ -490,7 +489,7 @@ class Regexp::Parser
       new_options[flag.to_sym] = true
     end
 
-    @options_stack << new_options
+    options_stack << new_options
 
     exp = Group::Options.new(token, active_opts)
 
@@ -525,43 +524,44 @@ class Regexp::Parser
 
     # Push the active options to the stack again. This way we can simply pop the
     # stack for any group we close, no matter if it had its own options or not.
-    @options_stack << active_opts
+    options_stack << active_opts
 
     nest(exp)
   end
 
   def close_group
-    @nesting.pop
-    @options_stack.pop unless @switching_options
-    @switching_options = false
+    nesting.pop
+    options_stack.pop unless switching_options
+    self.switching_options = false
 
-    @node = @nesting.last
-    @node = @node.last if @node.last and @node.last.is_a?(Alternation)
+    self.node = nesting.last
+    self.node = node.last if node.last and node.last.is_a?(Alternation)
   end
 
   def open_set(token)
     token.token = :character
 
     if token.type == :subset
-      @set << CharacterSubSet.new(token, active_opts)
+      current_set << CharacterSubSet.new(token, active_opts)
     else
-      @node << (@set = CharacterSet.new(token, active_opts))
+      self.current_set = CharacterSet.new(token, active_opts)
+      node << current_set
     end
   end
 
   def negate_set
-    @set.negate
+    current_set.negate
   end
 
   def append_set(token)
-    @set << token.text
+    current_set << token.text
   end
 
   def close_set(token)
-    @set.close
+    current_set.close
   end
 
   def active_opts
-    @options_stack.last
+    options_stack.last
   end
 end # module Regexp::Parser