simple-client 0.0.2

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

@@ -0,0 +1,279 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+require File.join(File.dirname(__FILE__), 'net_http_response')
+
+
+module WebMock
+  module HttpLibAdapters
+    class NetHttpAdapter < HttpLibAdapter
+      adapter_for :net_http
+
+      OriginalNetHTTP = Net::HTTP unless const_defined?(:OriginalNetHTTP)
+      OriginalNetBufferedIO = Net::BufferedIO unless const_defined?(:OriginalNetBufferedIO)
+
+      def self.enable!
+        Net.send(:remove_const, :BufferedIO)
+        Net.send(:remove_const, :HTTP)
+        Net.send(:remove_const, :HTTPSession)
+        Net.send(:const_set, :HTTP, @webMockNetHTTP)
+        Net.send(:const_set, :HTTPSession, @webMockNetHTTP)
+        Net.send(:const_set, :BufferedIO, Net::WebMockNetBufferedIO)
+      end
+
+      def self.disable!
+        Net.send(:remove_const, :BufferedIO)
+        Net.send(:remove_const, :HTTP)
+        Net.send(:remove_const, :HTTPSession)
+        Net.send(:const_set, :HTTP, OriginalNetHTTP)
+        Net.send(:const_set, :HTTPSession, OriginalNetHTTP)
+        Net.send(:const_set, :BufferedIO, OriginalNetBufferedIO)
+      end
+
+      @webMockNetHTTP = Class.new(Net::HTTP) do
+        class << self
+          def socket_type_with_webmock
+            StubSocket
+          end
+          alias_method :socket_type_without_webmock, :socket_type
+          alias_method :socket_type, :socket_type_with_webmock
+
+          if Module.method(:const_defined?).arity == 1
+            def const_defined?(name)
+              super || self.superclass.const_defined?(name)
+            end
+          else
+            def const_defined?(name, inherit=true)
+              super || self.superclass.const_defined?(name, inherit)
+            end
+          end
+
+          if Module.method(:const_get).arity != 1
+            def const_get(name, inherit=true)
+              super
+            rescue NameError
+              self.superclass.const_get(name, inherit)
+            end
+          end
+
+          if Module.method(:constants).arity != 0
+            def constants(inherit=true)
+              super + self.superclass.constants(inherit)
+            end
+          end
+        end
+
+        def request_with_webmock(request, body = nil, &block)
+          request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
+
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+          if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+            @socket = Net::HTTP.socket_type.new
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :net_http}, request_signature, webmock_response)
+            build_net_http_response(webmock_response, &block)
+          elsif WebMock.net_connect_allowed?(request_signature.uri)
+            check_right_http_connection
+            after_request = lambda do |response|
+              if WebMock::CallbackRegistry.any_callbacks?
+                webmock_response = build_webmock_response(response)
+                WebMock::CallbackRegistry.invoke_callbacks(
+                  {:lib => :net_http, :real_request => true}, request_signature, webmock_response)
+              end
+              response.extend Net::WebMockHTTPResponse
+              block.call response if block
+              response
+            end
+            response = if (started? && !WebMock::Config.instance.net_http_connect_on_start) || !started?
+              @started = false #otherwise start_with_connect wouldn't execute and connect
+              start_with_connect {
+                response = request_without_webmock(request, nil)
+                after_request.call(response)
+              }
+            else
+              response = request_without_webmock(request, nil)
+              after_request.call(response)
+            end
+          else
+            raise WebMock::NetConnectNotAllowedError.new(request_signature)
+          end
+        end
+        alias_method :request_without_webmock, :request
+        alias_method :request, :request_with_webmock
+
+        def start_without_connect
+          raise IOError, 'HTTP session already opened' if @started
+          if block_given?
+            begin
+              @started = true
+              return yield(self)
+            ensure
+              do_finish
+            end
+          end
+          @started = true
+          self
+        end
+
+        def start_with_conditional_connect(&block)
+          if WebMock::Config.instance.net_http_connect_on_start
+            start_with_connect(&block)
+          else
+            start_without_connect(&block)
+          end
+        end
+        alias_method :start_with_connect, :start
+        alias_method :start, :start_with_conditional_connect
+
+        def build_net_http_response(webmock_response, &block)
+          response = Net::HTTPResponse.send(:response_class, webmock_response.status[0].to_s).new("1.0", webmock_response.status[0].to_s, webmock_response.status[1])
+          body = webmock_response.body
+          body = nil if body.to_s == ''
+
+          response.instance_variable_set(:@body, body)
+          webmock_response.headers.to_a.each do |name, values|
+            values = [values] unless values.is_a?(Array)
+            values.each do |value|
+              response.add_field(name, value)
+            end
+          end
+
+          response.instance_variable_set(:@read, true)
+
+          response.extend Net::WebMockHTTPResponse
+
+          raise Timeout::Error, "execution expired" if webmock_response.should_timeout
+
+          webmock_response.raise_error_if_any
+
+          yield response if block_given?
+
+          response
+        end
+
+        def build_webmock_response(net_http_response)
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [
+             net_http_response.code.to_i,
+             net_http_response.message]
+          webmock_response.headers = net_http_response.to_hash
+          webmock_response.body = net_http_response.body
+          webmock_response
+        end
+
+
+        def check_right_http_connection
+          unless @@alredy_checked_for_right_http_connection ||= false
+            WebMock::NetHTTPUtility.puts_warning_for_right_http_if_needed
+            @@alredy_checked_for_right_http_connection = true
+          end
+        end
+      end
+      @webMockNetHTTP.version_1_2
+      [
+        [:Get, Net::HTTP::Get],
+        [:Post, Net::HTTP::Post],
+        [:Put, Net::HTTP::Put],
+        [:Delete, Net::HTTP::Delete],
+        [:Head, Net::HTTP::Head],
+        [:Options, Net::HTTP::Options]
+      ].each do |c|
+        @webMockNetHTTP.const_set(c[0], c[1])
+      end
+    end
+  end
+end
+
+class StubSocket #:nodoc:
+
+  attr_accessor :read_timeout
+
+  def initialize(*args)
+  end
+
+  def closed?
+    @closed ||= true
+  end
+
+  def readuntil(*args)
+  end
+
+end
+
+module Net  #:nodoc: all
+
+  class WebMockNetBufferedIO < BufferedIO
+    def initialize_with_webmock(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        StringIO.new(io)
+      end
+      raise "Unable to create local socket" unless @io
+    end
+    alias_method :initialize_without_webmock, :initialize
+    alias_method :initialize, :initialize_with_webmock
+  end
+
+end
+
+
+module WebMock
+  module NetHTTPUtility
+
+    def self.request_signature_from_request(net_http, request, body = nil)
+      protocol = net_http.use_ssl? ? "https" : "http"
+
+      path = request.path
+      path = WebMock::Util::URI.heuristic_parse(request.path).request_uri if request.path =~ /^http/
+
+      if request["authorization"] =~ /^Basic /
+        userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])
+        userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+      else
+        userinfo = ""
+      end
+
+      uri = "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
+      method = request.method.downcase.to_sym
+
+      headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
+
+      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v.first =~ /^Basic / } #we added it to url userinfo
+
+
+      if request.body_stream
+        body = request.body_stream.read
+        request.body_stream = nil
+      end
+
+      if body != nil && body.respond_to?(:read)
+        request.set_body_internal body.read
+      else
+        request.set_body_internal body
+      end
+
+      WebMock::RequestSignature.new(method, uri, :body => request.body, :headers => headers)
+    end
+
+
+    def self.check_right_http_connection
+      @was_right_http_connection_loaded = defined?(RightHttpConnection)
+    end
+
+    def self.puts_warning_for_right_http_if_needed
+      if !@was_right_http_connection_loaded && defined?(RightHttpConnection)
+        $stderr.puts "\nWarning: RightHttpConnection has to be required before WebMock is required !!!\n"
+      end
+    end
+
+  end
+end
+
+WebMock::NetHTTPUtility.check_right_http_connection

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

@@ -0,0 +1,34 @@
+# This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston
+
+# A Net::HTTP response that has already been read raises an IOError when #read_body
+# is called with a destination string or block.
+#
+# This causes a problem when VCR records a response--it reads the body before yielding
+# the response, and if the code that is consuming the HTTP requests uses #read_body, it
+# can cause an error.
+#
+# This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
+# after it has aleady been read.  This attemps to preserve the behavior of
+# #read_body, acting just as if it had never been read.
+
+
+module Net
+  module WebMockHTTPResponse
+    def read_body(dest = nil, &block)
+      if !(defined?(@__read_body_previously_called).nil?) && @__read_body_previously_called
+        return super
+      end
+      return @body if dest.nil? && block.nil?
+      raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
+      return nil if @body.nil?
+
+      dest ||= ::Net::ReadAdapter.new(block)
+      dest << @body
+      @body = dest
+    ensure
+      # allow subsequent calls to #read_body to proceed as normal, without our hack...
+      @__read_body_previously_called = true
+    end
+  end
+end
+

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

@@ -0,0 +1,129 @@
+begin
+  require 'patron'
+rescue LoadError
+  # patron not found
+end
+
+if defined?(::Patron)
+  module WebMock
+    module HttpLibAdapters
+      class PatronAdapter < ::WebMock::HttpLibAdapter
+        adapter_for :patron
+
+        OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
+
+        class WebMockPatronSession < ::Patron::Session
+          def handle_request_with_webmock(req)
+            request_signature =
+              WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
+
+            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+            if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+              WebMock::HttpLibAdapters::PatronAdapter.
+                handle_file_name(req, webmock_response)
+              res = WebMock::HttpLibAdapters::PatronAdapter.
+                build_patron_response(webmock_response, default_response_charset)
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {:lib => :patron}, request_signature, webmock_response)
+              res
+            elsif WebMock.net_connect_allowed?(request_signature.uri)
+              res = handle_request_without_webmock(req)
+              if WebMock::CallbackRegistry.any_callbacks?
+                webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
+                  build_webmock_response(res)
+                WebMock::CallbackRegistry.invoke_callbacks(
+                  {:lib => :patron, :real_request => true}, request_signature,
+                    webmock_response)
+              end
+              res
+            else
+              raise WebMock::NetConnectNotAllowedError.new(request_signature)
+            end
+          end
+
+          alias_method :handle_request_without_webmock, :handle_request
+          alias_method :handle_request, :handle_request_with_webmock
+        end
+
+        def self.enable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, WebMockPatronSession)
+        end
+
+        def self.disable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, OriginalPatronSession)
+        end
+
+        def self.handle_file_name(req, webmock_response)
+          if req.action == :get && req.file_name
+            begin
+              File.open(req.file_name, "w") do |f|
+                f.write webmock_response.body
+              end
+            rescue Errno::EACCES
+              raise ArgumentError.new("Unable to open specified file.")
+            end
+          end
+        end
+
+        def self.build_request_signature(req)
+          uri = WebMock::Util::URI.heuristic_parse(req.url)
+          uri.path = uri.normalized_path.gsub("[^:]//","/")
+          uri.user = req.username
+          uri.password = req.password
+
+          if [:put, :post].include?(req.action)
+            if req.file_name
+              if !File.exist?(req.file_name) || !File.readable?(req.file_name)
+                raise ArgumentError.new("Unable to open specified file.")
+              end
+              request_body = File.read(req.file_name)
+            elsif req.upload_data
+              request_body = req.upload_data
+            else
+              raise ArgumentError.new("Must provide either data or a filename when doing a PUT or POST")
+            end
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.action,
+            uri.to_s,
+            :body => request_body,
+            :headers => req.headers
+          )
+          request_signature
+        end
+
+        def self.build_patron_response(webmock_response, default_response_charset)
+          raise ::Patron::TimeoutError if webmock_response.should_timeout
+          webmock_response.raise_error_if_any
+
+          header_fields = (webmock_response.headers || []).map { |(k, vs)| Array(vs).map { |v| "#{k}: #{v}" } }.flatten
+          status_line   = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}"
+          header_data   = ([status_line] + header_fields).join("\r\n")
+
+          ::Patron::Response.new(
+            "",
+            webmock_response.status[0],
+            0,
+            header_data,
+            webmock_response.body,
+            default_response_charset
+          )
+        end
+
+        def self.build_webmock_response(patron_response)
+          webmock_response = WebMock::Response.new
+          reason = patron_response.status_line.
+            scan(%r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?))[0][2]
+          webmock_response.status = [patron_response.status, reason]
+          webmock_response.body = patron_response.body
+          webmock_response.headers = patron_response.headers
+          webmock_response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+begin
+  require 'typhoeus'
+rescue LoadError
+  # typhoeus not found
+end
+
+if defined?(Typhoeus)
+  WebMock::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2').check_version!
+
+  module WebMock
+    module HttpLibAdapters
+      class TyphoeusAdapter < HttpLibAdapter
+        adapter_for :typhoeus
+
+        def self.enable!
+          @disabled = false
+          add_after_request_callback
+          ::Typhoeus::Hydra.allow_net_connect = true
+        end
+
+        def self.disable!
+          @disabled = true
+          remove_after_request_callback
+          ::Typhoeus::Hydra.allow_net_connect = true
+        end
+
+        def self.disabled?
+          !!@disabled
+        end
+
+        def self.add_after_request_callback
+          unless Typhoeus::Hydra.
+            global_hooks[:after_request_before_on_complete].
+              include?(AFTER_REQUEST_CALLBACK)
+            Typhoeus::Hydra.
+              global_hooks[:after_request_before_on_complete] << AFTER_REQUEST_CALLBACK
+          end
+        end
+
+        def self.remove_after_request_callback
+          Typhoeus::Hydra.global_hooks[:after_request_before_on_complete].
+            delete_if {|v| v == AFTER_REQUEST_CALLBACK }
+        end
+
+        def self.build_request_signature(req)
+          uri = WebMock::Util::URI.heuristic_parse(req.url)
+          uri.path = uri.normalized_path.gsub("[^:]//","/")
+          if req.username
+            uri.user = req.username
+            uri.password = req.password
+          end
+
+          body = req.body
+
+          if req.params && req.method == :post
+            body = request_body_for_post_request_with_params(req)
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.method,
+            uri.to_s,
+            :body => body,
+            :headers => req.headers
+          )
+
+          req.instance_variable_set(:@__webmock_request_signature, request_signature)
+
+          request_signature
+        end
+
+        def self.request_body_for_post_request_with_params(req)
+          params = req.params
+          form = Typhoeus::Form.new(params)
+          form.process!
+          form.to_s
+        end
+
+        def self.build_webmock_response(typhoeus_response)
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [typhoeus_response.code, typhoeus_response.status_message]
+          webmock_response.body = typhoeus_response.body
+          webmock_response.headers = typhoeus_response.headers_hash
+          webmock_response
+        end
+
+        def self.stub_typhoeus(request_signature, webmock_response, typhoeus)
+          response = if webmock_response.should_timeout
+            ::Typhoeus::Response.new(
+              :code         => 0,
+              :status_message => "",
+              :body         => "",
+              :headers_hash => {},
+              :curl_return_code => 28
+            )
+          else
+            ::Typhoeus::Response.new(
+              :code         => webmock_response.status[0],
+              :status_message => webmock_response.status[1],
+              :body         => webmock_response.body,
+              :headers_hash => webmock_response.headers
+            )
+          end
+
+
+          typhoeus.stub(
+            request_signature.method || :any,
+            /.*/,
+            :webmock_stub => true
+          ).and_return(response)
+        end
+
+        def self.request_hash(request_signature)
+          hash = {}
+
+          hash[:body]    = request_signature.body
+          hash[:headers] = request_signature.headers
+
+          hash
+        end
+
+        AFTER_REQUEST_CALLBACK = Proc.new do |request|
+          request_signature = request.instance_variable_get(:@__webmock_request_signature)
+          webmock_response =
+            ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+              build_webmock_response(request.response)
+          if request.response.mock?
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :typhoeus},
+              request_signature,
+              webmock_response
+            )
+          else
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :typhoeus, :real_request => true},
+              request_signature,
+              webmock_response
+            )
+          end
+        end
+      end
+    end
+  end
+
+
+  module Typhoeus
+    class Hydra
+      def queue_with_webmock(request)
+        self.clear_webmock_stubs
+
+        if WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
+          return queue_without_webmock(request)
+        end
+
+        request_signature =
+         ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
+
+        ::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
+          ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+            stub_typhoeus(request_signature, webmock_response, self)
+          webmock_response.raise_error_if_any
+        elsif !WebMock.net_connect_allowed?(request_signature.uri)
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+        queue_without_webmock(request)
+      end
+
+      alias_method :queue_without_webmock, :queue
+      alias_method :queue, :queue_with_webmock
+
+      def clear_webmock_stubs
+        self.stubs = [] unless self.stubs
+        self.stubs.delete_if {|s|
+          s.instance_variable_get(:@options)[:webmock_stub]
+        }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/matchers/hash_including_matcher.rb

@@ -0,0 +1,25 @@
+module WebMock
+  module Matchers
+    #this is a based on RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher
+    #https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashIncludingMatcher
+      def initialize(expected)
+        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected).sort]
+      end
+
+      def ==(actual)
+        @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+      rescue NoMethodError
+        false
+      end
+
+      def inspect
+        "hash_including(#{@expected.inspect})"
+      end
+
+      def self.from_rspec_matcher(matcher)
+        new(matcher.instance_variable_get(:@expected))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'minitest/unit'
+require 'webmock'
+
+MiniTest::Unit::TestCase.class_eval do
+  include WebMock::API
+
+  alias_method :teardown_without_webmock, :teardown
+  def teardown_with_webmock
+    teardown_without_webmock
+    WebMock.reset!
+  end
+  alias_method :teardown, :teardown_with_webmock
+end
+
+WebMock::AssertionFailure.error_class = MiniTest::Assertion