faraday 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e442daff424089e143751d7cb1d684c169bf4fc
-  data.tar.gz: ba1dd50171576d5064350e48b8869364c0710a26
+  metadata.gz: 1c31dbb021fc6a43b4f0b102a9a3ccf52a72303a
+  data.tar.gz: 54da868027777adb5a21145bd6433b0154af2297
 SHA512:
-  metadata.gz: 80c7a955f7d0a2217fcde0be2760649b9e5fc2d950929b118383ba61ea7282410b224315e289b40fec12be13898b0b00551e441704462ac39269368a8f9d5931
-  data.tar.gz: cdef47ebdb9519d0e45e7511326ed1368fa520ad314a4055ea154187193c967f8821573705161e3bbca5d3cbbf40f219071223ba8d24821c5dd89e37ddd16a9e
+  metadata.gz: 22c1c286687ca596bd1d6b7d9a6a3749731f6d8962a5bbbe7e1e39cf22e364b92010ae44446cf1804ba10567a2e6409cc2be537375d9f47ace9bca909196dcd3
+  data.tar.gz: 7e8116cdeea918b8e7de661ec6d49d839960e26f136903e53db62e8cc353f89b3ac053d5efe6401995129418ae4dfce8fda9c8a471093223dca08002615d10e1

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Faraday Changelog
 
+## v0.9.1
+
+* Refactor Net:HTTP adapter so that with_net_http_connection can be overridden to allow pooled connections. (@Ben-M)
+* Add configurable methods that bypass `retry_if` in the Retry request middleware.  (@mike-bourgeous)
+
 ## v0.9.0
 
 * Add HTTPClient adapter (@hakanensari)

data/CONTRIBUTING.md

@@ -28,9 +28,9 @@ We will accept adapters that:
 2. if they have features not present in included adapters.
 
 We are pushing towards a 1.0 release, when we will have to follow [Semantic
-Versioning][semver].  If your patch includes changes to break compatiblitity,
+Versioning][semver].  If your patch includes changes to break compatibility,
 note that so we can add it to the [Changelog][].
 
 [semver]:    http://semver.org/
-[changelog]: https://github.com/technoweenie/faraday/wiki/Changelog
-[faraday_middleware]: https://github.com/pengwynn/faraday_middleware/wiki
+[changelog]: https://github.com/lostisland/faraday/wiki/Changelog
+[faraday_middleware]: https://github.com/lostisland/faraday_middleware/wiki

data/Gemfile

@@ -13,17 +13,13 @@ group :test do
   gem 'leftright', '>= 0.9', :require => false
   gem 'mime-types', '~> 1.25', :platforms => [:jruby, :ruby_18]
   gem 'minitest', '>= 5.0.5'
-  gem 'net-http-persistent', '>= 2.5', :require => false
+  gem 'net-http-persistent', '>= 2.9.4'
   gem 'patron', '>= 0.4.2', :platforms => :ruby
   gem 'rack-test', '>= 0.6', :require => 'rack/test'
+  gem 'rest-client', '~> 1.6.0', :platforms => [:jruby, :ruby_18]
   gem 'simplecov'
   gem 'sinatra', '~> 1.3'
   gem 'typhoeus', '~> 0.3.3', :platforms => :ruby
 end
 
-platforms :rbx do
-  gem 'rubinius-coverage'
-  gem 'rubysl'
-end
-
 gemspec

data/README.md

@@ -11,6 +11,7 @@ Faraday supports these adapters:
 * [Typhoeus][]
 * [Patron][]
 * [EventMachine][]
+* [HTTPClient][]
 
 It also includes a Rack adapter for hitting loaded Rack applications through
 Rack::Test, and a Test adapter for stubbing requests by hand.
@@ -29,7 +30,7 @@ end
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
 response.body
 
-conn.get '/nigiri', { :name => 'Maguro' }   # GET /nigiri?name=Maguro
+conn.get '/nigiri', { :name => 'Maguro' }   # GET http://sushi.com/nigiri?name=Maguro
 
 conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
   req.url '/search', :page => 2
@@ -56,10 +57,10 @@ conn.get do |req|
 end
 ```
 
-If you don't need to set up anything, you can roll with just the bare minimum:
+If you don't need to set up anything, you can roll with just the default middleware
+stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)):
 
 ```ruby
-# using the default stack:
 response = Faraday.get 'http://sushi.com/nigiri/sake.json'
 ```
 
@@ -106,11 +107,13 @@ Middleware are classes that implement a `call` instance method. They hook into
 the request/response cycle.
 
 ```ruby
-def call(env)
+def call(request_env)
   # do something with the request
+  # request_env[:request_headers].merge!(...)
 
-  @app.call(env).on_complete do
+  @app.call(request_env).on_complete do |response_env|
     # do something with the response
+    # response_env[:response_headers].merge!(...)
   end
 end
 ```
@@ -140,20 +143,20 @@ later, response. Some keys are:
 ```ruby
 # It's possible to define stubbed request outside a test adapter block.
 stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-  stub.get('/tamago') { [200, {}, 'egg'] }
+  stub.get('/tamago') { |env| [200, {}, 'egg'] }
 end
 
 # You can pass stubbed request to the test adapter or define them in a block
 # or a combination of the two.
 test = Faraday.new do |builder|
   builder.adapter :test, stubs do |stub|
-    stub.get('/ebi') {[ 200, {}, 'shrimp' ]}
+    stub.get('/ebi') { |env| [ 200, {}, 'shrimp' ]}
   end
 end
 
 # It's also possible to stub additional requests after the connection has
 # been initialized. This is useful for testing.
-stubs.get('/uni') {[ 200, {}, 'urchin' ]}
+stubs.get('/uni') { |env| [ 200, {}, 'urchin' ]}
 
 resp = test.get '/tamago'
 resp.body # => 'egg'
@@ -211,6 +214,7 @@ See [LICENSE][] for details.
 [typhoeus]:  https://github.com/typhoeus/typhoeus#readme
 [patron]:    http://toland.github.com/patron/
 [eventmachine]: https://github.com/igrigorik/em-http-request#readme
+[httpclient]: https://github.com/nahi/httpclient
 [jruby]:     http://jruby.org/
 [rubinius]:  http://rubini.us/
 [license]:   LICENSE.md

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.

data/lib/faraday/adapter/net_http.rb

@@ -25,29 +25,31 @@ module Faraday
       ]
 
       NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
+      NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
 
       def call(env)
         super
-        http = net_http_connection(env)
-        configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-        req = env[:request]
-        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
-
-        begin
-          http_response = perform_request(http, env)
-        rescue *NET_HTTP_EXCEPTIONS => err
-          if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-            raise Faraday::SSLError, err
-          else
-            raise Error::ConnectionFailed, err
+        with_net_http_connection(env) do |http|
+          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
+
+          req = env[:request]
+          http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
+          http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+
+          begin
+            http_response = perform_request(http, env)
+          rescue *NET_HTTP_EXCEPTIONS => err
+            if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+              raise Faraday::SSLError, err
+            else
+              raise Error::ConnectionFailed, err
+            end
           end
-        end
 
-        save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
-          http_response.each_header do |key, value|
-            response_headers[key] = value
+          save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
+            http_response.each_header do |key, value|
+              response_headers[key] = value
+            end
           end
         end
 
@@ -81,6 +83,10 @@ module Faraday
         end
       end
 
+      def with_net_http_connection(env)
+        yield net_http_connection(env)
+      end
+
       def net_http_connection(env)
         if proxy = env[:request][:proxy]
           Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])

data/lib/faraday/adapter/net_http_persistent.rb

@@ -8,7 +8,7 @@ module Faraday
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      def net_http_connection(env)
+      def with_net_http_connection(env)
         if proxy = env[:request][:proxy]
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
           proxy_uri.user = proxy_uri.password = nil
@@ -18,7 +18,8 @@ module Faraday
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
         end
-        Net::HTTP::Persistent.new 'Faraday', proxy_uri
+
+        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
       end
 
       def perform_request(http, env)

data/lib/faraday/adapter/patron.rb

@@ -39,7 +39,11 @@ module Faraday
 
         @app.call env
       rescue ::Patron::TimeoutError => err
-        raise Faraday::Error::TimeoutError, err
+        if err.message == "Connection time-out"
+          raise Faraday::Error::ConnectionFailed, err
+        else
+          raise Faraday::Error::TimeoutError, err
+        end
       rescue ::Patron::Error => err
         if err.message.include?("code 407")
           raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}

data/lib/faraday/autoload.rb

@@ -69,7 +69,6 @@ module Faraday
       :UrlEncoded => 'url_encoded',
       :Multipart => 'multipart',
       :Retry => 'retry',
-      :Timeout => 'timeout',
       :Authorization => 'authorization',
       :BasicAuthentication => 'basic_authentication',
       :TokenAuthentication => 'token_authentication',

data/lib/faraday/parameters.rb

@@ -1,15 +1,10 @@
+require "forwardable"
+
 module Faraday
   module NestedParamsEncoder
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def self.escape(s)
-      return s.to_s.gsub(ESCAPE_RE) {
-        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def self.unescape(s)
-      CGI.unescape(s.to_s)
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
     end
 
     def self.encode(params)
@@ -117,16 +112,9 @@ module Faraday
   end
 
   module FlatParamsEncoder
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def self.escape(s)
-      return s.to_s.gsub(ESCAPE_RE) {
-        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def self.unescape(s)
-      CGI.unescape(s.to_s)
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
     end
 
     def self.encode(params)

data/lib/faraday/request/retry.rb

@@ -19,7 +19,13 @@ module Faraday
   # interval that is random between 0.1 and 0.15
   #
   class Request::Retry < Faraday::Middleware
-    class Options < Faraday::Options.new(:max, :interval, :interval_randomness, :backoff_factor, :exceptions)
+
+    IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
+
+    class Options < Faraday::Options.new(:max, :interval, :interval_randomness, :backoff_factor,
+                                         :exceptions, :methods, :retry_if)
+      DEFAULT_CHECK = lambda { |env,exception| false }
+
       def self.from(value)
         if Fixnum === value
           new(value)
@@ -49,6 +55,14 @@ module Faraday
                                      Error::TimeoutError])
       end
 
+      def methods
+        Array(self[:methods] ||= IDEMPOTENT_METHODS)
+      end
+
+      def retry_if
+        self[:retry_if] ||= DEFAULT_CHECK
+      end
+
     end
 
     # Public: Initialize middleware
@@ -66,6 +80,15 @@ module Faraday
     #                       given as Class, Module, or String. (default:
     #                       [Errno::ETIMEDOUT, Timeout::Error,
     #                       Error::TimeoutError])
+    # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
+    #                       an empty Array to call retry_if for all exceptions.
+    #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
+    # retry_if            - block that will receive the env object and the exception raised
+    #                       and should decide if the code should retry still the action or
+    #                       not independent of the retry count. This would be useful
+    #                       if the exception produced is non-recoverable or if the
+    #                       the HTTP method called is not idempotent.
+    #                       (defaults to return false)
     def initialize(app, options = nil)
       super(app)
       @options = Options.from(options)
@@ -85,8 +108,8 @@ module Faraday
       begin
         env[:body] = request_body # after failure env[:body] is set to the response body
         @app.call(env)
-      rescue @errmatch
-        if retries > 0
+      rescue @errmatch => exception
+        if retries > 0 && retry_request?(env, exception)
           retries -= 1
           sleep sleep_amount(retries + 1)
           retry
@@ -114,5 +137,12 @@ module Faraday
       end
       matcher
     end
+
+    private
+
+    def retry_request?(env, exception)
+      @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
+    end
+
   end
 end

data/lib/faraday/response.rb

@@ -61,8 +61,8 @@ module Faraday
 
     def finish(env)
       raise "response already finished" if finished?
-      @env = Env.from(env)
       @on_complete_callbacks.each { |callback| callback.call(env) }
+      @env = Env.from(env)
       return self
     end
 

data/lib/faraday/response/logger.rb

@@ -4,12 +4,15 @@ module Faraday
   class Response::Logger < Response::Middleware
     extend Forwardable
 
-    def initialize(app, logger = nil)
+    DEFAULT_OPTIONS = { :bodies => false }
+
+    def initialize(app, logger = nil, options = {})
       super(app)
       @logger = logger || begin
         require 'logger'
         ::Logger.new(STDOUT)
       end
+      @options = DEFAULT_OPTIONS.merge(options)
     end
 
     def_delegators :@logger, :debug, :info, :warn, :error, :fatal
@@ -17,12 +20,14 @@ module Faraday
     def call(env)
       info "#{env.method} #{env.url.to_s}"
       debug('request') { dump_headers env.request_headers }
+      debug('request') { dump_body(env[:body]) } if env[:body] && log_body?(:request)
       super
     end
 
     def on_complete(env)
       info('Status') { env.status.to_s }
       debug('response') { dump_headers env.response_headers }
+      debug('response') { dump_body env[:body] } if env[:body] && log_body?(:response)
     end
 
     private
@@ -30,5 +35,25 @@ module Faraday
     def dump_headers(headers)
       headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
     end
+
+    def dump_body(body)
+      if body.respond_to?(:to_str)
+        body.to_str
+      else
+        pretty_inspect(body)
+      end
+    end
+
+    def pretty_inspect(body)
+      require 'pp' unless body.respond_to?(:pretty_inspect)
+      body.pretty_inspect
+    end
+
+    def log_body?(type)
+      case @options[:bodies]
+      when Hash then @options[:bodies][type]
+      else @options[:bodies]
+      end
+    end
   end
 end

data/script/cached-bundle

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# Usage: cached-bundle install --deployment
+#
+# After running `bundle`, caches the `./bundle` directory to S3.
+# On the next run, restores the cached directory before running `bundle`.
+# When `Gemfile` changes, the cache gets rebuilt.
+#
+# Requirements:
+# - Gemfile
+# - TRAVIS_REPO_SLUG
+# - TRAVIS_RUBY_VERSION
+# - AMAZON_S3_BUCKET
+# - script/s3-put
+# - bundle
+# - curl
+#
+# Author: Mislav Marohnić
+
+set -e
+
+compute_md5() {
+  local output="$(openssl md5)"
+  echo "${output##* }"
+}
+
+download() {
+  curl --tcp-nodelay -qsfL "$1" -o "$2"
+}
+
+bundle_path="bundle"
+gemfile_hash="$(compute_md5 <"${BUNDLE_GEMFILE:-Gemfile}")"
+cache_name="${TRAVIS_RUBY_VERSION}-${gemfile_hash}.tgz"
+fetch_url="http://${AMAZON_S3_BUCKET}.s3.amazonaws.com/${TRAVIS_REPO_SLUG}/${cache_name}"
+
+if download "$fetch_url" "$cache_name"; then
+  echo "Reusing cached bundle ${cache_name}"
+  tar xzf "$cache_name"
+fi
+
+bundle "$@"
+
+if [ ! -f "$cache_name" ] && [ -n "$AMAZON_SECRET_ACCESS_KEY" ]; then
+  echo "Caching \`${bundle_path}' to S3"
+  tar czf "$cache_name" "$bundle_path"
+  script/s3-put "$cache_name" "${AMAZON_S3_BUCKET}:${TRAVIS_REPO_SLUG}/${cache_name}"
+fi

data/script/s3-put

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# Usage: s3-put <FILE> <S3_BUCKET>[:<PATH>] [<CONTENT_TYPE>]
+#
+# Uploads a file to the Amazon S3 service.
+# Outputs the URL for the newly uploaded file.
+#
+# Requirements:
+# - AMAZON_ACCESS_KEY_ID
+# - AMAZON_SECRET_ACCESS_KEY
+# - openssl
+# - curl
+#
+# Author: Mislav Marohnić
+
+set -e
+
+authorization() {
+  local signature="$(string_to_sign | hmac_sha1 | base64)"
+  echo "AWS ${AMAZON_ACCESS_KEY_ID?}:${signature}"
+}
+
+hmac_sha1() {
+  openssl dgst -binary -sha1 -hmac "${AMAZON_SECRET_ACCESS_KEY?}"
+}
+
+base64() {
+  openssl enc -base64
+}
+
+bin_md5() {
+  openssl dgst -binary -md5
+}
+
+string_to_sign() {
+  echo "$http_method"
+  echo "$content_md5"
+  echo "$content_type"
+  echo "$date"
+  echo "x-amz-acl:$acl"
+  printf "/$bucket/$remote_path"
+}
+
+date_string() {
+  LC_TIME=C date "+%a, %d %h %Y %T %z"
+}
+
+file="$1"
+bucket="${2%%:*}"
+remote_path="${2#*:}"
+content_type="$3"
+
+if [ -z "$remote_path" ] || [ "$remote_path" = "$bucket" ]; then
+  remote_path="${file##*/}"
+fi
+
+http_method=PUT
+acl="public-read"
+content_md5="$(bin_md5 < "$file" | base64)"
+date="$(date_string)"
+
+url="https://$bucket.s3.amazonaws.com/$remote_path"
+
+curl -qsSf -T "$file" \
+  -H "Authorization: $(authorization)" \
+  -H "x-amz-acl: $acl" \
+  -H "Date: $date" \
+  -H "Content-MD5: $content_md5" \
+  -H "Content-Type: $content_type" \
+  "$url"
+
+echo "$url"

data/test/adapters/logger_test.rb

@@ -4,17 +4,27 @@ require 'logger'
 
 module Adapters
   class LoggerTest < Faraday::TestCase
-    def setup
-      @io     = StringIO.new
-      @logger = Logger.new(@io)
-      @logger.level = Logger::DEBUG
+    def conn(logger, logger_options={})
+      rubbles = ['Barney', 'Betty', 'Bam Bam']
 
-      @conn = Faraday.new do |b|
-        b.response :logger, @logger
+      Faraday.new do |b|
+        b.response :logger, logger, logger_options
         b.adapter :test do |stubs|
           stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'hello'] }
+          stubs.post('/ohai') { [200, {'Content-Type' => 'text/html'}, 'fred'] }
+          stubs.get('/ohno') { [200, {'Content-Type' => 'text/html'}, 'wilma'] }
+          stubs.post('/ohyes') { [200, {'Content-Type' => 'text/html'}, 'pebbles'] }
+          stubs.get('/rubbles') { [200, {'Content-Type' => 'application/json'}, rubbles] }
         end
       end
+    end
+
+    def setup
+      @io     = StringIO.new
+      @logger = Logger.new(@io)
+      @logger.level = Logger::DEBUG
+
+      @conn = conn(@logger)
       @resp = @conn.get '/hello', nil, :accept => 'text/html'
     end
 
@@ -33,5 +43,40 @@ module Adapters
     def test_logs_response_headers
       assert_match %(Content-Type: "text/html), @io.string
     end
+
+    def test_does_not_log_request_body_by_default
+      @conn.post '/ohai', 'name=Unagi', :accept => 'text/html'
+      refute_match %(name=Unagi), @io.string
+    end
+
+    def test_does_not_log_response_body_by_default
+      @conn.post '/ohai', 'name=Toro', :accept => 'text/html'
+      refute_match %(fred), @io.string
+    end
+
+    def test_log_request_body
+      app = conn(@logger, :bodies => { :request => true })
+      app.post '/ohyes', 'name=Tamago', :accept => 'text/html'
+      assert_match %(name=Tamago), @io.string
+    end
+
+    def test_log_response_body
+      app = conn(@logger, :bodies => { :response => true })
+      app.get '/ohno', :accept => 'text/html'
+      assert_match %(wilma), @io.string
+    end
+
+    def test_log_request_and_response_body
+      app = conn(@logger, :bodies => true)
+      app.post '/ohyes', 'name=Ebi', :accept => 'text/html'
+      assert_match %(name=Ebi), @io.string
+      assert_match %(pebbles), @io.string
+    end
+
+    def test_log_response_body_object
+      app = conn(@logger, :bodies => true)
+      app.get '/rubbles', nil, :accept => 'text/html'
+      assert_match %([\"Barney\", \"Betty\", \"Bam Bam\"]\n), @io.string
+    end
   end
 end

data/test/env_test.rb

@@ -166,6 +166,14 @@ class ResponseTest < Faraday::TestCase
     end
   end
 
+  def test_body_is_parsed_on_finish
+    response = Faraday::Response.new
+    response.on_complete { |env| env[:body] = env[:body].upcase }
+    response.finish(@env)
+
+    assert_equal "YIKES", response.body
+  end
+
   def test_not_success
     assert !@response.success?
   end

data/test/helper.rb

@@ -1,14 +1,14 @@
-require 'rubygems'         # rubygems/version doesn't work by itself
-require 'rubygems/version' # for simplecov-html
-require 'simplecov'
-require 'coveralls'
+if RUBY_VERSION >= '1.9'
+  require 'simplecov'
+  require 'coveralls'
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start do
-  add_filter '/bundle/'
+  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+
+  SimpleCov.start do
+    add_filter '/bundle/'
+    add_filter '/test/'
+    minimum_coverage(87.27)
+  end
 end
 
 gem 'minitest' if defined? Bundler

data/test/middleware/retry_test.rb

@@ -10,43 +10,57 @@ module Middleware
       Faraday.new do |b|
         b.request :retry, *retry_args
         b.adapter :test do |stub|
-          stub.post('/unstable') {
-            @times_called += 1
-            @explode.call @times_called
-          }
+          ['get', 'post'].each do |method|
+            stub.send(method, '/unstable') {
+              @times_called += 1
+              @explode.call @times_called
+            }
+          end
         end
       end
     end
 
     def test_unhandled_error
       @explode = lambda {|n| raise "boom!" }
-      assert_raises(RuntimeError) { conn.post("/unstable") }
+      assert_raises(RuntimeError) { conn.get("/unstable") }
       assert_equal 1, @times_called
     end
 
     def test_handled_error
       @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn.post("/unstable") }
+      assert_raises(Errno::ETIMEDOUT) { conn.get("/unstable") }
       assert_equal 3, @times_called
     end
 
     def test_legacy_max_retries
       @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(1).post("/unstable") }
+      assert_raises(Errno::ETIMEDOUT) { conn(1).get("/unstable") }
       assert_equal 2, @times_called
     end
 
+    def test_legacy_max_negative_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(-9).get("/unstable") }
+      assert_equal 1, @times_called
+    end
+
     def test_new_max_retries
       @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).post("/unstable") }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).get("/unstable") }
       assert_equal 4, @times_called
     end
 
+    def test_new_max_negative_retries
+      @explode = lambda { |n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => -9).get("/unstable") }
+      assert_equal 1, @times_called
+    end
+
     def test_interval
       @explode = lambda {|n| raise Errno::ETIMEDOUT }
       started  = Time.now
       assert_raises(Errno::ETIMEDOUT) {
-        conn(:max => 2, :interval => 0.1).post("/unstable")
+        conn(:max => 2, :interval => 0.1).get("/unstable")
       }
       assert_in_delta 0.2, Time.now - started, 0.04
     end
@@ -70,7 +84,7 @@ module Middleware
       retry_middleware.sleep_amount_retries = [2, 1]
 
       assert_raises(Errno::ETIMEDOUT) {
-        retry_middleware.call({})
+        retry_middleware.call({:method => :get})
       }
 
       assert_empty retry_middleware.sleep_amount_retries
@@ -101,9 +115,63 @@ module Middleware
     def test_custom_exceptions
       @explode = lambda {|n| raise "boom!" }
       assert_raises(RuntimeError) {
-        conn(:exceptions => StandardError).post("/unstable")
+        conn(:exceptions => StandardError).get("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+
+    def test_should_stop_retrying_if_block_returns_false_checking_env
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| env[:method] != :post }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_stop_retrying_if_block_returns_false_checking_exception
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| !exception.kind_of?(Errno::ETIMEDOUT) }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_not_call_retry_if_for_idempotent_methods_if_methods_unspecified
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| raise "this should have never been called" }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).get("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+
+    def test_should_not_retry_for_non_idempotent_method_if_methods_unspecified
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn.post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_not_call_retry_if_for_specified_methods
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| raise "this should have never been called" }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check, :methods => [:post]).post("/unstable")
       }
       assert_equal 3, @times_called
     end
+
+    def test_should_call_retry_if_for_empty_method_list
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| @times_called < 2 }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check, :methods => []).get("/unstable")
+      }
+      assert_equal 2, @times_called
+    end
+
   end
 end

data/test/parameters_test.rb

@@ -0,0 +1,64 @@
+require File.expand_path("../helper", __FILE__)
+
+class TestParameters < Faraday::TestCase
+  # emulates ActiveSupport::SafeBuffer#gsub
+  FakeSafeBuffer = Struct.new(:string) do
+    def to_s() self end
+    def gsub(regex)
+      string.gsub(regex) {
+        match, = $&, '' =~ /a/
+        yield(match)
+      }
+    end
+  end
+
+  def test_escaping_safe_buffer_nested
+    monies = FakeSafeBuffer.new("$32,000.00")
+    assert_equal "a=%2432%2C000.00", Faraday::NestedParamsEncoder.encode("a" => monies)
+  end
+
+  def test_escaping_safe_buffer_flat
+    monies = FakeSafeBuffer.new("$32,000.00")
+    assert_equal "a=%2432%2C000.00", Faraday::FlatParamsEncoder.encode("a" => monies)
+  end
+
+  def test_raises_typeerror_nested
+    error = assert_raises TypeError do
+      Faraday::NestedParamsEncoder.encode("")
+    end
+    assert_equal "Can't convert String into Hash.", error.message
+  end
+
+  def test_raises_typeerror_flat
+    error = assert_raises TypeError do
+      Faraday::FlatParamsEncoder.encode("")
+    end
+    assert_equal "Can't convert String into Hash.", error.message
+  end
+
+  def test_decode_array_nested
+    query = "a[1]=one&a[2]=two&a[3]=three"
+    expected = {"a" => ["one", "two", "three"]}
+    assert_equal expected, Faraday::NestedParamsEncoder.decode(query)
+  end
+
+  def test_decode_array_flat
+    query = "a=one&a=two&a=three"
+    expected = {"a" => ["one", "two", "three"]}
+    assert_equal expected, Faraday::FlatParamsEncoder.decode(query)
+  end
+
+  def test_nested_decode_hash
+    query = "a[b1]=one&a[b2]=two&a[b][c]=foo"
+    expected = {"a" => {"b1" => "one", "b2" => "two", "b" => {"c" => "foo"}}}
+    assert_equal expected, Faraday::NestedParamsEncoder.decode(query)
+  end
+
+  def test_encode_nil_nested
+    assert_equal "a=", Faraday::NestedParamsEncoder.encode("a" => nil)
+  end
+
+  def test_encode_nil_flat
+    assert_equal "a", Faraday::FlatParamsEncoder.encode("a" => nil)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Rick Olson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-16 00:00:00.000000000 Z
+date: 2015-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -92,11 +92,13 @@ files:
 - lib/faraday/response/raise_error.rb
 - lib/faraday/upload_io.rb
 - lib/faraday/utils.rb
+- script/cached-bundle
 - script/console
 - script/generate_certs
 - script/package
 - script/proxy-server
 - script/release
+- script/s3-put
 - script/server
 - script/test
 - test/adapters/default_test.rb
@@ -123,6 +125,7 @@ files:
 - test/middleware_stack_test.rb
 - test/multibyte.txt
 - test/options_test.rb
+- test/parameters_test.rb
 - test/request_middleware_test.rb
 - test/response_middleware_test.rb
 - test/strawberry.rb
@@ -147,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.5
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 2
 summary: HTTP/REST API client library.
@@ -175,6 +178,7 @@ test_files:
 - test/middleware/retry_test.rb
 - test/middleware_stack_test.rb
 - test/options_test.rb
+- test/parameters_test.rb
 - test/request_middleware_test.rb
 - test/response_middleware_test.rb
 - test/strawberry.rb