httparty 0.13.3 → 0.13.4

data/examples/google.rb

@@ -10,7 +10,7 @@ end
 # google.com redirects to www.google.com so this is live test for redirection
 pp Google.get('http://google.com')
 
-puts '', '*'*70, ''
+puts '', '*' * 70, ''
 
 # check that ssl is requesting right
-pp Google.get('https://www.google.com')
+pp Google.get('https://www.google.com')

data/examples/logging.rb

@@ -8,31 +8,29 @@ my_logger = Logger.new "httparty.log"
 my_logger.info "Logging can be used on the main HTTParty class. It logs redirects too."
 HTTParty.get "http://google.com", logger: my_logger
 
-my_logger.info '*'*70
+my_logger.info '*' * 70
 
 my_logger.info "It can be used also on a custom class."
 
 class Google
   include HTTParty
-  logger  ::Logger.new "httparty.log"
+  logger ::Logger.new "httparty.log"
 end
 
 Google.get "http://google.com"
 
-my_logger.info '*'*70
+my_logger.info '*' * 70
 
 my_logger.info "The default formatter is :apache. The :curl formatter can also be used."
 my_logger.info "You can tell wich method to call on the logger too. It is info by default."
 HTTParty.get "http://google.com", logger: my_logger, log_level: :debug, log_format: :curl
 
-
-my_logger.info '*'*70
+my_logger.info '*' * 70
 
 my_logger.info "These configs are also available on custom classes."
 class Google
   include HTTParty
-  logger  ::Logger.new("httparty.log"), :debug, :curl
+  logger ::Logger.new("httparty.log"), :debug, :curl
 end
 
 Google.get "http://google.com"
-

data/examples/nokogiri_html_parser.rb

@@ -1,14 +1,11 @@
 require 'rubygems'
 require 'nokogiri'
 
-
 dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 require File.join(dir, 'httparty')
 require 'pp'
 
 class HtmlParserIncluded < HTTParty::Parser
-  SupportedFormats.merge!('text/html' => :html)
-
   def html
     Nokogiri::HTML(body)
   end

data/examples/rescue_json.rb

@@ -0,0 +1,17 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+# Take note of the "; 1" at the end of the following line. It's required only if
+# running this in IRB, because IRB will try to inspect the variable named
+# "request", triggering the exception.
+request = HTTParty.get 'https://rubygems.org/api/v1/versions/doesnotexist.json' ; 1
+
+# Check an exception due to parsing the response
+# because HTTParty evaluate the response lazily
+begin
+  request.inspect
+  # This would also suffice by forcing the request to be parsed:
+  # request.parsed_response
+rescue => e
+  puts "Rescued #{e.inspect}"
+end

data/examples/rubyurl.rb

@@ -6,9 +6,9 @@ class Rubyurl
   include HTTParty
   base_uri 'rubyurl.com'
 
-  def self.shorten( website_url )
-    post( '/api/links.json', query: { link: { website_url: website_url } } )
+  def self.shorten(website_url)
+    post('/api/links.json', query: { link: { website_url: website_url } })
   end
 end
 
-pp Rubyurl.shorten( 'http://istwitterdown.com/')
+pp Rubyurl.shorten('http://istwitterdown.com/')

data/examples/twitter.rb

@@ -1,7 +1,7 @@
 dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 require File.join(dir, 'httparty')
 require 'pp'
-config = YAML::load(File.read(File.join(ENV['HOME'], '.twitter')))
+config = YAML.load(File.read(File.join(ENV['HOME'], '.twitter')))
 
 class Twitter
   include HTTParty
@@ -13,7 +13,7 @@ class Twitter
 
   # which can be :friends, :user or :public
   # options[:query] can be things like since, since_id, count, etc.
-  def timeline(which=:friends, options={})
+  def timeline(which = :friends, options = {})
     options.merge!({basic_auth: @auth})
     self.class.get("/statuses/#{which}_timeline.json", options)
   end

data/examples/whoismyrep.rb

@@ -7,4 +7,4 @@ class Rep
 end
 
 pp Rep.get('http://whoismyrepresentative.com/getall_mems.php?zip=46544')
-pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', query: {zip: 46544})
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', query: {zip: 46544})

data/features/command_line.feature

@@ -1,7 +1,90 @@
+@command_line
 Feature: Command Line
 
   As a developer
   I want to be able to harness the power of HTTParty from the command line
   Because that would make quick testing and debugging easy
-  And 'easy' is my middle name
-  And I'm kidding it's actually 'Danger'!
+
+  Scenario: Show help information
+    When I run `httparty --help`
+    Then the output should contain "-f, --format [FORMAT]"
+
+  Scenario: Make a get request
+    Given a remote deflate service on port '4001'
+    And the response from the service has a body of 'GET request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4001/fun`
+    Then the output should contain "GET request"
+
+  Scenario: Make a post request
+    Given a remote deflate service on port '4002'
+    And the response from the service has a body of 'POST request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4002/fun --action post --data "a=1&b=2"`
+    Then the output should contain "POST request"
+
+  Scenario: Make a put request
+    Given a remote deflate service on port '4003'
+    And the response from the service has a body of 'PUT request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4003/fun --action put --data "a=1&b=2"`
+    Then the output should contain "PUT request"
+
+  Scenario: Make a delete request
+    Given a remote deflate service on port '4004'
+    And the response from the service has a body of 'DELETE request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4004/fun --action delete`
+    Then the output should contain "DELETE request"
+
+  Scenario: Set a verbose mode
+    Given a remote deflate service on port '4005'
+    And the response from the service has a body of 'Some request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4005/fun --verbose`
+    Then the output should contain "content-length"
+
+  Scenario: Use service with basic authentication
+    Given a remote deflate service on port '4006'
+    And the response from the service has a body of 'Successfull authentication'
+    And that service is accessed at the path '/fun'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'user' with the password 'pass'
+    When I run `httparty http://0.0.0.0:4006/fun --user 'user:pass'`
+    Then the output should contain "Successfull authentication"
+
+  Scenario: Get response in plain format
+    Given a remote deflate service on port '4007'
+    And the response from the service has a body of 'Some request'
+    And that service is accessed at the path '/fun'
+    When I run `httparty http://0.0.0.0:4007/fun --format plain`
+    Then the output should contain "Some request"
+
+  Scenario: Get response in json format
+    Given a remote deflate service on port '4008'
+    Given a remote service that returns '{ "jennings": "waylon", "cash": "johnny" }'
+    And that service is accessed at the path '/service.json'
+    And the response from the service has a Content-Type of 'application/json'
+    When I run `httparty http://0.0.0.0:4008/service.json --format json`
+    Then the output should contain '"jennings": "waylon"'
+
+  Scenario: Get response in xml format
+    Given a remote deflate service on port '4009'
+    Given a remote service that returns '<singer>waylon jennings</singer>'
+    And that service is accessed at the path '/service.xml'
+    And the response from the service has a Content-Type of 'text/xml'
+    When I run `httparty http://0.0.0.0:4009/service.xml --format xml`
+    Then the output should contain "<singer>"
+
+  Scenario: Get response in csv format
+    Given a remote deflate service on port '4010'
+    Given a remote service that returns:
+      """
+      "Last Name","Name"
+      "jennings","waylon"
+      "cash","johnny"
+      """
+    And that service is accessed at the path '/service.csv'
+    And the response from the service has a Content-Type of 'application/csv'
+    When I run `httparty http://0.0.0.0:4010/service.csv --format csv`
+    Then the output should contain '["Last Name", "Name"]'

data/features/steps/env.rb

@@ -1,22 +1,27 @@
 require 'mongrel'
 require './lib/httparty'
-require 'spec/expectations'
+require 'rspec/expectations'
+require 'aruba/cucumber'
 
-Before do
-  def new_port
-    server = TCPServer.new('0.0.0.0', nil)
-    port = server.addr[1]
-  ensure
-    server.close
-  end
-
-  port = ENV["HTTPARTY_PORT"] || new_port
+def run_server(port)
   @host_and_port = "0.0.0.0:#{port}"
   @server = Mongrel::HttpServer.new("0.0.0.0", port)
   @server.run
   @request_options = {}
 end
 
+def new_port
+  server = TCPServer.new('0.0.0.0', nil)
+  port = server.addr[1]
+ensure
+  server.close
+end
+
+Before('~@command_line') do
+  port = ENV["HTTPARTY_PORT"] || new_port
+  run_server(port)
+end
+
 After do
-  @server.stop
+  @server.stop if @server
 end

data/features/steps/httparty_response_steps.rb

@@ -12,41 +12,41 @@ def constantize(camel_cased_word)
 end
 
 Then /it should return an? (\w+)$/ do |class_string|
-  @response_from_httparty.should be_an_instance_of(class_string.class)
+  expect(@response_from_httparty).to be_a(class_string.class)
 end
 
 Then /the return value should match '(.*)'/ do |expected_text|
-  @response_from_httparty.should eql(expected_text)
+  expect(@response_from_httparty.parsed_response).to eq(expected_text)
 end
 
 Then /it should return a Hash equaling:/ do |hash_table|
-  @response_from_httparty.should be_an_instance_of(Hash)
-  @response_from_httparty.keys.length.should eql(hash_table.rows.length)
+  expect(@response_from_httparty).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"]
-    @response_from_httparty.keys.should include(key)
-    @response_from_httparty[key].should eql(value)
+    expect(@response_from_httparty.keys).to include(key)
+    expect(@response_from_httparty[key]).to eq(value)
   end
 end
 
 Then /it should return an Array equaling:/ do |array|
-  @response_from_httparty.should be_an_instance_of(Array)
-  @response_from_httparty.should eql array.raw
+  expect(@response_from_httparty).to be_a(Array)
+  expect(@response_from_httparty.parsed_response).to eq(array.raw)
 end
 
 Then /it should return a response with a (\d+) response code/ do |code|
-  @response_from_httparty.code.should eql(code.to_i)
+  expect(@response_from_httparty.code).to eq(code.to_i)
 end
 
 Then /it should return a response with a (.*) content\-encoding$/ do |content_type|
-  @response_from_httparty.headers['content-encoding'].should eql('gzip')
+  expect(@response_from_httparty.headers['content-encoding']).to eq('gzip')
 end
 
 Then /it should return a response with a blank body$/ do
-  @response_from_httparty.body.should be(nil)
+  expect(@response_from_httparty.body).to be_nil
 end
 
 Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
-  @exception_from_httparty.should_not be_nil
-  @exception_from_httparty.should be_a constantize(exception)
+  expect(@exception_from_httparty).to_not be_nil
+  expect(@exception_from_httparty).to be_a constantize(exception)
 end

data/features/steps/mongrel_helper.rb

@@ -10,14 +10,14 @@ class BasicMongrelHandler < Mongrel::HttpHandler
   end
 
   def process(request, response)
-    instance_eval &preprocessor if preprocessor
+    instance_eval(&preprocessor) if preprocessor
     reply_with(response, response_code, response_body)
   end
 
   def reply_with(response, code, response_body)
     response.start(code) do |head, body|
       head["Content-Type"] = content_type
-      custom_headers.each { |k,v| head[k] = v }
+      custom_headers.each { |k, v| head[k] = v }
       body.write(response_body)
     end
   end

data/features/steps/remote_service_steps.rb

@@ -1,6 +1,6 @@
 Given /a remote service that returns '(.*)'/ do |response_body|
   @handler = BasicMongrelHandler.new
-  Given "the response from the service has a body of '#{response_body}'"
+  step "the response from the service has a body of '#{response_body}'"
 end
 
 Given /^a remote service that returns:$/ do |response_body|
@@ -19,13 +19,18 @@ end
 
 Given /^that service takes (\d+) seconds to generate a response$/ do |time|
   @server_response_time = time.to_i
-  @handler.preprocessor = Proc.new { sleep time.to_i }
+  @handler.preprocessor = proc { sleep time.to_i }
 end
 
 Given /^a remote deflate service$/ do
   @handler = DeflateHandler.new
 end
 
+Given /^a remote deflate service on port '(\d+)'/ do |port|
+  run_server(port)
+  @handler = DeflateHandler.new
+end
+
 Given /^a remote gzip service$/ do
   @handler = GzipHandler.new
 end
@@ -55,11 +60,18 @@ Given /that service requires the username '(.*)' with the password '(.*)'/ do |u
   @handler.password = password
 end
 
+# customize aruba cucumber step
+Then /^the output should contain '(.*)'$/ do |expected|
+  assert_partial_output(expected, all_output)
+end
+
 Given /a restricted page at '(.*)'/ do |url|
-  Given "a remote service that returns 'A response I will never see'"
-  And "that service is accessed at the path '#{url}'"
-  And "that service is protected by Basic Authentication"
-  And "that service requires the username 'something' with the password 'secret'"
+  steps "
+    Given a remote service that returns 'A response I will never see'
+    And that service is accessed at the path '#{url}'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'something' with the password 'secret'
+  "
 end
 
 # This joins the server thread, and halts cucumber, so you can actually hit the

data/httparty.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
 require "httparty/version"
 
 Gem::Specification.new do |s|
@@ -10,8 +10,8 @@ Gem::Specification.new do |s|
   s.authors     = ["John Nunemaker", "Sandro Turriate"]
   s.email       = ["nunemaker@gmail.com"]
   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.}
+  s.summary     = 'Makes http fun! Also, makes consuming restful web services dead easy.'
+  s.description = 'Makes http fun! Also, makes consuming restful web services dead easy.'
 
   s.required_ruby_version     = '>= 1.9.3'
 
@@ -23,6 +23,6 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/lib/httparty.rb

@@ -16,22 +16,9 @@ require 'httparty/logger/logger'
 
 # @see HTTParty::ClassMethods
 module HTTParty
-  module AllowedFormatsDeprecation
-    def const_missing(const)
-      if const.to_s =~ /AllowedFormats$/
-        Kernel.warn("Deprecated: Use HTTParty::Parser::SupportedFormats")
-        HTTParty::Parser::SupportedFormats
-      else
-        super
-      end
-    end
-  end
-
-  extend AllowedFormatsDeprecation
-
   def self.included(base)
     base.extend ClassMethods
-    base.send :include, HTTParty::ModuleInheritableAttributes
+    base.send :include, ModuleInheritableAttributes
     base.send(:mattr_inheritable, :default_options)
     base.send(:mattr_inheritable, :default_cookies)
     base.instance_variable_set("@default_options", {})
@@ -69,16 +56,13 @@ module HTTParty
   # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
 
   module ClassMethods
-
-    extend AllowedFormatsDeprecation
-
     # Turns on logging
     #
     #   class Foo
     #     include HTTParty
     #     logger Logger.new('http_logger'), :info, :apache
     #   end
-    def logger(logger, level=:info, format=:apache)
+    def logger(logger, level = :info, format = :apache)
       default_options[:logger]     = logger
       default_options[:log_level]  = level
       default_options[:log_format] = format
@@ -90,7 +74,7 @@ module HTTParty
     #     include HTTParty
     #     http_proxy 'http://foo.com', 80, 'user', 'pass'
     #   end
-    def http_proxy(addr=nil, port=nil, user=nil, pass=nil)
+    def http_proxy(addr = nil, port = nil, user = nil, pass = nil)
       default_options[:http_proxyaddr] = addr
       default_options[:http_proxyport] = port
       default_options[:http_proxyuser] = user
@@ -104,7 +88,7 @@ module HTTParty
     #     include HTTParty
     #     base_uri 'twitter.com'
     #   end
-    def base_uri(uri=nil)
+    def base_uri(uri = nil)
       return default_options[:base_uri] unless uri
       default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
     end
@@ -158,7 +142,7 @@ module HTTParty
     #     include HTTParty
     #     default_params api_key: 'secret', another: 'foo'
     #   end
-    def default_params(h={})
+    def default_params(h = {})
       raise ArgumentError, 'Default params must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
       default_options[:default_params] ||= {}
       default_options[:default_params].merge!(h)
@@ -215,13 +199,13 @@ module HTTParty
     #     include HTTParty
     #     headers 'Accept' => 'text/html'
     #   end
-    def headers(h={})
+    def headers(h = {})
       raise ArgumentError, 'Headers must 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={})
+    def cookies(h = {})
       raise ArgumentError, 'Cookies must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
       default_cookies.add_cookies(h)
     end
@@ -318,7 +302,7 @@ module HTTParty
     #     include HTTParty
     #     pem File.read('/home/user/my.pem'), "optional password"
     #   end
-    def pem(pem_contents, password=nil)
+    def pem(pem_contents, password = nil)
       default_options[:pem] = pem_contents
       default_options[:pem_password] = password
     end
@@ -471,7 +455,7 @@ module HTTParty
     #   # Simple get with full url and query parameters
     #   # ie: http://foo.com/resource.json?limit=10
     #   Foo.get('http://foo.com/resource.json', query: {limit: 10})
-    def get(path, options={}, &block)
+    def get(path, options = {}, &block)
       perform_request Net::HTTP::Get, path, options, &block
     end
 
@@ -487,75 +471,73 @@ module HTTParty
     #   # Simple post with full url using :query option,
     #   # which gets set as form data on the request.
     #   Foo.post('http://foo.com/resources', query: {bar: 'baz'})
-    def post(path, options={}, &block)
+    def post(path, options = {}, &block)
       perform_request Net::HTTP::Post, path, options, &block
     end
 
     # Perform a PATCH request to a path
-    def patch(path, options={}, &block)
+    def patch(path, options = {}, &block)
       perform_request Net::HTTP::Patch, path, options, &block
     end
 
     # Perform a PUT request to a path
-    def put(path, options={}, &block)
+    def put(path, options = {}, &block)
       perform_request Net::HTTP::Put, path, options, &block
     end
 
     # Perform a DELETE request to a path
-    def delete(path, options={}, &block)
+    def delete(path, options = {}, &block)
       perform_request Net::HTTP::Delete, path, options, &block
     end
 
     # Perform a MOVE request to a path
-    def move(path, options={}, &block)
+    def move(path, options = {}, &block)
       perform_request Net::HTTP::Move, path, options, &block
     end
 
     # Perform a COPY request to a path
-    def copy(path, options={}, &block)
+    def copy(path, options = {}, &block)
       perform_request Net::HTTP::Copy, path, options, &block
     end
 
     # Perform a HEAD request to a path
-    def head(path, options={}, &block)
+    def head(path, options = {}, &block)
       perform_request Net::HTTP::Head, path, options, &block
     end
 
     # Perform an OPTIONS request to a path
-    def options(path, options={}, &block)
+    def options(path, options = {}, &block)
       perform_request Net::HTTP::Options, path, options, &block
     end
 
-    def default_options #:nodoc:
-      @default_options
-    end
+    attr_reader :default_options
 
     private
 
-      def perform_request(http_method, path, options, &block) #:nodoc:
-        options = ModuleInheritableAttributes.hash_deep_dup(default_options).merge(options)
-        process_headers(options)
-        process_cookies(options)
-        Request.new(http_method, path, options).perform(&block)
-      end
+    def perform_request(http_method, path, options, &block) #:nodoc:
+      options = ModuleInheritableAttributes.hash_deep_dup(default_options).merge(options)
+      process_headers(options)
+      process_cookies(options)
+      Request.new(http_method, path, options).perform(&block)
+    end
 
-      def process_headers(options)
-        if options[:headers] && headers.any?
-          options[:headers] = headers.merge(options[:headers])
-        end
+    def process_headers(options)
+      if options[:headers] && headers.any?
+        options[:headers] = headers.merge(options[:headers])
       end
+    end
 
-      def process_cookies(options) #:nodoc:
-        return unless options[:cookies] || default_cookies.any?
-        options[:headers] ||= headers.dup
-        options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
-      end
+    def process_cookies(options) #:nodoc:
+      return unless options[:cookies] || default_cookies.any?
+      options[:headers] ||= headers.dup
+      options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
+    end
 
-      def validate_format
-        if format && parser.respond_to?(:supports_format?) && !parser.supports_format?(format)
-          raise UnsupportedFormat, "'#{format.inspect}' Must be one of: #{parser.supported_formats.map{|f| f.to_s}.sort.join(', ')}"
-        end
+    def validate_format
+      if format && parser.respond_to?(:supports_format?) && !parser.supports_format?(format)
+        raise UnsupportedFormat, "'#{format.inspect}' Must be one of: #{parser.supported_formats.map(&:to_s).sort.join(', ')}"
       end
+    end
   end
 
   def self.normalize_base_uri(url) #:nodoc:
@@ -610,7 +592,6 @@ module HTTParty
   end
 end
 
-require 'httparty/core_extensions'
 require 'httparty/hash_conversions'
 require 'httparty/exceptions'
 require 'httparty/parser'