footrest 0.2.2 → 0.3.0

data/footrest.gemspec

@@ -26,8 +26,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "debugger"
   gem.add_development_dependency "pry"
 
-  gem.add_dependency "faraday", "~> 0.8.8"
-  gem.add_dependency "faraday_middleware", "~> 0.9.0"
+  gem.add_dependency "faraday", "~> 0.9.0"
   gem.add_dependency "activesupport", ">= 3.0.0"
 
   # Parses Link headers formatted according to RFC 5988 draft spec

data/lib/footrest/connection.rb

@@ -1,7 +1,8 @@
 require 'faraday'
-require 'faraday_middleware'
 require 'footrest/http_error'
 require 'footrest/pagination'
+require 'footrest/follow_redirects'
+require 'footrest/parse_json'
 
 module Footrest
   module Connection
@@ -14,8 +15,8 @@ module Footrest
         faraday.request                     :url_encoded
         faraday.response                    :logger if config[:logging]
         faraday.adapter                     Faraday.default_adapter
-        faraday.use                         FaradayMiddleware::FollowRedirects
-        faraday.use                         FaradayMiddleware::ParseJson, :content_type => /\bjson$/
+        faraday.use                         Footrest::FollowRedirects
+        faraday.use                         Footrest::ParseJson, :content_type => /\bjson$/
         faraday.use                         Footrest::RaiseFootrestErrors
         faraday.use                         Footrest::Pagination
         faraday.headers[:accept]          = "application/json"

data/lib/footrest/follow_redirects.rb

@@ -0,0 +1,142 @@
+require 'faraday'
+require 'set'
+
+module Footrest
+  # Public: Exception thrown when the maximum amount of requests is exceeded.
+  class RedirectLimitReached < Faraday::Error::ClientError
+    attr_reader :response
+
+    def initialize(response)
+      super "too many redirects; last one to: #{response['location']}"
+      @response = response
+    end
+  end
+
+  # 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
+    # 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
+
+    # Public: Initialize the middleware.
+    #
+    # 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)
+      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 perform_with_redirection(env, follows)
+      request_body = env[:body]
+      response = @app.call(env)
+
+      response.on_complete do |env|
+        if follow_redirect?(env, response)
+          raise RedirectLimitReached, response if follows.zero?
+          env = update_env(env, request_body, response)
+          response = perform_with_redirection(env, follows - 1)
+        end
+      end
+      response
+    end
+
+    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

data/lib/footrest/parse_json.rb

@@ -0,0 +1,47 @@
+require 'footrest/response_middleware'
+
+module Footrest
+  # Public: Parse response bodies as JSON.
+  class ParseJson < ResponseMiddleware
+    dependency do
+      require 'json' unless defined?(::JSON)
+    end
+
+    define_parser do |body|
+      ::JSON.parse body unless body.strip.empty?
+    end
+
+    # Public: Override the content-type of the response with "application/json"
+    # if the response body looks like it might be JSON, i.e. starts with an
+    # open bracket.
+    #
+    # This is to fix responses from certain API providers that insist on serving
+    # JSON with wrong MIME-types such as "text/javascript".
+    class MimeTypeFix < ResponseMiddleware
+      MIME_TYPE = 'application/json'.freeze
+
+      def process_response(env)
+        old_type = env[:response_headers][CONTENT_TYPE].to_s
+        new_type = MIME_TYPE.dup
+        new_type << ';' << old_type.split(';', 2).last if old_type.index(';')
+        env[:response_headers][CONTENT_TYPE] = new_type
+      end
+
+      BRACKETS = %w- [ { -
+      WHITESPACE = [ " ", "\n", "\r", "\t" ]
+
+      def parse_response?(env)
+        super and BRACKETS.include? first_char(env[:body])
+      end
+
+      def first_char(body)
+        idx = -1
+        begin
+          char = body[idx += 1]
+          char = char.chr if char
+        end while char and WHITESPACE.include? char
+        char
+      end
+    end
+  end
+end

data/lib/footrest/response_middleware.rb

@@ -0,0 +1,78 @@
+require 'faraday'
+
+module Footrest
+  # Internal: The base class for middleware that parses responses.
+  class ResponseMiddleware < Faraday::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    class << self
+      attr_accessor :parser
+    end
+
+    # Store a Proc that receives the body and returns the parsed result.
+    def self.define_parser(parser = nil)
+      @parser = parser || Proc.new
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.load_error = self.load_error if subclass.respond_to? :load_error=
+      subclass.parser = self.parser
+    end
+
+    def initialize(app = nil, options = {})
+      super(app)
+      @options = options
+      @content_types = Array(options[:content_type])
+    end
+
+    def call(environment)
+      @app.call(environment).on_complete do |env|
+        if process_response_type?(response_type(env)) and parse_response?(env)
+          process_response(env)
+        end
+      end
+    end
+
+    def process_response(env)
+      env[:raw_body] = env[:body] if preserve_raw?(env)
+      env[:body] = parse(env[:body])
+    end
+
+    # Parse the response body.
+    #
+    # Instead of overriding this method, consider using `define_parser`.
+    def parse(body)
+      if self.class.parser
+        begin
+          self.class.parser.call(body)
+        rescue StandardError, SyntaxError => err
+          raise err if err.is_a? SyntaxError and err.class.name != 'Psych::SyntaxError'
+          raise Faraday::Error::ParsingError, err
+        end
+      else
+        body
+      end
+    end
+
+    def response_type(env)
+      type = env[:response_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+
+    def process_response_type?(type)
+      @content_types.empty? or @content_types.any? { |pattern|
+        pattern.is_a?(Regexp) ? type =~ pattern : type == pattern
+      }
+    end
+
+    def parse_response?(env)
+      env[:body].respond_to? :to_str
+    end
+
+    def preserve_raw?(env)
+      env[:request].fetch(:preserve_raw, @options[:preserve_raw])
+    end
+  end
+end

data/lib/footrest/version.rb

@@ -1,3 +1,3 @@
 module Footrest
-  VERSION = '0.2.2' unless defined?(Footrest::VERSION)
+  VERSION = '0.3.0' unless defined?(Footrest::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: footrest
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-03 00:00:00.000000000 Z
+date: 2014-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -110,22 +110,6 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.8.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.8.8
-- !ruby/object:Gem::Dependency
-  name: faraday_middleware
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -184,9 +168,12 @@ files:
 - footrest.gemspec
 - lib/footrest/client.rb
 - lib/footrest/connection.rb
+- lib/footrest/follow_redirects.rb
 - lib/footrest/http_error.rb
 - lib/footrest/pagination.rb
+- lib/footrest/parse_json.rb
 - lib/footrest/request.rb
+- lib/footrest/response_middleware.rb
 - lib/footrest/version.rb
 - lib/footrest.rb
 - spec/footrest/client_spec.rb