simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/Rakefile

@@ -0,0 +1,65 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+namespace :rvm do
+  desc 'Run specs against 1.8.6, REE, 1.8.7, 1.9.2 and jRuby'
+  task :specs do
+    # JCF: I'd love to be able to use RVM's `rvm {rubies} specs` command but
+    # the require tests in spec/other_net_http_libs_spec.rb break when doing
+    # so.
+    spec_files = Dir[File.dirname(__FILE__) + '/spec/**/*_spec.rb'].join(' ')
+    sh "rvm 1.8.6@webmock,ree@webmock,1.8.7@webmock,1.9.2@webmock,jruby@webmock exec rspec #{spec_files}"
+  end
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:spec_http_without_webmock) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/acceptance/net_http/real_net_http_spec.rb"]
+  t.pattern = 'spec/acceptance/net_http/real_net_http_spec.rb'
+end
+
+
+task :em_http_request_0_x_spec do
+  sh "EM_HTTP_REQUEST_0_X=true bundle install && bundle exec rspec spec/acceptance/em_http_request/em_http_request_spec.rb" if RUBY_VERSION <= "1.8.7"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
+  test.verbose = false
+  test.warning = false
+end
+
+Rake::TestTask.new(:minitest) do |test|
+  test.test_files = FileList["minitest/**/*.rb"].exclude("test/test_helper.rb")
+  test.verbose = false
+  test.warning = false
+end
+
+
+task :default => [:spec, :spec_http_without_webmock, :test, :minitest]
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  $:.push File.expand_path('../lib', __FILE__)
+  require 'webmock/version'
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "webmock #{WebMock::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/webmock/webmock.rb')
+end
+
+
+task :require_ruby_18 do
+  raise "This must be run on Ruby 1.8" unless RUBY_VERSION =~ /^1\.8/
+end
+
+task :release => [:require_ruby_18]

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

@@ -0,0 +1,63 @@
+module WebMock
+  module API
+    extend self
+
+    def stub_request(method, uri)
+      WebMock::StubRegistry.instance.
+        register_request_stub(WebMock::RequestStub.new(method, uri))
+    end
+
+    alias_method :stub_http_request, :stub_request
+
+    def a_request(method, uri)
+      WebMock::RequestPattern.new(method, uri)
+    end
+
+    class << self
+      alias :request :a_request
+    end
+
+
+    def assert_requested(*args, &block)
+      if not args[0].is_a?(WebMock::RequestStub)
+        args = convert_uri_method_and_options_to_request_and_options(*args, &block)
+      end
+      assert_request_requested(*args, &block)
+    end
+
+    def assert_not_requested(*args, &block)
+      if not args[0].is_a?(WebMock::RequestStub)
+        args = convert_uri_method_and_options_to_request_and_options(*args, &block)
+      end
+      assert_request_not_requested(*args, &block)
+    end
+
+    def hash_including(expected)
+      if defined?(::RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher)
+        RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new(expected)
+      elsif defined?(::Spec::Mocks::ArgumentMatchers::HashIncludingMatcher)
+        Spec::Mocks::ArgumentMatchers::HashIncludingMatcher.new(expected)
+      else
+        WebMock::Matchers::HashIncludingMatcher.new(expected)
+      end
+    end
+
+    private
+
+    def convert_uri_method_and_options_to_request_and_options(*args, &block)
+      request = WebMock::RequestPattern.new(*args).with(&block)
+      [request, args[2] || {}]
+    end
+
+    def assert_request_requested(request, options = {})
+      verifier = WebMock::RequestExecutionVerifier.new(request, options.delete(:times) || 1)
+      WebMock::AssertionFailure.failure(verifier.failure_message) unless verifier.matches?
+    end
+
+    def assert_request_not_requested(request, options = {})
+      verifier = WebMock::RequestExecutionVerifier.new(request, options.delete(:times))
+      WebMock::AssertionFailure.failure(verifier.negative_failure_message) unless verifier.does_not_match?
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+module WebMock
+  class AssertionFailure
+    @error_class = RuntimeError
+    class << self
+      attr_accessor :error_class
+      def failure(message)
+        raise @error_class.new(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module WebMock
+  class CallbackRegistry
+    @@callbacks = []
+
+    def self.add_callback(options, block)
+      @@callbacks << {:options => options, :block => block}
+    end
+
+    def self.callbacks
+      @@callbacks
+    end
+
+    def self.invoke_callbacks(options, request_signature, response)
+      return if @@callbacks.empty?
+      CallbackRegistry.callbacks.each do |callback|
+        except = callback[:options][:except]
+        real_only = callback[:options][:real_requests_only]
+        unless except && except.include?(options[:lib])
+          if !real_only || options[:real_request]
+            callback[:block].call(request_signature, response)
+          end
+        end
+      end
+    end
+
+    def self.reset
+      @@callbacks = []
+    end
+
+    def self.any_callbacks?
+      !@@callbacks.empty?
+    end
+
+  end
+end

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

@@ -0,0 +1,10 @@
+module WebMock
+  class Config
+    include Singleton
+
+    attr_accessor :allow_net_connect
+    attr_accessor :allow_localhost
+    attr_accessor :allow
+    attr_accessor :net_http_connect_on_start
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'webmock'
+require 'webmock/rspec/matchers'
+
+World(WebMock::API, WebMock::Matchers)
+
+After do
+  WebMock.reset!
+end

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

@@ -0,0 +1,9 @@
+module WebMock
+  class Deprecation
+    class << self
+      def warning(message)
+        warn "WebMock deprecation warning: #{message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module WebMock
+
+  class NetConnectNotAllowedError < StandardError
+    def initialize(request_signature)
+      text = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
+      text << "\n\n"
+      text << stubbing_instructions(request_signature)
+      text << request_stubs
+      text << "\n\n" + "="*60
+      super(text)
+    end
+
+    private
+
+    def request_stubs
+      return "" if WebMock::StubRegistry.instance.request_stubs.empty?
+      text = "\n\nregistered request stubs:\n"
+      WebMock::StubRegistry.instance.request_stubs.each do |stub|
+        text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
+      end
+      text
+    end
+
+    def stubbing_instructions(request_signature)
+      text = ""
+      request_stub = RequestStub.from_request_signature(request_signature)
+      text << "You can stub this request with the following snippet:\n\n"
+      text << WebMock::StubRequestSnippet.new(request_stub).to_s
+      text
+    end
+  end
+
+end

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

@@ -0,0 +1,287 @@
+begin
+  require 'curb'
+rescue LoadError
+  # curb not found
+end
+
+if defined?(Curl)
+  WebMock::VersionChecker.new('Curb', Gem.loaded_specs['curb'].version.to_s, '0.7.16').check_version!
+
+  module WebMock
+    module HttpLibAdapters
+      class CurbAdapter < HttpLibAdapter
+        adapter_for :curb
+
+        OriginalCurlEasy = Curl::Easy unless const_defined?(:OriginalCurlEasy)
+
+        def self.enable!
+          Curl.send(:remove_const, :Easy)
+          Curl.send(:const_set, :Easy, Curl::WebMockCurlEasy)
+        end
+
+        def self.disable!
+          Curl.send(:remove_const, :Easy)
+          Curl.send(:const_set, :Easy, OriginalCurlEasy)
+        end
+
+        # Borrowed from Patron:
+        # http://github.com/toland/patron/blob/master/lib/patron/response.rb
+        def self.parse_header_string(header_string)
+          status, headers = nil, {}
+
+          header_string.split(/\r\n/).each do |header|
+            if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
+              status = $1
+            else
+              parts = header.split(':', 2)
+              unless parts.empty?
+                parts[1].strip! unless parts[1].nil?
+                if headers.has_key?(parts[0])
+                  headers[parts[0]] = [headers[parts[0]]] unless headers[parts[0]].kind_of? Array
+                  headers[parts[0]] << parts[1]
+                else
+                  headers[parts[0]] = parts[1]
+                end
+              end
+            end
+          end
+
+          return status, headers
+        end
+      end
+    end
+  end
+
+  module Curl
+    class WebMockCurlEasy < Curl::Easy
+      def curb_or_webmock
+
+        request_signature = build_request_signature
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          build_curb_response(webmock_response)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :curb}, request_signature, webmock_response)
+          invoke_curb_callbacks
+          true
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          res = yield
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response = build_webmock_response
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :curb, :real_request => true}, request_signature,
+                webmock_response)
+          end
+          res
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      def build_request_signature
+        method = @webmock_method.to_s.downcase.to_sym
+
+        uri = WebMock::Util::URI.heuristic_parse(self.url)
+        uri.path = uri.normalized_path.gsub("[^:]//","/")
+        uri.user = self.username
+        uri.password = self.password
+
+        request_body = case method
+        when :post
+          self.post_body || @post_body
+        when :put
+          @put_data
+        else
+          nil
+        end
+
+        request_signature = WebMock::RequestSignature.new(
+          method,
+          uri.to_s,
+          :body => request_body,
+          :headers => self.headers
+        )
+        request_signature
+      end
+
+      def build_curb_response(webmock_response)
+        raise Curl::Err::TimeoutError if webmock_response.should_timeout
+        webmock_response.raise_error_if_any
+
+        @body_str = webmock_response.body
+        @response_code = webmock_response.status[0]
+
+        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n"
+        if webmock_response.headers
+          @header_str << webmock_response.headers.map do |k,v|
+            "#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
+          end.join("\r\n")
+
+          location = webmock_response.headers['Location']
+          if self.follow_location? && location
+            @last_effective_url = location
+            webmock_follow_location(location)
+          end
+
+          @content_type = webmock_response.headers["Content-Type"]
+        end
+
+        @last_effective_url ||= self.url
+      end
+
+      def webmock_follow_location(location)
+        first_url = self.url
+        self.url = location
+
+        curb_or_webmock do
+          send( "http_#{@webmock_method}_without_webmock" )
+        end
+
+        self.url = first_url
+      end
+
+      def invoke_curb_callbacks
+        @on_progress.call(0.0,1.0,0.0,1.0) if @on_progress
+        @on_header.call(self.header_str) if @on_header
+        @on_body.call(self.body_str) if @on_body
+        @on_complete.call(self) if @on_complete
+
+        case response_code
+        when 200..299
+          @on_success.call(self) if @on_success
+        when 400..599
+          @on_failure.call(self, self.response_code) if @on_failure
+        end
+      end
+
+      def build_webmock_response
+        status, headers =
+         WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(self.header_str)
+
+        webmock_response = WebMock::Response.new
+        webmock_response.status = [self.response_code, status]
+        webmock_response.body = self.body_str
+        webmock_response.headers = headers
+        webmock_response
+      end
+
+      ###
+      ### Mocks of Curl::Easy methods below here.
+      ###
+
+      def http_with_webmock(method)
+        @webmock_method = method
+          http_without_webmock(method)
+      end
+      alias_method :http_without_webmock, :http
+      alias_method :http, :http_with_webmock
+
+      %w[ get head delete ].each do |verb|
+        define_method "http_#{verb}_with_webmock" do
+          @webmock_method = verb
+          send( "http_#{verb}_without_webmock" )
+        end
+
+        alias_method "http_#{verb}_without_webmock", "http_#{verb}"
+        alias_method "http_#{verb}", "http_#{verb}_with_webmock"
+      end
+
+      def http_put_with_webmock data = nil
+        @webmock_method = :put
+        @put_data = data if data
+        http_put_without_webmock(data)
+      end
+      alias_method :http_put_without_webmock, :http_put
+      alias_method :http_put, :http_put_with_webmock
+
+      def http_post_with_webmock *data
+        @webmock_method = :post
+        @post_body = data.join('&') if data && !data.empty?
+        http_post_without_webmock(*data)
+      end
+      alias_method :http_post_without_webmock, :http_post
+      alias_method :http_post, :http_post_with_webmock
+
+
+      def perform_with_webmock
+        @webmock_method ||= :get
+        curb_or_webmock do
+          perform_without_webmock
+        end
+      end
+      alias :perform_without_webmock :perform
+      alias :perform :perform_with_webmock
+
+      def put_data_with_webmock= data
+        @webmock_method = :put
+        @put_data = data
+        self.put_data_without_webmock = data
+      end
+      alias_method :put_data_without_webmock=, :put_data=
+      alias_method :put_data=, :put_data_with_webmock=
+
+      def post_body_with_webmock= data
+        @webmock_method = :post
+        self.post_body_without_webmock = data
+      end
+      alias_method :post_body_without_webmock=, :post_body=
+      alias_method :post_body=, :post_body_with_webmock=
+
+      def delete_with_webmock= value
+        @webmock_method = :delete if value
+        self.delete_without_webmock = value
+      end
+      alias_method :delete_without_webmock=, :delete=
+      alias_method :delete=, :delete_with_webmock=
+
+      def head_with_webmock= value
+        @webmock_method = :head if value
+        self.head_without_webmock = value
+      end
+      alias_method :head_without_webmock=, :head=
+      alias_method :head=, :head_with_webmock=
+
+      def body_str_with_webmock
+        @body_str || body_str_without_webmock
+      end
+      alias :body_str_without_webmock :body_str
+      alias :body_str :body_str_with_webmock
+
+      def response_code_with_webmock
+        @response_code || response_code_without_webmock
+      end
+      alias :response_code_without_webmock :response_code
+      alias :response_code :response_code_with_webmock
+
+      def header_str_with_webmock
+        @header_str || header_str_without_webmock
+      end
+      alias :header_str_without_webmock :header_str
+      alias :header_str :header_str_with_webmock
+
+      def last_effective_url_with_webmock
+        @last_effective_url || last_effective_url_without_webmock
+      end
+      alias :last_effective_url_without_webmock :last_effective_url
+      alias :last_effective_url :last_effective_url_with_webmock
+
+      def content_type_with_webmock
+        @content_type || content_type_without_webmock
+      end
+      alias :content_type_without_webmock :content_type
+      alias :content_type :content_type_with_webmock
+
+      %w[ success failure header body complete progress ].each do |callback|
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def on_#{callback}_with_webmock &block
+            @on_#{callback} = block
+            on_#{callback}_without_webmock &block
+          end
+        METHOD
+        alias_method "on_#{callback}_without_webmock", "on_#{callback}"
+        alias_method "on_#{callback}", "on_#{callback}_with_webmock"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+if defined?(EventMachine::HttpRequest)
+  module WebMock
+    module HttpLibAdapters
+      class EmHttpRequestAdapter < HttpLibAdapter
+        adapter_for :em_http_request
+
+        OriginalHttpRequest = EventMachine::HttpRequest unless const_defined?(:OriginalHttpRequest)
+
+        def self.enable!
+          EventMachine.send(:remove_const, :HttpRequest)
+          EventMachine.send(:const_set, :HttpRequest, EventMachine::WebMockHttpRequest)
+        end
+
+        def self.disable!
+          EventMachine.send(:remove_const, :HttpRequest)
+          EventMachine.send(:const_set, :HttpRequest, OriginalHttpRequest)
+        end
+      end
+    end
+  end
+
+
+  module EventMachine
+    class WebMockHttpRequest < EventMachine::HttpRequest
+
+      include HttpEncoding
+
+      class WebMockHttpClient < EventMachine::HttpClient
+
+        def setup(response, uri, error = nil)
+          @last_effective_url = @uri = uri
+          if error
+            on_error(error)
+            fail(self)
+          else
+            EM.next_tick do
+              receive_data(response)
+              succeed(self)
+            end
+          end
+        end
+
+        def unbind
+        end
+
+        def close_connection
+        end
+      end
+
+      def send_request_with_webmock(&block)
+        request_signature = build_request_signature
+
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          WebMock::CallbackRegistry.invoke_callbacks(
+          {:lib => :em_http_request}, request_signature, webmock_response)
+          client = WebMockHttpClient.new(nil)
+          client.on_error("WebMock timeout error") if webmock_response.should_timeout
+          client.setup(make_raw_response(webmock_response), @uri,
+            webmock_response.should_timeout ? "WebMock timeout error" : nil)
+          client
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          http = send_request_without_webmock(&block)
+          http.callback {
+            if WebMock::CallbackRegistry.any_callbacks?
+              webmock_response = build_webmock_response(http)
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {:lib => :em_http_request, :real_request => true}, request_signature,
+                webmock_response)
+            end
+          }
+          http
+        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
+
+
+      private
+
+      def build_webmock_response(http)
+        webmock_response = WebMock::Response.new
+        webmock_response.status = [http.response_header.status, http.response_header.http_reason]
+        webmock_response.headers = http.response_header
+        webmock_response.body = http.response
+        webmock_response
+      end
+
+      def build_request_signature
+        if @req
+          options = @req.options
+          method = @req.method
+          uri = @req.uri
+        else
+          options = @options
+          method = @method
+          uri = @uri
+        end
+
+        if options[:authorization] || options['authorization']
+          auth = (options[:authorization] || options['authorization'])
+          userinfo = auth.join(':')
+          userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
+          options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
+          uri.userinfo = userinfo
+        end
+
+        uri.query = encode_query(@req.uri, options[:query]).slice(/\?(.*)/, 1)
+
+        body = options[:body] || options['body']
+        body = form_encode_body(body) if body.is_a?(Hash)
+
+        WebMock::RequestSignature.new(
+          method.downcase.to_sym,
+          uri.to_s,
+          :body => body,
+          :headers => (options[:head] || options['head'])
+        )
+      end
+
+
+      def make_raw_response(response)
+        response.raise_error_if_any
+
+        status, headers, body = response.status, response.headers, response.body
+
+        response_string = []
+        response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
+
+        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