rest-client 1.1.0 → 1.2.0

data/lib/restclient/resource.rb

@@ -1,146 +1,146 @@
 module RestClient
-	# A class that can be instantiated for access to a RESTful resource,
-	# including authentication.
-	#
-	# Example:
-	#
-	#   resource = RestClient::Resource.new('http://some/resource')
-	#   jpg = resource.get(:accept => 'image/jpg')
-	#
-	# With HTTP basic authentication:
-	#
-	#   resource = RestClient::Resource.new('http://protected/resource', :user => 'user', :password => 'password')
-	#   resource.delete
-	#
-	# With a timeout (seconds):
-	#
-	#   RestClient::Resource.new('http://slow', :timeout => 10)
-	#
-	# With an open timeout (seconds):
-	#
-	#   RestClient::Resource.new('http://behindfirewall', :open_timeout => 10)
-	#
-	# You can also use resources to share common headers. For headers keys,
-	# symbols are converted to strings. Example:
-	#
-	#   resource = RestClient::Resource.new('http://some/resource', :headers => { :client_version => 1 })
-	#
-	# This header will be transported as X-Client-Version (notice the X prefix,
-	# capitalization and hyphens)
-	#
-	# Use the [] syntax to allocate subresources:
-	#
-	#   site = RestClient::Resource.new('http://example.com', :user => 'adam', :password => 'mypasswd')
-	#   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
-	#
-	class Resource
-		attr_reader :url, :options
+  # A class that can be instantiated for access to a RESTful resource,
+  # including authentication.
+  #
+  # Example:
+  #
+  #   resource = RestClient::Resource.new('http://some/resource')
+  #   jpg = resource.get(:accept => 'image/jpg')
+  #
+  # With HTTP basic authentication:
+  #
+  #   resource = RestClient::Resource.new('http://protected/resource', :user => 'user', :password => 'password')
+  #   resource.delete
+  #
+  # With a timeout (seconds):
+  #
+  #   RestClient::Resource.new('http://slow', :timeout => 10)
+  #
+  # With an open timeout (seconds):
+  #
+  #   RestClient::Resource.new('http://behindfirewall', :open_timeout => 10)
+  #
+  # You can also use resources to share common headers. For headers keys,
+  # symbols are converted to strings. Example:
+  #
+  #   resource = RestClient::Resource.new('http://some/resource', :headers => { :client_version => 1 })
+  #
+  # This header will be transported as X-Client-Version (notice the X prefix,
+  # capitalization and hyphens)
+  #
+  # Use the [] syntax to allocate subresources:
+  #
+  #   site = RestClient::Resource.new('http://example.com', :user => 'adam', :password => 'mypasswd')
+  #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+  #
+  class Resource
+    attr_reader :url, :options
 
-		def initialize(url, options={}, backwards_compatibility=nil)
-			@url = url
-			if options.class == Hash
-				@options = options
-			else # compatibility with previous versions
-				@options = { :user => options, :password => backwards_compatibility }
-			end
-		end
+    def initialize(url, options={}, backwards_compatibility=nil)
+      @url = url
+      if options.class == Hash
+        @options = options
+      else # compatibility with previous versions
+        @options = { :user => options, :password => backwards_compatibility }
+      end
+    end
 
-		def get(additional_headers={}, &b)
-			headers = (options[:headers] || {}).merge(additional_headers)
-			Request.execute(options.merge(
-				:method => :get,
-				:url => url,
-				:headers => headers), &b)
-		end
+    def get(additional_headers={}, &b)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :get,
+              :url => url,
+              :headers => headers), &b)
+    end
 
-		def post(payload, additional_headers={}, &b)
-			headers = (options[:headers] || {}).merge(additional_headers)
-			Request.execute(options.merge(
-				:method => :post,
-				:url => url,
-				:payload => payload,
-				:headers => headers), &b)
-		end
+    def post(payload, additional_headers={}, &b)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :post,
+              :url => url,
+              :payload => payload,
+              :headers => headers), &b)
+    end
 
-		def put(payload, additional_headers={}, &b)
-			headers = (options[:headers] || {}).merge(additional_headers)
-			Request.execute(options.merge(
-				:method => :put,
-				:url => url,
-				:payload => payload,
-				:headers => headers), &b)
-		end
+    def put(payload, additional_headers={}, &b)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :put,
+              :url => url,
+              :payload => payload,
+              :headers => headers), &b)
+    end
 
-		def delete(additional_headers={}, &b)
-			headers = (options[:headers] || {}).merge(additional_headers)
-			Request.execute(options.merge(
-				:method => :delete,
-				:url => url,
-				:headers => headers), &b)
-		end
+    def delete(additional_headers={}, &b)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :delete,
+              :url => url,
+              :headers => headers), &b)
+    end
 
-		def to_s
-			url
-		end
+    def to_s
+      url
+    end
 
-		def user
-			options[:user]
-		end
+    def user
+      options[:user]
+    end
 
-		def password
-			options[:password]
-		end
+    def password
+      options[:password]
+    end
 
-		def headers
-			options[:headers] || {}
-		end
+    def headers
+      options[:headers] || {}
+    end
 
-		def timeout
-			options[:timeout]
-		end
-		
-		def open_timeout
-			options[:open_timeout]
-		end
+    def timeout
+      options[:timeout]
+    end
 
-		# Construct a subresource, preserving authentication.
-		#
-		# Example:
-		#
-		#   site = RestClient::Resource.new('http://example.com', 'adam', 'mypasswd')
-		#   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
-		#
-		# This is especially useful if you wish to define your site in one place and
-		# call it in multiple locations:
-		#
-		#   def orders
-		#     RestClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
-		#   end
-		#
-		#   orders.get                     # GET http://example.com/orders
-		#   orders['1'].get                # GET http://example.com/orders/1
-		#   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
-		#
-		# Nest resources as far as you want:
-		#
-		#   site = RestClient::Resource.new('http://example.com')
-		#   posts = site['posts']
-		#   first_post = posts['1']
-		#   comments = first_post['comments']
-		#   comments.post 'Hello', :content_type => 'text/plain'
-		#
-		def [](suburl)
-			self.class.new(concat_urls(url, suburl), options)
-		end
+    def open_timeout
+      options[:open_timeout]
+    end
 
-		def concat_urls(url, suburl)   # :nodoc:
-			url = url.to_s
-			suburl = suburl.to_s
-			if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
-				url + suburl
-			else
-				"#{url}/#{suburl}"
-			end
-		end
-	end
+    # Construct a subresource, preserving authentication.
+    #
+    # Example:
+    #
+    #   site = RestClient::Resource.new('http://example.com', 'adam', 'mypasswd')
+    #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+    #
+    # This is especially useful if you wish to define your site in one place and
+    # call it in multiple locations:
+    #
+    #   def orders
+    #     RestClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
+    #   end
+    #
+    #   orders.get                     # GET http://example.com/orders
+    #   orders['1'].get                # GET http://example.com/orders/1
+    #   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
+    #
+    # Nest resources as far as you want:
+    #
+    #   site = RestClient::Resource.new('http://example.com')
+    #   posts = site['posts']
+    #   first_post = posts['1']
+    #   comments = first_post['comments']
+    #   comments.post 'Hello', :content_type => 'text/plain'
+    #
+    def [](suburl)
+      self.class.new(concat_urls(url, suburl), options)
+    end
+
+    def concat_urls(url, suburl) # :nodoc:
+      url = url.to_s
+      suburl = suburl.to_s
+      if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
+        url + suburl
+      else
+        "#{url}/#{suburl}"
+      end
+    end
+  end
 end

data/lib/restclient/response.rb

@@ -1,20 +1,20 @@
 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
-	# the body, but on the occassion you want to fetch the headers you can:
-	#
-	#   RestClient.get('http://example.com').headers[:content_type]
-	#
-	class Response < String
+  # 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
+  # the body, but on the occassion you want to fetch the headers you can:
+  #
+  #   RestClient.get('http://example.com').headers[:content_type]
+  #
+  class Response < String
 
-		include RestClient::Mixin::Response
+    include RestClient::Mixin::Response
 
-		def initialize(string, net_http_res)
-			@net_http_res = net_http_res
-			super(string || "")
-		end
+    def initialize(string, net_http_res)
+      @net_http_res = net_http_res
+      super(string || "")
+    end
 
-	end
+  end
 end

data/spec/exceptions_spec.rb

@@ -1,65 +1,65 @@
 require File.dirname(__FILE__) + '/base'
 
 describe RestClient::Exception do
-	it "sets the exception message to ErrorMessage" do
-		RestClient::ResourceNotFound.new.message.should == 'Resource not found'
-	end
+  it "sets the exception message to ErrorMessage" do
+    RestClient::ResourceNotFound.new.message.should == 'Resource not found'
+  end
 
-	it "contains exceptions in RestClient" do
-		RestClient::Unauthorized.new.should be_a_kind_of(RestClient::Exception)
-		RestClient::ServerBrokeConnection.new.should be_a_kind_of(RestClient::Exception)
-	end
+  it "contains exceptions in RestClient" do
+    RestClient::Unauthorized.new.should be_a_kind_of(RestClient::Exception)
+    RestClient::ServerBrokeConnection.new.should be_a_kind_of(RestClient::Exception)
+  end
 end
 
 describe RestClient::RequestFailed do
-	before do
-		@response = mock('HTTP Response', :code => '502')
-	end
+  before do
+    @response = mock('HTTP Response', :code => '502')
+  end
 
-	it "stores the http response on the exception" do
-		begin
-			raise RestClient::RequestFailed, :response
-		rescue RestClient::RequestFailed => e
-			e.response.should == :response
-		end
-	end
+  it "stores the http response on the exception" do
+    begin
+      raise RestClient::RequestFailed, :response
+    rescue RestClient::RequestFailed => e
+      e.response.should == :response
+    end
+  end
 
-	it "http_code convenience method for fetching the code as an integer" do
-		RestClient::RequestFailed.new(@response).http_code.should == 502
-	end
+  it "http_code convenience method for fetching the code as an integer" do
+    RestClient::RequestFailed.new(@response).http_code.should == 502
+  end
 
-	it "http_body convenience method for fetching the body (decoding when necessary)" do
-		@response.stub!(:[]).with('content-encoding').and_return('gzip')
-		@response.stub!(:body).and_return('compressed body')
-		RestClient::Request.should_receive(:decode).with('gzip', 'compressed body').and_return('plain body')
-		RestClient::RequestFailed.new(@response).http_body.should == 'plain body'
-	end
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    @response.stub!(:[]).with('content-encoding').and_return('gzip')
+    @response.stub!(:body).and_return('compressed body')
+    RestClient::Request.should_receive(:decode).with('gzip', 'compressed body').and_return('plain body')
+    RestClient::RequestFailed.new(@response).http_body.should == 'plain body'
+  end
 
-	it "shows the status code in the message" do
-		RestClient::RequestFailed.new(@response).to_s.should match(/502/)
-	end
+  it "shows the status code in the message" do
+    RestClient::RequestFailed.new(@response).to_s.should match(/502/)
+  end
 end
 
 describe RestClient::ResourceNotFound do
-	it "also has the http response attached" do
-		begin
-			raise RestClient::ResourceNotFound, :response
-		rescue RestClient::ResourceNotFound => e
-			e.response.should == :response
-		end
-	end
+  it "also has the http response attached" do
+    begin
+      raise RestClient::ResourceNotFound, :response
+    rescue RestClient::ResourceNotFound => e
+      e.response.should == :response
+    end
+  end
 end
 
 describe "backwards compatibility" do
-	it "alias RestClient::Request::Redirect to RestClient::Redirect" do
-		RestClient::Request::Redirect.should == RestClient::Redirect
-	end
+  it "alias RestClient::Request::Redirect to RestClient::Redirect" do
+    RestClient::Request::Redirect.should == RestClient::Redirect
+  end
 
-	it "alias RestClient::Request::Unauthorized to RestClient::Unauthorized" do
-		RestClient::Request::Unauthorized.should == RestClient::Unauthorized
-	end
+  it "alias RestClient::Request::Unauthorized to RestClient::Unauthorized" do
+    RestClient::Request::Unauthorized.should == RestClient::Unauthorized
+  end
 
-	it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
-		RestClient::Request::RequestFailed.should == RestClient::RequestFailed
-	end
+  it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
+    RestClient::Request::RequestFailed.should == RestClient::RequestFailed
+  end
 end

data/spec/mixin/response_spec.rb

@@ -1,46 +1,46 @@
 require File.dirname(__FILE__) + '/../base'
 
 class MockResponse
-	include RestClient::Mixin::Response
+  include RestClient::Mixin::Response
 
-	def initialize(body, res)
-		@net_http_res = res
-		@body = @body
-	end
+  def initialize(body, res)
+    @net_http_res = res
+    @body = @body
+  end
 end
 
 describe RestClient::Mixin::Response do
-	before do
-		@net_http_res = mock('net http response')
-		@response = MockResponse.new('abc', @net_http_res)
-	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
+  before do
+    @net_http_res = mock('net http response')
+    @response = MockResponse.new('abc', @net_http_res)
+  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
 end