rack-mount 0.6.1 → 0.6.2

data/lib/rack/mount/strexp.rb

@@ -1,65 +1,68 @@
 require 'rack/mount/strexp/parser'
 
 module Rack::Mount
-  class Strexp < Regexp
-    # Parses segmented string expression and converts it into a Regexp
-    #
-    #   Strexp.compile('foo')
-    #     # => %r{\Afoo\Z}
-    #
-    #   Strexp.compile('foo/:bar', {}, ['/'])
-    #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
-    #
-    #   Strexp.compile(':foo.example.com')
-    #     # => %r{\A(?<foo>.+)\.example\.com\Z}
-    #
-    #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
-    #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
-    #
-    #   Strexp.compile('foo(.:extension)')
-    #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
-    #
-    #   Strexp.compile('src/*files')
-    #     # => %r{\Asrc/(?<files>.+)\Z}
-    def initialize(str, requirements = {}, separators = [], anchor = true)
-      return super(str) if str.is_a?(Regexp)
+  class Strexp
+    class << self
+      # Parses segmented string expression and converts it into a Regexp
+      #
+      #   Strexp.compile('foo')
+      #     # => %r{\Afoo\Z}
+      #
+      #   Strexp.compile('foo/:bar', {}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
+      #
+      #   Strexp.compile(':foo.example.com')
+      #     # => %r{\A(?<foo>.+)\.example\.com\Z}
+      #
+      #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
+      #
+      #   Strexp.compile('foo(.:extension)')
+      #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
+      #
+      #   Strexp.compile('src/*files')
+      #     # => %r{\Asrc/(?<files>.+)\Z}
+      def compile(str, requirements = {}, separators = [], anchor = true)
+        return Regexp.compile(str) if str.is_a?(Regexp)
 
-      requirements = requirements ? requirements.dup : {}
-      normalize_requirements!(requirements, separators)
+        requirements = requirements ? requirements.dup : {}
+        normalize_requirements!(requirements, separators)
 
-      parser = StrexpParser.new
-      parser.anchor = anchor
-      parser.requirements = requirements
+        parser = StrexpParser.new
+        parser.anchor = anchor
+        parser.requirements = requirements
 
-      begin
-        re = parser.scan_str(str)
-      rescue Racc::ParseError => e
-        raise RegexpError, e.message
-      end
+        begin
+          re = parser.scan_str(str)
+        rescue Racc::ParseError => e
+          raise RegexpError, e.message
+        end
 
-      super(re)
-    end
+        Regexp.compile(re)
+      end
+      alias_method :new, :compile
 
-    private
-      def normalize_requirements!(requirements, separators)
-        requirements.each do |key, value|
-          if value.is_a?(Regexp)
-            if regexp_has_modifiers?(value)
-              requirements[key] = value
+      private
+        def normalize_requirements!(requirements, separators)
+          requirements.each do |key, value|
+            if value.is_a?(Regexp)
+              if regexp_has_modifiers?(value)
+                requirements[key] = value
+              else
+                requirements[key] = value.source
+              end
             else
-              requirements[key] = value.source
+              requirements[key] = Regexp.escape(value)
             end
-          else
-            requirements[key] = Regexp.escape(value)
           end
+          requirements.default ||= separators.any? ?
+            "[^#{separators.join}]+" : '.+'
+          requirements
         end
-        requirements.default ||= separators.any? ?
-          "[^#{separators.join}]+" : '.+'
-        requirements
-      end
 
-      def regexp_has_modifiers?(regexp)
-        regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
-      end
+        def regexp_has_modifiers?(regexp)
+          regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
+        end
+    end
   end
 end

data/lib/rack/mount/utils.rb

@@ -124,13 +124,13 @@ module Rack::Mount
 
       unless Reginald.regexp_supports_named_captures?
         tag_captures = Proc.new do |group|
-          group.each do |child|
-            if child.is_a?(Reginald::Group)
-              child.name = regexp.names[child.index] if child.index
-              tag_captures.call(child)
-            elsif child.is_a?(Reginald::Expression)
-              tag_captures.call(child)
-            end
+          case group
+          when Reginald::Group
+            # TODO: dup instead of mutating
+            group.instance_variable_set('@name', regexp.names[group.index]) if group.index
+            tag_captures.call(group.expression)
+          when Reginald::Expression
+            group.each { |child| tag_captures.call(child) }
           end
         end
         tag_captures.call(expression)

data/lib/rack/mount/vendor/reginald/reginald.rb

@@ -7,6 +7,7 @@ module Reginald
   autoload :Collection, 'reginald/collection'
   autoload :Expression, 'reginald/expression'
   autoload :Group, 'reginald/group'
+  autoload :Options, 'reginald/options'
   autoload :Parser, 'reginald/parser'
 
   class << self
@@ -38,7 +39,7 @@ module Reginald
     def compile(source)
       regexp = Regexp.compile(source)
       expression = parse(regexp)
-      Regexp.compile(expression.to_s(true), expression.options)
+      Regexp.compile(expression.to_s(true), expression.flags)
     end
   end
 end

data/lib/rack/mount/vendor/reginald/reginald/alternation.rb

@@ -11,11 +11,17 @@ module Reginald
     end
 
     def initialize(*args)
+      args, options = extract_options(args)
+
       if args.length == 1 && args.first.instance_of?(Array)
         super(args.first)
       else
         super(args)
       end
+
+      if options.key?(:ignorecase)
+        map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
+      end
     end
 
     # Returns true if expression could be treated as a literal string.
@@ -25,10 +31,14 @@ module Reginald
       false
     end
 
-    def options
+    def flags
       0
     end
 
+    def dup(options = {})
+      self.class.new(to_a, options)
+    end
+
     def to_s(parent = false)
       map { |e| e.to_s(parent) }.join('|')
     end

data/lib/rack/mount/vendor/reginald/reginald/atom.rb

@@ -1,10 +1,14 @@
 module Reginald
-  class Atom < Struct.new(:value)
-    attr_accessor :ignorecase
+  class Atom
+    attr_reader :value, :ignorecase
 
-    def initialize(*args)
-      @ignorecase = nil
-      super
+    def initialize(value, options = {})
+      @value = value
+      @ignorecase = options[:ignorecase]
+    end
+
+    def option_names
+      %w( ignorecase )
     end
 
     # Returns true if expression could be treated as a literal string.
@@ -16,6 +20,14 @@ module Reginald
       ignorecase ? true : false
     end
 
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(value, original_options.merge(options))
+    end
+
     def to_s(parent = false)
       "#{value}"
     end

data/lib/rack/mount/vendor/reginald/reginald/character.rb

@@ -1,6 +1,15 @@
 module Reginald
   class Character < Atom
-    attr_accessor :quantifier
+    attr_reader :quantifier
+
+    def initialize(value, options = {})
+      @quantifier = options[:quantifier]
+      super
+    end
+
+    def option_names
+      %w( quantifier ) + super
+    end
 
     # Returns true if expression could be treated as a literal string.
     #
@@ -38,7 +47,7 @@ module Reginald
     end
 
     def freeze #:nodoc:
-      quantifier.freeze
+      quantifier.freeze if quantifier
       super
     end
   end

data/lib/rack/mount/vendor/reginald/reginald/character_class.rb

@@ -1,27 +1,15 @@
 module Reginald
   class CharacterClass < Character
-    ALNUM = new(':alnum:').freeze
-    ALPHA = new(':alpha:').freeze
-    ASCII = new(':ascii:').freeze
-    BLANK = new(':blank:').freeze
-    CNTRL = new(':cntrl:').freeze
-    DIGIT = new(':digit:').freeze
-    GRAPH = new(':graph:').freeze
-    LOWER = new(':lower:').freeze
-    PRINT = new(':print:').freeze
-    PUNCT = new(':punct:').freeze
-    SPACE = new(':space:').freeze
-    UPPER = new(':upper:').freeze
-    WORD = new(':word:').freeze
-    XDIGIT = new(':xdigit:').freeze
+    def initialize(value, options = {})
+      @negate = options[:negate]
+      super
+    end
 
-    def ignorecase=(ignorecase)
-      if to_s !~ /\A\[:.*:\]\Z/
-        super
-      end
+    def option_names
+      %w( negate ) + super
     end
 
-    attr_accessor :negate
+    attr_reader :negate
 
     def negated?
       negate ? true : false
@@ -60,7 +48,7 @@ module Reginald
     end
 
     def freeze #:nodoc:
-      negate.freeze
+      negate.freeze if negate
       super
     end
   end

data/lib/rack/mount/vendor/reginald/reginald/collection.rb

@@ -1,12 +1,7 @@
 module Reginald
   class Collection < Array
-    def ignorecase=(ignorecase)
-      each { |e| e.ignorecase = ignorecase }
-      ignorecase
-    end
-
     def to_regexp
-      Regexp.compile("\\A#{to_s(true)}\\Z", options)
+      Regexp.compile("\\A#{to_s(true)}\\Z", flags)
     end
 
     def match(char)
@@ -36,5 +31,14 @@ module Reginald
       each { |e| e.freeze }
       super
     end
+
+    protected
+      def extract_options(args)
+        if args.last.is_a?(Hash)
+          return args[0..-2], args.last
+        else
+          return args, {}
+        end
+      end
   end
 end

data/lib/rack/mount/vendor/reginald/reginald/expression.rb

@@ -15,6 +15,8 @@ module Reginald
     end
 
     def initialize(*args)
+      args, options = extract_options(args)
+
       @multiline = @ignorecase = @extended = nil
 
       if args.length == 1 && args.first.instance_of?(Array)
@@ -23,15 +25,10 @@ module Reginald
         args = args.map { |e| e.instance_of?(String) ? Character.new(e) : e }
         super(args)
       end
-    end
 
-    def ignorecase=(ignorecase)
-      if @ignorecase.nil?
-        super
-        @ignorecase = ignorecase
-      else
-        false
-      end
+      self.multiline  = options[:multiline] if options.key?(:multiline)
+      self.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      self.extended   = options[:extended] if options.key?(:extended)
     end
 
     # Returns true if expression could be treated as a literal string.
@@ -65,23 +62,24 @@ module Reginald
       anchored_to_end? || (last.is_a?(Anchor) && last == '$')
     end
 
-    def options
-      flag = 0
-      flag |= Regexp::MULTILINE if multiline
-      flag |= Regexp::IGNORECASE if ignorecase
-      flag |= Regexp::EXTENDED if extended
-      flag
+    def options?
+      options.any?(true)
+    end
+
+    def flags
+      options.to_i
     end
 
-    def options=(flag)
-      self.multiline  = flag & Regexp::MULTILINE != 0
-      self.ignorecase = flag & Regexp::IGNORECASE != 0
-      self.extended   = flag & Regexp::EXTENDED != 0
-      nil
+    def dup(options = {})
+      expression = super()
+      expression.multiline  = options[:multiline] if options.key?(:multiline)
+      expression.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      expression.extended   = options[:extended] if options.key?(:extended)
+      expression
     end
 
     def to_s(parent = false)
-      if parent || options == 0
+      if parent || !options?
         map { |e| e.to_s(parent) }.join
       else
         with, without = [], []
@@ -110,5 +108,17 @@ module Reginald
         !!self.ignorecase == !!other.ignorecase &&
         !!self.extended == !!other.extended
     end
+
+    protected
+      def options
+        Options.new(multiline, ignorecase, extended)
+      end
+
+      def ignorecase=(ignorecase)
+        if @ignorecase.nil?
+          map! { |e| e.dup(:ignorecase => ignorecase) }
+          @ignorecase = ignorecase
+        end
+      end
   end
 end

data/lib/rack/mount/vendor/reginald/reginald/group.rb

@@ -1,14 +1,20 @@
 module Reginald
-  class Group < Struct.new(:expression)
-    attr_accessor :quantifier, :capture, :index, :name
+  class Group
+    attr_reader :expression, :quantifier, :capture, :index, :name
 
-    def initialize(*args)
+    def initialize(expression, options = {})
+      @quantifier = @index = @name = nil
       @capture = true
-      super
+      @expression = expression.dup(options)
+
+      @quantifier = options[:quantifier] if options.key?(:quantifier)
+      @capture    = options[:capture] if options.key?(:capture)
+      @index      = options[:index] if options.key?(:index)
+      @name       = options[:name] if options.key?(:name)
     end
 
-    def ignorecase=(ignorecase)
-      expression.ignorecase = ignorecase
+    def option_names
+      %w( quantifier capture index name )
     end
 
     # Returns true if expression could be treated as a literal string.
@@ -19,7 +25,7 @@ module Reginald
     end
 
     def to_s(parent = false)
-      if expression.options == 0
+      if !expression.options?
         "(#{capture ? '' : '?:'}#{expression.to_s(parent)})#{quantifier}"
       elsif capture == false
         "#{expression.to_s}#{quantifier}"
@@ -32,6 +38,14 @@ module Reginald
       Regexp.compile("\\A#{to_s}\\Z")
     end
 
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(expression, original_options.merge(options))
+    end
+
     def inspect #:nodoc:
       to_s.inspect
     end
@@ -67,7 +81,7 @@ module Reginald
     end
 
     def freeze #:nodoc:
-      expression.freeze
+      expression.freeze if expression
       super
     end
   end