httparty 0.13.7 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e38f46dd22e2a48a187998d68305ae356a1a9c8
-  data.tar.gz: 257d70e92f1a15ee99c017c30f05b93b95b2410a
+  metadata.gz: f66396072d869ad76f661789a0e9b2d66495faa2
+  data.tar.gz: ae8e43661459ee5bd5c9018645812ecd9500cd6b
 SHA512:
-  metadata.gz: 106f0de2d1a32408da7442ccedc324dda618fa233e4e29389b632f3be6b0c39ab36280b9fe33247a7878fc8a8a6323eee8ed6566ff5ea24ea341e04ffc0d5da1
-  data.tar.gz: f4f2e8725cf55e63480e54b84e6f4c386815debd6033dd396c4a12217cddc7f8154c22ccde4999a9b048f4b0e53192e4a5f975793a57114270afb8d867ce985c
+  metadata.gz: ac6a080a19674df0435a6715406b97645ed9ee2ed803b92eb3e90ade39e75ac311b3e11960d2c44d00a561720be53aa1d229f216fb40e67f4452659701005695
+  data.tar.gz: 7529cf1586833fef74e6e6840a8992ab6b8c8b9ff83db89c5179bf166ce21abc0868c63bd800b5f110a85f65c90472e24cc89632d9cedf0f3bae39c70c1baa6c

data/.travis.yml

@@ -2,6 +2,8 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-notifications:
-  email: false
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
 bundler_args: --without development
+before_install: gem install bundler

data/Gemfile

@@ -12,8 +12,8 @@ group :development do
 end
 
 group :test do
-  gem 'rspec',    '~> 3.1'
+  gem 'rspec',    '~> 3.4'
   gem 'simplecov', require: false
   gem 'aruba'
-  gem 'cucumber', '~> 1.3.17'
+  gem 'cucumber', '~> 2.3'
 end

data/History

@@ -1,3 +1,11 @@
+== 0.14.0
+* [added status predicate methods to Response#respond_to?](https://github.com/jnunemaker/httparty/pull/482)
+* [allow empty array to be used as param](https://github.com/jnunemaker/httparty/pull/477)
+* [add support for MKCOL method](https://github.com/jnunemaker/httparty/pull/465)
+* [remove json gem from gemspec](https://github.com/jnunemaker/httparty/pull/464)
+* [stop mutating cookie hash](https://github.com/jnunemaker/httparty/pull/460)
+* [optional raising exception on certain status codes](https://github.com/jnunemaker/httparty/pull/455)
+
 == 0.13.7 aka "party not as hard"
 * remove post install emoji as it caused installation issues for some people
 

data/README.md

@@ -62,6 +62,7 @@ httparty "https://api.stackexchange.com/2.2/questions?site=stackoverflow"
 
 ## Help and Docs
 
+* [Docs](docs/)
 * https://groups.google.com/forum/#!forum/httparty-gem
 * http://rdoc.info/projects/jnunemaker/httparty
 * http://stackoverflow.com/questions/tagged/httparty

data/docs/README.md

@@ -0,0 +1,100 @@
+# httparty
+
+Makes http fun again!
+
+## Table of contents
+- [Working with SSL](#working-with-ssl)
+
+## Working with SSL
+
+You can use this guide to work with SSL certificates.
+
+#### Using `pem` option
+
+```ruby
+# Use this example if you are using a pem file
+
+class Client
+	include HTTParty
+	
+	base_uri "https://example.com"
+	pem File.read("#{File.expand_path('.')}/path/to/certs/cert.pem"), "123456"
+
+end
+```
+
+#### Using `pkcs12` option
+
+```ruby
+# Use this example if you are using a pkcs12 file
+
+class Client
+	include HTTParty
+	
+	base_uri "https://example.com"
+	pkcs12 File.read("#{File.expand_path('.')}/path/to/certs/cert.p12"), "123456"
+
+end
+```
+
+#### Using `ssl_ca_file` option
+
+```ruby
+# Use this example if you are using a pkcs12 file
+
+class Client
+	include HTTParty
+	
+	base_uri "https://example.com"
+	ssl_ca_file "#{File.expand_path('.')}/path/to/certs/cert.pem"
+
+end
+```
+
+#### Using `ssl_ca_path` option
+
+```ruby
+# Use this example if you are using a pkcs12 file
+
+class Client
+	include HTTParty
+	
+	base_uri "https://example.com"
+ 	ssl_ca_path '/path/to/certs'
+end
+```
+
+You can also include this options with the call:
+
+```ruby
+class Client
+	include HTTParty
+	
+	base_uri "https://example.com"
+	
+	def	self.fetch
+		get("/resources", pem: (File.read("#{File.expand_path('.')}/path/to/certs/cert.pem"), "123456")
+	end
+end
+```
+
+### Avoid SSL verification
+
+In some cases you may want to skip SSL verification, because the entity that issue the certificate is not a valid one, but you still want to work with it. You can achieve this through:
+
+```ruby
+#Skips SSL certificate verification
+
+class Client
+	include HTTParty
+
+	base_uri "https://example.com"
+	pem File.read("#{File.expand_path('.')}/path/to/certs/cert.pem"), "123456"
+	
+	def	self.fetch
+		get("/resources", verify: false)
+		# You can also use something like:
+		# get("resources", verify_peer: false)
+	end
+end
+```

data/examples/tripit_sign_in.rb

@@ -3,30 +3,41 @@ require File.join(dir, 'httparty')
 
 class TripIt
   include HTTParty
-  base_uri 'http://www.tripit.com'
+  base_uri 'https://www.tripit.com'
   debug_output
 
   def initialize(email, password)
     @email = email
-    response = self.class.get('/account/login')
-    response = self.class.post(
+    get_response = self.class.get('/account/login')
+    get_response_cookie = parse_cookie(get_response.headers['Set-Cookie'])
+
+    post_response = self.class.post(
       '/account/login',
       body: {
         login_email_address: email,
         login_password: password
       },
-      headers: {'Cookie' => response.headers['Set-Cookie']}
+      headers: {'Cookie' => get_response_cookie.to_cookie_string }
     )
-    @cookie = response.request.options[:headers]['Cookie']
+
+    @cookie = parse_cookie(post_response.headers['Set-Cookie'])
   end
 
   def account_settings
-    self.class.get('/account/edit', headers: {'Cookie' => @cookie})
+    self.class.get('/account/edit', headers: {'Cookie' => @cookie.to_cookie_string})
   end
 
   def logged_in?
     account_settings.include? "You're logged in as #{@email}"
   end
+
+  private
+
+  def parse_cookie(resp)
+    cookie_hash = CookieHash.new
+    resp.get_fields('Set-Cookie').each { |c| cookie_hash.add_cookies(c) }
+    cookie_hash
+  end
 end
 
 tripit = TripIt.new('email', 'password')

data/features/steps/httparty_response_steps.rb

@@ -11,8 +11,8 @@ def constantize(camel_cased_word)
   constant
 end
 
-Then /it should return an? (\w+)$/ do |class_string|
-  expect(@response_from_httparty).to be_a(class_string.class)
+Then /it should return an? ([\w\:]+)$/ do |class_string|
+  expect(@response_from_httparty.parsed_response).to be_a(Object.const_get(class_string))
 end
 
 Then /the return value should match '(.*)'/ do |expected_text|
@@ -20,7 +20,7 @@ Then /the return value should match '(.*)'/ do |expected_text|
 end
 
 Then /it should return a Hash equaling:/ do |hash_table|
-  expect(@response_from_httparty).to be_a(Hash)
+  expect(@response_from_httparty.parsed_response).to be_a(Hash)
   expect(@response_from_httparty.keys.length).to eq(hash_table.rows.length)
   hash_table.hashes.each do |pair|
     key, value = pair["key"], pair["value"]
@@ -30,7 +30,7 @@ Then /it should return a Hash equaling:/ do |hash_table|
 end
 
 Then /it should return an Array equaling:/ do |array|
-  expect(@response_from_httparty).to be_a(Array)
+  expect(@response_from_httparty.parsed_response).to be_a(Array)
   expect(@response_from_httparty.parsed_response).to eq(array.raw)
 end
 
@@ -50,3 +50,7 @@ Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
   expect(@exception_from_httparty).to_not be_nil
   expect(@exception_from_httparty).to be_a constantize(exception)
 end
+
+Then /it should not raise (?:an|a) ([\w:]+) exception/ do |exception|
+  expect(@exception_from_httparty).to be_nil
+end

data/features/steps/remote_service_steps.rb

@@ -17,9 +17,11 @@ Given /that service is accessed at the path '(.*)'/ do |path|
   @server.register(path, @handler)
 end
 
-Given /^that service takes (\d+) seconds to generate a response$/ do |time|
-  @server_response_time = time.to_i
-  @handler.preprocessor = proc { sleep time.to_i }
+Given /^that service takes (\d+) (.*) to generate a response$/ do |time, unit|
+  time = time.to_i
+  time *= 60 if unit =~ /minute/
+  @server_response_time = time
+  @handler.preprocessor = proc { sleep time }
 end
 
 Given /^a remote deflate service$/ do
@@ -66,7 +68,7 @@ end
 
 # customize aruba cucumber step
 Then /^the output should contain '(.*)'$/ do |expected|
-  assert_partial_output(expected, all_output)
+  expect(all_commands.map(&:output).join("\n")).to match_output_string(expected)
 end
 
 Given /a restricted page at '(.*)'/ do |url|

data/httparty.gemspec

@@ -15,7 +15,6 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version     = '>= 1.9.3'
 
-  s.add_dependency 'json',      "~> 1.8"
   s.add_dependency 'multi_xml', ">= 0.5.2"
 
   # If this line is removed, all hard partying will cease.

data/lib/httparty.rb

@@ -72,6 +72,16 @@ module HTTParty
       default_options[:log_format] = format
     end
 
+    # Raises HTTParty::ResponseError if response's code matches this statuses
+    #
+    #   class Foo
+    #     include HTTParty
+    #     raise_on [404, 500]
+    #   end
+    def raise_on(codes = [])
+      default_options[:raise_on] = *codes
+    end
+
     # Allows setting http proxy information to be used
     #
     #   class Foo
@@ -147,7 +157,7 @@ module HTTParty
     #     default_params api_key: 'secret', another: 'foo'
     #   end
     def default_params(h = {})
-      raise ArgumentError, 'Default params must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
+      raise ArgumentError, 'Default params must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
       default_options[:default_params] ||= {}
       default_options[:default_params].merge!(h)
     end
@@ -204,13 +214,13 @@ module HTTParty
     #     headers 'Accept' => 'text/html'
     #   end
     def headers(h = {})
-      raise ArgumentError, 'Headers must an object which responds to #to_hash' unless h.respond_to?(:to_hash)
+      raise ArgumentError, 'Headers must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
       default_options[:headers] ||= {}
       default_options[:headers].merge!(h.to_hash)
     end
 
     def cookies(h = {})
-      raise ArgumentError, 'Cookies must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
+      raise ArgumentError, 'Cookies must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
       default_cookies.add_cookies(h)
     end
 
@@ -486,7 +496,7 @@ module HTTParty
     #   Foo.post('http://foo.com/resources', body: {bar: 'baz'})
     #
     #   # Simple post with full url using :query option,
-    #   # which gets set as form data on the request.
+    #   # which appends the parameters to the URI.
     #   Foo.post('http://foo.com/resources', query: {bar: 'baz'})
     def post(path, options = {}, &block)
       perform_request Net::HTTP::Post, path, options, &block
@@ -528,12 +538,17 @@ module HTTParty
       perform_request Net::HTTP::Options, path, options, &block
     end
 
+    # Perform a MKCOL request to a path
+    def mkcol(path, options = {}, &block)
+      perform_request Net::HTTP::Mkcol, path, options, &block
+    end
+
     attr_reader :default_options
 
     private
 
     def ensure_method_maintained_across_redirects(options)
-      unless options.has_key? :maintain_method_across_redirects
+      unless options.key?(:maintain_method_across_redirects)
         options[:maintain_method_across_redirects] = true
       end
     end

data/lib/httparty/connection_adapter.rb

@@ -53,6 +53,11 @@ module HTTParty
     # Private: Regex used to strip brackets from IPv6 URIs.
     StripIpv6BracketsRegex = /\A\[(.*)\]\z/
 
+    OPTION_DEFAULTS = {
+      verify: true,
+      verify_peer: true
+    }
+
     # Public
     def self.call(uri, options)
       new(uri, options).connection
@@ -65,13 +70,13 @@ module HTTParty
       raise ArgumentError, "uri must be a #{uri_adapter}, not a #{uri.class}" unless uri.is_a? uri_adapter
 
       @uri = uri
-      @options = options
+      @options = OPTION_DEFAULTS.merge(options)
     end
 
     def connection
       host = clean_host(uri.host)
       port = uri.port || (uri.scheme == 'https' ? 443 : 80)
-      if options[:http_proxyaddr]
+      if options.key?(:http_proxyaddr)
         http = Net::HTTP.new(host, port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
       else
         http = Net::HTTP.new(host, port)
@@ -138,6 +143,10 @@ module HTTParty
       uri.port == 443 || uri.scheme == 'https'
     end
 
+    def verify_ssl_certificate?
+      !(options[:verify] == false || options[:verify_peer] == false)
+    end
+
     def attach_ssl_certificates(http, options)
       if http.use_ssl?
         if options.fetch(:verify, true)
@@ -158,7 +167,7 @@ module HTTParty
         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 = options[:verify_peer] == false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+          http.verify_mode = verify_ssl_certificate? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
         end
 
         # PKCS12 client certificate authentication
@@ -166,7 +175,7 @@ module HTTParty
           p12 = OpenSSL::PKCS12.new(options[:p12], options[:p12_password])
           http.cert = p12.certificate
           http.key = p12.key
-          http.verify_mode = options[:verify_peer] == false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+          http.verify_mode = verify_ssl_certificate? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
         end
 
         # SSL certificate authority file and/or directory

data/lib/httparty/cookie_hash.rb

@@ -16,6 +16,6 @@ class HTTParty::CookieHash < Hash #:nodoc:
   end
 
   def to_cookie_string
-    delete_if { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+    reject { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
   end
 end

data/lib/httparty/exceptions.rb

@@ -2,7 +2,7 @@ module HTTParty
   # @abstact Exceptions raised by HTTParty inherit from Error
   class Error < StandardError; end
 
-  # Exception raised when you attempt to set a non-existant format
+  # Exception raised when you attempt to set a non-existent format
   class UnsupportedFormat < Error; end
 
   # Exception raised when using a URI scheme other than HTTP or HTTPS
@@ -26,4 +26,7 @@ module HTTParty
   # Exception that is raised when request has redirected too many times.
   # Calling {#response} returns the Net:HTTP response object.
   class RedirectionTooDeep < ResponseError; end
+
+  # Exception that is raised when request redirects and location header is present more than once
+  class DuplicateLocationHeader < ResponseError; end
 end

data/lib/httparty/hash_conversions.rb

@@ -26,7 +26,11 @@ module HTTParty
       stack = []
 
       if value.respond_to?(:to_ary)
-        param << value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+        param << if value.empty?
+                   "#{key}[]=&"
+                 else
+                   value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+                 end
       elsif value.respond_to?(:to_hash)
         stack << [key, value.to_hash]
       else

data/lib/httparty/logger/curl_formatter.rb

@@ -2,46 +2,89 @@ module HTTParty
   module Logger
     class CurlFormatter #:nodoc:
       TAG_NAME = HTTParty.name
-      OUT = ">"
-      IN = "<"
+      OUT      = '>'.freeze
+      IN       = '<'.freeze
 
-      attr_accessor :level, :logger, :current_time
+      attr_accessor :level, :logger
 
       def initialize(logger, level)
-        @logger = logger
-        @level  = level.to_sym
+        @logger   = logger
+        @level    = level.to_sym
+        @messages = []
       end
 
       def format(request, response)
-        messages        = []
-        time            = Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
-        http_method     = request.http_method.name.split("::").last.upcase
-        path            = request.path.to_s
+        @request  = request
+        @response = response
 
-        messages << print(time, OUT, "#{http_method} #{path}")
+        log_request
+        log_response
 
-        if request.options[:headers] && request.options[:headers].size > 0
-          request.options[:headers].each do |k, v|
-            messages << print(time, OUT, "#{k}: #{v}")
-          end
-        end
+        logger.send level, messages.join("\n")
+      end
+
+      private
+
+      attr_reader :request, :response
+      attr_accessor :messages
+
+      def log_request
+        log_url
+        log_headers
+        log_query
+        log OUT, request.raw_body if request.raw_body
+        log OUT
+      end
+
+      def log_response
+        log IN, "HTTP/#{response.http_version} #{response.code}"
+        log_response_headers
+        log IN, "\n#{response.body}"
+        log IN
+      end
+
+      def log_url
+        http_method = request.http_method.name.split("::").last.upcase
+        uri = if request.options[:base_uri]
+                request.options[:base_uri] + request.path.path
+              else
+                request.path.to_s
+              end
 
-        messages << print(time, OUT, request.raw_body)
-        messages << print(time, OUT, "")
-        messages << print(time, IN, "HTTP/#{response.http_version} #{response.code}")
+        log OUT, "#{http_method} #{uri}"
+      end
+
+      def log_headers
+        return unless request.options[:headers] && request.options[:headers].size > 0
+
+        log OUT, 'Headers: '
+        log_hash request.options[:headers]
+      end
+
+      def log_query
+        return unless request.options[:query]
 
+        log OUT, 'Query: '
+        log_hash request.options[:query]
+      end
+
+      def log_response_headers
         headers = response.respond_to?(:headers) ? response.headers : response
         response.each_header do |response_header|
-          messages << print(time, IN, "#{response_header.capitalize}: #{headers[response_header]}")
+          log IN, "#{response_header.capitalize}: #{headers[response_header]}"
         end
+      end
 
-        messages << print(time, IN, "\n#{response.body}")
+      def log_hash(hash)
+        hash.each { |k, v| log(OUT, "#{k}: #{v}") }
+      end
 
-        @logger.send @level, messages.join("\n")
+      def log(direction, line = '')
+        messages << "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
       end
 
-      def print(time, direction, line)
-        "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
+      def time
+        @time ||= Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
       end
     end
   end