http 0.5.1 → 0.6.0.pre

data/Rakefile

@@ -4,4 +4,26 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new
 
-task :default => :spec
+task :test => :spec
+
+begin
+  require 'rubocop/rake_task'
+  Rubocop::RakeTask.new
+rescue LoadError
+  task :rubocop do
+    $stderr.puts 'Rubocop is disabled'
+  end
+end
+
+require 'yardstick/rake/measurement'
+Yardstick::Rake::Measurement.new do |measurement|
+  measurement.output = 'measurement/report.txt'
+end
+
+require 'yardstick/rake/verify'
+Yardstick::Rake::Verify.new do |verify|
+  verify.require_exact_threshold = false
+  verify.threshold = 58
+end
+
+task :default => [:spec, :rubocop, :verify_measurements]

data/examples/parallel_requests_with_celluloid.rb

@@ -15,13 +15,13 @@ class HttpFetcher
   def fetch(url)
     # Note: For SSL support specify:
     # ssl_socket_class: Celluloid::IO::SSLSocket
-    HTTP.get(url, socket_class: Celluloid::IO::TCPSocket).response
+    HTTP.get(url, :socket_class => Celluloid::IO::TCPSocket).response
   end
 end
 
 fetcher = HttpFetcher.new
 
-urls = %w(http://www.ruby-lang.org/ http://www.rubygems.org/ http://celluloid.io/)
+urls = %w[http://www.ruby-lang.org/ http://www.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

@@ -1,23 +1,23 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/http/version', __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http/version'
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Tony Arcieri"]
-  gem.email         = ["tony.arcieri@gmail.com"]
-  gem.description   = "HTTP so awesome it will lure Catherine Zeta Jones into your unicorn petting zoo"
-  gem.summary       = "HTTP should be easy"
-  gem.homepage      = "https://github.com/tarcieri/http"
+  gem.authors       = %w[Tony Arcieri]
+  gem.email         = %w[tony.arcieri@gmail.com]
+  gem.description   = 'HTTP so awesome it will lure Catherine Zeta Jones into your unicorn petting zoo'
+  gem.summary       = 'HTTP should be easy'
+  gem.homepage      = 'https://github.com/tarcieri/http'
+  gem.licenses      = %w[MIT]
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  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 = ["lib"]
+  gem.name          = 'http'
+  gem.require_paths = %w[lib]
   gem.version       = HTTP::VERSION
 
-  gem.add_runtime_dependency 'http_parser.rb'
+  gem.add_runtime_dependency 'http_parser.rb', '~> 0.6.0'
 
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '>= 2.11'
-  gem.add_development_dependency 'json'
+  gem.add_development_dependency 'bundler', '~> 1.0'
 end

data/lib/http.rb

@@ -1,14 +1,15 @@
 require 'http/parser'
 
+require 'http/errors'
 require 'http/chainable'
 require 'http/client'
-require 'http/mime_type'
 require 'http/options'
 require 'http/request'
-require 'http/request_stream'
+require 'http/request/writer'
 require 'http/response'
-require 'http/response_parser'
-require 'http/uri_backport' if RUBY_VERSION < "1.9.0"
+require 'http/response/body'
+require 'http/response/parser'
+require 'http/backports' if RUBY_VERSION < '1.9.0'
 
 # HTTP should be easy
 module HTTP

data/lib/http/authorization_header.rb

@@ -0,0 +1,37 @@
+module HTTP
+  # Authorization header value builders
+  module AuthorizationHeader
+    class << self
+      # Associate type with given builder.
+      # @param [#to_sym] type
+      # @param [Class] klass
+      # @return [void]
+      def register(type, klass)
+        builders[type.to_sym] = klass
+      end
+
+      # Builds Authorization header value with associated builder.
+      # @param [#to_sym] type
+      # @param [Object] opts
+      # @return [String]
+      def build(type, opts)
+        klass = builders[type.to_sym]
+
+        fail Error, "Unknown authorization type #{type}" unless klass
+
+        klass.new opts
+      end
+
+    private
+
+      # :nodoc:
+      def builders
+        @builders ||= {}
+      end
+    end
+  end
+end
+
+# built-in builders
+require 'http/authorization_header/basic_auth'
+require 'http/authorization_header/bearer_token'

data/lib/http/authorization_header/basic_auth.rb

@@ -0,0 +1,24 @@
+require 'base64'
+
+module HTTP
+  module AuthorizationHeader
+    # Basic authorization header builder
+    # @see http://tools.ietf.org/html/rfc2617
+    class BasicAuth
+      # @param [#fetch] opts
+      # @option opts [#to_s] :user
+      # @option opts [#to_s] :pass
+      def initialize(opts)
+        @user = opts.fetch :user
+        @pass = opts.fetch :pass
+      end
+
+      # :nodoc:
+      def to_s
+        'Basic ' << Base64.strict_encode64("#{@user}:#{@pass}")
+      end
+    end
+
+    register :basic, BasicAuth
+  end
+end

data/lib/http/authorization_header/bearer_token.rb

@@ -0,0 +1,29 @@
+require 'base64'
+
+module HTTP
+  module AuthorizationHeader
+    # OAuth2 Bearer token authorization header builder
+    # @see http://tools.ietf.org/html/rfc6750
+    class BearerToken
+      # @param [#fetch] opts
+      # @option opts [#to_s] :token
+      # @option opts [#to_s] :encode (false)
+      def initialize(opts)
+        @encode = opts.fetch :encode, false
+        @token  = opts.fetch :token
+      end
+
+      def token
+        return Base64.strict_encode64 @token if @encode
+        @token
+      end
+
+      # :nodoc:
+      def to_s
+        "Bearer #{token}"
+      end
+    end
+
+    register :bearer, BearerToken
+  end
+end

data/lib/http/backports.rb

@@ -0,0 +1,2 @@
+require 'http/backports/uri'
+require 'http/backports/base64'

data/lib/http/backports/base64.rb

@@ -0,0 +1,6 @@
+module Base64
+  # :nodoc:
+  def self.strict_encode64(data)
+    encode64(data).gsub(/\n/, '')
+  end
+end

data/lib/http/{uri_backport.rb → backports/uri.rb}

@@ -9,17 +9,17 @@ require 'uri'
 module URI
   TBLENCWWWCOMP_ = {} # :nodoc:
   256.times do |i|
-    TBLENCWWWCOMP_[i.chr] = '%%%02X' % i
+    TBLENCWWWCOMP_[i.chr] = format('%%%02X', i)
   end
   TBLENCWWWCOMP_[' '] = '+'
   TBLENCWWWCOMP_.freeze
   TBLDECWWWCOMP_ = {} # :nodoc:
   256.times do |i|
-    h, l = i>>4, i&15
-    TBLDECWWWCOMP_['%%%X%X' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%x%X' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%X%x' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%x%x' % [h, l]] = i.chr
+    h, l = i >> 4, i & 15
+    TBLDECWWWCOMP_[format('%%%X%X', h, l)] = i.chr
+    TBLDECWWWCOMP_[format('%%%x%X', h, l)] = i.chr
+    TBLDECWWWCOMP_[format('%%%X%x', h, l)] = i.chr
+    TBLDECWWWCOMP_[format('%%%x%x', h, l)] = i.chr
   end
   TBLDECWWWCOMP_['+'] = ' '
   TBLDECWWWCOMP_.freeze
@@ -43,7 +43,7 @@ module URI
   #
   # See URI.encode_www_form_component, URI.decode_www_form
   def self.decode_www_form_component(str)
-    raise ArgumentError, "invalid %-encoding (#{str})" unless /\A[^%]*(?:%\h\h[^%]*)*\z/ =~ str
+    fail(ArgumentError, "invalid %-encoding (#{str})") unless /\A[^%]*(?:%\h\h[^%]*)*\z/ =~ str
     str.gsub(/\+|%\h\h/) { |chr| TBLDECWWWCOMP_[chr] }
   end
 
@@ -76,7 +76,7 @@ module URI
   #
   # See URI.encode_www_form_component, URI.decode_www_form
   def self.encode_www_form(enum)
-    enum.map do |k,v|
+    enum.map do |k, v|
       if v.nil?
         encode_www_form_component(k)
       elsif v.respond_to?(:to_ary)
@@ -120,11 +120,11 @@ module URI
   def self.decode_www_form(str)
     return [] if str.empty?
     unless /\A#{WFKV_}=#{WFKV_}(?:[;&]#{WFKV_}=#{WFKV_})*\z/o =~ str
-      raise ArgumentError, "invalid data of application/x-www-form-urlencoded (#{str})"
+      fail(ArgumentError, "invalid data of application/x-www-form-urlencoded (#{str})")
     end
     ary = []
     $&.scan(/([^=;&]+)=([^;&]*)/) do
-      ary << [decode_www_form_component($1), decode_www_form_component($2)]
+      ary << [decode_www_form_component(Regexp.last_match[1]), decode_www_form_component(Regexp.last_match[2])]
     end
     ary
   end

data/lib/http/chainable.rb

@@ -1,3 +1,5 @@
+require 'http/authorization_header'
+
 module HTTP
   module Chainable
     # Request a get sans response body
@@ -50,34 +52,26 @@ module HTTP
       branch(options).request verb, uri
     end
 
-    # Make a request invoking the given event callbacks
-    def on(event, &block)
-      branch default_options.with_callback(event, block)
-    end
-
     # Make a request through an HTTP proxy
     def via(*proxy)
       proxy_hash = {}
-      proxy_hash[:proxy_address] = proxy[0] if proxy[0].is_a? String
-      proxy_hash[:proxy_port]    = proxy[1] if proxy[1].is_a? Integer
-      proxy_hash[:proxy_username]= proxy[2] if proxy[2].is_a? String
-      proxy_hash[:proxy_password]= proxy[3] if proxy[3].is_a? String
+      proxy_hash[:proxy_address]  = proxy[0] if proxy[0].is_a?(String)
+      proxy_hash[:proxy_port]     = proxy[1] if proxy[1].is_a?(Integer)
+      proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
+      proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
 
-      if proxy_hash.keys.size >=2
+      if [2, 4].include?(proxy_hash.keys.size)
         branch default_options.with_proxy(proxy_hash)
       else
-        raise ArgumentError, "invalid HTTP proxy: #{proxy_hash}"
+        fail(RequestError, "invalid HTTP proxy: #{proxy_hash}")
       end
     end
     alias_method :through, :via
 
-    # Specify the kind of response to return (:auto, :object, :body, :parsed_body)
-    def with_response(response_type)
-      branch default_options.with_response(response_type)
-    end
-
     # Alias for with_response(:object)
-    def stream; with_response(:object); end
+    def stream
+      with_response(:object)
+    end
 
     def with_follow(follow)
       branch default_options.with_follow(follow)
@@ -91,13 +85,18 @@ module HTTP
 
     # Accept the given MIME type(s)
     def accept(type)
-      if type.is_a? String
-        with :accept => type
-      else
-        mime_type = HTTP::MimeType[type]
-        raise ArgumentError, "unknown MIME type: #{type}" unless mime_type
-        with :accept => mime_type.type
-      end
+      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
+
+      with :authorization => value.to_s
     end
 
     def default_options
@@ -128,7 +127,7 @@ module HTTP
       end
     end
 
-    private
+  private
 
     def branch(options)
       HTTP::Client.new(options)

data/lib/http/client.rb

@@ -7,108 +7,138 @@ module HTTP
   class Client
     include Chainable
 
-    BUFFER_SIZE = 4096 # Input buffer size
+    # Input buffer size
+    BUFFER_SIZE = 16_384
 
     attr_reader :default_options
 
     def initialize(default_options = {})
       @default_options = HTTP::Options.new(default_options)
-    end
-
-    def body(opts, headers)
-      if opts.body
-        body = opts.body
-      elsif opts.form
-        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
-        body = URI.encode_www_form(opts.form)
-      end
+      @parser = HTTP::Response::Parser.new
+      @socket = nil
     end
 
     # Make an HTTP request
-    def request(method, uri, options = {})
+    def request(verb, uri, options = {})
       opts = @default_options.merge(options)
-      host = URI.parse(uri).host
-      opts.headers["Host"] = host
       headers = opts.headers
       proxy = opts.proxy
 
-      method_body = body(opts, headers)
-      if opts.params && !opts.params.empty?
-        uri="#{uri}?#{URI.encode_www_form(opts.params)}"
-      end
+      request_body = make_request_body(opts, headers)
+      uri, opts = normalize_get_params(uri, opts) if verb == :get
+
+      uri = "#{uri}?#{URI.encode_www_form(opts.params)}" if opts.params && !opts.params.empty?
 
-      request = HTTP::Request.new method, uri, headers, proxy, method_body
-      opts.callbacks[:request].each { |c| c.call(request) }
+      request = HTTP::Request.new(verb, uri, headers, proxy, request_body)
+      perform request, opts
+    end
 
-      response = perform request, opts
+    # Perform the HTTP request (following redirects if needed)
+    def perform(req, options)
+      res = perform_without_following_redirects req, options
 
-      if opts.follow
-        response = Redirector.new(opts.follow).perform request, response do |req|
-          perform req, opts
+      if options.follow
+        res = Redirector.new(options.follow).perform req, res do |request|
+          perform_without_following_redirects request, options
         end
       end
 
-      opts.callbacks[:response].each { |c| c.call(response) }
-      format_response method, response, opts.response
+      res
     end
 
-    def perform(request, options)
-      parser = HTTP::Response::Parser.new
-      uri = request.uri
-      socket = options[:socket_class].open(uri.host, uri.port) # TODO: proxy support
+    # Read a chunk of the body
+    def readpartial(size = BUFFER_SIZE)
+      return unless @socket
 
-      if uri.is_a?(URI::HTTPS)
-        if options[:ssl_context] == nil
-          context = OpenSSL::SSL::SSLContext.new
-        else
-          context = options[:ssl_context]
-        end
-        socket = options[:ssl_socket_class].new(socket, context)
-        socket.connect
-      end
+      read_more size
+      chunk = @parser.chunk
+
+      finish_response if @parser.finished?
+
+      chunk
+    end
+
+  private
+
+    # Perform a single (no follow) HTTP request
+    def perform_without_following_redirects(req, options)
+      # finish previous response if client was re-used
+      # TODO: this is pretty wrong, as socket shoud be part of response
+      #       connection, so that re-use of client will not break multiple
+      #       chunked responses
+      finish_response
 
-      request.stream socket
+      uri = req.uri
+
+      # TODO: keep-alive support
+      @socket = options[:socket_class].open(req.socket_host, req.socket_port)
+      @socket = start_tls(@socket, options) if uri.is_a?(URI::HTTPS)
+
+      req.stream @socket
 
       begin
-        parser << socket.readpartial(BUFFER_SIZE) until parser.headers
+        read_more BUFFER_SIZE until @parser.headers
       rescue IOError, Errno::ECONNRESET, Errno::EPIPE => ex
         raise IOError, "problem making HTTP request: #{ex}"
       end
 
-      response = HTTP::Response.new(parser.status_code, parser.http_version, parser.headers) do
-        if !parser.finished? || (@body_remaining && @body_remaining > 0)
-          chunk = parser.chunk || begin
-            parser << socket.readpartial(BUFFER_SIZE)
-            parser.chunk || ""
-          end
+      body = Response::Body.new(self)
+      res  = Response.new(@parser.status_code, @parser.http_version, @parser.headers, body, uri)
 
-          @body_remaining -= chunk.length if @body_remaining
-          @body_remaining = nil if @body_remaining && @body_remaining < 1
+      finish_response if :head == req.verb
 
-          chunk
-        end
+      res
+    end
+
+    # Initialize TLS connection
+    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
+      socket
+    end
+
+    # Create the request body object to send
+    def make_request_body(opts, headers)
+      if opts.body
+        opts.body
+      elsif opts.form
+        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
+        URI.encode_www_form(opts.form)
+      elsif opts.json
+        headers['Content-Type'] ||= 'application/json'
+        MimeType[:json].encode opts.json
       end
+    end
 
-      @body_remaining = Integer(response['Content-Length']) if response['Content-Length']
-      response
+    # Callback for when we've reached the end of a response
+    def finish_response
+      @socket.close if @socket && !@socket.closed?
+      @parser.reset
+
+      @socket = nil
     end
 
-    def format_response(method, response, option)
-      case option
-      when :auto, NilClass
-        if method == :head
-          response
-        else
-          HTTP::Response::BodyDelegator.new(response, response.parse_body)
-        end
-      when :object
-        response
-      when :parsed_body
-        HTTP::Response::BodyDelegator.new(response, response.parse_body)
-      when :body
-        HTTP::Response::BodyDelegator.new(response)
-      else raise ArgumentError, "invalid response type: #{option}"
+    # Feeds some more data into parser
+    def read_more(size)
+      @parser << @socket.readpartial(size) unless @parser.finished?
+      return true
+    rescue EOFError
+      return false
+    end
+
+    # Moves uri get params into the opts.params hash
+    # @return [Array<URI, Hash>]
+    def normalize_get_params(uri, opts)
+      uri = URI(uri) unless uri.is_a?(URI)
+      if uri.query
+        extracted_params_from_uri = Hash[URI.decode_www_form(uri.query)]
+        opts = opts.with_params(extracted_params_from_uri.merge(opts.params || {}))
+        uri.query = nil
       end
+      [uri, opts]
     end
   end
 end