simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb

@@ -0,0 +1,212 @@
+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 webmock_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)
+          real_activate_connection(client)
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+      alias_method :real_activate_connection, :activate_connection
+      alias_method :activate_connection, :webmock_activate_connection
+    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)
+          fail(self)
+        else
+          @conn.receive_data(response)
+          succeed(self)
+        end
+      end
+
+      def send_request_with_webmock(head, body)
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if stubbed_webmock_response
+          on_error("WebMock timeout error") if stubbed_webmock_response.should_timeout
+          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)
+          send_request_without_webmock(head, body)
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      alias_method :send_request_without_webmock, :send_request
+      alias_method :send_request, :send_request_with_webmock
+
+      def set_deferred_status(status, *args)
+        if status == :succeeded && !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
+
+        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
+
+      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,
+          :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|
+          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 if headers
+
+        response_string << "" << body
+        response_string.join("\n")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/em_http_request_adapter.rb

@@ -0,0 +1,11 @@
+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/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -0,0 +1,95 @@
+begin
+  require 'excon'
+rescue LoadError
+  # excon not found
+end
+
+if defined?(Excon)
+  WebMock::VersionChecker.new('Excon', Excon::VERSION, '0.9.6').check_version!
+
+  module WebMock
+    module HttpLibAdapters
+
+      class ExconAdapter < HttpLibAdapter
+        adapter_for :excon
+
+        def self.enable!
+          Excon.send(:remove_const, :Connection)
+          Excon.send(:const_set, :Connection, ExconConnection)
+        end
+
+        def self.disable!
+          Excon.send(:remove_const, :Connection)
+          Excon.send(:const_set, :Connection, ExconConnection.superclass)
+        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 => params[:body], :headers => params[:headers]
+        end
+
+        def self.real_response(mock)
+          raise Excon::Errors::Timeout if mock.should_timeout
+          mock.raise_error_if_any
+          Excon::Response.new \
+            :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
+          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
+
+      class ExconConnection < ::Excon::Connection
+
+        def request_kernel(params, &block)
+          mock_request  = ExconAdapter.build_request params.dup
+          WebMock::RequestRegistry.instance.requested_signatures.put(mock_request)
+
+          if mock_response = WebMock::StubRegistry.instance.response_for_request(mock_request)
+            ExconAdapter.perform_callbacks(mock_request, mock_response, :real_request => false)
+            ExconAdapter.real_response(mock_response)
+          elsif WebMock.net_connect_allowed?(mock_request.uri)
+            real_response = super
+            ExconAdapter.perform_callbacks(mock_request, ExconAdapter.mock_response(real_response), :real_request => true)
+            real_response
+          else
+            raise WebMock::NetConnectNotAllowedError.new(mock_request)
+          end
+        end
+
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/http_lib_adapter.rb

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

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb

@@ -0,0 +1,19 @@
+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/1.8/gems/webmock-1.8.8/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -0,0 +1,193 @@
+begin
+  require 'httpclient'
+rescue LoadError
+  # httpclient not found
+end
+
+if defined?(::HTTPClient)
+
+  module WebMock
+    module HttpLibAdapters
+      class HTTPClientAdapter < HttpLibAdapter
+        adapter_for :httpclient
+
+        OriginalHttpClient = ::HTTPClient unless const_defined?(:OriginalHttpClient)
+
+        def self.enable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, WebMockHTTPClient)
+        end
+
+        def self.disable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, OriginalHttpClient)
+        end
+      end
+    end
+  end
+
+
+  class WebMockHTTPClient < HTTPClient
+
+    def do_get_block_with_webmock(req, proxy, conn, &block)
+      do_get_with_webmock(req, proxy, conn, false, &block)
+    end
+
+    def do_get_stream_with_webmock(req, proxy, conn, &block)
+      do_get_with_webmock(req, proxy, conn, true, &block)
+    end
+
+    def do_get_with_webmock(req, proxy, conn, stream = false, &block)
+      request_signature = build_request_signature(req, :reuse_existing)
+
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+      if webmock_responses[request_signature]
+        webmock_response = webmock_responses.delete(request_signature)
+        response = build_httpclient_response(webmock_response, stream, &block)
+        @request_filter.each do |filter|
+          filter.filter_response(req, response)
+        end
+        res = conn.push(response)
+        WebMock::CallbackRegistry.invoke_callbacks(
+          {:lib => :httpclient}, request_signature, webmock_response)
+        res
+      elsif WebMock.net_connect_allowed?(request_signature.uri)
+        res = if stream
+          do_get_stream_without_webmock(req, proxy, conn, &block)
+        else
+          do_get_block_without_webmock(req, proxy, conn, &block)
+        end
+        res = conn.pop
+        conn.push(res)
+        if WebMock::CallbackRegistry.any_callbacks?
+          webmock_response = build_webmock_response(res)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :httpclient, :real_request => true}, request_signature,
+            webmock_response)
+        end
+        res
+      else
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
+      end
+    end
+
+    def do_request_async_with_webmock(method, uri, query, body, extheader)
+      req = create_request(method, uri, query, body, extheader)
+      request_signature = build_request_signature(req)
+      webmock_request_signatures << request_signature
+
+      if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
+        do_request_async_without_webmock(method, uri, query, body, extheader)
+      else
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
+      end
+    end
+
+    alias_method :do_get_block_without_webmock, :do_get_block
+    alias_method :do_get_block, :do_get_block_with_webmock
+
+    alias_method :do_get_stream_without_webmock, :do_get_stream
+    alias_method :do_get_stream, :do_get_stream_with_webmock
+
+    alias_method :do_request_async_without_webmock, :do_request_async
+    alias_method :do_request_async, :do_request_async_with_webmock
+
+    def build_httpclient_response(webmock_response, stream = false, &block)
+      body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
+      response = HTTP::Message.new_response(body)
+      response.header.init_response(webmock_response.status[0])
+      response.reason=webmock_response.status[1]
+      webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
+
+      raise HTTPClient::TimeoutError if webmock_response.should_timeout
+      webmock_response.raise_error_if_any
+
+      block.call(response, body) if block
+
+      response
+    end
+  end
+
+  def build_webmock_response(httpclient_response)
+    webmock_response = WebMock::Response.new
+    webmock_response.status = [httpclient_response.status, httpclient_response.reason]
+
+    webmock_response.headers = {}.tap do |hash|
+      httpclient_response.header.all.each do |(key, value)|
+        if hash.has_key?(key)
+          hash[key] = Array(hash[key]) + [value]
+        else
+          hash[key] = value
+        end
+      end
+    end
+
+    if  httpclient_response.content.respond_to?(:read)
+      webmock_response.body = httpclient_response.content.read
+      body = HTTP::Message::Body.new
+      body.init_response(StringIO.new(webmock_response.body))
+      httpclient_response.body = body
+    else
+      webmock_response.body = httpclient_response.content
+    end
+    webmock_response
+  end
+
+  def build_request_signature(req, reuse_existing = false)
+    uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
+    uri.query_values = req.header.request_query if req.header.request_query
+    uri.port = req.header.request_uri.port
+    uri = uri.omit(:userinfo)
+
+    auth = www_auth.basic_auth
+    auth.challenge(req.header.request_uri, nil)
+
+    @request_filter.each do |filter|
+      filter.filter_request(req)
+    end
+
+    headers = req.header.all.inject({}) do |hdrs, header|
+      hdrs[header[0]] ||= []
+      hdrs[header[0]] << header[1]
+      hdrs
+    end
+
+    if (auth_cred = auth.get(req)) && auth.scheme == 'Basic'
+      userinfo = WebMock::Util::Headers.decode_userinfo_from_header(auth_cred)
+      userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
+      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v =~ /^Basic / } #we added it to url userinfo
+      uri.userinfo = userinfo
+    end
+
+    signature = WebMock::RequestSignature.new(
+      req.header.request_method.downcase.to_sym,
+      uri.to_s,
+      :body => req.content,
+      :headers => headers
+    )
+
+    # reuse a previous identical signature object if we stored one for later use
+    if reuse_existing && previous_signature = previous_signature_for(signature)
+      return previous_signature
+    end
+
+    signature
+  end
+
+  def webmock_responses
+    @webmock_responses ||= Hash.new do |hash, request_signature|
+      hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+    end
+  end
+
+  def webmock_request_signatures
+    @webmock_request_signatures ||= []
+  end
+
+  def previous_signature_for(signature)
+    return nil unless index = webmock_request_signatures.index(signature)
+    webmock_request_signatures.delete_at(index)
+  end
+
+end