faraday 0.15.0 → 2.2.0

data/lib/faraday/adapter/net_http.rb

@@ -1,137 +0,0 @@
-begin
-  require 'net/https'
-rescue LoadError
-  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
-  require 'net/http'
-end
-require 'zlib'
-
-module Faraday
-  class Adapter
-    class NetHttp < Faraday::Adapter
-      NET_HTTP_EXCEPTIONS = [
-        IOError,
-        Errno::ECONNABORTED,
-        Errno::ECONNREFUSED,
-        Errno::ECONNRESET,
-        Errno::EHOSTUNREACH,
-        Errno::EINVAL,
-        Errno::ENETUNREACH,
-        Errno::EPIPE,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        SocketError,
-        Zlib::GzipFile::Error,
-      ]
-
-      NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
-      NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
-
-      def call(env)
-        super
-        with_net_http_connection(env) do |http|
-          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-          configure_request(http, env[:request])
-
-          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
-
-          save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
-            http_response.each_header do |key, value|
-              response_headers[key] = value
-            end
-          end
-        end
-
-        @app.call env
-      rescue Timeout::Error, Errno::ETIMEDOUT => err
-        raise Faraday::Error::TimeoutError, err
-      end
-
-      private
-
-      def create_request(env)
-        request = Net::HTTPGenericRequest.new \
-          env[:method].to_s.upcase,    # request method
-          !!env[:body],                # is there request body
-          :head != env[:method],       # is there response body
-          env[:url].request_uri,       # request uri path
-          env[:request_headers]        # request headers
-
-        if env[:body].respond_to?(:read)
-          request.body_stream = env[:body]
-        else
-          request.body = env[:body]
-        end
-        request
-      end
-
-      def perform_request(http, env)
-        if :get == env[:method] and !env[:body]
-          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
-          http.get env[:url].request_uri, env[:request_headers]
-        else
-          http.request create_request(env)
-        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].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
-        else
-          Net::HTTP
-        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
-      end
-
-      def configure_ssl(http, ssl)
-        http.use_ssl      = true
-        http.verify_mode  = ssl_verify_mode(ssl)
-        http.cert_store   = ssl_cert_store(ssl)
-
-        http.cert         = ssl[:client_cert]  if ssl[:client_cert]
-        http.key          = ssl[:client_key]   if ssl[:client_key]
-        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-        http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
-        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        http.ssl_version  = ssl[:version]      if ssl[:version]
-      end
-
-      def configure_request(http, req)
-        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
-
-        @config_block.call(http) if @config_block
-      end
-
-      def ssl_cert_store(ssl)
-        return ssl[:cert_store] if ssl[:cert_store]
-        # Use the default cert store by default, i.e. system ca certs
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.set_default_paths
-        cert_store
-      end
-
-      def ssl_verify_mode(ssl)
-        ssl[:verify_mode] || begin
-          if ssl.fetch(:verify, true)
-            OpenSSL::SSL::VERIFY_PEER
-          else
-            OpenSSL::SSL::VERIFY_NONE
-          end
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,63 +0,0 @@
-module Faraday
-  class Adapter
-    class NetHttpPersistent < NetHttp
-      dependency 'net/http/persistent'
-
-      private
-
-      def net_http_connection(env)
-        proxy_uri = proxy_uri(env)
-
-        cached_connection env[:url], proxy_uri do
-          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
-            Net::HTTP::Persistent.new(name: 'Faraday', proxy: proxy_uri)
-          else
-            Net::HTTP::Persistent.new('Faraday', proxy_uri)
-          end
-        end
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        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
-          # awful patch for net-http-persistent 2.8 not unescaping user/password
-          (class << proxy_uri; self; end).class_eval do
-            define_method(:user) { proxy[:user] }
-            define_method(:password) { proxy[:password] }
-          end if proxy[:user]
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        http.request env[:url], create_request(env)
-      rescue Errno::ETIMEDOUT => error
-        raise Faraday::Error::TimeoutError, error
-      rescue Net::HTTP::Persistent::Error => error
-        if error.message.include? 'Timeout'
-          raise Faraday::Error::TimeoutError, error
-        elsif error.message.include? 'connection refused'
-          raise Faraday::Error::ConnectionFailed, error
-        else
-          raise
-        end
-      end
-
-      def configure_ssl(http, ssl)
-        http.verify_mode  = ssl_verify_mode(ssl)
-        http.cert_store   = ssl_cert_store(ssl)
-
-        http.certificate  = ssl[:client_cert]  if ssl[:client_cert]
-        http.private_key  = ssl[:client_key]   if ssl[:client_key]
-        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-        http.ssl_version  = ssl[:version]      if ssl[:version]
-      end
-
-      def cached_connection(url, proxy_uri)
-        (@cached_connection ||= {})[[url.scheme, url.host, url.port, proxy_uri]] ||= yield
-      end
-    end
-  end
-end

data/lib/faraday/adapter/patron.rb

@@ -1,100 +0,0 @@
-module Faraday
-  class Adapter
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        session = @session ||= create_session
-        configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-        if req = env[:request]
-          session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
-          session.connect_timeout = req[:open_timeout]              if req[:open_timeout]
-
-          if proxy = req[:proxy]
-            proxy_uri = proxy[:uri].dup
-            proxy_uri.user = proxy[:user] && Utils.escape(proxy[:user]).gsub('+', '%20')
-            proxy_uri.password = proxy[:password] && Utils.escape(proxy[:password]).gsub('+', '%20')
-            session.proxy = proxy_uri.to_s
-          end
-        end
-
-        response = begin
-          data = env[:body] ? env[:body].to_s : nil
-          session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
-        rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-          raise Error::ConnectionFailed, $!
-        end
-
-        # Remove the "HTTP/1.1 200", leaving just the reason phrase
-        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
-
-        save_response(env, response.status, response.body, response.headers, reason_phrase)
-
-        @app.call env
-      rescue ::Patron::TimeoutError => err
-        if connection_timed_out_message?(err.message)
-          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 "}
-        else
-          raise Error::ConnectionFailed, err
-        end
-      end
-
-      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
-        # HAX: helps but doesn't work completely
-        # https://github.com/toland/patron/issues/34
-        ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          if actions[0].is_a?(Symbol)
-            actions << :patch unless actions.include? :patch
-            actions << :options unless actions.include? :options
-          else
-            # Patron 0.4.20 and up
-            actions << "PATCH" unless actions.include? "PATCH"
-            actions << "OPTIONS" unless actions.include? "OPTIONS"
-          end
-        end
-      end
-
-      def create_session
-        session = ::Patron::Session.new
-        @config_block.call(session) if @config_block
-        session
-      end
-
-      def configure_ssl(session, ssl)
-        if ssl.fetch(:verify, true)
-          session.cacert = ssl[:ca_file]
-        else
-          session.insecure = true
-        end
-      end
-
-      private
-
-      CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
-          "Connection timed out",
-          "Timed out before name resolve",
-          "server connect has timed out",
-          "Resolving timed out",
-          "name lookup timed out",
-          "timed out before SSL",
-          "connect() timed out"
-        ].freeze
-
-      def connection_timed_out_message?(message)
-        CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
-      end
-
-    end
-  end
-end

data/lib/faraday/adapter/rack.rb

@@ -1,58 +0,0 @@
-module Faraday
-  class Adapter
-    # Sends requests to a Rack app.
-    #
-    # Examples
-    #
-    #   class MyRackApp
-    #     def call(env)
-    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
-    #     end
-    #   end
-    #
-    #   Faraday.new do |conn|
-    #     conn.adapter :rack, MyRackApp.new
-    #   end
-    class Rack < Faraday::Adapter
-      dependency 'rack/test'
-
-      # not prefixed with "HTTP_"
-      SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
-
-      def initialize(faraday_app, rack_app)
-        super(faraday_app)
-        mock_session = ::Rack::MockSession.new(rack_app)
-        @session     = ::Rack::Test::Session.new(mock_session)
-      end
-
-      def call(env)
-        super
-        rack_env = {
-          :method => env[:method],
-          :input  => env[:body].respond_to?(:read) ? env[:body].read : env[:body],
-          'rack.url_scheme' => env[:url].scheme
-        }
-
-        env[:request_headers].each do |name, value|
-          name = name.upcase.tr('-', '_')
-          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
-          rack_env[name] = value
-        end if env[:request_headers]
-
-        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
-        response = if timeout
-          Timer.timeout(timeout, Faraday::Error::TimeoutError) { execute_request(env, rack_env) }
-        else
-          execute_request(env, rack_env)
-        end
-
-        save_response(env, response.status, response.body, response.headers)
-        @app.call env
-      end
-
-      def execute_request(env, rack_env)
-        @session.request(env[:url].to_s, rack_env)
-      end
-    end
-  end
-end

data/lib/faraday/adapter/typhoeus.rb

@@ -1,12 +0,0 @@
-module Faraday
-  class Adapter
-    # This class is just a stub, the real adapter is in https://github.com/philsturgeon/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
-    class Typhoeus < Faraday::Adapter
-      # Needs to define this method in order to support Typhoeus <= 1.3.0
-      def call; end
-
-      dependency 'typhoeus'
-      dependency 'typhoeus/adapters/faraday'
-    end
-  end
-end

data/lib/faraday/autoload.rb

@@ -1,84 +0,0 @@
-module Faraday
-  # Internal: Adds the ability for other modules to manage autoloadable
-  # constants.
-  module AutoloadHelper
-    # Internal: Registers the constants to be auto loaded.
-    #
-    # prefix  - The String require prefix.  If the path is inside Faraday, then
-    #           it will be prefixed with the root path of this loaded Faraday
-    #           version.
-    # options - Hash of Symbol => String library names.
-    #
-    # Examples.
-    #
-    #   Faraday.autoload_all 'faraday/foo',
-    #     :Bar => 'bar'
-    #
-    #   # requires faraday/foo/bar to load Faraday::Bar.
-    #   Faraday::Bar
-    #
-    #
-    # Returns nothing.
-    def autoload_all(prefix, options)
-      if prefix =~ /^faraday(\/|$)/i
-        prefix = File.join(Faraday.root_path, prefix)
-      end
-      options.each do |const_name, path|
-        autoload const_name, File.join(prefix, path)
-      end
-    end
-
-    # Internal: Loads each autoloaded constant.  If thread safety is a concern,
-    # wrap this in a Mutex.
-    #
-    # Returns nothing.
-    def load_autoloaded_constants
-      constants.each do |const|
-        const_get(const) if autoload?(const)
-      end
-    end
-
-    # Internal: Filters the module's contents with those that have been already
-    # autoloaded.
-    #
-    # Returns an Array of Class/Module objects.
-    def all_loaded_constants
-      constants.map { |c| const_get(c) }.
-        select { |a| a.respond_to?(:loaded?) && a.loaded? }
-    end
-  end
-
-  class Adapter
-    extend AutoloadHelper
-    autoload_all 'faraday/adapter',
-      :NetHttp           => 'net_http',
-      :NetHttpPersistent => 'net_http_persistent',
-      :EMSynchrony       => 'em_synchrony',
-      :EMHttp            => 'em_http',
-      :Typhoeus          => 'typhoeus',
-      :Patron            => 'patron',
-      :Excon             => 'excon',
-      :Test              => 'test',
-      :Rack              => 'rack',
-      :HTTPClient        => 'httpclient'
-  end
-
-  class Request
-    extend AutoloadHelper
-    autoload_all 'faraday/request',
-      :UrlEncoded => 'url_encoded',
-      :Multipart => 'multipart',
-      :Retry => 'retry',
-      :Authorization => 'authorization',
-      :BasicAuthentication => 'basic_authentication',
-      :TokenAuthentication => 'token_authentication',
-      :Instrumentation => 'instrumentation'
-  end
-
-  class Response
-    extend AutoloadHelper
-    autoload_all 'faraday/response',
-      :RaiseError => 'raise_error',
-      :Logger     => 'logger'
-  end
-end

data/lib/faraday/request/basic_authentication.rb

@@ -1,13 +0,0 @@
-require 'base64'
-
-module Faraday
-  class Request::BasicAuthentication < Request.load_middleware(:authorization)
-    # Public
-    def self.header(login, pass)
-      value = Base64.encode64([login, pass].join(':'))
-      value.gsub!("\n", '')
-      super(:Basic, value)
-    end
-  end
-end
-

data/lib/faraday/request/multipart.rb

@@ -1,68 +0,0 @@
-require File.expand_path("../url_encoded", __FILE__)
-require 'securerandom'
-
-module Faraday
-  class Request::Multipart < Request::UrlEncoded
-    self.mime_type = 'multipart/form-data'.freeze
-    DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
-
-    def call(env)
-      match_content_type(env) do |params|
-        env.request.boundary ||= unique_boundary
-        env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
-        env.body = create_multipart(env, params)
-      end
-      @app.call env
-    end
-
-    def process_request?(env)
-      type = request_type(env)
-      env.body.respond_to?(:each_key) and !env.body.empty? and (
-        (type.empty? and has_multipart?(env.body)) or
-        type == self.class.mime_type
-      )
-    end
-
-    def has_multipart?(obj)
-      # string is an enum in 1.8, returning list of itself
-      if obj.respond_to?(:each) && !obj.is_a?(String)
-        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
-          return true if (val.respond_to?(:content_type) || has_multipart?(val))
-        end
-      end
-      false
-    end
-
-    def create_multipart(env, params)
-      boundary = env.request.boundary
-      parts = process_params(params) do |key, value|
-        Faraday::Parts::Part.new(boundary, key, value)
-      end
-      parts << Faraday::Parts::EpiloguePart.new(boundary)
-
-      body = Faraday::CompositeReadIO.new(parts)
-      env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
-      return body
-    end
-
-    def unique_boundary
-      "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
-    end
-
-    def process_params(params, prefix = nil, pieces = nil, &block)
-      params.inject(pieces || []) do |all, (key, value)|
-        key = "#{prefix}[#{key}]" if prefix
-
-        case value
-        when Array
-          values = value.inject([]) { |a,v| a << [nil, v] }
-          process_params(values, key, all, &block)
-        when Hash
-          process_params(value, key, all, &block)
-        else
-          all << block.call(key, value)
-        end
-      end
-    end
-  end
-end