lgierth-rack-mount 0.6.13

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

@@ -0,0 +1,185 @@
+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

@@ -0,0 +1,158 @@
+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

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

@@ -0,0 +1,75 @@
+module Regin
+  autoload :Alternation, 'regin/alternation'
+  autoload :Anchor, 'regin/anchor'
+  autoload :Atom, 'regin/atom'
+  autoload :Character, 'regin/character'
+  autoload :CharacterClass, 'regin/character_class'
+  autoload :Collection, 'regin/collection'
+  autoload :Expression, 'regin/expression'
+  autoload :Group, 'regin/group'
+  autoload :Options, 'regin/options'
+  autoload :Parser, 'regin/parser'
+
+  # Detect named capture support
+  begin
+    old_debug, $DEBUG = $DEBUG, nil
+    eval('foo = /(?<foo>.*)/').named_captures
+
+    # Returns true if the interpreter is using the Oniguruma Regexp lib
+    # and supports named captures.
+    #
+    #   /(?<foo>bar)/
+    def self.regexp_supports_named_captures?
+      true
+    end
+  rescue SyntaxError, NoMethodError
+    def self.regexp_supports_named_captures? #:nodoc:
+      false
+    end
+  ensure
+    $DEBUG = old_debug
+  end
+
+
+  POSIX_BRACKET_TYPES = %w(
+    alnum alpha ascii blank cntrl digit graph
+    lower print punct space upper word xdigit
+    foo
+  )
+
+  # Returns array of supported POSX bracket types
+  def self.supported_posix_bracket_types
+    @supported_posix_bracket_types ||= []
+  end
+
+  # Detect supported posix bracket types
+  begin
+    old_debug, $DEBUG = $DEBUG, nil
+
+    POSIX_BRACKET_TYPES.each do |type|
+      begin
+        eval("foo = /[[:#{type}:]]/")
+        supported_posix_bracket_types << type
+      rescue SyntaxError, RegexpError
+      end
+    end
+  ensure
+    $DEBUG = old_debug
+  end
+
+
+  # Parses Regexp and returns a Expression data structure.
+  def self.parse(regexp)
+    Parser.parse_regexp(regexp)
+  end
+
+  # Recompiles Regexp by parsing it and turning it back into a Regexp.
+  #
+  # (In the future Regin will perform some Regexp optimizations
+  # such as removing unnecessary captures and options)
+  def self.compile(source)
+    regexp = Regexp.compile(source)
+    expression = parse(regexp)
+    Regexp.compile(expression.to_s(true), expression.flags)
+  end
+end

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

@@ -0,0 +1,40 @@
+module Regin
+  class Alternation < Collection
+    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)
+        @array.map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
+      end
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # Alternation groups are never literal.
+    def literal?
+      false
+    end
+
+    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
+
+    def inspect #:nodoc:
+      to_s.inspect
+    end
+  end
+end