http 0.6.4 → 0.7.0

data/Rakefile

@@ -23,7 +23,7 @@ end
 require 'yardstick/rake/verify'
 Yardstick::Rake::Verify.new do |verify|
   verify.require_exact_threshold = false
-  verify.threshold = 58
+  verify.threshold = 58.8
 end
 
 task :default => [:spec, :rubocop, :verify_measurements]

data/examples/parallel_requests_with_celluloid.rb

@@ -21,7 +21,7 @@ end
 
 fetcher = HttpFetcher.new
 
-urls = %w[http://ruby-lang.org/ http://rubygems.org/ http://celluloid.io/]
+urls = %w(http://ruby-lang.org/ http://rubygems.org/ http://celluloid.io/)
 
 # Kick off a bunch of future calls to HttpFetcher to grab the URLs in parallel
 futures = urls.map { |u| [u, fetcher.future.fetch(u)] }

data/http.gemspec

@@ -3,8 +3,8 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'http/version'
 
 Gem::Specification.new do |gem|
-  gem.authors       = %w[Tony Arcieri]
-  gem.email         = %w[tony.arcieri@gmail.com]
+  gem.authors       = %w(Tony Arcieri)
+  gem.email         = %w(tony.arcieri@gmail.com)
 
   gem.description   = <<-DESCRIPTION.strip.gsub(/\s+/, ' ')
     An easy-to-use client library for making requests from Ruby.
@@ -13,17 +13,18 @@ Gem::Specification.new do |gem|
   DESCRIPTION
 
   gem.summary       = 'HTTP should be easy'
-  gem.homepage      = 'https://github.com/tarcieri/http'
-  gem.licenses      = %w[MIT]
+  gem.homepage      = 'https://github.com/tarcieri/http.rb'
+  gem.licenses      = %w(MIT)
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = 'http'
-  gem.require_paths = %w[lib]
+  gem.require_paths = %w(lib)
   gem.version       = HTTP::VERSION
 
   gem.add_runtime_dependency 'http_parser.rb', '~> 0.6.0'
+  gem.add_runtime_dependency 'form_data',      '~> 0.0.1'
 
   gem.add_development_dependency 'bundler', '~> 1.0'
 end

data/lib/http.rb

@@ -9,7 +9,6 @@ require 'http/request/writer'
 require 'http/response'
 require 'http/response/body'
 require 'http/response/parser'
-require 'http/backports'
 
 # HTTP should be easy
 module HTTP

data/lib/http/chainable.rb

@@ -1,58 +1,80 @@
-require 'http/authorization_header'
+require 'base64'
 
 module HTTP
   module Chainable
     # Request a get sans response body
+    # @param uri
+    # @option options [Hash]
     def head(uri, options = {})
       request :head, uri, options
     end
 
     # Get a resource
+    # @param uri
+    # @option options [Hash]
     def get(uri, options = {})
       request :get, uri, options
     end
 
     # Post to a resource
+    # @param uri
+    # @option options [Hash]
     def post(uri, options = {})
       request :post, uri, options
     end
 
     # Put to a resource
+    # @param uri
+    # @option options [Hash]
     def put(uri, options = {})
       request :put, uri, options
     end
 
     # Delete a resource
+    # @param uri
+    # @option options [Hash]
     def delete(uri, options = {})
       request :delete, uri, options
     end
 
     # Echo the request back to the client
+    # @param uri
+    # @option options [Hash]
     def trace(uri, options = {})
       request :trace, uri, options
     end
 
     # Return the methods supported on the given URI
+    # @param uri
+    # @option options [Hash]
     def options(uri, options = {})
       request :options, uri, options
     end
 
     # Convert to a transparent TCP/IP tunnel
+    # @param uri
+    # @option options [Hash]
     def connect(uri, options = {})
       request :connect, uri, options
     end
 
     # Apply partial modifications to a resource
+    # @param uri
+    # @option options [Hash]
     def patch(uri, options = {})
       request :patch, uri, options
     end
 
     # Make an HTTP request with the given verb
+    # @param uri
+    # @option options [Hash]
     def request(verb, uri, options = {})
       branch(options).request verb, uri
     end
 
     # Make a request through an HTTP proxy
+    # @param [Array] proxy
+    # @raise [Request::Error] if HTTP proxy is invalid
     def via(*proxy)
       proxy_hash = {}
       proxy_hash[:proxy_address]  = proxy[0] if proxy[0].is_a?(String)
@@ -74,68 +96,80 @@ module HTTP
     end
 
     # Make client follow redirects.
-    # @param opts (see Redirector#initialize)
+    # @param opts
     # @return [HTTP::Client]
+    # @see Redirector#initialize
     def follow(opts = true)
       branch default_options.with_follow opts
     end
 
-    # (see #follow)
     # @deprecated
+    # @see #follow
     alias_method :with_follow, :follow
 
     # Make a request with the given headers
+    # @param headers
     def with_headers(headers)
       branch default_options.with_headers(headers)
     end
     alias_method :with, :with_headers
 
     # Accept the given MIME type(s)
+    # @param type
     def accept(type)
       with :accept => MimeType.normalize(type)
     end
 
     # Make a request with the given Authorization header
-    def auth(*args)
-      value = case args.count
-              when 1 then args.first
-              when 2 then AuthorizationHeader.build(*args)
-              else fail ArgumentError, "wrong number of arguments (#{args.count} for 1..2)"
-              end
-
+    # @param [#to_s] value Authorization header value
+    def auth(value, opts = nil)
+      # shim for deprecated auth(:basic, opts).
+      # will be removed in 0.8.0
+      return basic_auth(opts) if :basic == value
       with :authorization => value.to_s
     end
 
+    # Make a request with the given Basic authorization header
+    # @see http://tools.ietf.org/html/rfc2617
+    # @param [#fetch] opts
+    # @option opts [#to_s] :user
+    # @option opts [#to_s] :pass
+    def basic_auth(opts)
+      user = opts.fetch :user
+      pass = opts.fetch :pass
+
+      auth('Basic ' << Base64.strict_encode64("#{user}:#{pass}"))
+    end
+
+    # Get options for HTTP
+    # @return [HTTP::Options]
     def default_options
       @default_options ||= HTTP::Options.new
     end
 
+    # Set options for HTTP
+    # @param opts
+    # @return [HTTP::Options]
     def default_options=(opts)
       @default_options = HTTP::Options.new(opts)
     end
 
+    # Get headers of HTTP options
     def default_headers
       default_options.headers
     end
 
+    # Set headers of HTTP options
+    # @param headers
     def default_headers=(headers)
       @default_options = default_options.dup do |opts|
         opts.headers = headers
       end
     end
 
-    def default_callbacks
-      default_options.callbacks
-    end
-
-    def default_callbacks=(callbacks)
-      @default_options = default_options.dup do |opts|
-        opts.callbacks = callbacks
-      end
-    end
-
   private
 
+    # :nodoc:
     def branch(options)
       HTTP::Client.new(options)
     end

data/lib/http/client.rb

@@ -1,5 +1,6 @@
 require 'cgi'
 require 'uri'
+require 'form_data'
 require 'http/options'
 require 'http/redirector'
 
@@ -51,7 +52,7 @@ module HTTP
 
       # TODO: keep-alive support
       @socket = options[:socket_class].open(req.socket_host, req.socket_port)
-      @socket = start_tls(@socket, uri.host, options) if uri.is_a?(URI::HTTPS)
+      @socket = start_tls(@socket, options) if uri.is_a?(URI::HTTPS) && !req.using_proxy?
 
       req.stream @socket
 
@@ -66,6 +67,9 @@ module HTTP
     end
 
     # Read a chunk of the body
+    #
+    # @return [String] data chunk
+    # @return [Nil] when no more data left
     def readpartial(size = BUFFER_SIZE)
       return unless @socket
 
@@ -86,17 +90,12 @@ module HTTP
   private
 
     # Initialize TLS connection
-    def start_tls(socket, host, options)
+    def start_tls(socket, options)
       # TODO: abstract away SSLContexts so we can use other TLS libraries
       context = options[:ssl_context] || OpenSSL::SSL::SSLContext.new
       socket  = options[:ssl_socket_class].new(socket, context)
 
       socket.connect
-
-      if context.verify_mode == OpenSSL::SSL::VERIFY_PEER
-        socket.post_connection_check(host)
-      end
-
       socket
     end
 
@@ -129,12 +128,15 @@ module HTTP
 
     # Create the request body object to send
     def make_request_body(opts, headers)
-      if opts.body
+      case
+      when opts.body
         opts.body
-      elsif opts.form
-        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
-        URI.encode_www_form(opts.form)
-      elsif opts.json
+      when opts.form
+        form = FormData.create opts.form
+        headers['Content-Type']   ||= form.content_type
+        headers['Content-Length'] ||= form.content_length
+        form.to_s
+      when opts.json
         headers['Content-Type'] ||= 'application/json'
         MimeType[:json].encode opts.json
       end

data/lib/http/headers.rb

@@ -122,24 +122,27 @@ module HTTP
       dup.tap { |dupped| dupped.merge! other }
     end
 
-    # Initiates new Headers object from given object.
-    #
-    # @raise [Error] if given object can't be coerced
-    # @param [#to_hash, #to_h, #to_a] object
-    # @return [Headers]
-    def self.coerce(object)
-      unless object.is_a? self
-        object = case
-                when object.respond_to?(:to_hash) then object.to_hash
-                when object.respond_to?(:to_h)    then object.to_h
-                when object.respond_to?(:to_a)    then object.to_a
-                else fail Error, "Can't coerce #{object.inspect} to Headers"
-                end
+    class << self
+      # Initiates new Headers object from given object.
+      #
+      # @raise [Error] if given object can't be coerced
+      # @param [#to_hash, #to_h, #to_a] object
+      # @return [Headers]
+      def coerce(object)
+        unless object.is_a? self
+          object = case
+                   when object.respond_to?(:to_hash) then object.to_hash
+                   when object.respond_to?(:to_h)    then object.to_h
+                   when object.respond_to?(:to_a)    then object.to_a
+                   else fail Error, "Can't coerce #{object.inspect} to Headers"
+                   end
+        end
+
+        headers = new
+        object.each { |k, v| headers.add k, v }
+        headers
       end
-
-      headers = new
-      object.each { |k, v| headers.add k, v }
-      headers
+      alias_method :[], :coerce
     end
 
   private

data/lib/http/mime_type/adapter.rb

@@ -12,7 +12,7 @@ module HTTP
         def_delegators :instance, :encode, :decode
       end
 
-      %w[encode decode].each do |operation|
+      %w(encode decode).each do |operation|
         class_eval <<-RUBY, __FILE__, __LINE__
           def #{operation}(*)
             fail Error, "\#{self.class} does not supports ##{operation}"

data/lib/http/options.rb

@@ -70,7 +70,7 @@ module HTTP
       end
     end
 
-    %w[proxy params form json body follow].each do |method_name|
+    %w(proxy params form json body follow).each do |method_name|
       class_eval <<-RUBY, __FILE__, __LINE__
         def with_#{method_name}(value)
           dup { |opts| opts.#{method_name} = value }

data/lib/http/request.rb

@@ -53,15 +53,11 @@ module HTTP
     # Scheme is normalized to be a lowercase symbol e.g. :http, :https
     attr_reader :scheme
 
-    # The following alias may be removed in three minor versions (0.8.0) or one
+    # The following alias may be removed in two minor versions (0.8.0) or one
     # major version (1.0.0)
-    alias_method :__method__, :method
-
-    # The following method may be removed in two minor versions (0.7.0) or one
-    # major version (1.0.0)
-    def method(*)
-      warn "#{Kernel.caller.first}: [DEPRECATION] HTTP::Request#method is deprecated. Use #verb instead. For Object#method, use #__method__."
-      @verb
+    def __method__(*args)
+      warn "#{Kernel.caller.first}: [DEPRECATION] HTTP::Request#__method__ is deprecated. Use #method instead."
+      method(*args)
     end
 
     # "Request URI" as per RFC 2616
@@ -73,7 +69,7 @@ module HTTP
     def initialize(verb, uri, headers = {}, proxy = {}, body = nil, version = '1.1') # rubocop:disable ParameterLists
       @verb   = verb.to_s.downcase.to_sym
       @uri    = uri.is_a?(URI) ? uri : URI(uri.to_s)
-      @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
+      @scheme = @uri.scheme && @uri.scheme.to_s.downcase.to_sym
 
       fail(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
       fail(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
@@ -118,13 +114,7 @@ module HTTP
 
     # Compute HTTP request header for direct or proxy request
     def request_header
-      if using_proxy?
-        "#{verb.to_s.upcase} #{uri} HTTP/#{version}"
-      else
-        path = uri.query && !uri.query.empty? ? "#{uri.path}?#{uri.query}" : uri.path
-        path = '/' if path.empty?
-        "#{verb.to_s.upcase} #{path} HTTP/#{version}"
-      end
+      "#{verb.to_s.upcase} #{path_for_request_header} HTTP/#{version}"
     end
 
     # Host for tcp socket
@@ -139,6 +129,23 @@ module HTTP
 
   private
 
+    def path_for_request_header
+      if using_proxy?
+        uri
+      else
+        uri_path_with_query
+      end
+    end
+
+    def uri_path_with_query
+      path = uri_has_query? ? "#{uri.path}?#{uri.query}" : uri.path
+      path.empty? ? '/' : path
+    end
+
+    def uri_has_query?
+      uri.query && !uri.query.empty?
+    end
+
     # Default host (with port if needed) header value.
     #
     # @return [String]

data/lib/http/request/writer.rb

@@ -34,13 +34,8 @@ module HTTP
       def add_body_type_headers
         if @body.is_a?(String) && !@headers['Content-Length']
           @request_header << "Content-Length: #{@body.bytesize}"
-        elsif @body.is_a?(Enumerable)
-          encoding = @headers['Transfer-Encoding']
-          if encoding == 'chunked'
-            @request_header << 'Transfer-Encoding: chunked'
-          else
-            fail(RequestError, 'invalid transfer encoding')
-          end
+        elsif @body.is_a?(Enumerable) && 'chunked' != @headers['Transfer-Encoding']
+          fail(RequestError, 'invalid transfer encoding')
         end
       end