httsoiree 0.13.1

data/features/steps/mongrel_helper.rb

@@ -0,0 +1,94 @@
+require 'base64'
+class BasicMongrelHandler < Mongrel::HttpHandler
+  attr_accessor :content_type, :custom_headers, :response_body, :response_code, :preprocessor, :username, :password
+
+  def initialize
+    @content_type = "text/html"
+    @response_body = ""
+    @response_code = 200
+    @custom_headers = {}
+  end
+
+  def process(request, response)
+    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 }
+      body.write(response_body)
+    end
+  end
+end
+
+class DeflateHandler < BasicMongrelHandler
+  def process(request, response)
+    response.start do |head, body|
+      head['Content-Encoding'] = 'deflate'
+      body.write Zlib::Deflate.deflate(response_body)
+    end
+  end
+end
+
+class GzipHandler < BasicMongrelHandler
+  def process(request, response)
+    response.start do |head, body|
+      head['Content-Encoding'] = 'gzip'
+      body.write gzip(response_body)
+    end
+  end
+
+  protected
+
+  def gzip(string)
+    sio = StringIO.new('', 'r+')
+    gz = Zlib::GzipWriter.new sio
+    gz.write string
+    gz.finish
+    sio.rewind
+    sio.read
+  end
+end
+
+module BasicAuthentication
+  def self.extended(base)
+    base.custom_headers["WWW-Authenticate"] = 'Basic Realm="Super Secret Page"'
+  end
+
+  def process(request, response)
+    if authorized?(request)
+      super
+    else
+      reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+    end
+  end
+
+  def authorized?(request)
+    request.params["HTTP_AUTHORIZATION"] == "Basic " + Base64.encode64("#{@username}:#{@password}").strip
+  end
+end
+
+module DigestAuthentication
+  def self.extended(base)
+    base.custom_headers["WWW-Authenticate"] = 'Digest realm="testrealm@host.com",qop="auth,auth-int",nonce="nonce",opaque="opaque"'
+  end
+
+  def process(request, response)
+    if authorized?(request)
+      super
+    else
+      reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+    end
+  end
+
+  def authorized?(request)
+    request.params["HTTP_AUTHORIZATION"] =~ /Digest.*uri=/
+  end
+end
+
+def new_mongrel_redirector(target_url, relative_path = false)
+  target_url = "http://#{@host_and_port}#{target_url}" unless relative_path
+  Mongrel::RedirectHandler.new(target_url)
+end

data/features/steps/remote_service_steps.rb

@@ -0,0 +1,74 @@
+Given /a remote service that returns '(.*)'/ do |response_body|
+  @handler = BasicMongrelHandler.new
+  Given "the response from the service has a body of '#{response_body}'"
+end
+
+Given /^a remote service that returns:$/ do |response_body|
+  @handler = BasicMongrelHandler.new
+  @handler.response_body = response_body
+end
+
+Given /a remote service that returns a (\d+) status code/ do |code|
+  @handler = BasicMongrelHandler.new
+  @handler.response_code = code
+end
+
+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.new { sleep time.to_i }
+end
+
+Given /^a remote deflate service$/ do
+  @handler = DeflateHandler.new
+end
+
+Given /^a remote gzip service$/ do
+  @handler = GzipHandler.new
+end
+
+Given /the response from the service has a Content-Type of '(.*)'/ do |content_type|
+  @handler.content_type = content_type
+end
+
+Given /the response from the service has a body of '(.*)'/ do |response_body|
+  @handler.response_body = response_body
+end
+
+Given /the url '(.*)' redirects to '(.*)'/ do |redirection_url, target_url|
+  @server.register redirection_url, new_mongrel_redirector(target_url)
+end
+
+Given /that service is protected by Basic Authentication/ do
+  @handler.extend BasicAuthentication
+end
+
+Given /that service is protected by Digest Authentication/ do
+  @handler.extend DigestAuthentication
+end
+
+Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
+  @handler.username = username
+  @handler.password = password
+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'"
+end
+
+# This joins the server thread, and halts cucumber, so you can actually hit the
+# server with a browser.  Runs until you kill it with Ctrl-c
+Given /I want to hit this in a browser/ do
+  @server.acceptor.join
+end
+
+Then /I wait for the server to recover/ do
+  timeout = @request_options[:timeout] || 0
+  sleep @server_response_time - timeout
+end

data/features/supports_read_timeout_option.feature

@@ -0,0 +1,13 @@
+Feature: Supports the read timeout option
+  In order to handle inappropriately slow response times
+  As a developer
+  I want my request to raise an exception after my specified read_timeout as elapsed
+
+  Scenario: A long running response
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/long_running_service.html'
+    And that service takes 2 seconds to generate a response
+    When I set my HTTParty read_timeout option to 1
+    And I call HTTParty#get with '/long_running_service.html'
+    Then it should raise a Timeout::Error exception
+    And I wait for the server to recover

data/features/supports_redirection.feature

@@ -0,0 +1,22 @@
+Feature: Supports Redirection
+
+  As a developer
+  I want to work with services that may redirect me
+  And I want it to follow a reasonable number of redirects
+  Because sometimes web services do that
+
+  Scenario: A service that redirects once
+    Given a remote service that returns 'Service Response'
+    And that service is accessed at the path '/landing_service.html'
+    And the url '/redirector.html' redirects to '/landing_service.html'
+    When I call HTTParty#get with '/redirector.html'
+    Then the return value should match 'Service Response'
+
+  # TODO: Look in to why this actually fails...
+  Scenario: A service that redirects to a relative URL
+
+  Scenario: A service that redirects infinitely
+    Given the url '/first.html' redirects to '/second.html'
+    And the url '/second.html' redirects to '/first.html'
+    When I call HTTParty#get with '/first.html'
+    Then it should raise an HTTParty::RedirectionTooDeep exception

data/features/supports_timeout_option.feature

@@ -0,0 +1,13 @@
+Feature: Supports the timeout option
+  In order to handle inappropriately slow response times
+  As a developer
+  I want my request to raise an exception after my specified timeout as elapsed
+
+  Scenario: A long running response
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/long_running_service.html'
+    And that service takes 2 seconds to generate a response
+    When I set my HTTParty timeout option to 1
+    And I call HTTParty#get with '/long_running_service.html'
+    Then it should raise a Timeout::Error exception
+    And I wait for the server to recover

data/httparty.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "httparty/version"
+
+Gem::Specification.new do |s|
+  s.name        = "httparty"
+  s.version     = HTTParty::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.licenses    = ['MIT']
+  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.required_ruby_version     = '>= 1.9.3'
+
+  s.add_dependency 'json',      "~> 1.8"
+  s.add_dependency 'multi_xml', ">= 0.5.2"
+
+  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.require_paths = ["lib"]
+end

data/lib/httparty/connection_adapter.rb

@@ -0,0 +1,188 @@
+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.
+  # Some things that are probably interesting are as follows:
+  # * :+timeout+: timeout in seconds
+  # * :+open_timeout+: http connection open_timeout in seconds, overrides timeout if set
+  # * :+read_timeout+: http connection read_timeout in seconds, overrides timeout if set
+  # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
+  # * :+pem+: contains pem data. see HTTParty::ClassMethods.pem.
+  # * :+verify+: verify the server’s certificate against the ca certificate.
+  # * :+verify_peer+: set to false to turn off server verification but still send client certificate
+  # * :+ssl_ca_file+: see HTTParty::ClassMethods.ssl_ca_file.
+  # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
+  # * :+connection_adapter_options+: contains the hash you passed to HTTParty.connection_adapter when you configured your connection adapter
+  class ConnectionAdapter
+
+    # Private: Regex used to strip brackets from IPv6 URIs.
+    StripIpv6BracketsRegex = /\A\[(.*)\]\z/
+
+    # Public
+    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
+      host = clean_host(uri.host)
+      if options[:http_proxyaddr]
+        http = Net::HTTP.new(host, uri.port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
+      else
+        http = Net::HTTP.new(host, uri.port)
+      end
+
+      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[:read_timeout] && (options[:read_timeout].is_a?(Integer) || options[:read_timeout].is_a?(Float))
+        http.read_timeout = options[:read_timeout]
+      end
+
+      if options[:open_timeout] && (options[:open_timeout].is_a?(Integer) || options[:open_timeout].is_a?(Float))
+        http.open_timeout = options[:open_timeout]
+      end
+
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
+      end
+
+      if options[:ciphers]
+        http.ciphers = options[:ciphers]
+      end
+
+      # Bind to a specific local address or port
+      #
+      # @see https://bugs.ruby-lang.org/issues/6617
+      if options[:local_host]
+        if RUBY_VERSION >= "2.0.0"
+          http.local_host = options[:local_host]
+        else
+          Kernel.warn("Warning: option :local_host requires Ruby version 2.0 or later")
+        end
+      end
+
+      if options[:local_port]
+        if RUBY_VERSION >= "2.0.0"
+          http.local_port = options[:local_port]
+        else
+          Kernel.warn("Warning: option :local_port requires Ruby version 2.0 or later")
+        end
+      end
+
+      return http
+    end
+
+    private
+
+    def clean_host(host)
+      strip_ipv6_brackets(host)
+    end
+
+    def strip_ipv6_brackets(host)
+      StripIpv6BracketsRegex =~ host ? $1 : host
+    end
+
+    def ssl_implied?(uri)
+      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    end
+
+    def attach_ssl_certificates(http, options)
+      if http.use_ssl?
+        if options.fetch(:verify, true)
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          if options[:cert_store]
+            http.cert_store = options[:cert_store]
+          else
+            # Use the default cert store by default, i.e. system ca certs
+            http.cert_store = OpenSSL::X509::Store.new
+            http.cert_store.set_default_paths
+          end
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        # 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 = options[:verify_peer] == false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # PKCS12 client certificate authentication
+        if options[:p12]
+          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
+        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/cookie_hash.rb

@@ -0,0 +1,22 @@
+class HTTParty::CookieHash < Hash #:nodoc:
+
+  CLIENT_COOKIES = %w{path expires domain path secure httponly}
+
+  def add_cookies(value)
+    case value
+    when Hash
+      merge!(value)
+    when String
+      value.split('; ').each do |cookie|
+        array = cookie.split('=',2)
+        self[array[0].to_sym] = array[1]
+      end
+    else
+      raise "add_cookies only takes a Hash or a String"
+    end
+  end
+
+  def to_cookie_string
+    delete_if { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+  end
+end

data/lib/httparty/core_extensions.rb

@@ -0,0 +1,32 @@
+module HTTParty
+  if defined?(::BasicObject)
+    BasicObject = ::BasicObject #:nodoc:
+  else
+    class BasicObject #:nodoc:
+      instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
+    end
+  end
+
+  unless defined?(Net::HTTP::Patch)
+    class Net::HTTP
+      def patch(path, data, initheader = nil, dest = nil, &block) #:nodoc:
+        res = nil
+        request(Patch.new(path, initheader), data) {|r|
+          r.read_body dest, &block
+          res = r
+        }
+        unless @newimpl
+          res.value
+          return res, res.body
+        end
+        res
+      end
+
+      class Patch < Net::HTTPRequest
+        METHOD = 'PATCH'
+        REQUEST_HAS_BODY = true
+        RESPONSE_HAS_BODY = true
+      end
+    end
+  end
+end

data/lib/httparty/exceptions.rb

@@ -0,0 +1,29 @@
+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
+  class UnsupportedFormat < Error; end
+
+  # Exception raised when using a URI scheme other than HTTP or HTTPS
+  class UnsupportedURIScheme < Error; end
+
+  # @abstract Exceptions which inherit from ResponseError contain the Net::HTTP
+  # response object accessible via the {#response} method.
+  class ResponseError < Error
+    # Returns the response of the last request
+    # @return [Net::HTTPResponse] A subclass of Net::HTTPResponse, e.g.
+    # Net::HTTPOK
+    attr_reader :response
+
+    # Instantiate an instance of ResponseError with a Net::HTTPResponse object
+    # @param [Net::HTTPResponse]
+    def initialize(response)
+      @response = response
+    end
+  end
+
+  # Exception that is raised when request has redirected too many times.
+  # Calling {#response} returns the Net:HTTP response object.
+  class RedirectionTooDeep < ResponseError; end
+end

data/lib/httparty/hash_conversions.rb

@@ -0,0 +1,51 @@
+module HTTParty
+  module HashConversions
+    # @return <String> This hash as a query string
+    #
+    # @example
+    #   { name: "Bob",
+    #     address: {
+    #       street: '111 Ruby Ave.',
+    #       city: 'Ruby Central',
+    #       phones: ['111-111-1111', '222-222-2222']
+    #     }
+    #   }.to_params
+    #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+    def self.to_params(hash)
+      params = hash.to_hash.map { |k,v| normalize_param(k,v) }.join
+      params.chop! # trailing &
+      params
+    end
+
+    # @param key<Object> The key for the param.
+    # @param value<Object> The value for the param.
+    #
+    # @return <String> This key value pair as a param
+    #
+    # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones&"
+    def self.normalize_param(key, value)
+      param = ''
+      stack = []
+
+      if value.respond_to?(:to_ary)
+        param << value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+      elsif value.respond_to?(:to_hash)
+        stack << [key,value.to_hash]
+      else
+        param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+      end
+
+      stack.each do |parent, hash|
+        hash.each do |k, v|
+          if v.respond_to?(:to_hash)
+            stack << ["#{parent}[#{k}]", v.to_hash]
+          else
+            param << normalize_param("#{parent}[#{k}]", v)
+          end
+        end
+      end
+
+      param
+    end
+  end
+end

data/lib/httparty/logger/apache_logger.rb

@@ -0,0 +1,22 @@
+module HTTParty
+  module Logger
+    class ApacheLogger #:nodoc:
+      TAG_NAME = HTTParty.name
+
+      attr_accessor :level, :logger, :current_time
+
+      def initialize(logger, level)
+        @logger = logger
+        @level  = level.to_sym
+      end
+
+      def format(request, response)
+        current_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
+        content_length = response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
+        @logger.send @level, "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || "-"} "
+      end
+    end
+  end
+end

data/lib/httparty/logger/curl_logger.rb

@@ -0,0 +1,48 @@
+module HTTParty
+  module Logger
+    class CurlLogger #:nodoc:
+      TAG_NAME = HTTParty.name
+      OUT = ">"
+      IN = "<"
+
+      attr_accessor :level, :logger, :current_time
+
+      def initialize(logger, level)
+        @logger = logger
+        @level  = level.to_sym
+      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
+
+        messages << print(time, OUT, "#{http_method} #{path}")
+
+        if request.options[:headers] && request.options[:headers].size > 0
+          request.options[:headers].each do |k, v|
+            messages << print(time, OUT, "#{k}: #{v}")
+          end
+        end
+
+        messages << print(time, OUT, request.raw_body)
+        messages << print(time, OUT, "")
+        messages << print(time, IN, "HTTP/#{response.http_version} #{response.code}")
+
+        headers = response.respond_to?(:headers) ? response.headers : response
+        response.each_header do |response_header|
+          messages << print(time, IN, "#{response_header.capitalize}: #{headers[response_header]}")
+        end
+
+        messages << print(time, IN, "\n#{response.body}")
+
+        @logger.send @level, messages.join("\n")
+      end
+
+      def print(time, direction, line)
+        "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
+      end
+    end
+  end
+end

data/lib/httparty/logger/logger.rb

@@ -0,0 +1,18 @@
+require 'httparty/logger/apache_logger'
+require 'httparty/logger/curl_logger'
+
+module HTTParty
+  module Logger
+    def self.build(logger, level, formatter)
+      level  ||= :info
+      format ||= :apache
+
+      case formatter
+      when :curl
+        Logger::CurlLogger.new(logger, level)
+      else
+        Logger::ApacheLogger.new(logger, level)
+      end
+    end
+  end
+end