9 |
11 |
12 |
10 |
13 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | ## Basic Info
2 |
3 | * Faraday Version:
4 | * Ruby Version:
5 |
6 | ## Issue description
7 | Please provide a description of the issue you're experiencing.
8 | Please also provide the exception message/stacktrace or any other useful detail.
9 |
10 | ## Steps to reproduce
11 | If possible, please provide the steps to reproduce the issue.
12 |
13 | ## CHECKLIST (delete before creating the issue)
14 | * If you're not reporting a bug/issue, you can ignore this whole template.
15 | * Are you using the latest Faraday version? If not, please check the [Releases](https://github.com/lostisland/faraday/releases) page to see if the issue has already been fixed.
16 | * Provide the Faraday and Ruby Version you're using while experiencing the issue.
17 | * Fill the `Issue description` and `Steps to Reproduce` sections.
18 | * Delete this checklist before posting the issue.
19 |
--------------------------------------------------------------------------------
/lib/faraday/middleware.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | # Middleware is the basic base class of any Faraday middleware.
5 | class Middleware
6 | extend MiddlewareRegistry
7 |
8 | attr_reader :app, :options
9 |
10 | def initialize(app = nil, options = {})
11 | @app = app
12 | @options = options
13 | end
14 |
15 | def call(env)
16 | on_request(env) if respond_to?(:on_request)
17 | app.call(env).on_complete do |environment|
18 | on_complete(environment) if respond_to?(:on_complete)
19 | end
20 | rescue StandardError => e
21 | on_error(e) if respond_to?(:on_error)
22 | raise
23 | end
24 |
25 | def close
26 | if app.respond_to?(:close)
27 | app.close
28 | else
29 | warn "#{app} does not implement \#close!"
30 | end
31 | end
32 | end
33 | end
34 |
--------------------------------------------------------------------------------
/docs/_includes/footer.html:
--------------------------------------------------------------------------------
1 |
3 |
4 | {% if site.theme_settings.katex and page.id %}
5 |
6 | {% endif %}
7 |
8 | {% if site.theme_settings.footer_text %}
9 |
12 | {% endif %}
13 |
14 |
15 |
22 |
--------------------------------------------------------------------------------
/spec/faraday/adapter_registry_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday::AdapterRegistry do
4 | describe '#initialize' do
5 | subject(:registry) { described_class.new }
6 |
7 | it { expect { registry.get(:FinFangFoom) }.to raise_error(NameError) }
8 | it { expect { registry.get('FinFangFoom') }.to raise_error(NameError) }
9 |
10 | it 'looks up class by string name' do
11 | expect(registry.get('Faraday::Connection')).to eq(Faraday::Connection)
12 | end
13 |
14 | it 'looks up class by symbol name' do
15 | expect(registry.get(:Faraday)).to eq(Faraday)
16 | end
17 |
18 | it 'caches lookups with implicit name' do
19 | registry.set :symbol
20 | expect(registry.get('symbol')).to eq(:symbol)
21 | end
22 |
23 | it 'caches lookups with explicit name' do
24 | registry.set 'string', :name
25 | expect(registry.get(:name)).to eq('string')
26 | end
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/docs/middleware/request/json.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "JSON Request Middleware"
4 | permalink: /middleware/json-request
5 | hide: true
6 | prev_name: UrlEncoded Middleware
7 | prev_link: ./url-encoded
8 | next_name: Instrumentation Middleware
9 | next_link: ./instrumentation
10 | top_name: Back to Middleware
11 | top_link: ./list
12 | ---
13 |
14 | The `JSON` request middleware converts a `Faraday::Request#body` hash of key/value pairs into a JSON request body.
15 | The middleware also automatically sets the `Content-Type` header to `application/json`,
16 | processes only requests with matching Content-Type or those without a type and
17 | doesn't try to encode bodies that already are in string form.
18 |
19 | ### Example Usage
20 |
21 | ```ruby
22 | conn = Faraday.new(...) do |f|
23 | f.request :json
24 | ...
25 | end
26 |
27 | conn.post('/', { a: 1, b: 2 })
28 | # POST with
29 | # Content-Type: application/json
30 | # Body: {"a":1,"b":2}
31 | ```
32 |
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright (c) 2009-2023 Rick Olson, Zack Hobson
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining
4 | a copy of this software and associated documentation files (the
5 | "Software"), to deal in the Software without restriction, including
6 | without limitation the rights to use, copy, modify, merge, publish,
7 | distribute, sublicense, and/or sell copies of the Software, and to
8 | permit persons to whom the Software is furnished to do so, subject to
9 | the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/spec/faraday_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday do
4 | it 'has a version number' do
5 | expect(Faraday::VERSION).not_to be nil
6 | end
7 |
8 | context 'proxies to default_connection' do
9 | let(:mock_connection) { double('Connection') }
10 | before do
11 | Faraday.default_connection = mock_connection
12 | end
13 |
14 | it 'proxies methods that exist on the default_connection' do
15 | expect(mock_connection).to receive(:this_should_be_proxied)
16 |
17 | Faraday.this_should_be_proxied
18 | end
19 |
20 | it 'uses method_missing on Faraday if there is no proxyable method' do
21 | expect { Faraday.this_method_does_not_exist }.to raise_error(
22 | NoMethodError,
23 | "undefined method `this_method_does_not_exist' for Faraday:Module"
24 | )
25 | end
26 |
27 | it 'proxied methods can be accessed' do
28 | allow(mock_connection).to receive(:this_should_be_proxied)
29 |
30 | expect(Faraday.method(:this_should_be_proxied)).to be_a(Method)
31 | end
32 |
33 | after do
34 | Faraday.default_connection = nil
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/faraday/response/logger.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'forwardable'
4 | require 'logger'
5 | require 'faraday/logging/formatter'
6 |
7 | module Faraday
8 | class Response
9 | # Logger is a middleware that logs internal events in the HTTP request
10 | # lifecycle to a given Logger object. By default, this logs to STDOUT. See
11 | # Faraday::Logging::Formatter to see specifically what is logged.
12 | class Logger < Middleware
13 | def initialize(app, logger = nil, options = {})
14 | super(app)
15 | logger ||= ::Logger.new($stdout)
16 | formatter_class = options.delete(:formatter) || Logging::Formatter
17 | @formatter = formatter_class.new(logger: logger, options: options)
18 | yield @formatter if block_given?
19 | end
20 |
21 | def call(env)
22 | @formatter.request(env)
23 | super
24 | end
25 |
26 | def on_complete(env)
27 | @formatter.response(env)
28 | end
29 |
30 | def on_error(exc)
31 | @formatter.exception(exc) if @formatter.respond_to?(:exception)
32 | end
33 | end
34 | end
35 | end
36 |
37 | Faraday::Response.register_middleware(logger: Faraday::Response::Logger)
38 |
--------------------------------------------------------------------------------
/lib/faraday/options/proxy_options.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | # @!parse
5 | # # ProxyOptions contains the configurable properties for the proxy
6 | # # configuration used when making an HTTP request.
7 | # class ProxyOptions < Options; end
8 | ProxyOptions = Options.new(:uri, :user, :password) do
9 | extend Forwardable
10 | def_delegators :uri, :scheme, :scheme=, :host, :host=, :port, :port=,
11 | :path, :path=
12 |
13 | def self.from(value)
14 | case value
15 | when String
16 | # URIs without a scheme should default to http (like 'example:123').
17 | # This fixes #1282 and prevents a silent failure in some adapters.
18 | value = "http://#{value}" unless value.include?('://')
19 | value = { uri: Utils.URI(value) }
20 | when URI
21 | value = { uri: value }
22 | when Hash, Options
23 | if (uri = value.delete(:uri))
24 | value[:uri] = Utils.URI(uri)
25 | end
26 | end
27 |
28 | super(value)
29 | end
30 |
31 | memoized(:user) { uri&.user && Utils.unescape(uri.user) }
32 | memoized(:password) { uri&.password && Utils.unescape(uri.password) }
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/spec/faraday/middleware_registry_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday::MiddlewareRegistry do
4 | before do
5 | stub_const('CustomMiddleware', custom_middleware_klass)
6 | end
7 | let(:custom_middleware_klass) { Class.new(Faraday::Middleware) }
8 | let(:dummy) { Class.new { extend Faraday::MiddlewareRegistry } }
9 |
10 | after { dummy.unregister_middleware(:custom) }
11 |
12 | it 'allows to register with constant' do
13 | dummy.register_middleware(custom: custom_middleware_klass)
14 | expect(dummy.lookup_middleware(:custom)).to eq(custom_middleware_klass)
15 | end
16 |
17 | it 'allows to register with symbol' do
18 | dummy.register_middleware(custom: :CustomMiddleware)
19 | expect(dummy.lookup_middleware(:custom)).to eq(custom_middleware_klass)
20 | end
21 |
22 | it 'allows to register with string' do
23 | dummy.register_middleware(custom: 'CustomMiddleware')
24 | expect(dummy.lookup_middleware(:custom)).to eq(custom_middleware_klass)
25 | end
26 |
27 | it 'allows to register with Proc' do
28 | dummy.register_middleware(custom: -> { custom_middleware_klass })
29 | expect(dummy.lookup_middleware(:custom)).to eq(custom_middleware_klass)
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/spec/support/streaming_response_checker.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | module StreamingResponseChecker
5 | def check_streaming_response(streamed, options = {})
6 | opts = {
7 | prefix: '',
8 | streaming?: true
9 | }.merge(options)
10 |
11 | expected_response = opts[:prefix] + big_string
12 |
13 | chunks, sizes = streamed.transpose
14 |
15 | # Check that the total size of the chunks (via the last size returned)
16 | # is the same size as the expected_response
17 | expect(sizes.last).to eq(expected_response.bytesize)
18 |
19 | start_index = 0
20 | expected_chunks = []
21 | chunks.each do |actual_chunk|
22 | expected_chunk = expected_response[start_index..((start_index + actual_chunk.bytesize) - 1)]
23 | expected_chunks << expected_chunk
24 | start_index += expected_chunk.bytesize
25 | end
26 |
27 | # it's easier to read a smaller portion, so we check that first
28 | expect(expected_chunks[0][0..255]).to eq(chunks[0][0..255])
29 |
30 | [expected_chunks, chunks].transpose.each do |expected, actual|
31 | expect(actual).to eq(expected)
32 | end
33 | end
34 | end
35 | end
36 |
--------------------------------------------------------------------------------
/docs/middleware/request/url_encoded.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "UrlEncoded Middleware"
4 | permalink: /middleware/url-encoded
5 | hide: true
6 | prev_name: Authentication Middleware
7 | prev_link: ./authentication
8 | next_name: JSON Request Middleware
9 | next_link: ./json-request
10 | top_name: Back to Middleware
11 | top_link: ./list
12 | ---
13 |
14 | The `UrlEncoded` middleware converts a `Faraday::Request#body` hash of key/value pairs into a url-encoded request body.
15 | The middleware also automatically sets the `Content-Type` header to `application/x-www-form-urlencoded`.
16 | The way parameters are serialized can be [customized][customize].
17 |
18 |
19 | ### Example Usage
20 |
21 | ```ruby
22 | conn = Faraday.new(...) do |f|
23 | f.request :url_encoded
24 | ...
25 | end
26 |
27 | conn.post('/', { a: 1, b: 2 })
28 | # POST with
29 | # Content-Type: application/x-www-form-urlencoded
30 | # Body: a=1&b=2
31 | ```
32 |
33 | Complex structures can also be passed
34 |
35 | ```ruby
36 | conn.post('/', { a: [1, 3], b: { c: 2, d: 4} })
37 | # POST with
38 | # Content-Type: application/x-www-form-urlencoded
39 | # Body: a%5B%5D=1&a%5B%5D=3&b%5Bc%5D=2&b%5Bd%5D=4
40 | ```
41 |
42 | [customize]: ../usage/customize#changing-how-parameters-are-serialized
43 |
--------------------------------------------------------------------------------
/docs/_posts/2019-03-12-welcome-to-jekyll.markdown:
--------------------------------------------------------------------------------
1 | ---
2 | layout: post
3 | title: "Welcome to Jekyll!"
4 | date: 2019-03-12 10:25:23 +0000
5 | categories: jekyll update
6 | ---
7 | You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.
8 |
9 | To add new posts, simply add a file in the `_posts` directory that follows the convention `YYYY-MM-DD-name-of-post.ext` and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
10 |
11 | Jekyll also offers powerful support for code snippets:
12 |
13 | {% highlight ruby %}
14 | def print_hi(name)
15 | puts "Hi, #{name}"
16 | end
17 | print_hi('Tom')
18 | #=> prints 'Hi, Tom' to STDOUT.
19 | {% endhighlight %}
20 |
21 | Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll’s GitHub repo][jekyll-gh]. If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
22 |
23 | [jekyll-docs]: https://jekyllrb.com/docs/home
24 | [jekyll-gh]: https://github.com/jekyll/jekyll
25 | [jekyll-talk]: https://talk.jekyllrb.com/
26 |
--------------------------------------------------------------------------------
/docs/Gemfile:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | source 'https://rubygems.org'
4 |
5 | # Hello! This is where you manage which Jekyll version is used to run.
6 | # When you want to use a different version, change it below, save the
7 | # file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
8 | #
9 | # bundle exec jekyll serve
10 | #
11 | # This will help ensure the proper Jekyll version is running.
12 | # Happy Jekylling!
13 | # gem "jekyll", "~> 3.7.4"
14 |
15 | # This is the default theme for new Jekyll sites.
16 | # You may change this to anything you like.
17 | # gem "minima", "~> 2.0"
18 | # gem "jekyll-theme-type"
19 | gem 'jekyll-remote-theme'
20 |
21 | # If you want to use GitHub Pages, remove the "gem "jekyll"" above and
22 | # uncomment the line below. To upgrade, run `bundle update github-pages`.
23 | gem 'github-pages', group: :jekyll_plugins
24 |
25 | # If you have any plugins, put them here!
26 | group :jekyll_plugins do
27 | gem 'jekyll-feed', '~> 0.6'
28 | end
29 |
30 | # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
31 | gem 'tzinfo-data', platforms: %i[mingw mswin x64_mingw jruby]
32 |
33 | # Performance-booster for watching directories on Windows
34 | gem 'wdm', '~> 0.1.0' if Gem.win_platform?
35 |
36 | # Ruby 3.X doesn't come with webrick by default anymore
37 | gem 'webrick', '~> 1.7'
38 |
--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
1 | ---
2 | # You don't need to edit this file, it's empty on purpose.
3 | # Edit theme's home layout instead if you wanna make some changes
4 | # See: https://jekyllrb.com/docs/themes/#overriding-theme-defaults
5 | layout: page
6 | title: Homepage
7 | feature-title: Active Maintainers
14 | 15 | 16 |Historical team
17 | 18 | 19 |All the contributors
20 | 21 | 22 |And some extra help
23 |Website and branding design: Elena Lo Piccolo
24 |
8 | feature-img: "assets/img/featured-bg.svg"
9 | hide: true
10 | ---
11 |
12 | Faraday is an HTTP client library that provides a common interface over many adapters (such as Net::HTTP)
13 | and embraces the concept of Rack middleware when processing the request/response cycle.
14 |
15 | {: .text-center}
16 | [ Fork on GitHub][github]{: .btn}
17 | [ Chat with us][gitter]{: .btn}
18 |
19 | {: .mt-60}
20 | ## Installation
21 |
22 | Add this line to your application's Gemfile:
23 |
24 | ```ruby
25 | gem 'faraday'
26 | ```
27 |
28 | And then execute:
29 |
30 | ```bash
31 | $ bundle
32 | ```
33 |
34 | Or install it yourself as:
35 |
36 | ```bash
37 | $ gem install faraday
38 | ```
39 |
40 | {: .mt-60}
41 |
42 | {: .text-center}
43 | [ Read the docs][usage]{: .btn}
44 |
45 | [github]: https://github.com/lostisland/faraday
46 | [gitter]: https://gitter.im/lostisland/faraday
47 | [usage]: ./usage
48 |
--------------------------------------------------------------------------------
/spec/faraday/params_encoders/flat_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'rack/utils'
4 |
5 | RSpec.describe Faraday::FlatParamsEncoder do
6 | it_behaves_like 'a params encoder'
7 |
8 | it 'decodes arrays' do
9 | query = 'a=one&a=two&a=three'
10 | expected = { 'a' => %w[one two three] }
11 | expect(subject.decode(query)).to eq(expected)
12 | end
13 |
14 | it 'decodes boolean values' do
15 | query = 'a=true&b=false'
16 | expected = { 'a' => 'true', 'b' => 'false' }
17 | expect(subject.decode(query)).to eq(expected)
18 | end
19 |
20 | it 'encodes boolean values' do
21 | params = { a: true, b: false }
22 | expect(subject.encode(params)).to eq('a=true&b=false')
23 | end
24 |
25 | it 'encodes boolean values in array' do
26 | params = { a: [true, false] }
27 | expect(subject.encode(params)).to eq('a=true&a=false')
28 | end
29 |
30 | it 'encodes empty array in hash' do
31 | params = { a: [] }
32 | expect(subject.encode(params)).to eq('a=')
33 | end
34 |
35 | it 'encodes unsorted when asked' do
36 | params = { b: false, a: true }
37 | expect(subject.encode(params)).to eq('a=true&b=false')
38 | Faraday::FlatParamsEncoder.sort_params = false
39 | expect(subject.encode(params)).to eq('b=false&a=true')
40 | Faraday::FlatParamsEncoder.sort_params = true
41 | end
42 | end
43 |
--------------------------------------------------------------------------------
/docs/middleware/response/json.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "JSON Response Middleware"
4 | permalink: /middleware/json-response
5 | hide: true
6 | prev_name: Instrumentation Middleware
7 | prev_link: ./instrumentation
8 | next_name: Logger Middleware
9 | next_link: ./logger
10 | top_name: Back to Middleware
11 | top_link: ./list
12 | ---
13 |
14 | The `JSON` response middleware parses response body into a hash of key/value pairs.
15 | The behaviour can be customized with the following options:
16 | * **parser_options:** options that will be sent to the JSON.parse method. Defaults to {}.
17 | * **content_type:** Single value or Array of response content-types that should be processed. Can be either strings or Regex. Defaults to `/\bjson$/`.
18 | * **preserve_raw:** If set to true, the original un-parsed response will be stored in the `response.env[:raw_body]` property. Defaults to `false`.
19 |
20 | ### Example Usage
21 |
22 | ```ruby
23 | conn = Faraday.new('http://httpbingo.org') do |f|
24 | f.response :json, **options
25 | end
26 |
27 | conn.get('json').body
28 | # => {"slideshow"=>{"author"=>"Yours Truly", "date"=>"date of publication", "slides"=>[{"title"=>"Wake up to WonderWidgets!", "type"=>"all"}, {"items"=>["Why WonderWidgets are great", "Who buys WonderWidgets"], "title"=>"Overview", "type"=>"all"}], "title"=>"Sample Slide Show"}}
29 | ```
30 |
--------------------------------------------------------------------------------
/spec/faraday/adapter_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday::Adapter do
4 | let(:adapter) { Faraday::Adapter.new }
5 | let(:request) { {} }
6 |
7 | context '#request_timeout' do
8 | it 'gets :read timeout' do
9 | expect(timeout(:read)).to eq(nil)
10 |
11 | request[:timeout] = 5
12 | request[:write_timeout] = 1
13 |
14 | expect(timeout(:read)).to eq(5)
15 |
16 | request[:read_timeout] = 2
17 |
18 | expect(timeout(:read)).to eq(2)
19 | end
20 |
21 | it 'gets :open timeout' do
22 | expect(timeout(:open)).to eq(nil)
23 |
24 | request[:timeout] = 5
25 | request[:write_timeout] = 1
26 |
27 | expect(timeout(:open)).to eq(5)
28 |
29 | request[:open_timeout] = 2
30 |
31 | expect(timeout(:open)).to eq(2)
32 | end
33 |
34 | it 'gets :write timeout' do
35 | expect(timeout(:write)).to eq(nil)
36 |
37 | request[:timeout] = 5
38 | request[:read_timeout] = 1
39 |
40 | expect(timeout(:write)).to eq(5)
41 |
42 | request[:write_timeout] = 2
43 |
44 | expect(timeout(:write)).to eq(2)
45 | end
46 |
47 | it 'attempts unknown timeout type' do
48 | expect { timeout(:unknown) }.to raise_error(ArgumentError)
49 | end
50 |
51 | def timeout(type)
52 | adapter.send(:request_timeout, type, request)
53 | end
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/lib/faraday/utils/params_hash.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | module Utils
5 | # A hash with stringified keys.
6 | class ParamsHash < Hash
7 | def [](key)
8 | super(convert_key(key))
9 | end
10 |
11 | def []=(key, value)
12 | super(convert_key(key), value)
13 | end
14 |
15 | def delete(key)
16 | super(convert_key(key))
17 | end
18 |
19 | def include?(key)
20 | super(convert_key(key))
21 | end
22 |
23 | alias has_key? include?
24 | alias member? include?
25 | alias key? include?
26 |
27 | def update(params)
28 | params.each do |key, value|
29 | self[key] = value
30 | end
31 | self
32 | end
33 | alias merge! update
34 |
35 | def merge(params)
36 | dup.update(params)
37 | end
38 |
39 | def replace(other)
40 | clear
41 | update(other)
42 | end
43 |
44 | def merge_query(query, encoder = nil)
45 | return self unless query && !query.empty?
46 |
47 | update((encoder || Utils.default_params_encoder).decode(query))
48 | end
49 |
50 | def to_query(encoder = nil)
51 | (encoder || Utils.default_params_encoder).encode(self)
52 | end
53 |
54 | private
55 |
56 | def convert_key(key)
57 | key.to_s
58 | end
59 | end
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | # SITE CONFIGURATION
2 | url: 'https://lostisland.github.io'
3 | baseurl: '/faraday'
4 | repository: 'lostisland/faraday'
5 |
6 | # THEME-SPECIFIC CONFIGURATION
7 | theme_settings:
8 | title: Faraday
9 | avatar: assets/img/logo.png
10 | favicon: assets/img/favicon.png
11 | # email: your-email@example.com
12 | description: >-
13 | Simple, but flexible HTTP client library, with support for multiple backends
14 | footer_text: "© 2009 - 2023, the Faraday Team. Website and branding design by Elena Lo Piccolo."
15 |
16 | # Icons
17 | github: 'lostisland/faraday'
18 | gitter: 'lostisland/faraday'
19 |
20 | # Post navigation
21 | post_navigation: true
22 | site_navigation_sort: 'order'
23 |
24 | # BUILD SETTINGS
25 | markdown: kramdown
26 | remote_theme: rohanchandra/type-theme
27 |
28 | plugins:
29 | - jekyll-feed
30 | - jekyll-remote-theme
31 |
32 | # GitHub settings
33 | lsi: false
34 | safe: true
35 | #source: [your repo's top level directory]
36 | incremental: false
37 | highlighter: rouge
38 | gist:
39 | noscript: false
40 | kramdown:
41 | math_engine: mathjax
42 | syntax_highlighter: rouge
43 |
44 | # Exclude from processing.
45 | # The following items will not be processed, by default. Create a custom list
46 | # to override the default setting.
47 | exclude:
48 | - Gemfile
49 | - Gemfile.lock
50 | - README.md
51 | - node_modules
52 | - vendor/bundle/
53 | - vendor/cache/
54 | - vendor/gems/
55 | - vendor/ruby/
56 |
--------------------------------------------------------------------------------
/docs/middleware/request/instrumentation.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "Instrumentation Middleware"
4 | permalink: /middleware/instrumentation
5 | hide: true
6 | prev_name: JSON Request Middleware
7 | prev_link: ./json-request
8 | next_name: JSON Response Middleware
9 | next_link: ./json-response
10 | top_name: Back to Middleware
11 | top_link: ./list
12 | ---
13 |
14 | The `Instrumentation` middleware allows to instrument requests using different tools.
15 | Options for this middleware include the instrumentation `name` and the `instrumenter` you want to use.
16 | They default to `request.faraday` and `ActiveSupport::Notifications` respectively, but you can provide your own:
17 |
18 | ```ruby
19 | conn = Faraday.new(...) do |f|
20 | f.request :instrumentation, name: 'custom_name', instrumenter: MyInstrumenter
21 | ...
22 | end
23 | ```
24 |
25 | ### Example Usage
26 |
27 | The `Instrumentation` middleware will use `ActiveSupport::Notifications` by default as instrumenter,
28 | allowing you to subscribe to the default event name and instrument requests:
29 |
30 | ```ruby
31 | conn = Faraday.new('http://example.com') do |f|
32 | f.request :instrumentation
33 | ...
34 | end
35 |
36 | ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
37 | url = env[:url]
38 | http_method = env[:method].to_s.upcase
39 | duration = ends - starts
40 | $stdout.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
41 | end
42 |
43 | conn.get('/search', { a: 1, b: 2 })
44 | #=> [example.com] GET /search?a=1&b=2 (0.529 s)
45 | ```
46 |
--------------------------------------------------------------------------------
/docs/usage/streaming.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "Streaming Responses"
4 | permalink: /usage/streaming
5 | hide: true
6 | top_name: Usage
7 | top_link: ./
8 | prev_name: Customizing the Request
9 | prev_link: ./customize
10 | ---
11 |
12 | Sometimes you might need to receive a streaming response.
13 | You can do this with the `on_data` request option.
14 |
15 | The `on_data` callback is a receives tuples of chunk Strings, and the total
16 | of received bytes so far.
17 |
18 | This example implements such a callback:
19 |
20 | ```ruby
21 | # A buffer to store the streamed data
22 | streamed = []
23 |
24 | conn.get('/stream/10') do |req|
25 | # Set a callback which will receive tuples of chunk Strings,
26 | # the sum of characters received so far, and the response environment.
27 | # The latter will allow access to the response status, headers and reason, as well as the request info.
28 | req.options.on_data = Proc.new do |chunk, overall_received_bytes, env|
29 | puts "Received #{overall_received_bytes} characters"
30 | streamed << chunk
31 | end
32 | end
33 |
34 | # Joins all response chunks together
35 | streamed.join
36 | ```
37 |
38 | The `on_data` streaming is currently only supported by some adapters.
39 | To see which ones, please refer to [Awesome Faraday][awesome] comparative table or check the adapter documentation.
40 | Moreover, the `env` parameter was only recently added, which means some adapters may only have partial support
41 | (i.e. only `chunk` and `overall_received_bytes` will be passed to your block).
42 |
43 | [awesome]: https://github.com/lostisland/awesome-faraday/#adapters
44 |
45 |
--------------------------------------------------------------------------------
/spec/faraday/options/proxy_options_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday::ProxyOptions do
4 | describe '#from' do
5 | it 'works with string' do
6 | options = Faraday::ProxyOptions.from 'http://user:pass@example.org'
7 | expect(options.user).to eq('user')
8 | expect(options.password).to eq('pass')
9 | expect(options.uri).to be_a_kind_of(URI)
10 | expect(options.path).to eq('')
11 | expect(options.port).to eq(80)
12 | expect(options.host).to eq('example.org')
13 | expect(options.scheme).to eq('http')
14 | expect(options.inspect).to match('#' +
4 | '' +
5 | '
' +
6 | '
';
11 | }
12 |
13 | function fetchTeam(json, team, div) {
14 | let el = document.querySelector(div);
15 | el.innerHTML = team.map(function (m) {
16 | let index = json.findIndex(function(e) {
17 | return e.author.login === m
18 | });
19 | return teamTile(json.splice(index, 1)[0]);
20 | }).join('');
21 | }
22 |
23 | function fetchContributors(json) {
24 | let el = document.querySelector('#contributors-list');
25 | el.innerHTML = json.reverse().map(function (c) {
26 | return '' + c.author.login + '';
27 | }).join(' · ');
28 | }
29 |
30 | function hideLoader() {
31 | let el = document.querySelector('#loader');
32 | el.classList.add('hidden');
33 | }
34 |
35 | function showTeam() {
36 | let el = document.querySelector('#team-content');
37 | el.classList.remove('hidden');
38 | }
39 |
40 | fetch('https://api.github.com/repos/lostisland/faraday/stats/contributors')
41 | .then(function (response) {
42 | response.json().then(function (json) {
43 | fetchTeam(json, ['technoweenie', 'iMacTia', 'olleolleolle'], '#active-maintainers-list');
44 | fetchTeam(json, ['mislav', 'sferik'], '#historical-team-list');
45 | fetchContributors(json);
46 | hideLoader();
47 | showTeam();
48 | });
49 | });
50 |
--------------------------------------------------------------------------------
/lib/faraday/request/json.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'json'
4 |
5 | module Faraday
6 | class Request
7 | # Request middleware that encodes the body as JSON.
8 | #
9 | # Processes only requests with matching Content-type or those without a type.
10 | # If a request doesn't have a type but has a body, it sets the Content-type
11 | # to JSON MIME-type.
12 | #
13 | # Doesn't try to encode bodies that already are in string form.
14 | class Json < Middleware
15 | MIME_TYPE = 'application/json'
16 | MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
17 |
18 | def on_request(env)
19 | match_content_type(env) do |data|
20 | env[:body] = encode(data)
21 | end
22 | end
23 |
24 | private
25 |
26 | def encode(data)
27 | ::JSON.generate(data)
28 | end
29 |
30 | def match_content_type(env)
31 | return unless process_request?(env)
32 |
33 | env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
34 | yield env[:body] unless env[:body].respond_to?(:to_str)
35 | end
36 |
37 | def process_request?(env)
38 | type = request_type(env)
39 | body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
40 | end
41 |
42 | def body?(env)
43 | (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
44 | end
45 |
46 | def request_type(env)
47 | type = env[:request_headers][CONTENT_TYPE].to_s
48 | type = type.split(';', 2).first if type.index(';')
49 | type
50 | end
51 | end
52 | end
53 | end
54 |
55 | Faraday::Request.register_middleware(json: Faraday::Request::Json)
56 |
--------------------------------------------------------------------------------
/lib/faraday/response/json.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'json'
4 |
5 | module Faraday
6 | class Response
7 | # Parse response bodies as JSON.
8 | class Json < Middleware
9 | def initialize(app = nil, parser_options: nil, content_type: /\bjson$/, preserve_raw: false)
10 | super(app)
11 | @parser_options = parser_options
12 | @content_types = Array(content_type)
13 | @preserve_raw = preserve_raw
14 | end
15 |
16 | def on_complete(env)
17 | process_response(env) if parse_response?(env)
18 | end
19 |
20 | private
21 |
22 | def process_response(env)
23 | env[:raw_body] = env[:body] if @preserve_raw
24 | env[:body] = parse(env[:body])
25 | rescue StandardError, SyntaxError => e
26 | raise Faraday::ParsingError.new(e, env[:response])
27 | end
28 |
29 | def parse(body)
30 | ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
31 | end
32 |
33 | def parse_response?(env)
34 | process_response_type?(env) &&
35 | env[:body].respond_to?(:to_str)
36 | end
37 |
38 | def process_response_type?(env)
39 | type = response_type(env)
40 | @content_types.empty? || @content_types.any? do |pattern|
41 | pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
42 | end
43 | end
44 |
45 | def response_type(env)
46 | type = env[:response_headers][CONTENT_TYPE].to_s
47 | type = type.split(';', 2).first if type.index(';')
48 | type
49 | end
50 | end
51 | end
52 | end
53 |
54 | Faraday::Response.register_middleware(json: Faraday::Response::Json)
55 |
--------------------------------------------------------------------------------
/faraday.gemspec:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require_relative 'lib/faraday/version'
4 |
5 | Gem::Specification.new do |spec|
6 | spec.name = 'faraday'
7 | spec.version = Faraday::VERSION
8 |
9 | spec.summary = 'HTTP/REST API client library.'
10 |
11 | spec.authors = ['@technoweenie', '@iMacTia', '@olleolleolle']
12 | spec.email = 'technoweenie@gmail.com'
13 | spec.homepage = 'https://lostisland.github.io/faraday'
14 | spec.licenses = ['MIT']
15 |
16 | spec.required_ruby_version = '>= 2.6'
17 |
18 | # faraday-net_http is the "default adapter", but being a Faraday dependency it can't
19 | # control which version of faraday it will be pulled from.
20 | # To avoid releasing a major version every time there's a new Faraday API, we should
21 | # always fix its required version to the next MINOR version.
22 | # This way, we can release minor versions of the adapter with "breaking" changes for older versions of Faraday
23 | # and then bump the version requirement on the next compatible version of faraday.
24 | spec.add_dependency 'faraday-net_http', '>= 2.0', '< 3.1'
25 | spec.add_dependency 'ruby2_keywords', '>= 0.0.4'
26 |
27 | # Includes `examples` and `spec` to allow external adapter gems to run Faraday unit and integration tests
28 | spec.files = Dir['CHANGELOG.md', '{examples,lib,spec}/**/*', 'LICENSE.md', 'Rakefile', 'README.md']
29 | spec.require_paths = %w[lib spec/external_adapters]
30 | spec.metadata = {
31 | 'homepage_uri' => 'https://lostisland.github.io/faraday',
32 | 'changelog_uri' =>
33 | "https://github.com/lostisland/faraday/releases/tag/v#{spec.version}",
34 | 'source_code_uri' => 'https://github.com/lostisland/faraday',
35 | 'bug_tracker_uri' => 'https://github.com/lostisland/faraday/issues'
36 | }
37 | end
38 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: CI
2 |
3 | on:
4 | pull_request:
5 |
6 | push:
7 | branches: [ main, 1.x, 0.1x ]
8 |
9 | env:
10 | GIT_COMMIT_SHA: ${{ github.sha }}
11 | GIT_BRANCH: ${{ github.ref }}
12 | COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
13 |
14 | permissions:
15 | contents: read # to fetch code (actions/checkout)
16 |
17 | jobs:
18 | linting:
19 | runs-on: ubuntu-latest
20 | env:
21 | BUNDLE_WITH: lint
22 | BUNDLE_WITHOUT: development:test
23 |
24 | steps:
25 | - uses: actions/checkout@v3
26 |
27 | - name: Set up Ruby 2.7
28 | uses: ruby/setup-ruby@v1
29 | with:
30 | ruby-version: 2.7
31 | bundler-cache: true
32 |
33 | - name: Rubocop
34 | run: bundle exec rubocop --format progress
35 |
36 | - name: Yard-Junk
37 | run: bundle exec yard-junk --path lib
38 |
39 | build:
40 | needs: [ linting ]
41 | runs-on: ubuntu-latest
42 | name: build ${{ matrix.ruby }}
43 | strategy:
44 | fail-fast: false
45 | matrix:
46 | ruby: [ '2.6', '2.7', '3.0', '3.1', '3.2' ]
47 | experimental: [false]
48 | include:
49 | - ruby: head
50 | experimental: true
51 | - ruby: truffleruby-head
52 | experimental: true
53 |
54 | steps:
55 | - uses: actions/checkout@v3
56 | - uses: ruby/setup-ruby@v1
57 | with:
58 | ruby-version: ${{ matrix.ruby }}
59 | bundler-cache: true
60 |
61 | - name: RSpec
62 | continue-on-error: ${{ matrix.experimental }}
63 | run: bundle exec rake
64 |
65 | - name: Test External Adapters
66 | if: ${{ matrix.ruby != '2.6' }}
67 | continue-on-error: ${{ matrix.experimental }}
68 | run: bundle exec bake test:external
69 |
70 |
71 |
--------------------------------------------------------------------------------
/docs/middleware/response/raise_error.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: documentation
3 | title: "Raise Error Middleware"
4 | permalink: /middleware/raise-error
5 | hide: true
6 | prev_name: Logger Middleware
7 | prev_link: ./logger
8 | top_name: Back to Middleware
9 | top_link: ./list
10 | ---
11 |
12 | The `RaiseError` middleware raises a `Faraday::Error` exception if an HTTP
13 | response returns with a 4xx or 5xx status code. All exceptions are initialized
14 | providing the response `status`, `headers`, and `body`.
15 |
16 | ```ruby
17 | conn = Faraday.new(url: 'http://httpbingo.org') do |faraday|
18 | faraday.response :raise_error # raise Faraday::Error on status code 4xx or 5xx
19 | end
20 |
21 | begin
22 | conn.get('/wrong-url') # => Assume this raises a 404 response
23 | rescue Faraday::ResourceNotFound => e
24 | e.response[:status] #=> 404
25 | e.response[:headers] #=> { ... }
26 | e.response[:body] #=> "..."
27 | end
28 | ```
29 |
30 | Specific exceptions are raised based on the HTTP Status code, according to the list below:
31 |
32 | An HTTP status in the 400-499 range typically represents an error
33 | by the client. They raise error classes inheriting from `Faraday::ClientError`.
34 |
35 | * 400 => `Faraday::BadRequestError`
36 | * 401 => `Faraday::UnauthorizedError`
37 | * 403 => `Faraday::ForbiddenError`
38 | * 404 => `Faraday::ResourceNotFound`
39 | * 407 => `Faraday::ProxyAuthError`
40 | * 409 => `Faraday::ConflictError`
41 | * 422 => `Faraday::UnprocessableEntityError`
42 | * 4xx => `Faraday::ClientError`
43 |
44 | An HTTP status in the 500-599 range represents a server error, and raises a
45 | `Faraday::ServerError` exception.
46 |
47 | * 5xx => `Faraday::ServerError`
48 |
49 | The HTTP response status may be nil due to a malformed HTTP response from the
50 | server, or a bug in the underlying HTTP library. It inherits from
51 | `Faraday::ServerError`.
52 |
53 | * nil => `Faraday::NilStatusError`
54 |
--------------------------------------------------------------------------------
/lib/faraday/request/url_encoded.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | class Request
5 | # Middleware for supporting urlencoded requests.
6 | class UrlEncoded < Faraday::Middleware
7 | unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
8 | CONTENT_TYPE = 'Content-Type'
9 | end
10 |
11 | class << self
12 | attr_accessor :mime_type
13 | end
14 | self.mime_type = 'application/x-www-form-urlencoded'
15 |
16 | # Encodes as "application/x-www-form-urlencoded" if not already encoded or
17 | # of another type.
18 | #
19 | # @param env [Faraday::Env]
20 | def call(env)
21 | match_content_type(env) do |data|
22 | params = Faraday::Utils::ParamsHash[data]
23 | env.body = params.to_query(env.params_encoder)
24 | end
25 | @app.call env
26 | end
27 |
28 | # @param env [Faraday::Env]
29 | # @yield [request_body] Body of the request
30 | def match_content_type(env)
31 | return unless process_request?(env)
32 |
33 | env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
34 | return if env.body.respond_to?(:to_str) || env.body.respond_to?(:read)
35 |
36 | yield(env.body)
37 | end
38 |
39 | # @param env [Faraday::Env]
40 | #
41 | # @return [Boolean] True if the request has a body and its Content-Type is
42 | # urlencoded.
43 | def process_request?(env)
44 | type = request_type(env)
45 | env.body && (type.empty? || (type == self.class.mime_type))
46 | end
47 |
48 | # @param env [Faraday::Env]
49 | #
50 | # @return [String]
51 | def request_type(env)
52 | type = env.request_headers[CONTENT_TYPE].to_s
53 | type = type.split(';', 2).first if type.index(';')
54 | type
55 | end
56 | end
57 | end
58 | end
59 |
60 | Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)
61 |
--------------------------------------------------------------------------------
/spec/faraday/middleware_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe Faraday::Middleware do
4 | subject { described_class.new(app) }
5 | let(:app) { double }
6 |
7 | describe 'options' do
8 | context 'when options are passed to the middleware' do
9 | subject { described_class.new(app, options) }
10 | let(:options) { { field: 'value' } }
11 |
12 | it 'accepts options when initialized' do
13 | expect(subject.options[:field]).to eq('value')
14 | end
15 | end
16 | end
17 |
18 | describe '#on_request' do
19 | subject do
20 | Class.new(described_class) do
21 | def on_request(env)
22 | # do nothing
23 | end
24 | end.new(app)
25 | end
26 |
27 | it 'is called by #call' do
28 | expect(app).to receive(:call).and_return(app)
29 | expect(app).to receive(:on_complete)
30 | is_expected.to receive(:call).and_call_original
31 | is_expected.to receive(:on_request)
32 | subject.call(double)
33 | end
34 | end
35 |
36 | describe '#on_error' do
37 | subject do
38 | Class.new(described_class) do
39 | def on_error(error)
40 | # do nothing
41 | end
42 | end.new(app)
43 | end
44 |
45 | it 'is called by #call' do
46 | expect(app).to receive(:call).and_raise(Faraday::ConnectionFailed)
47 | is_expected.to receive(:call).and_call_original
48 | is_expected.to receive(:on_error)
49 |
50 | expect { subject.call(double) }.to raise_error(Faraday::ConnectionFailed)
51 | end
52 | end
53 |
54 | describe '#close' do
55 | context "with app that doesn't support \#close" do
56 | it 'should issue warning' do
57 | is_expected.to receive(:warn)
58 | subject.close
59 | end
60 | end
61 |
62 | context "with app that supports \#close" do
63 | it 'should issue warning' do
64 | expect(app).to receive(:close)
65 | is_expected.to_not receive(:warn)
66 | subject.close
67 | end
68 | end
69 | end
70 | end
71 |
--------------------------------------------------------------------------------
/.rubocop_todo.yml:
--------------------------------------------------------------------------------
1 | # This configuration was generated by
2 | # `rubocop --auto-gen-config`
3 | # on 2022-08-08 14:26:32 UTC using RuboCop version 1.33.0.
4 | # The point is for the user to remove these configuration records
5 | # one by one as the offenses are removed from the code base.
6 | # Note that changes in the inspected code, or installation of new
7 | # versions of RuboCop, may require this file to be generated again.
8 |
9 | # Offense count: 6
10 | # Configuration parameters: AllowedMethods.
11 | # AllowedMethods: enums
12 | Lint/ConstantDefinitionInBlock:
13 | Exclude:
14 | - 'spec/faraday/options/options_spec.rb'
15 | - 'spec/faraday/rack_builder_spec.rb'
16 | - 'spec/faraday/request/instrumentation_spec.rb'
17 |
18 | # Offense count: 11
19 | # Configuration parameters: AllowComments, AllowEmptyLambdas.
20 | Lint/EmptyBlock:
21 | Exclude:
22 | - 'spec/faraday/connection_spec.rb'
23 | - 'spec/faraday/rack_builder_spec.rb'
24 | - 'spec/faraday/response_spec.rb'
25 |
26 | # Offense count: 12
27 | # Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods, CountRepeatedAttributes.
28 | Metrics/AbcSize:
29 | Max: 42
30 |
31 | # Offense count: 4
32 | # Configuration parameters: CountComments, CountAsOne.
33 | Metrics/ClassLength:
34 | Max: 230
35 |
36 | # Offense count: 9
37 | # Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods.
38 | Metrics/CyclomaticComplexity:
39 | Max: 13
40 |
41 | # Offense count: 26
42 | # Configuration parameters: CountComments, CountAsOne, ExcludedMethods, AllowedMethods, AllowedPatterns, IgnoredMethods.
43 | Metrics/MethodLength:
44 | Max: 33
45 |
46 | # Offense count: 1
47 | # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
48 | Metrics/ParameterLists:
49 | Max: 6
50 |
51 | # Offense count: 6
52 | # Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods.
53 | Metrics/PerceivedComplexity:
54 | Max: 14
55 |
56 | # Offense count: 3
57 | Style/DocumentDynamicEvalDefinition:
58 | Exclude:
59 | - 'lib/faraday/connection.rb'
60 | - 'lib/faraday/options.rb'
61 |
--------------------------------------------------------------------------------
/lib/faraday/request/instrumentation.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | class Request
5 | # Middleware for instrumenting Requests.
6 | class Instrumentation < Faraday::Middleware
7 | # Options class used in Request::Instrumentation class.
8 | Options = Faraday::Options.new(:name, :instrumenter) do
9 | # @return [String]
10 | def name
11 | self[:name] ||= 'request.faraday'
12 | end
13 |
14 | # @return [Class]
15 | def instrumenter
16 | self[:instrumenter] ||= ActiveSupport::Notifications
17 | end
18 | end
19 |
20 | # Instruments requests using Active Support.
21 | #
22 | # Measures time spent only for synchronous requests.
23 | #
24 | # @example Using ActiveSupport::Notifications to measure time spent
25 | # for Faraday requests.
26 | # ActiveSupport::Notifications
27 | # .subscribe('request.faraday') do |name, starts, ends, _, env|
28 | # url = env[:url]
29 | # http_method = env[:method].to_s.upcase
30 | # duration = ends - starts
31 | # $stderr.puts '[%s] %s %s (%.3f s)' %
32 | # [url.host, http_method, url.request_uri, duration]
33 | # end
34 | # @param app [#call]
35 | # @param options [nil, Hash] Options hash
36 | # @option options [String] :name ('request.faraday')
37 | # Name of the instrumenter
38 | # @option options [Class] :instrumenter (ActiveSupport::Notifications)
39 | # Active Support instrumenter class.
40 | def initialize(app, options = nil)
41 | super(app)
42 | @name, @instrumenter = Options.from(options)
43 | .values_at(:name, :instrumenter)
44 | end
45 |
46 | # @param env [Faraday::Env]
47 | def call(env)
48 | @instrumenter.instrument(@name, env) do
49 | @app.call(env)
50 | end
51 | end
52 | end
53 | end
54 | end
55 |
56 | Faraday::Request.register_middleware(instrumentation: Faraday::Request::Instrumentation)
57 |
--------------------------------------------------------------------------------
/lib/faraday/request/authorization.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Faraday
4 | class Request
5 | # Request middleware for the Authorization HTTP header
6 | class Authorization < Faraday::Middleware
7 | KEY = 'Authorization'
8 |
9 | # @param app [#call]
10 | # @param type [String, Symbol] Type of Authorization
11 | # @param params [Array' + 7 | member.author.login + 8 | '
' + 9 | '' + 10 | '
5 | {% if site.theme_settings.gravatar %}
6 |
7 | 
8 |
9 | {% elsif site.theme_settings.avatar %}
10 |
11 | 
12 |
13 | {% endif %}
14 |
18 |
58 |
59 |
8 |
9 | {% elsif site.theme_settings.avatar %}
10 |
11 |