dkastner-httparty 0.9.0

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/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('=')
+        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) }.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,26 @@
+module HTTParty
+  # Exception raised when you attempt to set a non-existant format
+  class UnsupportedFormat < StandardError; end
+
+  # Exception raised when using a URI scheme other than HTTP or HTTPS
+  class UnsupportedURIScheme < StandardError; end
+
+  # @abstract Exceptions which inherit from ResponseError contain the Net::HTTP
+  # response object accessible via the {#response} method.
+  class ResponseError < StandardError
+    # 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.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.is_a?(Array)
+        param << value.map { |element| normalize_param("#{key}[]", element) }.join
+      elsif value.is_a?(Hash)
+        stack << [key,value]
+      else
+        param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+      end
+
+      stack.each do |parent, hash|
+        hash.each do |key, value|
+          if value.is_a?(Hash)
+            stack << ["#{parent}[#{key}]", value]
+          else
+            param << normalize_param("#{parent}[#{key}]", value)
+          end
+        end
+      end
+
+      param
+    end
+  end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -0,0 +1,44 @@
+module HTTParty
+  module ModuleInheritableAttributes #:nodoc:
+    def self.included(base)
+      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]
+        @mattr_inheritable_attrs += args
+        args.each do |arg|
+          module_eval %(class << self; attr_accessor :#{arg} end)
+        end
+        @mattr_inheritable_attrs
+      end
+
+      def inherited(subclass)
+        super
+        @mattr_inheritable_attrs.each do |inheritable_attribute|
+          ivar = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(ivar, instance_variable_get(ivar).clone)
+          if instance_variable_get(ivar).respond_to?(:merge)
+            method = <<-EOM
+              def self.#{inheritable_attribute}
+                #{ivar} = superclass.#{inheritable_attribute}.merge ModuleInheritableAttributes.hash_deep_dup(#{ivar})
+              end
+            EOM
+            subclass.class_eval method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/httparty/net_digest_auth.rb

@@ -0,0 +1,84 @@
+require 'digest/md5'
+require 'net/http'
+
+module Net
+  module HTTPHeader
+    def digest_auth(username, password, response)
+      @header['Authorization'] = DigestAuthenticator.new(username, password,
+          @method, @path, response).authorization_header
+    end
+
+
+    class DigestAuthenticator
+      def initialize(username, password, method, path, response_header)
+        @username = username
+        @password = password
+        @method   = method
+        @path     = path
+        @response = parse(response_header)
+      end
+
+      def authorization_header
+        @cnonce = md5(random)
+        header = [
+          %Q(Digest username="#{@username}"),
+          %Q(realm="#{@response['realm']}"),
+          %Q(nonce="#{@response['nonce']}"),
+          %Q(uri="#{@path}"),
+          %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
+
+    private
+
+      def parse(response_header)
+        response_header['www-authenticate'] =~ /^(\w+) (.*)/
+        params = {}
+        $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        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
+
+      def random
+        "%x" % (Time.now.to_i + rand(65535))
+      end
+
+      def request_digest
+        a = [md5(a1), @response['nonce'], md5(a2)]
+        a.insert(2, "00000001", @cnonce, @response['qop']) if qop_present?
+        md5(a.join(":"))
+      end
+
+      def md5(str)
+        Digest::MD5.hexdigest(str)
+      end
+
+      def a1
+        [@username, @response['realm'], @password].join(":")
+      end
+
+      def a2
+        [@method, @path].join(":")
+      end
+    end
+  end
+end

data/lib/httparty/parser.rb

@@ -0,0 +1,145 @@
+module HTTParty
+  # The default parser used by HTTParty, supports xml, json, html, yaml, and
+  # plain text.
+  #
+  # == Custom Parsers
+  #
+  # If you'd like to do your own custom parsing, subclassing HTTParty::Parser
+  # will make that process much easier. There are a few different ways you can
+  # utilize HTTParty::Parser as a superclass.
+  #
+  # @example Intercept the parsing for all formats
+  #   class SimpleParser < HTTParty::Parser
+  #     def parse
+  #       perform_parsing
+  #     end
+  #   end
+  #
+  # @example Add the atom format and parsing method to the default parser
+  #   class AtomParsingIncluded < HTTParty::Parser
+  #     SupportedFormats.merge!(
+  #       {"application/atom+xml" => :atom}
+  #     )
+  #
+  #     def atom
+  #       perform_atom_parsing
+  #     end
+  #   end
+  #
+  # @example Only support the atom format
+  #   class ParseOnlyAtom < HTTParty::Parser
+  #     SupportedFormats = {"application/atom+xml" => :atom}
+  #
+  #     def atom
+  #       perform_atom_parsing
+  #     end
+  #   end
+  #
+  # @abstract Read the Custom Parsers section for more information.
+  class Parser
+    SupportedFormats = {
+      'text/xml'               => :xml,
+      'application/xml'        => :xml,
+      'application/json'       => :json,
+      'text/json'              => :json,
+      'application/javascript' => :json,
+      'text/javascript'        => :json,
+      'text/html'              => :html,
+      'application/x-yaml'     => :yaml,
+      'text/yaml'              => :yaml,
+      'text/plain'             => :plain
+    }
+
+    # The response body of the request
+    # @return [String]
+    attr_reader :body
+
+    # The intended parsing format for the request
+    # @return [Symbol] e.g. :json
+    attr_reader :format
+
+    # Instantiate the parser and call {#parse}.
+    # @param [String] body the response body
+    # @param [Symbol] format the response format
+    # @return parsed response
+    def self.call(body, format)
+      new(body, format).parse
+    end
+
+    # @return [Hash] the SupportedFormats hash
+    def self.formats
+      const_get(:SupportedFormats)
+    end
+
+    # @param [String] mimetype response MIME type
+    # @return [Symbol]
+    # @return [nil] mime type not supported
+    def self.format_from_mimetype(mimetype)
+      formats[formats.keys.detect {|k| mimetype.include?(k)}]
+    end
+
+    # @return [Array<Symbol>] list of supported formats
+    def self.supported_formats
+      formats.values.uniq
+    end
+
+    # @param [Symbol] format e.g. :json, :xml
+    # @return [Boolean]
+    def self.supports_format?(format)
+      supported_formats.include?(format)
+    end
+
+    def initialize(body, format)
+      @body = body
+      @format = format
+    end
+
+    # @return [Object] the parsed body
+    # @return [nil] when the response body is nil, an empty string, spaces only or "null"
+    def parse
+      return nil if body.nil? || body.strip.empty? || body == "null"
+      if supports_format?
+        parse_supported_format
+      else
+        body
+      end
+    end
+
+    protected
+
+    def xml
+      MultiXml.parse(body)
+    end
+
+    def json
+      # https://github.com/sferik/rails/commit/5e62670131dfa1718eaf21ff8dd3371395a5f1cc
+      if MultiJson.respond_to?(:adapter)
+        MultiJson.load(body)
+      else
+        MultiJson.decode(body)
+      end
+    end
+
+    def yaml
+      YAML.load(body)
+    end
+
+    def html
+      body
+    end
+
+    def plain
+      body
+    end
+
+    def supports_format?
+      self.class.supports_format?(format)
+    end
+
+    def parse_supported_format
+      send(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