alexvollmer-httparty 0.2.6 → 0.3.1

data/lib/httparty/request.rb

@@ -11,8 +11,7 @@ module HTTParty
       self.path = path
       self.options = {
         :limit => o.delete(:no_follow) ? 0 : 5,
-        :default_params => {},
-        :keep_body => false
+        :default_params => {}
       }.merge(o)
     end
 
@@ -21,9 +20,13 @@ module HTTParty
     end
 
     def uri
-      uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
-      uri.query = query_string(uri)
-      uri
+      new_uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
+      
+      if Net::HTTP::Get === http_method and !@redirect
+        new_uri.query = query_string(new_uri)
+      end
+      
+      new_uri
     end
 
     def format
@@ -31,38 +34,47 @@ module HTTParty
     end
 
     def perform
-      validate!
-      handle_response!(get_response(uri))
+      validate
+      setup_raw_request
+      handle_response(get_response)
     end
 
     private
-      def http(uri) #:nodoc:
+      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
       end
 
-      def get_response(uri) #:nodoc:
-        request = http_method.new(uri.request_uri)
+      def configure_basic_auth
+        @raw_request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password])
+      end
+
+      def setup_raw_request
+        @raw_request = http_method.new(uri.request_uri)
 
         if post? && options[:query]
-          request.set_form_data(options[:query])
+          @raw_request.set_form_data(options[:query])
         end
+        
+        @raw_request.body = options[:body].is_a?(Hash) ? options[:body].to_params : options[:body] unless options[:body].blank?
+        @raw_request.initialize_http_header options[:headers]
+        
+        configure_basic_auth if options[:basic_auth]
+      end
 
-        request.body = options[:body].is_a?(Hash) ? options[:body].to_params : options[:body] unless options[:body].blank?
-        request.initialize_http_header options[:headers]
-
-        if options[:basic_auth]
-          request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password])
-        end
+      def perform_actual_request
+        http.request(@raw_request)
+      end
 
-        response = http(uri).request(request)
+      def get_response
+        response = perform_actual_request
         options[:format] ||= format_from_mimetype(response['content-type'])
         response
       end
-
-      def query_string(uri) #:nodoc:
+      
+      def query_string(uri)
         query_string_parts = []
         query_string_parts << uri.query unless uri.query.blank?
 
@@ -75,48 +87,47 @@ module HTTParty
 
         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) #:nodoc:
+      def handle_response(response)
         case response
-        when Net::HTTPSuccess
-          original_resp = parse_response(response.body)
-          final_resp = Response.new(response.body, nil, original_resp)
-          response.each_header { |n,v| final_resp.add_header(n, v) }
-          final_resp
-        when Net::HTTPRedirection
-          options[:limit] -= 1
-          self.path = response['location']
-          perform
-        else
-          response.instance_eval { class << self; attr_accessor :body_parsed; end }
-          begin; response.body_parsed = parse_response(response.body); rescue; end
-          response.error! # raises  exception corresponding to http error Net::XXX
-        end
+          when Net::HTTPRedirection
+            options[:limit] -= 1
+            if options[:limit].to_i <= 0
+              raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep'
+            end
+            self.http_method = Net::HTTP::Get
+            self.path = response['location']
+            @redirect = true
+            perform
+          else
+            parsed_response = parse_response(response.body)
+            Response.new(parsed_response, response.body, response.code, response.to_hash)
+          end
       end
-
-      def parse_response(body) #:nodoc:
+      
+      def parse_response(body)
         return nil if body.nil? or body.empty?
-        response = case format
-                   when :xml
-                     ToHashParser.from_xml(body)
-                   when :json
-                     JSON.parse(body)
-                   else
-                     body
-                   end
-        response
+        case format
+          when :xml
+            HTTParty::Parsers::XML.parse(body)
+          when :json
+            HTTParty::Parsers::JSON.decode(body)
+          when :yaml
+            YAML::load(body)
+          else
+            body
+          end
       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
-      def format_from_mimetype(mimetype) #:nodoc:
+      def format_from_mimetype(mimetype)
         return nil if mimetype.nil?
-        AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
+        AllowedFormats.each { |k, v| return v if mimetype.include?(k) }
       end
-
-      def validate! #:nodoc:
-        raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
+      
+      def validate
         raise ArgumentError, 'only get, post, put and delete 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)
@@ -127,28 +138,4 @@ module HTTParty
         Net::HTTP::Post == http_method
       end
   end
-
-  class Response
-    attr_accessor :original_body, :format, :headers
-
-    def initialize(original_body, format, delegate)
-      self.original_body = original_body
-      self.format = format
-      self.headers = { }
-      @delegate = delegate
-    end
-
-    def add_header(name, value)
-      @headers[name] = value
-    end
-
-    def method_missing(sym, *args)
-      @delegate.send(sym, *args)
-    end
-
-    def pretty_print(pp)
-      @delegate.pretty_print(pp)
-    end
-
-  end
 end

data/lib/httparty/response.rb

@@ -0,0 +1,17 @@
+module HTTParty
+  class Response < BlankSlate #:nodoc:
+    attr_accessor :body, :code, :headers
+    attr_reader :delegate
+
+    def initialize(delegate, body, code, headers={})
+      @delegate = delegate
+      @body = body
+      @code = code
+      @headers = headers
+    end
+
+    def method_missing(name, *args, &block)
+      @delegate.send(name, *args, &block)
+    end
+  end
+end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
-module HTTParty
-  Version = '0.2.6'
+module HTTParty #:nodoc:
+  Version = '0.3.1'
 end

data/lib/httparty.rb

@@ -2,63 +2,135 @@ $:.unshift(File.dirname(__FILE__))
 
 require 'net/http'
 require 'net/https'
-require 'rubygems'
-gem 'json', '>= 1.1.3'
-require 'json'
-
-require 'module_level_inheritable_attributes'
 require 'core_extensions'
+require 'httparty/module_inheritable_attributes'
 
-module HTTParty  
-  AllowedFormats = {:xml => 'text/xml', :json => 'application/json', :html => 'text/html'}
+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
+  } unless defined?(AllowedFormats)
   
   def self.included(base)
     base.extend ClassMethods
-    base.send :include, ModuleLevelInheritableAttributes
+    base.send :include, HTTParty::ModuleInheritableAttributes
     base.send(:mattr_inheritable, :default_options)
     base.instance_variable_set("@default_options", {})
   end
   
   module ClassMethods
-    def default_options
-      @default_options
-    end
-
+    # Allows setting http proxy information to be used
+    #
+    #   class Foo
+    #     include HTTParty
+    #     http_proxy 'http://foo.com', 80
+    #   end
     def http_proxy(addr=nil, port = nil)
       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.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     base_uri 'twitter.com'
+    #   end
     def base_uri(uri=nil)
       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
+    #     include HTTParty
+    #     basic_auth 'username', 'password'
+    #   end
     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.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     default_params :api_key => 'secret', :another => 'foo'
+    #   end
     def default_params(h={})
       raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
       default_options[:default_params] ||= {}
       default_options[:default_params].merge!(h)
     end
-
+    
+    # Allows setting a base uri to be used for each request.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     headers 'Accept' => 'text/html'
+    #   end
     def headers(h={})
       raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
       default_options[:headers] ||= {}
       default_options[:headers].merge!(h)
     end
+
+    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)
+    end
     
+    # Allows setting the format with which to parse.
+    # Must be one of the allowed formats ie: json, xml
+    #
+    #   class Foo
+    #     include HTTParty
+    #     format :json
+    #   end
     def format(f)
-      raise UnsupportedFormat, "Must be one of: #{AllowedFormats.keys.join(', ')}" unless AllowedFormats.key?(f)
+      raise UnsupportedFormat, "Must be one of: #{AllowedFormats.values.join(', ')}" unless AllowedFormats.value?(f)
       default_options[:format] = f
     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, 
+    #   # which gets set as form data on the request.
+    #   Foo.post('http://foo.com/resources', :query => {:bar => 'baz'})
     def post(path, options={})
       perform_request Net::HTTP::Post, path, options
     end
@@ -70,11 +142,25 @@ module HTTParty
     def delete(path, options={})
       perform_request Net::HTTP::Delete, path, options
     end
+    
+    def default_options #:nodoc:
+      @default_options
+    end
 
     private
       def perform_request(http_method, path, options) #:nodoc:
+        process_cookies(options)
         Request.new(http_method, path, default_options.dup.merge(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
+
+        default_options.delete(:cookies)
+        options.delete(:cookies)
+      end
   end
 
   def self.normalize_base_uri(url) #:nodoc:
@@ -87,7 +173,7 @@ module HTTParty
     "http#{'s' if use_ssl}://#{url}"
   end
   
-  class Basement
+  class Basement #:nodoc:
     include HTTParty
   end
   
@@ -108,5 +194,8 @@ module HTTParty
   end
 end
 
+require 'httparty/cookie_hash'
 require 'httparty/exceptions'
-require 'httparty/request'
+require 'httparty/request'
+require 'httparty/response'
+require 'httparty/parsers'

data/spec/fixtures/undefined_method_add_node_for_nil.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entities total="0" results="0" page="1" page-size="25" href="https://s3-sandbox.parature.com/api/v1/5578/5633/Account" />

data/spec/hash_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Hash, "to_xml_attributes" do
+  before do
+    @hash = { :one => "ONE", "two" => "TWO" }
+  end
+
+  it "should turn the hash into xml attributes" do
+    attrs = @hash.to_xml_attributes
+    attrs.should match(/one="ONE"/m)
+    attrs.should match(/two="TWO"/m)
+  end
+
+  it 'should preserve _ in hash keys' do
+    attrs = {
+      :some_long_attribute => "with short value",
+      :crash               => :burn,
+      :merb                => "uses extlib"
+    }.to_xml_attributes
+
+    attrs.should =~ /some_long_attribute="with short value"/
+    attrs.should =~ /merb="uses extlib"/
+    attrs.should =~ /crash="burn"/
+  end
+end
+
+
+describe Hash, 'to_params' do
+  {
+    { "foo" => "bar", "baz" => "bat" } => "foo=bar&baz=bat",
+    { "foo" => [ "bar", "baz" ] } => "foo[]=bar&foo[]=baz",
+    { "foo" => [ {"bar" => "1"}, {"bar" => 2} ] } => "foo[][bar]=1&foo[][bar]=2",
+    { "foo" => { "bar" => [ {"baz" => 1}, {"baz" => "2"}  ] } } => "foo[bar][][baz]=1&foo[bar][][baz]=2",
+    { "foo" => {"1" => "bar", "2" => "baz"} } => "foo[1]=bar&foo[2]=baz"
+  }.each do |hash, params|
+    it "should covert hash: #{hash.inspect} to params: #{params.inspect}" do
+      hash.to_params.split('&').sort.should == params.split('&').sort
+    end
+  end
+
+  it 'should not leave a trailing &' do
+    { :name => 'Bob', :address => { :street => '111 Ruby Ave.', :city => 'Ruby Central', :phones => ['111-111-1111', '222-222-2222'] } }.to_params.should_not match(/&$/)
+  end
+  
+  it 'should URL encode unsafe characters' do
+    {:q => "?&\" +"}.to_params.should == "q=%3F%26%22%20%2B"
+  end
+  
+end

data/spec/httparty/cookie_hash_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+
+describe HTTParty::CookieHash do
+  before(:each) do
+    @cookie_hash = HTTParty::CookieHash.new
+  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)
+    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
+
+  # The regexen are required because Hashes aren't ordered, so a test against
+  # a hardcoded string was randomly failing.
+  describe "#to_cookie_string" do
+    before(:each) do
+      @cookie_hash.add_cookies(:foo => "bar")
+      @cookie_hash.add_cookies(:rofl => "copter")
+      @s = @cookie_hash.to_cookie_string
+    end
+
+    it "should format the key/value pairs, delimited by semi-colons" do
+      @s.should match(/foo=bar/)
+      @s.should match(/rofl=copter/)
+      @s.should match(/^\w+=\w+; \w+=\w+$/)
+    end
+  end
+end

data/spec/httparty/parsers/json_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe HTTParty::Parsers::JSON do
+  TESTS = {
+    %q({"data": "G\u00fcnter"})                   => {"data" => "Günter"},
+    %q({"returnTo":{"\/categories":"\/"}})        => {"returnTo" => {"/categories" => "/"}},
+    %q({returnTo:{"\/categories":"\/"}})          => {"returnTo" => {"/categories" => "/"}},
+    %q({"return\\"To\\":":{"\/categories":"\/"}}) => {"return\"To\":" => {"/categories" => "/"}},
+    %q({"returnTo":{"\/categories":1}})           => {"returnTo" => {"/categories" => 1}},
+    %({"returnTo":[1,"a"]})                       => {"returnTo" => [1, "a"]},
+    %({"returnTo":[1,"\\"a\\",", "b"]})           => {"returnTo" => [1, "\"a\",", "b"]},
+    %({a: "'", "b": "5,000"})                     => {"a" => "'", "b" => "5,000"},
+    %({a: "a's, b's and c's", "b": "5,000"})      => {"a" => "a's, b's and c's", "b" => "5,000"},
+    %({a: "2007-01-01"})                          => {'a' => Date.new(2007, 1, 1)}, 
+    %({a: "2007-01-01 01:12:34 Z"})               => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)}, 
+    # no time zone                                
+    %({a: "2007-01-01 01:12:34"})                 => {'a' => "2007-01-01 01:12:34"}, 
+    %([])    => [],
+    %({})    => {},
+    %(1)     => 1,
+    %("")    => "",
+    %("\\"") => "\"",
+    %(null)  => nil,
+    %(true)  => true,
+    %(false) => false,
+    %q("http:\/\/test.host\/posts\/1") => "http://test.host/posts/1"
+  }
+  
+  TESTS.each do |json, expected|
+    it "should decode json (#{json})" do
+      lambda {
+        HTTParty::Parsers::JSON.decode(json).should == expected
+      }.should_not raise_error
+    end
+  end
+  
+  it "should raise error for failed decoding" do
+    lambda {
+      HTTParty::Parsers::JSON.decode(%({: 1}))
+    }.should raise_error(HTTParty::Parsers::JSON::ParseError)
+  end
+end