dwolla_swagger 1.0.6 → 1.0.7

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb

@@ -1,229 +0,0 @@
-if defined?(EventMachine::HttpClient)
-  module WebMock
-    module HttpLibAdapters
-      class EmHttpRequestAdapter < HttpLibAdapter
-        adapter_for :em_http_request
-
-        OriginalHttpClient = EventMachine::HttpClient unless const_defined?(:OriginalHttpClient)
-        OriginalHttpConnection = EventMachine::HttpConnection unless const_defined?(:OriginalHttpConnection)
-
-
-        def self.enable!
-          EventMachine.send(:remove_const, :HttpConnection)
-          EventMachine.send(:const_set, :HttpConnection, EventMachine::WebMockHttpConnection)
-          EventMachine.send(:remove_const, :HttpClient)
-          EventMachine.send(:const_set, :HttpClient, EventMachine::WebMockHttpClient)
-        end
-
-        def self.disable!
-          EventMachine.send(:remove_const, :HttpConnection)
-          EventMachine.send(:const_set, :HttpConnection, OriginalHttpConnection)
-          EventMachine.send(:remove_const, :HttpClient)
-          EventMachine.send(:const_set, :HttpClient, OriginalHttpClient)
-        end
-      end
-    end
-  end
-
-  module EventMachine
-
-    if defined?(Synchrony) && HTTPMethods.instance_methods.include?(:aget)
-      # have to make the callbacks fire on the next tick in order
-      # to avoid the dreaded "double resume" exception
-      module HTTPMethods
-        %w[get head post delete put].each do |type|
-          class_eval %[
-            def #{type}(options = {}, &blk)
-              f = Fiber.current
-
-               conn = setup_request(:#{type}, options, &blk)
-               conn.callback { EM.next_tick { f.resume(conn) } }
-               conn.errback  { EM.next_tick { f.resume(conn) } }
-
-               Fiber.yield
-            end
-          ]
-        end
-      end
-    end
-
-    class WebMockHttpConnection < HttpConnection
-      def activate_connection(client)
-        request_signature = client.request_signature
-
-        if client.stubbed_webmock_response
-          conn = HttpStubConnection.new rand(10000)
-          post_init
-
-          @deferred = false
-          @conn = conn
-
-          conn.parent = self
-          conn.pending_connect_timeout = @connopts.connect_timeout
-          conn.comm_inactivity_timeout = @connopts.inactivity_timeout
-
-          finalize_request(client)
-          @conn.set_deferred_status :succeeded
-        elsif WebMock.net_connect_allowed?(request_signature.uri)
-          super
-        else
-          raise WebMock::NetConnectNotAllowedError.new(request_signature)
-        end
-      end
-
-      def drop_client
-        @clients.shift
-      end
-    end
-
-    class WebMockHttpClient < EventMachine::HttpClient
-      include HttpEncoding
-
-      def uri
-        @req.uri
-      end
-
-      def setup(response, uri, error = nil)
-        @last_effective_url = @uri = uri
-        if error
-          on_error(error)
-          @conn.drop_client
-          fail(self)
-        else
-          @conn.receive_data(response)
-          succeed(self)
-        end
-      end
-
-      def send_request(head, body)
-        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
-
-        if stubbed_webmock_response
-          WebMock::CallbackRegistry.invoke_callbacks({:lib => :em_http_request}, request_signature, stubbed_webmock_response)
-          EM.next_tick {
-            setup(make_raw_response(stubbed_webmock_response), @uri,
-                  stubbed_webmock_response.should_timeout ? "WebMock timeout error" : nil)
-          }
-          self
-        elsif WebMock.net_connect_allowed?(request_signature.uri)
-          super
-        else
-          raise WebMock::NetConnectNotAllowedError.new(request_signature)
-        end
-      end
-
-      def unbind(reason = nil)
-        if !stubbed_webmock_response && WebMock::CallbackRegistry.any_callbacks?
-          webmock_response = build_webmock_response
-          WebMock::CallbackRegistry.invoke_callbacks(
-            {:lib => :em_http_request, :real_request => true},
-            request_signature,
-            webmock_response)
-        end
-        @request_signature = nil
-        remove_instance_variable(:@stubbed_webmock_response)
-
-        super
-      end
-
-      def request_signature
-        @request_signature ||= build_request_signature
-      end
-
-      def stubbed_webmock_response
-        unless defined?(@stubbed_webmock_response)
-          @stubbed_webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
-        end
-
-        @stubbed_webmock_response
-      end
-
-      def get_response_cookie(name)
-        name = name.to_s
-
-        raw_cookie = response_header.cookie
-        raw_cookie = [raw_cookie] if raw_cookie.is_a? String
-
-        cookie = raw_cookie.select { |c| c.start_with? name }.first
-        cookie and cookie.split('=', 2)[1]
-      end
-
-      private
-
-      def build_webmock_response
-        webmock_response = WebMock::Response.new
-        webmock_response.status = [response_header.status, response_header.http_reason]
-        webmock_response.headers = response_header
-        webmock_response.body = response
-        webmock_response
-      end
-
-      def build_request_signature
-        headers, body = @req.headers, @req.body
-
-        @conn.middleware.select {|m| m.respond_to?(:request) }.each do |m|
-          headers, body = m.request(self, headers, body)
-        end
-
-        method = @req.method
-        uri = @req.uri.clone
-        auth = @req.headers[:'proxy-authorization']
-        query = @req.query
-
-        if auth
-          userinfo = auth.join(':')
-          userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
-          if @req
-            @req.proxy.reject! {|k,v| t.to_s == 'authorization' }
-          else
-            options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
-          end
-          uri.userinfo = userinfo
-        end
-
-        uri.query = encode_query(@req.uri, query).slice(/\?(.*)/, 1)
-
-        body = form_encode_body(body) if body.is_a?(Hash)
-
-        WebMock::RequestSignature.new(
-          method.downcase.to_sym,
-          uri.to_s,
-          :body => body || (@req.file && File.read(@req.file)),
-          :headers => headers
-        )
-      end
-
-      def make_raw_response(response)
-        response.raise_error_if_any
-
-        status, headers, body = response.status, response.headers, response.body
-        headers ||= {}
-
-        response_string = []
-        response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
-
-        headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
-        headers.each do |header, value|
-          if header =~ /set-cookie/i
-            [value].flatten.each do |cookie|
-              response_string << "#{header}: #{cookie}"
-            end
-          else
-            value = value.join(", ") if value.is_a?(Array)
-
-            # WebMock's internal processing will not handle the body
-            # correctly if the header indicates that it is chunked, unless
-            # we also create all the chunks.
-            # It's far easier just to remove the header.
-            next if header =~ /transfer-encoding/i && value =~/chunked/i
-
-            response_string << "#{header}: #{value}"
-          end
-        end if headers
-
-        response_string << "" << body
-        response_string.join("\n")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/em_http_request_adapter.rb

@@ -1,11 +0,0 @@
-begin
-  require 'em-http-request'
-rescue LoadError
-  # em-http-request not found
-end
-
-if defined?(EventMachine::HttpConnection)
-  require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_1_x')
-else
-  require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_0_x')
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -1,154 +0,0 @@
-begin
-  require 'excon'
-rescue LoadError
-  # excon not found
-end
-
-if defined?(Excon)
-  WebMock::VersionChecker.new('Excon', Excon::VERSION, '0.27.5').check_version!
-
-  module WebMock
-    module HttpLibAdapters
-
-      class ExconAdapter < HttpLibAdapter
-        PARAMS_TO_DELETE = [:expects, :idempotent,
-                            :instrumentor_name, :instrumentor,
-                            :response_block,
-                            :__construction_args, :stack,
-                            :connection, :response]
-
-        adapter_for :excon
-
-        def self.enable!
-          self.add_excon_stub
-        end
-
-        def self.disable!
-          self.remove_excon_stub
-        end
-
-        def self.add_excon_stub
-          if not @stub
-            @original_excon_mock_default = ::Excon.defaults[:mock]
-            ::Excon.defaults[:mock] = true
-            @stub = ::Excon.stub({}) do |params|
-              self.handle_request(params)
-            end
-          end
-        end
-
-        def self.remove_excon_stub
-          ::Excon.defaults[:mock] = @original_excon_mock_default
-          @original_excon_mock_default = nil
-          Excon.stubs.delete(@stub)
-          @stub = nil
-        end
-
-        def self.handle_request(params)
-          mock_request  = self.build_request params.dup
-          WebMock::RequestRegistry.instance.requested_signatures.put(mock_request)
-
-          if mock_response = WebMock::StubRegistry.instance.response_for_request(mock_request)
-            self.perform_callbacks(mock_request, mock_response, :real_request => false)
-            response = self.real_response(mock_response)
-            response
-          elsif WebMock.net_connect_allowed?(mock_request.uri)
-            conn = new_excon_connection(params)
-            real_response = conn.request(request_params_from(params.merge(:mock => false)))
-
-            ExconAdapter.perform_callbacks(mock_request, ExconAdapter.mock_response(real_response), :real_request => true)
-
-            real_response.data
-          else
-            raise WebMock::NetConnectNotAllowedError.new(mock_request)
-          end
-        end
-
-        def self.new_excon_connection(params)
-          # Ensure the connection is constructed with the exact same args
-          # that the orginal connection was constructed with.
-          args = params.fetch(:__construction_args)
-          ::Excon::Connection.new(connection_params_from args.merge(:mock => false))
-        end
-
-        def self.connection_params_from(hash)
-          hash = hash.dup
-          PARAMS_TO_DELETE.each { |key| hash.delete(key) }
-          hash
-        end
-
-        def self.request_params_from(hash)
-          hash = hash.dup
-          if defined?(Excon::VALID_REQUEST_KEYS)
-            hash.reject! {|key,_| !Excon::VALID_REQUEST_KEYS.include?(key) }
-          end
-          PARAMS_TO_DELETE.each { |key| hash.delete(key) }
-          hash
-        end
-
-        def self.to_query(hash)
-          string = ""
-          for key, values in hash
-            if values.nil?
-              string << key.to_s << '&'
-            else
-              for value in [*values]
-                string << key.to_s << '=' << CGI.escape(value.to_s) << '&'
-              end
-            end
-          end
-          string.chop! # remove trailing '&'
-        end
-
-        def self.build_request(params)
-          params = params.dup
-          method  = (params.delete(:method) || :get).to_s.downcase.to_sym
-          params[:query] = to_query(params[:query]) if params[:query].is_a?(Hash)
-          uri = Addressable::URI.new(params).to_s
-          WebMock::RequestSignature.new method, uri, :body => body_from(params), :headers => params[:headers]
-        end
-
-        def self.body_from(params)
-          body = params[:body]
-          return body unless body.respond_to?(:read)
-
-          contents = body.read
-          body.rewind if body.respond_to?(:rewind)
-          contents
-        end
-
-        def self.real_response(mock)
-          raise Excon::Errors::Timeout if mock.should_timeout
-          mock.raise_error_if_any
-          {
-            :body    => mock.body,
-            :status  => mock.status[0].to_i,
-            :headers => mock.headers || {}
-          }
-        end
-
-        def self.mock_response(real)
-          mock = WebMock::Response.new
-          mock.status  = real.status
-          mock.headers = real.headers
-          mock.body    = real.body.dup
-          mock
-        end
-
-        def self.perform_callbacks(request, response, options = {})
-          return unless WebMock::CallbackRegistry.any_callbacks?
-          WebMock::CallbackRegistry.invoke_callbacks(options.merge(:lib => :excon), request, response)
-        end
-      end
-    end
-  end
-
-  Excon::Connection.class_eval do
-    def self.new(args)
-      args.delete(:__construction_args)
-      super(args).tap do |instance|
-        instance.data[:__construction_args] = args
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_lib_adapter.rb

@@ -1,7 +0,0 @@
-module WebMock
-  class HttpLibAdapter
-    def self.adapter_for(lib)
-      WebMock::HttpLibAdapterRegistry.instance.register(lib, self)
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb

@@ -1,19 +0,0 @@
-module WebMock
-  class HttpLibAdapterRegistry
-    include Singleton
-
-    attr_accessor :http_lib_adapters
-
-    def initialize
-      @http_lib_adapters = {}
-    end
-
-    def register(lib, adapter)
-      @http_lib_adapters[lib] = adapter
-    end
-
-    def each_adapter(&block)
-      @http_lib_adapters.each(&block)
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb/client.rb

@@ -1,14 +0,0 @@
-module HTTP
-  class Client
-    alias_method :__perform__, :perform
-
-    def perform(request, options)
-      return __perform__(request, options) unless webmock_enabled?
-      WebMockPerform.new(request) { __perform__(request, options) }.exec
-    end
-
-    def webmock_enabled?
-      ::WebMock::HttpLibAdapters::HttpRbAdapter.enabled?
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb/request.rb

@@ -1,10 +0,0 @@
-module HTTP
-  class Request
-    def webmock_signature
-      ::WebMock::RequestSignature.new(verb, uri.to_s, {
-        :headers  => headers.to_h,
-        :body     => body
-      })
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb/response.rb

@@ -1,22 +0,0 @@
-module HTTP
-  class Response
-    def to_webmock
-      webmock_response = ::WebMock::Response.new
-
-      webmock_response.status  = [status.to_i, reason]
-      webmock_response.body    = body.to_s
-      webmock_response.headers = headers.to_h
-
-      webmock_response
-    end
-
-    def self.from_webmock(webmock_response, request_signature = nil)
-      status  = Status.new(webmock_response.status.first)
-      headers = webmock_response.headers || {}
-      body    = Body.new Streamer.new webmock_response.body
-      uri     = URI request_signature.uri.to_s if request_signature
-
-      new(status, "1.1", headers, body, uri)
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb/streamer.rb

@@ -1,25 +0,0 @@
-module HTTP
-  class Response
-    class Streamer
-      def initialize(str)
-        @io = StringIO.new str
-      end
-
-      def readpartial(size = nil)
-        unless size
-          if defined?(HTTP::Client::BUFFER_SIZE)
-            size = HTTP::Client::BUFFER_SIZE
-          elsif defined?(HTTP::Connection::BUFFER_SIZE)
-            size = HTTP::Connection::BUFFER_SIZE
-          end
-        end
-
-        @io.read size
-      end
-
-      def sequence_id
-        -1
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb/webmock.rb

@@ -1,62 +0,0 @@
-module HTTP
-  class WebMockPerform
-    def initialize(request, &perform)
-      @request = request
-      @perform = perform
-    end
-
-    def exec
-      replay || perform || halt
-    end
-
-    def request_signature
-      unless @request_signature
-        @request_signature = @request.webmock_signature
-        register_request(@request_signature)
-      end
-
-      @request_signature
-    end
-
-    protected
-
-    def response_for_request(signature)
-      ::WebMock::StubRegistry.instance.response_for_request(signature)
-    end
-
-    def register_request(signature)
-      ::WebMock::RequestRegistry.instance.requested_signatures.put(signature)
-    end
-
-    def replay
-      webmock_response = response_for_request request_signature
-
-      return unless webmock_response
-
-      raise Errno::ETIMEDOUT if webmock_response.should_timeout
-      webmock_response.raise_error_if_any
-
-      invoke_callbacks(webmock_response, :real_request => false)
-      ::HTTP::Response.from_webmock webmock_response, request_signature
-    end
-
-    def perform
-      return unless ::WebMock.net_connect_allowed?(request_signature.uri)
-      response = @perform.call
-      invoke_callbacks(response.to_webmock, :real_request => true)
-      response
-    end
-
-    def halt
-      raise ::WebMock::NetConnectNotAllowedError.new request_signature
-    end
-
-    def invoke_callbacks(webmock_response, options = {})
-      ::WebMock::CallbackRegistry.invoke_callbacks(
-        options.merge({ :lib => :http_rb }),
-        request_signature,
-        webmock_response
-      )
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/webmock-1.22.3/lib/webmock/http_lib_adapters/http_rb_adapter.rb

@@ -1,37 +0,0 @@
-begin
-  require "http"
-rescue LoadError
-  # HTTP gem not found
-end
-
-if defined?(HTTP) && defined?(HTTP::VERSION)
-  WebMock::VersionChecker.new("HTTP Gem", HTTP::VERSION, "0.6.0").check_version!
-
-  module WebMock
-    module HttpLibAdapters
-      class HttpRbAdapter < HttpLibAdapter
-        adapter_for :http_rb
-
-        class << self
-          def enable!
-            @enabled = true
-          end
-
-          def disable!
-            @enabled = false
-          end
-
-          def enabled?
-            @enabled
-          end
-        end
-      end
-    end
-  end
-
-  require "webmock/http_lib_adapters/http_rb/client"
-  require "webmock/http_lib_adapters/http_rb/request"
-  require "webmock/http_lib_adapters/http_rb/response"
-  require "webmock/http_lib_adapters/http_rb/streamer"
-  require "webmock/http_lib_adapters/http_rb/webmock"
-end