faraday_middleware 0.7.0 → 0.8.0

data/.rspec

@@ -1,3 +1,2 @@
 --color
---format=nested
 --backtrace

data/.travis.yml

@@ -1,8 +1,7 @@
 rvm:
   - 1.8.7
-  - 1.9.1
   - 1.9.2
+  - 1.9.3
   - jruby
   - rbx
   - ree
-  - ruby-head

data/CHANGELOG.md

@@ -1,10 +1,10 @@
-# Changelog
-
-### 0.0.2 September 25, 2010
-
-* Mashify now handles arrays of non-hashes
-
-### 0.0.1 June 27, 2010
-
-* MultiJSON
+# Changelog
+
+### 0.0.2 September 25, 2010
+
+* Mashify now handles arrays of non-hashes
+
+### 0.0.1 June 27, 2010
+
+* MultiJSON
 * Mashify

data/Gemfile

@@ -1,7 +1,7 @@
 source 'http://rubygems.org'
 
-platforms :jruby do
-  gem "jruby-openssl", "~> 0.7"
-end
+gem 'simplecov' unless ENV['CI']
+gem 'json', :platforms => [:ruby_18, :jruby]
+gem 'jruby-openssl', '~> 0.7', :platforms => :jruby
 
 gemspec

data/README.md

@@ -3,11 +3,11 @@ Faraday Middleware
 
 A collection of some useful [Faraday](https://github.com/technoweenie/faraday) middleware
 
-Installation
+<a name="installation">Installation</a>
 ------------
     gem install faraday_middleware
 
-Examples
+<a name="examples">Examples</a>
 --------
 Let's decode the response body with [MultiJson](https://github.com/intridea/multi_json)!
 

data/Rakefile

@@ -1,10 +1,17 @@
 #!/usr/bin/env rake
 
+task :default => [:enable_coverage, :spec, :test]
+
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :test => :spec
-task :default => :spec
+task :enable_coverage do
+  ENV['COVERAGE'] = 'yes' unless ENV['CI']
+end
+
+task :test do
+  sh 'ruby', '-Ilib', 'spec/caching_test.rb'
+end

data/faraday_middleware.gemspec

@@ -1,31 +1,23 @@
 require File.expand_path('../lib/faraday_middleware/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.name = 'faraday_middleware'
-  gem.summary = %q{Various middleware for Faraday}
-  gem.description = gem.summary
-
-  gem.homepage = 'https://github.com/pengwynn/faraday_middleware'
-
-  gem.authors = ["Erik Michaels-Ober", "Wynn Netherland"]
-  gem.email   = ['sferik@gmail.com', 'wynn.netherland@gmail.com']
-
-  gem.version  = FaradayMiddleware::VERSION
-
-  gem.require_paths = ['lib']
-  gem.files = `git ls-files`.split("\n")
-  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-
-  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-
-  gem.add_runtime_dependency 'faraday', '~> 0.7.3'
+  gem.add_dependency 'faraday', ['>= 0.7.4', '< 0.9']
+  gem.add_development_dependency 'multi_xml', '~> 0.2'
   gem.add_development_dependency 'rake', '~> 0.9'
-  gem.add_development_dependency 'rspec', '~> 2.6'
-  gem.add_development_dependency 'simplecov', '~> 0.4'
+  gem.add_development_dependency 'hashie', '~> 1.2'
   gem.add_development_dependency 'rash', '~> 0.3'
-  gem.add_development_dependency 'multi_json', '~> 1.0'
-  gem.add_development_dependency 'multi_xml', '~> 0.2'
-  gem.add_development_dependency 'oauth2', '~> 0.5.0'
+  gem.add_development_dependency 'rspec', '~> 2.6'
   gem.add_development_dependency 'simple_oauth', '~> 0.1'
+  gem.add_development_dependency 'rack-cache', '~> 1.1'
+  gem.authors = ["Erik Michaels-Ober", "Wynn Netherland"]
+  gem.description = %q{Various middleware for Faraday}
+  gem.email = ['sferik@gmail.com', 'wynn.netherland@gmail.com']
+  gem.files = `git ls-files`.split("\n")
+  gem.homepage = 'https://github.com/pengwynn/faraday_middleware'
+  gem.name = 'faraday_middleware'
+  gem.require_paths = ['lib']
+  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+  gem.summary = gem.description
+  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.version  = FaradayMiddleware::VERSION
 end

data/lib/faraday_middleware.rb

@@ -1,15 +1,55 @@
 require 'faraday'
 
-class Faraday::Request
-  autoload :OAuth,  'faraday/request/oauth'
-  autoload :OAuth2, 'faraday/request/oauth2'
-end
+module FaradayMiddleware
+  class << self
+    middleware = {
+      :OAuth        => 'request/oauth',
+      :OAuth2       => 'request/oauth2',
+      :EncodeJson   => 'request/encode_json',
+      :Mashify      => 'response/mashify',
+      :Rashify      => 'response/rashify',
+      :ParseJson    => 'response/parse_json',
+      :ParseXml     => 'response/parse_xml',
+      :ParseMarshal => 'response/parse_marshal',
+      :ParseYaml    => 'response/parse_yaml',
+      :Caching      => 'response/caching',
+      :RackCompatible  => 'rack_compatible',
+      :FollowRedirects => 'response/follow_redirects',
+      :Instrumentation => 'instrumentation'
+    }
+
+    # autoload without the autoload
+    define_method(:const_missing) { |const|
+      if middleware.member? const
+        require "faraday_middleware/#{middleware[const]}"
+        raise NameError, "missing #{const} middleware" unless const_defined? const
+        const_get const
+      else
+        super
+      end
+    }
+  end
+
+  if Faraday.respond_to? :register_middleware
+    Faraday.register_middleware :request,
+      :oauth    => lambda { OAuth },
+      :oauth2   => lambda { OAuth2 },
+      :json     => lambda { EncodeJson }
 
-class Faraday::Response
-  autoload :Mashify,      'faraday/response/mashify'
-  autoload :ParseJson,    'faraday/response/parse_json'
-  autoload :ParseMarshal, 'faraday/response/parse_marshal'
-  autoload :ParseXml,     'faraday/response/parse_xml'
-  autoload :ParseYaml,    'faraday/response/parse_yaml'
-  autoload :Rashify,      'faraday/response/rashify'
+    Faraday.register_middleware :response,
+      :mashify  => lambda { Mashify },
+      :rashify  => lambda { Rashify },
+      :json     => lambda { ParseJson },
+      :json_fix => lambda { ParseJson::MimeTypeFix },
+      :xml      => lambda { ParseXml },
+      :marshal  => lambda { ParseMarshal },
+      :yaml     => lambda { ParseYaml },
+      :caching  => lambda { Caching },
+      :follow_redirects => lambda { FollowRedirects }
+
+    Faraday.register_middleware \
+      :instrumentation  => lambda { Instrumentation }
+  end
 end
+
+require 'faraday_middleware/backwards_compatibility'

data/lib/faraday_middleware/addressable_patch.rb

@@ -0,0 +1,20 @@
+require 'addressable/uri'
+
+# feature-detect the bug
+unless Addressable::URI.parse('/?a=1&b=2') === '/?b=2&a=1'
+  # fix `normalized_query` by sorting query key-value pairs
+  # (rejected: https://github.com/sporkmonger/addressable/issues/28)
+  class Addressable::URI
+    alias normalized_query_without_ordering_fix normalized_query
+
+    def normalized_query
+      fresh = @normalized_query.nil?
+      query = normalized_query_without_ordering_fix
+      if query && fresh
+        @normalized_query = query.split('&', -1).sort_by {|q| q[0..(q.index('=')||-1)] }.join('&')
+      else
+        query
+      end
+    end
+  end
+end

data/lib/faraday_middleware/backwards_compatibility.rb

@@ -0,0 +1,30 @@
+deprecation_warning = lambda { |old, new, trace|
+  warn "Deprecation warning: #{old} is deprecated; use #{new}"
+  warn trace[0,10].join("\n") if $DEBUG
+}
+
+Faraday::Request.extend Module.new {
+  legacy = [:OAuth, :OAuth2]
+  define_method(:const_missing) { |const|
+    if legacy.include? const
+      klass = FaradayMiddleware.const_get(const)
+      deprecation_warning.call "Faraday::Request::#{const}", klass.name, caller
+      const_set const, klass
+    else
+      super
+    end
+  }
+}
+
+Faraday::Response.extend Module.new {
+  legacy = [:Mashify, :Rashify, :ParseJson, :ParseMarshal, :ParseXml, :ParseYaml]
+  define_method(:const_missing) { |const|
+    if legacy.include? const
+      klass = FaradayMiddleware.const_get(const)
+      deprecation_warning.call "Faraday::Response::#{const}", klass.name, caller
+      const_set const, klass
+    else
+      super
+    end
+  }
+}

data/lib/faraday_middleware/instrumentation.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # Public: Instruments requests using Active Support.
+  #
+  # Measures time spent only for synchronous requests.
+  #
+  # Examples
+  #
+  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, start_time, end_time, _, env|
+  #     url = env[:url]
+  #     http_method = env[:method].to_s.upcase
+  #     duration = end_time - start_time
+  #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
+  #   end
+  class Instrumentation < Faraday::Middleware
+    dependency 'active_support/notifications'
+
+    def initialize(app, options = {})
+      super(app)
+      @name = options.fetch(:name, 'request.faraday')
+    end
+
+    def call(env)
+      ActiveSupport::Notifications.instrument(@name, env) do
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/faraday_middleware/rack_compatible.rb

@@ -0,0 +1,76 @@
+require 'stringio'
+
+module FaradayMiddleware
+  # Wraps a handler originally written for Rack to make it compatible with Faraday.
+  #
+  # Experimental. Only handles changes in request headers.
+  class RackCompatible
+    def initialize(app, rack_handler, *args)
+      # tiny middleware that decomposes a Faraday::Response to standard Rack
+      # array: [status, headers, body]
+      compatible_app = lambda do |env|
+        restore_env(env)
+        response = app.call(env)
+        [response.status, response.headers, Array(response.body)]
+      end
+      @rack = rack_handler.new(compatible_app, *args)
+    end
+
+    def call(env)
+      prepare_env(env)
+      rack_response = @rack.call(env)
+      finalize_response(env, rack_response)
+    end
+
+    NonPrefixedHeaders = %w[CONTENT_LENGTH CONTENT_TYPE]
+
+    # 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
+
+      url = env[:url]
+      env['rack.url_scheme'] = url.scheme
+      env['PATH_INFO'] = url.path
+      env['SERVER_PORT'] = url.respond_to?(:inferred_port) ? url.inferred_port : url.port
+      env['QUERY_STRING'] = url.query
+      env['REQUEST_METHOD'] = env[:method].to_s.upcase
+
+      env['rack.errors'] ||= StringIO.new
+
+      env
+    end
+
+    # rack to faraday-compatible
+    def restore_env(env)
+      headers = env[:request_headers]
+      headers.clear
+
+      env.each do |name, value|
+        next unless String === name
+        if NonPrefixedHeaders.include? name or name.index('HTTP_') == 0
+          name = name.sub(/^HTTP_/, '').downcase.tr('_', '-')
+          headers[name] = value
+        end
+      end
+
+      env[:method] = env['REQUEST_METHOD'].downcase.to_sym
+      env
+    end
+
+    def finalize_response(env, rack_response)
+      status, headers, body = rack_response
+      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[:response] ||= Faraday::Response.new({})
+      env[:response].env.update(response_env)
+      env[:response]
+    end
+  end
+end

data/lib/faraday_middleware/request/encode_json.rb

@@ -0,0 +1,50 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # Request middleware that encodes the body as JSON.
+  #
+  # Processes only requests with matching Content-type or those without a type.
+  # If a request doesn't have a type but has a body, it sets the Content-type
+  # to JSON MIME-type.
+  #
+  # Doesn't try to encode bodies that already are in string form.
+  class EncodeJson < Faraday::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze
+    MIME_TYPE    = 'application/json'.freeze
+
+    dependency 'json'
+
+    def call(env)
+      match_content_type(env) do |data|
+        env[:body] = encode data
+      end
+      @app.call env
+    end
+
+    def encode(data)
+      JSON.dump data
+    end
+
+    def match_content_type(env)
+      if process_request?(env)
+        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+        yield env[:body] unless env[:body].respond_to?(:to_str)
+      end
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      has_body?(env) and (type.empty? or type == MIME_TYPE)
+    end
+
+    def has_body?(env)
+      body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+    end
+
+    def request_type(env)
+      type = env[:request_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end

data/lib/faraday_middleware/request/oauth.rb

@@ -0,0 +1,61 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # Public: Uses the simple_oauth library to sign requests according the
+  # OAuth protocol.
+  #
+  # The options for this middleware are forwarded to SimpleOAuth::Header:
+  # :consumer_key, :consumer_secret, :token, :token_secret. All these
+  # parameters are optional.
+  #
+  # 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.
+  class OAuth < Faraday::Middleware
+    dependency 'simple_oauth'
+
+    AUTH_HEADER = 'Authorization'.freeze
+
+    def initialize(app, options)
+      super(app)
+      @options = options
+    end
+
+    def call(env)
+      env[:request_headers][AUTH_HEADER] ||= oauth_header(env).to_s if sign_request?(env)
+      @app.call(env)
+    end
+
+    def oauth_header(env)
+      SimpleOAuth::Header.new env[:method],
+                              env[:url].to_s,
+                              signature_params(body_params(env)),
+                              oauth_options(env)
+    end
+
+    def sign_request?(env)
+      !!env[:request].fetch(:oauth, true)
+    end
+
+    def oauth_options(env)
+      if extra = env[:request][:oauth] and extra.is_a? Hash and !extra.empty?
+        @options.merge extra
+      else
+        @options
+      end
+    end
+
+    def body_params(env)
+      env[:body] || {}
+    end
+
+    def signature_params(params)
+      params.empty? ? params :
+        params.reject {|k,v| v.respond_to?(:content_type) }
+    end
+  end
+end