jnunemaker-httparty 0.2.6 → 0.2.7

data/History

@@ -1,3 +1,12 @@
+== 0.2.7 2009-01-28
+* 2 minor fixes, 2 minor enhancements, 2 major enhancements
+  * fixed undefined method add_node for nil class error that occasionally happened (juliocesar)
+  * Handle nil or unexpected values better when typecasting. (Brian Landau)
+  * More robust handling of mime types (Alex Vollmer)
+  * Fixed support for specifying headers and added support for basic auth to CLI. (Alex Vollmer)
+  * Added first class response object that includes original body and status code (Alex Vollmer)
+  * Now parsing all response types as some non-200 responses provide important information, this means no more exception raising (Alex Vollmer)
+
 == 0.2.6 2009-01-05
 * 1 minor bug fix
   * added explicit require of time as Time#parse failed outside of rails (willcodeforfoo)

data/Manifest

@@ -11,6 +11,7 @@ httparty.gemspec
 lib/core_extensions.rb
 lib/httparty/exceptions.rb
 lib/httparty/request.rb
+lib/httparty/response.rb
 lib/httparty/version.rb
 lib/httparty.rb
 lib/module_level_inheritable_attributes.rb
@@ -21,9 +22,11 @@ README
 setup.rb
 spec/as_buggery_spec.rb
 spec/fixtures/delicious.xml
+spec/fixtures/empty.xml
 spec/fixtures/google.html
 spec/fixtures/twitter.json
 spec/fixtures/twitter.xml
+spec/fixtures/undefined_method_add_node_for_nil.xml
 spec/httparty/request_spec.rb
 spec/httparty_spec.rb
 spec/spec.opts

data/bin/httparty

@@ -10,26 +10,30 @@ require "httparty"
 opts = {
   :action => :get,
   :headers => {},
-  :keep_body => true,
-  :verbose => false,
-  :pretty_print => false
+  :verbose => false
 }
 
+def die(msg)
+  STDERR.puts(msg)
+  exit 1
+end
+
 OptionParser.new do |o|
   o.banner = "USAGE: #{$0} [options] [url]"
+  
   o.on("-f",
        "--format [FORMAT]",
-       "Body format: plain, json or xml") do |f|
-    opts[:format] = f.downcase.to_sym
-  end
-  o.on("-r", "--ruby", "Dump output in Ruby pretty-print format") do |r|
-    opts[:pretty_print] = true
+       "Output format to use instead of pretty-print ruby: " +
+       "plain, json or xml") do |f|
+    opts[:output_format] = f.downcase.to_sym
   end
+  
   o.on("-a",
        "--action [ACTION]",
        "HTTP action: get (default), post, put or delete") do |a|
     opts[:action] = a.downcase.to_sym
   end
+  
   o.on("-d",
        "--data [BODY]",
        "Data to put in request body (prefix with '@' for file)") do |d|
@@ -39,13 +43,23 @@ OptionParser.new do |o|
       opts[:data] = d
     end
   end
+  
   o.on("-H", "--header [NAME=VALUE]", "Additional HTTP headers in NAME=VALUE form") do |h|
-    name, value = h.split('=')
-    opts[:headers][name] = value
+    die "Invalid header specification, should be Name:Value" unless h =~ /.+:.+/
+    name, value = h.split(':')
+    opts[:headers][name.strip] = value.strip
   end
+  
   o.on("-v", "--verbose", "If set, print verbose output") do |v|
     opts[:verbose] = true
   end
+  
+  o.on("-u", "--user [CREDS]", "Use basic authentication. Value should be user:password") do |u|
+    die "Invalid credentials format. Must be user:password" unless u =~ /.+:.+/
+    user, password = u.split(':')
+    opts[:basic_auth] = { :username => user, :password => password }
+  end
+  
   o.on("-h", "--help", "Show help documentation") do |h|
     puts o
     exit
@@ -76,28 +90,25 @@ module REXML
           REXML::Formatters::Default.new( ie_hack )
         end
       formatter.write( self, output )
-		end
+    end
   end
 end
 
-if opts[:pretty_print] || opts[:format].nil?
-  pp HTTParty.send(opts[:action], ARGV.first, opts)
+if opts[:output_format].nil?
+  response = HTTParty.send(opts[:action], ARGV.first, opts)
+  puts "Status: #{response.code}"
+  pp response
 else
-  print_format = opts[:format]
-  opts.merge!(:format => :plain) if opts[:format]
+  print_format = opts[:output_format]
   response = HTTParty.send(opts[:action], ARGV.first, opts)
-
-  if print_format.nil?
-    pp response
+  puts "Status: #{response.code}"
+  case opts[:output_format]
+  when :json
+    puts JSON.pretty_generate(response)
+  when :xml
+    REXML::Document.new(response.body).write(STDOUT, 2)
+    puts
   else
-    case print_format
-    when :json
-      puts JSON.pretty_generate(JSON.parse(response))
-    when :xml
-      REXML::Document.new(response).write(STDOUT, 2)
-      puts
-    else
-      puts response
-    end
+    puts response
   end
 end

data/httparty.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{httparty}
-  s.version = "0.2.6"
+  s.version = "0.2.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2009-01-05}
+  s.date = %q{2009-01-28}
   s.default_executable = %q{httparty}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.email = %q{nunemaker@gmail.com}

data/lib/core_extensions.rb

@@ -115,10 +115,10 @@ class REXMLUtilityNode
   self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
   self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
   self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
-  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
+  self.typecasts["decimal"]       = lambda{|v| v.nil? ? nil : BigDecimal(v.to_s)}
   self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
   self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
-  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
+  self.typecasts["symbol"]        = lambda{|v| v.nil? ? nil : v.to_sym}
   self.typecasts["string"]        = lambda{|v| v.to_s}
   self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
   self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
@@ -280,7 +280,7 @@ class ToHashParser
           stack.last.add_node(temp)
         end
       when :text, :cdata
-        stack.last.add_node(event[1]) unless event[1].strip.length == 0
+        stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
       end
     end
     stack.pop.to_hash

data/lib/httparty/request.rb

@@ -20,9 +20,9 @@ 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
+      new_uri.query = query_string(new_uri)
+      new_uri
     end
     
     def format
@@ -31,32 +31,41 @@ module HTTParty
     
     def perform
       validate!
-      handle_response!(get_response(uri))
+      setup_raw_request
+      handle_response!(get_response)
     end
 
     private
-      def http(uri) #:nodoc:
+      def http #:nodoc:
         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
         
-        request.body = options[:body].is_a?(Hash) ? options[:body].to_params : options[:body] unless options[:body].blank?
-        request.initialize_http_header options[:headers]
+        @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]
         
-        if options[:basic_auth]
-          request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password])
-        end
-        
-        response = http(uri).request(request)
+        configure_basic_auth if options[:basic_auth]
+      end
+
+      def perform_actual_request
+        http.request(@raw_request)
+      end
+
+      def get_response #:nodoc:
+        response = perform_actual_request
         options[:format] ||= format_from_mimetype(response['content-type'])
         response
       end
@@ -78,36 +87,33 @@ module HTTParty
       # Raises exception Net::XXX (http error code) if an http error occured
       def handle_response!(response) #:nodoc:
         case response
-        when Net::HTTPSuccess
-          parse_response(response.body)
-        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
+            self.path = response['location']
+            perform
+          else
+            parsed_response = parse_response(response.body)
+            Response.new(parsed_response, response.body, response.code)
+          end
       end
       
       def parse_response(body) #:nodoc:
         return nil if body.nil? or body.empty?
         case format
-        when :xml
-          ToHashParser.from_xml(body)
-        when :json
-          JSON.parse(body)
-        else
-          body
-        end
+          when :xml
+            ToHashParser.from_xml(body)
+          when :json
+            JSON.parse(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:
         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:

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  Version = '0.2.6'
+  Version = '0.2.7'
 end

data/lib/httparty.rb

@@ -9,8 +9,17 @@ require 'json'
 require 'module_level_inheritable_attributes'
 require 'core_extensions'
 
-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
+  } unless defined?(AllowedFormats)
   
   def self.included(base)
     base.extend ClassMethods
@@ -51,7 +60,7 @@ module HTTParty
     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
     
@@ -109,4 +118,5 @@ module HTTParty
 end
 
 require 'httparty/exceptions'
-require 'httparty/request'
+require 'httparty/request'
+require 'httparty/response'

data/spec/httparty/request_spec.rb

@@ -13,11 +13,57 @@ describe HTTParty::Request do
 
   describe 'http' do
     it "should use ssl for port 443" do
-      @request.send(:http, URI.parse('https://api.foo.com/v1:443')).use_ssl?.should == true
+      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443')
+      request.send(:http).use_ssl?.should == true
     end
     
     it 'should not use ssl for port 80' do
-      @request.send(:http, URI.parse('http://foobar.com')).use_ssl?.should == false
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://foobar.com')
+      @request.send(:http).use_ssl?.should == false
+    end
+
+    it "should use basic auth when configured" do
+      @request.options[:basic_auth] = {:username => 'foobar', :password => 'secret'}
+      @request.send(:setup_raw_request)
+      @request.instance_variable_get(:@raw_request)['authorization'].should_not be_nil
+    end
+  end
+  
+  describe '#format_from_mimetype' do
+    it 'should handle text/xml' do
+      ["text/xml", "text/xml; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :xml
+      end
+    end
+
+    it 'should handle application/xml' do
+      ["application/xml", "application/xml; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :xml
+      end
+    end
+
+    it 'should handle text/json' do
+      ["text/json", "text/json; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :json
+      end
+    end
+
+    it 'should handle application/json' do
+      ["application/json", "application/json; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :json
+      end
+    end
+
+    it 'should handle text/javascript' do
+      ["text/javascript", "text/javascript; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :json
+      end
+    end
+
+    it 'should handle application/javascript' do
+      ["application/javascript", "application/javascript; charset=iso8859-1"].each do |ct|
+        @request.send(:format_from_mimetype, ct).should == :json
+      end
     end
   end
 
@@ -33,6 +79,32 @@ describe HTTParty::Request do
       @request.options[:format] = :json
       @request.send(:parse_response, json).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
     end
+    
+    describe 'with non-200 responses' do
+
+      it 'should return a valid object for 4xx response' do
+        http_response = Net::HTTPUnauthorized.new('1.1', 401, '')
+        http_response.stub!(:body).and_return('<foo><bar>yes</bar></foo>')
+        
+        @request.should_receive(:get_response).and_return(http_response)
+        resp = @request.perform
+        resp.code.should == 401
+        resp.body.should == "<foo><bar>yes</bar></foo>"
+        resp['foo']['bar'].should == "yes"
+      end
+
+      it 'should return a valid object for 5xx response' do
+        http_response = Net::HTTPUnauthorized.new('1.1', 500, '')
+        http_response.stub!(:body).and_return('<foo><bar>error</bar></foo>')
+        
+        @request.should_receive(:get_response).and_return(http_response)
+        resp = @request.perform
+        resp.code.should == 500
+        resp.body.should == "<foo><bar>error</bar></foo>"
+        resp['foo']['bar'].should == "error"
+      end
+
+    end
   end
 
   it "should not attempt to parse empty responses" do
@@ -41,7 +113,7 @@ describe HTTParty::Request do
     response = Net::HTTPNoContent.new("1.1", 204, "No content for you")
     response.stub!(:body).and_return(nil)
     http.stub!(:request).and_return(response)
-
+    
     @request.options[:format] = :xml
     @request.perform.should be_nil
 

data/spec/httparty_spec.rb

@@ -173,5 +173,17 @@ describe HTTParty do
         "location"          => nil
       }
     end
+    
+    it "should not get undefined method add_node for nil class for the following xml" do
+      stub_http_response_with('undefined_method_add_node_for_nil.xml')
+      result = HTTParty.get('http://foobar.com')
+      result.should == {"Entities"=>{"href"=>"https://s3-sandbox.parature.com/api/v1/5578/5633/Account", "results"=>"0", "total"=>"0", "page_size"=>"25", "page"=>"1"}}
+    end
+    
+    it "should parse empty response fine" do
+      stub_http_response_with('empty.xml')
+      result = HTTParty.get('http://foobar.com')
+      result.should == nil
+    end
   end
 end

data/spec/spec_helper.rb

@@ -10,15 +10,12 @@ end
 def stub_http_response_with(filename)
   format = filename.split('.').last.intern
   data = file_fixture(filename)
-  http = Net::HTTP.new('localhost', 80)
-  
+
   response = Net::HTTPOK.new("1.1", 200, "Content for you")
   response.stub!(:body).and_return(data)
-  http.stub!(:request).and_return(response)
-  
-  http_request = HTTParty::Request.new(Net::HTTP::Get, '')
-  http_request.stub!(:get_response).and_return(response)
-  http_request.stub!(:format).and_return(format)
-  
+
+  http_request = HTTParty::Request.new(Net::HTTP::Get, 'http://localhost', :format => format)
+  http_request.stub!(:perform_actual_request).and_return(response)
+
   HTTParty::Request.should_receive(:new).and_return(http_request)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jnunemaker-httparty
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-05 00:00:00 -08:00
+date: 2009-01-28 00:00:00 -08:00
 default_executable: httparty
 dependencies: 
 - !ruby/object:Gem::Dependency