mailgun 0.7 → 0.8

data/lib/multimap/lib/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/multimap/lib/nested_multimap.rb

@@ -0,0 +1,158 @@
+require 'multimap/lib/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/multimap/spec/enumerable_examples.rb

@@ -0,0 +1,50 @@
+shared_examples_for Enumerable, Multimap, "with inital values {'a' => [100], 'b' => [200, 300]}" do
+  it "should check all key/value pairs for condition" do
+    @map.all? { |key, value| key =~ /\w/ }.should be_true
+    @map.all? { |key, value| key =~ /\d/ }.should be_false
+    @map.all? { |key, value| value > 0 }.should be_true
+    @map.all? { |key, value| value > 200 }.should be_false
+  end
+
+  it "should check any key/value pairs for condition" do
+    @map.any? { |key, value| key == "a" }.should be_true
+    @map.any? { |key, value| key == "z" }.should be_false
+    @map.any? { |key, value| value == 100 }.should be_true
+    @map.any? { |key, value| value > 1000 }.should be_false
+  end
+
+  it "should collect key/value pairs" do
+    @map.collect { |key, value| [key, value] }.should sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+    @map.map { |key, value| [key, value] }.should sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+  end
+
+  it "should detect key/value pair" do
+    @map.detect { |key, value| value > 200 }.should eql(["b", 300])
+    @map.find { |key, value| value > 200 }.should eql(["b", 300])
+  end
+
+  it "should return entries" do
+    @map.entries.should sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+    @map.to_a.should sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+  end
+
+  it "should find all key/value pairs" do
+    @map.find_all { |key, value| value >= 200 }.should eql([["b", 200], ["b", 300]])
+    @map.select { |key, value| value >= 200 }.should eql(Multimap["b", [200, 300]])
+  end
+
+  it "should combine key/value pairs with inject" do
+    @map.inject(0) { |sum, (key, value)| sum + value }.should eql(600)
+
+    @map.inject(0) { |memo, (key, value)|
+      memo > value ? memo : value
+    }.should eql(300)
+  end
+
+  it "should check for key membership" do
+    @map.member?("a").should be_true
+    @map.include?("a").should be_true
+    @map.member?("z").should be_false
+    @map.include?("z").should be_false
+  end
+end

data/lib/multimap/spec/hash_examples.rb

@@ -0,0 +1,264 @@
+shared_examples_for Hash, Multimap, "with inital values {'a' => [100], 'b' => [200, 300]}" do
+  before do
+    @container ||= Array
+  end
+
+  it "should be equal to another Multimap if they contain the same keys and values" do
+    map2 = Multimap.new(@container.new)
+    map2["a"] = 100
+    map2["b"] = 200
+    map2["b"] = 300
+    @map.should eql(map2)
+  end
+
+  it "should not be equal to another Multimap if they contain different values" do
+    @map.should_not == Multimap["a" => [100], "b" => [200]]
+  end
+
+  it "should retrieve container of values for key" do
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new([200, 300]))
+    @map["z"].should eql(@container.new)
+  end
+
+  it "should append values to container at key" do
+    @map["a"] = 400
+    @map.store("b", 500)
+    @map["a"].should eql(@container.new([100, 400]))
+    @map["b"].should eql(@container.new([200, 300, 500]))
+  end
+
+  it "should clear all key/values" do
+    @map.clear
+    @map.should be_empty
+  end
+
+  it "should be the class of the container" do
+    @map.default.class.should eql(@container)
+  end
+
+  it "should delete all values at key" do
+    @map.delete("a")
+    @map["a"].should eql(@container.new)
+  end
+
+  it "should delete single value at key" do
+    @map.delete("b", 200)
+    @map["b"].should eql(@container.new([300]))
+  end
+
+  it "should delete if key condition is matched" do
+    @map.delete_if { |key, value| key >= "b" }.should eql(@map)
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new)
+
+    @map.delete_if { |key, value| key > "z" }.should eql(@map)
+  end
+
+  it "should delete if value condition is matched" do
+    @map.delete_if { |key, value| value >= 300 }.should eql(@map)
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new([200]))
+  end
+
+  it "should duplicate the containers" do
+    map2 = @map.dup
+    map2.should_not equal(@map)
+    map2.should eql(@map)
+    map2["a"].should_not equal(@map["a"])
+    map2["b"].should_not equal(@map["b"])
+    map2.default.should_not equal(@map.default)
+    map2.default.should eql(@map.default)
+  end
+
+  it "should freeze containers" do
+    @map.freeze
+    @map.should be_frozen
+    @map["a"].should be_frozen
+    @map["b"].should be_frozen
+  end
+
+  it "should iterate over each key/value pair and yield an array" do
+    a = []
+    @map.each { |pair| a << pair }
+    a.should sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+  end
+
+  it "should iterate over each container" do
+    a = []
+    @map.each_container { |container| a << container }
+    a.should sorted_eql([@container.new([100]), @container.new([200, 300])])
+  end
+
+  it "should iterate over each key/container" do
+    a = []
+    @map.each_association { |key, container| a << [key, container] }
+    a.should sorted_eql([["a", @container.new([100])], ["b", @container.new([200, 300])]])
+  end
+
+  it "should iterate over each key" do
+    a = []
+    @map.each_key { |key| a << key }
+    a.should sorted_eql(["a", "b", "b"])
+  end
+
+  it "should iterate over each key/value pair and yield the pair" do
+    h = {}
+    @map.each_pair { |key, value| (h[key] ||= []) << value }
+    h.should eql({ "a" => [100], "b" => [200, 300] })
+  end
+
+  it "should iterate over each value" do
+    a = []
+    @map.each_value { |value| a << value }
+    a.should sorted_eql([100, 200, 300])
+  end
+
+  it "should be empty if there are no key/value pairs" do
+    @map.clear
+    @map.should be_empty
+  end
+
+  it "should not be empty if there are any key/value pairs" do
+    @map.should_not be_empty
+  end
+
+  it "should fetch container of values for key" do
+    @map.fetch("a").should eql(@container.new([100]))
+    @map.fetch("b").should eql(@container.new([200, 300]))
+    lambda { @map.fetch("z") }.should raise_error(IndexError)
+  end
+
+  it "should check if key is present" do
+    @map.has_key?("a").should be_true
+    @map.key?("a").should be_true
+    @map.has_key?("z").should be_false
+    @map.key?("z").should be_false
+  end
+
+  it "should check containers when looking up by value" do
+    @map.has_value?(100).should be_true
+    @map.value?(100).should be_true
+    @map.has_value?(999).should be_false
+    @map.value?(999).should be_false
+  end
+
+  it "it should return the index for value" do
+    if @map.respond_to?(:index)
+      @map.index(200).should eql(@container.new(["b"]))
+      @map.index(999).should eql(@container.new)
+    end
+  end
+
+  it "should replace the contents of hash" do
+    @map.replace({ "c" => @container.new([300]), "d" => @container.new([400]) })
+    @map["a"].should eql(@container.new)
+    @map["c"].should eql(@container.new([300]))
+  end
+
+  it "should return an inverted Multimap" do
+    if @map.respond_to?(:invert)
+      map2 = Multimap.new(@container.new)
+      map2[100] = "a"
+      map2[200] = "b"
+      map2[300] = "b"
+      @map.invert.should eql(map2)
+    end
+  end
+
+  it "should return array of keys" do
+    @map.keys.should eql(["a", "b", "b"])
+  end
+
+  it "should return the number of key/value pairs" do
+    @map.length.should eql(3)
+    @map.size.should eql(3)
+  end
+
+  it "should duplicate map and with merged values" do
+    map = @map.merge("b" => 254, "c" => @container.new([300]))
+    map["a"].should eql(@container.new([100]))
+    map["b"].should eql(@container.new([200, 300, 254]))
+    map["c"].should eql(@container.new([300]))
+
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new([200, 300]))
+    @map["c"].should eql(@container.new)
+  end
+
+  it "should update map" do
+    @map.update("b" => 254, "c" => @container.new([300]))
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new([200, 300, 254]))
+    @map["c"].should eql(@container.new([300]))
+
+    klass = @map.class
+    @map.update(klass[@container.new, {"a" => @container.new([400, 500]), "c" => 600}])
+    @map["a"].should eql(@container.new([100, 400, 500]))
+    @map["b"].should eql(@container.new([200, 300, 254]))
+    @map["c"].should eql(@container.new([300, 600]))
+  end
+
+  it "should reject key pairs on copy of the map" do
+    map = @map.reject { |key, value| key >= "b" }
+    map["b"].should eql(@container.new)
+    @map["b"].should eql(@container.new([200, 300]))
+  end
+
+  it "should reject value pairs on copy of the map" do
+    map = @map.reject { |key, value| value >= 300 }
+    map["b"].should eql(@container.new([200]))
+    @map["b"].should eql(@container.new([200, 300]))
+  end
+
+  it "should reject key pairs" do
+    @map.reject! { |key, value| key >= "b" }.should eql(@map)
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new)
+
+    @map.reject! { |key, value| key >= "z" }.should eql(nil)
+  end
+
+  it "should reject value pairs" do
+    @map.reject! { |key, value| value >= 300 }.should eql(@map)
+    @map["a"].should eql(@container.new([100]))
+    @map["b"].should eql(@container.new([200]))
+
+    @map.reject! { |key, value| key >= "z" }.should eql(nil)
+  end
+
+  it "should select key/value pairs" do
+    @map.select { |k, v| k > "a" }.should eql(Multimap["b", [200, 300]])
+    @map.select { |k, v| v < 200 }.should eql(Multimap["a", 100])
+  end
+
+  it "should convert to hash" do
+    @map.to_hash["a"].should eql(@container.new([100]))
+    @map.to_hash["b"].should eql(@container.new([200, 300]))
+    @map.to_hash.should_not equal(@map)
+  end
+
+  it "should return all containers" do
+    @map.containers.should sorted_eql([@container.new([100]), @container.new([200, 300])])
+  end
+
+  it "should return all values" do
+    @map.values.should sorted_eql([100, 200, 300])
+  end
+
+  it "should return return values at keys" do
+    @map.values_at("a", "b").should eql([@container.new([100]), @container.new([200, 300])])
+  end
+
+  it "should marshal hash" do
+    data = Marshal.dump(@map)
+    Marshal.load(data).should eql(@map)
+  end
+
+  it "should dump yaml" do
+    require 'yaml'
+
+    data = YAML.dump(@map)
+    YAML.load(data).should eql(@map)
+  end
+end