regexp_parser 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6bc36d64eb84ebef5287ca3c866c834339b6b563
-  data.tar.gz: 59db2b321120f59697d3ce6e0c612dd745a41ffc
+  metadata.gz: de01aa2d195d95dd0bee1afd232f85195562a8bf
+  data.tar.gz: b41cb58a4e07d681da7c16473f4f03d96a792ff9
 SHA512:
-  metadata.gz: fcf1c339c360217fbb2a1c4cedfd2eeeca199a52983fe706c7d661141a93b3793e1de0901d6c935b61dad30a78c4ad7f510bfec6abdf765f2c6e6a6edb3adefa
-  data.tar.gz: d0fc3eb8fd70a252d60ed25f7472ad36e76d379d5660f5d9d28735b9faa7caf1e15bc69468849e91d20832e3249a582c53ce52b67c5a01e50b2f6325dcf1063e
+  metadata.gz: 342d6218d5553f2f2f6975f202cf650cd74c9128379348526981d829188b38836dfd88bc46b8476212d4b10aeb628479109baff075e1297c4cf69aaa4fe8ff03
+  data.tar.gz: 80883d05ff9bb3f5f9f296aeeb5eabde013a362c6d6c82f4eeab87438050f93fea2224f407b170b65ff55d175937c55f56d49077e0ad43b0a55832989e221544

data/ChangeLog

@@ -1,3 +1,16 @@
+Sun Oct 15 2017 Janosch Müller <janosch84@gmail.com>
+
+	* Fixed a thread safety issue (issue #45)
+	* Some public class methods that were only reliable for
+	  internal use are now private instance methods (PR #46)
+	* Improved the usefulness of Expression#options (issue #43) -
+	  #options and derived methods such as #i?, #m? and #x? are now
+	  defined for all Expressions that are affected by such flags.
+	* Fixed scanning of whitespace following (?x) (commit 5c94bd2)
+	* Fixed a Parser bug where the #number attribute of traditional
+	  numerical backreferences was not set correctly (commit 851b620)
+	* Bumped version to 0.4.7
+
 Mon Sep 18 2017 Janosch Müller <janosch84@gmail.com>
 
 	* Added Parser support for hex escapes in sets (PR #36)

data/README.md

@@ -125,9 +125,10 @@ Regexp::Scanner.scan( /(cat?([bhm]at)){3,5}/ ).map {|token| token[2]}
 
   * If the input is a ruby **Regexp** object, the scanner calls #source on it to
     get its string representation. #source does not include the options of
-    the expression (m, i, and x) To include the options in the scan, #to_s
-    should be called on the **Regexp** before passing it to the scanner or any
-    of the other modules.
+    the expression (m, i, and x). To include the options in the scan, #to_s
+    should be called on the **Regexp** before passing it to the scanner or the
+    lexer. For the parser, however, this is not necessary. It automatically
+    exposes the options of a passed **Regexp** in the returned root expression.
 
   * To keep the scanner simple(r) and fairly reusable for other purposes, it
     does not perform lexical analysis on the tokens, sticking to the task

data/lib/regexp_parser/expression.rb

@@ -8,7 +8,7 @@ module Regexp::Expression
     attr_accessor :quantifier
     attr_accessor :options
 
-    def initialize(token)
+    def initialize(token, options = {})
       @type               = token.type
       @token              = token.token
       @text               = token.text
@@ -17,7 +17,7 @@ module Regexp::Expression
       @set_level          = token.set_level
       @conditional_level  = token.conditional_level
       @quantifier         = nil
-      @options            = nil
+      @options            = options
     end
 
     def clone
@@ -95,35 +95,35 @@ module Regexp::Expression
     end
 
     def multiline?
-      (@options and @options[:m]) ? true : false
+      @options[:m] == true
     end
     alias :m? :multiline?
 
     def case_insensitive?
-      (@options and @options[:i]) ? true : false
+      @options[:i] == true
     end
     alias :i? :case_insensitive?
     alias :ignore_case? :case_insensitive?
 
     def free_spacing?
-      (@options and @options[:x]) ? true : false
+      @options[:x] == true
     end
     alias :x? :free_spacing?
     alias :extended? :free_spacing?
 
     if RUBY_VERSION >= '2.0'
       def default_classes?
-        (@options and @options[:d]) ? true : false
+        @options[:d] == true
       end
       alias :d? :default_classes?
 
       def ascii_classes?
-        (@options and @options[:a]) ? true : false
+        @options[:a] == true
       end
       alias :a? :ascii_classes?
 
       def unicode_classes?
-        (@options and @options[:u]) ? true : false
+        @options[:u] == true
       end
       alias :u? :unicode_classes?
     end

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

@@ -6,18 +6,18 @@ module Regexp::Expression
     class Name < Backreference::Base
       attr_reader :name
 
-      def initialize(token)
+      def initialize(token, options = {})
         @name = token.text[3..-2]
-        super(token)
+        super
       end
     end
 
     class Number < Backreference::Base
       attr_reader :number
 
-      def initialize(token)
-        @number = token.text[3..-2]
-        super(token)
+      def initialize(token, options = {})
+        @number = token.text[token.token.equal?(:number) ? 1..-1 : 3..-2]
+        super
       end
     end
 
@@ -29,9 +29,9 @@ module Regexp::Expression
     class NameCall < Backreference::Base
       attr_reader :name
 
-      def initialize(token)
+      def initialize(token, options = {})
         @name = token.text[3..-2]
-        super(token)
+        super
       end
     end
 

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

@@ -11,8 +11,8 @@ module Regexp::Expression
     class Branch    < Regexp::Expression::Sequence; end
 
     class Expression < Regexp::Expression::Subexpression
-      def initialize(token)
-        super(token)
+      def initialize(token, options = {})
+        super
 
         @condition = nil
         @branches  = []

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

@@ -36,9 +36,9 @@ module Regexp::Expression
     class Named     < Group::Capture
       attr_reader :name
 
-      def initialize(token)
+      def initialize(token, options = {})
         @name = token.text[3..-2]
-        super(token)
+        super
       end
 
       def clone

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

@@ -1,26 +1,12 @@
 module Regexp::Expression
 
   class Root < Regexp::Expression::Subexpression
-    def initialize
-      super Regexp::Token.new(:expression, :root, '', 0)
+    def initialize(options = {})
+      super(Regexp::Token.new(:expression, :root, '', 0), options)
     end
 
-    def multiline?
-      @expressions[0].m?
-    end
-    alias :m? :multiline?
-
-    def case_insensitive?
-      @expressions[0].i?
-    end
-    alias :i? :case_insensitive?
-    alias :ignore_case? :case_insensitive?
-
-    def free_spacing?
-      @expressions[0].x?
-    end
-    alias :x? :free_spacing?
-    alias :extended? :free_spacing?
+    alias ignore_case? case_insensitive?
+    alias extended?    free_spacing?
   end
 
 end

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

@@ -3,7 +3,7 @@ module Regexp::Expression
   class CharacterSet < Regexp::Expression::Base
     attr_accessor :members
 
-    def initialize(token)
+    def initialize(token, options = {})
       @members  = []
       @negative = false
       @closed   = false

data/lib/regexp_parser/expression/subexpression.rb

@@ -3,8 +3,8 @@ module Regexp::Expression
   class Subexpression < Regexp::Expression::Base
     attr_accessor :expressions
 
-    def initialize(token)
-      super(token)
+    def initialize(token, options = {})
+      super
 
       @expressions = []
     end

data/lib/regexp_parser/lexer.rb

@@ -2,7 +2,7 @@
 # collects emitted tokens into an array, calculates their nesting depth, and
 # normalizes tokens for the parser, and checks if they are implemented by the
 # given syntax flavor.
-module Regexp::Lexer
+class Regexp::Lexer
 
   OPENING_TOKENS = [:capture, :options, :passive, :atomic, :named, :absence,
                     :lookahead, :nlookahead, :lookbehind, :nlookbehind
@@ -11,6 +11,10 @@ module Regexp::Lexer
   CLOSING_TOKENS = [:close].freeze
 
   def self.lex(input, syntax = "ruby/#{RUBY_VERSION}", &block)
+    new.lex(input, syntax, &block)
+  end
+
+  def lex(input, syntax = "ruby/#{RUBY_VERSION}", &block)
     syntax = Regexp::Syntax.new(syntax)
 
     @tokens = []
@@ -57,7 +61,7 @@ module Regexp::Lexer
 
   protected
 
-  def self.ascend(type, token)
+  def ascend(type, token)
     if type == :group or type == :assertion
       @nesting -= 1 if CLOSING_TOKENS.include?(token)
     end
@@ -71,7 +75,7 @@ module Regexp::Lexer
     end
   end
 
-  def self.descend(type, token)
+  def descend(type, token)
     if type == :group or type == :assertion
       @nesting += 1 if OPENING_TOKENS.include?(token)
     end
@@ -87,7 +91,7 @@ module Regexp::Lexer
 
   # called by scan to break a literal run that is longer than one character
   # into two separate tokens when it is followed by a quantifier
-  def self.break_literal(token)
+  def break_literal(token)
     text = token.text
     if text.scan(/./mu).length > 1
       lead = text.sub(/.\z/mu, "")
@@ -113,7 +117,7 @@ module Regexp::Lexer
 
   # 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 self.merge_literal(current)
+  def merge_literal(current)
     last = @tokens.pop
 
     Regexp::Token.new(
@@ -128,7 +132,7 @@ module Regexp::Lexer
     )
   end
 
-  def self.merge_condition(current)
+  def merge_condition(current)
     last = @tokens.pop
     Regexp::Token.new(:conditional, :condition, last.text + current.text,
       last.ts, current.te, @nesting, @set_nesting, @conditional_nesting)

data/lib/regexp_parser/parser.rb

@@ -1,6 +1,6 @@
 require 'regexp_parser/expression'
 
-module Regexp::Parser
+class Regexp::Parser
   include Regexp::Expression
   include Regexp::Syntax
 
@@ -19,8 +19,14 @@ module Regexp::Parser
   end
 
   def self.parse(input, syntax = "ruby/#{RUBY_VERSION}", &block)
-    @nesting = [@root = @node = Root.new]
+    new.parse(input, syntax, &block)
+  end
+
+  def parse(input, syntax = "ruby/#{RUBY_VERSION}", &block)
+    @nesting = [@root = @node = Root.new(options_from_input(input))]
 
+    @options_stack = [@root.options]
+    @switching_options = false
     @conditional_nesting = []
 
     Regexp::Lexer.scan(input, syntax) do |token|
@@ -34,21 +40,33 @@ module Regexp::Parser
     end
   end
 
-  def self.nest(exp)
+  private
+
+  def options_from_input(input)
+    return {} unless input.is_a?(::Regexp)
+
+    options = {}
+    options[:i] = true if input.options & ::Regexp::IGNORECASE != 0
+    options[:m] = true if input.options & ::Regexp::MULTILINE  != 0
+    options[:x] = true if input.options & ::Regexp::EXTENDED   != 0
+    options
+  end
+
+  def nest(exp)
     @nesting.push exp
 
     @node << exp
     @node  = exp
   end
 
-  def self.nest_conditional(exp)
+  def nest_conditional(exp)
     @conditional_nesting.push exp
 
     @node << exp
     @node  = exp
   end
 
-  def self.parse_token(token)
+  def parse_token(token)
     case token.type
     when :meta;         meta(token)
     when :quantifier;   quantifier(token)
@@ -66,7 +84,7 @@ module Regexp::Parser
       property(token)
 
     when :literal
-      @node << Literal.new(token)
+      @node << Literal.new(token, active_opts)
     when :free_space
       free_space(token)
 
@@ -75,7 +93,7 @@ module Regexp::Parser
     end
   end
 
-  def self.set(token)
+  def set(token)
     case token.token
     when :open
       open_set(token)
@@ -96,14 +114,14 @@ module Regexp::Parser
     end
   end
 
-  def self.meta(token)
+  def meta(token)
     case token.token
     when :dot
-      @node << CharacterType::Any.new(token)
+      @node << CharacterType::Any.new(token, active_opts)
     when :alternation
       unless @node.token == :alternation
         unless @node.last.is_a?(Alternation)
-          alt = Alternation.new(token)
+          alt = Alternation.new(token, active_opts)
           seq = Alternative.new(alt.level, alt.set_level, alt.conditional_level)
 
           while @node.expressions.last
@@ -126,62 +144,62 @@ module Regexp::Parser
     end
   end
 
-  def self.backref(token)
+  def backref(token)
     case token.token
     when :name_ref
-      @node << Backreference::Name.new(token)
+      @node << Backreference::Name.new(token, active_opts)
     when :name_nest_ref
-      @node << Backreference::NameNestLevel.new(token)
+      @node << Backreference::NameNestLevel.new(token, active_opts)
     when :name_call
-      @node << Backreference::NameCall.new(token)
+      @node << Backreference::NameCall.new(token, active_opts)
     when :number, :number_ref
-      @node << Backreference::Number.new(token)
+      @node << Backreference::Number.new(token, active_opts)
     when :number_rel_ref
-      @node << Backreference::NumberRelative.new(token)
+      @node << Backreference::NumberRelative.new(token, active_opts)
     when :number_nest_ref
-      @node << Backreference::NumberNestLevel.new(token)
+      @node << Backreference::NumberNestLevel.new(token, active_opts)
     when :number_call
-      @node << Backreference::NumberCall.new(token)
+      @node << Backreference::NumberCall.new(token, active_opts)
     when :number_rel_call
-      @node << Backreference::NumberCallRelative.new(token)
+      @node << Backreference::NumberCallRelative.new(token, active_opts)
     else
       raise UnknownTokenError.new('Backreference', token)
     end
   end
 
-  def self.type(token)
+  def type(token)
     case token.token
     when :digit
-      @node << CharacterType::Digit.new(token)
+      @node << CharacterType::Digit.new(token, active_opts)
     when :nondigit
-      @node << CharacterType::NonDigit.new(token)
+      @node << CharacterType::NonDigit.new(token, active_opts)
     when :hex
-      @node << CharacterType::Hex.new(token)
+      @node << CharacterType::Hex.new(token, active_opts)
     when :nonhex
-      @node << CharacterType::NonHex.new(token)
+      @node << CharacterType::NonHex.new(token, active_opts)
     when :space
-      @node << CharacterType::Space.new(token)
+      @node << CharacterType::Space.new(token, active_opts)
     when :nonspace
-      @node << CharacterType::NonSpace.new(token)
+      @node << CharacterType::NonSpace.new(token, active_opts)
     when :word
-      @node << CharacterType::Word.new(token)
+      @node << CharacterType::Word.new(token, active_opts)
     when :nonword
-      @node << CharacterType::NonWord.new(token)
+      @node << CharacterType::NonWord.new(token, active_opts)
     when :linebreak
-      @node << CharacterType::Linebreak.new(token)
+      @node << CharacterType::Linebreak.new(token, active_opts)
     when :xgrapheme
-      @node << CharacterType::ExtendedGrapheme.new(token)
+      @node << CharacterType::ExtendedGrapheme.new(token, active_opts)
     else
       raise UnknownTokenError.new('CharacterType', token)
     end
   end
 
-  def self.conditional(token)
+  def conditional(token)
     case token.token
     when :open
-      nest_conditional(Conditional::Expression.new(token))
+      nest_conditional(Conditional::Expression.new(token, active_opts))
     when :condition
-      @conditional_nesting.last.condition(Conditional::Condition.new(token))
+      @conditional_nesting.last.condition(Conditional::Condition.new(token, active_opts))
       @conditional_nesting.last.branch
     when :separator
       @conditional_nesting.last.branch
@@ -200,175 +218,174 @@ module Regexp::Parser
     end
   end
 
-  def self.property(token)
-    include Regexp::Expression::UnicodeProperty
+  include Regexp::Expression::UnicodeProperty
 
+  def property(token)
     case token.token
-    when :alnum;            @node << Alnum.new(token)
-    when :alpha;            @node << Alpha.new(token)
-    when :any;              @node << Any.new(token)
-    when :ascii;            @node << Ascii.new(token)
-    when :blank;            @node << Blank.new(token)
-    when :cntrl;            @node << Cntrl.new(token)
-    when :digit;            @node << Digit.new(token)
-    when :graph;            @node << Graph.new(token)
-    when :lower;            @node << Lower.new(token)
-    when :print;            @node << Print.new(token)
-    when :punct;            @node << Punct.new(token)
-    when :space;            @node << Space.new(token)
-    when :upper;            @node << Upper.new(token)
-    when :word;             @node << Word.new(token)
-    when :xdigit;           @node << Xdigit.new(token)
-    when :newline;          @node << Newline.new(token)
-
-    when :letter_any;       @node << Letter::Any.new(token)
-    when :letter_uppercase; @node << Letter::Uppercase.new(token)
-    when :letter_lowercase; @node << Letter::Lowercase.new(token)
-    when :letter_titlecase; @node << Letter::Titlecase.new(token)
-    when :letter_modifier;  @node << Letter::Modifier.new(token)
-    when :letter_other;     @node << Letter::Other.new(token)
-
-    when :mark_any;         @node << Mark::Any.new(token)
-    when :mark_nonspacing;  @node << Mark::Nonspacing.new(token)
-    when :mark_spacing;     @node << Mark::Spacing.new(token)
-    when :mark_enclosing;   @node << Mark::Enclosing.new(token)
-
-    when :number_any;       @node << Number::Any.new(token)
-    when :number_decimal;   @node << Number::Decimal.new(token)
-    when :number_letter;    @node << Number::Letter.new(token)
-    when :number_other;     @node << Number::Other.new(token)
-
-    when :punct_any;        @node << Punctuation::Any.new(token)
-    when :punct_connector;  @node << Punctuation::Connector.new(token)
-    when :punct_dash;       @node << Punctuation::Dash.new(token)
-    when :punct_open;       @node << Punctuation::Open.new(token)
-    when :punct_close;      @node << Punctuation::Close.new(token)
-    when :punct_initial;    @node << Punctuation::Initial.new(token)
-    when :punct_final;      @node << Punctuation::Final.new(token)
-    when :punct_other;      @node << Punctuation::Other.new(token)
-
-    when :separator_any;    @node << Separator::Any.new(token)
-    when :separator_space;  @node << Separator::Space.new(token)
-    when :separator_line;   @node << Separator::Line.new(token)
-    when :separator_para;   @node << Separator::Paragraph.new(token)
-
-    when :symbol_any;       @node << Symbol::Any.new(token)
-    when :symbol_math;      @node << Symbol::Math.new(token)
-    when :symbol_currency;  @node << Symbol::Currency.new(token)
-    when :symbol_modifier;  @node << Symbol::Modifier.new(token)
-    when :symbol_other;     @node << Symbol::Other.new(token)
-
-    when :other;            @node << Codepoint::Any.new(token)
-    when :control;          @node << Codepoint::Control.new(token)
-    when :format;           @node << Codepoint::Format.new(token)
-    when :surrogate;        @node << Codepoint::Surrogate.new(token)
-    when :private_use;      @node << Codepoint::PrivateUse.new(token)
-    when :unassigned;       @node << Codepoint::Unassigned.new(token)
+    when :alnum;            @node << Alnum.new(token, active_opts)
+    when :alpha;            @node << Alpha.new(token, active_opts)
+    when :any;              @node << Any.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 :newline;          @node << Newline.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)
+      @node << Age.new(token, active_opts)
 
     when *Token::UnicodeProperty::Derived
-      @node << Derived.new(token)
+      @node << Derived.new(token, active_opts)
 
     when *Regexp::Syntax::Token::UnicodeProperty::Script
-      @node << Script.new(token)
+      @node << Script.new(token, active_opts)
 
     when *Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock
-      @node << Block.new(token)
+      @node << Block.new(token, active_opts)
 
     else
       raise UnknownTokenError.new('UnicodeProperty', token)
     end
   end
 
-  def self.anchor(token)
+  def anchor(token)
     case token.token
     when :bol
-      @node << Anchor::BeginningOfLine.new(token)
+      @node << Anchor::BeginningOfLine.new(token, active_opts)
     when :eol
-      @node << Anchor::EndOfLine.new(token)
+      @node << Anchor::EndOfLine.new(token, active_opts)
     when :bos
-      @node << Anchor::BOS.new(token)
+      @node << Anchor::BOS.new(token, active_opts)
     when :eos
-      @node << Anchor::EOS.new(token)
+      @node << Anchor::EOS.new(token, active_opts)
     when :eos_ob_eol
-      @node << Anchor::EOSobEOL.new(token)
+      @node << Anchor::EOSobEOL.new(token, active_opts)
     when :word_boundary
-      @node << Anchor::WordBoundary.new(token)
+      @node << Anchor::WordBoundary.new(token, active_opts)
     when :nonword_boundary
-      @node << Anchor::NonWordBoundary.new(token)
+      @node << Anchor::NonWordBoundary.new(token, active_opts)
     when :match_start
-      @node << Anchor::MatchStart.new(token)
+      @node << Anchor::MatchStart.new(token, active_opts)
     else
       raise UnknownTokenError.new('Anchor', token)
     end
   end
 
-  def self.escape(token)
+  def escape(token)
     case token.token
 
     when :backspace
-      @node << EscapeSequence::Backspace.new(token)
+      @node << EscapeSequence::Backspace.new(token, active_opts)
 
     when :escape
-      @node << EscapeSequence::AsciiEscape.new(token)
+      @node << EscapeSequence::AsciiEscape.new(token, active_opts)
     when :bell
-      @node << EscapeSequence::Bell.new(token)
+      @node << EscapeSequence::Bell.new(token, active_opts)
     when :form_feed
-      @node << EscapeSequence::FormFeed.new(token)
+      @node << EscapeSequence::FormFeed.new(token, active_opts)
     when :newline
-      @node << EscapeSequence::Newline.new(token)
+      @node << EscapeSequence::Newline.new(token, active_opts)
     when :carriage
-      @node << EscapeSequence::Return.new(token)
+      @node << EscapeSequence::Return.new(token, active_opts)
     when :space
-      @node << EscapeSequence::Space.new(token)
+      @node << EscapeSequence::Space.new(token, active_opts)
     when :tab
-      @node << EscapeSequence::Tab.new(token)
+      @node << EscapeSequence::Tab.new(token, active_opts)
     when :vertical_tab
-      @node << EscapeSequence::VerticalTab.new(token)
+      @node << EscapeSequence::VerticalTab.new(token, active_opts)
 
     when :control
       if token.text =~ /\A(?:\\C-\\M|\\c\\M)/
-        @node << EscapeSequence::MetaControl.new(token)
+        @node << EscapeSequence::MetaControl.new(token, active_opts)
       else
-        @node << EscapeSequence::Control.new(token)
+        @node << EscapeSequence::Control.new(token, active_opts)
       end
 
     when :meta_sequence
       if token.text =~ /\A\\M-\\[Cc]/
-        @node << EscapeSequence::MetaControl.new(token)
+        @node << EscapeSequence::MetaControl.new(token, active_opts)
       else
-        @node << EscapeSequence::Meta.new(token)
+        @node << EscapeSequence::Meta.new(token, active_opts)
       end
 
     else
       # treating everything else as a literal
-      @node << EscapeSequence::Literal.new(token)
+      @node << EscapeSequence::Literal.new(token, active_opts)
     end
   end
 
-
-  def self.keep(token)
-    @node << Keep::Mark.new(token)
+  def keep(token)
+    @node << Keep::Mark.new(token, active_opts)
   end
 
-  def self.free_space(token)
+  def free_space(token)
     case token.token
     when :comment
-      @node << Comment.new(token)
+      @node << Comment.new(token, active_opts)
     when :whitespace
       if @node.last and @node.last.is_a?(WhiteSpace)
-        @node.last.merge(WhiteSpace.new(token))
+        @node.last.merge(WhiteSpace.new(token, active_opts))
       else
-        @node << WhiteSpace.new(token)
+        @node << WhiteSpace.new(token, active_opts)
       end
     else
       raise UnknownTokenError.new('FreeSpace', token)
     end
   end
 
-  def self.quantifier(token)
+  def quantifier(token)
     offset = -1
     target_node = @node.expressions[offset]
     while target_node and target_node.is_a?(FreeSpace)
@@ -378,15 +395,6 @@ module Regexp::Parser
     raise ArgumentError.new("No valid target found for '#{token.text}' "+
                             "quantifier") unless target_node
 
-    unless target_node
-      if token.token == :zero_or_one
-        raise "Quantifier given without a target, or the syntax of the group " +
-              "or its options is incorrect"
-      else
-        raise "Quantifier `#{token.text}' given without a target"
-      end
-    end
-
     case token.token
     when :zero_or_one
       target_node.quantify(:zero_or_one, token.text, 0, 1, :greedy)
@@ -417,7 +425,7 @@ module Regexp::Parser
     end
   end
 
-  def self.interval(target_node, token)
+  def interval(target_node, token)
     text = token.text
     mchr = text[text.length-1].chr =~ /[?+]/ ? text[text.length-1].chr : nil
     case mchr
@@ -439,91 +447,113 @@ module Regexp::Parser
     target_node.quantify(:interval, text, min.to_i, max.to_i, mode)
   end
 
-  def self.group(token)
+  def group(token)
     case token.token
     when :options
-      options(token)
+      options_group(token)
     when :close
       close_group
     when :comment
-      @node << Group::Comment.new(token)
+      @node << Group::Comment.new(token, active_opts)
     else
       open_group(token)
     end
   end
 
-  def self.options(token)
-    opt = token.text.split('-', 2)
+  def options_group(token)
+    positive, negative = token.text.split('-', 2)
+    negative ||= ''
+    @switching_options = !token.text.include?(':')
+    # TODO: change this -^ to token.type == :options_switch in v1.0.0
+
+    new_options = active_opts.dup
 
-    exp = Group::Options.new(token)
-    exp.options = {
-      :m => opt[0].include?('m') ? true : false,
-      :i => opt[0].include?('i') ? true : false,
-      :x => opt[0].include?('x') ? true : false,
-      :d => opt[0].include?('d') ? true : false,
-      :a => opt[0].include?('a') ? true : false,
-      :u => opt[0].include?('u') ? true : false
-    }
+    # 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)
+    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
+    end
+
+    @options_stack << new_options
+
+    exp = Group::Options.new(token, active_opts)
 
     nest(exp)
   end
 
-  def self.open_group(token)
+  def open_group(token)
     case token.token
     when :passive
-      exp = Group::Passive.new(token)
+      exp = Group::Passive.new(token, active_opts)
     when :atomic
-      exp = Group::Atomic.new(token)
+      exp = Group::Atomic.new(token, active_opts)
     when :named
-      exp = Group::Named.new(token)
+      exp = Group::Named.new(token, active_opts)
     when :capture
-      exp = Group::Capture.new(token)
+      exp = Group::Capture.new(token, active_opts)
     when :absence
-      exp = Group::Absence.new(token)
+      exp = Group::Absence.new(token, active_opts)
 
     when :lookahead
-      exp = Assertion::Lookahead.new(token)
+      exp = Assertion::Lookahead.new(token, active_opts)
     when :nlookahead
-      exp = Assertion::NegativeLookahead.new(token)
+      exp = Assertion::NegativeLookahead.new(token, active_opts)
     when :lookbehind
-      exp = Assertion::Lookbehind.new(token)
+      exp = Assertion::Lookbehind.new(token, active_opts)
     when :nlookbehind
-      exp = Assertion::NegativeLookbehind.new(token)
+      exp = Assertion::NegativeLookbehind.new(token, active_opts)
 
     else
       raise UnknownTokenError.new('Group type open', token)
     end
 
+    # 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
+
     nest(exp)
   end
 
-  def self.close_group
+  def close_group
     @nesting.pop
+    @options_stack.pop unless @switching_options
+    @switching_options = false
 
     @node = @nesting.last
     @node = @node.last if @node.last and @node.last.is_a?(Alternation)
   end
 
-  def self.open_set(token)
+  def open_set(token)
     token.token = :character
 
     if token.type == :subset
-      @set << CharacterSubSet.new(token)
+      @set << CharacterSubSet.new(token, active_opts)
     else
-      @node << (@set = CharacterSet.new(token))
+      @node << (@set = CharacterSet.new(token, active_opts))
     end
   end
 
-  def self.negate_set
+  def negate_set
     @set.negate
   end
 
-  def self.append_set(token)
+  def append_set(token)
     @set << token.text
   end
 
-  def self.close_set(token)
+  def close_set(token)
     @set.close
   end
 
+  def active_opts
+    @options_stack.last
+  end
 end # module Regexp::Parser