mailgun 0.8 → 0.11

data/lib/mailgun/route.rb

@@ -1,10 +1,9 @@
 module Mailgun
   class Route
-
     def initialize(mailgun)
       @mailgun = mailgun
     end
-    
+
     def list(options={})
       Mailgun.submit(:get, route_url, options)["items"] || []
     end
@@ -26,6 +25,8 @@ module Mailgun
         data['action'] = action
       end
 
+      data = data.to_hash
+
       # TODO: Raise an error or return false if unable to create route
       Mailgun.submit(:post, route_url, data)["route"]["id"]
     end
@@ -33,6 +34,8 @@ module Mailgun
     def update(route_id, params)
       data = ::Multimap.new
 
+      params = Hash[params.map{ |k, v| [k.to_s, v] }]
+
       ['priority', 'description'].each do |key|
         data[key] = params[key] if params.has_key?(key)
       end
@@ -47,13 +50,15 @@ module Mailgun
         end
       end
 
+      data = data.to_hash
+
       Mailgun.submit(:put, route_url(route_id), data)
     end
-    
+
     def destroy(route_id)
       Mailgun.submit(:delete, route_url(route_id))["id"]
     end
-    
+
     private
 
     def route_url(route_id=nil)

data/lib/mailgun/secure.rb

@@ -0,0 +1,30 @@
+# verifySignature: function(timestamp, token, signature, minutes_offset) {
+#   var offset = Math.round((new Date()).getTime() / 1000) - (minutes_offset || 5) * 60;
+#   if(timestamp < offset)
+#     return false;
+#     
+#   var hmac = crypto.createHmac('sha256', api_key);
+#   hmac.update(timestamp + token);
+#   return signature == hmac.digest('hex');
+# },
+
+module Mailgun
+  class Secure
+    def initialize(mailgun)
+      @mailgun = mailgun
+    end
+    
+    # check request auth
+    def check_request_auth(timestamp, token, signature, offset=-5)
+      if offset != 0
+        offset = Time.now.to_i + offset * 60
+        return false if timestamp < offset
+      end
+      
+      return signature == OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest::Digest.new('sha256'),
+        Mailgun.api_key,
+        '%s%s' % [timestamp, token])
+    end
+  end
+end

data/lib/mailgun/webhook.rb

@@ -0,0 +1,55 @@
+module Mailgun
+  # Interface to manage webhooks
+  # https://documentation.mailgun.com/api-webhooks.html#webhooks
+  class Webhook
+    attr_accessor :default_webhook_url, :domain
+
+    # Used internally, called from Mailgun::Base
+    def initialize(mailgun, domain, url)
+      @mailgun = mailgun
+      @domain = domain
+      @default_webhook_url = url
+    end
+
+    # List of currently available webhooks
+    def available_ids
+      %w(bounce deliver drop spam unsubscribe click open).map(&:to_sym)
+    end
+
+    # Returns a list of webhooks set for the specified domain
+    def list
+      Mailgun.submit(:get, webhook_url)["webhooks"] || []
+    end
+
+    # Returns details about the webhook specified
+    def find(id)
+      Mailgun.submit :get, webhook_url(id)
+    end
+
+    # Creates a new webhook
+    # Note: Creating an Open or Click webhook will enable Open or Click tracking
+    def create(id, url=default_webhook_url)
+      params = {:id => id, :url => url}
+      Mailgun.submit :post, webhook_url, params
+    end
+
+    # Updates an existing webhook
+    def update(id, url=default_webhook_url)
+      params = {:url => url}
+      Mailgun.submit :put, webhook_url(id), params
+    end
+
+    # Deletes an existing webhook
+    # Note: Deleting an Open or Click webhook will disable Open or Click tracking
+    def delete(id)
+      Mailgun.submit :delete, webhook_url(id)
+    end
+
+    private
+
+    # Helper method to generate the proper url for Mailgun webhook API calls
+    def webhook_url(id=nil)
+      "#{@mailgun.base_url}/domains/#{domain}/webhooks#{'/' + id if id}"
+    end
+  end
+end

data/lib/multimap/spec/enumerable_examples.rb

@@ -1,50 +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
+    expect(@map.all? { |key, value| key =~ /\w/ }).to be_true
+    expect(@map.all? { |key, value| key =~ /\d/ }).to be_false
+    expect(@map.all? { |key, value| value > 0 }).to be_true
+    expect(@map.all? { |key, value| value > 200 }).to 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
+    expect(@map.any? { |key, value| key == "a" }).to be_true
+    expect(@map.any? { |key, value| key == "z" }).to be_false
+    expect(@map.any? { |key, value| value == 100 }).to be_true
+    expect(@map.any? { |key, value| value > 1000 }).to 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]])
+    expect(@map.collect { |key, value| [key, value] }).to sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+    expect(@map.map { |key, value| [key, value] }).to 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])
+    expect(@map.detect { |key, value| value > 200 }).to eql(["b", 300])
+    expect(@map.find { |key, value| value > 200 }).to 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]])
+    expect(@map.entries).to sorted_eql([["a", 100], ["b", 200], ["b", 300]])
+    expect(@map.to_a).to 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]])
+    expect(@map.find_all { |key, value| value >= 200 }).to eql([["b", 200], ["b", 300]])
+    expect(@map.select { |key, value| value >= 200 }).to 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)
+    expect(@map.inject(0) { |sum, (key, value)| sum + value }).to eql(600)
 
     @map.inject(0) { |memo, (key, value)|
       memo > value ? memo : value
-    }.should eql(300)
+    expect(}).to 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
+    expect(@map.member?("a")).to be_true
+    expect(@map.include?("a")).to be_true
+    expect(@map.member?("z")).to be_false
+    expect(@map.include?("z")).to be_false
   end
 end

data/lib/multimap/spec/hash_examples.rb

@@ -8,152 +8,152 @@ shared_examples_for Hash, Multimap, "with inital values {'a' => [100], 'b' => [2
     map2["a"] = 100
     map2["b"] = 200
     map2["b"] = 300
-    @map.should eql(map2)
+    expect(@map).to 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]]
+    expect(@map).to_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)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new([200, 300]))
+    expect(@map["z"]).to 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]))
+    expect(@map["a"]).to eql(@container.new([100, 400]))
+    expect(@map["b"]).to eql(@container.new([200, 300, 500]))
   end
 
   it "should clear all key/values" do
     @map.clear
-    @map.should be_empty
+    expect(@map).to be_empty
   end
 
   it "should be the class of the container" do
-    @map.default.class.should eql(@container)
+    expect(@map.default.class).to eql(@container)
   end
 
   it "should delete all values at key" do
     @map.delete("a")
-    @map["a"].should eql(@container.new)
+    expect(@map["a"]).to eql(@container.new)
   end
 
   it "should delete single value at key" do
     @map.delete("b", 200)
-    @map["b"].should eql(@container.new([300]))
+    expect(@map["b"]).to 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)
+    expect(@map.delete_if { |key, value| key >= "b" }).to eql(@map)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new)
 
-    @map.delete_if { |key, value| key > "z" }.should eql(@map)
+    expect(@map.delete_if { |key, value| key > "z" }).to 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]))
+    expect(@map.delete_if { |key, value| value >= 300 }).to eql(@map)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to 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)
+    expect(map2).to_not equal(@map)
+    expect(map2).to eql(@map)
+    expect(map2["a"]).to_not equal(@map["a"])
+    expect(map2["b"]).to_not equal(@map["b"])
+    expect(map2.default).to_not equal(@map.default)
+    expect(map2.default).to 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
+    expect(@map).to be_frozen
+    expect(@map["a"]).to be_frozen
+    expect(@map["b"]).to 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]])
+    expect(a).to 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])])
+    expect(a).to 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])]])
+    expect(a).to 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"])
+    expect(a).to 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] })
+    expect(h).to 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])
+    expect(a).to sorted_eql([100, 200, 300])
   end
 
   it "should be empty if there are no key/value pairs" do
     @map.clear
-    @map.should be_empty
+    expect(@map).to be_empty
   end
 
   it "should not be empty if there are any key/value pairs" do
-    @map.should_not be_empty
+    expect(@map).to_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)
+    expect(@map.fetch("a")).to eql(@container.new([100]))
+    expect(@map.fetch("b")).to eql(@container.new([200, 300]))
+    expect(lambda { @map.fetch("z") }).to 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
+    expect(@map.has_key?("a")).to be_true
+    expect(@map.key?("a")).to be_true
+    expect(@map.has_key?("z")).to be_false
+    expect(@map.key?("z")).to 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
+    expect(@map.has_value?(100)).to be_true
+    expect(@map.value?(100)).to be_true
+    expect(@map.has_value?(999)).to be_false
+    expect(@map.value?(999)).to 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)
+      expect(@map.index(200)).to eql(@container.new(["b"]))
+      expect(@map.index(999)).to 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]))
+    expect(@map["a"]).to eql(@container.new)
+    expect(@map["c"]).to eql(@container.new([300]))
   end
 
   it "should return an inverted Multimap" do
@@ -162,103 +162,103 @@ shared_examples_for Hash, Multimap, "with inital values {'a' => [100], 'b' => [2
       map2[100] = "a"
       map2[200] = "b"
       map2[300] = "b"
-      @map.invert.should eql(map2)
+      expect(@map.invert).to eql(map2)
     end
   end
 
   it "should return array of keys" do
-    @map.keys.should eql(["a", "b", "b"])
+    expect(@map.keys).to 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)
+    expect(@map.length).to eql(3)
+    expect(@map.size).to 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]))
+    expect(map["a"]).to eql(@container.new([100]))
+    expect(map["b"]).to eql(@container.new([200, 300, 254]))
+    expect(map["c"]).to 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)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new([200, 300]))
+    expect(@map["c"]).to 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]))
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new([200, 300, 254]))
+    expect(@map["c"]).to 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]))
+    expect(@map["a"]).to eql(@container.new([100, 400, 500]))
+    expect(@map["b"]).to eql(@container.new([200, 300, 254]))
+    expect(@map["c"]).to 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]))
+    expect(map["b"]).to eql(@container.new)
+    expect(@map["b"]).to 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]))
+    expect(map["b"]).to eql(@container.new([200]))
+    expect(@map["b"]).to 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)
+    expect(@map.reject! { |key, value| key >= "b" }).to eql(@map)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new)
 
-    @map.reject! { |key, value| key >= "z" }.should eql(nil)
+    expect(@map.reject! { |key, value| key >= "z" }).to 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]))
+    expect(@map.reject! { |key, value| value >= 300 }).to eql(@map)
+    expect(@map["a"]).to eql(@container.new([100]))
+    expect(@map["b"]).to eql(@container.new([200]))
 
-    @map.reject! { |key, value| key >= "z" }.should eql(nil)
+    expect(@map.reject! { |key, value| key >= "z" }).to 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])
+    expect(@map.select { |k, v| k > "a" }).to eql(Multimap["b", [200, 300]])
+    expect(@map.select { |k, v| v < 200 }).to 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)
+    expect(@map.to_hash["a"]).to eql(@container.new([100]))
+    expect(@map.to_hash["b"]).to eql(@container.new([200, 300]))
+    expect(@map.to_hash).to_not equal(@map)
   end
 
   it "should return all containers" do
-    @map.containers.should sorted_eql([@container.new([100]), @container.new([200, 300])])
+    expect(@map.containers).to sorted_eql([@container.new([100]), @container.new([200, 300])])
   end
 
   it "should return all values" do
-    @map.values.should sorted_eql([100, 200, 300])
+    expect(@map.values).to 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])])
+    expect(@map.values_at("a", "b")).to eql([@container.new([100]), @container.new([200, 300])])
   end
 
   it "should marshal hash" do
     data = Marshal.dump(@map)
-    Marshal.load(data).should eql(@map)
+    expect(Marshal.load(data)).to eql(@map)
   end
 
   it "should dump yaml" do
     require 'yaml'
 
     data = YAML.dump(@map)
-    YAML.load(data).should eql(@map)
+    expect(YAML.load(data)).to eql(@map)
   end
 end