protobuf 2.1.0 → 2.1.1

data/lib/protobuf.rb

@@ -7,10 +7,10 @@ require 'active_support/all'
 module Protobuf
 
   # See Protobuf#connector_type documentation.
-  VALID_CONNECTOR_TYPES = [ :socket, :zmq, :evented ].freeze
+  CONNECTORS = [ :socket, :zmq, :evented ].freeze
 
   # Default is Socket as it has no external dependencies.
-  DEFAULT_CONNECTOR_TYPE = :socket
+  DEFAULT_CONNECTOR = :socket
 
 	module_function
 
@@ -21,15 +21,14 @@ module Protobuf
   # Symbol value which denotes the type of connector to use
   # during client requests to an RPC server.
   def self.connector_type
-    @_connector_type ||= DEFAULT_CONNECTOR_TYPE
+    @_connector_type ||= DEFAULT_CONNECTOR
   end
 
   def self.connector_type=(type)
-    raise ArgumentError, 'Invalid connector type given' unless VALID_CONNECTOR_TYPES.include?(type)
+    raise ArgumentError, 'Invalid connector type given' unless CONNECTORS.include?(type)
     @_connector_type = type
   end
 
-
   # GC Pause during server requests
   #
   # Default: false
@@ -70,4 +69,18 @@ end
 
 require 'protobuf/rpc/client'
 require 'protobuf/rpc/service'
-require 'protobuf/socket'
+
+env_connector_type = ENV.fetch('PB_CLIENT_TYPE') {
+  ::Protobuf::DEFAULT_CONNECTOR
+}.to_s.downcase.strip.to_sym
+
+if ::Protobuf::CONNECTORS.include?(env_connector_type)
+  require "protobuf/#{env_connector_type}"
+else
+  $stderr.puts <<-WARN
+    [WARNING] Require attempted on an invalid connector type '#{env_connector_type}'.
+              Falling back to default '#{::Protobuf::DEFAULT_CONNECTOR}' connector.
+  WARN
+
+  require "protobuf/#{::Protobuf::DEFAULT_CONNECTOR}"
+end

data/lib/protobuf/cli.rb

@@ -16,7 +16,7 @@ module Protobuf
     desc 'start APP_FILE', 'Run the RPC server in the given mode, preloading the given APP_FILE. This is the default task.'
 
     option :host,                       :type => :string, :default => '127.0.0.1', :aliases => %w(-o), :desc => 'Host to bind.'
-    option :port,                       :type => :numeric, :default => 9595, :aliases => %w(-p), :desc => 'Port to bind.'
+    option :port,                       :type => :numeric, :default => 9399, :aliases => %w(-p), :desc => 'Master Port to bind.'
 
     option :backlog,                    :type => :numeric, :default => 100, :aliases => %w(-b), :desc => 'Backlog for listening socket when using Socket Server.'
     option :threshold,                  :type => :numeric, :default => 100, :aliases => %w(-t), :desc => 'Multi-threaded Socket Server cleanup threshold.'
@@ -107,19 +107,15 @@ module Protobuf
       # TODO add signal handling for hot-reloading the application.
       def configure_traps
         debug_say 'Configuring traps'
-        trap_block = proc {
-          ::Protobuf::Logger.info { 'RPC Server shutting down...' }
-          @start_aborted = true
-          @runner.stop
-          ::Protobuf::Logger.info { 'Shutdown complete' }
-        }
-
-        debug_say 'Registering INT', :blue
-        trap(:INT, &trap_block)
-        debug_say 'Registering QUIT', :blue
-        trap(:QUIT, &trap_block)
-        debug_say 'Registering TERM', :blue
-        trap(:TERM, &trap_block)
+        [:INT, :QUIT, :TERM].each do |signal|
+          debug_say "Registering signal trap for #{signal}", :blue
+          trap(signal) do
+            ::Protobuf::Logger.info { 'RPC Server shutting down...' }
+            @start_aborted = true
+            @runner.stop
+            ::Protobuf::Logger.info { 'Shutdown complete' }
+          end
+        end
       end
 
       # Say something if we're in debug mode.

data/lib/protobuf/field.rb

@@ -41,7 +41,7 @@ module Protobuf
       ::Protobuf::Field::BoolField
     ].freeze
 
-    def self.build(message_class, rule, type, name, tag, options={})
+    def self.build(message_class, rule, type, name, tag, options = {})
       field_class = type_message_or_enum(type)
       field_class.new(message_class, rule, type, name, tag, options)
     end

data/lib/protobuf/message.rb

@@ -29,17 +29,17 @@ module Protobuf
     end
 
     # Define a required field. Don't use this method directly.
-    def self.required(type, name, tag, options={})
+    def self.required(type, name, tag, options = {})
       define_field(:required, type, name, tag, options)
     end
 
     # Define a optional field. Don't use this method directly.
-    def self.optional(type, name, tag, options={})
+    def self.optional(type, name, tag, options = {})
       define_field(:optional, type, name, tag, options)
     end
 
     # Define a repeated field. Don't use this method directly.
-    def self.repeated(type, name, tag, options={})
+    def self.repeated(type, name, tag, options = {})
       define_field(:repeated, type, name, tag, options)
     end
 
@@ -111,7 +111,7 @@ module Protobuf
     ##
     # Constructor
     #
-    def initialize(values={})
+    def initialize(values = {})
       values = values.to_hash
       @values = {}
 

data/lib/protobuf/rpc/client.rb

@@ -26,10 +26,10 @@ module Protobuf
       #     :request => request
       #   })
       #
-      def initialize(opts={})
-        raise "Invalid client configuration. Service must be defined." if opts[:service].nil?
-        @connector = Connector.connector_for_client.new(opts)
-        log_debug { sign_message("Initialized with options: #{opts.inspect}") }
+      def initialize(options = {})
+        raise "Invalid client configuration. Service must be defined." if options[:service].nil?
+        @connector = Connector.connector_for_client.new(options)
+        log_debug { sign_message("Initialized with options: #{options.inspect}") }
       end
 
       def log_signature

data/lib/protobuf/rpc/connector.rb

@@ -3,19 +3,15 @@ module Protobuf
     class Connector
 
       # Returns a connector class for the pre-defined connector_type.
-      def self.connector_for_client(reload = false)
-        if reload || @_connector.nil?
-          @_connector = case ::Protobuf.connector_type
-                        when :evented then
-                          ::Protobuf::Rpc::Connectors::EventMachine
-                        when :zmq then
-                          ::Protobuf::Rpc::Connectors::Zmq
-                        else
-                          ::Protobuf::Rpc::Connectors::Socket
-                        end
+      def self.connector_for_client
+        case ::Protobuf.connector_type
+        when :evented then
+          ::Protobuf::Rpc::Connectors::EventMachine
+        when :zmq then
+          ::Protobuf::Rpc::Connectors::Zmq
+        else
+          ::Protobuf::Rpc::Connectors::Socket
         end
-
-        return @_connector
       end
 
     end

data/lib/protobuf/rpc/connectors/em_client.rb

@@ -13,7 +13,7 @@ module Protobuf
         ##
         # Constructor
         #
-        def initialize(options={}, &failure_cb)
+        def initialize(options = {}, &failure_cb)
           @failure_cb = failure_cb
           @options = DEFAULT_OPTIONS.merge(options)
           @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
@@ -27,7 +27,7 @@ module Protobuf
         ##
         # Class Methods
         #
-        def self.connect(options={})
+        def self.connect(options = {})
           options = DEFAULT_OPTIONS.merge(options)
           log_debug { sign_message("Connecting to server: #{options.inspect}") }
           EM.connect(options[:host], options[:port], self, options)

data/lib/protobuf/rpc/servers/evented_runner.rb

@@ -6,10 +6,10 @@ module Protobuf
         ::EventMachine.stop_event_loop if ::EventMachine.reactor_running?
       end
 
-      def self.run(server)
+      def self.run(options)
         # Startup and run the rpc server
         ::EventMachine.schedule do
-          ::EventMachine.start_server(server.host, server.port, ::Protobuf::Rpc::Evented::Server)
+          ::EventMachine.start_server(options[:host], options[:port], ::Protobuf::Rpc::Evented::Server)
         end
 
         # Join or start the reactor

data/lib/protobuf/rpc/servers/socket/server.rb

@@ -9,9 +9,11 @@ module Protobuf
         include ::Protobuf::Rpc::Server
         include ::Protobuf::Logger::LogMethods
 
+        AUTO_COLLECT_TIMEOUT = 20 # seconds
+
         def self.cleanup?
           # every 10 connections run a cleanup routine after closing the response
-          @threads.size > (@thread_threshold - 1) && (@threads.size % @thread_threshold) == 0
+          @threads.size > (@threshold - 1) && (@threads.size % @threshold) == 0
         end
 
         def self.cleanup_threads
@@ -42,18 +44,17 @@ module Protobuf
           end
         end
 
-        def self.run(opts = {})
+        def self.run(options = {})
           log_debug { sign_message("Run") }
-          host = opts.fetch(:host, "127.0.0.1")
-          port = opts.fetch(:port, 9399)
-          backlog = opts.fetch(:backlog, 100)
-          thread_threshold = opts.fetch(:thread_threshold, 100)
-          auto_collect_timeout = opts.fetch(:auto_collect_timeout, 20)
+          host = options[:host]
+          port = options[:port]
+          backlog = options[:backlog]
+          @threshold = options[:threshold]
 
           @threads = []
-          @thread_threshold = thread_threshold
           @server = ::TCPServer.new(host, port)
-          raise "blah" if @server.closed?
+          raise "The server was unable to start properly." if @server.closed?
+
           @server.listen(backlog)
           @working = []
           @listen_fds = [@server]
@@ -62,7 +63,7 @@ module Protobuf
           while running?
             log_debug { sign_message("Waiting for connections") }
 
-            if ready_cnxns = IO.select(@listen_fds, [], [], auto_collect_timeout)
+            if ready_cnxns = IO.select(@listen_fds, [], [], AUTO_COLLECT_TIMEOUT)
               cnxns = ready_cnxns.first
               cnxns.each do |client|
                 case

data/lib/protobuf/rpc/servers/zmq/broker.rb

@@ -8,13 +8,13 @@ module Protobuf
         include ::Protobuf::Rpc::Zmq::Util
         attr_reader :frontend, :backend, :poller, :context
 
-        ## 
+        ##
         # Constructor
         #
-        def initialize(opts={})
+        def initialize(options = {})
           @context = ::ZMQ::Context.new
-          @frontend = setup_frontend(opts)
-          @backend = setup_backend(opts)
+          @frontend = setup_frontend(options)
+          @backend = setup_backend(options)
           @poller = setup_poller
         end
 
@@ -52,27 +52,29 @@ module Protobuf
             end
           end
 
-          def setup_backend(opts={})
-            dealer_options = opts.merge(:port => opts.fetch(:port, 9399) + 1)
-            host = dealer_options.fetch(:host, "127.0.0.1")
-            port = dealer_options.fetch(:port, 9400)
-            protocol = dealer_options.fetch(:protocol, "tcp")
+          def setup_backend(options = {})
+            dealer_options = options.merge(:port => options[:port] + 1)
+            host = dealer_options[:host]
+            port = dealer_options[:port]
 
             zmq_backend = context.socket(::ZMQ::DEALER)
-            zmq_error_check(zmq_backend.bind("#{protocol}://#{resolve_ip(host)}:#{port}"))
+            zmq_error_check(zmq_backend.bind(bind_address(host, port)))
             zmq_backend
           end
 
-          def setup_frontend(opts={})
-            host = opts.fetch(:host, "127.0.0.1")
-            port = opts.fetch(:port, 9399)
-            protocol = opts.fetch(:protocol, "tcp")
+          def setup_frontend(options = {})
+            host = options[:host]
+            port = options[:port]
 
             zmq_frontend = context.socket(::ZMQ::ROUTER)
-            zmq_error_check(zmq_frontend.bind("#{protocol}://#{resolve_ip(host)}:#{port}"))
+            zmq_error_check(zmq_frontend.bind(bind_address(host, port)))
             zmq_frontend
           end
 
+          def bind_address(host, port)
+            "tcp://#{resolve_ip(host)}:#{port}"
+          end
+
           def setup_poller
             zmq_poller = ::ZMQ::Poller.new
             zmq_poller.register(frontend, ::ZMQ::POLLIN)

data/lib/protobuf/rpc/servers/zmq/server.rb

@@ -11,12 +11,12 @@ module Protobuf
         ##
         # Class Methods
         #
-        def self.run(opts = {})
+        def self.run(options = {})
           log_debug { sign_message("initializing broker") }
-          @broker = ::Protobuf::Rpc::Zmq::Broker.new(opts)
-          local_worker_threads = opts.fetch(:threads, 5)
+          @broker = ::Protobuf::Rpc::Zmq::Broker.new(options)
+          local_worker_threads = options[:threads]
 
-          worker_options = opts.merge(:port => opts.fetch(:port, 9399) + 1)
+          worker_options = options.merge(:port => options[:port] + 1)
           log_debug { sign_message("starting server workers") }
           local_worker_threads.times do
             @threads << Thread.new { ::Protobuf::Rpc::Zmq::Worker.new(worker_options).run }

data/lib/protobuf/rpc/servers/zmq/worker.rb

@@ -11,15 +11,13 @@ module Protobuf
         ##
         # Constructor
         #
-        def initialize(opts={})
-          @options = opts
-          host = @options.fetch(:host) { "127.0.0.1" }
-          port = @options.fetch(:port) { 9400 }
-          protocol = @options.fetch(:protocol) { "tcp" }
+        def initialize(options = {})
+          host = options[:host]
+          port = options[:port]
 
           @zmq_context = ::ZMQ::Context.new
           @socket = @zmq_context.socket(::ZMQ::REP)
-          zmq_error_check(@socket.connect("#{protocol}://#{resolve_ip(host)}:#{port}"))
+          zmq_error_check(@socket.connect("tcp://#{resolve_ip(host)}:#{port}"))
 
           @poller = ::ZMQ::Poller.new
           @poller.register(@socket, ::ZMQ::POLLIN)

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
   PROTOC_VERSION = '2.4.1'
 end

data/spec/benchmark/tasks.rb

@@ -60,7 +60,6 @@ namespace :benchmark do
 
   def sock_client_sock_server(number_tests, test_length, global_bench = nil)
     load "protobuf/socket.rb"
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
     EM.stop if EM.reactor_running?
 
     StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
@@ -76,7 +75,6 @@ namespace :benchmark do
 
   def sock_client_em_server(number_tests, test_length, global_bench = nil)
     load "protobuf/socket.rb"
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
     EM.stop if EM.reactor_running?
     em_thread = Thread.new { EM.run }
     Thread.pass until EM.reactor_running?
@@ -97,7 +95,6 @@ namespace :benchmark do
 
   def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
     load "protobuf/zmq.rb"
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
     StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server|
       client = ::Test::ResourceService.client(:port => 9399)
 

data/spec/functional/evented_server_spec.rb

@@ -4,7 +4,6 @@ require 'spec/support/test/resource_service'
 describe 'Functional EventMachine Client' do
   before(:each) do
     load 'protobuf/evented.rb'
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
   end
 
   it 'runs fine when required fields are set' do

data/spec/functional/socket_server_spec.rb

@@ -4,9 +4,8 @@ require 'spec/support/test/resource_service'
 describe 'Functional Socket Client' do
   before(:all) do
     load "protobuf/socket.rb"
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
     Thread.abort_on_exception = true
-    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    server = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
     @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }
     Thread.pass until Protobuf::Rpc::Socket::Server.running?
   end

data/spec/functional/zmq_server_spec.rb

@@ -4,9 +4,8 @@ require 'spec/support/test/resource_service'
 describe 'Functional ZMQ Client' do
   before(:all) do
     load "protobuf/zmq.rb"
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
     Thread.abort_on_exception = true
-    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    server = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100, :threads => 5)
     @server_thread = Thread.new(server) { |s| Protobuf::Rpc::ZmqRunner.run(s) }
     Thread.pass until Protobuf::Rpc::Zmq::Server.running?
   end

data/spec/lib/protobuf/rpc/client_spec.rb

@@ -4,7 +4,6 @@ require 'spec/support/test/resource_service'
 describe Protobuf::Rpc::Client do
   before(:each) do
     load 'protobuf/evented.rb'
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
   end
 
   context "when using fiber based calls" do

data/spec/lib/protobuf/rpc/connector_spec.rb

@@ -6,36 +6,27 @@ require 'protobuf/zmq'
 describe ::Protobuf::Rpc::Connector do
 
   describe '.connector_for_client(true)' do
-    after { described_class.instance_variable_set(:@_connector, nil) }
+    subject { described_class.connector_for_client }
 
     context 'Protobuf.connector_type is socket' do
-      it 'returns a socket connector class' do
-        ::Protobuf.connector_type = :socket
-        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Socket
-      end
+      before { ::Protobuf.connector_type = :socket }
+      it { should eq ::Protobuf::Rpc::Connectors::Socket }
     end
 
     context 'Protobuf.connector_type is not a known value' do
-      it 'returns a socket connector class' do
-        ::Protobuf.stub(:connector_type).and_return('some value')
-        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Socket
-      end
+      before { ::Protobuf.connector_type = :socket }
+      it { should eq ::Protobuf::Rpc::Connectors::Socket }
     end
 
     context 'Protobuf.connector_type is evented' do
-      it 'returns an eventmachine connector class' do
-        ::Protobuf.connector_type = :evented
-        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::EventMachine
-      end
+      before { ::Protobuf.connector_type = :evented }
+      it { should eq ::Protobuf::Rpc::Connectors::EventMachine }
     end
 
     context 'Protobuf.connector_type is zmq' do
-      it 'returns a zmq connector class' do
-        ::Protobuf.connector_type = :zmq
-        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Zmq
-      end
+      before { ::Protobuf.connector_type = :zmq }
+      it { should eq ::Protobuf::Rpc::Connectors::Zmq }
     end
-
   end
 
 end

data/spec/lib/protobuf/rpc/connectors/base_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Protobuf::Rpc::Connectors::Base do
 
-  let(:opts) do
+  let(:options) do
     { :timeout => 60 }
   end
 
-  subject { Protobuf::Rpc::Connectors::Base.new(opts) }
+  subject { Protobuf::Rpc::Connectors::Base.new(options) }
 
   describe "#send_request" do
     it "raising an error when 'send_request' is not overridden" do
@@ -14,14 +14,14 @@ describe Protobuf::Rpc::Connectors::Base do
     end
 
     it "does not raise error when 'send_request' is overridden" do
-      new_sub = Class.new(subject.class){ def send_request; end }.new(opts)
+      new_sub = Class.new(subject.class){ def send_request; end }.new(options)
       expect{ new_sub.send_request }.to_not raise_error
     end
   end
 
   describe '.new' do
     it 'assigns passed options and initializes success/failure callbacks' do
-      subject.options.should eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(opts))
+      subject.options.should eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
       subject.success_cb.should be_nil
       subject.failure_cb.should be_nil
     end

data/spec/lib/protobuf/rpc/servers/socket_server_spec.rb

@@ -5,14 +5,12 @@ require 'protobuf/evented'
 require 'protobuf/socket'
 
 describe Protobuf::Rpc::Socket::Server do
-  before(:each) do 
-    load 'protobuf/socket.rb' 
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
+  before(:each) do
+    load 'protobuf/socket.rb'
   end
 
   before(:all) do
-    load 'protobuf/socket.rb' 
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
+    load 'protobuf/socket.rb'
     Thread.abort_on_exception = true
     server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
     @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }

data/spec/lib/protobuf/rpc/servers/zmq/broker_spec.rb

@@ -1,15 +1,18 @@
 require 'spec_helper'
 
 describe ::Protobuf::Rpc::Zmq::Broker do
-  before(:each) do 
-    load 'protobuf/zmq.rb' 
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
+  before(:each) do
+    load 'protobuf/zmq.rb'
   end
 
   after(:each) do
     subject.teardown
   end
 
+  subject do
+    described_class.new({ :host => '127.0.0.1', :port => 9399 })
+  end
+
   it 'sets up a context' do
     subject.context.should be_a(::ZMQ::Context)
   end

data/spec/lib/protobuf/rpc/servers/zmq/server_spec.rb

@@ -4,7 +4,6 @@ require 'protobuf/rpc/servers/zmq/server'
 describe Protobuf::Rpc::Zmq::Server do
   before(:each) do 
     load 'protobuf/zmq.rb'
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
   end
 
   describe '.running?' do

data/spec/lib/protobuf/rpc/servers/zmq/util_spec.rb

@@ -6,8 +6,7 @@ end
 
 describe ::Protobuf::Rpc::Zmq::Util do
   before(:each) do
-    load 'protobuf/zmq.rb' 
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
+    load 'protobuf/zmq.rb'
   end
 
   subject { UtilTest.new }

data/spec/lib/protobuf/rpc/servers/zmq/worker_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 describe ::Protobuf::Rpc::Zmq::Worker do
   before(:each) do 
     load 'protobuf/zmq.rb'
-    ::Protobuf::Rpc::Connector.connector_for_client(true)
   end
 
   after(:each) do
@@ -11,6 +10,10 @@ describe ::Protobuf::Rpc::Zmq::Worker do
     subject.instance_variable_get(:@zmq_context).terminate
   end
 
+  subject do
+    described_class.new({ :host => '127.0.0.1', :port => 9400 })
+  end
+
   it 'sets the context' do
     subject.instance_variable_get(:@zmq_context).should be_a(::ZMQ::Context)
   end

data/spec/support/server.rb

@@ -37,12 +37,12 @@ class StubServer
 
   attr_accessor :options
 
-  def initialize(opts = {})
+  def initialize(options = {})
     @running = true
     @options = OpenStruct.new({ :host => "127.0.0.1",
                                 :port => 9399,
                                 :delay => 0,
-                                :server => Protobuf::Rpc::Evented::Server }.merge(opts))
+                                :server => Protobuf::Rpc::Evented::Server }.merge(options))
 
     start
     yield self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000Z
+date: 2012-11-06 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2152184060 !ruby/object:Gem::Requirement
+  requirement: &2152100680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152184060
+  version_requirements: *2152100680
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &2152179420 !ruby/object:Gem::Requirement
+  requirement: &2152099380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152179420
+  version_requirements: *2152099380
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &2152175780 !ruby/object:Gem::Requirement
+  requirement: &2152098400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152175780
+  version_requirements: *2152098400
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2152173860 !ruby/object:Gem::Requirement
+  requirement: &2152097220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152173860
+  version_requirements: *2152097220
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2152172500 !ruby/object:Gem::Requirement
+  requirement: &2152095600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,10 +66,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152172500
+  version_requirements: *2152095600
 - !ruby/object:Gem::Dependency
   name: ffi-rzmq
-  requirement: &2152170080 !ruby/object:Gem::Requirement
+  requirement: &2152094240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +77,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152170080
+  version_requirements: *2152094240
 - !ruby/object:Gem::Dependency
   name: perftools.rb
-  requirement: &2152151800 !ruby/object:Gem::Requirement
+  requirement: &2152088440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152151800
+  version_requirements: *2152088440
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &2152144100 !ruby/object:Gem::Requirement
+  requirement: &2152087100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152144100
+  version_requirements: *2152087100
 - !ruby/object:Gem::Dependency
   name: pry-nav
-  requirement: &2152143260 !ruby/object:Gem::Requirement
+  requirement: &2152086180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,10 +110,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152143260
+  version_requirements: *2152086180
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152142540 !ruby/object:Gem::Requirement
+  requirement: &2152085220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -121,10 +121,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152142540
+  version_requirements: *2152085220
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &2152141860 !ruby/object:Gem::Requirement
+  requirement: &2152083820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -132,10 +132,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152141860
+  version_requirements: *2152083820
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152140260 !ruby/object:Gem::Requirement
+  requirement: &2152082700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -143,10 +143,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152140260
+  version_requirements: *2152082700
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &2152139460 !ruby/object:Gem::Requirement
+  requirement: &2152081360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -154,10 +154,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152139460
+  version_requirements: *2152081360
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2152138580 !ruby/object:Gem::Requirement
+  requirement: &2152080320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -165,7 +165,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152138580
+  version_requirements: *2152080320
 description: Google Protocol Buffers v2.4.1 Serialization and RPC implementation for
   Ruby.
 email:
@@ -446,7 +446,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2922389583391730892
+      hash: 893090751339011969
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -455,7 +455,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2922389583391730892
+      hash: 893090751339011969
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.15