httparty 0.4.5 → 0.5.0

data/lib/httparty/core_extensions.rb

@@ -1,7 +1,13 @@
-class BasicObject #:nodoc:
-  instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
-end unless defined?(BasicObject)
- 
+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:

data/lib/httparty/exceptions.rb

@@ -1,7 +1,10 @@
 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
+
   # Exception that is raised when request has redirected too many times
   class RedirectionTooDeep < StandardError; end
-end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -16,10 +16,10 @@ module HTTParty
 
       def inherited(subclass)
         @mattr_inheritable_attrs.each do |inheritable_attribute|
-          instance_var = "@#{inheritable_attribute}" 
-          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+          instance_var = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var).clone)
         end
       end
     end
   end
-end
+end

data/lib/httparty/parser.rb

@@ -0,0 +1,140 @@
+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
+
+    # @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

@@ -2,38 +2,57 @@ require 'uri'
 
 module HTTParty
   class Request #:nodoc:
-    SupportedHTTPMethods = [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete]
-    
+    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
-    
+
     def initialize(http_method, path, o={})
       self.http_method = http_method
       self.path = path
       self.options = {
-        :limit => o.delete(:no_follow) ? 0 : 5, 
+        :limit => o.delete(:no_follow) ? 0 : 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]
     end
-    
+
+    def parser
+      options[:parser]
+    end
+
+
     def perform
       validate
       setup_raw_request
@@ -44,23 +63,36 @@ module HTTParty
 
       def http
         http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
-        http.use_ssl = (uri.port == 443)
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.use_ssl = ssl_implied?
+
         if options[:timeout] && options[:timeout].is_a?(Integer)
           http.open_timeout = options[:timeout]
           http.read_timeout = options[:timeout]
         end
+
+        if options[:pem] && http.use_ssl?
+          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+          http.key = OpenSSL::PKey::RSA.new(options[:pem])
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        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 username
         options[:basic_auth][:username]
       end
-      
+
       def password
         options[:basic_auth][:password]
       end
@@ -81,7 +113,7 @@ module HTTParty
         options[:format] ||= format_from_mimetype(response['content-type'])
         response
       end
-      
+
       def query_string(uri)
         query_string_parts = []
         query_string_parts << uri.query unless uri.query.nil?
@@ -92,10 +124,10 @@ module HTTParty
           query_string_parts << options[:default_params].to_params unless options[:default_params].nil?
           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(response)
         case response
@@ -107,43 +139,14 @@ module HTTParty
             capture_cookies(response)
             perform
           else
-            parsed_response = parse_response(response.body)
-            Response.new(parsed_response, response.body, response.code, response.message, response.to_hash)
+            Response.new(parse_response(response.body), response.body, response.code, response.message, response.to_hash)
           end
       end
-      
-      # HTTParty.const_get((self.format.to_s || 'text').capitalize)
+
       def parse_response(body)
-        return nil if body.nil? or body.empty?
-        if options[:parser].blank?
-          case format
-            when :xml
-              Crack::XML.parse(body)
-            when :json
-              Crack::JSON.parse(body)
-            when :yaml
-              YAML::load(body)
-            else
-              body
-            end
-        else
-          if options[:parser].is_a?(Proc)
-            options[:parser].call(body)
-          else
-            body
-          end
-        end
-      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
+        parser.call(body, format)
       end
-      
+
       def capture_cookies(response)
         return unless response['Set-Cookie']
         cookies_hash = HTTParty::CookieHash.new()
@@ -152,24 +155,27 @@ module HTTParty
         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 AllowedFormats hash
+
+      # 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)
-        return nil if mimetype.nil?
-        AllowedFormats.each { |k, v| return v if mimetype.include?(k) }
+        if mimetype && parser.respond_to?(:format_from_mimetype)
+          parser.format_from_mimetype(mimetype)
+        end
       end
-      
+
       def validate
         raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
-        raise ArgumentError, 'only get, post, put and delete methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        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, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_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
+

data/lib/httparty/response.rb

@@ -1,5 +1,5 @@
 module HTTParty
-  class Response < BasicObject #:nodoc:
+  class Response < HTTParty::BasicObject #:nodoc:
     attr_accessor :body, :code, :message, :headers
     attr_reader :delegate
 

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty #:nodoc:
-  Version = '0.4.4'
+  Version = '0.5.0'
 end

data/spec/httparty/parser_spec.rb

@@ -0,0 +1,154 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+class CustomParser < HTTParty::Parser; end
+
+describe HTTParty::Parser do
+  describe ".SupportedFormats" do
+    it "returns a hash" do
+      HTTParty::Parser::SupportedFormats.should be_instance_of(Hash)
+    end
+  end
+
+  describe ".call" do
+    it "generates an HTTParty::Parser instance with the given body and format" do
+      HTTParty::Parser.should_receive(:new).with('body', :plain).and_return(stub(:parse => nil))
+      HTTParty::Parser.call('body', :plain)
+    end
+
+    it "calls #parse on the parser" do
+      parser = mock('Parser')
+      parser.should_receive(:parse)
+      HTTParty::Parser.stub(:new => parser)
+      parser = HTTParty::Parser.call('body', :plain)
+    end
+  end
+
+  describe ".formats" do
+    it "returns the SupportedFormats constant" do
+      HTTParty::Parser.formats.should == HTTParty::Parser::SupportedFormats
+    end
+
+    it "returns the SupportedFormats constant for subclasses" do
+      class MyParser < HTTParty::Parser
+        SupportedFormats = {"application/atom+xml" => :atom}
+      end
+      MyParser.formats.should == {"application/atom+xml" => :atom}
+    end
+  end
+
+  describe ".format_from_mimetype" do
+    it "returns a symbol representing the format mimetype" do
+      HTTParty::Parser.format_from_mimetype("text/plain").should == :plain
+    end
+
+    it "returns nil when the mimetype is not supported" do
+      HTTParty::Parser.format_from_mimetype("application/atom+xml").should be_nil
+    end
+  end
+
+  describe ".supported_formats" do
+    it "returns a unique set of supported formats represented by symbols" do
+      HTTParty::Parser.supported_formats.should == HTTParty::Parser::SupportedFormats.values.uniq
+    end
+  end
+
+  describe ".supports_format?" do
+    it "returns true for a supported format" do
+      HTTParty::Parser.stub(:supported_formats => [:json])
+      HTTParty::Parser.supports_format?(:json).should be_true
+    end
+
+    it "returns false for an unsupported format" do
+      HTTParty::Parser.stub(:supported_formats => [])
+      HTTParty::Parser.supports_format?(:json).should be_false
+    end
+  end
+
+  describe "#parse" do
+    before do
+      @parser = HTTParty::Parser.new('body', :json)
+    end
+
+    it "attempts to parse supported formats" do
+      @parser.stub(:supports_format? => true)
+      @parser.should_receive(:parse_supported_format)
+      @parser.parse
+    end
+
+    it "returns the unparsed body when the format is unsupported" do
+      @parser.stub(:supports_format? => false)
+      @parser.parse.should == @parser.body
+    end
+
+    it "returns nil for an empty body" do
+      @parser.stub(:body => '')
+      @parser.parse.should be_nil
+    end
+
+    it "returns nil for a nil body" do
+      @parser.stub(:body => nil)
+      @parser.parse.should be_nil
+    end
+  end
+
+  describe "#supports_format?" do
+    it "utilizes the class method to determine if the format is supported" do
+      HTTParty::Parser.should_receive(:supports_format?).with(:json)
+      parser = HTTParty::Parser.new('body', :json)
+      parser.send(:supports_format?)
+    end
+  end
+
+  describe "#parse_supported_format" do
+    it "calls the parser for the given format" do
+      parser = HTTParty::Parser.new('body', :json)
+      parser.should_receive(:json)
+      parser.send(:parse_supported_format)
+    end
+
+    context "when a parsing method does not exist for the given format" do
+      it "raises an exception" do
+        parser = HTTParty::Parser.new('body', :atom)
+        expect do
+          parser.send(:parse_supported_format)
+        end.to raise_error(NotImplementedError, "HTTParty::Parser has not implemented a parsing method for the :atom format.")
+      end
+
+      it "raises a useful exception message for subclasses" do
+        parser = CustomParser.new('body', :atom)
+        expect do
+          parser.send(:parse_supported_format)
+        end.to raise_error(NotImplementedError, "CustomParser has not implemented a parsing method for the :atom format.")
+      end
+    end
+  end
+
+  context "parsers" do
+    subject do
+      HTTParty::Parser.new('body', nil)
+    end
+
+    it "parses xml with Crack" do
+      Crack::XML.should_receive(:parse).with('body')
+      subject.send(:xml)
+    end
+
+    it "parses json with Crack" do
+      Crack::JSON.should_receive(:parse).with('body')
+      subject.send(:json)
+    end
+
+    it "parses yaml" do
+      YAML.should_receive(:load).with('body')
+      subject.send(:yaml)
+    end
+
+    it "parses html by simply returning the body" do
+      subject.send(:html).should == 'body'
+    end
+
+    it "parses plain text by simply returning the body" do
+      subject.send(:plain).should == 'body'
+    end
+  end
+end