adamwiggins-rest-client 0.9.2 → 1.0

data/README.rdoc

@@ -121,6 +121,18 @@ extract and set headers for them as needed:
   )
   # ...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)
@@ -128,7 +140,8 @@ Written by Adam Wiggins (adam at heroku dot com)
 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, and Juan Alvarez
+Lennon Day-Reynolds, James Edward Gray II, Cyril Rohr, Juan Alvarez, and Adam
+Jacob
 
 Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
 

data/Rakefile

@@ -31,7 +31,7 @@ require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'fileutils'
 
-version = "0.9.2"
+version = "1.0"
 name = "rest-client"
 
 spec = Gem::Specification.new do |s|

data/lib/restclient/request.rb

@@ -1,12 +1,17 @@
+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
 	# main API.  For example:
 	#
 	#   RestClient::Request.execute(:method => :head, :url => 'http://example.com')
-   #
+	#
 	class Request
-		attr_reader :method, :url, :payload, :headers, :cookies, :user, :password, :timeout, :open_timeout
+		attr_reader :method, :url, :payload, :headers,
+			:cookies, :user, :password, :timeout, :open_timeout,
+			:verify_ssl, :ssl_client_cert, :ssl_client_key, :ssl_ca_file,
+			:raw_response
 
 		def self.execute(args)
 			new(args).execute
@@ -16,12 +21,18 @@ module RestClient
 			@method = args[:method] or raise ArgumentError, "must pass :method"
 			@url = args[:url] or raise ArgumentError, "must pass :url"
 			@headers = args[:headers] || {}
-      @cookies = @headers.delete(:cookies) || args[:cookies] || {}
+			@cookies = @headers.delete(:cookies) || args[:cookies] || {}
 			@payload = process_payload(args[:payload])
 			@user = args[:user]
 			@password = args[:password]
 			@timeout = args[:timeout]
 			@open_timeout = args[:open_timeout]
+			@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_ca_file = args[:ssl_ca_file] || nil
+			@tf = nil # If you are a raw request, this is your tempfile
 		end
 
 		def execute
@@ -37,13 +48,13 @@ module RestClient
 		end
 
 		def make_headers(user_headers)
-      unless @cookies.empty?
-        user_headers[:cookie] = @cookies.map {|key, val| "#{key.to_s}=#{val}" }.join('; ')
-      end
+			unless @cookies.empty?
+				user_headers[:cookie] = @cookies.map {|key, val| "#{key.to_s}=#{val}" }.join('; ')
+			end
 
 			default_headers.merge(user_headers).inject({}) do |final, (key, value)|
 				final[key.to_s.gsub(/_/, '-').capitalize] = value.to_s
-				final
+			final
 			end
 		end
 
@@ -94,19 +105,28 @@ module RestClient
 
 			net = net_http_class.new(uri.host, uri.port)
 			net.use_ssl = uri.is_a?(URI::HTTPS)
-			net.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			if @verify_ssl == false
+        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
 			net.read_timeout = @timeout if @timeout
 			net.open_timeout = @open_timeout if @open_timeout
 
 			display_log request_log
 
 			net.start do |http|
-				res = http.request(req, payload)
+				res = http.request(req, payload) { |http_response| fetch_body(http_response) }
+				result = process_result(res)
 				display_log response_log(res)
-				string = process_result(res)
 
-				if string or @method == :head
-					Response.new(string, res)
+				if result.kind_of?(String) or @method == :head
+					Response.new(result, res)
+				elsif @raw_response
+					RawResponse.new(@tf, res)
 				else
 					nil
 				end
@@ -121,9 +141,38 @@ module RestClient
 			req.basic_auth(user, password) if user
 		end
 
+		def fetch_body(http_response)
+			if @raw_response
+				# Taken from Chef, which as in turn...
+				# Stolen from http://www.ruby-forum.com/topic/166423
+				# Kudos to _why!
+				@tf = Tempfile.new("rest-client") 
+				size, total = 0, http_response.header['Content-Length'].to_i
+				http_response.read_body do |chunk|
+					@tf.write(chunk) 
+					size += chunk.size
+					if size == 0
+						display_log("#{@method} #{@url} done (0 length file)")
+					elsif total == 0
+						display_log("#{@method} #{@url} (zero content length)")
+					else
+						display_log("#{@method} #{@url} %d%% done (%d of %d)" % [(size * 100) / total, size, total])
+					end
+				end
+				@tf.close
+				@tf
+			else
+				http_response.read_body
+			end
+			http_response
+		end
+
 		def process_result(res)
-			if res.code =~ /\A2\d{2}\z/
-				decode res['content-encoding'], res.body if res.body
+			if res.code =~ /\A2\d{2}\z/ 
+				# We don't decode raw requests
+				unless @raw_response
+					decode res['content-encoding'], res.body if res.body
+				end
 			elsif %w(301 302 303).include? res.code
 				url = res.header['Location']
 
@@ -164,7 +213,8 @@ module RestClient
 		end
 
 		def response_log(res)
-			"# => #{res.code} #{res.class.to_s.gsub(/^Net::HTTP/, '')} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{(res.body) ? res.body.size : nil} bytes"
+			size = @raw_response ? File.size(@tf.path) : res.body.size
+			"# => #{res.code} #{res.class.to_s.gsub(/^Net::HTTP/, '')} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{size} bytes"
 		end
 
 		def display_log(msg)

data/lib/restclient/resource.rb

@@ -100,8 +100,8 @@ module RestClient
 		end
 		
 		def open_timeout
-		  options[:open_timeout]
-	  end
+			options[:open_timeout]
+		end
 
 		# Construct a subresource, preserving authentication.
 		#

data/lib/restclient/response.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/mixin/response'
+
 module RestClient
 	# The response from RestClient looks like a string, but is actually one of
 	# these.  99% of the time you're making a rest call all you care about is
@@ -6,41 +8,13 @@ module RestClient
 	#   RestClient.get('http://example.com').headers[:content_type]
 	#
 	class Response < String
-		attr_reader :net_http_res
+
+		include RestClient::Mixin::Response
 
 		def initialize(string, net_http_res)
 			@net_http_res = net_http_res
 			super(string || "")
 		end
 
-		# HTTP status code, always 200 since RestClient throws exceptions for
-		# other codes.
-		def code
-			@code ||= @net_http_res.code.to_i
-		end
-
-		# A hash of the headers, beautified with symbols and underscores.
-		# e.g. "Content-type" will become :content_type.
-		def headers
-			@headers ||= self.class.beautify_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|
-        key, val = raw_c.split('=')
-        unless %w(expires domain path secure).member?(key)
-          out[key] = val
-        end
-        out
-      end
-    end
-
-		def self.beautify_headers(headers)
-			headers.inject({}) do |out, (key, value)|
-				out[key.gsub(/-/, '_').to_sym] = value.first
-				out
-			end
-		end
 	end
 end

data/lib/restclient.rb

@@ -4,7 +4,9 @@ require 'zlib'
 require 'stringio'
 
 require File.dirname(__FILE__) + '/restclient/request'
+require File.dirname(__FILE__) + '/restclient/mixin/response'
 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'
 

data/rest-client.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
     s.name = "rest-client"
-    s.version = "0.9.2"
+    s.version = "1.0"
     s.summary = "Simple REST client for Ruby, inspired by microframework syntax for specifying actions."
     s.description = "A simple REST client for Ruby, inspired by the Sinatra microframework style of specifying actions: get, put, post, delete."
     s.author = "Adam Wiggins"

data/spec/request_spec.rb

@@ -28,7 +28,7 @@ describe RestClient::Request do
 	it "decodes a gzip body" do
 		@request.decode('gzip', "\037\213\b\b\006'\252H\000\003t\000\313T\317UH\257\312,HM\341\002\000G\242(\r\v\000\000\000").should == "i'm gziped\n"
 	end
-	
+
 	it "ingores gzip for empty bodies" do
 		@request.decode('gzip', '').should be_empty
 	end
@@ -37,23 +37,23 @@ describe RestClient::Request do
 		@request.decode('deflate', "x\234+\316\317MUHIM\313I,IMQ(I\255(\001\000A\223\006\363").should == "some deflated text"
 	end
 
-  it "processes a successful result" do
-    res = mock("result")
-    res.stub!(:code).and_return("200")
-    res.stub!(:body).and_return('body')
-    res.stub!(:[]).with('content-encoding').and_return(nil)
-    @request.process_result(res).should == 'body'
-  end
+	it "processes a successful result" do
+		res = mock("result")
+		res.stub!(:code).and_return("200")
+		res.stub!(:body).and_return('body')
+		res.stub!(:[]).with('content-encoding').and_return(nil)
+		@request.process_result(res).should == 'body'
+	end
 
-  it "doesn't classify successful requests as failed" do
-    203.upto(206) do |code|
-      res = mock("result")
-      res.stub!(:code).and_return(code.to_s)
-      res.stub!(:body).and_return("")
-      res.stub!(:[]).with('content-encoding').and_return(nil)
-      @request.process_result(res).should be_empty
-    end
-  end
+	it "doesn't classify successful requests as failed" do
+		203.upto(206) do |code|
+			res = mock("result")
+			res.stub!(:code).and_return(code.to_s)
+			res.stub!(:body).and_return("")
+			res.stub!(:[]).with('content-encoding').and_return(nil)
+			@request.process_result(res).should be_empty
+		end
+	end
 
 	it "parses a url into a URI object" do
 		URI.should_receive(:parse).with('http://example.com/resource')
@@ -80,12 +80,12 @@ describe RestClient::Request do
 		@request.password.should == 'pass2'
 	end
 
-  it "correctly formats cookies provided to the constructor" do
-    URI.stub!(:parse).and_return(mock('uri', :user => nil, :password => nil))
-    @request = RestClient::Request.new(:method => 'get', :url => 'example.com', :cookies => {:session_id => '1' })
-    @request.should_receive(:default_headers).and_return({'foo' => 'bar'})
-    headers = @request.make_headers({}).should == { 'Foo' => 'bar', 'Cookie' => 'session_id=1'}
-  end
+	it "correctly formats cookies provided to the constructor" do
+		URI.stub!(:parse).and_return(mock('uri', :user => nil, :password => nil))
+		@request = RestClient::Request.new(:method => 'get', :url => 'example.com', :cookies => {:session_id => '1' })
+		@request.should_receive(:default_headers).and_return({'foo' => 'bar'})
+		headers = @request.make_headers({}).should == { 'Foo' => 'bar', 'Cookie' => 'session_id=1'}
+	end
 
 	it "determines the Net::HTTP class to instantiate by the method name" do
 		@request.net_http_request_class(:put).should == Net::HTTP::Put
@@ -243,7 +243,7 @@ describe RestClient::Request do
 	end
 
 	it "creates a non-proxy class if a proxy url is not given" do
-	  @request.net_http_class.should_not include(Net::HTTP::ProxyDelta)
+		@request.net_http_class.should_not include(Net::HTTP::ProxyDelta)
 	end
 
 	it "logs a get request" do
@@ -303,26 +303,154 @@ describe RestClient::Request do
 		f.should_receive(:puts).with('xyz')
 		@request.display_log('xyz')
 	end
-	
+
 	it "set read_timeout" do
 		@request = RestClient::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :timeout => 123)
 		@http.stub!(:request)
 		@request.stub!(:process_result)
 		@request.stub!(:response_log)
-		
+
 		@net.should_receive(:read_timeout=).with(123)
-		
+
 		@request.transmit(@uri, 'req', nil)
 	end
-	
+
 	it "set open_timeout" do
 		@request = RestClient::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :open_timeout => 123)
 		@http.stub!(:request)
 		@request.stub!(:process_result)
 		@request.stub!(:response_log)
-		
+
 		@net.should_receive(:open_timeout=).with(123)
-		
+
 		@request.transmit(@uri, 'req', nil)
 	end
+
+	it "should default to not verifying ssl certificates" 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 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)
+		@net.should_not_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 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
+
+	it "should default to not having an ssl_client_cert" do
+		@request.ssl_client_cert.should be(nil)
+	end
+
+	it "should set the ssl_client_cert if provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload',
+			:ssl_client_cert => "whatsupdoc!"
+		)
+		@net.should_receive(:cert=).with("whatsupdoc!")
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
+
+	it "should not set the ssl_client_cert if it is not provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload'
+		)
+		@net.should_not_receive(:cert=).with("whatsupdoc!")
+		@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_key" do
+		@request.ssl_client_key.should be(nil)
+	end
+
+	it "should set the ssl_client_key if provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload',
+			:ssl_client_key => "whatsupdoc!"
+		)
+		@net.should_receive(:key=).with("whatsupdoc!")
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
+
+	it "should not set the ssl_client_key if it is not provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload'
+		)
+		@net.should_not_receive(:key=).with("whatsupdoc!")
+		@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_ca_file" do
+		@request.ssl_ca_file.should be(nil)
+	end
+
+	it "should set the ssl_ca_file if provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload',
+			:ssl_ca_file => "Certificate Authority File"
+		)
+		@net.should_receive(:ca_file=).with("Certificate Authority File")
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
+
+	it "should not set the ssl_ca_file if it is not provided" do
+		@request = RestClient::Request.new(
+			:method => :put, 
+			:url => 'https://some/resource', 
+			:payload => 'payload'
+		)
+		@net.should_not_receive(:ca_file=).with("Certificate Authority File")
+		@http.stub!(:request)
+		@request.stub!(:process_result)
+		@request.stub!(:response_log)
+		@request.transmit(@uri, 'req', 'payload')
+	end
 end

data/spec/response_spec.rb

@@ -10,35 +10,6 @@ describe RestClient::Response do
 		@response.should == 'abc'
 	end
 
-	it "fetches the numeric response code" do
-		@net_http_res.should_receive(:code).and_return('200')
-		@response.code.should == 200
-	end
-
-	it "beautifies the headers by turning the keys to symbols" do
-		h = RestClient::Response.beautify_headers('content-type' => [ 'x' ])
-		h.keys.first.should == :content_type
-	end
-
-	it "beautifies the headers by turning the values to strings instead of one-element arrays" do
-		h = RestClient::Response.beautify_headers('x' => [ 'text/html' ] )
-		h.values.first.should == 'text/html'
-	end
-
-	it "fetches the headers" do
-		@net_http_res.should_receive(:to_hash).and_return('content-type' => [ 'text/html' ])
-		@response.headers.should == { :content_type => 'text/html' }
-	end
-
-  it "extracts cookies from response headers" do
-    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-    @response.cookies.should == { 'session_id' => '1' }
-  end
-
-	it "can access the net http result directly" do
-		@response.net_http_res.should == @net_http_res
-	end
-
 	it "accepts nil strings and sets it to empty for the case of HEAD" do
 		RestClient::Response.new(nil, @net_http_res).should == ""
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: adamwiggins-rest-client
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: "1.0"
 platform: ruby
 authors: 
 - Adam Wiggins
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-25 00:00:00 -08:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: []