vorhees 0.0.2

data/Gemfile

@@ -0,0 +1,8 @@
+source :gemcutter
+
+gem 'rspec'
+gem 'eventmachine'
+gem 'json_pure', :as => 'json'
+if RUBY_VERSION < '1.9'
+   gem 'SystemTimer', :as => 'system_timer'
+end

data/Manifest

@@ -0,0 +1,11 @@
+Gemfile
+Manifest
+README
+Rakefile
+lib/vorhees.rb
+lib/vorhees/client.rb
+lib/vorhees/matchers.rb
+spec/client_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/usage_spec.rb

data/README

@@ -0,0 +1,24 @@
+http://github.com/davidlee/vorhees
+
+Vorhees is a simple JSON client and accompanying rspec matcher. 
+
+It's designed to aid the authors of simple JSON socket protocols & servers.
+
+It's opinionated, in that it expects you'll use a key (the default is
+'command') to differentiate types of message; it assumes that the commands are
+uppercase; and that you're using rspec -- other than that it should be
+reasonably universal.
+
+As an example, the following will assert that a message was received within 2
+seconds, with the values {"command":"HELLO", "recipient":"world"}. Additional
+values are allowed (i.e., a "body" field wouldn't cause the spec to fail):
+
+@client = Vorhees::Client.new(:host => 'localhost', :port => 1234)
+@client.should receive(:hello, :timeout => 2.0) { |msg| 
+  msg['recipient].should == 'world'
+}
+
+If you're interested, let me know and I'll try to add spec coverage for some
+of the other (currently undocumented) features.
+
+Provided under the MIT License.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'fileutils'
+
+begin
+  require 'echoe'
+  Echoe.new('vorhees', '0.0.2') do |p|
+    p.description    = "An opinionated JSON socket server client and matchers"
+    p.url            = "http://github.com/davidlee/vorhees"
+    p.author         = "David Lee"
+    p.email          = "david at davelee.com.au"
+    p.ignore_pattern = ["tmp/*", "script/*"]
+    p.development_dependencies = []
+  end
+rescue LoadError
+end
+
+begin
+  require 'cucumber/rake/task'
+rescue LoadError
+  puts "cucumber is not installed."
+end
+
+require '.bundle/environment'
+Bundler.setup()
+
+if defined? Cucumber
+  namespace :features do  
+    Cucumber::Rake::Task.new(:all) do |t|
+      t.cucumber_opts = %w{--format pretty --color}
+    end
+  end
+  task :features => 'features:all'
+end
+
+namespace :spec do
+  desc "Run the code examples in spec/*"
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts = ['-c', '--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+    t.spec_files = FileList["spec/**/*_spec.rb"]
+  end
+  
+  Dir['spec/**'].select {|f| File.directory? f }.map {|f| File.split(f).last }.each do |folder|
+    desc "Run the code examples in spec/#{folder}"
+    Spec::Rake::SpecTask.new(folder.to_sym) do |t|
+      t.spec_opts = ['-c', '--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+      t.spec_files = FileList["spec/#{folder}/*_spec.rb"]
+    end
+  end
+end
+
+task :spec    => "spec:all"
+task :default => :spec

data/lib/vorhees.rb

@@ -0,0 +1,2 @@
+require 'vorhees/client'
+require 'vorhees/matchers'

data/lib/vorhees/client.rb

@@ -0,0 +1,243 @@
+require 'socket'
+require 'json'
+
+unless Object.const_defined?('ActiveSupport')
+  class Hash
+    # Return a new hash with all keys converted to symbols.
+    def symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+
+    # Destructively convert all keys to symbols.
+    def symbolize_keys!
+      self.replace(self.symbolize_keys)
+    end
+  end
+end
+
+module Vorhees
+  class Client  
+    attr_accessor :socket, :buffer, :sent, :received, :options, :env
+
+    if RUBY_VERSION < '1.9'
+      require 'system_timer'
+    else
+      SystemTimer = Timeout
+    end
+    
+
+    GOT_NOTHING  = nil
+    GOT_DATA     = 1
+    GOT_MESSAGE  = 2
+
+    #cattr_accessor :defaults
+    def self.defaults
+      @@defaults
+    end
+
+    @@defaults = {
+      :timeout => 0.06,
+      :eof     => "\n",
+      :key     => 'command',
+      :host    => 'localhost',
+      :port    => 80,
+      :bufsize => 1024
+    }
+
+    def self.const_missing k
+      if k =~ /^DEFAULT_(.*)$/
+        @@defaults[$1.to_s.downcase.to_sym]
+      else super
+      end
+    end
+
+    def self.set_defaults(options={})    
+      defaults.merge! options.symbolize_keys!
+    end
+
+    def initialize(options={})    
+      @options  = Client.defaults.merge(options.symbolize_keys!)
+      @socket   = TCPSocket.new(options[:host], options[:port])
+      @env      = {}
+      @buffer   = ''
+      clear
+    end
+
+    def eof
+      options[:eof]
+    end
+    
+    alias :messages :received
+
+    # client.sends 'ERROR', :message => 'INVALID_RECORD' 
+    # => '{"command":"ERROR", "message":"INVALID_RECORD"}'
+    def sends *args
+      if args.last.is_a?(Hash)
+        send_message(*args)
+      else
+        begin
+          JSON.unparse(args.flatten.first)
+          send_data(*args)
+        rescue
+          send_message(*args)
+        end
+      end
+    end 
+  
+    def send_message *args
+      values = args.last.is_a?(Hash) ? args.pop : {}
+      values[options[:key]] = args.shift if args.first.is_a?(String)
+      send_json values
+    end 
+  
+    def send_json hash
+      send_data hash.to_json # JSON.unparse(hash)
+    end 
+  
+    def send_data(data)
+      data = data.chomp(options[:eof]) + eof
+      sent << data
+      socket.print data
+      socket.flush
+    end
+
+    def wait_for_responses(opts={})
+      wait_for opts do
+        if options[:exactly]
+          received.length == options[:exactly]
+        else
+          received.length >=(options[:at_least] || 1)        
+        end
+      end
+      received
+    end
+  
+    def wait_for_response opts={}
+      opts = options.merge(opts)
+      response = wait_for_responses opts
+      yield(response.first && response.first.parse) if block_given?
+      response.first
+    end
+    alias :response :wait_for_response
+  
+    # FIXME use wait_for, clean this up
+    def discard_responses_until(value, opts={})
+      opts = options.merge(opts)
+      SystemTimer.timeout(opts[:timeout]) do
+        loop do
+          wait_for_response opts do |msg|
+            if msg && msg[Client::DEFAULT_KEY] == value
+              return msg
+            else
+              opts[:debug] ? p(received.shift) : received.shift
+            end
+          end        
+        end
+      end
+    end
+  
+    def wait_for opts={}, &block
+      opts = options.merge(opts)
+      assertion_failed = nil
+      test = lambda do
+        begin
+          yield
+        rescue Spec::Expectations::ExpectationNotMetError => e
+          assertion_failed = true
+          # if there's a background server running, now is a good time
+          # to let it do it's thing.        
+          Thread.pass
+          retry
+        end         
+      end
+      SystemTimer.timeout(opts[:timeout]) do
+        until test.call do
+          receive_data options
+        end
+      end    
+    rescue Timeout::Error
+    ensure
+      # let the error be thrown one more time, this time it won't be caught
+      yield if assertion_failed
+    end
+  
+    def consume_message
+      received.shift.parse rescue nil
+    end
+  
+    def consume
+      v = received.parse
+      @received = [].extend MessageList
+      v
+    end
+  
+    def clear
+      @sent     = [].extend MessageList
+      @received = [].extend MessageList
+      # @buffer   = ""
+    end 
+  
+    def connected?
+      !disconnected?
+    end
+  
+    # for flash XMLSocket 
+    def request_policy_file
+      @socket.print "<policy-file-request/>\0"
+      self
+    end
+  
+    def disconnected?
+      wait_for :timeout => 0.1 do
+        begin
+          return socket && socket.eof?
+        rescue Errno::ECONNRESET
+          return true
+        end
+      end
+      return false
+    end
+  
+    module MessageList
+      def parse
+        map { |json| JSON.parse json }
+      end
+    end
+  
+    module MessageString
+      def parse
+        JSON.parse self
+      end
+    end
+
+    private
+  
+    def receive_data opts={}
+      opts = options.merge(opts) # not really necessary here
+      start_time = Time.now
+      begin
+        data = socket.read_nonblock opts[:bufsize]      
+        if data.match(opts[:eof] || '')
+          data, @buffer = (buffer + data).split(opts[:eof]), ''
+          data.each {|str| str.extend MessageString }
+          @received += data
+          @received.extend MessageList
+          GOT_MESSAGE
+        else
+          @buffer += data
+          GOT_DATA
+        end
+        elapsed = (Time.now.to_f - start_time.to_f)
+        elapsed = (elapsed * 10000).round / 10000        
+      rescue Errno::EAGAIN, EOFError
+        # yield to background thread if there is one
+        Thread.pass
+        GOT_NOTHING
+      end
+    end
+
+  end
+end

data/lib/vorhees/matchers.rb

@@ -0,0 +1,78 @@
+module Vorhees
+  module Matchers
+
+    def receive_nothing(options={})
+      Spec::Matchers::Matcher.new :receive_nothing do
+        match do |client|
+          client.clear
+          if client.received.empty?
+            client.wait_for_responses options
+          end
+          client.received.empty?         
+        end
+      
+        failure_message_for_should do |client|
+          "Expected nothing but received #{client.received}"
+        end
+      end
+    end
+  
+    def receive(expected=nil, options={})
+      Spec::Matchers::Matcher.new :receive, expected do |_expected_|
+        raw = nil
+        msg = nil
+        err = nil
+      
+        match do |client|
+          if client.received.empty?
+            client.wait_for_responses options
+          end
+          if expected == false && !block_given?
+            raw = client.received.shift
+            msg = raw.parse if raw
+            client.received.empty? 
+          else
+            raw = client.received.shift || raise('No Message Received') 
+            msg = raw.parse          
+            if block_given?
+              begin
+                msg['command'].should == expected.to_s.upcase if expected
+                yield msg # stick expectations in the block
+                true
+              rescue Spec::Expectations::ExpectationNotMetError => e
+                err = e
+                false
+              end
+            else
+              case expected
+              when '?'
+                $stderr.puts ' ?? -----> ' + msg.inspect
+                true
+              when String
+                msg == JSON.parse(expected)
+              when Symbol
+                msg['command'] == expected.to_s.upcase
+              else
+                msg == expected
+              end
+            end
+          
+          end
+        end # match
+
+        failure_message_for_should do |actual|
+          if err
+            "#{err.inspect} \n\n-- #{raw}"
+          elsif expected == false
+            "Expected no message but received #{raw.inspect}"
+          elsif msg.nil?
+            "Expected a message, but got nothing."
+          else
+            "Expected #{expected.inspect} but received #{msg.inspect} --> #{raw}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), './spec_helper')
+
+describe Vorhees::Client do
+  Client = Vorhees::Client
+    
+  before :each do
+    TCPSocket.should_receive(:new).any_number_of_times
+  end
+  
+  describe 'defaults' do
+    it 'should be the default options for new instances' do
+      c = Vorhees::Client.new
+      c.options.should == Vorhees::Client.defaults
+    end
+    
+    it 'should be overridden by any supplied options' do
+      c = Vorhees::Client.new 'timeout' => 2, :port => 8080
+      c.options[:timeout].should == 2
+      c.options[:port].should == 8080
+    end
+  end
+  
+  describe 'set_defaults' do
+    it 'should change the defaults for new instances' do
+      Vorhees::Client.set_defaults 'port' => 8080, :eof => "\000"
+      Vorhees::Client.defaults[:port].should == 8080
+      Vorhees::Client.defaults[:eof].should == "\000"
+      c = Vorhees::Client.new
+      c.options[:eof].should == "\000"
+      c.options[:port].should == 8080
+    end
+
+    it 'should not modify the options of extant instances' do
+      c = Vorhees::Client.new
+      lambda {
+        Vorhees::Client.set_defaults :eof => "\000"
+      }.should_not change(c, :options)
+    end
+  end
+  
+  describe '#env' do
+    it 'should be a user-assignable hash' do
+      c = Vorhees::Client.new
+      c.env.should == {}
+      c.env[:connection_id] = 'foo'
+      c.env[:connection_id].should == 'foo'
+    end
+  end
+  
+  
+  describe 'a new client' do
+    describe '#buffer' do
+      it 'should be an empty string' do
+        Client.new.buffer.should == ''
+      end
+    end
+
+    describe '#sent' do
+      it 'should be empty' do
+        Client.new.sent.should == []
+      end
+    end
+
+    describe '#received' do
+      it 'should be empty' do
+        Client.new.received.should == []
+      end
+    end
+    
+    describe '#socket' do
+      it 'should return the raw socket'
+    end
+
+    describe '#options' do
+      it 'should be the options merged with defaults' do
+        o = {:eof => 'XXX'}
+        c = Client.new(o)
+        c.options[:eof].should == "XXX"
+        c.options[:timeout].should == Client.defaults[:timeout]
+      end
+    end
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--format
+nested
+--color
+--loadby
+mtime
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require '.bundle/environment'
+Bundler.setup()
+
+require 'pp'
+# require 'spec'
+require 'lib/vorhees/client'
+require 'lib/vorhees/matchers'
+require 'eventmachine'
+
+class MockSocket
+  attr_accessor :received, :sent
+  
+  def initialize
+    @received = []
+    @sent     = []
+  end
+  
+  def print data
+    sent << data
+  end
+  
+  def flush
+    # noop
+  end  
+end
+
+# simple EM json server
+class TestServer < EventMachine::Connection
+  EOF= "\n"
+  
+  def post_init
+    @buffer = ''
+  end
+  
+  # ensure a null byte at EOF
+  def send_data(data)
+    unless data[-1] == 0
+      data << EOF
+    end
+    super data
+    Thread.pass
+  end
+  
+  def receive_data(data)
+    @buffer << data
+    @buffer = process_whole_messages(@buffer)    
+  end
+
+  # process any whole messages in the buffer,
+  # and return the new contents of the buffer
+  def process_whole_messages(data)
+    return data if data !~ /#{EOF}/ # only process if data contains a \0 char
+    messages = data.split(EOF)
+    if data =~ /#{EOF}$/
+      data = ''
+    else
+      # remove the last message from the list (because it is incomplete) before processing
+      data = messages.pop
+    end
+    messages.each {|message| process_message(message.strip)}
+    return data
+  end
+
+  def process_message(ln)
+    request = nil            
+    begin
+      request = JSON.parse(ln)
+    rescue JSON::ParserError => e
+      error ["CorruptJSON", ln]
+      send_error 'corrupt_JSON'
+      raise ['CorruptJSON', ln].inspect
+    end
+    dispatch request
+  end
+  
+  def dispatch(request)
+    # usually this would be a case on request['command']
+    # in this case just delay delivery if the request contains
+    # 'delay' => sec
+    delay = request['delay'].to_f
+    if delay > 0
+      # Ha, looks like EM::Timer doesn't allow floats in 1.8.7 ?
+      EM::Timer.new(delay) do
+        send_data request.to_json + EOF
+      end      
+    else
+      send_data request.to_json + EOF
+    end
+  end
+end

data/spec/usage_spec.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), './spec_helper')
+
+TEST_SERVER_PORT = 4001
+@@em = nil
+
+def with_server options={}, &bl
+  Thread.abort_on_exception = true
+  @@em ||= Thread.fork do
+    EM.run do
+      EM.start_server('localhost', TEST_SERVER_PORT, TestServer)      
+    end
+    exit
+  end
+  if block_given?
+    yield
+  end
+end
+
+describe Vorhees::Client do
+  include Vorhees::Matchers
+  Client = Vorhees::Client
+  
+  context 'mocked socket' do
+    before :each do
+      @socket = MockSocket.new
+      TCPSocket.should_receive(:new).and_return(@socket)
+      @client = Client.new
+    end
+
+
+    describe '#send_data' do
+      it 'should print a string directly to the socket with the EOF' do
+        @client.options[:eof].should == "\n"
+        str = '{"msg": "HELLO"}'
+        @client.send_data str
+        @socket.sent.should == [str + "\n"]
+      end
+
+      it 'does not append an extra EOF' do
+        @client.options[:eof].should == "\n"
+        str = '{"msg": "HELLO"}' + "\n"
+        @client.send_data str
+        @socket.sent.should == [str]
+      end
+    end
+
+    describe '#sends' do
+      context 'given a hash' do
+        it 'sends the hash as JSON with the EOF' do
+          data = {'command' => 'HELLO', 'payload' => '0xfff'}
+          @client.sends data
+          @socket.sent.length.should == 1
+          JSON.parse(@socket.sent.first).should == data
+        end
+
+      end
+
+      context 'given a symbol' do
+        it 'sends the uppercased symbol as the default key' do
+          @client.options[:key].should == 'command'
+          @client.sends :foo
+          @socket.sent.should == [JSON.unparse('command' => 'FOO') + @client.eof]
+        end
+      end
+
+      context 'given a string' do
+        it 'sends a JSON pair of the default key and the string as the value' do
+          @client.options[:key].should == 'command'
+          @client.sends 'FOO'
+          @socket.sent.should == [JSON.unparse('command' => 'FOO') + @client.eof]
+        end
+
+        it 'appends any additional values' do
+          @client.sends 'ERROR', :message => 'NOT_FOUND'
+          @client.options[:key].should == 'command'
+          @socket.sent.length.should == 1
+          JSON.parse(@socket.sent.first).should == {'command' => 'ERROR', 'message' => 'NOT_FOUND'}
+        end
+        
+        it 'appends an EOF' do
+          data = {'command' => 'HELLO', 'payload' => '0xfff'}
+          @client.sends data
+          @client.sent.first[-1,1].should == @client.eof
+        end
+      end
+    end
+  end
+  
+  context 'should receive matcher (running against an echo server)' do    
+    it 'sanity check' do
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO'
+        @client.should receive('{"command":"HELLO"}')
+      end
+    end
+    
+    it 'waits for the specified duration' do
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO', :delay => 0.1
+        @client.should receive(:hello, :timeout => 0.3)
+      end
+    end
+
+    it 'throws an error if it does not receive a message in the timeout' do
+      with_server do
+        # sanity test:
+        lambda { SystemTimer.timeout(0.1) { sleep 1 } }.should raise_error 
+        
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO', :delay => 1
+        lambda {
+          @client.should receive(:hello, :timeout => 0.1)
+        }.should raise_error(RuntimeError)
+      end
+    end
+
+    it 'raises if the wrong command (or custom :key value) is returned' do
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO', :delay => 0.2
+        
+        lambda {
+          @client.should receive(:goodbye)
+        }.should raise_error #(Spec::Expectations::ExpectationNotMetError, RuntimeError)
+      end
+    end
+    
+    it 'raises if any expectations in the block fail' do
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO'
+        lambda {          
+          @client.should receive(:hello) {|msg| msg['missing'].should_not be_nil }
+        }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+      end
+    end
+
+    it 'yields the message to the block' do
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO', :recipient => 'world'
+        recipient = nil
+        @client.should receive(:hello) {|msg| recipient = msg['recipient'] }
+        recipient.should == 'world'
+      end
+    end
+
+    it 'prints the message given should receive("?")' do
+      # ok, this was probably going overboard ...
+      require 'stringio'
+      with_server do
+        @client = Client.new(:host => 'localhost', :port => TEST_SERVER_PORT)
+        @client.sends 'HELLO'
+        recipient = nil
+        stderr, $stderr = $stderr, StringIO.new('','w+')       
+        @client.should receive('?')
+        stderr, $stderr = $stderr, stderr
+        stderr.rewind
+        stderr.read.gsub(/^.*\{|\}.*$/, '').should == '"command"=>"HELLO"' + "\n"
+      end
+    end
+  end  
+end

data/vorhees.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{vorhees}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Lee"]
+  s.date = %q{2010-03-15}
+  s.description = %q{An opinionated JSON socket server client and matchers}
+  s.email = %q{david at davelee.com.au}
+  s.extra_rdoc_files = ["README", "lib/vorhees.rb", "lib/vorhees/client.rb", "lib/vorhees/matchers.rb"]
+  s.files = ["Gemfile", "Manifest", "README", "Rakefile", "lib/vorhees.rb", "lib/vorhees/client.rb", "lib/vorhees/matchers.rb", "spec/client_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/usage_spec.rb", "vorhees.gemspec"]
+  s.homepage = %q{http://github.com/davidlee/vorhees}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Vorhees", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{vorhees}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{An opinionated JSON socket server client and matchers}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: vorhees
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- David Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-15 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: An opinionated JSON socket server client and matchers
+email: david at davelee.com.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- lib/vorhees.rb
+- lib/vorhees/client.rb
+- lib/vorhees/matchers.rb
+files: 
+- Gemfile
+- Manifest
+- README
+- Rakefile
+- lib/vorhees.rb
+- lib/vorhees/client.rb
+- lib/vorhees/matchers.rb
+- spec/client_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/usage_spec.rb
+- vorhees.gemspec
+has_rdoc: true
+homepage: http://github.com/davidlee/vorhees
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Vorhees
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: vorhees
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An opinionated JSON socket server client and matchers
+test_files: []
+