simple-client 0.0.2

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

@@ -0,0 +1,144 @@
+#compatibility with Ruby 1.9.2 preview1 to allow reading raw responses
+class StringIO
+  alias_method :read_nonblock, :sysread
+end
+
+module WebMock
+
+  class ResponseFactory
+    def self.response_for(options)
+      if options.respond_to?(:call)
+        WebMock::DynamicResponse.new(options)
+      else
+        WebMock::Response.new(options)
+      end
+    end
+  end
+
+  class Response
+    def initialize(options = {})
+      if options.is_a?(IO) || options.is_a?(String)
+        self.options = read_raw_response(options)
+      else
+        self.options = options
+      end
+    end
+
+    def headers
+      @headers
+    end
+
+    def headers=(headers)
+      @headers = headers
+      if @headers && !@headers.is_a?(Proc)
+        @headers = Util::Headers.normalize_headers(@headers)
+      end
+    end
+
+    def body
+      @body || ''
+    end
+
+    def body=(body)
+      @body = body
+      stringify_body!
+    end
+
+    def status
+      @status || [200, ""]
+    end
+
+    def status=(status)
+      @status = status.is_a?(Integer) ? [status, ""] : status
+    end
+
+    def exception
+      @exception
+    end
+
+    def exception=(exception)
+      @exception = case exception
+      when String then StandardError.new(exception)
+      when Class then exception.new('Exception from WebMock')
+      when Exception then exception
+      end
+    end
+
+    def raise_error_if_any
+      raise @exception if @exception
+    end
+
+    def should_timeout
+      @should_timeout == true
+    end
+
+    def options=(options)
+      self.headers = options[:headers]
+      self.status = options[:status]
+      self.body = options[:body]
+      self.exception = options[:exception]
+      @should_timeout = options[:should_timeout]
+    end
+
+    def evaluate(request_signature)
+      self.body = @body.call(request_signature) if @body.is_a?(Proc)
+      self.headers = @headers.call(request_signature) if @headers.is_a?(Proc)
+      self.status = @status.call(request_signature) if @status.is_a?(Proc)
+      @should_timeout = @should_timeout.call(request_signature) if @should_timeout.is_a?(Proc)
+      @exception = @exception.call(request_signature) if @exception.is_a?(Proc)
+      self
+    end
+
+    def ==(other)
+      self.body == other.body &&
+      self.headers === other.headers &&
+      self.status == other.status &&
+      self.exception == other.exception &&
+      self.should_timeout == other.should_timeout
+    end
+
+    private
+
+    def stringify_body!
+      if @body.is_a?(IO)
+        io = @body
+        @body = io.read
+        io.close
+      end
+    end
+
+    def read_raw_response(raw_response)
+      if raw_response.is_a?(IO)
+        string = raw_response.read
+        raw_response.close
+        raw_response = string
+      end
+      socket = ::Net::BufferedIO.new(raw_response)
+      response = ::Net::HTTPResponse.read_new(socket)
+      transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
+      response.reading_body(socket, true) {}
+
+      options = {}
+      options[:headers] = {}
+      response.each_header {|name, value| options[:headers][name] = value}
+      options[:headers]['transfer-encoding'] = transfer_encoding if transfer_encoding
+      options[:body] = response.read_body
+      options[:status] = [response.code.to_i, response.message]
+      options
+    end
+
+  end
+
+  class DynamicResponse < Response
+    attr_accessor :responder
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    def evaluate(request_signature)
+      options = @responder.call(request_signature)
+      Response.new(options)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module WebMock
+
+  class ResponsesSequence
+
+    attr_accessor :times_to_repeat
+
+    def initialize(responses)
+      @times_to_repeat = 1
+      @responses = responses
+      @current_position = 0
+    end
+
+    def end?
+      @times_to_repeat == 0
+    end
+
+    def next_response
+      if @times_to_repeat > 0
+        response = @responses[@current_position]
+        increase_position
+        response
+      else
+        @responses.last
+      end
+    end
+
+    private
+
+    def increase_position
+      if @current_position == (@responses.length - 1)
+        @current_position = 0
+        @times_to_repeat -= 1
+      else
+        @current_position += 1
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,42 @@
+module WebMock
+  class RequestPatternMatcher
+
+    def initialize
+      @request_execution_verifier = RequestExecutionVerifier.new
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def matches?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+
+    def negative_failure_message
+      @request_execution_verifier.negative_failure_message
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module WebMock
+  class WebMockMatcher
+
+    def initialize(method, uri)
+      @request_execution_verifier = RequestExecutionVerifier.new
+      @request_execution_verifier.request_pattern = RequestPattern.new(method, uri)
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def with(options = {}, &block)
+      @request_execution_verifier.request_pattern.with(options, &block)
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def matches?(webmock)
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(webmock)
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+
+    def negative_failure_message
+      @request_execution_verifier.negative_failure_message
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'webmock'
+require 'webmock/rspec/matchers/request_pattern_matcher'
+require 'webmock/rspec/matchers/webmock_matcher'
+
+module WebMock
+  module Matchers
+    def have_been_made
+      WebMock::RequestPatternMatcher.new
+    end
+
+    def have_been_requested
+      WebMock::RequestPatternMatcher.new
+    end
+
+
+    def have_not_been_made
+      WebMock::RequestPatternMatcher.new.times(0)
+    end
+
+    def have_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri)
+    end
+
+    def have_not_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri).times(0)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'webmock'
+
+# RSpec 1.x and 2.x compatibility
+if defined?(RSpec::Expectations::ExpectationNotMetError)
+  RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+elsif defined?(Spec) && defined?(Spec.configure)
+  RSPEC_NAMESPACE = Spec
+  RSPEC_CONFIGURER = Spec::Runner
+else
+  begin
+    require 'rspec/core'
+    require 'rspec/expectations'
+    RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+  rescue LoadError
+    require 'spec'
+    RSPEC_NAMESPACE = Spec
+    RSPEC_CONFIGURER = Spec::Runner
+  end
+end
+
+require 'webmock/rspec/matchers'
+
+RSPEC_CONFIGURER.configure { |config|
+
+  config.include WebMock::API
+  config.include WebMock::Matchers
+
+  config.after(:each) do
+    WebMock.reset!
+  end
+}
+
+WebMock::AssertionFailure.error_class = RSPEC_NAMESPACE::Expectations::ExpectationNotMetError

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

@@ -0,0 +1,61 @@
+module WebMock
+
+  class StubRegistry
+    include Singleton
+
+    attr_accessor :request_stubs
+
+    def initialize
+      reset!
+    end
+
+    def global_stubs
+      @global_stubs ||= []
+    end
+
+    def reset!
+      self.request_stubs = []
+    end
+
+    def register_global_stub(&block)
+      # This hash contains the responses returned by the block,
+      # keyed by the exact request (using the object_id).
+      # That way, there's no race condition in case #to_return
+      # doesn't run immediately after stub.with.
+      responses = {}
+
+      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
+        responses[request.object_id] = block.call(request)
+      }.to_return(lambda { |request| responses.delete(request.object_id) })
+
+      global_stubs.push stub
+    end
+
+    def register_request_stub(stub)
+      request_stubs.insert(0, stub)
+      stub
+    end
+
+    def registered_request?(request_signature)
+      request_stub_for(request_signature)
+    end
+
+    def response_for_request(request_signature)
+      stub = request_stub_for(request_signature)
+      stub ? evaluate_response_for_request(stub.response, request_signature) : nil
+    end
+
+    private
+
+    def request_stub_for(request_signature)
+      (global_stubs + request_stubs).detect { |registered_request_stub|
+        registered_request_stub.request_pattern.matches?(request_signature)
+      }
+    end
+
+    def evaluate_response_for_request(response, request_signature)
+      response.evaluate(request_signature)
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+module WebMock
+  class StubRequestSnippet
+    def initialize(request_stub)
+      @request_stub = request_stub
+    end
+
+    def to_s(with_response = true)
+      request_pattern = @request_stub.request_pattern
+      string = "stub_request(:#{request_pattern.method_pattern.to_s},"
+      string << " \"#{request_pattern.uri_pattern.to_s}\")"
+
+      with = ""
+
+      if (request_pattern.body_pattern)
+        with << ":body => #{request_pattern.body_pattern.to_s}"
+      end
+
+      if (request_pattern.headers_pattern)
+        with << ",\n       " unless with.empty?
+
+        with << ":headers => #{request_pattern.headers_pattern.to_s}"
+      end
+      string << ".\n  with(#{with})" unless with.empty?
+      if with_response
+        string << ".\n  to_return(:status => 200, :body => \"\", :headers => {})"
+      end
+      string
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'webmock'
+
+module Test
+  module Unit
+    class TestCase
+      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
+  end
+end
+
+WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError rescue MiniTest::Assertion # ruby1.9 compat

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

@@ -0,0 +1,25 @@
+module WebMock
+  module Util
+    class Util::HashCounter
+      attr_accessor :hash
+      def initialize
+        self.hash = {}
+        @order = {}
+        @max = 0
+      end
+      def put key, num=1
+        hash[key] = (hash[key] || 0) + num
+        @order[key] = @max = @max + 1
+      end
+      def get key
+        hash[key] || 0
+      end
+
+      def each(&block)
+        @order.to_a.sort {|a, b| a[1] <=> b[1]}.each do |a|
+          block.call(a[0], hash[a[0]])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module WebMock
+  module Util
+    class HashKeysStringifier
+
+      def self.stringify_keys!(arg)
+        case arg
+        when Array
+          arg.map { |elem| stringify_keys!(elem) }
+        when Hash
+          Hash[
+            *arg.map { |key, value|
+              k = key.is_a?(Symbol) ? key.to_s : key
+              v = stringify_keys!(value)
+              [k,v]
+            }.inject([]) {|r,x| r + x}]
+        else
+          arg
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module WebMock
+
+  module Util
+
+    class Headers
+
+      def self.normalize_headers(headers)
+        return nil unless headers
+        array = headers.map { |name, value|
+          [name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"),
+           case value
+            when Regexp then value
+            when Array then (value.size == 1) ? value.first : value.map {|v| v.to_s}.sort
+            else value.to_s
+           end
+          ]
+        }
+        Hash[*array.inject([]) {|r,x| r + x}]
+      end
+
+      def self.sorted_headers_string(headers)
+        headers = WebMock::Util::Headers.normalize_headers(headers)
+        str = '{'
+        str << headers.map do |k,v|
+          v = case v
+            when Regexp then v.inspect
+            when Array then "["+v.map{|w| "'#{w.to_s}'"}.join(", ")+"]"
+            else "'#{v.to_s}'"
+          end
+          "'#{k}'=>#{v}"
+        end.sort.join(", ")
+        str << '}'
+      end
+
+      def self.decode_userinfo_from_header(header)
+        header.sub(/^Basic /, "").unpack("m").first
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,54 @@
+# This is a copy of https://github.com/jnunemaker/crack/blob/master/lib/crack/json.rb
+# with date parsing removed
+module WebMock
+  module Util
+    class JSON
+      def self.parse(json)
+        YAML.load(unescape(convert_json_to_yaml(json)))
+      rescue ArgumentError
+        raise ParseError, "Invalid JSON string"
+      end
+
+      protected
+      def self.unescape(str)
+        str.gsub(/\\u([0-9a-f]{4})/) { [$1.hex].pack("U") }
+      end
+
+      # Ensure that ":" and "," are always followed by a space
+      def self.convert_json_to_yaml(json) #:nodoc:
+        scanner, quoting, marks, pos, times = StringScanner.new(json), false, [], nil, []
+        while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
+          case char = scanner[1]
+          when '"', "'"
+            if !quoting
+              quoting = char
+              pos = scanner.pos
+            elsif quoting == char
+              quoting = false
+            end
+          when ":",","
+              marks << scanner.pos - 1 unless quoting
+          when "\\"
+              scanner.skip(/\\/)
+          end
+        end
+
+        if marks.empty?
+          json.gsub(/\\\//, '/')
+        else
+          left_pos  = [-1].push(*marks)
+          right_pos = marks << json.length
+          output    = []
+          left_pos.each_with_index do |left, i|
+            output << json[left.succ..right_pos[i]]
+          end
+          output = output * " "
+
+          times.each { |i| output[i-1] = ' ' }
+          output.gsub!(/\\\//, '/')
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Addressable
+  class URI
+    module CharacterClasses
+      USERINFO = UNRESERVED + SUB_DELIMS + "\\:"
+    end
+  end
+end
+
+module WebMock
+
+  module Util
+
+    class URI
+      ADDRESSABLE_URIS = Hash.new do |hash, key|
+        hash[key] = Addressable::URI.heuristic_parse(key)
+      end
+
+      NORMALIZED_URIS = Hash.new do |hash, uri|
+        normalized_uri = WebMock::Util::URI.heuristic_parse(uri)
+        normalized_uri.query_values = sort_query_values(normalized_uri.query_values) if normalized_uri.query_values
+        normalized_uri = normalized_uri.normalize #normalize! is slower
+        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
+        hash[uri] = normalized_uri
+      end
+
+      def self.heuristic_parse(uri)
+        ADDRESSABLE_URIS[uri].dup
+      end
+
+      def self.normalize_uri(uri)
+        return uri if uri.is_a?(Regexp)
+        uri = 'http://' + uri unless uri.match('^https?://') if uri.is_a?(String)
+        NORMALIZED_URIS[uri].dup
+      end
+
+      def self.variations_of_uri_as_strings(uri_object)
+        normalized_uri = normalize_uri(uri_object.dup).freeze
+        uris = [ normalized_uri ]
+
+        if normalized_uri.path == '/'
+          uris = uris_with_trailing_slash_and_without(uris)
+        end
+
+        uris = uris_encoded_and_unencoded(uris)
+
+        if normalized_uri.port == Addressable::URI.port_mapping[normalized_uri.scheme]
+          uris = uris_with_inferred_port_and_without(uris)
+        end
+
+        if normalized_uri.scheme == "http"
+          uris = uris_with_scheme_and_without(uris)
+        end
+
+        uris.map {|uri| uri.to_s.gsub(/^\/\//,'') }.uniq
+      end
+
+      def self.strip_default_port_from_uri_string(uri_string)
+        case uri_string
+        when %r{^http://}  then uri_string.sub(%r{:80(/|$)}, '\1')
+        when %r{^https://} then uri_string.sub(%r{:443(/|$)}, '\1')
+        else uri_string
+        end
+      end
+
+      def self.encode_unsafe_chars_in_userinfo(userinfo)
+        Addressable::URI.encode_component(userinfo, Addressable::URI::CharacterClasses::USERINFO)
+      end
+
+      def self.is_uri_localhost?(uri)
+        uri.is_a?(Addressable::URI) &&
+        %w(localhost 127.0.0.1 0.0.0.0).include?(uri.host)
+      end
+
+      private
+
+      def self.sort_query_values(query_values)
+        Hash[*query_values.sort.inject([]) { |values, pair| values + pair}]
+      end
+
+      def self.uris_with_inferred_port_and_without(uris)
+        uris.map { |uri| [ uri, uri.gsub(%r{(:80)|(:443)}, "").freeze ] }.flatten
+      end
+
+      def self.uris_encoded_and_unencoded(uris)
+        uris.map do |uri|
+          [ uri.to_s, Addressable::URI.unencode(uri, String).freeze ]
+        end.flatten
+      end
+
+      def self.uris_with_scheme_and_without(uris)
+        uris.map { |uri| [ uri, uri.gsub(%r{^https?://},"").freeze ] }.flatten
+      end
+
+      def self.uris_with_trailing_slash_and_without(uris)
+        uris = uris.map { |uri| [ uri, uri.omit(:path).freeze ] }.flatten
+      end
+
+    end
+  end
+
+end