faraday 0.9.1 → 2.5.2

data/lib/faraday/adapter/typhoeus.rb

@@ -1,123 +0,0 @@
-module Faraday
-  class Adapter
-    class Typhoeus < Faraday::Adapter
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = {})
-        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
-      end
-
-      dependency 'typhoeus'
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        read_body env
-
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        hydra.queue request(env)
-        hydra.run unless parallel?(env)
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-      end
-
-      def request(env)
-        method = env[:method]
-        # For some reason, prevents Typhoeus from using "100-continue".
-        # We want this because Webrick 1.3.1 can't seem to handle it w/ PUT.
-        method = method.to_s.upcase if method == :put
-
-        req = ::Typhoeus::Request.new env[:url].to_s,
-          :method  => method,
-          :body    => env[:body],
-          :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl] && env[:ssl].disable?)
-
-        configure_ssl     req, env
-        configure_proxy   req, env
-        configure_timeout req, env
-        configure_socket  req, env
-
-        req.on_complete do |resp|
-          if resp.timed_out?
-            if parallel?(env)
-              # TODO: error callback in async mode
-            else
-              raise Faraday::Error::TimeoutError, "request timed out"
-            end
-          end
-
-          case resp.curl_return_code
-          when 0
-            # everything OK
-          when 7
-            raise Error::ConnectionFailed, resp.curl_error_message
-          when 60
-            raise Faraday::SSLError, resp.curl_error_message
-          else
-            raise Error::ClientError, resp.curl_error_message
-          end
-
-          save_response(env, resp.code, resp.body) do |response_headers|
-            response_headers.parse resp.headers
-          end
-          # in async mode, :response is initialized at this point
-          env[:response].finish(env) if parallel?(env)
-        end
-
-        req
-      end
-
-      def configure_ssl(req, env)
-        ssl = env[:ssl]
-
-        req.ssl_version = ssl[:version]          if ssl[:version]
-        req.ssl_cert    = ssl[:client_cert] if ssl[:client_cert]
-        req.ssl_key     = ssl[:client_key]  if ssl[:client_key]
-        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
-        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
-      end
-
-      def configure_proxy(req, env)
-        proxy = request_options(env)[:proxy]
-        return unless proxy
-
-        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
-
-        if proxy[:user] && proxy[:password]
-          req.proxy_username = proxy[:user]
-          req.proxy_password = proxy[:password]
-        end
-      end
-
-      def configure_timeout(req, env)
-        env_req = request_options(env)
-        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
-        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
-      end
-
-      def configure_socket(req, env)
-        if bind = request_options(env)[:bind]
-          req.interface = bind[:host]
-        end
-      end
-
-      def request_options(env)
-        env[:request]
-      end
-
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
-    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',
-      :Typhoeus          => 'typhoeus',
-      :EMSynchrony       => 'em_synchrony',
-      :EMHttp            => 'em_http',
-      :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,63 +0,0 @@
-require File.expand_path("../url_encoded", __FILE__)
-
-module Faraday
-  class Request::Multipart < Request::UrlEncoded
-    self.mime_type = 'multipart/form-data'.freeze
-    DEFAULT_BOUNDARY = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY
-
-    def call(env)
-      match_content_type(env) do |params|
-        env.request.boundary ||= DEFAULT_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 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

data/lib/faraday/request/retry.rb

@@ -1,148 +0,0 @@
-module Faraday
-  # Catches exceptions and retries each request a limited number of times.
-  #
-  # By default, it retries 2 times and handles only timeout exceptions. It can
-  # be configured with an arbitrary number of retries, a list of exceptions to
-  # handle, a retry interval, a percentage of randomness to add to the retry
-  # interval, and a backoff factor.
-  #
-  # Examples
-  #
-  #   Faraday.new do |conn|
-  #     conn.request :retry, max: 2, interval: 0.05,
-  #                          interval_randomness: 0.5, backoff_factor: 2
-  #                          exceptions: [CustomException, 'Timeout::Error']
-  #     conn.adapter ...
-  #   end
-  #
-  # This example will result in a first interval that is random between 0.05 and 0.075 and a second
-  # interval that is random between 0.1 and 0.15
-  #
-  class Request::Retry < Faraday::Middleware
-
-    IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
-
-    class Options < Faraday::Options.new(:max, :interval, :interval_randomness, :backoff_factor,
-                                         :exceptions, :methods, :retry_if)
-      DEFAULT_CHECK = lambda { |env,exception| false }
-
-      def self.from(value)
-        if Fixnum === value
-          new(value)
-        else
-          super(value)
-        end
-      end
-
-      def max
-        (self[:max] ||= 2).to_i
-      end
-
-      def interval
-        (self[:interval] ||= 0).to_f
-      end
-
-      def interval_randomness
-        (self[:interval_randomness] ||= 0).to_i
-      end
-
-      def backoff_factor
-        (self[:backoff_factor] ||= 1).to_f
-      end
-
-      def exceptions
-        Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
-                                     Error::TimeoutError])
-      end
-
-      def methods
-        Array(self[:methods] ||= IDEMPOTENT_METHODS)
-      end
-
-      def retry_if
-        self[:retry_if] ||= DEFAULT_CHECK
-      end
-
-    end
-
-    # Public: Initialize middleware
-    #
-    # Options:
-    # max                 - Maximum number of retries (default: 2)
-    # interval            - Pause in seconds between retries (default: 0)
-    # interval_randomness - The maximum random interval amount expressed
-    #                       as a float between 0 and 1 to use in addition to the
-    #                       interval. (default: 0)
-    # backoff_factor      - The amount to multiple each successive retry's
-    #                       interval amount by in order to provide backoff
-    #                       (default: 1)
-    # exceptions          - The list of exceptions to handle. Exceptions can be
-    #                       given as Class, Module, or String. (default:
-    #                       [Errno::ETIMEDOUT, Timeout::Error,
-    #                       Error::TimeoutError])
-    # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
-    #                       an empty Array to call retry_if for all exceptions.
-    #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
-    # retry_if            - block that will receive the env object and the exception raised
-    #                       and should decide if the code should retry still the action or
-    #                       not independent of the retry count. This would be useful
-    #                       if the exception produced is non-recoverable or if the
-    #                       the HTTP method called is not idempotent.
-    #                       (defaults to return false)
-    def initialize(app, options = nil)
-      super(app)
-      @options = Options.from(options)
-      @errmatch = build_exception_matcher(@options.exceptions)
-    end
-
-    def sleep_amount(retries)
-      retry_index = @options.max - retries
-      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
-      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
-      current_interval + random_interval
-    end
-
-    def call(env)
-      retries = @options.max
-      request_body = env[:body]
-      begin
-        env[:body] = request_body # after failure env[:body] is set to the response body
-        @app.call(env)
-      rescue @errmatch => exception
-        if retries > 0 && retry_request?(env, exception)
-          retries -= 1
-          sleep sleep_amount(retries + 1)
-          retry
-        end
-        raise
-      end
-    end
-
-    # Private: construct an exception matcher object.
-    #
-    # An exception matcher for the rescue clause can usually be any object that
-    # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
-    def build_exception_matcher(exceptions)
-      matcher = Module.new
-      (class << matcher; self; end).class_eval do
-        define_method(:===) do |error|
-          exceptions.any? do |ex|
-            if ex.is_a? Module
-              error.is_a? ex
-            else
-              error.class.to_s == ex.to_s
-            end
-          end
-        end
-      end
-      matcher
-    end
-
-    private
-
-    def retry_request?(env, exception)
-      @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
-    end
-
-  end
-end

data/lib/faraday/request/token_authentication.rb

@@ -1,15 +0,0 @@
-module Faraday
-  class Request::TokenAuthentication < Request.load_middleware(:authorization)
-    # Public
-    def self.header(token, options = nil)
-      options ||= {}
-      options[:token] = token
-      super(:Token, options)
-    end
-
-    def initialize(app, token, options = nil)
-      super(app, token, options)
-    end
-  end
-end
-

data/lib/faraday/upload_io.rb

@@ -1,67 +0,0 @@
-begin
-  require 'composite_io'
-  require 'parts'
-  require 'stringio'
-rescue LoadError
-  $stderr.puts "Install the multipart-post gem."
-  raise
-end
-
-module Faraday
-  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
-  class CompositeReadIO
-    def initialize(*parts)
-      @parts = parts.flatten
-      @ios = @parts.map { |part| part.to_io }
-      @index = 0
-    end
-
-    def length
-      @parts.inject(0) { |sum, part| sum + part.length }
-    end
-
-    def rewind
-      @ios.each { |io| io.rewind }
-      @index = 0
-    end
-
-    # Read from IOs in order until `length` bytes have been received.
-    def read(length = nil, outbuf = nil)
-      got_result = false
-      outbuf = outbuf ? outbuf.replace("") : ""
-
-      while io = current_io
-        if result = io.read(length)
-          got_result ||= !result.nil?
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
-          outbuf << result
-          length -= result.length if length
-          break if length == 0
-        end
-        advance_io
-      end
-      (!got_result && length) ? nil : outbuf
-    end
-
-    def close
-      @ios.each { |io| io.close }
-    end
-
-    def ensure_open_and_readable
-      # Rubinius compatibility
-    end
-
-    private
-
-    def current_io
-      @ios[@index]
-    end
-
-    def advance_io
-      @index += 1
-    end
-  end
-
-  UploadIO = ::UploadIO
-  Parts = ::Parts
-end

data/script/cached-bundle

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

data/script/console

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-# Usage: script/console
-# Starts an IRB console with this library loaded.
-
-gemspec="$(ls *.gemspec | head -1)"
-
-exec bundle exec irb -r "${gemspec%.*}"

data/script/generate_certs

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-# Usage: generate_certs
-# Generate test certs for testing Faraday with SSL
-
-require 'openssl'
-require 'fileutils'
-
-$shell = ARGV.include? '-s'
-
-# Adapted from WEBrick::Utils. Skips cert extensions so it
-# can be used as a CA bundle
-def create_self_signed_cert(bits, cn, comment)
-  rsa = OpenSSL::PKey::RSA.new(bits)
-  cert = OpenSSL::X509::Certificate.new
-  cert.version = 2
-  cert.serial = 1
-  name = OpenSSL::X509::Name.new(cn)
-  cert.subject = name
-  cert.issuer = name
-  cert.not_before = Time.now
-  cert.not_after = Time.now + (365*24*60*60)
-  cert.public_key = rsa.public_key
-  cert.sign(rsa, OpenSSL::Digest::SHA1.new)
-  return [cert, rsa]
-end
-
-def write(file, contents, env_var)
-  FileUtils.mkdir_p(File.dirname(file))
-  File.open(file, 'w') {|f| f.puts(contents) }
-  puts %(export #{env_var}="#{file}") if $shell
-end
-
-
-# One cert / CA for ease of testing when ignoring verification
-cert, key = create_self_signed_cert(1024, [['CN', 'localhost']], 'Faraday Test CA')
-write 'tmp/faraday-cert.key', key,  'SSL_KEY'
-write 'tmp/faraday-cert.crt', cert, 'SSL_FILE'
-
-# And a second CA to prove that verification can fail
-cert, key = create_self_signed_cert(1024, [['CN', 'real-ca.com']], 'A different CA')
-write 'tmp/faraday-different-ca-cert.key', key,  'SSL_KEY_ALT'
-write 'tmp/faraday-different-ca-cert.crt', cert, 'SSL_FILE_ALT'

data/script/package

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-# Usage: script/gem
-# Updates the gemspec and builds a new gem in the pkg directory.
-
-mkdir -p pkg
-gem build *.gemspec
-mv *.gem pkg

data/script/proxy-server

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-# Usage: script/proxy-server [-p PORT] [-u USER:PASSWORD]
-require 'webrick'
-require 'webrick/httpproxy'
-
-port = 4001
-
-if found = ARGV.index('-p')
-  port = ARGV[found + 1].to_i
-end
-if found = ARGV.index('-u')
-  username, password = ARGV[found + 1].split(':', 2)
-end
-
-match_credentials = lambda { |credentials|
-  got_username, got_password = credentials.to_s.unpack("m*")[0].split(":", 2)
-  got_username == username && got_password == password
-}
-
-log_io = $stdout
-log_io.sync = true
-
-webrick_opts = {
-  :Port => port, :Logger => WEBrick::Log::new(log_io),
-  :AccessLog => [[log_io, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]],
-  :ProxyAuthProc => lambda { |req, res|
-    if username
-      type, credentials = req.header['proxy-authorization'].first.to_s.split(/\s+/, 2)
-      unless "Basic" == type && match_credentials.call(credentials)
-        res['proxy-authenticate'] = %{Basic realm="testing"}
-        raise WEBrick::HTTPStatus::ProxyAuthenticationRequired
-      end
-    end
-  }
-}
-
-proxy = WEBrick::HTTPProxyServer.new(webrick_opts)
-
-trap(:TERM) { proxy.shutdown }
-trap(:INT) { proxy.shutdown }
-
-proxy.start

data/script/release

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# Usage: script/release
-# Build the package, tag a commit, push it to origin, and then release the
-# package publicly.
-
-set -e
-
-version="$(script/package | grep Version: | awk '{print $2}')"
-[ -n "$version" ] || exit 1
-
-git commit --allow-empty -a -m "Release $version"
-git tag "v$version"
-git push origin
-git push origin "v$version"
-git push legacy
-git push legacy "v$version"
-gem push pkg/*-${version}.gem