agiley-faraday_middleware 0.8.3.2 → 0.9.0

data/.gitignore

@@ -1,6 +1,7 @@
 # Mac OS X
 .DS_Store
 
+# RVM
 .rvmrc
 
 # TextMate
@@ -21,13 +22,12 @@ rdoc
 doc
 log
 .yardoc
+tmp
 
 # Bundler
-*.gem
 .bundle
 Gemfile.lock
 pkg
-*.gem
 
 # Rubinius
 *.rbc

data/.rspec

@@ -1,2 +1,3 @@
 --color
---backtrace
+--fail-fast
+--order random

data/.travis.yml

@@ -1,7 +1,10 @@
+language: ruby
 rvm:
+  - rbx-18mode
+  - rbx-19mode
+  - jruby-18mode
+  - jruby-19mode
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - jruby
-  - rbx
-  - ree
+  - ruby-head

data/Gemfile

@@ -1,6 +1,10 @@
 source 'http://rubygems.org'
 
-gem 'simplecov' unless ENV['CI']
+platforms :mri_19 do
+  gem 'simplecov'
+  gem 'cane', '~> 2.2.2'
+end
+
 gem 'json', :platforms => [:ruby_18, :jruby]
 gem 'jruby-openssl', '~> 0.7', :platforms => :jruby
 

data/Rakefile

@@ -1,6 +1,8 @@
-#!/usr/bin/env rake
-
-task :default => [:enable_coverage, :spec, :test]
+if defined? RUBY_ENGINE and 'ruby' == RUBY_ENGINE and RUBY_VERSION.index('1.9') == 0
+  task :default => [:enable_coverage, :spec, :test, :quality]
+else
+  task :default => [:spec, :test]
+end
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
@@ -9,9 +11,19 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :enable_coverage do
-  ENV['COVERAGE'] = 'yes' unless ENV['CI']
+  ENV['COVERAGE'] = 'yes'
 end
 
+desc %(Run Test::Unit tests)
 task :test do
   sh 'ruby', '-Ilib', 'spec/caching_test.rb'
 end
+
+desc %(Check code quality metrics with Cane)
+task :quality do
+  sh 'cane',
+    '--abc-max=15',
+    '--style-measure=110',
+    '--gte=coverage/covered_percent,99',
+    '--max-violations=0'
+end

data/faraday_middleware.gemspec

@@ -21,4 +21,4 @@ Gem::Specification.new do |gem|
   gem.summary = gem.description
   gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.version  = FaradayMiddleware::VERSION
-end
+end

data/lib/faraday_middleware.rb

@@ -4,16 +4,18 @@ module FaradayMiddleware
   autoload :OAuth,              'faraday_middleware/request/oauth'
   autoload :OAuth2,             'faraday_middleware/request/oauth2'
   autoload :EncodeJson,         'faraday_middleware/request/encode_json'
+  autoload :MethodOverride,     'faraday_middleware/request/method_override'
   autoload :Mashify,            'faraday_middleware/response/mashify'
   autoload :Rashify,            'faraday_middleware/response/rashify'
   autoload :ParseJson,          'faraday_middleware/response/parse_json'
   autoload :ParseXml,           'faraday_middleware/response/parse_xml'
   autoload :ParseNokogiriXml,   'faraday_middleware/response/parse_nokogiri_xml'
   autoload :ParseNokogiriHtml,  'faraday_middleware/response/parse_nokogiri_html'
-  autoload :ForceUtf,           'faraday_middleware/response/force_utf'
   autoload :ParseMarshal,       'faraday_middleware/response/parse_marshal'
   autoload :ParseYaml,          'faraday_middleware/response/parse_yaml'
+  autoload :ParseDates,         'faraday_middleware/response/parse_dates'
   autoload :Caching,            'faraday_middleware/response/caching'
+  autoload :Chunked,            'faraday_middleware/response/chunked'
   autoload :RackCompatible,     'faraday_middleware/rack_compatible'
   autoload :FollowRedirects,    'faraday_middleware/response/follow_redirects'
   autoload :Instrumentation,    'faraday_middleware/instrumentation'
@@ -22,25 +24,27 @@ module FaradayMiddleware
     Faraday.register_middleware :request,
       :oauth    => lambda { OAuth },
       :oauth2   => lambda { OAuth2 },
-      :json     => lambda { EncodeJson }
+      :json     => lambda { EncodeJson },
+      :method_override => lambda { MethodOverride }
 
     Faraday.register_middleware :response,
-      :mashify          =>  lambda { Mashify },
-      :rashify          =>  lambda { Rashify },
-      :json             =>  lambda { ParseJson },
-      :json_fix         =>  lambda { ParseJson::MimeTypeFix },
-      :xml              =>  lambda { ParseXml },
+      :mashify  => lambda { Mashify },
+      :rashify  => lambda { Rashify },
+      :json     => lambda { ParseJson },
+      :json_fix => lambda { ParseJson::MimeTypeFix },
+      :xml      => lambda { ParseXml },
       :nokogiri_xml     =>  lambda { ParseNokogiriXml },
       :nokogiri_html    =>  lambda { ParseNokogiriHtml },
-      :force_utf        =>  lambda { ForceUtf },
-      :marshal          =>  lambda { ParseMarshal },
-      :yaml             =>  lambda { ParseYaml },
-      :caching          =>  lambda { Caching },
-      :follow_redirects =>  lambda { FollowRedirects }
+      :marshal  => lambda { ParseMarshal },
+      :yaml     => lambda { ParseYaml },
+      :dates    => lambda { ParseDates },
+      :caching  => lambda { Caching },
+      :follow_redirects => lambda { FollowRedirects },
+      :chunked => lambda { Chunked }
 
     Faraday.register_middleware \
       :instrumentation  => lambda { Instrumentation }
   end
 end
 
-require 'faraday_middleware/backwards_compatibility'
+require 'faraday_middleware/backwards_compatibility'

data/lib/faraday_middleware/instrumentation.rb

@@ -7,10 +7,10 @@ module FaradayMiddleware
   #
   # Examples
   #
-  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, start_time, end_time, _, env|
+  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
   #     url = env[:url]
   #     http_method = env[:method].to_s.upcase
-  #     duration = end_time - start_time
+  #     duration = ends - starts
   #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
   #   end
   class Instrumentation < Faraday::Middleware

data/lib/faraday_middleware/rack_compatible.rb

@@ -26,11 +26,7 @@ module FaradayMiddleware
 
     # faraday to rack-compatible
     def prepare_env(env)
-      env[:request_headers].each do |name, value|
-        name = name.upcase.tr('-', '_')
-        name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
-        env[name] = value
-      end
+      headers_to_rack(env)
 
       url = env[:url]
       env['rack.url_scheme'] = url.scheme
@@ -44,6 +40,14 @@ module FaradayMiddleware
       env
     end
 
+    def headers_to_rack(env)
+      env[:request_headers].each do |name, value|
+        name = name.upcase.tr('-', '_')
+        name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
+        env[name] = value
+      end
+    end
+
     # rack to faraday-compatible
     def restore_env(env)
       headers = env[:request_headers]
@@ -63,13 +67,14 @@ module FaradayMiddleware
 
     def finalize_response(env, rack_response)
       status, headers, body = rack_response
-      body = body.inject('') { |str, part| str << part }
+      body = body.inject() { |str, part| str << part }
       headers = Faraday::Utils::Headers.new(headers) unless Faraday::Utils::Headers === headers
 
-      response_env = { :status => status, :body => body, :response_headers => headers }
+      env.update :status => status.to_i,
+                 :body => body,
+                 :response_headers => headers
 
-      env[:response] ||= Faraday::Response.new({})
-      env[:response].env.update(response_env)
+      env[:response] ||= Faraday::Response.new(env)
       env[:response]
     end
   end

data/lib/faraday_middleware/request/encode_json.rb

@@ -12,7 +12,9 @@ module FaradayMiddleware
     CONTENT_TYPE = 'Content-Type'.freeze
     MIME_TYPE    = 'application/json'.freeze
 
-    dependency 'json'
+    dependency do
+      require 'json' unless defined?(::JSON)
+    end
 
     def call(env)
       match_content_type(env) do |data|
@@ -22,7 +24,7 @@ module FaradayMiddleware
     end
 
     def encode(data)
-      JSON.dump data
+      ::JSON.dump data
     end
 
     def match_content_type(env)

data/lib/faraday_middleware/request/method_override.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # Public: Writes the original HTTP method to "X-Http-Method-Override" header
+  # and sends the request as POST.
+  #
+  # This can be used to work around technical issues with making non-POST
+  # requests, e.g. faulty HTTP client or server router.
+  #
+  # This header is recognized in Rack apps by default, courtesy of the
+  # Rack::MethodOverride module. See
+  # http://rack.rubyforge.org/doc/classes/Rack/MethodOverride.html
+  class MethodOverride < Faraday::Middleware
+
+    HEADER = "X-Http-Method-Override".freeze
+
+    # Public: Initialize the middleware.
+    #
+    # app     - the Faraday app to wrap
+    # options - (optional)
+    #           :rewrite - Array of HTTP methods to rewrite
+    #                      (default: all but GET and POST)
+    def initialize(app, options = nil)
+      super(app)
+      @methods = options && options.fetch(:rewrite).map { |method|
+        method = method.downcase if method.respond_to? :downcase
+        method.to_sym
+      }
+    end
+
+    def call(env)
+      method = env[:method]
+      rewrite_request(env, method) if rewrite_request?(method)
+      @app.call(env)
+    end
+
+    def rewrite_request?(method)
+      if @methods.nil? or @methods.empty?
+        method != :get and method != :post
+      else
+        @methods.include? method
+      end
+    end
+
+    # Internal: Write the original HTTP method to header, change method to POST.
+    def rewrite_request(env, original_method)
+      env[:request_headers][HEADER] = original_method.to_s.upcase
+      env[:method] = :post
+    end
+  end
+end

data/lib/faraday_middleware/request/oauth.rb

@@ -1,4 +1,5 @@
 require 'faraday'
+require 'forwardable'
 
 module FaradayMiddleware
   # Public: Uses the simple_oauth library to sign requests according the
@@ -11,14 +12,25 @@ module FaradayMiddleware
   # The signature is added to the "Authorization" HTTP request header. If the
   # value for this header already exists, it is not overriden.
   #
-  # For requests that have parameters in the body, such as POST, this
-  # middleware expects them to be in Hash form, i.e. not encoded to string.
-  # This means this middleware has to be positioned on the stack before any
-  # encoding middleware such as UrlEncoded.
+  # If no Content-Type header is specified, this middleware assumes that
+  # request body parameters should be included while signing the request.
+  # Otherwise, it only includes them if the Content-Type is
+  # "application/x-www-form-urlencoded", as per OAuth 1.0.
+  #
+  # For better performance while signing requests, this middleware should be
+  # positioned before UrlEncoded middleware on the stack, but after any other
+  # body-encoding middleware (such as EncodeJson).
   class OAuth < Faraday::Middleware
     dependency 'simple_oauth'
 
     AUTH_HEADER = 'Authorization'.freeze
+    CONTENT_TYPE = 'Content-Type'.freeze
+    TYPE_URLENCODED = 'application/x-www-form-urlencoded'.freeze
+
+    extend Forwardable
+    parser_method = :parse_nested_query
+    parser_module = ::Faraday::Utils.respond_to?(parser_method) ? 'Faraday::Utils' : 'Rack::Utils'
+    def_delegator parser_module, parser_method
 
     def initialize(app, options)
       super(app)
@@ -50,7 +62,18 @@ module FaradayMiddleware
     end
 
     def body_params(env)
-      env[:body] || {}
+      if include_body_params?(env)
+        if env[:body].respond_to?(:to_str)
+          parse_nested_query env[:body]
+        else
+          env[:body]
+        end
+      end || {}
+    end
+
+    def include_body_params?(env)
+      # see RFC 5489, section 3.4.1.3.1 for details
+      !(type = env[:request_headers][CONTENT_TYPE]) or type == TYPE_URLENCODED
     end
 
     def signature_params(params)

data/lib/faraday_middleware/response/caching.rb

@@ -68,8 +68,13 @@ module FaradayMiddleware
     end
 
     def finalize_response(response, env)
-      response = env[:response] = response.dup if response.frozen?
-      response.apply_request env unless response.env[:method]
+      response = response.dup if response.frozen?
+      env[:response] = response
+      unless env[:response_headers]
+        env.update response.env
+        # FIXME: omg hax
+        response.instance_variable_set('@env', env)
+      end
       response
     end
   end

data/lib/faraday_middleware/response/chunked.rb

@@ -0,0 +1,29 @@
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  # Public: Parse a Transfer-Encoding: Chunked response to just the original data
+  class Chunked < FaradayMiddleware::ResponseMiddleware
+    TRANSFER_ENCODING = 'transfer-encoding'.freeze
+
+    define_parser do |raw_body|
+      decoded_body = []
+      until raw_body.empty?
+        chunk_len, raw_body = raw_body.split("\r\n", 2)
+        chunk_len = chunk_len.split(';',2).first.hex
+        break if chunk_len == 0
+        decoded_body << raw_body[0, chunk_len]
+        # The 2 is to strip the extra CRLF at the end of the chunk
+        raw_body = raw_body[chunk_len + 2, raw_body.length - chunk_len - 2]
+      end
+      decoded_body.join('')
+    end
+
+    def parse_response?(env)
+      super and chunked_encoding?(env[:response_headers])
+    end
+
+    def chunked_encoding?(headers)
+      encoding = headers[TRANSFER_ENCODING] and encoding.split(',').include?('chunked')
+    end
+  end
+end

data/lib/faraday_middleware/response/follow_redirects.rb

@@ -1,6 +1,8 @@
 require 'faraday'
+require 'set'
 
 module FaradayMiddleware
+  # Public: Exception thrown when the maximum amount of requests is exceeded.
   class RedirectLimitReached < Faraday::Error::ClientError
     attr_reader :response
 
@@ -10,10 +12,34 @@ module FaradayMiddleware
     end
   end
 
-  # Public: Follow HTTP 30x redirects.
+  # Public: Follow HTTP 301, 302, 303, and 307 redirects for GET, PATCH, POST,
+  # PUT, and DELETE requests.
+  #
+  # This middleware does not follow the HTTP specification for HTTP 302, by
+  # default, in that it follows the improper implementation used by most major
+  # web browsers which forces the redirected request to become a GET request
+  # regardless of the original request method.
+  #
+  # For HTTP 301, 302, and 303, the original request is transformed into a
+  # GET request to the response Location, by default. However, with standards
+  # compliance enabled, a 302 will instead act in accordance with the HTTP
+  # specification, which will replay the original request to the received
+  # Location, just as with a 307.
+  #
+  # For HTTP 307, the original request is replayed to the response Location,
+  # including original HTTP request method (GET, POST, PUT, DELETE, PATCH),
+  # original headers, and original body.
+  #
+  # This middleware currently only works with synchronous requests; in other
+  # words, it doesn't support parallelism.
   class FollowRedirects < Faraday::Middleware
-    # TODO: 307 & standards-compliant 302
-    REDIRECTS = [301, 302, 303]
+    # HTTP methods for which 30x redirects can be followed
+    ALLOWED_METHODS = Set.new [:head, :options, :get, :post, :put, :patch, :delete]
+    # HTTP redirect status codes that this middleware implements
+    REDIRECT_CODES  = Set.new [301, 302, 303, 307]
+    # Keys in env hash which will get cleared between requests
+    ENV_TO_CLEAR    = Set.new [:status, :response, :response_headers]
+
     # Default value for max redirects followed
     FOLLOW_LIMIT = 3
 
@@ -21,33 +47,96 @@ module FaradayMiddleware
     #
     # options - An options Hash (default: {}):
     #           limit - A Numeric redirect limit (default: 3)
+    #           standards_compliant - A Boolean indicating whether to respect
+    #                                 the HTTP spec when following 302
+    #                                 (default: false)
+    #          cookie - Use either an array of strings
+    #                  (e.g. ['cookie1', 'cookie2']) to choose kept cookies
+    #                  or :all to keep all cookies.
     def initialize(app, options = {})
       super(app)
       @options = options
+
+      @replay_request_codes = Set.new [307]
+      @replay_request_codes << 302 if standards_compliant?
     end
 
     def call(env)
-      process_response(@app.call(env), follow_limit)
+      perform_with_redirection(env, follow_limit)
+    end
+
+    private
+
+    def transform_into_get?(response)
+      return false if [:head, :options].include? response.env[:method]
+      # Never convert head or options to a get. That would just be silly.
+
+      !@replay_request_codes.include? response.status
     end
 
-    def process_response(response, follows)
+    def perform_with_redirection(env, follows)
+      request_body = env[:body]
+      response = @app.call(env)
+
       response.on_complete do |env|
-        if redirect? response
+        if follow_redirect?(env, response)
           raise RedirectLimitReached, response if follows.zero?
-          env[:url] += response['location']
-          env[:method] = :get
-          response = process_response(@app.call(env), follows - 1)
+          env = update_env(env, request_body, response)
+          response = perform_with_redirection(env, follows - 1)
         end
       end
       response
     end
 
-    def redirect?(response)
-      REDIRECTS.include? response.status
+    def update_env(env, request_body, response)
+      env[:url] += response['location']
+      if @options[:cookies]
+        cookies = keep_cookies(env)
+        env[:request_headers][:cookies] = cookies unless cookies.nil?
+      end
+
+      if transform_into_get?(response)
+        env[:method] = :get
+        env[:body] = nil
+      else
+        env[:body] = request_body
+      end
+
+      ENV_TO_CLEAR.each {|key| env.delete key }
+
+      env
+    end
+
+    def follow_redirect?(env, response)
+      ALLOWED_METHODS.include? env[:method] and
+        REDIRECT_CODES.include? response.status
     end
 
     def follow_limit
       @options.fetch(:limit, FOLLOW_LIMIT)
     end
+
+    def keep_cookies(env)
+      cookies = @options.fetch(:cookies, [])
+      response_cookies = env[:response_headers][:cookies]
+      cookies == :all ? response_cookies : selected_request_cookies(response_cookies)
+    end
+
+    def selected_request_cookies(cookies)
+      selected_cookies(cookies)[0...-1]
+    end
+
+    def selected_cookies(cookies)
+      "".tap do |cookie_string|
+        @options[:cookies].each do |cookie|
+          string = /#{cookie}=?[^;]*/.match(cookies)[0] + ';'
+          cookie_string << string
+        end
+      end
+    end
+
+    def standards_compliant?
+      @options.fetch(:standards_compliant, false)
+    end
   end
 end