faraday_middleware 0.9.0 → 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 281f479ebac151c76b6f622d3e2d919fcba90d3e
+  data.tar.gz: b536b23c23f5980b7d1645b5907a0bd8401369c3
+SHA512:
+  metadata.gz: cb1e56ae090cdf939b3b9a74b366a7d6abb787486b019cbe8f9803295bfb600f78a276d47360af69e54138d601ea2d02c02e78fe7143e1b3a0bbb5158e709cff
+  data.tar.gz: ba124f9959f87f44128b8b7ab782360932d068077311a2ab15de90e37b784cb71350d1d2e47df0f660051e850ea6fbcd5917c741e36bbfdf50ab4295db02b255

data/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help
+improve this project.
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by fixing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/lostisland/faraday_middleware/issues
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add, commit, and push your changes.
+9. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/README.md

@@ -50,5 +50,5 @@ end
 ```
 
 
-  [faraday]: https://github.com/technoweenie/faraday#readme
-  [docs]: https://github.com/pengwynn/faraday_middleware/wiki
+  [faraday]: https://github.com/lostisland/faraday#readme
+  [docs]: https://github.com/lostisland/faraday_middleware/wiki

data/Rakefile

@@ -1,7 +1,11 @@
-if defined? RUBY_ENGINE and 'ruby' == RUBY_ENGINE and RUBY_VERSION.index('1.9') == 0
-  task :default => [:enable_coverage, :spec, :test, :quality]
+ruby_19 = RUBY_VERSION > '1.9'
+ruby_mri = !defined?(RUBY_ENGINE) || 'ruby' == RUBY_ENGINE
+default_gemfile = ENV['BUNDLE_GEMFILE'] =~ /Gemfile$/
+
+if ruby_19 && ruby_mri && default_gemfile
+  task :default => [:enable_coverage, :spec, :quality]
 else
-  task :default => [:spec, :test]
+  task :default => [:spec]
 end
 
 require 'bundler'
@@ -14,16 +18,11 @@ task :enable_coverage do
   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',
+    '--gte=coverage/covered_percent,98.9',
     '--max-violations=0'
 end

data/faraday_middleware.gemspec

@@ -1,23 +1,23 @@
-require File.expand_path('../lib/faraday_middleware/version', __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'faraday_middleware/version'
 
-Gem::Specification.new do |gem|
-  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 'hashie', '~> 1.2'
-  gem.add_development_dependency 'rash', '~> 0.3'
-  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
+Gem::Specification.new do |spec|
+  spec.add_dependency 'faraday', ['>= 0.7.4', '< 0.10']
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.authors = ["Erik Michaels-Ober", "Wynn Netherland"]
+  spec.description = %q{Various middleware for Faraday}
+  spec.email = ['sferik@gmail.com', 'wynn.netherland@gmail.com']
+  spec.files = %w(CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile faraday_middleware.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("spec/**/*")
+  spec.homepage = 'https://github.com/lostisland/faraday_middleware'
+  spec.licenses = ['MIT']
+  spec.name = 'faraday_middleware'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.summary = spec.description
+  spec.test_files += Dir.glob("spec/**/*")
+  spec.version = FaradayMiddleware::VERSION
 end

data/lib/faraday_middleware.rb

@@ -18,14 +18,14 @@ module FaradayMiddleware
   autoload :FollowRedirects, 'faraday_middleware/response/follow_redirects'
   autoload :Instrumentation, 'faraday_middleware/instrumentation'
 
-  if Faraday.respond_to? :register_middleware
-    Faraday.register_middleware :request,
+  if Faraday::Middleware.respond_to? :register_middleware
+    Faraday::Request.register_middleware \
       :oauth    => lambda { OAuth },
       :oauth2   => lambda { OAuth2 },
       :json     => lambda { EncodeJson },
       :method_override => lambda { MethodOverride }
 
-    Faraday.register_middleware :response,
+    Faraday::Response.register_middleware \
       :mashify  => lambda { Mashify },
       :rashify  => lambda { Rashify },
       :json     => lambda { ParseJson },
@@ -38,7 +38,7 @@ module FaradayMiddleware
       :follow_redirects => lambda { FollowRedirects },
       :chunked => lambda { Chunked }
 
-    Faraday.register_middleware \
+    Faraday::Middleware.register_middleware \
       :instrumentation  => lambda { Instrumentation }
   end
 end

data/lib/faraday_middleware/rack_compatible.rb

@@ -8,8 +8,8 @@ module FaradayMiddleware
     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)
+      compatible_app = lambda do |rack_env|
+        env = restore_env(rack_env)
         response = app.call(env)
         [response.status, response.headers, Array(response.body)]
       end
@@ -17,43 +17,47 @@ module FaradayMiddleware
     end
 
     def call(env)
-      prepare_env(env)
-      rack_response = @rack.call(env)
+      rack_env = prepare_env(env)
+      rack_response = @rack.call(rack_env)
       finalize_response(env, rack_response)
     end
 
     NonPrefixedHeaders = %w[CONTENT_LENGTH CONTENT_TYPE]
 
     # faraday to rack-compatible
-    def prepare_env(env)
-      headers_to_rack(env)
+    def prepare_env(faraday_env)
+      env = headers_to_rack(faraday_env)
 
-      url = env[:url]
+      url = faraday_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['REQUEST_METHOD'] = faraday_env[:method].to_s.upcase
 
       env['rack.errors'] ||= StringIO.new
+      env['faraday'] = faraday_env
 
       env
     end
 
     def headers_to_rack(env)
+      rack_env = {}
       env[:request_headers].each do |name, value|
         name = name.upcase.tr('-', '_')
         name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
-        env[name] = value
+        rack_env[name] = value
       end
+      rack_env
     end
 
     # rack to faraday-compatible
-    def restore_env(env)
+    def restore_env(rack_env)
+      env = rack_env.fetch('faraday')
       headers = env[:request_headers]
       headers.clear
 
-      env.each do |name, value|
+      rack_env.each do |name, value|
         next unless String === name
         if NonPrefixedHeaders.include? name or name.index('HTTP_') == 0
           name = name.sub(/^HTTP_/, '').downcase.tr('_', '-')
@@ -61,7 +65,8 @@ module FaradayMiddleware
         end
       end
 
-      env[:method] = env['REQUEST_METHOD'].downcase.to_sym
+      env[:method] = rack_env['REQUEST_METHOD'].downcase.to_sym
+      env[:rack_errors] = rack_env['rack.errors']
       env
     end
 

data/lib/faraday_middleware/request/oauth.rb

@@ -72,7 +72,7 @@ module FaradayMiddleware
     end
 
     def include_body_params?(env)
-      # see RFC 5489, section 3.4.1.3.1 for details
+      # see RFC 5849, section 3.4.1.3.1 for details
       !(type = env[:request_headers][CONTENT_TYPE]) or type == TYPE_URLENCODED
     end
 

data/lib/faraday_middleware/request/oauth2.rb

@@ -31,8 +31,9 @@ module FaradayMiddleware
 
     def call(env)
       params = { param_name => @token }.update query_params(env[:url])
+      token = params[param_name]
 
-      if token = params[param_name] and !token.empty?
+      if token.respond_to?(:empty?) && !token.empty?
         env[:url].query = build_query params
         env[:request_headers][AUTH_HEADER] ||= %(Token token="#{token}")
       end

data/lib/faraday_middleware/response/caching.rb

@@ -47,7 +47,7 @@ module FaradayMiddleware
       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
+        url.query = params.any? ? build_query(params) : nil
       end
       url.normalize!
       url.request_uri

data/lib/faraday_middleware/response/parse_dates.rb

@@ -4,7 +4,7 @@ require "faraday"
 module FaradayMiddleware
   # Parse dates from response body
   class ParseDates < ::Faraday::Response::Middleware
-    ISO_DATE_FORMAT = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/m
+    ISO_DATE_FORMAT = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z\Z/m
 
     def initialize(app, options = {})
       @regexp = options[:match] || ISO_DATE_FORMAT

data/lib/faraday_middleware/response_middleware.rb

@@ -75,4 +75,36 @@ module FaradayMiddleware
       env[:request].fetch(:preserve_raw, @options[:preserve_raw])
     end
   end
+
+  # DRAGONS
+  module OptionsExtension
+    attr_accessor :preserve_raw
+
+    def to_hash
+      super.update(:preserve_raw => preserve_raw)
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+      super
+      yield :preserve_raw, preserve_raw
+    end
+
+    def fetch(key, *args)
+      if :preserve_raw == key
+        value = __send__(key)
+        value.nil? ? args.fetch(0) : value
+      else
+        super
+      end
+    end
+  end
+
+  if defined?(Faraday::RequestOptions)
+    begin
+      Faraday::RequestOptions.from(:preserve_raw => true)
+    rescue NoMethodError
+      Faraday::RequestOptions.send(:include, OptionsExtension)
+    end
+  end
 end

data/lib/faraday_middleware/version.rb

@@ -1,3 +1,3 @@
 module FaradayMiddleware
-  VERSION = "0.9.0"
+  VERSION = "0.9.1" unless defined?(FaradayMiddleware::VERSION)
 end

data/spec/caching_spec.rb

@@ -0,0 +1,170 @@
+require 'helper'
+require 'forwardable'
+require 'fileutils'
+require 'rack/cache'
+require 'faraday'
+require 'faraday_middleware/response/caching'
+require 'faraday_middleware/rack_compatible'
+
+describe FaradayMiddleware::Caching do
+  before do
+    @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 CachingLint
+      b.use FaradayMiddleware::Caching, @cache, options
+      b.adapter :test do |stub|
+        stub.get('/', &response)
+        stub.get('/?foo=bar', &response)
+        stub.post('/', &response)
+        stub.get('/other', &response)
+      end
+    end
+  end
+
+  let(:options) { {} }
+
+  extend Forwardable
+  def_delegators :@conn, :get, :post
+
+  it 'caches get requests' do
+    expect(get('/').body).to eq('request:1')
+    expect(get('/').body).to eq('request:1')
+    expect(get('/other').body).to eq('request:2')
+    expect(get('/other').body).to eq('request:2')
+  end
+
+  it 'includes request params in the response' do
+    get('/') # make cache
+    response = get('/')
+    expect(response.env[:method]).to eq(:get)
+    expect(response.env[:url].request_uri).to eq('/')
+  end
+
+  it 'caches requests with query params' do
+    expect(get('/').body).to eq('request:1')
+    expect(get('/?foo=bar').body).to eq('request:2')
+    expect(get('/?foo=bar').body).to eq('request:2')
+    expect(get('/').body).to eq('request:1')
+  end
+
+  it 'does not cache post requests' do
+    expect(post('/').body).to eq('request:1')
+    expect(post('/').body).to eq('request:2')
+    expect(post('/').body).to eq('request:3')
+  end
+
+  context ":ignore_params" do
+    let(:options) { {:ignore_params => %w[ utm_source utm_term ]} }
+
+    it "strips ignored parameters from cache_key" do
+      expect(get('/').body).to eq('request:1')
+      expect(get('/?utm_source=a').body).to eq('request:1')
+      expect(get('/?utm_source=a&utm_term=b').body).to eq('request:1')
+      expect(get('/?utm_source=a&utm_term=b&foo=bar').body).to eq('request:2')
+      expect(get('/?foo=bar').body).to eq('request:2')
+    end
+  end
+
+  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
+
+  class CachingLint < Struct.new(:app)
+    def call(env)
+      app.call(env).on_complete do
+        raise "no headers" unless env[:response_headers].is_a? Hash
+        raise "no response" unless env[:response].is_a? Faraday::Response
+        # raise "env not identical" unless env[:response].env.object_id == env.object_id
+      end
+    end
+  end
+end
+
+# RackCompatible + Rack::Cache
+describe FaradayMiddleware::RackCompatible, 'caching' do
+  include FileUtils
+
+  CACHE_DIR = File.expand_path('../../tmp/cache', __FILE__)
+
+  before do
+    rm_r CACHE_DIR if File.exists? CACHE_DIR
+    # force reinitializing cache dirs
+    Rack::Cache::Storage.instance.clear
+
+    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 RackErrorsComplainer
+
+      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
+
+  it 'caches get requests' do
+    response = get('/', :user_agent => 'test')
+    expect(response.body).to eq('request:1')
+    expect(response.env[:method]).to eq(:get)
+    expect(response.status).to eq(200)
+
+    response = get('/', :user_agent => 'test')
+    expect(response.body).to eq('request:1')
+    expect(response['content-type']).to eq('text/plain')
+    expect(response.env[:method]).to eq(:get)
+    expect(response.env[:request].respond_to?(:fetch)).to be_true
+    expect(response.status). to eq(200)
+
+    expect(post('/').body).to eq('request:2')
+  end
+
+  it 'does not cache post requests' do
+    expect(get('/').body).to eq('request:1')
+    expect(post('/').body).to eq('request:2')
+    expect(post('/').body).to eq('request:3')
+  end
+
+  # middleware to check whether "rack.errors" is free of error reports
+  class RackErrorsComplainer < Struct.new(:app)
+    def call(env)
+      response = app.call(env)
+      error_stream = env[:rack_errors]
+      if error_stream.respond_to?(:string) && error_stream.string.include?('error')
+        raise %(unexpected error in 'rack.errors': %p) % error_stream.string
+      end
+      response
+    end
+  end
+end