rack-mount 0.6.14 → 0.7.1

data/lib/rack/mount.rb

@@ -24,7 +24,6 @@ module Rack #:nodoc:
     autoload :Version, 'rack/mount/version'
 
     module Analysis #:nodoc:
-      autoload :Frequency, 'rack/mount/analysis/frequency'
       autoload :Histogram, 'rack/mount/analysis/histogram'
       autoload :Splitting, 'rack/mount/analysis/splitting'
     end

data/lib/rack/mount/analysis/splitting.rb

@@ -2,8 +2,8 @@ require 'rack/mount/utils'
 
 module Rack::Mount
   module Analysis
-    class Splitting < Frequency
-      NULL = "\0".freeze
+    class Splitting
+      NULL = "\0"
 
       class Key < Struct.new(:method, :index, :separators)
         def self.split(value, separator_pattern)
@@ -26,26 +26,44 @@ module Rack::Mount
         end
       end
 
+      def initialize(*keys)
+        clear
+        keys.each { |key| self << key }
+      end
+
       def clear
-        @boundaries = {}
-        super
+        @raw_keys = []
+        @key_frequency = Analysis::Histogram.new
+        self
       end
 
       def <<(key)
-        super
-        key.each_pair do |k, v|
-          analyze_capture_boundaries(v, @boundaries[k] ||= Histogram.new)
+        raise ArgumentError unless key.is_a?(Hash)
+        @raw_keys << key
+        nil
+      end
+
+      def possible_keys
+        @possible_keys ||= begin
+          @raw_keys.map do |key|
+            key.inject({}) { |requirements, (method, requirement)|
+              process_key(requirements, method, requirement)
+              requirements
+            }
+          end
         end
       end
 
-      def separators(key)
-        @separators ||= {}
-        @separators[key] ||= lookup_separators(key)
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.keys_in_upper_quartile
+        end
       end
-      attr_writer :separators
 
-      def lookup_separators(key)
-        @boundaries[key].keys_in_upper_quartile
+      def expire!
+        @possible_keys = @report = nil
       end
 
       def process_key(requirements, method, requirement)
@@ -55,40 +73,22 @@ module Rack::Mount
             requirements[Key.new(method, index, Regexp.union(*separators))] = value
           end
         else
-          super
-        end
-      end
-
-      private
-        def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
-          return boundaries unless regexp.is_a?(Regexp)
-
-          parts = Utils.parse_regexp(regexp)
-          parts.each_with_index do |part, index|
-            if part.is_a?(Regin::Group)
-              if index > 0
-                previous = parts[index-1]
-                if previous.is_a?(Regin::Character) && previous.literal?
-                  boundaries << previous.to_s
-                end
-              end
-
-              if inside = part.expression[0]
-                if inside.is_a?(Regin::Character) && inside.literal?
-                  boundaries << inside.to_s
-                end
-              end
+          if requirement.is_a?(Regexp)
+            expression = Utils.parse_regexp(requirement)
 
-              if index < parts.length
-                following = parts[index+1]
-                if following.is_a?(Regin::Character) && following.literal?
-                  boundaries << following.to_s
-                end
-              end
+            if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+              expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
+              return requirements[method] = expression.to_s if expression.literal?
             end
           end
 
-          boundaries
+          requirements[method] = requirement
+        end
+      end
+
+      private
+        def separators(key)
+          key == :path_info ? ["/", "."] : []
         end
 
         def generate_split_keys(regexp, separators) #:nodoc:

data/lib/rack/mount/multimap.rb

@@ -1,12 +1,16 @@
-begin
-  require 'nested_multimap'
-rescue LoadError
-  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/multimap'))
-  require 'nested_multimap'
-end
-
 module Rack::Mount
-  class Multimap < NestedMultimap #:nodoc:
+  class Multimap #:nodoc:
+    def initialize(default = [])
+      @hash = Hash.new(default)
+    end
+
+    def initialize_copy(original)
+      @hash = Hash.new(original.default.dup)
+      original.hash.each_pair do |key, container|
+        @hash[key] = container.dup
+      end
+    end
+
     def store(*args)
       keys  = args.dup
       value = keys.pop
@@ -26,7 +30,7 @@ module Rack::Mount
           @hash.each_pair { |k, _|
             if k =~ key
               args[0] = k
-              super(*args)
+              _store(*args)
             end
           }
 
@@ -34,12 +38,19 @@ module Rack::Mount
           default[*keys.dup] = value
         end
       else
-        super(*args)
+        _store(*args)
       end
     end
     alias_method :[]=, :store
 
-    undef :index, :invert
+    def [](*keys)
+      i, l, r, k = 0, keys.length, self, self.class
+      while r.is_a?(k)
+        r = i < l ? r.hash[keys[i]] : r.default
+        i += 1
+      end
+      r
+    end
 
     def height
       containers_with_default.max { |a, b| a.length <=> b.length }.length
@@ -49,5 +60,78 @@ module Rack::Mount
       lengths = containers_with_default.map { |e| e.length }
       lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size
     end
+
+    def containers_with_default
+      containers = []
+      each_container_with_default { |container| containers << container }
+      containers
+    end
+
+    protected
+      def _store(*args)
+        keys  = args
+        value = args.pop
+
+        raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+        if keys.length > 1
+          update_container(keys.shift) do |container|
+            container = self.class.new(container) unless container.is_a?(self.class)
+            container[*keys] = value
+            container
+          end
+        elsif keys.length == 1
+          update_container(keys.first) do |container|
+            container << value
+            container
+          end
+        else
+          self << value
+        end
+      end
+
+      def <<(value)
+        @hash.each_value { |container| container << value }
+        self.default << value
+        self
+      end
+
+      def each_container_with_default(&block)
+        @hash.each_value do |container|
+          iterate_over_container(container, &block)
+        end
+        iterate_over_container(default, &block)
+        self
+      end
+
+      def default
+        @hash.default
+      end
+
+      def default=(value)
+        @hash.default = value
+      end
+
+      def hash
+        @hash
+      end
+
+    private
+      def update_container(key)
+        container = @hash[key]
+        container = container.dup if container.equal?(default)
+        container = yield(container)
+        @hash[key] = container
+      end
+
+      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
 end

data/lib/rack/mount/route_set.rb

@@ -25,7 +25,9 @@ module Rack::Mount
       @named_routes = {}
 
       @recognition_key_analyzer = Analysis::Splitting.new
-      @generation_key_analyzer  = Analysis::Frequency.new
+
+      @generation_keys = [:controller, :action]
+      @generation_route_keys = []
 
       @request_class = options.delete(:request_class) || Rack::Request
       @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym }
@@ -69,7 +71,7 @@ module Rack::Mount
       @recognition_key_analyzer << route.conditions
 
       @named_routes[route.name] = route if route.name
-      @generation_key_analyzer << route.generation_keys
+      @generation_route_keys << route.generation_keys
 
       expire!
       route
@@ -249,7 +251,6 @@ module Rack::Mount
 
       @recognition_keys  = build_recognition_keys
       @recognition_graph = build_recognition_graph
-      @generation_keys   = build_generation_keys
       @generation_graph  = build_generation_graph
 
       self
@@ -263,7 +264,7 @@ module Rack::Mount
         rehash
 
         @recognition_key_analyzer = nil
-        @generation_key_analyzer  = nil
+        @generation_route_keys    = nil
         @valid_conditions         = nil
 
         @routes.each { |route| route.freeze }
@@ -273,26 +274,6 @@ module Rack::Mount
       super
     end
 
-    def marshal_dump #:nodoc:
-      hash = {}
-
-      instance_variables_to_serialize.each do |ivar|
-        hash[ivar] = instance_variable_get(ivar)
-      end
-
-      if graph = hash[:@recognition_graph]
-        hash[:@recognition_graph] = graph.dup
-      end
-
-      hash
-    end
-
-    def marshal_load(hash) #:nodoc:
-      hash.each do |ivar, value|
-        instance_variable_set(ivar, value)
-      end
-    end
-
     protected
       def recognition_stats
         { :keys => @recognition_keys,
@@ -307,12 +288,7 @@ module Rack::Mount
         @recognition_keys = @recognition_graph = nil
         @recognition_key_analyzer.expire!
 
-        @generation_keys = @generation_graph = nil
-        @generation_key_analyzer.expire!
-      end
-
-      def instance_variables_to_serialize
-        instance_variables.map { |ivar| ivar.to_sym } - [:@stubbed_request_class, :@optimized_recognize_defined]
+        @generation_graph = nil
       end
 
       # An internal helper method for constructing a nested set from
@@ -350,7 +326,7 @@ module Rack::Mount
         build_nested_route_set(@generation_keys) { |k, i|
           throw :skip unless @routes[i].significant_params?
 
-          if k = @generation_key_analyzer.possible_keys[i][k]
+          if k = @generation_route_keys[i][k]
             k.to_s
           else
             nil
@@ -358,12 +334,6 @@ module Rack::Mount
         }
       end
 
-      def build_generation_keys
-        keys = @generation_key_analyzer.report
-        Utils.debug "generation keys - #{keys.inspect}"
-        keys
-      end
-
       def extract_params!(*args)
         case args.length
         when 4

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rack-mount
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 1
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 14
-  version: 0.6.14
+  - 7
+  - 1
+  version: 0.7.1
 platform: ruby
 authors: 
 - Joshua Peek
@@ -72,7 +72,6 @@ extra_rdoc_files: []
 
 files: 
 - lib/rack/mount.rb
-- lib/rack/mount/analysis/frequency.rb
 - lib/rack/mount/analysis/histogram.rb
 - lib/rack/mount/analysis/splitting.rb
 - lib/rack/mount/code_generation.rb
@@ -88,9 +87,6 @@ files:
 - lib/rack/mount/strexp/tokenizer.rb
 - lib/rack/mount/strexp/tokenizer.rex
 - lib/rack/mount/utils.rb
-- lib/rack/mount/vendor/multimap/multimap.rb
-- lib/rack/mount/vendor/multimap/multiset.rb
-- lib/rack/mount/vendor/multimap/nested_multimap.rb
 - lib/rack/mount/vendor/regin/regin.rb
 - lib/rack/mount/vendor/regin/regin/alternation.rb
 - lib/rack/mount/vendor/regin/regin/anchor.rb

data/lib/rack/mount/analysis/frequency.rb

@@ -1,60 +0,0 @@
-require 'rack/mount/utils'
-
-module Rack::Mount
-  module Analysis
-    class Frequency #:nodoc:
-      def initialize(*keys)
-        clear
-        keys.each { |key| self << key }
-      end
-
-      def clear
-        @raw_keys = []
-        @key_frequency = Analysis::Histogram.new
-        self
-      end
-
-      def <<(key)
-        raise ArgumentError unless key.is_a?(Hash)
-        @raw_keys << key
-        nil
-      end
-
-      def possible_keys
-        @possible_keys ||= begin
-          @raw_keys.map do |key|
-            key.inject({}) { |requirements, (method, requirement)|
-              process_key(requirements, method, requirement)
-              requirements
-            }
-          end
-        end
-      end
-
-      def process_key(requirements, method, requirement)
-        if requirement.is_a?(Regexp)
-          expression = Utils.parse_regexp(requirement)
-
-          if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
-            expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
-            return requirements[method] = expression.to_s if expression.literal?
-          end
-        end
-
-        requirements[method] = requirement
-      end
-
-      def report
-        @report ||= begin
-          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
-          return [] if @key_frequency.count <= 1
-          @key_frequency.keys_in_upper_quartile
-        end
-      end
-
-      def expire!
-        @possible_keys = @report = nil
-      end
-    end
-  end
-end

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

@@ -1,569 +0,0 @@
-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.
-#
-# == 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
-  #
-  # Creates a new multimap populated with the given objects.
-  #
-  #   Multimap["a", 100, "b", 200]       #=> {"a"=>[100], "b"=>[200]}
-  #   Multimap["a" => 100, "b" => 200]   #=> {"a"=>[100], "b"=>[200]}
-  def self.[](*args)
-    default = []
-
-    if args.size == 2 && args.last.is_a?(Hash)
-      default = args.shift
-    elsif !args.first.is_a?(Hash) && args.size % 2 == 1
-      default = args.shift
-    end
-
-    if args.size == 1 && args.first.is_a?(Hash)
-      args[0] = args.first.inject({}) { |hash, (key, value)|
-        unless value.is_a?(default.class)
-          value = (default.dup << value)
-        end
-        hash[key] = value
-        hash
-      }
-    else
-      index = 0
-      args.map! { |value|
-        unless index % 2 == 0 || value.is_a?(default.class)
-          value = (default.dup << value)
-        end
-        index += 1
-        value
-      }
-    end
-
-    map = new
-    map.instance_variable_set(:@hash, Hash[*args])
-    map.default = default
-    map
-  end
-
-  # call-seq:
-  #   Multimap.new           => multimap
-  #   Multimap.new(default)  => multimap
-  #
-  # Returns a new, empty multimap.
-  #
-  #   map = Multimap.new(Set.new)
-  #   h["a"] = 100
-  #   h["b"] = 200
-  #   h["a"]           #=> [100].to_set
-  #   h["c"]           #=> [].to_set
-  def initialize(default = [])
-    @hash = Hash.new(default)
-  end
-
-  def initialize_copy(original) #:nodoc:
-    @hash = Hash.new(original.default.dup)
-    original._internal_hash.each_pair do |key, container|
-      @hash[key] = container.dup
-    end
-  end
-
-  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
-  #   map.store(key, value)   => value
-  #
-  # Associates the value given by <i>value</i> with the key
-  # given by <i>key</i>. Unlike a regular hash, multiple can be
-  # assoicated with the same value.
-  #
-  #   map = Multimap["a" => 100, "b" => 200]
-  #   map["a"] = 9
-  #   map["c"] = 4
-  #   map   #=> {"a" => [100, 9], "b" => [200], "c" => [4]}
-  def store(key, value)
-    update_container(key) do |container|
-      container << value
-      container
-    end
-  end
-  alias_method :[]=, :store
-
-  # call-seq:
-  #   map.delete(key, value)  => value
-  #   map.delete(key)         => value
-  #
-  # Deletes and returns a key-value pair from <i>map</i>. If only
-  # <i>key</i> is given, all the values matching that key will be
-  # deleted.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.delete("b", 300) #=> 300
-  #   map.delete("a")      #=> [100]
-  def delete(key, value = nil)
-    if value
-      @hash[key].delete(value)
-    else
-      @hash.delete(key)
-    end
-  end
-
-  # call-seq:
-  #   map.each { |key, value| block } => map
-  #
-  # Calls <i>block</i> for each key/value pair in <i>map</i>, passing
-  # the key and value to the block as a two-element array.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each { |key, value| puts "#{key} is #{value}" }
-  #
-  # <em>produces:</em>
-  #
-  #   a is 100
-  #   b is 200
-  #   b is 300
-  def each
-    each_pair do |key, value|
-      yield [key, value]
-    end
-  end
-
-  # call-seq:
-  #   map.each_association { |key, container| block } => map
-  #
-  # Calls <i>block</i> once for each key/container in <i>map</i>, passing
-  # the key and container to the block as parameters.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each_association { |key, container| puts "#{key} is #{container}" }
-  #
-  # <em>produces:</em>
-  #
-  #   a is [100]
-  #   b is [200, 300]
-  def each_association(&block)
-    @hash.each_pair(&block)
-  end
-
-  # call-seq:
-  #   map.each_container { |container| block } => map
-  #
-  # Calls <i>block</i> for each container in <i>map</i>, passing the
-  # container as a parameter.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each_container { |container| puts container }
-  #
-  # <em>produces:</em>
-  #
-  #   [100]
-  #   [200, 300]
-  def each_container
-    each_association do |_, container|
-      yield container
-    end
-  end
-
-  # call-seq:
-  #   map.each_key { |key| block } => map
-  #
-  # Calls <i>block</i> for each key in <i>hsh</i>, passing the key
-  # as a parameter.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each_key { |key| puts key }
-  #
-  # <em>produces:</em>
-  #
-  #   a
-  #   b
-  #   b
-  def each_key
-    each_pair do |key, _|
-      yield key
-    end
-  end
-
-  # call-seq:
-  #   map.each_pair { |key_value_array| block } => map
-  #
-  # Calls <i>block</i> for each key/value pair in <i>map</i>,
-  # passing the key and value as parameters.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each_pair { |key, value| puts "#{key} is #{value}" }
-  #
-  # <em>produces:</em>
-  #
-  #   a is 100
-  #   b is 200
-  #   b is 300
-  def each_pair
-    each_association do |key, values|
-      values.each do |value|
-        yield key, value
-      end
-    end
-  end
-
-  # call-seq:
-  #   map.each_value { |value| block } => map
-  #
-  # Calls <i>block</i> for each key in <i>map</i>, passing the
-  # value as a parameter.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.each_value { |value| puts value }
-  #
-  # <em>produces:</em>
-  #
-  #   100
-  #   200
-  #   300
-  def each_value
-    each_pair do |_, value|
-      yield value
-    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
-    super
-  end
-
-  # call-seq:
-  #   map.has_value?(value)    => true or false
-  #   map.value?(value)        => true or false
-  #
-  # Returns <tt>true</tt> if the given value is present for any key
-  # in <i>map</i>.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.has_value?(300)   #=> true
-  #   map.has_value?(999)   #=> false
-  def has_value?(value)
-    values.include?(value)
-  end
-  alias_method :value?, :has_value?
-
-  # call-seq:
-  #   map.index(value)    => key
-  #
-  # Returns the key for a given value. If not found, returns
-  # <tt>nil</tt>.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.index(100)   #=> "a"
-  #   map.index(200)   #=> "b"
-  #   map.index(999)   #=> nil
-  def index(value)
-    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
-  #
-  # Replaces the contents of <i>map</i> with the contents of
-  # <i>other_map</i>.
-  #
-  #   map = Multimap["a" => 100, "b" => 200]
-  #   map.replace({ "c" => 300, "d" => 400 })
-  #   #=> Multimap["c" => 300, "d" => 400]
-  def replace(other)
-    case other
-    when Array
-      @hash.replace(self.class[self.default, *other])
-    when Hash
-      @hash.replace(self.class[self.default, other])
-    when self.class
-      @hash.replace(other)
-    else
-      raise ArgumentError
-    end
-  end
-
-  # call-seq:
-  #   map.invert => multimap
-  #
-  # Returns a new multimap created by using <i>map</i>'s values as keys,
-  # and the keys as values.
-  #
-  #   map = Multimap["n" => 100, "m" => 100, "d" => [200, 300]]
-  #   map.invert #=> Multimap[100 => ["n", "m"], 200 => "d", 300 => "d"]
-  def invert
-    h = self.class.new(default.dup)
-    each_pair { |key, value| h[value] = key }
-    h
-  end
-
-  # call-seq:
-  #   map.keys    => multiset
-  #
-  # Returns a new +Multiset+ populated with the keys from this hash. See also
-  # <tt>Multimap#values</tt> and <tt>Multimap#containers</tt>.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
-  #   map.keys   #=> Multiset.new(["a", "b", "b", "c"])
-  def keys
-    keys = Multiset.new
-    each_key { |key| keys << key }
-    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
-  #
-  # Returns the number of key-value pairs in the map.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
-  #   map.length        #=> 4
-  #   map.delete("a")   #=> 100
-  #   map.length        #=> 3
-  def size
-    values.size
-  end
-  alias_method :length, :size
-
-  # call-seq:
-  #   map.merge(other_map) => multimap
-  #
-  # Returns a new multimap containing the contents of <i>other_map</i> and
-  # the contents of <i>map</i>.
-  #
-  #   map1 = Multimap["a" => 100, "b" => 200]
-  #   map2 = Multimap["a" => 254, "c" => 300]
-  #   map2.merge(map2) #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]
-  #   map1             #=> Multimap["a" => 100, "b" => 200]
-  def merge(other)
-    dup.update(other)
-  end
-
-  # call-seq:
-  #   map.merge!(other_map)    => multimap
-  #   map.update(other_map)    => multimap
-  #
-  # Adds each pair from <i>other_map</i> to <i>map</i>.
-  #
-  #   map1 = Multimap["a" => 100, "b" => 200]
-  #   map2 = Multimap["b" => 254, "c" => 300]
-  #
-  #   map1.merge!(map2)
-  #   #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]
-  def update(other)
-    case other
-    when self.class
-      other.each_pair { |key, value| store(key, value) }
-    when Hash
-      update(self.class[self.default, other])
-    else
-      raise ArgumentError
-    end
-    self
-  end
-  alias_method :merge!, :update
-
-  # call-seq:
-  #   map.select { |key, value| block }   => multimap
-  #
-  # Returns a new Multimap consisting of the pairs for which the
-  # block returns true.
-  #
-  #   map = Multimap["a" => 100, "b" => 200, "c" => 300]
-  #   map.select { |k,v| k > "a" }  #=> Multimap["b" => 200, "c" => 300]
-  #   map.select { |k,v| v < 200 }  #=> Multimap["a" => 100]
-  def select
-    inject(self.class.new) { |map, (key, value)|
-      map[key] = value if yield([key, value])
-      map
-    }
-  end
-
-  # call-seq:
-  #   map.to_a => array
-  #
-  # Converts <i>map</i> to a nested array of [<i>key,
-  # value</i>] arrays.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
-  #   map.to_a   #=> [["a", 100], ["b", 200], ["b", 300], ["c", 400]]
-  def to_a
-    ary = []
-    each_pair do |key, value|
-      ary << [key, value]
-    end
-    ary
-  end
-
-  # call-seq:
-  #   map.to_hash => hash
-  #
-  # Converts <i>map</i> to a basic hash.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.to_hash   #=> { "a" => [100], "b" => [200, 300] }
-  def to_hash
-    @hash.dup
-  end
-
-  # call-seq:
-  #   map.containers    => array
-  #
-  # Returns a new array populated with the containers from <i>map</i>. See
-  # also <tt>Multimap#keys</tt> and <tt>Multimap#values</tt>.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.containers   #=> [[100], [200, 300]]
-  def containers
-    containers = []
-    each_container { |container| containers << container }
-    containers
-  end
-
-  # call-seq:
-  #   map.values    => array
-  #
-  # Returns a new array populated with the values from <i>map</i>. See
-  # also <tt>Multimap#keys</tt> and <tt>Multimap#containers</tt>.
-  #
-  #   map = Multimap["a" => 100, "b" => [200, 300]]
-  #   map.values   #=> [100, 200, 300]
-  def values
-    values = []
-    each_value { |value| values << value }
-    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[key]
-      container = container.dup if container.equal?(default)
-      container = yield(container)
-      @hash[key] = container
-    end
-end

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

@@ -1,185 +0,0 @@
-require 'set'
-
-# Multiset implements a collection of unordered values and
-# 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)
-    super
-  end
-
-  # Returns the number of times an element belongs to the multiset.
-  def multiplicity(e)
-    @hash[e]
-  end
-
-  # Returns the total number of elements in a multiset, including
-  # repeated memberships
-  def cardinality
-    @hash.inject(0) { |s, (e, m)| s += m }
-  end
-  alias_method :size, :cardinality
-  alias_method :length, :cardinality
-
-  # Converts the set to an array. The order of elements is uncertain.
-  def to_a
-    inject([]) { |ary, (key, _)| ary << key }
-  end
-
-  # Returns true if the set is a superset of the given set.
-  def superset?(set)
-    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
-    return false if cardinality < set.cardinality
-    set.all? { |o| set.multiplicity(o) <= multiplicity(o) }
-  end
-
-  # Returns true if the set is a proper superset of the given set.
-  def proper_superset?(set)
-    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
-    return false if cardinality <= set.cardinality
-    set.all? { |o| set.multiplicity(o) <= multiplicity(o) }
-  end
-
-  # Returns true if the set is a subset of the given set.
-  def subset?(set)
-    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
-    return false if set.cardinality < cardinality
-    all? { |o| multiplicity(o) <= set.multiplicity(o) }
-  end
-
-  # Returns true if the set is a proper subset of the given set.
-  def proper_subset?(set)
-    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
-    return false if set.cardinality <= cardinality
-    all? { |o| multiplicity(o) <= set.multiplicity(o) }
-  end
-
-  # Calls the given block once for each element in the set, passing
-  # the element as parameter. Returns an enumerator if no block is
-  # given.
-  def each
-    @hash.each_pair do |key, multiplicity|
-      multiplicity.times do
-        yield(key)
-      end
-    end
-    self
-  end
-
-  # Adds the given object to the set and returns self. Use +merge+ to
-  # add many elements at once.
-  def add(o)
-    @hash[o] ||= 0
-    @hash[o] += 1
-    self
-  end
-  alias << add
-
-  undef :add?
-
-  # Deletes all the identical object from the set and returns self.
-  # If +n+ is given, it will remove that amount of identical objects
-  # from the set. Use +subtract+ to delete many different items at
-  # once.
-  def delete(o, n = nil)
-    if n
-      @hash[o] ||= 0
-      @hash[o] -= n if @hash[o] > 0
-      @hash.delete(o) if @hash[o] == 0
-    else
-      @hash.delete(o)
-    end
-    self
-  end
-
-  undef :delete?
-
-  # Deletes every element of the set for which block evaluates to
-  # true, and returns self.
-  def delete_if
-    each { |o| delete(o) if yield(o) }
-    self
-  end
-
-  # Merges the elements of the given enumerable object to the set and
-  # returns self.
-  def merge(enum)
-    enum.each { |o| add(o) }
-    self
-  end
-
-  # Deletes every element that appears in the given enumerable object
-  # and returns self.
-  def subtract(enum)
-    enum.each { |o| delete(o, 1) }
-    self
-  end
-
-  # Returns a new set containing elements common to the set and the
-  # given enumerable object.
-  def &(enum)
-    s = dup
-    n = self.class.new
-    enum.each { |o|
-      if s.include?(o)
-        s.delete(o, 1)
-        n.add(o)
-      end
-    }
-    n
-  end
-  alias intersection &
-
-  # Returns a new set containing elements exclusive between the set
-  # and the given enumerable object.  (set ^ enum) is equivalent to
-  # ((set | enum) - (set & enum)).
-  def ^(enum)
-    n = self.class.new(enum)
-    each { |o| n.include?(o) ? n.delete(o, 1) : n.add(o) }
-    n
-  end
-
-  # Returns true if two sets are equal. Two multisets are equal if
-  # they have the same cardinalities and each element has the same
-  # multiplicity in both sets. The equality of each element inside
-  # the multiset is defined according to Object#eql?.
-  def eql?(set)
-    return true if equal?(set)
-    set = self.class.new(set) unless set.is_a?(self.class)
-    return false unless cardinality == set.cardinality
-    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

@@ -1,158 +0,0 @@
-require 'multimap'
-
-# NestedMultimap allows values to be assoicated with a nested
-# set of keys.
-class NestedMultimap < Multimap
-  # call-seq:
-  #   multimap[*keys] = value      => value
-  #   multimap.store(*keys, value) => value
-  #
-  # Associates the value given by <i>value</i> with multiple key
-  # given by <i>keys</i>.
-  #
-  #   map = NestedMultimap.new
-  #   map["a"] = 100
-  #   map["a", "b"] = 101
-  #   map["a"] = 102
-  #   map   #=> {"a"=>{"b"=>[100, 101, 102], default => [100, 102]}}
-  def store(*args)
-    keys  = args
-    value = args.pop
-
-    raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
-
-    if keys.length > 1
-      update_container(keys.shift) do |container|
-        container = self.class.new(container) unless container.is_a?(self.class)
-        container[*keys] = value
-        container
-      end
-    elsif keys.length == 1
-      super(keys.first, value)
-    else
-      self << value
-    end
-  end
-  alias_method :[]=, :store
-
-  # call-seq:
-  #   multimap << obj  => multimap
-  #
-  # Pushes the given object on to the end of all the containers.
-  #
-  #   map = NestedMultimap["a" => [100], "b" => [200, 300]]
-  #   map << 300
-  #   map["a"] #=> [100, 300]
-  #   map["c"] #=> [300]
-  def <<(value)
-    @hash.each_value { |container| container << value }
-    self.default << value
-    self
-  end
-
-  # call-seq:
-  #   multimap[*keys]               =>  value
-  #   multimap[key1, key2, key3]    =>  value
-  #
-  # Retrieves the <i>value</i> object corresponding to the
-  # <i>*keys</i> object.
-  def [](*keys)
-    i, l, r, k = 0, keys.length, self, self.class
-    while r.is_a?(k)
-      r = i < l ? r._internal_hash[keys[i]] : r.default
-      i += 1
-    end
-    r
-  end
-
-  # call-seq:
-  #   multimap.each_association { |key, container| block } => multimap
-  #
-  # Calls <i>block</i> once for each key/container in <i>map</i>, passing
-  # the key and container to the block as parameters.
-  #
-  #   map = NestedMultimap.new
-  #   map["a"] = 100
-  #   map["a", "b"] = 101
-  #   map["a"] = 102
-  #   map["c"] = 200
-  #   map.each_association { |key, container| puts "#{key} is #{container}" }
-  #
-  # <em>produces:</em>
-  #
-  #   ["a", "b"] is [100, 101, 102]
-  #   "c" is [200]
-  def each_association
-    super() do |key, container|
-      if container.respond_to?(:each_association)
-        container.each_association do |nested_key, value|
-          yield [key, nested_key].flatten, value
-        end
-      else
-        yield key, container
-      end
-    end
-  end
-
-  # call-seq:
-  #   multimap.each_container_with_default { |container| block } => map
-  #
-  # Calls <i>block</i> for every container in <i>map</i> including
-  # the default, passing the container as a parameter.
-  #
-  #   map = NestedMultimap.new
-  #   map["a"] = 100
-  #   map["a", "b"] = 101
-  #   map["a"] = 102
-  #   map.each_container_with_default { |container| puts container }
-  #
-  # <em>produces:</em>
-  #
-  #   [100, 101, 102]
-  #   [100, 102]
-  #   []
-  def each_container_with_default(&block)
-    @hash.each_value do |container|
-      iterate_over_container(container, &block)
-    end
-    iterate_over_container(default, &block)
-    self
-  end
-
-  # call-seq:
-  #   multimap.containers_with_default    => array
-  #
-  # Returns a new array populated with all the containers from
-  # <i>map</i> including the default.
-  #
-  #   map = NestedMultimap.new
-  #   map["a"] = 100
-  #   map["a", "b"] = 101
-  #   map["a"] = 102
-  #   map.containers_with_default   #=> [[100, 101, 102], [100, 102], []]
-  def containers_with_default
-    containers = []
-    each_container_with_default { |container| containers << container }
-    containers
-  end
-
-  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
-  require 'nested_multimap_ext'
-rescue LoadError
-end