dnclabs-httparty 0.6.1.2010090201

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,31 @@
+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
+end
+
+# 1.8.6 has mistyping of transitive in if statement
+require "rexml/document"
+module REXML #:nodoc:
+  class Document < Element #:nodoc:
+    def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
+      if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+        output = Output.new( output, xml_decl.encoding )
+      end
+      formatter = if indent > -1
+          if transitive
+            REXML::Formatters::Transitive.new( indent, ie_hack )
+          else
+            REXML::Formatters::Pretty.new( indent, ie_hack )
+          end
+        else
+          REXML::Formatters::Default.new( ie_hack )
+        end
+      formatter.write( self, output )
+    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/module_inheritable_attributes.rb

@@ -0,0 +1,34 @@
+module HTTParty
+  module ModuleInheritableAttributes #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    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 #{ivar}
+              end
+            EOM
+            subclass.class_eval method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/httparty/net_digest_auth.rb

@@ -0,0 +1,35 @@
+require 'digest/md5'
+require 'net/http'
+
+module Net
+  module HTTPHeader
+    def digest_auth(user, password, response)
+      response['www-authenticate'] =~ /^(\w+) (.*)/
+
+      params = {}
+      $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+      params.merge!("cnonce" => Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535))))
+
+      a_1 = Digest::MD5.hexdigest("#{user}:#{params['realm']}:#{password}")
+      a_2 = Digest::MD5.hexdigest("#{@method}:#{@path}")
+
+      request_digest = Digest::MD5.hexdigest(
+        [a_1, params['nonce'], "0", params['cnonce'], params['qop'], a_2].join(":")
+      )
+
+      header = [
+        %Q(Digest username="#{user}"),
+        %Q(realm="#{params['realm']}"),
+        %Q(qop="#{params['qop']}"),
+        %Q(uri="#{@path}"),
+        %Q(nonce="#{params['nonce']}"),
+        %Q(nc="0"),
+        %Q(cnonce="#{params['cnonce']}"),
+        %Q(opaque="#{params['opaque']}"),
+        %Q(response="#{request_digest}")
+      ]
+
+      @header['Authorization'] = header
+    end
+  end
+end

data/lib/httparty/parser.rb

@@ -0,0 +1,141 @@
+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
+    private_class_method :new
+
+    # @return [Object] the parsed body
+    # @return [nil] when the response body is nil or an empty string
+    def parse
+      return nil if body.nil? || body.empty?
+      if supports_format?
+        parse_supported_format
+      else
+        body
+      end
+    end
+
+    protected
+
+    def xml
+      Crack::XML.parse(body)
+    end
+
+    def json
+      Crack::JSON.parse(body)
+    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
+      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format."
+    end
+  end
+end

data/lib/httparty/request.rb

@@ -0,0 +1,231 @@
+module HTTParty
+  class Request #:nodoc:
+    SupportedHTTPMethods = [
+      Net::HTTP::Get,
+      Net::HTTP::Post,
+      Net::HTTP::Put,
+      Net::HTTP::Delete,
+      Net::HTTP::Head,
+      Net::HTTP::Options
+    ]
+
+    SupportedURISchemes  = [URI::HTTP, URI::HTTPS]
+
+    attr_accessor :http_method, :path, :options, :last_response, :redirect
+
+    def initialize(http_method, path, o={})
+      self.http_method = http_method
+      self.path = path
+      self.options = {
+        :limit => o.delete(:no_follow) ? 1 : 5,
+        :default_params => {},
+        :parser => Parser
+      }.merge(o)
+    end
+
+    def path=(uri)
+      @path = URI.parse(uri)
+    end
+
+    def uri
+      new_uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
+
+      # avoid double query string on redirects [#12]
+      unless redirect
+        new_uri.query = query_string(new_uri)
+      end
+
+      unless SupportedURISchemes.include? new_uri.class
+        raise UnsupportedURIScheme, "'#{new_uri}' Must be HTTP or HTTPS"
+      end
+
+      new_uri
+    end
+
+    def format
+      options[:format] || (format_from_mimetype(last_response['content-type']) if last_response)
+    end
+
+    def parser
+      options[:parser]
+    end
+
+    def perform
+      validate
+      setup_raw_request
+      get_response
+      handle_response
+    end
+
+    private
+
+    def attach_ssl_certificates(http)
+      if http.use_ssl?
+        # Client certificate authentication
+        if options[:pem]
+          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+          http.key = OpenSSL::PKey::RSA.new(options[:pem])
+          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])
+      http.use_ssl = ssl_implied?
+
+      if options[:timeout] && options[:timeout].is_a?(Integer)
+        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)
+    end
+
+    def body
+      options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+    end
+
+    def credentials
+      options[:basic_auth] || options[:digest_auth]
+    end
+
+    def username
+      credentials[:username]
+    end
+
+    def password
+      credentials[:password]
+    end
+
+    def setup_raw_request
+      @raw_request = http_method.new(uri.request_uri)
+      @raw_request.body = body if body
+      @raw_request.initialize_http_header(options[:headers])
+      @raw_request.basic_auth(username, password) if options[:basic_auth]
+      AuthHMAC.sign!(@raw_request, options[:hmac][:id], options[:hmac][:secret]) if options[:hmac]
+      setup_digest_auth if options[:digest_auth]
+    end
+
+    def setup_digest_auth
+      res = http.head(uri.request_uri, options[:headers])
+      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
+        @raw_request.digest_auth(username, password, res)
+      end
+    end
+
+    def perform_actual_request
+      http.request(@raw_request)
+    end
+
+    def get_response
+      self.last_response = perform_actual_request
+    end
+
+    def query_string(uri)
+      query_string_parts = []
+      query_string_parts << uri.query unless uri.query.nil?
+
+      if options[:query].is_a?(Hash)
+        query_string_parts << options[:default_params].merge(options[:query]).to_params
+      else
+        query_string_parts << options[:default_params].to_params unless options[:default_params].empty?
+        query_string_parts << options[:query] unless options[:query].nil?
+      end
+
+      query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+    end
+
+    # Raises exception Net::XXX (http error code) if an http error occured
+    def handle_response
+      handle_deflation
+      case last_response
+      when Net::HTTPMultipleChoice, # 300
+        Net::HTTPMovedPermanently, # 301
+        Net::HTTPFound, # 302
+        Net::HTTPSeeOther, # 303
+        Net::HTTPUseProxy, # 305
+        Net::HTTPTemporaryRedirect
+        if last_response.key?('location')
+          options[:limit] -= 1
+          self.path = last_response['location']
+          self.redirect = true
+          self.http_method = Net::HTTP::Get unless options[:maintain_method_across_redirects]
+          capture_cookies(last_response)
+          perform
+        else
+          last_response
+        end
+      else
+        Response.new(last_response, parse_response(last_response.body))
+      end
+    end
+
+    # Inspired by Ruby 1.9
+    def handle_deflation
+      case last_response["content-encoding"]
+      when "gzip"
+        body_io = StringIO.new(last_response.body)
+        last_response.body.replace Zlib::GzipReader.new(body_io).read
+      when "deflate"
+        last_response.body.replace Zlib::Inflate.inflate(last_response.body)
+      end
+    end
+
+    def parse_response(body)
+      parser.call(body, format)
+    end
+
+    def capture_cookies(response)
+      return unless response['Set-Cookie']
+      cookies_hash = HTTParty::CookieHash.new()
+      cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
+      cookies_hash.add_cookies(response['Set-Cookie'])
+      options[:headers] ||= {}
+      options[:headers]['Cookie'] = cookies_hash.to_cookie_string
+    end
+
+    # Uses the HTTP Content-Type header to determine the format of the
+    # response It compares the MIME type returned to the types stored in the
+    # SupportedFormats hash
+    def format_from_mimetype(mimetype)
+      if mimetype && parser.respond_to?(:format_from_mimetype)
+        parser.format_from_mimetype(mimetype)
+      end
+    end
+
+      def validate
+        raise HTTParty::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
+        raise ArgumentError, 'only get, post, put, delete, head, and options methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, 'only one authentication method, :basic_auth or :digest_auth may be used at a time' if options[:basic_auth] && options[:digest_auth]
+        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
+        raise ArgumentError, ':digest_auth must be a hash' if options[:digest_auth] && !options[:digest_auth].is_a?(Hash)
+        raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].is_a?(Hash)
+      end
+
+    def post?
+      Net::HTTP::Post == http_method
+    end
+  end
+end