httparty 0.4.3 → 0.5.0

data/lib/httparty.rb

@@ -1,35 +1,41 @@
-$:.unshift(File.dirname(__FILE__))
-
+require 'pathname'
 require 'net/http'
 require 'net/https'
-require 'httparty/module_inheritable_attributes'
 require 'rubygems'
-gem 'crack'
+gem 'crack', '>= 0.1.1'
 require 'crack'
 
+dir = Pathname(__FILE__).dirname.expand_path
+
+require dir + 'httparty/module_inheritable_attributes'
+require dir + 'httparty/cookie_hash'
+
 module HTTParty
-  
-  AllowedFormats = {
-    '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
-  } unless defined?(AllowedFormats)
-  
+  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(:mattr_inheritable, :default_options)
+    base.send(:mattr_inheritable, :default_cookies)
     base.instance_variable_set("@default_options", {})
+    base.instance_variable_set("@default_cookies", CookieHash.new)
   end
-  
+
   module ClassMethods
+    extend AllowedFormatsDeprecation
+
     # Allows setting http proxy information to be used
     #
     #   class Foo
@@ -40,7 +46,7 @@ module HTTParty
       default_options[:http_proxyaddr] = addr
       default_options[:http_proxyport] = port
     end
-    
+
     # Allows setting a base uri to be used for each request.
     # Will normalize uri to include http, etc.
     #
@@ -52,7 +58,7 @@ module HTTParty
       return default_options[:base_uri] unless uri
       default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
     end
-    
+
     # Allows setting basic authentication username and password.
     #
     #   class Foo
@@ -62,7 +68,7 @@ module HTTParty
     def basic_auth(u, p)
       default_options[:basic_auth] = {:username => u, :password => p}
     end
-    
+
     # Allows setting default parameters to be appended to each request.
     # Great for api keys and such.
     #
@@ -75,7 +81,7 @@ module HTTParty
       default_options[:default_params] ||= {}
       default_options[:default_params].merge!(h)
     end
-    
+
     # Allows setting a base uri to be used for each request.
     #
     #   class Foo
@@ -90,10 +96,9 @@ module HTTParty
 
     def cookies(h={})
       raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
-      default_options[:cookies] ||= CookieHash.new
-      default_options[:cookies].add_cookies(h)
+      default_cookies.add_cookies(h)
     end
-    
+
     # Allows setting the format with which to parse.
     # Must be one of the allowed formats ie: json, xml
     #
@@ -101,37 +106,67 @@ module HTTParty
     #     include HTTParty
     #     format :json
     #   end
-    def format(f)
-      raise UnsupportedFormat, "Must be one of: #{AllowedFormats.values.uniq.join(', ')}" unless AllowedFormats.value?(f)
-      default_options[:format] = f
+    def format(f = nil)
+      if f.nil?
+        default_options[:format]
+      else
+        parser(Parser) if parser.nil?
+        default_options[:format] = f
+        validate_format
+      end
+    end
+
+    # Allows setting a PEM file to be used
+    #
+    #   class Foo
+    #     include HTTParty
+    #     pem File.read('/home/user/my.pem')
+    #   end
+    def pem(pem_contents)
+      default_options[:pem] = pem_contents
+    end
+
+    # Allows setting a custom parser for the response.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     parser Proc.new {|data| ...}
+    #   end
+    def parser(customer_parser = nil)
+      if customer_parser.nil?
+        default_options[:parser]
+      else
+        default_options[:parser] = customer_parser
+        validate_format
+      end
     end
-    
+
     # Allows making a get request to a url.
     #
     #   class Foo
     #     include HTTParty
     #   end
-    #   
+    #
     #   # Simple get with full url
     #   Foo.get('http://foo.com/resource.json')
-    #   
+    #
     #   # 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={})
       perform_request Net::HTTP::Get, path, options
     end
-    
+
     # Allows making a post request to a url.
     #
     #   class Foo
     #     include HTTParty
     #   end
-    #   
+    #
     #   # Simple post with full url and setting the body
     #   Foo.post('http://foo.com/resources', :body => {:bar => 'baz'})
     #
-    #   # Simple post with full url using :query option, 
+    #   # 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={})
@@ -145,24 +180,37 @@ module HTTParty
     def delete(path, options={})
       perform_request Net::HTTP::Delete, path, options
     end
-    
+
+    def head(path, options={})
+      perform_request Net::HTTP::Head, path, options
+    end
+
+    def options(path, options={})
+      perform_request Net::HTTP::Options, path, options
+    end
+
     def default_options #:nodoc:
       @default_options
     end
 
     private
+
       def perform_request(http_method, path, options) #:nodoc:
+        options = default_options.dup.merge(options)
         process_cookies(options)
-        Request.new(http_method, path, default_options.dup.merge(options)).perform
+        Request.new(http_method, path, options).perform
       end
 
       def process_cookies(options) #:nodoc:
-        return unless options[:cookies] || default_options[:cookies]
-        options[:headers] ||= {}
-        options[:headers]["cookie"] = cookies(options[:cookies] || {}).to_cookie_string
+        return unless options[:cookies] || default_cookies.any?
+        options[:headers] ||= headers.dup
+        options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
+      end
 
-        default_options.delete(:cookies)
-        options.delete(:cookies)
+      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
       end
   end
 
@@ -170,21 +218,21 @@ module HTTParty
     normalized_url = url.dup
     use_ssl = (normalized_url =~ /^https/) || normalized_url.include?(':443')
     ends_with_slash = normalized_url =~ /\/$/
-    
+
     normalized_url.chop! if ends_with_slash
     normalized_url.gsub!(/^https?:\/\//i, '')
-    
+
     "http#{'s' if use_ssl}://#{normalized_url}"
   end
-  
+
   class Basement #:nodoc:
     include HTTParty
   end
-  
+
   def self.get(*args)
     Basement.get(*args)
   end
-  
+
   def self.post(*args)
     Basement.post(*args)
   end
@@ -196,10 +244,20 @@ module HTTParty
   def self.delete(*args)
     Basement.delete(*args)
   end
+
+  def self.head(*args)
+    Basement.head(*args)
+  end
+
+  def self.options(*args)
+    Basement.options(*args)
+  end
+
 end
 
-require 'httparty/cookie_hash'
-require 'httparty/core_extensions'
-require 'httparty/exceptions'
-require 'httparty/request'
-require 'httparty/response'
+require dir + 'httparty/core_extensions'
+require dir + 'httparty/exceptions'
+require dir + 'httparty/parser'
+require dir + 'httparty/request'
+require dir + 'httparty/response'
+

data/spec/httparty/cookie_hash_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '../spec_helper')
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
 describe HTTParty::CookieHash do
   before(:each) do
@@ -6,17 +6,44 @@ describe HTTParty::CookieHash do
   end
 
   describe "#add_cookies" do
-    it "should add new key/value pairs to the hash" do
-      @cookie_hash.add_cookies(:foo => "bar")
-      @cookie_hash.add_cookies(:rofl => "copter")
-      @cookie_hash.length.should eql(2)
+    
+    describe "with a hash" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies(:foo => "bar")
+        @cookie_hash.add_cookies(:rofl => "copter")
+        @cookie_hash.length.should eql(2)
+      end
+
+      it "should overwrite any existing key" do
+        @cookie_hash.add_cookies(:foo => "bar")
+        @cookie_hash.add_cookies(:foo => "copter")
+        @cookie_hash.length.should eql(1)
+        @cookie_hash[:foo].should eql("copter")
+      end
     end
 
-    it "should overwrite any existing key" do
-      @cookie_hash.add_cookies(:foo => "bar")
-      @cookie_hash.add_cookies(:foo => "copter")
-      @cookie_hash.length.should eql(1)
-      @cookie_hash[:foo].should eql("copter")
+    describe "with a string" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies("first=one; second=two; third")
+        @cookie_hash[:first].should == 'one'
+        @cookie_hash[:second].should == 'two'
+        @cookie_hash[:third].should == nil
+      end
+      
+      it "should overwrite any existing key" do
+        @cookie_hash[:foo] = 'bar'
+        @cookie_hash.add_cookies("foo=tar")
+        @cookie_hash.length.should eql(1)
+        @cookie_hash[:foo].should eql("tar")
+      end
+    end
+    
+    describe 'with other class' do
+      it "should error" do
+        lambda {
+          @cookie_hash.add_cookies(Array.new)
+        }.should raise_error
+      end
     end
   end
 
@@ -34,5 +61,11 @@ describe HTTParty::CookieHash do
       @s.should match(/rofl=copter/)
       @s.should match(/^\w+=\w+; \w+=\w+$/)
     end
+    
+    it "should not include client side only cookies" do
+      @cookie_hash.add_cookies(:path => "/")
+      @s = @cookie_hash.to_cookie_string
+      @s.should_not match(/path=\//)
+    end
   end
 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