faraday 0.15.0 → 1.3.0

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/client_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Requires Ruby with rspec and faraday gems.
+# rspec client_spec.rb
+
+require 'faraday'
+require 'json'
+
+# Example API client
+class Client
+  def initialize(conn)
+    @conn = conn
+  end
+
+  def sushi(jname)
+    res = @conn.get("/#{jname}")
+    data = JSON.parse(res.body)
+    data['name']
+  end
+end
+
+RSpec.describe Client do
+  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
+  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
+  let(:client) { Client.new(conn) }
+
+  it 'parses name' do
+    stubs.get('/ebi') do |env|
+      # optional: you can inspect the Faraday::Env
+      expect(env.url.path).to eq('/ebi')
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    expect(client.sushi('ebi')).to eq('shrimp')
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles 404' do
+    stubs.get('/ebi') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+    expect(client.sushi('ebi')).to be_nil
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles exception' do
+    stubs.get('/ebi') do
+      raise Faraday::ConnectionFailed, nil
+    end
+
+    expect { client.sushi('ebi') }.to raise_error(Faraday::ConnectionFailed)
+    stubs.verify_stubbed_calls
+  end
+end

data/examples/client_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Requires Ruby with test-unit and faraday gems.
+# ruby client_test.rb
+
+require 'faraday'
+require 'json'
+require 'test/unit'
+
+# Example API client
+class Client
+  def initialize(conn)
+    @conn = conn
+  end
+
+  def sushi(jname)
+    res = @conn.get("/#{jname}")
+    data = JSON.parse(res.body)
+    data['name']
+  end
+end
+
+# Example API client test
+class ClientTest < Test::Unit::TestCase
+  def test_sushi_name
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do |env|
+      # optional: you can inspect the Faraday::Env
+      assert_equal '/ebi', env.url.path
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    cli = client(stubs)
+    assert_equal 'shrimp', cli.sushi('ebi')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_sushi_404
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_nil cli.sushi('ebi')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_sushi_exception
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do
+      raise Faraday::ConnectionFailed, nil
+    end
+
+    cli = client(stubs)
+    assert_raise Faraday::ConnectionFailed do
+      cli.sushi('ebi')
+    end
+    stubs.verify_stubbed_calls
+  end
+
+  def client(stubs)
+    conn = Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+    Client.new(conn)
+  end
+end

data/lib/faraday.rb

@@ -1,248 +1,176 @@
-require 'thread'
+# frozen_string_literal: true
+
 require 'cgi'
+require 'date'
 require 'set'
 require 'forwardable'
+require 'faraday/middleware_registry'
+require 'faraday/dependency_loader'
+
+unless defined?(::Faraday::Timer)
+  require 'timeout'
+  ::Faraday::Timer = Timeout
+end
 
-# Public: This is the main namespace for Faraday.  You can either use it to
-# create Faraday::Connection objects, or access it directly.
+require 'faraday/version'
+require 'faraday/methods'
+require 'faraday/utils'
+require 'faraday/options'
+require 'faraday/connection'
+require 'faraday/rack_builder'
+require 'faraday/parameters'
+require 'faraday/middleware'
+require 'faraday/adapter'
+require 'faraday/request'
+require 'faraday/response'
+require 'faraday/error'
+require 'faraday/file_part'
+require 'faraday/param_part'
+
+require 'faraday/net_http'
+
+# This is the main namespace for Faraday.
 #
-# Examples
+# It provides methods to create {Connection} objects, and HTTP-related
+# methods to use directly.
 #
+# @example Helpful class methods for easy usage
 #   Faraday.get "http://faraday.com"
 #
+# @example Helpful class method `.new` to create {Connection} objects.
 #   conn = Faraday.new "http://faraday.com"
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.15.0"
-
   class << self
-    # Public: Gets or sets the root path that Faraday is being loaded from.
-    # This is the root from where the libraries are auto-loaded from.
+    # The root path that Faraday is being loaded from.
+    #
+    # This is the root from where the libraries are auto-loaded.
+    #
+    # @return [String]
     attr_accessor :root_path
 
-    # Public: Gets or sets the path that the Faraday libs are loaded from.
+    # Gets or sets the path that the Faraday libs are loaded from.
+    # @return [String]
     attr_accessor :lib_path
 
-    # Public: Gets or sets the Symbol key identifying a default Adapter to use
-    # for the default Faraday::Connection.
+    # @overload default_adapter
+    #   Gets the Symbol key identifying a default Adapter to use
+    #   for the default {Faraday::Connection}. Defaults to `:net_http`.
+    #   @return [Symbol] the default adapter
+    # @overload default_adapter=(adapter)
+    #   Updates default adapter while resetting {.default_connection}.
+    #   @return [Symbol] the new default_adapter.
     attr_reader :default_adapter
 
-    # Public: Sets the default Faraday::Connection for simple scripts that
-    # access the Faraday constant directly.
-    #
-    #     Faraday.get "https://faraday.com"
+    # Documented below, see default_connection
     attr_writer :default_connection
 
-    # Public: Tells faraday to ignore the environment proxy (http_proxy).
+    # Tells Faraday to ignore the environment proxy (http_proxy).
+    # Defaults to `false`.
+    # @return [Boolean]
     attr_accessor :ignore_env_proxy
 
-    # Public: Initializes a new Faraday::Connection.
-    #
-    # url     - The optional String base URL to use as a prefix for all
-    #           requests.  Can also be the options Hash.
-    # options - The optional Hash used to configure this Faraday::Connection.
-    #           Any of these values will be set on every request made, unless
-    #           overridden for a specific request.
-    #           :url     - String base URL.
-    #           :params  - Hash of URI query unencoded key/value pairs.
-    #           :headers - Hash of unencoded HTTP header key/value pairs.
-    #           :request - Hash of request options.
-    #           :ssl     - Hash of SSL options.
-    #           :proxy   - Hash of Proxy options.
-    #
-    # Examples
-    #
+    # Initializes a new {Connection}.
+    #
+    # @param url [String,Hash] The optional String base URL to use as a prefix
+    #           for all requests.  Can also be the options Hash. Any of these
+    #           values will be set on every request made, unless overridden
+    #           for a specific request.
+    # @param options [Hash]
+    # @option options [String] :url Base URL
+    # @option options [Hash] :params Hash of unencoded URI query params.
+    # @option options [Hash] :headers Hash of unencoded HTTP headers.
+    # @option options [Hash] :request Hash of request options.
+    # @option options [Hash] :ssl Hash of SSL options.
+    # @option options [Hash] :proxy Hash of Proxy options.
+    # @return [Faraday::Connection]
+    #
+    # @example With an URL argument
     #   Faraday.new 'http://faraday.com'
-    #
-    #   # http://faraday.com?page=1
-    #   Faraday.new 'http://faraday.com', :params => {:page => 1}
-    #
-    #   # same
-    #
-    #   Faraday.new :url => 'http://faraday.com',
-    #     :params => {:page => 1}
-    #
-    # Returns a Faraday::Connection.
-    def new(url = nil, options = nil)
-      block = block_given? ? Proc.new : nil
-      options = options ? default_connection_options.merge(options) : default_connection_options
+    #   # => Faraday::Connection to http://faraday.com
+    #
+    # @example With an URL argument and an options hash
+    #   Faraday.new 'http://faraday.com', params: { page: 1 }
+    #   # => Faraday::Connection to http://faraday.com?page=1
+    #
+    # @example With everything in an options hash
+    #   Faraday.new url: 'http://faraday.com',
+    #               params: { page: 1 }
+    #   # => Faraday::Connection to http://faraday.com?page=1
+    def new(url = nil, options = {}, &block)
+      options = default_connection_options.merge(options)
       Faraday::Connection.new(url, options, &block)
     end
 
+    # @private
     # Internal: Requires internal Faraday libraries.
     #
-    # *libs - One or more relative String names to Faraday classes.
-    #
-    # Returns nothing.
+    # @param libs [Array] one or more relative String names to Faraday classes.
+    # @return [void]
     def require_libs(*libs)
       libs.each do |lib|
         require "#{lib_path}/#{lib}"
       end
     end
 
-    # Public: Updates default adapter while resetting
-    # #default_connection.
-    #
-    # Returns the new default_adapter.
+    alias require_lib require_libs
+
+    # Documented elsewhere, see default_adapter reader
     def default_adapter=(adapter)
       @default_connection = nil
       @default_adapter = adapter
     end
 
-    alias require_lib require_libs
-
-    def respond_to?(symbol, include_private = false)
+    def respond_to_missing?(symbol, include_private = false)
       default_connection.respond_to?(symbol, include_private) || super
     end
 
-  private
-    # Internal: Proxies method calls on the Faraday constant to
-    # #default_connection.
-    def method_missing(name, *args, &block)
-      default_connection.send(name, *args, &block)
+    # @overload default_connection
+    #   Gets the default connection used for simple scripts.
+    #   @return [Faraday::Connection] a connection configured with
+    #   the default_adapter.
+    # @overload default_connection=(connection)
+    #   @param connection [Faraday::Connection]
+    #   Sets the default {Faraday::Connection} for simple scripts that
+    #   access the Faraday constant directly, such as
+    #   <code>Faraday.get "https://faraday.com"</code>.
+    def default_connection
+      @default_connection ||= Connection.new(default_connection_options)
     end
-  end
-
-  self.ignore_env_proxy = false
-  self.root_path = File.expand_path "..", __FILE__
-  self.lib_path = File.expand_path "../faraday", __FILE__
-  self.default_adapter = :net_http
-
-  # Gets the default connection used for simple scripts.
-  #
-  # Returns a Faraday::Connection, configured with the #default_adapter.
-  def self.default_connection
-    @default_connection ||= Connection.new(default_connection_options)
-  end
-
-  # Gets the default connection options used when calling Faraday#new.
-  #
-  # Returns a Faraday::ConnectionOptions.
-  def self.default_connection_options
-    @default_connection_options ||= ConnectionOptions.new
-  end
-
-  # Public: Sets the default options used when calling Faraday#new.
-  def self.default_connection_options=(options)
-    @default_connection = nil
-    @default_connection_options = ConnectionOptions.from(options)
-  end
-
-  unless const_defined? :Timer
-    require 'timeout'
-    Timer = Timeout
-  end
 
-  # Public: Adds the ability for other modules to register and lookup
-  # middleware classes.
-  module MiddlewareRegistry
-    # Public: Register middleware class(es) on the current module.
-    #
-    # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
-    #           as fully qualified constant, or a Proc that will be lazily
-    #           called to return the former.
-    #
-    # Examples
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
-    #       register_middleware :foo => Foo
+    # Gets the default connection options used when calling {Faraday#new}.
     #
-    #       # Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)
-    #       register_middleware :bar => :Bar
-    #
-    #       # Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)
-    #       register_middleware :baz => [:Baz, 'baz']
-    #     end
-    #   end
-    #
-    # Returns nothing.
-    def register_middleware(autoload_path = nil, mapping = nil)
-      if mapping.nil?
-        mapping = autoload_path
-        autoload_path = nil
-      end
-      middleware_mutex do
-        @middleware_autoload_path = autoload_path if autoload_path
-        (@registered_middleware ||= {}).update(mapping)
-      end
+    # @return [Faraday::ConnectionOptions]
+    def default_connection_options
+      @default_connection_options ||= ConnectionOptions.new
     end
 
-    # Public: Lookup middleware class with a registered Symbol shortcut.
-    #
-    # key - The Symbol key for the registered middleware.
-    #
-    # Examples
-    #
-    #   module Faraday
-    #     class Whatever
-    #       register_middleware :foo => Foo
-    #     end
-    #   end
+    # Sets the default options used when calling {Faraday#new}.
     #
-    #   Faraday::Whatever.lookup_middleware(:foo)
-    #   # => Faraday::Whatever::Foo
-    #
-    # Returns a middleware Class.
-    def lookup_middleware(key)
-      load_middleware(key) ||
-        raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
-    end
-
-    def middleware_mutex(&block)
-      @middleware_mutex ||= begin
-        require 'monitor'
-        Monitor.new
-      end
-      @middleware_mutex.synchronize(&block)
+    # @param options [Hash, Faraday::ConnectionOptions]
+    def default_connection_options=(options)
+      @default_connection = nil
+      @default_connection_options = ConnectionOptions.from(options)
     end
 
-    def fetch_middleware(key)
-      defined?(@registered_middleware) && @registered_middleware[key]
-    end
+    private
 
-    def load_middleware(key)
-      value = fetch_middleware(key)
-      case value
-      when Module
-        value
-      when Symbol, String
-        middleware_mutex do
-          @registered_middleware[key] = const_get(value)
-        end
-      when Proc
-        middleware_mutex do
-          @registered_middleware[key] = value.call
-        end
-      when Array
-        middleware_mutex do
-          const, path = value
-          if root = @middleware_autoload_path
-            path = "#{root}/#{path}"
-          end
-          require(path)
-          @registered_middleware[key] = const
-        end
-        load_middleware(key)
+    # Internal: Proxies method calls on the Faraday constant to
+    # .default_connection.
+    def method_missing(name, *args, &block)
+      if default_connection.respond_to?(name)
+        default_connection.send(name, *args, &block)
+      else
+        super
       end
     end
   end
 
-  def self.const_missing(name)
-    if name.to_sym == :Builder
-      warn "Faraday::Builder is now Faraday::RackBuilder."
-      const_set name, RackBuilder
-    else
-      super
-    end
-  end
-
-  require_libs "utils", "options", "connection", "rack_builder", "parameters",
-    "middleware", "adapter", "request", "response", "upload_io", "error"
+  self.ignore_env_proxy = false
+  self.root_path = File.expand_path __dir__
+  self.lib_path = File.expand_path 'faraday', __dir__
+  self.default_adapter = :net_http
 
-  if !ENV["FARADAY_NO_AUTOLOAD"]
-    require_lib 'autoload'
-  end
+  require_lib 'autoload' unless ENV['FARADAY_NO_AUTOLOAD']
 end