and-son 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in and-son.gemspec
+gemspec
+
+gem 'bundler', '~>1.1'
+gem 'rake',    '~>0.9.2'
+
+gem 'bson_ext'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Collin Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# AndSon
+
+AndSon is a simple Sanford client for Ruby.  It provides an API for calling services and handling responses.  It uses [Sanford::Protocol](https://github.com/redding/sanford-protocol) to communicate with Sanford servers.
+
+## Usage
+
+```ruby
+# create a client
+client = AndSon.new('127.0.0.1', 8000, 'v1')
+
+# call a service and get its response data:
+user_data = client.call('get_user', {:user_name => 'joetest'})
+```
+
+## Calling Services
+
+To call a service, you first need a client to make the calls.  You define clients by specifying the host's ip address and port plus the version of the API to make calls against.
+
+Once you have your client defined, make service calls using the `call` method.  It will return any response data and raise an exception if anything goes wrong.
+
+### Timeouts
+
+By default, all requests timeout after 60s.  You can override this globally using the `ANDSON_TIMEOUT` env var. You can override this global timeout on a per-call basis by chaining in the `timeout` method.
+
+```ruby
+# timeout this request after 10 seconds
+client.timeout(10).call('get_user', {:user_name => 'joetest'})
+```
+
+When a request times out, a `Sanford::Protocol::TimeoutError` is raised:
+
+```ruby
+begin
+  client.timeout(10).call('get_user', {:user_name => 'joetest'})
+rescue Sanford::Protocol::TimeoutError => err
+  puts "timeout - so sad :("
+end
+```
+
+### Default Params
+
+Similarly to timeouts, all requests default their params to an empty `Hash` (`{}`). This can be overriden using the `params` method.
+
+```ruby
+# add an API key to all requests made by this client, to authorize our client
+client.params({ 'api_key' => 12345 }).call('get_user', {:user_name => 'joetest'})
+```
+
+One thing to be aware of, AndSon has limited ability to 'merge' or 'append' params. For example:
+
+```ruby
+# raises an exception, can't merge a string on to a hash
+client.params({ 'api_key' => 12345 }).call('get_user', 'joetest')
+```
+
+Be aware of this when setting default params and passing additional params with the `call` method. In general, it's recommended to use ruby's `Hash` for the best results.
+
+### Exception Handling
+
+AndSon raises exceptions when a call responds with a `4xx` or `5xx` response code (see [Sanford Status Codes](https://github.com/redding/sanford-protocol#status-codes) for more on response codes):
+
+* `400`: `BadRequestError < ClientError`
+* `404`: `NotFoundError < ClientError`
+* `4xx`: `ClientError < RequestError`
+* `5xx`: `ServerError < RequestError`
+
+```ruby
+client.call('some_unknown_service')   #=> NotFoundError...
+```
+
+Each exception knows about the response that raised it:
+
+```ruby
+begin
+  client.call('some_unknown_service')
+rescue AndSon::NotFoundError => err
+  err.response       #=> AndSon::Response ...
+  err.response.code  #=> 404
+end
+```
+
+### Response Handling
+
+If you call a service and pass it a block, no exceptions will be raised and the call will yield its response to the block.  The call will return the return value of the block.
+
+```ruby
+user = client.call('get_user', { :user_name => 'joetest' }) do |response|
+  if response.code == 200
+    User.new(response.data)
+  else
+    NullUser.new
+  end
+end
+```
+
+For more details about the response object, see [sanford-protocol](https://github.com/redding/sanford-protocol#response).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+
+require "assert/rake_tasks"
+Assert::RakeTasks.install

data/and-son.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'and-son/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "and-son"
+  gem.version       = AndSon::VERSION
+  gem.authors       = ["Collin Redding", "Kelly Redding"]
+  gem.email         = ["collin.redding@me.com", "kelly@kellyredding.com"]
+  gem.description   = "Simple Sanford client for Ruby."
+  gem.summary       = "Simple Sanford client for Ruby."
+  gem.homepage      = "https://github.com/redding/and-son"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("sanford-protocol",  ["~>0.4"])
+
+  gem.add_development_dependency("assert",        ["~>1.0"])
+  gem.add_development_dependency("assert-mocha",  ["~>1.0"])
+end

data/lib/and-son.rb

@@ -0,0 +1,10 @@
+require 'and-son/client'
+require 'and-son/version'
+
+module AndSon
+
+  def self.new(*args)
+    AndSon::Client.new(*args)
+  end
+
+end

data/lib/and-son/client.rb

@@ -0,0 +1,73 @@
+require 'ostruct'
+require 'sanford-protocol'
+require 'and-son/connection'
+require 'and-son/response'
+
+module AndSon
+
+  module CallRunnerMethods
+
+    # define methods here to allow configuring call runner params.  be sure to
+    # use `tap` to return whatever instance `self.call_runner` returns so you
+    # can method-chain.  `self.call_runner` returns a new runner instance if
+    # called on a client, but returns the chained instance if called on a runner
+
+    def timeout(seconds)
+      self.call_runner.tap{|r| r.timeout_value = seconds.to_f}
+    end
+
+    def params(hash = nil)
+      if !hash.kind_of?(Hash)
+        raise ArgumentError, "expected params to be a Hash instead of a #{hash.class}"
+      end
+      self.call_runner.tap{|r| r.params_value.merge!(hash) }
+    end
+
+  end
+
+  class Client < Struct.new(:host, :port, :version)
+    include CallRunnerMethods
+
+    DEFAULT_TIMEOUT = 60 #seconds
+
+    # proxy the call method to the call runner
+    def call(*args, &block); self.call_runner.call(*args, &block); end
+
+    def call_runner
+      # always start with this default CallRunner
+      CallRunner.new({
+        :host    => host,
+        :port    => port,
+        :version => version,
+        :timeout_value => (ENV['ANDSON_TIMEOUT'] || DEFAULT_TIMEOUT).to_f,
+        :params_value  => {}
+      })
+    end
+  end
+
+  class CallRunner < OpenStruct # {:host, :port, :version, :timeout_value, :params_value}
+    include CallRunnerMethods
+
+    # chain runner methods by returning itself
+    def call_runner; self; end
+
+    def call(name, params = {})
+      if !params.kind_of?(Hash)
+        raise ArgumentError, "expected params to be a Hash instead of a #{hash.class}"
+      end
+      call_params = self.params_value.merge(params)
+      AndSon::Connection.new(host, port).open do |connection|
+        connection.write(Sanford::Protocol::Request.new(version, name, call_params).to_hash)
+        client_response = AndSon::Response.parse(connection.read(timeout_value))
+
+        if block_given?
+          yield client_response.protocol_response
+        else
+          client_response.data
+        end
+      end
+    end
+
+  end
+
+end

data/lib/and-son/connection.rb

@@ -0,0 +1,33 @@
+require 'socket'
+require 'sanford-protocol'
+
+module AndSon
+
+  class Connection < Struct.new(:host, :port)
+    module NoRequest
+      def self.to_s; "[?]"; end
+    end
+
+    def open
+      protocol_connection = Sanford::Protocol::Connection.new(tcp_socket)
+      yield protocol_connection if block_given?
+    ensure
+      protocol_connection.close rescue false
+    end
+
+    private
+
+    # TCP_NODELAY is set to disable buffering. In the case of Sanford
+    # communication, we have all the information we need to send up front and
+    # are closing the connection, so it doesn't need to buffer.
+    # See http://linux.die.net/man/7/tcp
+
+    def tcp_socket
+      TCPSocket.new(host, port).tap do |socket|
+        socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+      end
+    end
+
+  end
+
+end

data/lib/and-son/exceptions.rb

@@ -0,0 +1,19 @@
+module AndSon
+
+  class RequestError < RuntimeError
+    attr_reader :response
+
+    def initialize(protocol_response)
+      super(protocol_response.status.message)
+      @response = protocol_response
+    end
+  end
+
+  ClientError     = Class.new(RequestError)
+
+  BadRequestError = Class.new(ClientError)
+  NotFoundError   = Class.new(ClientError)
+
+  ServerError     = Class.new(RequestError)
+
+end

data/lib/and-son/response.rb

@@ -0,0 +1,44 @@
+require 'sanford-protocol'
+
+require 'and-son/exceptions'
+
+module AndSon
+
+  class Response < Struct.new(:protocol_response)
+
+    CODE_MATCHERS = {
+      '400' => 400,
+      '404' => 404,
+      '4xx' => /4[0-9][0-9]/,
+      '5xx' => /5[0-9][0-9]/
+    }
+
+    def self.parse(hash)
+      self.new(Sanford::Protocol::Response.parse(hash))
+    end
+
+    def data
+      if self.code_is_5xx?
+        raise ServerError.new(self.protocol_response)
+      elsif self.code_is_404?
+        raise NotFoundError.new(self.protocol_response)
+      elsif self.code_is_400?
+        raise BadRequestError.new(self.protocol_response)
+      elsif self.code_is_4xx?
+        raise ClientError.new(self.protocol_response)
+      else
+        self.protocol_response.data
+      end
+    end
+
+    CODE_MATCHERS.each do |name, matcher|
+      matcher = matcher.kind_of?(Regexp) ? matcher : Regexp.new(matcher.to_s)
+
+      define_method("code_is_#{name}?") do
+        !!(self.protocol_response.code.to_s =~ matcher)
+      end
+    end
+
+  end
+
+end

data/lib/and-son/version.rb

@@ -0,0 +1,3 @@
+module AndSon
+  VERSION = "0.1.0"
+end

data/test/helper.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+
+ROOT = File.expand_path('../..', __FILE__)
+
+require 'and-son'
+
+require 'test/support/fake_server'
+
+if defined?(Assert)
+  require 'assert-mocha'
+end

data/test/support/fake_server.rb

@@ -0,0 +1,57 @@
+class FakeServer
+
+  def initialize(port)
+    @port = port
+    @handlers = {}
+  end
+
+  def add_handler(version, name, &block)
+    @handlers["#{version}-#{name}"] = block
+  end
+
+  def run
+    server = TCPServer.new("localhost", @port)
+    socket = server.accept
+
+    serve(socket)
+
+    server.close rescue false
+  end
+
+  protected
+
+  def serve(socket)
+    connection = Sanford::Protocol::Connection.new(socket)
+    request = Sanford::Protocol::Request.parse(connection.read)
+    status, result = route(request)
+    response = Sanford::Protocol::Response.new(status, result)
+    connection.write(response.to_hash)
+  end
+
+  def route(request)
+    handler = @handlers["#{request.version}-#{request.name}"]
+    returned = handler.call(request.params)
+  end
+
+  module Helper
+
+    def run_fake_server(server, &block)
+      begin
+        pid = fork do
+          trap("TERM"){ exit }
+          server.run
+        end
+
+        sleep 0.3 # Give time for the socket to start listening.
+        yield
+      ensure
+        if pid
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        end
+      end
+    end
+
+  end
+
+end

data/test/system/making_requests_test.rb

@@ -0,0 +1,163 @@
+require 'assert'
+
+class MakingRequestsTest < Assert::Context
+  include FakeServer::Helper
+
+  desc "making a request that"
+  setup do
+    @fake_server = FakeServer.new(12000)
+  end
+
+  class SuccessTest < MakingRequestsTest
+    desc "returns a successful response"
+    setup do
+      @fake_server.add_handler('v1', 'echo'){|params| [ 200, params['message'] ] }
+    end
+
+    should "get a 200 response with the parameter echoed back" do
+      self.run_fake_server(@fake_server) do
+
+        client = AndSon.new('localhost', 12000, 'v1')
+        client.call('echo', :message => 'test') do |response|
+          assert_equal 200,     response.status.code
+          assert_equal nil,     response.status.message
+          assert_equal 'test',  response.data
+        end
+
+      end
+    end
+
+  end
+
+  class AuthorizeTest < MakingRequestsTest
+    setup do
+      @fake_server.add_handler('v1', 'authorize_it') do |params|
+        if params['api_key'] == 12345
+          [ 200, params['data'] ]
+        else
+          [ 401, params['data'] ]
+        end
+      end
+    end
+
+    should "get a 200 response when api_key is passed with the correct value" do
+      self.run_fake_server(@fake_server) do
+
+        client = AndSon.new('localhost', 12000, 'v1').params({ 'api_key' => 12345 })
+        client.call('authorize_it', { 'data' => 'holla' }) do |response|
+          assert_equal 200,     response.status.code
+          assert_equal nil,     response.status.message
+          assert_equal 'holla', response.data
+        end
+
+      end
+    end
+
+    should "get a 401 response when api_key isn't passed" do
+      self.run_fake_server(@fake_server) do
+
+        client = AndSon.new('localhost', 12000, 'v1')
+        client.call('authorize_it', { 'data' => 'holla' }) do |response|
+          assert_equal 401,     response.status.code
+          assert_equal nil,     response.status.message
+          assert_equal 'holla', response.data
+        end
+
+      end
+    end
+  end
+
+  class Failure400Test < MakingRequestsTest
+    desc "when a request fails with a 400"
+    setup do
+      @fake_server.add_handler('v1', '400'){|params| [ 400, false ] }
+    end
+
+    should "raise a bad request error" do
+      self.run_fake_server(@fake_server) do
+
+        assert_raises(AndSon::BadRequestError) do
+          client = AndSon.new('localhost', 12000, 'v1')
+          client.call('400')
+        end
+
+      end
+    end
+  end
+
+  class Failure404Test < MakingRequestsTest
+    desc "when a request fails with a 404"
+    setup do
+      @fake_server.add_handler('v1', '404'){|params| [ 404, false ] }
+    end
+
+    should "raise a not found error" do
+      self.run_fake_server(@fake_server) do
+
+        assert_raises(AndSon::NotFoundError) do
+          client = AndSon.new('localhost', 12000, 'v1')
+          client.call('404')
+        end
+
+      end
+    end
+  end
+
+  class Failure4xxTest < MakingRequestsTest
+    desc "when a request fails with a 4xx"
+    setup do
+      @fake_server.add_handler('v1', '4xx'){|params| [ 402, false ] }
+    end
+
+    should "raise a client error" do
+      self.run_fake_server(@fake_server) do
+
+        assert_raises(AndSon::ClientError) do
+          client = AndSon.new('localhost', 12000, 'v1')
+          client.call('4xx')
+        end
+
+      end
+    end
+  end
+
+  class Failure5xxTest < MakingRequestsTest
+    desc "when a request fails with a 5xx"
+    setup do
+      @fake_server.add_handler('v1', '5xx'){|params| [ 500, false ] }
+    end
+
+    should "raise a server error" do
+      self.run_fake_server(@fake_server) do
+
+        assert_raises(AndSon::ServerError) do
+          client = AndSon.new('localhost', 12000, 'v1')
+          client.call('5xx')
+        end
+
+      end
+    end
+  end
+
+  class TimeoutErrorTest < MakingRequestsTest
+    desc "when a request takes to long to respond"
+    setup do
+      @fake_server.add_handler('v1', 'forever') do |params|
+        sleep 0.2
+        [ 200, true ]
+      end
+    end
+
+    should "raise a timeout error" do
+      self.run_fake_server(@fake_server) do
+
+        assert_raises(Sanford::Protocol::TimeoutError) do
+          client = AndSon.new('localhost', 12000, 'v1')
+          client.timeout(0.1).call('forever')
+        end
+
+      end
+    end
+  end
+
+end

data/test/unit/and-son_test.rb

@@ -0,0 +1,13 @@
+require 'assert'
+
+module AndSon
+
+  class BaseTest < Assert::Context
+    desc "AndSon"
+    subject{ AndSon }
+
+    should have_instance_methods :new
+
+  end
+
+end

data/test/unit/client_test.rb

@@ -0,0 +1,68 @@
+require 'assert'
+
+class AndSon::Client
+
+  class BaseTest < Assert::Context
+    desc "AndSon::Client"
+    setup do
+      @host, @port, @version = '0.0.0.0', 8000, "v1"
+      @client = AndSon::Client.new(@host, @port, @version)
+    end
+    subject{ @client }
+
+    should have_imeths :host, :port, :version
+    should have_imeths :call_runner, :call, :timeout
+
+    should "know its default call runner" do
+      default_runner = subject.call_runner
+
+      assert_equal @host, default_runner.host
+      assert_equal @port, default_runner.port
+      assert_equal @version, default_runner.version
+      assert_equal 60.0, default_runner.timeout_value
+    end
+
+    should "override the default call runner timeout with an env var" do
+      prev = ENV['ANDSON_TIMEOUT']
+      ENV['ANDSON_TIMEOUT'] = '20'
+
+      assert_equal 20.0, subject.call_runner.timeout_value
+
+      ENV['ANDSON_TIMEOUT'] = prev
+    end
+
+    should "return a CallRunner with a timeout value set #timeout" do
+      runner = subject.timeout(10)
+
+      assert_kind_of AndSon::CallRunner, runner
+      assert_respond_to :call, runner
+      assert_equal 10.0, runner.timeout_value
+    end
+
+    should "return a CallRunner with params_value set using #params" do
+      runner = subject.params({ :api_key => 12345 })
+
+      assert_kind_of AndSon::CallRunner, runner
+      assert_respond_to :call, runner
+      assert_equal({ :api_key => 12345 }, runner.params_value)
+    end
+
+    should "raise an ArgumentError when #params is not passed a Hash" do
+      assert_raises(ArgumentError) do
+        subject.params('test')
+      end
+    end
+
+    should "raise an ArgumentError when #call is not passed a Hash for params" do
+      runner = subject.timeout(0.1) # in case it actually tries to make the request
+
+      assert_raises(ArgumentError) do
+        runner.call('something', 'test')
+      end
+    end
+  end
+
+  # the `call` method is tested in the file test/system/making_requests_test.rb,
+  # because there is a lot of setup needed to call this method
+
+end

data/test/unit/response_test.rb

@@ -0,0 +1,108 @@
+require 'assert'
+
+class AndSon::Response
+
+  class BaseTest < Assert::Context
+    desc "AndSon::Response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new([ 200, 'message' ], 'data')
+      @response = AndSon::Response.new(@protocol_response)
+    end
+    subject{ @response }
+
+    should have_instance_methods :data, :code_is_5xx?, :code_is_404?, :code_is_400?, :code_is_4xx?
+    should have_class_methods :parse
+
+    should "return the protocol response's data with #data" do
+      assert_equal @protocol_response.data, subject.data
+    end
+    should "return false for all the code_is methods" do
+      assert_equal false, subject.code_is_5xx?
+      assert_equal false, subject.code_is_404?
+      assert_equal false, subject.code_is_400?
+      assert_equal false, subject.code_is_4xx?
+    end
+  end
+
+  class FailedResponseTest < BaseTest
+    desc "given a failed response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new([ 500, 'message' ])
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+    should "raise an exception using the response's message and the exception should have the" \
+           "response as well" do
+      exception = nil
+      begin; subject.data; rescue Exception => exception; end
+
+      assert_instance_of AndSon::ServerError,         exception
+      assert_equal @protocol_response.status.message, exception.message
+      assert_equal @protocol_response,                exception.response
+    end
+  end
+
+  class Response5xxTest < BaseTest
+    desc "given a 5xx response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new(500)
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+    should "return true with code_is_5xx? and false for all the other code_is methods" do
+      assert_equal true,  subject.code_is_5xx?
+      assert_equal false, subject.code_is_404?
+      assert_equal false, subject.code_is_400?
+      assert_equal false, subject.code_is_4xx?
+    end
+  end
+
+  class Response404Test < BaseTest
+    desc "given a 404 response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new(404)
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+    should "return true with code_is_404? and code_is_4xx?; false for all the other " \
+           "code_is methods" do
+      assert_equal false, subject.code_is_5xx?
+      assert_equal true,  subject.code_is_404?
+      assert_equal false, subject.code_is_400?
+      assert_equal true,  subject.code_is_4xx?
+    end
+  end
+
+  class Response400Test < BaseTest
+    desc "given a 400 response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new(400)
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+    should "return true with code_is_400? and code_is_4xx?; false for all the other " \
+           "code_is methods" do
+      assert_equal false, subject.code_is_5xx?
+      assert_equal false, subject.code_is_404?
+      assert_equal true,  subject.code_is_400?
+      assert_equal true,  subject.code_is_4xx?
+    end
+  end
+
+  class Response4xxTest < BaseTest
+    desc "given a 4xx response"
+    setup do
+      @protocol_response = Sanford::Protocol::Response.new(402)
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+    should "return true with code_is_4xx? and false for all the other code_is methods" do
+      assert_equal false, subject.code_is_5xx?
+      assert_equal false, subject.code_is_404?
+      assert_equal false, subject.code_is_400?
+      assert_equal true,  subject.code_is_4xx?
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: and-son
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Collin Redding
+- Kelly Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  requirement: *id001
+  name: sanford-protocol
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  requirement: *id002
+  name: assert
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  requirement: *id003
+  name: assert-mocha
+  type: :development
+description: Simple Sanford client for Ruby.
+email: 
+- collin.redding@me.com
+- kelly@kellyredding.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- and-son.gemspec
+- lib/and-son.rb
+- lib/and-son/client.rb
+- lib/and-son/connection.rb
+- lib/and-son/exceptions.rb
+- lib/and-son/response.rb
+- lib/and-son/version.rb
+- test/helper.rb
+- test/support/fake_server.rb
+- test/system/making_requests_test.rb
+- test/unit/and-son_test.rb
+- test/unit/client_test.rb
+- test/unit/response_test.rb
+homepage: https://github.com/redding/and-son
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Simple Sanford client for Ruby.
+test_files: 
+- test/helper.rb
+- test/support/fake_server.rb
+- test/system/making_requests_test.rb
+- test/unit/and-son_test.rb
+- test/unit/client_test.rb
+- test/unit/response_test.rb