rack-mount 0.0.1 → 0.6.13

data/lib/rack/mount/utils.rb

@@ -1,5 +1,10 @@
-require 'rack/mount/regexp_with_named_groups'
-require 'strscan'
+begin
+  require 'regin'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin'))
+  require 'regin'
+end
+
 require 'uri'
 
 module Rack::Mount
@@ -9,6 +14,19 @@ module Rack::Mount
   # more appropriate contexts.
   #++
   module Utils
+    def silence_debug
+      old_debug, $DEBUG = $DEBUG, nil
+      yield
+    ensure
+      $DEBUG = old_debug
+    end
+    module_function :silence_debug
+
+    def debug(msg)
+      warn "Rack::Mount #{msg}" if $DEBUG
+    end
+    module_function :debug
+
     # Normalizes URI path.
     #
     # Strips off trailing slash and ensures there is a leading slash.
@@ -19,25 +37,26 @@ module Rack::Mount
     #   normalize_path("")      # => "/"
     def normalize_path(path)
       path = "/#{path}"
-      path.squeeze!(Const::SLASH)
-      path.sub!(%r{/+\Z}, Const::EMPTY_STRING)
-      path = Const::SLASH if path == Const::EMPTY_STRING
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
       path
     end
     module_function :normalize_path
 
     # Removes trailing nils from array.
     #
-    #   pop_trailing_nils!([1, 2, 3])           # => [1, 2, 3]
-    #   pop_trailing_nils!([1, 2, 3, nil, nil]) # => [1, 2, 3]
-    #   pop_trailing_nils!([nil])               # => []
-    def pop_trailing_nils!(ary)
-      while ary.length > 0 && ary.last.nil?
+    #   pop_trailing_blanks!([1, 2, 3])           # => [1, 2, 3]
+    #   pop_trailing_blanks!([1, 2, 3, nil, ""])  # => [1, 2, 3]
+    #   pop_trailing_blanks!([nil])               # => []
+    #   pop_trailing_blanks!([""])                # => []
+    def pop_trailing_blanks!(ary)
+      while ary.length > 0 && (ary.last.nil? || ary.last == '')
         ary.pop
       end
       ary
     end
-    module_function :pop_trailing_nils!
+    module_function :pop_trailing_blanks!
 
     RESERVED_PCHAR = ':@&=+$,;%'
     SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}"
@@ -47,14 +66,16 @@ module Rack::Mount
       UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false, 'N').freeze
     end
 
+    Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
     def escape_uri(uri)
-      URI.escape(uri.to_s, UNSAFE_PCHAR)
+      Parser.escape(uri.to_s, UNSAFE_PCHAR)
     end
     module_function :escape_uri
 
     if ''.respond_to?(:force_encoding)
       def unescape_uri(uri)
-        URI.unescape(uri).force_encoding('utf-8')
+        Parser.unescape(uri).force_encoding('utf-8')
       end
     else
       def unescape_uri(uri)
@@ -72,33 +93,17 @@ module Rack::Mount
         }.join("&")
       when Hash
         value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+          build_nested_query(v, prefix ? "#{prefix}[#{Rack::Utils.escape(k)}]" : Rack::Utils.escape(k))
         }.join("&")
       when String
         raise ArgumentError, "value must be a Hash" if prefix.nil?
-        "#{Rack::Utils.escape(prefix)}=#{Rack::Utils.escape(value)}"
-      when NilClass
-        Rack::Utils.escape(prefix)
+        "#{prefix}=#{Rack::Utils.escape(value)}"
       else
-        if value.respond_to?(:to_param)
-          build_nested_query(value.to_param.to_s, prefix)
-        else
-          Rack::Utils.escape(prefix)
-        end
+        prefix
       end
     end
     module_function :build_nested_query
 
-    def normalize_extended_expression(regexp)
-      return regexp unless regexp.options & Regexp::EXTENDED != 0
-      source = regexp.source
-      source.gsub!(/#.+$/, '')
-      source.gsub!(/\s+/, '')
-      source.gsub!(/\\\//, '/')
-      Regexp.compile(source)
-    end
-    module_function :normalize_extended_expression
-
     # Determines whether the regexp must match the entire string.
     #
     #   regexp_anchored?(/^foo$/) # => true
@@ -106,166 +111,52 @@ module Rack::Mount
     #   regexp_anchored?(/^foo/)  # => false
     #   regexp_anchored?(/foo$/)  # => false
     def regexp_anchored?(regexp)
-      regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/ ? true : false
+     regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/m ? true : false
     end
     module_function :regexp_anchored?
 
-    # Returns static string source of Regexp if it only includes static
-    # characters and no metacharacters. Otherwise the original Regexp is
-    # returned.
-    #
-    #   extract_static_regexp(/^foo$/)      # => "foo"
-    #   extract_static_regexp(/^foo\.bar$/) # => "foo.bar"
-    #   extract_static_regexp(/^foo|bar$/)  # => /^foo|bar$/
-    def extract_static_regexp(regexp, options = nil)
-      if regexp.is_a?(String)
-        regexp = Regexp.compile("\\A#{regexp}\\Z", options)
-      end
-
-      # Just return if regexp is case-insensitive
-      return regexp if regexp.casefold?
-
+    def normalize_extended_expression(regexp)
+      return regexp unless regexp.options & Regexp::EXTENDED != 0
       source = regexp.source
-      if regexp_anchored?(regexp)
-        source.sub!(/^(\\A|\^)(.*)(\\Z|\$)$/, '\2')
-        unescaped_source = source.gsub(/\\/, Const::EMPTY_STRING)
-        if source == Regexp.escape(unescaped_source) &&
-            Regexp.compile("\\A(#{source})\\Z") =~ unescaped_source
-          return unescaped_source
-        end
-      end
-      regexp
-    end
-    module_function :extract_static_regexp
-
-    if Const::SUPPORTS_NAMED_CAPTURES
-      NAMED_CAPTURE_REGEXP = /\?<([^>]+)>/
-    else
-      NAMED_CAPTURE_REGEXP = /\?:<([^>]+)>/
-    end
-
-    # Strips shim named capture syntax and returns a clean Regexp and
-    # an ordered array of the named captures.
-    #
-    #   extract_named_captures(/[a-z]+/)          # => /[a-z]+/, []
-    #   extract_named_captures(/(?:<foo>[a-z]+)/) # => /([a-z]+)/, ['foo']
-    #   extract_named_captures(/([a-z]+)(?:<foo>[a-z]+)/)
-    #     # => /([a-z]+)([a-z]+)/, [nil, 'foo']
-    def extract_named_captures(regexp)
-      options = regexp.is_a?(Regexp) ? regexp.options : nil
-      source = Regexp.compile(regexp).source
-      names, scanner = [], StringScanner.new(source)
-
-      while scanner.skip_until(/\(/)
-        if scanner.scan(NAMED_CAPTURE_REGEXP)
-          names << scanner[1]
-        else
-          names << nil
-        end
-      end
-
-      names = [] unless names.any?
-      source.gsub!(NAMED_CAPTURE_REGEXP, Const::EMPTY_STRING)
-      return Regexp.compile(source, options), names
+      source.gsub!(/#.+$/, '')
+      source.gsub!(/\s+/, '')
+      source.gsub!(/\\\//, '/')
+      Regexp.compile(source)
     end
-    module_function :extract_named_captures
-
-    class Capture < Array #:nodoc:
-      attr_reader :name, :optional
-      alias_method :optional?, :optional
-
-      def initialize(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-
-        @name = options.delete(:name)
-        @name = @name.to_s if @name
-
-        @optional = options.delete(:optional) || false
-
-        super(args)
-      end
-
-      def ==(obj)
-        obj.is_a?(Capture) && @name == obj.name && @optional == obj.optional && super
-      end
-
-      def optionalize!
-        @optional = true
-        self
-      end
-
-      def named?
-        name && name != Const::EMPTY_STRING
-      end
-
-      def to_s
-        source = "(#{join})"
-        source << '?' if optional?
-        source
-      end
+    module_function :normalize_extended_expression
 
-      def first_part
-        first.is_a?(Capture) ? first.first_part : first
-      end
+    def parse_regexp(regexp)
+      cache = @@_parse_regexp_cache ||= {}
 
-      def last_part
-        last.is_a?(Capture) ? last.last_part : last
+      if expression = cache[regexp]
+        return expression
       end
-    end
 
-    def extract_regexp_parts(regexp) #:nodoc:
       unless regexp.is_a?(RegexpWithNamedGroups)
         regexp = RegexpWithNamedGroups.new(regexp)
       end
 
-      if regexp.source =~ /\?<([^>]+)>/
-        regexp, names = extract_named_captures(regexp)
-      else
-        names = regexp.names
-      end
-      source = regexp.source
-
-      source =~ /^(\\A|\^)/ ? source.gsub!(/^(\\A|\^)/, Const::EMPTY_STRING) :
-        raise(ArgumentError, "#{source} needs to match the start of the string")
-
-      scanner = StringScanner.new(source)
-      stack = [[]]
-
-      capture_index = 0
-      until scanner.eos?
-        char = scanner.getch
-        cur  = stack.last
-
-        escaped = cur.last.is_a?(String) && cur.last[-1, 1] == '\\'
+      expression = Regin.parse(regexp)
 
-        if char == '\\' && scanner.peek(1) == 'Z'
-          scanner.pos += 1
-          cur.push(Const::NULL)
-        elsif escaped
-          cur.push('') unless cur.last.is_a?(String)
-          cur.last << char
-        elsif char == '('
-          name = names[capture_index]
-          capture = Capture.new(:name => name)
-          capture_index += 1
-          cur.push(capture)
-          stack.push(capture)
-        elsif char == ')'
-          capture = stack.pop
-          if scanner.peek(1) == '?'
-            scanner.pos += 1
-            capture.optionalize!
+      unless Regin.regexp_supports_named_captures?
+        tag_captures = Proc.new do |group|
+          case group
+          when Regin::Group
+            # TODO: dup instead of mutating
+            group.instance_variable_set('@name', regexp.names[group.index]) if group.index
+            tag_captures.call(group.expression)
+          when Regin::Expression
+            group.each { |child| tag_captures.call(child) }
           end
-        elsif char == '$'
-          cur.push(Const::NULL)
-        else
-          cur.push('') unless cur.last.is_a?(String)
-          cur.last << char
         end
+        tag_captures.call(expression)
       end
 
-      stack.pop
+      cache[regexp] = expression.freeze
+      expression
+    rescue Racc::ParseError, Regin::Parser::ScanError
+      []
     end
-    module_function :extract_regexp_parts
+    module_function :parse_regexp
   end
 end

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

@@ -1,22 +1,24 @@
+require 'forwardable'
 require 'multiset'
 
 # Multimap is a generalization of a map or associative array
 # abstract data type in which more than one value may be associated
 # with and returned for a given key.
-class Multimap < Hash
-  #--
-  # Ignore protected aliases back to the original Hash methods
-  #++
-  module_eval %{
-    alias_method :hash_aref, :[]
-    protected :hash_aref
-
-    alias_method :hash_aset, :[]=
-    protected :hash_aset
-
-    alias_method :hash_each_pair, :each_pair
-    protected :hash_each_pair
-  }
+#
+# == Example
+#
+#   require 'multimap'
+#   map = Multimap.new
+#   map["a"] = 100
+#   map["b"] = 200
+#   map["a"] = 300
+#   map["a"]                              # -> [100, 300]
+#   map["b"]                              # -> [200]
+#   map.keys                              # -> #<Multiset: {a, a, b}>
+class Multimap
+  extend Forwardable
+
+  include Enumerable
 
   # call-seq:
   #   Multimap[ [key =>|, value]* ]   => multimap
@@ -53,7 +55,8 @@ class Multimap < Hash
       }
     end
 
-    map = super
+    map = new
+    map.instance_variable_set(:@hash, Hash[*args])
     map.default = default
     map
   end
@@ -70,20 +73,24 @@ class Multimap < Hash
   #   h["a"]           #=> [100].to_set
   #   h["c"]           #=> [].to_set
   def initialize(default = [])
-    super
+    @hash = Hash.new(default)
   end
 
   def initialize_copy(original) #:nodoc:
-    super
-    clear
-    original.each_pair { |key, container| self[key] = container }
-    self.default = original.default.dup
+    @hash = Hash.new(original.default.dup)
+    original._internal_hash.each_pair do |key, container|
+      @hash[key] = container.dup
+    end
   end
 
-  #--
-  # Setting a default proc is not supported
-  #++
-  undef :default_proc
+  def_delegators :@hash, :clear, :default, :default=, :empty?,
+                         :fetch, :has_key?, :key?
+
+  # Retrieves the <i>value</i> object corresponding to the
+  # <i>*keys</i> object.
+  def [](key)
+    @hash[key]
+  end
 
   # call-seq:
   #   map[key] = value        => value
@@ -118,9 +125,9 @@ class Multimap < Hash
   #   map.delete("a")      #=> [100]
   def delete(key, value = nil)
     if value
-      hash_aref(key).delete(value)
+      @hash[key].delete(value)
     else
-      super(key)
+      @hash.delete(key)
     end
   end
 
@@ -157,14 +164,9 @@ class Multimap < Hash
   #
   #   a is [100]
   #   b is [200, 300]
-  def each_association
-    # each_pair
+  def each_association(&block)
+    @hash.each_pair(&block)
   end
-  #--
-  # Ignore alias_method since the definition above serves
-  # as its documentation.
-  #++
-  module_eval "alias_method :each_association, :each_pair"
 
   # call-seq:
   #   map.each_container { |container| block } => map
@@ -247,6 +249,24 @@ class Multimap < Hash
     end
   end
 
+  def ==(other) #:nodoc:
+    case other
+    when Multimap
+      @hash == other._internal_hash
+    else
+      @hash == other
+    end
+  end
+
+  def eql?(other) #:nodoc:
+    case other
+    when Multimap
+      @hash.eql?(other._internal_hash)
+    else
+      @hash.eql?(other)
+    end
+  end
+
   def freeze #:nodoc:
     each_container { |container| container.freeze }
     default.freeze
@@ -282,6 +302,48 @@ class Multimap < Hash
     invert[value]
   end
 
+  # call-seq:
+  #   map.delete_if {| key, value | block }  -> map
+  #
+  # Deletes every key-value pair from <i>map</i> for which <i>block</i>
+  # evaluates to <code>true</code>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.delete_if {|key, value| value >= 300 }
+  #     #=> Multimap["a" => 100, "b" => 200]
+  #
+  def delete_if
+    each_association do |key, container|
+      container.delete_if do |value|
+        yield [key, value]
+      end
+    end
+    self
+  end
+
+  # call-seq:
+  #   map.reject {| key, value | block }  -> map
+  #
+  # Same as <code>Multimap#delete_if</code>, but works on (and returns) a
+  # copy of the <i>map</i>. Equivalent to
+  # <code><i>map</i>.dup.delete_if</code>.
+  #
+  def reject(&block)
+    dup.delete_if(&block)
+  end
+
+  # call-seq:
+  #   map.reject! {| key, value | block }  -> map or nil
+  #
+  # Equivalent to <code>Multimap#delete_if</code>, but returns
+  # <code>nil</code> if no changes were made.
+  #
+  def reject!(&block)
+    old_size = size
+    delete_if(&block)
+    old_size == size ? nil : self
+  end
+
   # call-seq:
   #   map.replace(other_map) => map
   #
@@ -294,11 +356,11 @@ class Multimap < Hash
   def replace(other)
     case other
     when Array
-      super(self.class[self.default, *other])
+      @hash.replace(self.class[self.default, *other])
     when Hash
-      super(self.class[self.default, other])
+      @hash.replace(self.class[self.default, other])
     when self.class
-      super
+      @hash.replace(other)
     else
       raise ArgumentError
     end
@@ -332,6 +394,12 @@ class Multimap < Hash
     keys
   end
 
+  # Returns true if the given key is present in Multimap.
+  def include?(key)
+    keys.include?(key)
+  end
+  alias_method :member?, :include?
+
   # call-seq:
   #   map.length    =>  fixnum
   #   map.size      =>  fixnum
@@ -425,7 +493,7 @@ class Multimap < Hash
   #   map = Multimap["a" => 100, "b" => [200, 300]]
   #   map.to_hash   #=> { "a" => [100], "b" => [200, 300] }
   def to_hash
-    dup
+    @hash.dup
   end
 
   # call-seq:
@@ -456,11 +524,46 @@ class Multimap < Hash
     values
   end
 
+  # Return an array containing the values associated with the given keys.
+  def values_at(*keys)
+    @hash.values_at(*keys)
+  end
+
+  def marshal_dump #:nodoc:
+    @hash
+  end
+
+  def marshal_load(hash) #:nodoc:
+    @hash = hash
+  end
+
+  def to_yaml(opts = {}) #:nodoc:
+    YAML::quick_emit(self, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        @hash.each do |k, v|
+          map.add(k, v)
+        end
+        map.add('__default__', @hash.default)
+      end
+    end
+  end
+
+  def yaml_initialize(tag, val) #:nodoc:
+    default = val.delete('__default__')
+    @hash = val
+    @hash.default = default
+    self
+  end
+
   protected
+    def _internal_hash #:nodoc:
+      @hash
+    end
+
     def update_container(key) #:nodoc:
-      container = hash_aref(key)
+      container = @hash[key]
       container = container.dup if container.equal?(default)
       container = yield(container)
-      hash_aset(key, container)
+      @hash[key] = container
     end
 end

data/lib/rack/mount/vendor/multimap/multiset.rb

@@ -1,7 +1,16 @@
 require 'set'
 
 # Multiset implements a collection of unordered values and
-# allows duplicate values.
+# allows duplicates.
+#
+# == Example
+#
+#   require 'multiset'
+#   s1 = Multiset.new [1, 2]              # -> #<Multiset: {1, 2}>
+#   s1.add(2)                             # -> #<Multiset: {1, 2, 2}>
+#   s1.merge([2, 6])                      # -> #<Multiset: {1, 2, 2, 2, 3}>
+#   s1.multiplicity(2)                    # -> 3
+#   s1.multiplicity(3)                    # -> 1
 class Multiset < Set
   def initialize(*args, &block) #:nodoc:
     @hash = Hash.new(0)
@@ -150,4 +159,27 @@ class Multiset < Set
     superset?(set) && subset?(set)
   end
   alias_method :==, :eql?
+
+  def marshal_dump #:nodoc:
+    @hash
+  end
+
+  def marshal_load(hash) #:nodoc:
+    @hash = hash
+  end
+
+  def to_yaml(opts = {}) #:nodoc:
+    YAML::quick_emit(self, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        @hash.each do |k, v|
+          map.add(k, v)
+        end
+      end
+    end
+  end
+
+  def yaml_initialize(tag, val) #:nodoc:
+    @hash = val
+    self
+  end
 end

data/lib/rack/mount/vendor/multimap/nested_multimap.rb

@@ -45,7 +45,7 @@ class NestedMultimap < Multimap
   #   map["a"] #=> [100, 300]
   #   map["c"] #=> [300]
   def <<(value)
-    hash_each_pair { |_, container| container << value }
+    @hash.each_value { |container| container << value }
     self.default << value
     self
   end
@@ -59,7 +59,7 @@ class NestedMultimap < Multimap
   def [](*keys)
     i, l, r, k = 0, keys.length, self, self.class
     while r.is_a?(k)
-      r = i < l ? r.hash_aref(keys[i]) : r.default
+      r = i < l ? r._internal_hash[keys[i]] : r.default
       i += 1
     end
     r
@@ -83,7 +83,7 @@ class NestedMultimap < Multimap
   #   ["a", "b"] is [100, 101, 102]
   #   "c" is [200]
   def each_association
-    super do |key, container|
+    super() do |key, container|
       if container.respond_to?(:each_association)
         container.each_association do |nested_key, value|
           yield [key, nested_key].flatten, value
@@ -111,20 +111,11 @@ class NestedMultimap < Multimap
   #   [100, 101, 102]
   #   [100, 102]
   #   []
-  def each_container_with_default
-    each_container = Proc.new do |container|
-      if container.respond_to?(:each_container_with_default)
-        container.each_container_with_default do |value|
-          yield value
-        end
-      else
-        yield container
-      end
+  def each_container_with_default(&block)
+    @hash.each_value do |container|
+      iterate_over_container(container, &block)
     end
-
-    hash_each_pair { |_, container| each_container.call(container) }
-    each_container.call(default)
-
+    iterate_over_container(default, &block)
     self
   end
 
@@ -148,6 +139,17 @@ class NestedMultimap < Multimap
   def inspect #:nodoc:
     super.gsub(/\}$/, ", default => #{default.inspect}}")
   end
+
+  private
+    def iterate_over_container(container)
+      if container.respond_to?(:each_container_with_default)
+        container.each_container_with_default do |value|
+          yield value
+        end
+      else
+        yield container
+      end
+    end
 end
 
 begin