faraday_middleware 0.7.0 → 0.8.0

data/lib/faraday_middleware/request/oauth2.rb

@@ -0,0 +1,60 @@
+require 'faraday'
+require 'forwardable'
+
+module FaradayMiddleware
+  # Public: A simple middleware that adds an access token to each request.
+  #
+  # The token is added as both "access_token" query parameter and the
+  # "Authorization" HTTP request header. However, an explicit "access_token"
+  # parameter or "Authorization" header for the current request are not
+  # overriden.
+  #
+  # Examples
+  #
+  #   # configure default token:
+  #   OAuth2.new(app, 'abc123')
+  #
+  #   # configure query parameter name:
+  #   OAuth2.new(app, 'abc123', :param_name => 'my_oauth_token')
+  #
+  #   # default token value is optional:
+  #   OAuth2.new(app, :param_name => 'my_oauth_token')
+  class OAuth2 < Faraday::Middleware
+    dependency 'oauth2'
+
+    PARAM_NAME  = 'access_token'.freeze
+    AUTH_HEADER = 'Authorization'.freeze
+
+    attr_reader :param_name
+
+    extend Forwardable
+    def_delegators :'Faraday::Utils', :parse_query, :build_query
+
+    def call(env)
+      params = { param_name => @token }.update query_params(env[:url])
+
+      if token = params[param_name] and !token.empty?
+        env[:url].query = build_query params
+        env[:request_headers][AUTH_HEADER] ||= %(Token token="#{token}")
+      end
+
+      @app.call env
+    end
+
+    def initialize(app, token = nil, options = {})
+      super(app)
+      options, token = token, nil if token.is_a? Hash
+      @token = token && token.to_s
+      @param_name = options.fetch(:param_name, PARAM_NAME).to_s
+      raise ArgumentError, ":param_name can't be blank" if @param_name.empty?
+    end
+
+    def query_params(url)
+      if url.query.nil? or url.query.empty?
+        {}
+      else
+        parse_query url.query
+      end
+    end
+  end
+end

data/lib/faraday_middleware/response/caching.rb

@@ -0,0 +1,76 @@
+require 'faraday'
+require 'forwardable'
+# fixes normalizing query strings:
+require 'faraday_middleware/addressable_patch' if defined? ::Addressable::URI
+
+module FaradayMiddleware
+  # Public: Caches GET responses and pulls subsequent ones from the cache.
+  class Caching < Faraday::Middleware
+    attr_reader :cache
+
+    extend Forwardable
+    def_delegators :'Faraday::Utils', :parse_query, :build_query
+
+    # Public: initialize the middleware.
+    #
+    # cache   - An object that responds to read, write and fetch (default: nil).
+    # options - An options Hash (default: {}):
+    #           :ignore_params - String name or Array names of query params
+    #                            that should be ignored when forming the cache
+    #                            key (default: []).
+    #
+    # Yields if no cache is given. The block should return a cache object.
+    def initialize(app, cache = nil, options = {})
+      super(app)
+      options, cache = cache, nil if cache.is_a? Hash and block_given?
+      @cache = cache || yield
+      @options = options
+    end
+
+    def call(env)
+      if :get == env[:method]
+        if env[:parallel_manager]
+          # callback mode
+          cache_on_complete(env)
+        else
+          # synchronous mode
+          response = cache.fetch(cache_key(env)) { @app.call(env) }
+          finalize_response(response, env)
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    def cache_key(env)
+      url = env[:url].dup
+      if url.query && params_to_ignore.any?
+        params = parse_query url.query
+        params.reject! {|k,| params_to_ignore.include? k }
+        url.query = build_query params
+      end
+      url.normalize!
+      url.request_uri
+    end
+
+    def params_to_ignore
+      @params_to_ignore ||= Array(@options[:ignore_params]).map { |p| p.to_s }
+    end
+
+    def cache_on_complete(env)
+      key = cache_key(env)
+      if cached_response = cache.read(key)
+        finalize_response(cached_response, env)
+      else
+        response = @app.call(env)
+        response.on_complete { cache.write(key, response) }
+      end
+    end
+
+    def finalize_response(response, env)
+      response = env[:response] = response.dup if response.frozen?
+      response.apply_request env unless response.env[:method]
+      response
+    end
+  end
+end

data/lib/faraday_middleware/response/follow_redirects.rb

@@ -0,0 +1,53 @@
+require 'faraday'
+
+module FaradayMiddleware
+  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 30x redirects.
+  class FollowRedirects < Faraday::Middleware
+    # TODO: 307 & standards-compliant 302
+    REDIRECTS = [301, 302, 303]
+    # 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)
+    def initialize(app, options = {})
+      super(app)
+      @options = options
+    end
+
+    def call(env)
+      process_response(@app.call(env), follow_limit)
+    end
+
+    def process_response(response, follows)
+      response.on_complete do |env|
+        if redirect? response
+          raise RedirectLimitReached, response if follows.zero?
+          env[:url] += response['location']
+          env[:method] = :get
+          response = process_response(@app.call(env), follows - 1)
+        end
+      end
+      response
+    end
+
+    def redirect?(response)
+      REDIRECTS.include? response.status
+    end
+
+    def follow_limit
+      @options.fetch(:limit, FOLLOW_LIMIT)
+    end
+  end
+end

data/lib/{faraday → faraday_middleware}/response/mashify.rb

@@ -1,7 +1,7 @@
 require 'faraday'
 
-module Faraday
-  class Response::Mashify < Response::Middleware
+module FaradayMiddleware
+  class Mashify < Faraday::Response::Middleware
     dependency 'hashie/mash'
 
     class << self

data/lib/faraday_middleware/response/parse_json.rb

@@ -0,0 +1,35 @@
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  # Public: Parse response bodies as JSON.
+  class ParseJson < ResponseMiddleware
+    dependency 'json'
+
+    define_parser { |body|
+      JSON.parse body unless body.empty?
+    }
+
+    # 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- [ { -
+
+      def parse_response?(env)
+        super and BRACKETS.include? env[:body][0,1]
+      end
+    end
+  end
+end

data/lib/faraday_middleware/response/parse_marshal.rb

@@ -0,0 +1,10 @@
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  # Public: Restore marshalled Ruby objects in response bodies.
+  class ParseMarshal < ResponseMiddleware
+    define_parser { |body|
+      ::Marshal.load body unless body.empty?
+    }
+  end
+end

data/lib/faraday_middleware/response/parse_xml.rb

@@ -0,0 +1,11 @@
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  class ParseXml < ResponseMiddleware
+    dependency 'multi_xml'
+
+    define_parser { |body|
+      ::MultiXml.parse(body)
+    }
+  end
+end

data/lib/faraday_middleware/response/parse_yaml.rb

@@ -0,0 +1,10 @@
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  # Public: Parse response bodies as YAML.
+  class ParseYaml < ResponseMiddleware
+    dependency 'yaml'
+
+    define_parser { |body| ::YAML.load body }
+  end
+end

data/lib/faraday_middleware/response/rashify.rb

@@ -0,0 +1,9 @@
+require 'faraday_middleware/response/mashify'
+
+module FaradayMiddleware
+  class Rashify < Mashify
+    dependency 'rash'
+
+    self.mash_class = ::Hashie::Rash
+  end
+end

data/lib/faraday_middleware/response_middleware.rb

@@ -0,0 +1,78 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # 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
+      subclass.parser = self.parser
+    end
+
+    def initialize(app = nil, options = {})
+      super(app)
+      @options = options
+      @content_types = Array(options[:content_type])
+    end
+
+    def call(env)
+      @app.call(env).on_complete do
+        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/faraday_middleware/version.rb

@@ -1,3 +1,3 @@
 module FaradayMiddleware
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/spec/caching_test.rb

@@ -0,0 +1,122 @@
+require 'test/unit'
+require 'forwardable'
+require 'fileutils'
+require 'rack/cache'
+require 'faraday_middleware/response/caching'
+require 'faraday_middleware/rack_compatible'
+
+class CachingTest < Test::Unit::TestCase
+  class TestCache < Hash
+    def read(key)
+      if cached = self[key]
+        Marshal.load(cached)
+      end
+    end
+
+    def write(key, data)
+      self[key] = Marshal.dump(data)
+    end
+
+    def fetch(key)
+      read(key) || yield.tap { |data| write(key, data) }
+    end
+  end
+
+  def setup
+    @cache = TestCache.new
+
+    request_count = 0
+    response = lambda { |env|
+      [200, {'Content-Type' => 'text/plain'}, "request:#{request_count+=1}"]
+    }
+
+    @conn = Faraday.new do |b|
+      b.use FaradayMiddleware::Caching, @cache
+      b.adapter :test do |stub|
+        stub.get('/', &response)
+        stub.get('/?foo=bar', &response)
+        stub.post('/', &response)
+        stub.get('/other', &response)
+      end
+    end
+  end
+
+  extend Forwardable
+  def_delegators :@conn, :get, :post
+
+  def test_cache_get
+    assert_equal 'request:1', get('/').body
+    assert_equal 'request:1', get('/').body
+    assert_equal 'request:2', get('/other').body
+    assert_equal 'request:2', get('/other').body
+  end
+
+  def test_response_has_request_params
+    get('/') # make cache
+    response = get('/')
+    assert_equal :get, response.env[:method]
+    assert_equal '/', response.env[:url].to_s
+  end
+
+  def test_cache_query_params
+    assert_equal 'request:1', get('/').body
+    assert_equal 'request:2', get('/?foo=bar').body
+    assert_equal 'request:2', get('/?foo=bar').body
+    assert_equal 'request:1', get('/').body
+  end
+
+  def test_doesnt_cache_post
+    assert_equal 'request:1', post('/').body
+    assert_equal 'request:2', post('/').body
+    assert_equal 'request:3', post('/').body
+  end
+end
+
+# RackCompatible + Rack::Cache
+class HttpCachingTest < Test::Unit::TestCase
+  include FileUtils
+
+  CACHE_DIR = File.expand_path('../cache', __FILE__)
+
+  def setup
+    rm_r CACHE_DIR if File.exists? CACHE_DIR
+
+    request_count = 0
+    response = lambda { |env|
+      [200, { 'Content-Type' => 'text/plain',
+              'Cache-Control' => 'public, max-age=900',
+            },
+            "request:#{request_count+=1}"]
+    }
+
+    @conn = Faraday.new do |b|
+      b.use FaradayMiddleware::RackCompatible, Rack::Cache::Context,
+        :metastore   => "file:#{CACHE_DIR}/rack/meta",
+        :entitystore => "file:#{CACHE_DIR}/rack/body",
+        :verbose     => true
+
+      b.adapter :test do |stub|
+        stub.get('/', &response)
+        stub.post('/', &response)
+      end
+    end
+  end
+
+  extend Forwardable
+  def_delegators :@conn, :get, :post
+
+  def test_cache_get
+    assert_equal 'request:1', get('/', :user_agent => 'test').body
+    response = get('/', :user_agent => 'test')
+    assert_equal 'request:1', response.body
+    assert_equal 'text/plain', response['content-type']
+
+    assert_equal 'request:2', post('/').body
+  end
+
+  def test_doesnt_cache_post
+    assert_equal 'request:1', get('/').body
+    assert_equal 'request:2', post('/').body
+    assert_equal 'request:3', post('/').body
+  end
+end unless defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE  # rbx bug #1522