defensio 0.9.0 → 0.9.1

data/Rakefile

@@ -9,8 +9,8 @@ begin
     gemspec.description = "Official Ruby library for Defensio 2.0"
     gemspec.email = "support@defensio.com"
     gemspec.homepage = "http://github.com/defensio/defensio-ruby"
-    gemspec.authors = ["Carl Mercier"]
-    gemspec.add_dependency('patron', '>= 0.4.4')
+    gemspec.authors = ["The Defensio Team", "Carl Mercier"]
+    gemspec.add_dependency('httparty', '>= 0.5.0')
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.1

data/defensio.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{defensio}
+  s.version = "0.9.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["The Defensio Team", "Carl Mercier"]
+  s.date = %q{2010-01-21}
+  s.description = %q{Official Ruby library for Defensio 2.0}
+  s.email = %q{support@defensio.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "defensio.gemspec",
+     "lib/defensio.rb",
+     "test/defensio_test.rb"
+  ]
+  s.homepage = %q{http://github.com/defensio/defensio-ruby}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Official Ruby library for Defensio 2.0}
+  s.test_files = [
+    "test/defensio_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httparty>, [">= 0.5.0"])
+    else
+      s.add_dependency(%q<httparty>, [">= 0.5.0"])
+    end
+  else
+    s.add_dependency(%q<httparty>, [">= 0.5.0"])
+  end
+end
+

data/lib/defensio.rb

@@ -9,7 +9,7 @@
 #
 
 require 'rubygems'
-require 'patron'
+require 'httparty'
 require 'uri'
 
 class Defensio
@@ -18,14 +18,18 @@ class Defensio
   API_HOST      = "http://api.defensio.com"
 
   # You should't modify anything below this line.
-  LIB_VERSION   = "0.9"
+  LIB_VERSION   = "0.9.1"
   ROOT_NODE     = "defensio-result"
   FORMAT        = :yaml
   USER_AGENT    = "Defensio-Ruby #{LIB_VERSION}"
   CLIENT        = "Defensio-Ruby | #{LIB_VERSION} | Carl Mercier | cmercier@websense.com"
   KEEP_ALIVE    = false
   
-  attr_reader :http_session, :client
+  include HTTParty
+  format FORMAT
+  base_uri API_HOST
+  
+  attr_reader :api_key, :client
   
   def initialize(api_key, client = CLIENT)
     @client = client
@@ -34,7 +38,7 @@ class Defensio
 
   # Get information about the api key
   def get_user
-    call :get, api_url
+    respond self.class.get(api_path)
   end
   
   # Create and analyze a new document
@@ -42,14 +46,14 @@ class Defensio
   # @return [Array] An array containing 2 values: the HTTP status code & a Hash with the values returned by Defensio
   def post_document(data)
     data = { :client => @client }.merge(data)
-    call :post, api_url("documents"), data
+    respond self.class.post(api_path("documents"), :body => data)
   end
   
   # Get the status of an existing document
   # @param [String] signature The signature of the document to retrieve
   # @return [Array] An array containing 2 values: the HTTP status code & a Hash with the values returned by Defensio
   def get_document(signature)
-    call :get, api_url("documents", signature)
+    respond self.class.get(api_path("documents", signature))
   end
   
   # Modify the properties of an existing document
@@ -57,30 +61,33 @@ class Defensio
   # @param [Hash] data The parameters to be sent to Defensio. Keys can either be Strings or Symbols
   # @return [Array] An array containing 2 values: the HTTP status code & a Hash with the values returned by Defensio
   def put_document(signature, data)
-    call :put, api_url("documents", signature), data
+    respond self.class.put(api_path("documents", signature), :body => data)
   end
   
   # Get basic statistics for the current user
   # @return [Array] An array containing 2 values: the HTTP status code & a Hash with the values returned by Defensio
   def get_basic_stats
-    call :get, api_url("basic-stats")
+    respond self.class.get(api_path("basic-stats"))
   end
 
   # Get more exhaustive statistics for the current user
   # @param [Hash] data The parameters to be sent to Defensio. Keys can either be Strings or Symbols
   # @return [Array] An array containing 2 values: the HTTP status code & a Hash with the values returned by Defensio
   def get_extended_stats(data)
-    result = call(:get, api_url("extended-stats"), data)
-    0.upto(result[1]["data"].size - 1) do |i|
-      result[1]["data"][i]["date"] = Date.parse(result[1]["data"][i]["date"])
+    result = self.class.get(api_path("extended-stats"), :query => data)
+    code = result.code
+    result = result[ROOT_NODE]
+
+    0.upto(result["data"].size - 1) do |i|
+      result["data"][i]["date"] = Date.parse(result["data"][i]["date"])
     end
       
-    result
+    [code, result]
   end
 
   # Filter a set of values based on a pre-defined dictionary
   def post_profanity_filter(data)
-    call :post, api_url("profanity-filter"), data
+    respond self.class.post(api_path("profanity-filter"), :body => data)
   end
   
   # Takes the request object (Rails, Sinatra, Merb) of an async request callback and returns a hash
@@ -90,7 +97,7 @@ class Defensio
   def handle_post_document_async_callback(request)
     if request.is_a?(String)
       data = request
-    elsif request.respond_to?(:body) && request.body.is_a?(StringIO)
+    elsif request.respond_to?(:body) && request.body.respond_to?(:read)
       data = request.body.read
     else
       raise ArgumentError, "Unknown request type: #{request.class}"
@@ -105,47 +112,16 @@ class Defensio
   end
 
   protected
-    def api_url(action = nil, id = nil)
-      path = "#{API_HOST}/#{API_VERSION}/users/#{@api_key}"
+    def respond(response)
+      [response.code, response[ROOT_NODE]]
+    end
+    
+    def api_path(action = nil, id = nil)
+      path = "/#{API_VERSION}/users/#{@api_key}"
       path += "/#{action}" if action
       path += "/#{id}" if id
       path += ".#{FORMAT}"
     end
-  
-    def http_session
-      return @http_session if KEEP_ALIVE && @http_session
-      @http_session = Patron::Session.new
-      @http_session.timeout = 20
-      @http_session.headers['User-Agent'] = USER_AGENT
-      @http_session.headers['Content-Type'] = "text/#{FORMAT}"
-      @http_session
-    end
-
-    def http_session=(session)
-      @http_session = session
-    end
-    
-    def call(method, url, data = nil)
-      data = hash_to_query_string(data) if data.is_a?(Hash)
-      url = url + "?#{data}" unless data.nil? || data.empty?
-
-      response = case method
-      when :get
-        http_session.get(url)
-      when :delete
-        http_session.delete(url)
-      when :post
-        http_session.post(url, {})
-      when :put
-        http_session.put(url, {})
-      else
-        raise(ArgumentError, "Invalid HTTP method: #{method}")
-      end
-      
-      http_session = nil unless KEEP_ALIVE
-      
-      [response.status, parse_body(response.body)]
-    end
 
     def parse_body(str)
       if FORMAT == :yaml
@@ -155,19 +131,4 @@ class Defensio
       end
     end
 
-    def hash_to_query_string(data)
-      return nil unless data.is_a?(Hash)
-      out = ""
-      sort_hash_by_key(data).each do |item|
-        k, v = item[0], item[1]
-        out += "&" unless out.empty?
-        k = k.to_s.gsub(/_/, "-") if k.is_a?(Symbol)
-        out += "#{k}=#{URI.escape(v.to_s)}"
-      end
-      out
-    end
-
-    def sort_hash_by_key(hash)
-      hash.keys.sort_by {|s| s.to_s}.map {|key| [key, hash[key]] }
-    end
 end

data/test/defensio_test.rb

@@ -1,78 +1,70 @@
-require File.dirname(__FILE__) + "/../lib/defensio"
 DEFENSIO_ENV = "test"
+
+require File.dirname(__FILE__) + "/../lib/defensio"
 require 'test/unit'
 require 'mocha'
 require 'redgreen'
 require 'ostruct'
 
-class DefensioTest < Test::Unit::TestCase
-  MOCK_RESPONSE = true
-  API_KEY       = "1234567890"
-  OWNER_URL     = "http://example.org"
-  SIGNATURE     = "abcdefghijklmnop"
+# You must run this script as following:
+# $ DEFENSIO_KEY=<your api key here> ruby test/defensio_test.rb
 
-  API_VERSION = 2.0
+class DefensioTest < Test::Unit::TestCase
   API_HOST    = "http://api.defensio.com"
+  API_VERSION = 2.0
+  OWNER_URL   = "http://example.org"
   FORMAT      = :yaml
   HEADERS     = {"User-Agent" => "Defensio-Ruby #{Defensio::LIB_VERSION}", "Content-Type" => "text/yaml"}
 
   # API METHOD TESTS -- Useful to learn how to use the library
   def test_get_user
-    if MOCK_RESPONSE
-      Patron::Session.any_instance.expects(:get).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}.#{FORMAT}").once.returns(FakePatronResponse.new(200, user_body))
-    end
-    
     status, body = @d.get_user
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
   end
 
-  def test_post_document
-    if MOCK_RESPONSE
-      query = "client=Defensio-Ruby%20%7C%20#{Defensio::LIB_VERSION}%20%7C%20Carl%20Mercier%20%7C%20cmercier@websense.com&content=We%20sell%20cheap%20Viagra!%20[spam,0.95]&platform=my_awesome_app&type=test"
-      Patron::Session.any_instance.expects(:post).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/documents.#{FORMAT}?#{query}", {}).once.returns(FakePatronResponse.new(200, document_body(SIGNATURE)))
-    end
-
-    data = { :content => "We sell cheap Viagra! [spam,0.95]", :platform => "my_awesome_app", :type => "test" }
+  def test_post_get_put_document
+    # POST
+    data = { :content => "This is a simple test", :platform => "my_awesome_app", :type => "comment" }
     status, body = @d.post_document(data)
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
     assert body["signature"].is_a?(String)
-  end
-  
-  def test_get_document
-    if MOCK_RESPONSE
-      Patron::Session.any_instance.expects(:get).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/documents/#{SIGNATURE}.#{FORMAT}").once.returns(FakePatronResponse.new(200, document_body(SIGNATURE)))
-    end
-    
-    status, body = @d.get_document(SIGNATURE)
+
+    # Keep some variables around
+    original_allow_result = body["allow"]
+    signature = body["signature"]
+
+    # Give Defensio some time to process
+    sleep 0.5
+
+    # GET
+    status, body = @d.get_document(signature)
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
-    assert_equal SIGNATURE, body["signature"]
-  end
+    assert_equal signature, body["signature"]
 
-  def test_put_document
-    if MOCK_RESPONSE
-      query = "allow=true"
-      Patron::Session.any_instance.expects(:put).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/documents/#{SIGNATURE}.#{FORMAT}?#{query}", {}).once.returns(FakePatronResponse.new(200, document_body_allowed(SIGNATURE)))
-    end
+    # PUT
+    status, body = @d.put_document(signature, :allow => !original_allow_result)
+    assert body.is_a?(Hash)
+    assert_equal 200, status
+    assert_equal "success", body["status"]
+    assert_equal signature, body["signature"]
+    assert_equal !original_allow_result, body["allow"]
 
-    status, body = @d.put_document(SIGNATURE, :allow => true)
+    # PUT (back to original value)
+    status, body = @d.put_document(signature, :allow => original_allow_result)
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
-    assert_equal SIGNATURE, body["signature"]
-    assert_equal true, body["allow"]
+    assert_equal signature, body["signature"]
+    assert_equal original_allow_result, body["allow"]
   end
   
   def test_get_basic_stats
-    if MOCK_RESPONSE
-      Patron::Session.any_instance.expects(:get).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/basic-stats.#{FORMAT}").once.returns(FakePatronResponse.new(200, basic_stats_body))
-    end
-    
     status, body = @d.get_basic_stats
     assert body.is_a?(Hash)
     assert_equal 200, status
@@ -81,63 +73,60 @@ class DefensioTest < Test::Unit::TestCase
   end
 
   def test_get_extended_stats
-    if MOCK_RESPONSE
-      query="from=2009-09-01&to=2009-09-03"
-      Patron::Session.any_instance.expects(:get).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/extended-stats.#{FORMAT}?#{query}").once.returns(FakePatronResponse.new(200, extended_stats_body))
-    end
-    
     status, body = @d.get_extended_stats(:from => Date.new(2009, 9, 1), :to => Date.new(2009, 9, 3))
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
     assert body["data"].is_a?(Array)
-    assert body["data"][0]["date"].is_a?(Date)
+    assert body["data"][0]["date"].is_a?(Date)  if body["data"].size > 0
   end
   
   def test_post_profanity_filter
-    if MOCK_RESPONSE
-      query="OtherField=hello%20again&field1=hello%20world"
-      Patron::Session.any_instance.expects(:post).with("#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/profanity-filter.#{FORMAT}?#{query}", {}).once.returns(FakePatronResponse.new(200, profanity_filter_body))
-    end
-    
-    status, body = @d.post_profanity_filter("field1"=>"hello world", "OtherField"=>"hello again")
+    status, body = @d.post_profanity_filter("field1"=>"hello world", "other_field"=>"hello again")
     assert body.is_a?(Hash)
     assert_equal 200, status
     assert_equal "success", body["status"]
     assert body["filtered"].is_a?(Hash)
     assert body["filtered"].keys.include?("field1")
-    assert body["filtered"].keys.include?("OtherField")
+    assert body["filtered"].keys.include?("other_field") 
   end
   
   def test_handle_post_document_async_callback__string
-    result = { "api-version"       => API_VERSION, 
-               "status"            => "success", 
-               "message"           => nil, 
-               "signature"         => SIGNATURE,
-               "allow"             => false,
-               "classification"    => "malicious",
-               "spaminess"         => 0.95,
-               "profanity-match"  => true }
-
-    assert_equal result, @d.class.handle_post_document_async_callback(document_body(SIGNATURE))
-    assert_equal result, @d.handle_post_document_async_callback(document_body(SIGNATURE))
+    result = { "defensio-result" =>
+               { "api-version"       => API_VERSION, 
+                 "status"            => "success", 
+                 "message"           => nil, 
+                 "signature"         => "123456",
+                 "allow"             => false,
+                 "classification"    => "malicious",
+                 "spaminess"         => 0.95,
+                 "profanity-match"  => true }
+              }
+    
+    assert_equal Hash, @d.class.handle_post_document_async_callback(result.to_yaml).class
   end
 
   def test_handle_post_document_async_callback__request_object
-    result = { "api-version"       => API_VERSION, 
-               "status"            => "success", 
-               "message"           => nil, 
-               "signature"         => SIGNATURE,
-               "allow"             => false,
-               "classification"    => "malicious",
-               "spaminess"         => 0.95,
-               "profanity-match"  => true }
+    post_data = { "defensio-result" =>
+                  { "api-version"       => API_VERSION, 
+                   "status"            => "success", 
+                   "message"           => nil, 
+                   "signature"         => "123456",
+                   "allow"             => false,
+                   "classification"    => "malicious",
+                   "spaminess"         => 0.95,
+                   "profanity-match"  => true }
+                }
     
-    fake_request_object = OpenStruct.new(:body => StringIO.new(document_body(SIGNATURE)))
-    assert_equal result, @d.class.handle_post_document_async_callback(fake_request_object)
-
-    fake_request_object = OpenStruct.new(:body => StringIO.new(document_body(SIGNATURE)))
-    assert_equal result, @d.handle_post_document_async_callback(fake_request_object)
+    fake_request_object = OpenStruct.new(:body => StringIO.new(post_data.to_yaml))
+    result = @d.class.handle_post_document_async_callback(fake_request_object)
+    assert_equal Hash, result.class
+    assert_equal "success", result["status"]
+    
+    fake_request_object = OpenStruct.new(:body => StringIO.new(post_data.to_yaml))
+    result = @d.handle_post_document_async_callback(fake_request_object)
+    assert_equal Hash, result.class
+    assert_equal "success", result["status"]
   end
 
   def test_handle_post_document_async_callback__invalid_object_type
@@ -147,31 +136,10 @@ class DefensioTest < Test::Unit::TestCase
 
   
   # OTHER TESTS
-  def test_http_session
-    s = @d.send(:http_session)
-    assert s.is_a?(Patron::Session)
-    if @d.class.class_eval("KEEP_ALIVE")
-      assert_equal s, @d.send(:http_session) # make sure sessions are reused when KEEP_ALIVE is true
-    else
-      assert_not_equal s, @d.send(:http_session) # make sure sessions are dropped when KEEP_ALIVE is false
-    end
-    
-    assert_equal HEADERS, s.headers
-  end
-
-  def test_api_url
-    assert_equal "#{API_HOST}/#{API_VERSION}/users/#{API_KEY}.yaml", @d.send(:api_url)
-    assert_equal "#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/documents.yaml", @d.send(:api_url, "documents")
-    assert_equal "#{API_HOST}/#{API_VERSION}/users/#{API_KEY}/documents/abcdefghijklmnop.yaml", @d.send(:api_url, "documents", "abcdefghijklmnop")
-  end
-  
-  def test_hash_to_query_string
-    assert_equal "hello-world=true", @d.send(:hash_to_query_string, {:hello_world => true} )
-    assert_equal "hello-world=this%20has%20spaces%20and%20characters%20($%20?%20&%20%5E%20%C3%A9)%20that%20should%20be%20escaped", 
-      @d.send(:hash_to_query_string, {:hello_world => "this has spaces and characters ($ ? & ^ é) that should be escaped"} )
-    assert_equal "value1=true&value2=true&value3=true", @d.send(:hash_to_query_string, { "value1" => true, "value2" => true, :value3 => true})
-    assert_equal "date=2009-01-01", @d.send(:hash_to_query_string, { "date" => Date.new(2009,1,1) })
-    assert_nil @d.send(:hash_to_query_string, nil)
+  def test_api_path
+    assert_equal "/#{API_VERSION}/users/#{@api_key}.yaml", @d.send(:api_path)
+    assert_equal "/#{API_VERSION}/users/#{@api_key}/documents.yaml", @d.send(:api_path, "documents")
+    assert_equal "/#{API_VERSION}/users/#{@api_key}/documents/abcdefghijklmnop.yaml", @d.send(:api_path, "documents", "abcdefghijklmnop")
   end
   
   def test_parse_body
@@ -181,108 +149,14 @@ class DefensioTest < Test::Unit::TestCase
 
   # HELPERS AND SETUP
   def setup
-    @d = Defensio.new(API_KEY)
-  end
-
-  def http_session
-    @d.send(:http_session)
-  end
-  
-  def base_url
-    "#{API_HOST}/#{API_VERSION}"
-  end
-
-  # MOCKING
-  class FakePatronResponse < Struct.new(:status, :body); end
-  
-  def user_body
-    { "defensio-result" => {"api-version" => API_VERSION, "status" => "success", "message" => nil, "owner-url" => OWNER_URL} }.send("to_#{FORMAT}")
-  end
-  
-  def document_body(signature)
-    { "defensio-result" => {
-        "api-version"       => API_VERSION, 
-        "status"            => "success", 
-        "message"           => nil, 
-        "signature"         => signature, 
-        "allow"             => false,
-        "classification"    => "malicious",
-        "spaminess"         => 0.95,
-        "profanity-match"  => true } 
-    }.send("to_#{FORMAT}")
-  end
+    if ENV['DEFENSIO_KEY'].nil?
+      puts "You must set the DEFENSIO_KEY environment variable before running tests. Example:"
+      puts "$ DEFENSIO_KEY=<your api key here> ruby test/defensio_test.rb"
+      puts "Fail. Epic Fail."
+      exit 1
+    end
 
-  def document_body_allowed(signature)
-    { "defensio-result" => {
-        "api-version"       => API_VERSION, 
-        "status"            => "success", 
-        "message"           => nil, 
-        "signature"         => signature, 
-        "allow"             => true,
-        "classification"    => "innocent",
-        "spaminess"         => 0.95,
-        "profanity-match"  => true } 
-    }.send("to_#{FORMAT}")
-  end
-  
-  def basic_stats_body
-    { "defensio-result" => {
-      "api-version"       => API_VERSION, 
-      "status"            => "success", 
-      "message"           => nil, 
-      "recent-accuracy"   => 0.9975,
-      "legitimate"        => { "total" => 100 },
-      "unwanted"          => { "total" => 100, "malicious" => 50, "spam" => 100},
-      "false-positives"   => 1,
-      "false-negatices"   => 2,
-      "learning"          => true,
-      "learning-status"   => "Details about learning mode" }
-    }.send("to_#{FORMAT}")
-  end
-  
-  def extended_stats_body
-    { "defensio-result" => {
-      "api-version"       => API_VERSION, 
-      "status"            => "success", 
-      "message"           => nil,
-      "data" => [ 
-        { "date"            => "2009-09-01",
-          "recent-accuracy" => 0.9975,
-          "legitimate"      => 100,
-          "unwanted"        => 500,
-          "false-positives" => 1,
-          "false-negatives" => 0 }, 
-        {
-          "date"            => "2009-09-02",
-          "recent-accuracy" => 0.9985,
-          "legitimate"      => 50,
-          "unwanted"        => 475,
-          "false-positives" => 0,
-          "false-negatives" => 0 }, 
-        { "date"            => "2009-09-03",
-          "recent-accuracy" => 0.9992,
-          "legitimate"      => 100,
-          "unwanted"        => 500,
-          "false-positives" => 1,
-          "false-negatives" => 0 } 
-      ],
-      "chart-urls" => {
-        "recent-accuracy" => "http://domain.com/chart/123456",
-        "total-unwanted"  => "http://domain.com/chart/abcdef",
-        "total-legitimate" => "http://domain.com/chart/xyzabc" }
-      } 
-    }.send("to_#{FORMAT}")
-  end
-  
-  def profanity_filter_body
-    { "defensio-result" => {
-      "api-version"       => API_VERSION, 
-      "status"            => "success", 
-      "message"           => nil,
-      "filtered" => 
-        { "field1"     => "hello world",
-          "OtherField" => "hello again"  }
-      }
-    }.send("to_#{FORMAT}")
+    @api_key = ENV['DEFENSIO_KEY']
+    @d = Defensio.new(@api_key)
   end
 end

metadata

@@ -1,26 +1,27 @@
 --- !ruby/object:Gem::Specification 
 name: defensio
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
+- The Defensio Team
 - Carl Mercier
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-07 00:00:00 -05:00
+date: 2010-01-21 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: patron
+  name: httparty
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.4.4
+        version: 0.5.0
     version: 
 description: Official Ruby library for Defensio 2.0
 email: support@defensio.com
@@ -37,6 +38,7 @@ files:
 - README
 - Rakefile
 - VERSION
+- defensio.gemspec
 - lib/defensio.rb
 - test/defensio_test.rb
 has_rdoc: true