mercadopago-custom-checkout 0.1.1

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/rack.rb

@@ -0,0 +1,58 @@
+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/.gs/gems/faraday-0.9.2/lib/faraday/adapter/test.rb

@@ -0,0 +1,162 @@
+module Faraday
+  class Adapter
+    # test = Faraday::Connection.new do
+    #   use Faraday::Adapter::Test do |stub|
+    #     stub.get '/nigiri/sake.json' do
+    #       [200, {}, 'hi world']
+    #     end
+    #   end
+    # end
+    #
+    # resp = test.get '/nigiri/sake.json'
+    # resp.body # => 'hi world'
+    #
+    class Test < Faraday::Adapter
+      attr_accessor :stubs
+
+      class Stubs
+        class NotFound < StandardError
+        end
+
+        def initialize
+          # {:get => [Stub, Stub]}
+          @stack, @consumed = {}, {}
+          yield(self) if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def match(request_method, path, headers, body)
+          return false if !@stack.key?(request_method)
+          stack = @stack[request_method]
+          consumed = (@consumed[request_method] ||= [])
+
+          if stub = matches?(stack, path, headers, body)
+            consumed << stack.delete(stub)
+            stub
+          else
+            matches?(consumed, path, headers, body)
+          end
+        end
+
+        def get(path, headers = {}, &block)
+          new_stub(:get, path, headers, &block)
+        end
+
+        def head(path, headers = {}, &block)
+          new_stub(:head, path, headers, &block)
+        end
+
+        def post(path, body=nil, headers = {}, &block)
+          new_stub(:post, path, headers, body, &block)
+        end
+
+        def put(path, body=nil, headers = {}, &block)
+          new_stub(:put, path, headers, body, &block)
+        end
+
+        def patch(path, body=nil, headers = {}, &block)
+          new_stub(:patch, path, headers, body, &block)
+        end
+
+        def delete(path, headers = {}, &block)
+          new_stub(:delete, path, headers, &block)
+        end
+
+        def options(path, headers = {}, &block)
+          new_stub(:options, path, headers, &block)
+        end
+
+        # Raises an error if any of the stubbed calls have not been made.
+        def verify_stubbed_calls
+          failed_stubs = []
+          @stack.each do |method, stubs|
+            unless stubs.size == 0
+              failed_stubs.concat(stubs.map {|stub|
+                "Expected #{method} #{stub}."
+              })
+            end
+          end
+          raise failed_stubs.join(" ") unless failed_stubs.size == 0
+        end
+
+        protected
+
+        def new_stub(request_method, path, headers = {}, body=nil, &block)
+          normalized_path = Faraday::Utils.normalize_path(path)
+          (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
+        end
+
+        def matches?(stack, path, headers, body)
+          stack.detect { |stub| stub.matches?(path, headers, body) }
+        end
+      end
+
+      class Stub < Struct.new(:path, :params, :headers, :body, :block)
+        def initialize(full, headers, body, block)
+          path, query = full.split('?')
+          params = query ?
+            Faraday::Utils.parse_nested_query(query) :
+            {}
+          super(path, params, headers, body, block)
+        end
+
+        def matches?(request_uri, request_headers, request_body)
+          request_path, request_query = request_uri.split('?')
+          request_params = request_query ?
+            Faraday::Utils.parse_nested_query(request_query) :
+            {}
+          request_path == path &&
+            params_match?(request_params) &&
+            (body.to_s.size.zero? || request_body == body) &&
+            headers_match?(request_headers)
+        end
+
+        def params_match?(request_params)
+          params.keys.all? do |key|
+            request_params[key] == params[key]
+          end
+        end
+
+        def headers_match?(request_headers)
+          headers.keys.all? do |key|
+            request_headers[key] == headers[key]
+          end
+        end
+
+        def to_s
+          "#{path} #{body}"
+        end
+      end
+
+      def initialize(app, stubs=nil, &block)
+        super(app)
+        @stubs = stubs || Stubs.new
+        configure(&block) if block
+      end
+
+      def configure
+        yield(stubs)
+      end
+
+      def call(env)
+        super
+        normalized_path = Faraday::Utils.normalize_path(env[:url])
+        params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
+
+        if stub = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+          env[:params] = (query = env[:url].query) ?
+            params_encoder.decode(query)  :
+            {}
+          status, headers, body = stub.block.call(env)
+          save_response(env, status, body, headers)
+        else
+          raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/typhoeus.rb

@@ -0,0 +1,123 @@
+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/.gs/gems/faraday-0.9.2/lib/faraday/autoload.rb

@@ -0,0 +1,84 @@
+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/.gs/gems/faraday-0.9.2/lib/faraday/connection.rb

@@ -0,0 +1,437 @@
+module Faraday
+  # Public: Connection objects manage the default properties and the middleware
+  # stack for fulfilling an HTTP request.
+  #
+  # Examples
+  #
+  #   conn = Faraday::Connection.new 'http://sushi.com'
+  #
+  #   # GET http://sushi.com/nigiri
+  #   conn.get 'nigiri'
+  #   # => #<Faraday::Response>
+  #
+  class Connection
+    # A Set of allowed HTTP verbs.
+    METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
+
+    # Public: Returns a Hash of URI query unencoded key/value pairs.
+    attr_reader :params
+
+    # Public: Returns a Hash of unencoded HTTP header key/value pairs.
+    attr_reader :headers
+
+    # Public: Returns a URI with the prefix used for all requests from this
+    # Connection.  This includes a default host name, scheme, port, and path.
+    attr_reader :url_prefix
+
+    # Public: Returns the Faraday::Builder for this Connection.
+    attr_reader :builder
+
+    # Public: Returns a Hash of the request options.
+    attr_reader :options
+
+    # Public: Returns a Hash of the SSL options.
+    attr_reader :ssl
+
+    # Public: Returns the parallel manager for this Connection.
+    attr_reader :parallel_manager
+
+    # Public: Sets the default parallel manager for this connection.
+    attr_writer :default_parallel_manager
+
+    # Public: Initializes a new Faraday::Connection.
+    #
+    # url     - URI or String base URL to use as a prefix for all
+    #           requests (optional).
+    # options - Hash or Faraday::ConnectionOptions.
+    #           :url     - URI or String base URL (default: "http:/").
+    #           :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   - URI, String or Hash of HTTP proxy options
+    #                     (default: "http_proxy" environment variable).
+    #                     :uri      - URI or String
+    #                     :user     - String (optional)
+    #                     :password - String (optional)
+    def initialize(url = nil, options = nil)
+      if url.is_a?(Hash)
+        options = ConnectionOptions.from(url)
+        url     = options.url
+      else
+        options = ConnectionOptions.from(options)
+      end
+
+      @parallel_manager = nil
+      @headers = Utils::Headers.new
+      @params  = Utils::ParamsHash.new
+      @options = options.request
+      @ssl = options.ssl
+      @default_parallel_manager = options.parallel_manager
+
+      @builder = options.builder || begin
+        # pass an empty block to Builder so it doesn't assume default middleware
+        options.new_builder(block_given? ? Proc.new { |b| } : nil)
+      end
+
+      self.url_prefix = url || 'http:/'
+
+      @params.update(options.params)   if options.params
+      @headers.update(options.headers) if options.headers
+
+      @proxy = nil
+      proxy(options.fetch(:proxy) {
+        uri = ENV['http_proxy']
+        if uri && !uri.empty?
+          uri = 'http://' + uri if uri !~ /^http/i
+          uri
+        end
+      })
+
+      yield(self) if block_given?
+
+      @headers[:user_agent] ||= "Faraday v#{VERSION}"
+    end
+
+    # Public: Sets the Hash of URI query unencoded key/value pairs.
+    def params=(hash)
+      @params.replace hash
+    end
+
+    # Public: Sets the Hash of unencoded HTTP header key/value pairs.
+    def headers=(hash)
+      @headers.replace hash
+    end
+
+    extend Forwardable
+
+    def_delegators :builder, :build, :use, :request, :response, :adapter, :app
+
+    # Public: Makes an HTTP request without a body.
+    #
+    # url     - The optional String base URL to use as a prefix for all
+    #           requests.  Can also be the options Hash.
+    # params  - Hash of URI query unencoded key/value pairs.
+    # headers - Hash of unencoded HTTP header key/value pairs.
+    #
+    # Examples
+    #
+    #   conn.get '/items', {:page => 1}, :accept => 'application/json'
+    #   conn.head '/items/1'
+    #
+    #   # ElasticSearch example sending a body with GET.
+    #   conn.get '/twitter/tweet/_search' do |req|
+    #     req.headers[:content_type] = 'application/json'
+    #     req.params[:routing] = 'kimchy'
+    #     req.body = JSON.generate(:query => {...})
+    #   end
+    #
+    # Yields a Faraday::Response for further request customizations.
+    # Returns a Faraday::Response.
+    #
+    # Signature
+    #
+    #   <verb>(url = nil, params = nil, headers = nil)
+    #
+    # verb - An HTTP verb: get, head, or delete.
+    %w[get head delete].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(url = nil, params = nil, headers = nil)
+          run_request(:#{method}, url, nil, headers) { |request|
+            request.params.update(params) if params
+            yield(request) if block_given?
+          }
+        end
+      RUBY
+    end
+
+    # Public: Makes an HTTP request with a body.
+    #
+    # url     - The optional String base URL to use as a prefix for all
+    #           requests.  Can also be the options Hash.
+    # body    - The String body for the request.
+    # headers - Hash of unencoded HTTP header key/value pairs.
+    #
+    # Examples
+    #
+    #   conn.post '/items', data, :content_type => 'application/json'
+    #
+    #   # Simple ElasticSearch indexing sample.
+    #   conn.post '/twitter/tweet' do |req|
+    #     req.headers[:content_type] = 'application/json'
+    #     req.params[:routing] = 'kimchy'
+    #     req.body = JSON.generate(:user => 'kimchy', ...)
+    #   end
+    #
+    # Yields a Faraday::Response for further request customizations.
+    # Returns a Faraday::Response.
+    #
+    # Signature
+    #
+    #   <verb>(url = nil, body = nil, headers = nil)
+    #
+    # verb - An HTTP verb: post, put, or patch.
+    %w[post put patch].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(url = nil, body = nil, headers = nil, &block)
+          run_request(:#{method}, url, body, headers, &block)
+        end
+      RUBY
+    end
+
+    # Public: Sets up the Authorization header with these credentials, encoded
+    # with base64.
+    #
+    # login - The authentication login.
+    # pass  - The authentication password.
+    #
+    # Examples
+    #
+    #   conn.basic_auth 'Aladdin', 'open sesame'
+    #   conn.headers['Authorization']
+    #   # => "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+    #
+    # Returns nothing.
+    def basic_auth(login, pass)
+      set_authorization_header(:basic_auth, login, pass)
+    end
+
+    # Public: Sets up the Authorization header with the given token.
+    #
+    # token   - The String token.
+    # options - Optional Hash of extra token options.
+    #
+    # Examples
+    #
+    #   conn.token_auth 'abcdef', :foo => 'bar'
+    #   conn.headers['Authorization']
+    #   # => "Token token=\"abcdef\",
+    #               foo=\"bar\""
+    #
+    # Returns nothing.
+    def token_auth(token, options = nil)
+      set_authorization_header(:token_auth, token, options)
+    end
+
+    # Public: Sets up a custom Authorization header.
+    #
+    # type  - The String authorization type.
+    # token - The String or Hash token.  A String value is taken literally, and
+    #         a Hash is encoded into comma separated key/value pairs.
+    #
+    # Examples
+    #
+    #   conn.authorization :Bearer, 'mF_9.B5f-4.1JqM'
+    #   conn.headers['Authorization']
+    #   # => "Bearer mF_9.B5f-4.1JqM"
+    #
+    #   conn.authorization :Token, :token => 'abcdef', :foo => 'bar'
+    #   conn.headers['Authorization']
+    #   # => "Token token=\"abcdef\",
+    #               foo=\"bar\""
+    #
+    # Returns nothing.
+    def authorization(type, token)
+      set_authorization_header(:authorization, type, token)
+    end
+
+    # Internal: Traverse the middleware stack in search of a
+    # parallel-capable adapter.
+    #
+    # Yields in case of not found.
+    #
+    # Returns a parallel manager or nil if not found.
+    def default_parallel_manager
+      @default_parallel_manager ||= begin
+        handler = @builder.handlers.detect do |h|
+          h.klass.respond_to?(:supports_parallel?) and h.klass.supports_parallel?
+        end
+
+        if handler
+          handler.klass.setup_parallel_manager
+        elsif block_given?
+          yield
+        end
+      end
+    end
+
+    # Public: Determine if this Faraday::Connection can make parallel requests.
+    #
+    # Returns true or false.
+    def in_parallel?
+      !!@parallel_manager
+    end
+
+    # Public: Sets up the parallel manager to make a set of requests.
+    #
+    # manager - The parallel manager that this Connection's Adapter uses.
+    #
+    # Yields a block to execute multiple requests.
+    # Returns nothing.
+    def in_parallel(manager = nil)
+      @parallel_manager = manager || default_parallel_manager {
+        warn "Warning: `in_parallel` called but no parallel-capable adapter on Faraday stack"
+        warn caller[2,10].join("\n")
+        nil
+      }
+      yield
+      @parallel_manager && @parallel_manager.run
+    ensure
+      @parallel_manager = nil
+    end
+
+    # Public: Gets or Sets the Hash proxy options.
+    def proxy(arg = nil)
+      return @proxy if arg.nil?
+      @proxy = ProxyOptions.from(arg)
+    end
+
+    def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=
+    def_delegator :url_prefix, :path, :path_prefix
+
+    # Public: Parses the giving url with URI and stores the individual
+    # components in this connection.  These components serve as defaults for
+    # requests made by this connection.
+    #
+    # url - A String or URI.
+    #
+    # Examples
+    #
+    #   conn = Faraday::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
+    #
+    # Returns the parsed URI from teh given input..
+    def url_prefix=(url, encoder = nil)
+      uri = @url_prefix = Utils.URI(url)
+      self.path_prefix = uri.path
+
+      params.merge_query(uri.query, encoder)
+      uri.query = nil
+
+      with_uri_credentials(uri) do |user, password|
+        basic_auth user, password
+        uri.user = uri.password = nil
+      end
+
+      uri
+    end
+
+    # Public: Sets the path prefix and ensures that it always has a leading
+    # slash.
+    #
+    # value - A String.
+    #
+    # Returns the new String path prefix.
+    def path_prefix=(value)
+      url_prefix.path = if value
+        value = '/' + value unless value[0,1] == '/'
+        value
+      end
+    end
+
+    # Public: Takes a relative url for a request and combines it with the defaults
+    # set on the connection instance.
+    #
+    #   conn = Faraday::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api?token=abc"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
+    #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
+    #
+    def build_url(url = nil, extra_params = nil)
+      uri = build_exclusive_url(url)
+
+      query_values = params.dup.merge_query(uri.query, options.params_encoder)
+      query_values.update extra_params if extra_params
+      uri.query = query_values.empty? ? nil : query_values.to_query(options.params_encoder)
+
+      uri
+    end
+
+    # Builds and runs the Faraday::Request.
+    #
+    # method  - The Symbol HTTP method.
+    # url     - The String or URI to access.
+    # body    - The String body
+    # headers - Hash of unencoded HTTP header key/value pairs.
+    #
+    # Returns a Faraday::Response.
+    def run_request(method, url, body, headers)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      request = build_request(method) do |req|
+        req.url(url)                if url
+        req.headers.update(headers) if headers
+        req.body = body             if body
+        yield(req) if block_given?
+      end
+
+      builder.build_response(self, request)
+    end
+
+    # Creates and configures the request object.
+    #
+    # Returns the new Request.
+    def build_request(method)
+      Request.create(method) do |req|
+        req.params  = self.params.dup
+        req.headers = self.headers.dup
+        req.options = self.options.merge(:proxy => self.proxy)
+        yield(req) if block_given?
+      end
+    end
+
+    # Internal: Build an absolute URL based on url_prefix.
+    #
+    # url    - A String or URI-like object
+    # params - A Faraday::Utils::ParamsHash to replace the query values
+    #          of the resulting url (default: nil).
+    #
+    # Returns the resulting URI instance.
+    def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
+      url = nil if url.respond_to?(:empty?) and url.empty?
+      base = url_prefix
+      if url and base.path and base.path !~ /\/$/
+        base = base.dup
+        base.path = base.path + '/'  # ensure trailing slash
+      end
+      uri = url ? base + url : base
+      uri.query = params.to_query(params_encoder || options.params_encoder) if params
+      uri.query = nil if uri.query and uri.query.empty?
+      uri
+    end
+
+    # Internal: Creates a duplicate of this Faraday::Connection.
+    #
+    # Returns a Faraday::Connection.
+    def dup
+      self.class.new(build_exclusive_url,
+                     :headers => headers.dup,
+                     :params => params.dup,
+                     :builder => builder.dup,
+                     :ssl => ssl.dup,
+                     :request => options.dup)
+    end
+
+    # Internal: Yields username and password extracted from a URI if they both exist.
+    def with_uri_credentials(uri)
+      if uri.user and uri.password
+        yield(Utils.unescape(uri.user), Utils.unescape(uri.password))
+      end
+    end
+
+    def set_authorization_header(header_type, *args)
+      header = Faraday::Request.lookup_middleware(header_type).
+        header(*args)
+      headers[Faraday::Request::Authorization::KEY] = header
+    end
+  end
+end