rack-mount 0.0.1

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

@@ -0,0 +1,466 @@
+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
+  }
+
+  # 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 = super
+    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 = [])
+    super
+  end
+
+  def initialize_copy(original) #:nodoc:
+    super
+    clear
+    original.each_pair { |key, container| self[key] = container }
+    self.default = original.default.dup
+  end
+
+  #--
+  # Setting a default proc is not supported
+  #++
+  undef :default_proc
+
+  # 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_aref(key).delete(value)
+    else
+      super(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
+    # each_pair
+  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
+  #
+  # 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 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.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
+      super(self.class[self.default, *other])
+    when Hash
+      super(self.class[self.default, other])
+    when self.class
+      super
+    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
+
+  # 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
+    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
+
+  protected
+    def update_container(key) #:nodoc:
+      container = hash_aref(key)
+      container = container.dup if container.equal?(default)
+      container = yield(container)
+      hash_aset(key, container)
+    end
+end

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

@@ -0,0 +1,153 @@
+require 'set'
+
+# Multiset implements a collection of unordered values and
+# allows duplicate values.
+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?
+end