rest-client-next 1.1.0 → 1.3.0

data/lib/restclient/mixin/response.rb

@@ -1,48 +1,64 @@
 module RestClient
-	module Mixin
-		module Response
-			attr_reader :net_http_res
+  module Mixin
+    module Response
+      attr_reader :net_http_res
 
-			# HTTP status code, always 200 since RestClient throws exceptions for
-			# other codes.
-			def code
-				@code ||= @net_http_res.code.to_i
-			end
+      # HTTP status code
+      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
+      # 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
 
-			# The raw headers.
-			def raw_headers
-				@raw_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|
-					key, val = raw_c.split('=')
-					unless %w(expires domain path secure).member?(key)
-						out[key] = val
-					end
-					out
-				end
-			end
+      # Hash of cookies extracted from response headers
+      def cookies
+        @cookies ||= (self.headers[:set_cookie] || []).inject({}) do |out, cookie_content|
+          # correctly parse comma-separated cookies containing HTTP dates (which also contain a comma)
+          cookie_content.split(/,\s*/).inject([""]) { |array, blob| 
+            blob =~ /expires=.+?$/ ? array.push(blob) : array.last.concat(blob)
+            array
+          }.each do |cookie|
+            next if cookie.empty?
+            key, *val = cookie.split(";").first.split("=")
+            out[key] = val.join("=")
+          end
+          out
+        end
+      end
 
-			def self.included(receiver)
-				receiver.extend(RestClient::Mixin::Response::ClassMethods)
-			end
+      # Return the default behavior corresponding to the response code:
+      # the response itself for code in 200..206 and an exception in other cases
+      def return!
+        if (200..206).include? code
+          self
+        elsif Exceptions::EXCEPTIONS_MAP[code]
+          raise Exceptions::EXCEPTIONS_MAP[code], self
+        else
+          raise RequestFailed, self
+        end
+      end
 
-			module ClassMethods
-				def beautify_headers(headers)
-					headers.inject({}) do |out, (key, value)|
-						out[key.gsub(/-/, '_').downcase.to_sym] = value.first
-					out
-					end
-				end
-			end
-		end
-	end
+      def self.included(receiver)
+        receiver.extend(RestClient::Mixin::Response::ClassMethods)
+      end
+
+      module ClassMethods
+        def beautify_headers(headers)
+          headers.inject({}) do |out, (key, value)|
+            out[key.gsub(/-/, '_').downcase.to_sym] = %w{set-cookie}.include?(key.downcase) ? value : value.first
+            out
+          end
+        end
+      end
+    end
+  end
 end

data/lib/restclient/net_http_ext.rb

@@ -6,16 +6,16 @@
 # http://www.missiondata.com/blog/ruby/29/streaming-data-to-s3-with-ruby/
 
 module Net
-	class HTTP
-		alias __request__ request
+  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
+    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

@@ -1,171 +1,178 @@
-require "tempfile"
-require "stringio"
-require "mime/types"
+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
+  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
+
+      def short_inspect
+        (size > 100 ? "#{size} byte length" : inspect)
+      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: 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: 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