faraday 0.15.1 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db0b54b940edbbba0e72c6a5d393b101f6852c4d4c9d4b31106382a983c31045
-  data.tar.gz: 594b4833954d6049878ccc1e1006d4b4295da70b01809f2abbd977368215812e
+  metadata.gz: 010e4dd27187eb834e8a0c185cab419a1b69c6e3f8a5728f6681109b7848091d
+  data.tar.gz: ccd678f8acf84929c15a19b7a6ca1b22b2d634eabfae21c84c4a0f0ba97fb8b6
 SHA512:
-  metadata.gz: 347f4c8f7e15467652370480e1131ec28ee9eeb964bc5eb8982781da79718a74bd3fe2421d57107e2245fc218b1cb0351c0df569f18b2f2fe0d1625408b8fa82
-  data.tar.gz: 5014a90947f8987b70facb531f9dd83f4df923ee9d14cb3b8d5250cce0fe51e0eaba6b4a1ca9b5a35db15d5b181a964b9aaeaddcfc0f4f3feec9b669a48817c5
+  metadata.gz: 150271b18c60bf5b55cc7e74f39fb01d6c83eecc39119d425fe8d399829ba728183900a5a948dbb874f432fc95996b88c367e87b5274b45addbd15d6175d7bc0
+  data.tar.gz: 3f4ef0b5d787aeffef29d79af04297a62a6b1ae77f034858b7d68ac4bdcfc00734c976cb8dff8b76b0af007590c6f4a5376797c14d3798cc13193aed96689d0c

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2017 Rick Olson, Zack Hobson
+Copyright (c) 2009-2019 Rick Olson, Zack Hobson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,353 +1,32 @@
-# Faraday
+# ![Faraday](./docs/assets/img/repo-card-slim.png)
 
 [![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
-[![Build Status](https://travis-ci.org/lostisland/faraday.svg)](https://travis-ci.org/lostisland/faraday)
-[![Coverage Status](https://coveralls.io/repos/github/lostisland/faraday/badge.svg?branch=master)](https://coveralls.io/github/lostisland/faraday?branch=master)
-[![Code Climate](https://codeclimate.com/github/lostisland/faraday/badges/gpa.svg)](https://codeclimate.com/github/lostisland/faraday)
+[![CircleCI](https://circleci.com/gh/lostisland/faraday/tree/master.svg?style=svg)](https://circleci.com/gh/lostisland/faraday/tree/master)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/f869daab091ceef1da73/test_coverage)](https://codeclimate.com/github/lostisland/faraday/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/f869daab091ceef1da73/maintainability)](https://codeclimate.com/github/lostisland/faraday/maintainability)
 [![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 
-Faraday is an HTTP client lib that provides a common interface over many
+Faraday is an HTTP client library that provides a common interface over many
 adapters (such as Net::HTTP) and embraces the concept of Rack middleware when
 processing the request/response cycle.
 
-Faraday supports these adapters out of the box:
+## Getting Started
 
-* [Net::HTTP][net_http] _(default)_
-* [Net::HTTP::Persistent][persistent]
-* [Excon][]
-* [Patron][]
-* [EventMachine][]
-* [HTTPClient][]
-
-Adapters are slowly being moved into their own gems, or bundled with HTTP clients:
-
-* [Typhoeus][]
-
-It also includes a Rack adapter for hitting loaded Rack applications through
-Rack::Test, and a Test adapter for stubbing requests by hand.
-
-## API documentation
-
-Available at [rubydoc.info](http://www.rubydoc.info/gems/faraday).
-
-## Usage
-
-### Basic Use
-
-```ruby
-response = Faraday.get 'http://sushi.com/nigiri/sake.json'
-```
-A simple `get` request can be performed by using the syntax described above. This works 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)).
-
-A more flexible way to use Faraday is to start with a Connection object. If you want to keep the same defaults, you can use this syntax:
-
-```ruby
-conn = Faraday.new(:url => 'http://www.example.com')
-response = conn.get '/users'                 # GET http://www.example.com/users'
-```
-
-Connections can also take an options hash as a parameter or be configured by using a block. Checkout the section called [Advanced middleware usage](#advanced-middleware-usage) for more details about how to use this block for configurations.
-Since the default middleware stack uses url\_encoded middleware and default adapter, use them on building your own middleware stack.
-
-```ruby
-conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
-  faraday.request  :url_encoded             # form-encode POST params
-  faraday.response :logger                  # log requests to $stdout
-  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-end
-
-# Filter sensitive information from logs with a regex matcher
-
-conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
-  faraday.request  :url_encoded             # form-encode POST params
-  faraday.response :logger do | logger |
-    logger.filter(/(api_key=)(\w+)/,'\1[REMOVED]')
-  end
-  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-end
-```
-
-Once you have the connection object, use it to make HTTP requests. You can pass parameters to it in a few different ways:
-
-```ruby
-## GET ##
-
-response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
-response.body
-
-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
-  req.params['limit'] = 100
-end
-
-## POST ##
-
-conn.post '/nigiri', { :name => 'Maguro' }  # POST "name=maguro" to http://sushi.com/nigiri
-```
-
-Some configuration options can be adjusted per request:
-
-```ruby
-# post payload as JSON instead of "www-form-urlencoded" encoding:
-conn.post do |req|
-  req.url '/nigiri'
-  req.headers['Content-Type'] = 'application/json'
-  req.body = '{ "name": "Unagi" }'
-end
-
-## Per-request options ##
-
-conn.get do |req|
-  req.url '/search'
-  req.options.timeout = 5           # open/read timeout in seconds
-  req.options.open_timeout = 2      # connection open timeout in seconds
-end
-```
-
-And you can inject arbitrary data into the request using the `context` option:
-
-```ruby
-# Anything you inject using context option will be available in the env on all middlewares
-
-conn.get do |req|
-  req.url '/search'
-  req.options.context = {
-      foo: 'foo',
-      bar: 'bar'
-  }
-end
-```
-
-### Changing how parameters are serialized
-
-Sometimes you need to send the same URL parameter multiple times with different
-values. This requires manually setting the parameter encoder and can be done on
-either per-connection or per-request basis.
-
-```ruby
-# per-connection setting
-conn = Faraday.new :request => { :params_encoder => Faraday::FlatParamsEncoder }
-
-conn.get do |req|
-  # per-request setting:
-  # req.options.params_encoder = my_encoder
-  req.params['roll'] = ['california', 'philadelphia']
-end
-# GET 'http://sushi.com?roll=california&roll=philadelphia'
-```
-
-The value of Faraday `params_encoder` can be any object that responds to:
-
-* `encode(hash) #=> String`
-* `decode(string) #=> Hash`
-
-The encoder will affect both how query strings are processed and how POST bodies
-get serialized. The default encoder is Faraday::NestedParamsEncoder.
-
-## Authentication
-
-Basic and Token authentication are handled by Faraday::Request::BasicAuthentication and Faraday::Request::TokenAuthentication respectively. These can be added as middleware manually or through the helper methods.
-
-```ruby
-Faraday.new(...) do |conn|
-  conn.basic_auth('username', 'password')
-end
-
-Faraday.new(...) do |conn|
-  conn.token_auth('authentication-token')
-end
-```
-
-## Proxy
-
-Faraday will try to automatically infer the proxy settings from your system using `URI#find_proxy`.
-This will retrieve them from environment variables such as http_proxy, ftp_proxy, no_proxy, etc.
-If for any reason you want to disable this behaviour, you can do so by setting the global varibale `ignore_env_proxy`:
-
-```ruby
-Faraday.ignore_env_proxy = true
-```
-
-You can also specify a custom proxy when initializing the connection
-
-```ruby
-Faraday.new('http://www.example.com', :proxy => 'http://proxy.com')
-```
-
-## Advanced middleware usage
-
-The order in which middleware is stacked is important. Like with Rack, the
-first middleware on the list wraps all others, while the last middleware is the
-innermost one, so that must be the adapter.
-
-```ruby
-Faraday.new(...) do |conn|
-  # POST/PUT params encoders:
-  conn.request :multipart
-  conn.request :url_encoded
-
-  # Last middleware must be the adapter:
-  conn.adapter :net_http
-end
-```
-
-This request middleware setup affects POST/PUT requests in the following way:
-
-1. `Request::Multipart` checks for files in the payload, otherwise leaves
-  everything untouched;
-2. `Request::UrlEncoded` encodes as "application/x-www-form-urlencoded" if not
-  already encoded or of another type
-
-Swapping middleware means giving the other priority. Specifying the
-"Content-Type" for the request is explicitly stating which middleware should
-process it.
-
-Examples:
-
-```ruby
-# uploading a file:
-payload[:profile_pic] = Faraday::UploadIO.new('/path/to/avatar.jpg', 'image/jpeg')
-
-# "Multipart" middleware detects files and encodes with "multipart/form-data":
-conn.put '/profile', payload
-```
-
-## Writing middleware
-
-Middleware are classes that implement a `call` instance method. They hook into
-the request/response cycle.
-
-```ruby
-def call(request_env)
-  # do something with the request
-  # request_env[:request_headers].merge!(...)
-
-  @app.call(request_env).on_complete do |response_env|
-    # do something with the response
-    # response_env[:response_headers].merge!(...)
-  end
-end
-```
-
-It's important to do all processing of the response only in the `on_complete`
-block. This enables middleware to work in parallel mode where requests are
-asynchronous.
-
-The `env` is a hash with symbol keys that contains info about the request and,
-later, response. Some keys are:
-
-```
-# request phase
-:method - :get, :post, ...
-:url    - URI for the current request; also contains GET parameters
-:body   - POST parameters for :post/:put requests
-:request_headers
-
-# response phase
-:status - HTTP response status code, such as 200
-:body   - the response body
-:response_headers
-```
-
-## Ad-hoc adapters customization
-
-Faraday is intended to be a generic interface between your code and the adapter. However, sometimes you need to access a feature specific to one of the adapters that is not covered in Faraday's interface.
-
-When that happens, you can pass a block when specifying the adapter to customize it. The block parameter will change based on the adapter you're using. See below for some examples.
-
-### NetHttp
-```ruby
-conn = Faraday.new(...) do |f|
-  f.adapter :net_http do |http| # yields Net::HTTP
-    http.idle_timeout = 100
-    http.verify_callback = lambda do | preverify_ok, cert_store |
-      # do something here...
-    end
-  end
-end
-```
-
-### NetHttpPersistent
-```ruby
-conn = Faraday.new(...) do |f|
-  f.adapter :net_http_persistent do |http| # yields Net::HTTP::Persistent
-    http.idle_timeout = 100
-    http.retry_change_requests = true
-  end
-end
-```
-
-### Patron
-```ruby
-conn = Faraday.new(...) do |f|
-  f.adapter :patron do |session| # yields Patron::Session
-    session.max_redirects = 10
-  end
-end
-```
-
-### HTTPClient
-```ruby
-conn = Faraday.new(...) do |f|
-  f.adapter :httpclient do |client| # yields HTTPClient
-    client.keep_alive_timeout = 20
-    client.ssl_config.timeout = 25
-  end
-end
-```
-
-## Using Faraday for testing
-
-```ruby
-# It's possible to define stubbed request outside a test adapter block.
-stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-  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') { |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') { |env| [ 200, {}, 'urchin' ]}
-
-resp = test.get '/tamago'
-resp.body # => 'egg'
-resp = test.get '/ebi'
-resp.body # => 'shrimp'
-resp = test.get '/uni'
-resp.body # => 'urchin'
-resp = test.get '/else' #=> raises "no such stub" error
-
-# If you like, you can treat your stubs as mocks by verifying that all of
-# the stubbed calls were made. NOTE that this feature is still fairly
-# experimental: It will not verify the order or count of any stub, only that
-# it was called once during the course of the test.
-stubs.verify_stubbed_calls
-```
+The best starting point is the [Faraday Website][website], with its introduction and explanation.
+Need more details? See the [Faraday API Documentation][apidoc] to see how it works internally.
 
 ## Supported Ruby versions
 
-This library aims to support and is [tested against][travis] the following Ruby
+This library aims to support and is [tested against][circle_ci] the following Ruby
 implementations:
 
-* Ruby 1.9.3+
-* [JRuby][] 1.7+
-* [Rubinius][] 2+
+* Ruby 2.3+
 
 If something doesn't work on one of these Ruby versions, it's a bug.
 
 This library may inadvertently work (or seem to work) on other Ruby
-implementations, however support will only be provided for the versions listed
+implementations and versions, however support will only be provided for the versions listed
 above.
 
 If you would like this library to support another Ruby version, you may
@@ -360,22 +39,17 @@ of a major release, support for that Ruby version may be dropped.
 ## Contribute
 
 Do you want to contribute to Faraday?
-Open the issues page and check for the `any volunteer?` label!
-But before you start coding, please read our [Contributing Guide](https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md)
+Open the issues page and check for the `help wanted` label!
+But before you start coding, please read our [Contributing Guide][contributing]
 
 ## Copyright
+© 2009 - 2019, the [Faraday Team][faraday_team]. Website and branding design by [Elena Lo Piccolo](https://elelopic.design).
 
-Copyright (c) 2009-2017 [Rick Olson](mailto:technoweenie@gmail.com), Zack Hobson.
-See [LICENSE][] for details.
-
-[net_http]:     http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html
-[persistent]:   https://github.com/drbrain/net-http-persistent
-[travis]:       https://travis-ci.org/lostisland/faraday
-[excon]:        https://github.com/excon/excon#readme
-[patron]:       http://toland.github.io/patron/
-[eventmachine]: https://github.com/igrigorik/em-http-request#readme
-[httpclient]:   https://github.com/nahi/httpclient
-[typhoeus]:     https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
+[website]:      https://lostisland.github.io/faraday
+[faraday_team]: https://lostisland.github.io/faraday/team
+[contributing]: https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md
+[apidoc]:       http://www.rubydoc.info/gems/faraday
+[circle_ci]:    https://circleci.com/gh/lostisland/faraday
 [jruby]:        http://jruby.org/
 [rubinius]:     http://rubini.us/
 [license]:      LICENSE.md