rest-client 1.0.4 → 1.1.0

data/README.rdoc

@@ -14,14 +14,27 @@ of specifying actions: get, put, post, delete.
 
   RestClient.delete 'http://example.com/resource'
 
-See RestClient module docs for details.
+== Multipart
+
+Yeah, that's right!  This does multipart sends for you!
+
+  RestClient.post '/data', :myfile => File.new("/path/to/image.jpg")
+
+This does two things for you:
+
+* Auto-detects that you have a File value sends it as multipart
+* Auto-detects the mime of the file and sets it in the HEAD of the payload for each entry
+
+If you are sending params that do not contain a File object but the payload needs to be multipart then:
+
+  RestClient.post '/data', :foo => 'bar', :multipart => true
 
 == Usage: ActiveResource-Style
 
   resource = RestClient::Resource.new 'http://example.com/resource'
   resource.get
 
-  private_resource = RestClient::Resource.new 'https://example.com/private/resource', :user => 'adam', :password => 'secret', :timeout => 20, :open_timeout => 5
+  private_resource = RestClient::Resource.new 'https://example.com/private/resource', 'user', 'pass'
   private_resource.put File.read('pic.jpg'), :content_type => 'image/jpg'
 
 See RestClient::Resource module docs for details.
@@ -33,6 +46,10 @@ See RestClient::Resource module docs for details.
 
 See RestClient::Resource docs for details.
 
+== Lower-level access
+
+For cases not covered by the general API, you can use the RestClient::Resource class which provide a lower-level API, see the class' rdoc for more information.
+
 == Shell
 
 The restclient shell command gives an IRB session with RestClient already loaded:
@@ -64,88 +81,19 @@ Create ~/.restclient for named sessions:
 Then invoke:
 
   $ restclient private_site
-  
-Use as a one-off, curl-style:
-
-  $ restclient get http://example.com/resource > output_body
-
-  $ restclient put http://example.com/resource < input_body
-
-== Logging
-
-Write calls to a log filename (can also be "stdout" or "stderr"):
-
-  RestClient.log = '/tmp/restclient.log'
-
-Or set an environment variable to avoid modifying the code:
-
-  $ RESTCLIENT_LOG=stdout path/to/my/program
-
-Either produces logs like this:
-
-  RestClient.get "http://some/resource"
-  # => 200 OK | text/html 250 bytes
-  RestClient.put "http://some/resource", "payload"
-  # => 401 Unauthorized | application/xml 340 bytes
-
-Note that these logs are valid Ruby, so you can paste them into the restclient
-shell or a script to replay your sequence of rest calls.
-
-== Proxy
-
-All calls to RestClient, including Resources, will use the proxy specified by
-RestClient.proxy:
-
-  RestClient.proxy = "http://proxy.example.com/"
-  RestClient.get "http://some/resource"
-  # => response from some/resource as proxied through proxy.example.com
-
-Often the proxy url is set in an environment variable, so you can do this to
-use whatever proxy the system is configured to use:
-
-  RestClient.proxy = ENV['http_proxy']
-
-== Cookies
-
-Request and Response objects know about HTTP cookies, and will automatically
-extract and set headers for them as needed:
-
-  response = RestClient.get 'http://example.com/action_which_sets_session_id'
-  response.cookies
-  # => {"_applicatioN_session_id" => "1234"}
-
-  response2 = RestClient.post(
-    'http://localhost:3000/',
-    {:param1 => "foo"},
-    {:cookies => {:session_id => "1234"}}
-  )
-  # ...response body
-
-== SSL Client Certificates
-
-  RestClient::Resource.new(
-    'https://example.com', 
-    :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read("cert.pem")), 
-    :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read("key.pem"), "passphrase, if any"),
-    :ssl_ca_file      =>  "ca_certificate.pem", 
-    :verify_ssl       =>  OpenSSL::SSL::VERIFY_PEER 
-  ).get
-
-Self-signed certificates can be generated with the openssl command-line tool.
 
 == Meta
 
-Written by Adam Wiggins (adam at heroku dot com)
+Written by Adam Wiggins, major modifications by Blake Mizerany, maintained by Archiloque
 
-Patches contributed by: Chris Anderson, Greg Borenstein, Ardekantur, Pedro
-Belo, Rafael Souza, Rick Olson, Aman Gupta, Blake Mizerany, Brian Donovan, Ivan
-Makfinsky, Marc-André Cournoyer, Coda Hale, Tetsuo Watanabe, Dusty Doris,
-Lennon Day-Reynolds, James Edward Gray II, Cyril Rohr, Juan Alvarez, and Adam
-Jacob, Paul Dlug, and Brad Ediger
+Patches contributed by: Chris Anderson, Greg Borenstein, Ardekantur, Pedro Belo, Rafael Souza, Rick Olson, Aman Gupta, François Beausoleil and Nick Plante.
 
 Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-http://rest-client.heroku.com
+Main page: http://github.com/archiloque/rest-client
+
+Rdoc: http://rdoc.info/projects/archiloque/rest-client
 
-http://github.com/adamwiggins/rest-client
+Mailing list: rest.client@librelist.com (send a mail to subscribe).
 
+IRC: #rest-client at freenode

data/Rakefile

@@ -52,7 +52,6 @@ Rake::RDocTask.new do |t|
 	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
 	t.options << '--charset' << 'utf-8'
 	t.rdoc_files.include('README.rdoc')
-	t.rdoc_files.include('lib/restclient.rb')
-	t.rdoc_files.include('lib/restclient/*.rb')
+	t.rdoc_files.include('lib/*.rb')
 end
 

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.1.0

data/lib/restclient.rb

@@ -15,6 +15,8 @@ require File.dirname(__FILE__) + '/restclient/response'
 require File.dirname(__FILE__) + '/restclient/raw_response'
 require File.dirname(__FILE__) + '/restclient/resource'
 require File.dirname(__FILE__) + '/restclient/exceptions'
+require File.dirname(__FILE__) + '/restclient/payload'
+require File.dirname(__FILE__) + '/restclient/net_http_ext'
 
 # This module's static methods are the entry point for using the REST client.
 #
@@ -96,4 +98,10 @@ module RestClient
 		return @@log if defined? @@log
 		nil
 	end
+
+  def self.version
+    version_path = File.dirname(__FILE__) + "/../VERSION"
+    return File.read(version_path).chomp if File.file?(version_path)
+    "0.0.0"
+  end
 end

data/lib/restclient/mixin/response.rb

@@ -15,6 +15,11 @@ module RestClient
 				@headers ||= self.class.beautify_headers(@net_http_res.to_hash)
 			end
 
+			# The raw headers.
+			def raw_headers
+				@raw_headers ||= @net_http_res.to_hash
+			end
+
 			# Hash of cookies extracted from response headers
 			def cookies
 				@cookies ||= (self.headers[:set_cookie] || "").split('; ').inject({}) do |out, raw_c|
@@ -33,7 +38,7 @@ module RestClient
 			module ClassMethods
 				def beautify_headers(headers)
 					headers.inject({}) do |out, (key, value)|
-						out[key.gsub(/-/, '_').to_sym] = value.first
+						out[key.gsub(/-/, '_').downcase.to_sym] = value.first
 					out
 					end
 				end

data/lib/restclient/net_http_ext.rb

@@ -0,0 +1,21 @@
+#
+# Replace the request method in Net::HTTP to sniff the body type
+# and set the stream if appropriate
+#
+# Taken from:	
+# http://www.missiondata.com/blog/ruby/29/streaming-data-to-s3-with-ruby/
+
+module Net
+	class HTTP
+		alias __request__ request
+
+		def request(req, body=nil, &block)
+			if body != nil && body.respond_to?(:read)
+				req.body_stream = body
+				return __request__(req, nil, &block)
+			else
+				return __request__(req, body, &block)
+			end
+		end
+	end
+end

data/lib/restclient/payload.rb

@@ -0,0 +1,171 @@
+require "tempfile"
+require "stringio"
+require "mime/types"
+
+module RestClient
+	module Payload
+		extend self
+
+		def generate(params)
+			if params.is_a?(String)
+				Base.new(params)
+			elsif params
+				if params.delete(:multipart) == true || has_file?(params)
+					Multipart.new(params)
+				else
+					UrlEncoded.new(params)
+				end
+			else
+				nil
+			end
+		end
+
+		def has_file?(params)
+			params.any? do |_, v|
+				case v
+				when Hash
+					has_file?(v)
+				else
+					v.respond_to?(:path) && v.respond_to?(:read)
+				end
+			end
+		end
+
+		class Base
+			def initialize(params)
+				build_stream(params)
+			end
+
+			def build_stream(params)
+				@stream = StringIO.new(params)
+				@stream.seek(0)
+			end
+
+			def read(bytes=nil)
+				@stream.read(bytes)
+			end
+			alias :to_s :read
+
+			def escape(v)
+				URI.escape(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+			end
+
+			# Flatten parameters by converting hashes of hashes to flat hashes
+			# {keys1 => {keys2 => value}} will be transformed into {keys1[key2] => value}
+			def flatten_params(params, parent_key = nil)
+				result = {}
+				params.keys.map do |key|
+					calculated_key = parent_key ? "#{parent_key}[#{escape key}]" : escape(key)
+					value = params[key]
+					if value.is_a? Hash
+						result.merge!(flatten_params(value, calculated_key))
+					else
+						result[calculated_key] = value
+					end
+				end
+				result
+			end
+
+			def headers
+				{ 'Content-Length' => size.to_s }
+			end
+
+			def size
+				@stream.size
+			end
+			alias :length :size
+
+			def close
+				@stream.close
+			end
+
+			def inspect
+				result = to_s.inspect
+				@stream.seek(0)
+				result
+			end
+		end
+
+		class UrlEncoded < Base
+			def build_stream(params = nil)
+				@stream = StringIO.new(flatten_params(params).map do |k,v| 
+					"#{k}=#{escape(v)}"
+				end.join("&"))
+				@stream.seek(0)
+			end
+
+			def headers
+				super.merge({ 'Content-Type' => 'application/x-www-form-urlencoded' })
+			end
+		end
+
+		class Multipart < Base
+			EOL = "\r\n"
+
+			def build_stream(params)
+				b = "--#{boundary}"
+
+				@stream = Tempfile.new("RESTClient.Stream.#{rand(1000)}")
+				@stream.write(b + EOL)
+
+				if params.is_a? Hash
+					x = flatten_params(params).to_a
+				else
+					x = params.to_a
+				end
+				
+				last_index = x.length - 1
+				x.each_with_index do |a, index|
+					k, v = *a
+					if v.respond_to?(:read) && v.respond_to?(:path)
+						create_file_field(@stream, k,v)
+					else
+						create_regular_field(@stream, k,v)
+					end
+					@stream.write(EOL + b)
+					@stream.write(EOL) unless last_index == index
+				end
+				@stream.write('--')
+				@stream.write(EOL)
+				@stream.seek(0)
+			end
+
+			def create_regular_field(s, k, v)
+				s.write("Content-Disposition: multipart/form-data; name=\"#{k}\"")
+				s.write(EOL)
+				s.write(EOL)
+				s.write(v)
+			end
+
+			def create_file_field(s, k, v)
+				begin
+					s.write("Content-Disposition: multipart/form-data; name=\"#{k}\"; filename=\"#{v.respond_to?(:original_filename) ? v.original_filename : File.basename(v.path)}\"#{EOL}")
+					s.write("Content-Type: #{v.respond_to?(:content_type) ? v.content_type : mime_for(v.path)}#{EOL}")
+					s.write(EOL)
+					while data = v.read(8124)
+						s.write(data)
+					end
+				ensure
+					v.close
+				end
+			end
+
+			def mime_for(path)
+				mime = MIME::Types.type_for path
+				mime.empty? ? 'text/plain' : mime[0].content_type
+			end
+
+			def boundary
+				@boundary ||= rand(1_000_000).to_s
+			end
+
+			def headers
+				super.merge({'Content-Type' => %Q{multipart/form-data; boundary="#{boundary}"}})
+			end
+
+			def close
+				@stream.close
+			end
+		end
+	end
+end

data/lib/restclient/request.rb

@@ -2,11 +2,22 @@ require 'tempfile'
 
 module RestClient
 	# This class is used internally by RestClient to send the request, but you can also
-	# access it internally if you'd like to use a method not directly supported by the
+	# call it directly if you'd like to use a method not supported by the
 	# main API.  For example:
 	#
 	#   RestClient::Request.execute(:method => :head, :url => 'http://example.com')
 	#
+	# Mandatory parameters:
+	# * :method
+	# * :url
+	# Optional parameters (have a look at ssl and/or uri for some explanations):
+	# * :headers a hash containing the request headers
+	# * :cookies will replace possible cookies in the :headers
+	# * :user and :password for basic auth, will be replaced by a user/password available in the :url
+	# * :raw_response return a low-level RawResponse instead of a Response
+	# * :verify_ssl enable ssl verification, possible values are constants from OpenSSL::SSL
+	# * :timeout and :open_timeout
+	# * :ssl_client_cert, :ssl_client_key, :ssl_ca_file
 	class Request
 		attr_reader :method, :url, :payload, :headers,
 			:cookies, :user, :password, :timeout, :open_timeout,
@@ -22,7 +33,7 @@ module RestClient
 			@url = args[:url] or raise ArgumentError, "must pass :url"
 			@headers = args[:headers] || {}
 			@cookies = @headers.delete(:cookies) || args[:cookies] || {}
-			@payload = process_payload(args[:payload])
+			@payload = Payload.generate(args[:payload])
 			@user = args[:user]
 			@password = args[:password]
 			@timeout = args[:timeout]
@@ -30,7 +41,7 @@ module RestClient
 			@raw_response = args[:raw_response] || false
 			@verify_ssl = args[:verify_ssl] || false
 			@ssl_client_cert = args[:ssl_client_cert] || nil
-			@ssl_client_key  = args[:ssl_client_key] || nil
+			@ssl_client_key = args[:ssl_client_key] || nil
 			@ssl_ca_file = args[:ssl_ca_file] || nil
 			@tf = nil # If you are a raw request, this is your tempfile
 		end
@@ -54,10 +65,13 @@ module RestClient
 				user_headers[:cookie] = @cookies.map {|key, val| "#{key.to_s}=#{val}" }.join('; ')
 			end
 
-			default_headers.merge(user_headers).inject({}) do |final, (key, value)|
+			headers = default_headers.merge(user_headers).inject({}) do |final, (key, value)|
 				final[key.to_s.gsub(/_/, '-').capitalize] = value.to_s
-			final
+				final
 			end
+
+			headers.merge!(@payload.headers) if @payload
+			headers
 		end
 
 		def net_http_class
@@ -108,10 +122,10 @@ module RestClient
 			net = net_http_class.new(uri.host, uri.port)
 			net.use_ssl = uri.is_a?(URI::HTTPS)
 			if @verify_ssl == false
-        net.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      elsif @verify_ssl.is_a? Integer
-        net.verify_mode = @verify_ssl
-      end
+				net.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			elsif @verify_ssl.is_a? Integer
+				net.verify_mode = @verify_ssl
+			end
 			net.cert = @ssl_client_cert if @ssl_client_cert
 			net.key = @ssl_client_key if @ssl_client_key
 			net.ca_file = @ssl_ca_file if @ssl_ca_file
@@ -130,7 +144,7 @@ module RestClient
 				elsif @raw_response
 					RawResponse.new(@tf, res)
 				else
-					nil
+					Response.new(nil, res)
 				end
 			end
 		rescue EOFError

data/lib/restclient/resource.rb

@@ -45,38 +45,38 @@ module RestClient
 			end
 		end
 
-		def get(additional_headers={})
+		def get(additional_headers={}, &b)
+			headers = (options[:headers] || {}).merge(additional_headers)
 			Request.execute(options.merge(
 				:method => :get,
 				:url => url,
-				:headers => headers.merge(additional_headers)
-			))
+				:headers => headers), &b)
 		end
 
-		def post(payload, additional_headers={})
+		def post(payload, additional_headers={}, &b)
+			headers = (options[:headers] || {}).merge(additional_headers)
 			Request.execute(options.merge(
 				:method => :post,
 				:url => url,
 				:payload => payload,
-				:headers => headers.merge(additional_headers)
-			))
+				:headers => headers), &b)
 		end
 
-		def put(payload, additional_headers={})
+		def put(payload, additional_headers={}, &b)
+			headers = (options[:headers] || {}).merge(additional_headers)
 			Request.execute(options.merge(
 				:method => :put,
 				:url => url,
 				:payload => payload,
-				:headers => headers.merge(additional_headers)
-			))
+				:headers => headers), &b)
 		end
 
-		def delete(additional_headers={})
+		def delete(additional_headers={}, &b)
+			headers = (options[:headers] || {}).merge(additional_headers)
 			Request.execute(options.merge(
 				:method => :delete,
 				:url => url,
-				:headers => headers.merge(additional_headers)
-			))
+				:headers => headers), &b)
 		end
 
 		def to_s

data/spec/base.rb

@@ -1,4 +1,10 @@
 require 'rubygems'
 require 'spec'
 
+begin
+  require "ruby-debug"
+rescue LoadError
+  # NOP, ignore
+end
+
 require File.dirname(__FILE__) + '/../lib/restclient'

data/spec/payload_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + "/base"
+
+describe RestClient::Payload do
+	context "A regular Payload" do
+		it "should use standard enctype as default content-type" do
+			RestClient::Payload::UrlEncoded.new({}).headers['Content-Type'].
+				should == 'application/x-www-form-urlencoded'
+		end
+
+		it "should form properly encoded params" do
+			RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s.
+				should == "foo=bar"
+		end
+
+		it "should properly handle hashes as parameter" do
+			RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz' }}).to_s.
+				should == "foo[bar]=baz"
+			RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux' }}}).to_s.
+				should == "foo[bar][baz]=qux"
+		end
+
+		it "should form properly use symbols as parameters" do
+			RestClient::Payload::UrlEncoded.new({:foo => :bar}).to_s.
+				should == "foo=bar"
+			RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz }}).to_s.
+				should == "foo[bar]=baz"
+		end
+
+	end
+
+	context "A multipart Payload" do
+		it "should use standard enctype as default content-type" do
+			m = RestClient::Payload::Multipart.new({})
+			m.stub!(:boundary).and_return(123)
+			m.headers['Content-Type'].should == 'multipart/form-data; boundary="123"'
+		end
+
+		it "should form properly seperated multipart data" do
+			m = RestClient::Payload::Multipart.new([[:bar , "baz"], [:foo, "bar"]])
+			m.to_s.should == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="bar"\r
+\r
+baz\r
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="foo"\r
+\r
+bar\r
+--#{m.boundary}--\r
+EOS
+		end
+
+		it "should form properly seperated multipart data" do
+			f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+			m = RestClient::Payload::Multipart.new({:foo => f})
+			m.to_s.should == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="foo"; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{IO.read(f.path)}\r
+--#{m.boundary}--\r
+EOS
+		end
+
+		it "should detect optional (original) content type and filename" do
+			f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+			f.instance_eval "def content_type; 'text/plain'; end" 
+			f.instance_eval "def original_filename; 'foo.txt'; end" 
+			m = RestClient::Payload::Multipart.new({:foo => f})
+			m.to_s.should == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="foo"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{IO.read(f.path)}\r
+--#{m.boundary}--\r
+EOS
+		end
+
+		it "should handle hash in hash parameters" do
+			m = RestClient::Payload::Multipart.new({:bar => {:baz => "foo"}})
+			m.to_s.should == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="bar[baz]"\r
+\r
+foo\r
+--#{m.boundary}--\r
+EOS
+
+			f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+			f.instance_eval "def content_type; 'text/plain'; end" 
+			f.instance_eval "def original_filename; 'foo.txt'; end" 
+			m = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
+			m.to_s.should == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: multipart/form-data; name="foo[bar]"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{IO.read(f.path)}\r
+--#{m.boundary}--\r
+EOS
+		end
+
+	end
+
+	context "Payload generation" do
+		it "should recognize standard urlencoded params" do
+			RestClient::Payload.generate({"foo" => 'bar'}).should be_kind_of(RestClient::Payload::UrlEncoded)
+		end
+		
+		it "should recognize multipart params" do
+			f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+			RestClient::Payload.generate({"foo" => f}).should be_kind_of(RestClient::Payload::Multipart)
+		end
+		
+		it "should be multipart if forced" do
+			RestClient::Payload.generate({"foo" => "bar", :multipart => true}).should be_kind_of(RestClient::Payload::Multipart)
+		end
+
+		it "should return data if no of the above" do
+			RestClient::Payload.generate("data").should be_kind_of(RestClient::Payload::Base)
+		end
+
+		it "should recognize nested multipart payloads" do
+			f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+			RestClient::Payload.generate({"foo" => {"file" => f}}).should be_kind_of(RestClient::Payload::Multipart)
+		end
+
+	end
+end

data/spec/request_spec.rb

@@ -93,17 +93,25 @@ describe RestClient::Request do
 
 	it "merges user headers with the default headers" do
 		@request.should_receive(:default_headers).and_return({ '1' => '2' })
-		@request.make_headers('3' => '4').should == { '1' => '2', '3' => '4' }
+		headers = @request.make_headers('3' => '4')
+		headers.should have_key('1')
+		headers['1'].should == '2'
+		headers.should have_key('3')
+		headers['3'].should == '4'
 	end
 
 	it "prefers the user header when the same header exists in the defaults" do
 		@request.should_receive(:default_headers).and_return({ '1' => '2' })
-		@request.make_headers('1' => '3').should == { '1' => '3' }
+		headers = @request.make_headers('1' => '3')
+		headers.should have_key('1')
+		headers['1'].should == '3'
 	end
 
 	it "converts header symbols from :content_type to 'Content-type'" do
 		@request.should_receive(:default_headers).and_return({})
-		@request.make_headers(:content_type => 'abc').should == { 'Content-type' => 'abc' }
+		headers = @request.make_headers(:content_type => 'abc')
+		headers.should have_key('Content-type')
+		headers['Content-type'].should == 'abc'
 	end
 
 	it "converts header values to strings" do
@@ -115,7 +123,7 @@ describe RestClient::Request do
 		klass = mock("net:http class")
 		@request.should_receive(:net_http_request_class).with(:put).and_return(klass)
 		klass.should_receive(:new).and_return('result')
-		@request.should_receive(:transmit).with(@uri, 'result', 'payload')
+		@request.should_receive(:transmit).with(@uri, 'result', kind_of(RestClient::Payload::Base))
 		@request.execute_inner
 	end
 
@@ -350,13 +358,13 @@ describe RestClient::Request do
 		@request.verify_ssl.should == false
 	end
 
-  it "should set net.verify_mode to OpenSSL::SSL::VERIFY_NONE if verify_ssl is false" do
-    @net.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
-    @http.stub!(:request)
-    @request.stub!(:process_result)
-    @request.stub!(:response_log)
-    @request.transmit(@uri, 'req', 'payload')
-  end
+	it "should set net.verify_mode to OpenSSL::SSL::VERIFY_NONE if verify_ssl is false" do
+		@net.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
 
 	it "should not set net.verify_mode to OpenSSL::SSL::VERIFY_NONE if verify_ssl is true" do
 		@request = RestClient::Request.new(:method => :put, :url => 'https://some/resource', :payload => 'payload', :verify_ssl => true)
@@ -367,19 +375,18 @@ describe RestClient::Request do
 		@request.transmit(@uri, 'req', 'payload')
 	end
 
-  it "should set net.verify_mode to the passed value if verify_ssl is an OpenSSL constant" do
-    mode     = OpenSSL::SSL::VERIFY_PEER |
-               OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+	it "should set net.verify_mode to the passed value if verify_ssl is an OpenSSL constant" do
+		mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
 		@request = RestClient::Request.new( :method     => :put,
 		                                    :url        => 'https://some/resource',
 		                                    :payload    => 'payload',
 		                                    :verify_ssl => mode )
-    @net.should_receive(:verify_mode=).with(mode)
-    @http.stub!(:request)
-    @request.stub!(:process_result)
-    @request.stub!(:response_log)
-    @request.transmit(@uri, 'req', 'payload')
-  end
+		@net.should_receive(:verify_mode=).with(mode)
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
 
 	it "should default to not having an ssl_client_cert" do
 		@request.ssl_client_cert.should be(nil)
@@ -473,4 +480,18 @@ describe RestClient::Request do
 		@request.stub!(:response_log)
 		@request.transmit(@uri, 'req', 'payload')
 	end
+
+	it "should still return a response object for 204 No Content responses" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload'
+		)
+		net_http_res = Net::HTTPNoContent.new("", "204", "No Content")
+		net_http_res.stub(:read_body).and_return(nil)
+		@http.should_receive(:request).and_return(@request.fetch_body(net_http_res))
+		response = @request.transmit(@uri, 'req', 'payload')
+		response.should_not be_nil
+		response.code.should equal(204)
+	end
 end

data/spec/resource_spec.rb

@@ -42,19 +42,19 @@ describe RestClient::Resource do
 		@resource.password.should == 'pass'
 	end
 
-	it "concatinates urls, inserting a slash when it needs one" do
+	it "concatenates urls, inserting a slash when it needs one" do
 		@resource.concat_urls('http://example.com', 'resource').should == 'http://example.com/resource'
 	end
 
-	it "concatinates urls, using no slash if the first url ends with a slash" do
+	it "concatenates urls, using no slash if the first url ends with a slash" do
 		@resource.concat_urls('http://example.com/', 'resource').should == 'http://example.com/resource'
 	end
 
-	it "concatinates urls, using no slash if the second url starts with a slash" do
+	it "concatenates urls, using no slash if the second url starts with a slash" do
 		@resource.concat_urls('http://example.com', '/resource').should == 'http://example.com/resource'
 	end
 
-	it "concatinates even non-string urls, :posts + 1 => 'posts/1'" do
+	it "concatenates even non-string urls, :posts + 1 => 'posts/1'" do
 		@resource.concat_urls(:posts, 1).should == 'posts/1'
 	end
 

data/spec/response_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/base'
 
 describe RestClient::Response do
 	before do
-		@net_http_res = mock('net http response')
+		@net_http_res = mock('net http response', :to_hash => {"Status" => ["200 OK"]})
 		@response = RestClient::Response.new('abc', @net_http_res)
 	end
 
@@ -13,4 +13,9 @@ describe RestClient::Response do
 	it "accepts nil strings and sets it to empty for the case of HEAD" do
 		RestClient::Response.new(nil, @net_http_res).should == ""
 	end
+	
+	it "test headers and raw headers" do
+		@response.raw_headers["Status"][0].should == "200 OK"
+		@response.headers[:status].should == "200 OK"
+	end
 end

metadata

@@ -1,20 +1,30 @@
 --- !ruby/object:Gem::Specification 
 name: rest-client
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors: 
 - Adam Wiggins
+- Archiloque
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-12 00:00:00 -08:00
+date: 2009-12-28 00:00:00 +01:00
 default_executable: restclient
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.16"
+    version: 
 description: "A simple REST client for Ruby, inspired by the Sinatra microframework style of specifying actions: get, put, post, delete."
-email: adam@heroku.com
+email: rest.client@librelist.com
 executables: 
 - restclient
 extensions: []
@@ -30,20 +40,24 @@ files:
 - lib/restclient.rb
 - lib/restclient/exceptions.rb
 - lib/restclient/mixin/response.rb
+- lib/restclient/net_http_ext.rb
+- lib/restclient/payload.rb
 - lib/restclient/raw_response.rb
 - lib/restclient/request.rb
 - lib/restclient/resource.rb
 - lib/restclient/response.rb
 - spec/base.rb
 - spec/exceptions_spec.rb
+- spec/master_shake.jpg
 - spec/mixin/response_spec.rb
+- spec/payload_spec.rb
 - spec/raw_response_spec.rb
 - spec/request_spec.rb
 - spec/resource_spec.rb
 - spec/response_spec.rb
 - spec/restclient_spec.rb
 has_rdoc: true
-homepage: http://rest-client.heroku.com/
+homepage: http://github.com/archiloque/rest-client
 licenses: []
 
 post_install_message: 
@@ -74,6 +88,7 @@ test_files:
 - spec/base.rb
 - spec/exceptions_spec.rb
 - spec/mixin/response_spec.rb
+- spec/payload_spec.rb
 - spec/raw_response_spec.rb
 - spec/request_spec.rb
 - spec/resource_spec.rb