httparty 0.8.3 → 0.9.0

data/.travis.yml

@@ -2,7 +2,6 @@ language: ruby
 rvm:
   - 1.8.7
   - ree
-  - 1.9.2
   - 1.9.3
 notifications:
   email: false

data/History

@@ -1,3 +1,13 @@
+== 0.9.0 2012-09-07
+* new
+  * [support for connection adapters](https://github.com/jnunemaker/httparty/pull/157)
+  * [allow ssl_version on ruby 1.9](https://github.com/jnunemaker/httparty/pull/159)
+
+* bug fixes
+  * [don't treat port 4430 as ssl](https://github.com/jnunemaker/httparty/commit/a296b1c97f83d7dcc6ef85720a43664c265685ac)
+  * [deep clone default options](https://github.com/jnunemaker/httparty/commit/f74227d30f9389b4b23a888c9af49fb9b8248e1f)
+  * a few net digest auth fixes
+
 == 0.8.3 2012-04-21
 * new
   * [lazy parsing of responses](https://github.com/jnunemaker/httparty/commit/9fd5259c8dab00e426082b66af44ede2c9068f45)

data/README.md

@@ -0,0 +1,79 @@
+# httparty
+
+Makes http fun again!
+
+## Install
+
+```
+gem install httparty
+```
+
+## Requirements
+
+* multi_json and multi_xml
+* You like to party!
+
+## Examples
+
+```ruby
+# Use the class methods to get down to business quickly
+response = HTTParty.get('http://twitter.com/statuses/public_timeline.json')
+puts response.body, response.code, response.message, response.headers.inspect
+
+response.each do |item|
+  puts item['user']['screen_name']
+end
+
+# Or wrap things up in your own class
+class Twitter
+  include HTTParty
+  base_uri 'twitter.com'
+
+  def initialize(u, p)
+    @auth = {:username => u, :password => p}
+  end
+
+  # which can be :friends, :user or :public
+  # options[:query] can be things like since, since_id, count, etc.
+  def timeline(which=:friends, options={})
+    options.merge!({:basic_auth => @auth})
+    self.class.get("/statuses/#{which}_timeline.json", options)
+  end
+
+  def post(text)
+    options = { :body => {:status => text}, :basic_auth => @auth }
+    self.class.post('/statuses/update.json', options)
+  end
+end
+
+twitter = Twitter.new(config['email'], config['password'])
+pp twitter.timeline
+```
+
+See the [examples directory](http://github.com/jnunemaker/httparty/tree/master/examples) for even more goodies.
+
+## Command Line Interface
+
+httparty also includes the executable `httparty` which can be
+used to query web services and examine the resulting output. By default
+it will output the response as a pretty-printed Ruby object (useful for
+grokking the structure of output). This can also be overridden to output
+formatted XML or JSON. Execute `httparty --help` for all the
+options. Below is an example of how easy it is.
+
+```
+httparty "http://twitter.com/statuses/public_timeline.json"
+```
+
+## Help and Docs
+
+* https://groups.google.com/forum/#!forum/httparty-gem
+* http://rdoc.info/projects/jnunemaker/httparty
+
+## Contributing
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.

data/bin/httparty

@@ -38,7 +38,7 @@ OptionParser.new do |o|
     end
   end
 
-  o.on("-H", "--header [NAME=VALUE]", "Additional HTTP headers in NAME=VALUE form") do |h|
+  o.on("-H", "--header [NAME:VALUE]", "Additional HTTP headers in NAME:VALUE form") do |h|
     abort "Invalid header specification, should be Name:Value" unless h =~ /.+:.+/
     name, value = h.split(':')
     opts[:headers][name.strip] = value.strip

data/httparty.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["John Nunemaker", "Sandro Turriate"]
   s.email       = ["nunemaker@gmail.com"]
-  s.homepage    = "http://httparty.rubyforge.org/"
+  s.homepage    = "http://jnunemaker.github.com/httparty"
   s.summary     = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
 

data/lib/httparty.rb

@@ -10,6 +10,7 @@ require 'httparty/module_inheritable_attributes'
 require 'httparty/cookie_hash'
 require 'httparty/net_digest_auth'
 require 'httparty/version'
+require 'httparty/connection_adapter'
 
 # @see HTTParty::ClassMethods
 module HTTParty
@@ -57,9 +58,11 @@ module HTTParty
   # * :+maintain_method_across_redirects+: see HTTParty::ClassMethods.maintain_method_across_redirects.
   # * :+no_follow+: see HTTParty::ClassMethods.no_follow.
   # * :+parser+: see HTTParty::ClassMethods.parser.
+  # * :+connection_adapter+: see HTTParty::ClassMethods.connection_adapter.
   # * :+pem+: see HTTParty::ClassMethods.pem.
   # * :+query_string_normalizer+: see HTTParty::ClassMethods.query_string_normalizer
   # * :+ssl_ca_file+: see HTTParty::ClassMethods.ssl_ca_file.
+  # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
 
   module ClassMethods
 
@@ -296,6 +299,17 @@ module HTTParty
       default_options[:query_string_normalizer] = normalizer
     end
 
+    # Allows setting of SSL version to use. This only works in Ruby 1.9.
+    # You can get a list of valid versions from OpenSSL::SSL::SSLContext::METHODS.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     ssl_version :SSLv3
+    #   end
+    def ssl_version(version)
+      default_options[:ssl_version] = version
+    end
+
     # Allows setting an OpenSSL certificate authority file
     #
     #   class Foo
@@ -331,6 +345,30 @@ module HTTParty
       end
     end
 
+    # Allows setting a custom connection_adapter for the http connections
+    #
+    # @example
+    #   class Foo
+    #     include HTTParty
+    #     connection_adapter Proc.new {|uri, options| ... }
+    #   end
+    #
+    # @example provide optional configuration for your connection_adapter
+    #   class Foo
+    #     include HTTParty
+    #     connection_adapter Proc.new {|uri, options| ... }, {:foo => :bar}
+    #   end
+    #
+    # @see HTTParty::ConnectionAdapter
+    def connection_adapter(custom_adapter = nil, options = nil)
+      if custom_adapter.nil?
+        default_options[:connection_adapter]
+      else
+        default_options[:connection_adapter] = custom_adapter
+        default_options[:connection_adapter_options] = options
+      end
+    end
+
     # Allows making a get request to a url.
     #
     #   class Foo
@@ -415,7 +453,7 @@ module HTTParty
 
   def self.normalize_base_uri(url) #:nodoc:
     normalized_url = url.dup
-    use_ssl = (normalized_url =~ /^https/) || normalized_url.include?(':443')
+    use_ssl = (normalized_url =~ /^https/) || (normalized_url =~ /:443\b/)
     ends_with_slash = normalized_url =~ /\/$/
 
     normalized_url.chop! if ends_with_slash

data/lib/httparty/connection_adapter.rb

@@ -0,0 +1,116 @@
+module HTTParty
+  # Default connection adapter that returns a new Net::HTTP each time
+  #
+  # == Custom Connection Factories
+  #
+  # If you like to implement your own connection adapter, subclassing
+  # HTTPParty::ConnectionAdapter will make it easier. Just override
+  # the #connection method. The uri and options attributes will have
+  # all the info you need to construct your http connection. Whatever
+  # you return from your connection method needs to adhere to the
+  # Net::HTTP interface as this is what HTTParty expects.
+  #
+  # @example log the uri and options
+  #   class LoggingConnectionAdapter < HTTParty::ConnectionAdapter
+  #     def connection
+  #       puts uri
+  #       puts options
+  #       Net::HTTP.new(uri)
+  #     end
+  #   end
+  #
+  # @example count number of http calls
+  #   class CountingConnectionAdapter < HTTParty::ConnectionAdapter
+  #     @@count = 0
+  #
+  #     self.count
+  #       @@count
+  #     end
+  #
+  #     def connection
+  #       self.count += 1
+  #       super
+  #     end
+  #   end
+  #
+  # === Configuration
+  # There is lots of configuration data available for your connection adapter
+  # in the #options attribute. It is up to you to interpret them within your
+  # connection adapter. Take a look at the implementation of
+  # HTTParty::ConnectionAdapter#connection for examples of how they are used.
+  # Something are probably interesting are as follows:
+  # * :+timeout+: timeout in seconds
+  # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
+  # * :+pem+: contains pem data. see HTTParty::ClassMethods.pem.
+  # * :+ssl_ca_file+: see HTTParty::ClassMethods.ssl_ca_file.
+  # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
+  # * :+connection_adapter_options+: contains the hash your passed to HTTParty.connection_adapter when you configured your connection adapter
+  class ConnectionAdapter
+
+    def self.call(uri, options)
+      new(uri, options).connection
+    end
+
+    attr_reader :uri, :options
+
+    def initialize(uri, options={})
+      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.kind_of? URI
+
+      @uri = uri
+      @options = options
+    end
+
+    def connection
+      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
+
+      http.use_ssl = ssl_implied?(uri)
+
+      attach_ssl_certificates(http, options)
+
+      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
+        http.open_timeout = options[:timeout]
+        http.read_timeout = options[:timeout]
+      end
+
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
+      end
+
+      return http
+    end
+
+    private
+    def ssl_implied?(uri)
+      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    end
+
+    def attach_ssl_certificates(http, options)
+      if http.use_ssl?
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        # Client certificate authentication
+        if options[:pem]
+          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+          http.key = OpenSSL::PKey::RSA.new(options[:pem], options[:pem_password])
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # SSL certificate authority file and/or directory
+        if options[:ssl_ca_file]
+          http.ca_file = options[:ssl_ca_file]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        if options[:ssl_ca_path]
+          http.ca_path = options[:ssl_ca_path]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # This is only Ruby 1.9+
+        if options[:ssl_version] && http.respond_to?(:ssl_version=)
+          http.ssl_version = options[:ssl_version]
+        end
+      end
+    end
+  end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -4,6 +4,16 @@ module HTTParty
       base.extend(ClassMethods)
     end
 
+    # borrowed from Rails 3.2 ActiveSupport
+    def self.hash_deep_dup(h)
+      duplicate = h.dup
+      duplicate.each_pair do |k,v|
+        tv = duplicate[k]
+        duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? hash_deep_dup(tv) : v
+      end
+      duplicate
+    end
+
     module ClassMethods #:nodoc:
       def mattr_inheritable(*args)
         @mattr_inheritable_attrs ||= [:mattr_inheritable_attrs]
@@ -22,7 +32,7 @@ module HTTParty
           if instance_variable_get(ivar).respond_to?(:merge)
             method = <<-EOM
               def self.#{inheritable_attribute}
-                #{ivar} = superclass.#{inheritable_attribute}.merge Marshal.load(Marshal.dump(#{ivar}))
+                #{ivar} = superclass.#{inheritable_attribute}.merge ModuleInheritableAttributes.hash_deep_dup(#{ivar})
               end
             EOM
             subclass.class_eval method

data/lib/httparty/net_digest_auth.rb

@@ -20,15 +20,24 @@ module Net
 
       def authorization_header
         @cnonce = md5(random)
-        header = [%Q(Digest username="#{@username}"),
+        header = [
+          %Q(Digest username="#{@username}"),
           %Q(realm="#{@response['realm']}"),
           %Q(nonce="#{@response['nonce']}"),
           %Q(uri="#{@path}"),
-          %Q(response="#{request_digest}")]
-        [%Q(cnonce="#{@cnonce}"),
-          %Q(opaque="#{@response['opaque']}"),
-          %Q(qop="#{@response['qop']}"),
-          %Q(nc="0")].each { |field| header << field } if qop_present?
+          %Q(response="#{request_digest}"),
+        ]
+
+        if qop_present?
+          fields = [
+            %Q(cnonce="#{@cnonce}"),
+            %Q(qop="#{@response['qop']}"),
+            %Q(nc="00000001")
+          ]
+          fields.each { |field| header << field }
+        end
+
+        header << %Q(opaque="#{@response['opaque']}") if opaque_present?
         header
       end
 
@@ -41,6 +50,10 @@ module Net
         params
       end
 
+      def opaque_present?
+        @response.has_key?('opaque') and not @response['opaque'].empty?
+      end
+
       def qop_present?
         @response.has_key?('qop') and not @response['qop'].empty?
       end
@@ -51,7 +64,7 @@ module Net
 
       def request_digest
         a = [md5(a1), @response['nonce'], md5(a2)]
-        a.insert(2, "0", @cnonce, @response['qop']) if qop_present?
+        a.insert(2, "00000001", @cnonce, @response['qop']) if qop_present?
         md5(a.join(":"))
       end
 

data/lib/httparty/parser.rb

@@ -138,8 +138,8 @@ module HTTParty
 
     def parse_supported_format
       send(format)
-    rescue NoMethodError
-      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format."
+    rescue NoMethodError => e
+      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format.", e.backtrace
     end
   end
 end

data/lib/httparty/request.rb

@@ -33,7 +33,8 @@ module HTTParty
         :limit => o.delete(:no_follow) ? 1 : 5,
         :default_params => {},
         :follow_redirects => true,
-        :parser => Parser
+        :parser => Parser,
+        :connection_adapter => ConnectionAdapter
       }.merge(o)
     end
 
@@ -68,6 +69,10 @@ module HTTParty
       options[:parser]
     end
 
+    def connection_adapter
+      options[:connection_adapter]
+    end
+
     def perform(&block)
       validate
       setup_raw_request
@@ -92,50 +97,8 @@ module HTTParty
 
     private
 
-    def attach_ssl_certificates(http)
-      if http.use_ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-        # Client certificate authentication
-        if options[:pem]
-          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
-          http.key = OpenSSL::PKey::RSA.new(options[:pem], options[:pem_password])
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
-
-        # SSL certificate authority file and/or directory
-        if options[:ssl_ca_file]
-          http.ca_file = options[:ssl_ca_file]
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
-
-        if options[:ssl_ca_path]
-          http.ca_path = options[:ssl_ca_path]
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
-      end
-    end
-
     def http
-      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
-      http.use_ssl = ssl_implied?
-
-      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
-        http.open_timeout = options[:timeout]
-        http.read_timeout = options[:timeout]
-      end
-
-      attach_ssl_certificates(http)
-
-      if options[:debug_output]
-        http.set_debug_output(options[:debug_output])
-      end
-
-      http
-    end
-
-    def ssl_implied?
-      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      connection_adapter.call(uri, options)
     end
 
     def body

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.8.3"
+  VERSION = "0.9.0"
 end

data/spec/httparty/connection_adapter_spec.rb

@@ -0,0 +1,206 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe HTTParty::ConnectionAdapter do
+
+  describe "initialization" do
+    let(:uri) { URI 'http://www.google.com' }
+    it "takes a URI as input" do
+      HTTParty::ConnectionAdapter.new(uri)
+    end
+
+    it "raises an ArgumentError if the uri is nil" do
+      expect { HTTParty::ConnectionAdapter.new(nil) }.to raise_error ArgumentError
+    end
+
+    it "raises an ArgumentError if the uri is a String" do
+      expect { HTTParty::ConnectionAdapter.new('http://www.google.com') }.to raise_error ArgumentError
+    end
+
+    it "sets the uri" do
+      adapter = HTTParty::ConnectionAdapter.new(uri)
+      adapter.uri.should be uri
+    end
+
+    it "also accepts an optional options hash" do
+      HTTParty::ConnectionAdapter.new(uri, {})
+    end
+
+    it "sets the options" do
+      options = {:foo => :bar}
+      adapter = HTTParty::ConnectionAdapter.new(uri, options)
+      adapter.options.should be options
+    end
+  end
+
+  describe ".call" do
+    it "generates an HTTParty::ConnectionAdapter instance with the given uri and options" do
+      HTTParty::ConnectionAdapter.should_receive(:new).with(@uri, @options).and_return(stub(:connection => nil))
+      HTTParty::ConnectionAdapter.call(@uri, @options)
+    end
+
+    it "calls #connection on the connection adapter" do
+      adapter = mock('Adapter')
+      connection = mock('Connection')
+      adapter.should_receive(:connection).and_return(connection)
+      HTTParty::ConnectionAdapter.stub(:new => adapter)
+      HTTParty::ConnectionAdapter.call(@uri, @options).should be connection
+    end
+  end
+
+  describe '#connection' do
+    let(:uri) { URI 'http://www.google.com' }
+    let(:options) { Hash.new }
+    let(:adapter) { HTTParty::ConnectionAdapter.new(uri, options) }
+
+    describe "the resulting connection" do
+      subject { adapter.connection }
+      it { should be_an_instance_of Net::HTTP }
+
+      context "using port 80" do
+        let(:uri) { URI 'http://foobar.com' }
+        it { should_not use_ssl }
+      end
+
+      context "when dealing with ssl" do
+        let(:uri) { URI 'https://foobar.com' }
+
+        context "using port 443 for ssl" do
+          let(:uri) { URI 'https://api.foo.com/v1:443' }
+          it { should use_ssl }
+        end
+
+        context "https scheme with default port" do
+          it { should use_ssl }
+        end
+
+        context "https scheme with non-standard port" do
+          let(:uri) { URI 'https://foobar.com:123456' }
+          it { should use_ssl }
+        end
+
+        context "when ssl version is set" do
+          let(:options) { {:ssl_version => :TLSv1} }
+
+          it "sets ssl version" do
+            subject.ssl_version.should == :TLSv1
+          end
+        end if RUBY_VERSION > '1.9'
+      end
+
+      context "when timeout is not set" do
+        it "doesn't set the timeout" do
+          http = mock("http", :null_object => true)
+          http.should_not_receive(:open_timeout=)
+          http.should_not_receive(:read_timeout=)
+          Net::HTTP.stub(:new => http)
+
+          adapter.connection
+        end
+      end
+
+      context "when setting timeout" do
+        context "to 5 seconds" do
+          let(:options) { {:timeout => 5} }
+
+          its(:open_timeout) { should == 5 }
+          its(:read_timeout) { should == 5 }
+        end
+
+        context "and timeout is a string" do
+          let(:options) { {:timeout => "five seconds"} }
+
+          it "doesn't set the timeout" do
+            http = mock("http", :null_object => true)
+            http.should_not_receive(:open_timeout=)
+            http.should_not_receive(:read_timeout=)
+            Net::HTTP.stub(:new => http)
+
+            adapter.connection
+          end
+        end
+      end
+
+      context "when debug_output" do
+        let(:http) { Net::HTTP.new(uri) }
+        before do
+          Net::HTTP.stub(:new => http)
+        end
+
+        context "is set to $stderr" do
+          let(:options) { {:debug_output => $stderr} }
+          it "has debug output set" do
+            http.should_receive(:set_debug_output).with($stderr)
+            adapter.connection
+          end
+        end
+
+        context "is not provided" do
+          it "does not set_debug_output" do
+            http.should_not_receive(:set_debug_output)
+            adapter.connection
+          end
+        end
+      end
+
+      context 'when providing proxy address and port' do
+        let(:options) { {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080} }
+
+        it { should be_a_proxy }
+        its(:proxy_address) { should == '1.2.3.4' }
+        its(:proxy_port) { should == 8080 }
+
+        context 'as well as proxy user and password' do
+          let(:options) do
+            {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080,
+             :http_proxyuser => 'user', :http_proxypass => 'pass'}
+          end
+          its(:proxy_user) { should == 'user' }
+          its(:proxy_pass) { should == 'pass' }
+        end
+      end
+
+      context "when providing PEM certificates" do
+        let(:pem) { :pem_contents }
+        let(:options) { {:pem => pem, :pem_password => "password"} }
+
+        context "when scheme is https" do
+          let(:uri) { URI 'https://google.com' }
+          let(:cert) { mock("OpenSSL::X509::Certificate") }
+          let(:key) { mock("OpenSSL::PKey::RSA") }
+
+          before do
+            OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(cert)
+            OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(key)
+          end
+
+          it "uses the provided PEM certificate " do
+            subject.cert.should == cert
+            subject.key.should == key
+          end
+
+          it "will verify the certificate" do
+            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+          end
+        end
+
+        context "when scheme is not https" do
+          let(:uri) { URI 'http://google.com' }
+          let(:http) { Net::HTTP.new(uri) }
+
+          before do
+            Net::HTTP.stub(:new => http)
+            OpenSSL::X509::Certificate.should_not_receive(:new).with(pem)
+            OpenSSL::PKey::RSA.should_not_receive(:new).with(pem, "password")
+            http.should_not_receive(:cert=)
+            http.should_not_receive(:key=)
+          end
+
+          it "has no PEM certificate " do
+            subject.cert.should be_nil
+            subject.key.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/httparty/net_digest_auth_spec.rb

@@ -13,6 +13,31 @@ describe Net::HTTPHeader::DigestAuthenticator do
     @digest.authorization_header.join(", ")
   end
 
+
+  context "with an opaque value in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", opaque="solid"'
+      })
+    end
+
+    it "should set opaque" do
+      authorization_header.should include(%Q(opaque="solid"))
+    end
+  end
+
+  context "without an opaque valid in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
+      })  
+    end
+
+    it "should not set opaque" do
+      authorization_header.should_not include(%Q(opaque=)) 
+    end
+  end
+
   context "with specified quality of protection (qop)" do
     before do
       @digest = setup_digest({
@@ -41,11 +66,11 @@ describe Net::HTTPHeader::DigestAuthenticator do
     end
 
     it "should set nonce-count" do
-      authorization_header.should include(%Q(nc="0"))
+      authorization_header.should include(%Q(nc="00000001"))
     end
 
     it "should set response" do
-      request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:0:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
       authorization_header.should include(%Q(response="#{request_digest}"))
     end
   end

data/spec/httparty/request_spec.rb

@@ -45,6 +45,17 @@ describe HTTParty::Request do
       request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :parser => my_parser)
       request.parser.should == my_parser
     end
+
+    it "sets connection_adapter to HTTPParty::ConnectionAdapter" do
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
+      request.connection_adapter.should == HTTParty::ConnectionAdapter
+    end
+
+    it "sets connection_adapter to the optional connection_adapter" do
+      my_adapter = lambda {}
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :connection_adapter => my_adapter)
+      request.connection_adapter.should == my_adapter
+    end
   end
 
   describe "#format" do
@@ -145,125 +156,12 @@ describe HTTParty::Request do
   end
 
   describe 'http' do
-    it "should use ssl for port 443" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    it 'should not use ssl for port 80' do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'http://foobar.com')
-      request.send(:http).use_ssl?.should == false
-    end
-
-    it "uses ssl for https scheme with default port" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    it "uses ssl for https scheme regardless of port" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com:123456')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    context "PEM certificates" do
-      before do
-        OpenSSL::X509::Certificate.stub(:new)
-        OpenSSL::PKey::RSA.stub(:new)
-      end
-
-      context "when scheme is https" do
-        before do
-          @request.stub!(:uri).and_return(URI.parse("https://google.com"))
-          pem = :pem_contents
-          @cert = mock("OpenSSL::X509::Certificate")
-          @key =  mock("OpenSSL::PKey::RSA")
-          OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(@cert)
-          OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(@key)
-
-          @request.options[:pem] = pem
-          @request.options[:pem_password] = "password"
-          @pem_http = @request.send(:http)
-        end
-
-        it "should use a PEM certificate when provided" do
-          @pem_http.cert.should == @cert
-          @pem_http.key.should == @key
-        end
-
-        it "should verify the certificate when provided" do
-          @pem_http = @request.send(:http)
-          @pem_http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
-        end
-      end
-
-      context "when scheme is not https" do
-        it "does not assign a PEM" do
-          http = Net::HTTP.new('google.com')
-          http.should_not_receive(:cert=)
-          http.should_not_receive(:key=)
-          Net::HTTP.stub(:new => http)
-
-          request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
-          request.options[:pem] = :pem_contents
-          request.send(:http)
-        end
-      end
-
-      context "debugging" do
-        before do
-          @http = Net::HTTP.new('google.com')
-          Net::HTTP.stub(:new => @http)
-          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
-        end
-
-        it "calls #set_debug_output when the option is provided" do
-          @request.options[:debug_output] = $stderr
-          @http.should_receive(:set_debug_output).with($stderr)
-          @request.send(:http)
-        end
-
-        it "does not set_debug_output when the option is not provided" do
-          @http.should_not_receive(:set_debug_output)
-          @request.send(:http)
-        end
-      end
-
-      context 'with a proxy' do
-        it 'should use a proxy address and port' do
-          request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com',
-            :http_proxyaddr => '1.2.3.4', :http_proxyport => 8080)
-          http = request.send(:http)
-          http.proxy_address.should == '1.2.3.4'
-          http.proxy_port.should == 8080
-        end
-
-        it 'should use a proxy user and password when provided' do
-          request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com',
-            :http_proxyaddr => '1.2.3.4', :http_proxyport => 8080,
-            :http_proxyuser => 'user', :http_proxypass => 'pass')
-          http = request.send(:http)
-          http.proxy_user.should == 'user'
-          http.proxy_pass.should == 'pass'
-        end
-      end
-    end
-
-    context "when setting timeout" do
-      it "does nothing if the timeout option is a string" do
-        http = mock("http", :null_object => true)
-        http.should_not_receive(:open_timeout=)
-        http.should_not_receive(:read_timeout=)
-        Net::HTTP.stub(:new => http)
-
-        request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com', {:timeout => "five seconds"})
-        request.send(:http)
-      end
-
-      it "sets the timeout to 5 seconds" do
-        @request.options[:timeout] = 5
-        @request.send(:http).open_timeout.should == 5
-        @request.send(:http).read_timeout.should == 5
-      end
+    it "should get a connection from the connection_adapter" do
+      http = Net::HTTP.new('google.com')
+      adapter = mock('adapter')
+      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443', :connection_adapter => adapter)
+      adapter.should_receive(:call).with(request.uri, request.options).and_return(http)
+      request.send(:http).should be http
     end
   end
 

data/spec/httparty_spec.rb

@@ -38,6 +38,13 @@ describe HTTParty do
     end
   end
 
+  describe 'ssl_version' do
+    it 'should set the ssl_version content' do
+      @klass.ssl_version :SSLv3
+      @klass.default_options[:ssl_version].should == :SSLv3
+    end
+  end
+
   describe 'http_proxy' do
     it 'should set the address' do
       @klass.http_proxy 'proxy.foo.com', 80
@@ -103,6 +110,11 @@ describe HTTParty do
       HTTParty.normalize_base_uri(uri)
       uri.should == 'http://api.foobar.com'
     end
+
+    it "should not treat uri's with a port of 4430 as ssl" do
+      uri = HTTParty.normalize_base_uri('http://api.foo.com:4430/v1')
+      uri.should == 'http://api.foo.com:4430/v1'
+    end
   end
 
   describe "headers" do
@@ -321,6 +333,38 @@ describe HTTParty do
     end
   end
 
+  describe "connection_adapter" do
+    let(:uri) { 'http://google.com/api.json' }
+    let(:connection_adapter) { mock('CustomConnectionAdapter') }
+
+    it "should set the connection_adapter" do
+      @klass.connection_adapter connection_adapter
+      @klass.default_options[:connection_adapter].should be connection_adapter
+    end
+
+    it "should set the connection_adapter_options when provided" do
+      options = {:foo => :bar}
+      @klass.connection_adapter connection_adapter, options
+      @klass.default_options[:connection_adapter_options].should be options
+    end
+
+    it "should not set the connection_adapter_options when not provided" do
+      @klass.connection_adapter connection_adapter
+      @klass.default_options[:connection_adapter_options].should be_nil
+    end
+
+    it "should process a request with a connection from the adapter" do
+      connection_adapter_options = {:foo => :bar}
+      connection_adapter.should_receive(:call) do |u,o|
+        o[:connection_adapter_options].should == connection_adapter_options
+        HTTParty::ConnectionAdapter.call(u,o)
+      end.with(URI.parse(uri), kind_of(Hash))
+      FakeWeb.register_uri(:get, uri, :body => 'stuff')
+      @klass.connection_adapter connection_adapter, connection_adapter_options
+      @klass.get(uri).should == 'stuff'
+    end
+  end
+
   describe "format" do
     it "should allow xml" do
       @klass.format :xml

data/spec/spec_helper.rb

@@ -22,3 +22,9 @@ Spec::Runner.configure do |config|
     FakeWeb.allow_net_connect = true
   end
 end
+
+Spec::Matchers.define :use_ssl do
+  match do |connection|
+    connection.use_ssl?
+  end
+end

metadata

@@ -1,69 +1,54 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: httparty
-version: !ruby/object:Gem::Version 
-  hash: 57
+version: !ruby/object:Gem::Version
+  version: 0.9.0
   prerelease: 
-  segments: 
-  - 0
-  - 8
-  - 3
-  version: 0.8.3
 platform: ruby
-authors: 
+authors:
 - John Nunemaker
 - Sandro Turriate
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-04-22 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  type: :runtime
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2012-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70139029121860 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
-  version_requirements: *id001
-  name: multi_json
-- !ruby/object:Gem::Dependency 
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  version_requirements: *id002
+  version_requirements: *70139029121860
+- !ruby/object:Gem::Dependency
   name: multi_xml
+  requirement: &70139029121440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70139029121440
 description: Makes http fun! Also, makes consuming restful web services dead easy.
-email: 
+email:
 - nunemaker@gmail.com
-executables: 
+executables:
 - httparty
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
 - Guardfile
 - History
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - bin/httparty
 - cucumber.yml
@@ -94,6 +79,7 @@ files:
 - features/supports_timeout_option.feature
 - httparty.gemspec
 - lib/httparty.rb
+- lib/httparty/connection_adapter.rb
 - lib/httparty/cookie_hash.rb
 - lib/httparty/core_extensions.rb
 - lib/httparty/exceptions.rb
@@ -120,6 +106,7 @@ files:
 - spec/fixtures/twitter.json
 - spec/fixtures/twitter.xml
 - spec/fixtures/undefined_method_add_node_for_nil.xml
+- spec/httparty/connection_adapter_spec.rb
 - spec/httparty/cookie_hash_spec.rb
 - spec/httparty/net_digest_auth_spec.rb
 - spec/httparty/parser_spec.rb
@@ -134,40 +121,37 @@ files:
 - spec/support/stub_response.rb
 - website/css/common.css
 - website/index.html
-homepage: http://httparty.rubyforge.org/
+homepage: http://jnunemaker.github.com/httparty
 licenses: []
-
 post_install_message: When you HTTParty, you must party hard!
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -1568840353759951881
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: -1568840353759951881
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Makes http fun! Also, makes consuming restful web services dead easy.
-test_files: 
+test_files:
 - features/basic_authentication.feature
 - features/command_line.feature
 - features/deals_with_http_error_codes.feature
@@ -196,6 +180,7 @@ test_files:
 - spec/fixtures/twitter.json
 - spec/fixtures/twitter.xml
 - spec/fixtures/undefined_method_add_node_for_nil.xml
+- spec/httparty/connection_adapter_spec.rb
 - spec/httparty/cookie_hash_spec.rb
 - spec/httparty/net_digest_auth_spec.rb
 - spec/httparty/parser_spec.rb

data/README.rdoc

@@ -1,47 +0,0 @@
-= httparty
-
-Makes http fun again!
-
-== Features:
-
-* Easy get, post requests
-* Basic http authentication
-* Default request query string parameters (ie: for api keys that are needed on each request)
-* Automatic parsing of JSON and XML into ruby hashes based on response content-type
-
-== Examples
-
-See http://github.com/jnunemaker/httparty/tree/master/examples
-
-== Note on Patches/Pull Requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Command Line Interface
-
-httparty also includes the executable <tt>httparty</tt> which can be
-used to query web services and examine the resulting output. By default
-it will output the response as a pretty-printed Ruby object (useful for
-grokking the structure of output). This can also be overridden to output
-formatted XML or JSON. Execute <tt>httparty --help</tt> for all the
-options. Below is an example of how easy it is.
-
-  httparty "http://twitter.com/statuses/public_timeline.json"
-
-== Requirements
-
-* multijson and multixml
-* You like to party!
-
-== Install
-
-* sudo gem install httparty
-
-== Help and Docs
-
-* https://groups.google.com/forum/#!forum/httparty-gem
-* http://rdoc.info/projects/jnunemaker/httparty