em-zeromq 0.3.1 → 0.4.0

data/README.md

@@ -53,50 +53,25 @@ flag api changes but be aware that small changes can still occur between release
 
 ## Example ##
 ```ruby
-require 'rubygems'
 require 'em-zeromq'
 
-class EMTestPullHandler
-  attr_reader :received
-  def on_readable(socket, parts)
-    parts.each do |m|
-      puts m.copy_out_string
-    end
-  end
-end
+zmq = EM::ZeroMQ::Context.new(1)
 
-trap('INT') do
-  EM::stop()
-end
+EM.run {
+  push = zmq.socket(ZMQ::PUSH)
+  push.connect("tcp://127.0.0.1:2091")
 
-ctx = EM::ZeroMQ::Context.new(1)
-EM.run do
-  # setup push sockets
-  push_socket1 = ctx.socket(ZMQ::PUSH)  
-  push_socket1.bind('tcp://127.0.0.1:2091')
-  
-  push_socket2 = ctx.socket(ZMQ::PUSH) do |s|
-    s.bind('ipc:///tmp/a')
-  end
-  
-  push_socket3 = ctx.socket(ZMQ::PUSH)
-  push_socket3.bind('inproc://simple_test')
-  
-  # setup one pull sockets listening to all push sockets
-  pull_socket = ctx.socket(ZMQ::PULL, EMTestPullHandler.new)
-  pull_socket.connect('tcp://127.0.0.1:2091')
-  pull_socket.connect('ipc:///tmp/a')
-  pull_socket.connect('inproc://simple_test')
-  
-  n = 0
-  
-  EM::PeriodicTimer.new(0.1) do
-    puts '.'
-    push_socket1.send_msg("t#{n += 1}_")
-    push_socket2.send_msg("i#{n += 1}_")
-    push_socket3.send_msg("p#{n += 1}_")
-  end
-end
+  pull = zmq.socket(ZMQ::PULL)
+  pull.bind("tcp://127.0.0.1:2091")
+
+  pull.on(:message) { |part|
+    puts part.copy_out_string
+  }
+
+  EM.add_periodic_timer(1) {
+    push.send_msg("Hello")
+  }
+}
 ```
 
 ## License: ##

data/em-zeromq.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "em-zeromq"
 
-  s.add_dependency 'eventmachine', '1.0.0.beta.4'
+  s.add_dependency 'eventmachine', '>= 1.0.0'
   s.add_dependency 'ffi', '>= 1.0.0'
   s.add_dependency 'ffi-rzmq', '0.9.3'
 

data/example/multi-part.rb

@@ -0,0 +1,31 @@
+# This example shows how one might deal with sending and recieving multi-part
+# messages
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'em-zeromq'
+
+zmq = EM::ZeroMQ::Context.new(1)
+
+EM.run {
+  pull = zmq.socket(ZMQ::PULL)
+  pull.bind("ipc:///tmp/test")
+
+  pull.on(:message) { |part1, part2|
+    p [:part1, part1.copy_out_string, :part2, part2.copy_out_string]
+  }
+
+  pull.on(:message) { |*parts|
+    p [:parts, parts.map(&:copy_out_string)]
+  }
+
+  push = zmq.socket(ZMQ::PUSH)
+  push.connect("ipc:///tmp/test")
+
+  i = 0
+  EM.add_periodic_timer(1) {
+    puts "Sending 2-part message"
+    i += 1
+    push.send_msg("hello #{i}", "second part")
+  }
+}

data/example/simple.rb

@@ -4,23 +4,14 @@ require 'em-zeromq'
     
 Thread.abort_on_exception = true
 
-class EMTestPullHandler
-  attr_reader :received
-  def on_readable(socket, parts)
-    parts.each do |m|
-      puts m.copy_out_string
-    end
-  end
-end
-
 trap('INT') do
   EM::stop()
 end
 
 puts "Started (with zmq #{ZMQ::Util.version.join('.')})."
 
-
 ctx = EM::ZeroMQ::Context.new(1)
+
 EM.run do
   # setup push sockets
   push_socket1 = ctx.socket(ZMQ::PUSH)
@@ -30,19 +21,24 @@ EM.run do
   
   push_socket1.bind('tcp://127.0.0.1:2091')
   
-  push_socket2 = ctx.socket(ZMQ::PUSH) do |s|
-    s.bind('ipc:///tmp/a')
-  end
+  push_socket2 = ctx.socket(ZMQ::PUSH)
+  push_socket2.bind('ipc:///tmp/a')
   
   push_socket3 = ctx.socket(ZMQ::PUSH)
   push_socket3.bind('inproc://simple_test')
   
   # setup one pull sockets listening to all push sockets
-  pull_socket = ctx.socket(ZMQ::PULL, EMTestPullHandler.new)
+  pull_socket = ctx.socket(ZMQ::PULL)
   pull_socket.connect('tcp://127.0.0.1:2091')
   pull_socket.connect('ipc:///tmp/a')
   pull_socket.connect('inproc://simple_test')
   
+  pull_socket.on(:message) { |*parts|
+    parts.each do |m|
+      puts m.copy_out_string
+    end
+  }
+
   n = 0
   
   EM::PeriodicTimer.new(0.1) do

data/example/simpler.rb

@@ -0,0 +1,23 @@
+# Simpler than simple.rb ;)
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'em-zeromq'
+
+zmq = EM::ZeroMQ::Context.new(1)
+
+EM.run {
+  push = zmq.socket(ZMQ::PUSH)
+  push.connect("tcp://127.0.0.1:2091")
+
+  pull = zmq.socket(ZMQ::PULL)
+  pull.bind("tcp://127.0.0.1:2091")
+
+  pull.on(:message) { |part|
+    puts part.copy_out_string
+  }
+
+  EM.add_periodic_timer(1) {
+    push.send_msg("Hello")
+  }
+}

data/example/terminating.rb

@@ -0,0 +1,23 @@
+# This example shows how to use setsockopt to set the linger period for socket
+# shutdown. This is useful since by default pending meesages will block the
+# termination of the ZMQ context.
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'em-zeromq'
+
+zmq = EM::ZeroMQ::Context.new(1)
+
+EM.run {
+  push = zmq.socket(ZMQ::PUSH)
+  push.setsockopt(ZMQ::LINGER, 0)
+
+  push.connect("ipc:///tmp/foo")
+
+  push.send_msg('hello')
+
+  Signal.trap('INT') {
+    puts 'Trapped INT signal. Stopping eventmachine'
+    EM.stop
+  }
+}

data/lib/em-zeromq.rb

@@ -3,59 +3,8 @@ require 'ffi-rzmq'
 
 module EmZeromq
 
-  # :stopdoc:
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
-  # :startdoc:
-
-  # Returns the library path for the module. If any arguments are given,
-  # they will be joined to the end of the libray path using
-  # <tt>File.join</tt>.
-  #
-  def self.libpath( *args, &block )
-    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
-    if block
-      begin
-        $LOAD_PATH.unshift LIBPATH
-        rv = block.call
-      ensure
-        $LOAD_PATH.shift
-      end
-    end
-    return rv
-  end
-
-  # Returns the lpath for the module. If any arguments are given,
-  # they will be joined to the end of the path using
-  # <tt>File.join</tt>.
-  #
-  def self.path( *args, &block )
-    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
-    if block
-      begin
-        $LOAD_PATH.unshift PATH
-        rv = block.call
-      ensure
-        $LOAD_PATH.shift
-      end
-    end
-    return rv
-  end
-
-  # Utility method used to require all files ending in .rb that lie in the
-  # directory below this file that has the same name as the filename passed
-  # in. Optionally, a specific _directory_ name can be passed in such that
-  # the _filename_ does not have to be equivalent to the directory.
-  #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= ::File.basename(fname, '.*')
-    search_me = ::File.expand_path(
-        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
-
-    Dir.glob(search_me).sort.each {|rb| require rb}
-  end
-
-end  # module EmZeromq
-
-EmZeromq.require_all_libs_relative_to(__FILE__)
+end
 
+require 'em-zeromq/context'
+require 'em-zeromq/event_emitter'
+require 'em-zeromq/socket'

data/lib/em-zeromq/context.rb

@@ -7,8 +7,7 @@
 module EventMachine
   module ZeroMQ
     class Context
-      READABLES = [ ZMQ::SUB, ZMQ::PULL, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ ]
-      WRITABLES = [ ZMQ::PUB, ZMQ::PUSH, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ ]
+
       
       def initialize(threads_or_context)
         if threads_or_context.is_a?(ZMQ::Context)
@@ -24,10 +23,8 @@ module EventMachine
       # @param [Integer] socket_type One of ZMQ::REQ, ZMQ::REP, ZMQ::PULL, ZMQ::PUSH,
       #   ZMQ::ROUTER, ZMQ::DEALER
       # 
-      # @param [Object] handler an object which respond to on_readable(socket, parts)
-      #   and can respond to on_writeable(socket)
       # 
-      def socket(socket_type, handler = nil)
+      def socket(socket_type)
         zmq_socket = @context.socket(socket_type)
         
         fd = []
@@ -35,13 +32,7 @@ module EventMachine
           raise "Unable to get socket FD: #{ZMQ::Util.error_string}"
         end
         
-        
-        EM.watch(fd[0], EventMachine::ZeroMQ::Socket, zmq_socket, socket_type, handler).tap do |s|
-          s.register_readable if READABLES.include?(socket_type)
-          s.register_writable if WRITABLES.include?(socket_type)
-          
-          yield(s) if block_given?
-        end
+        EM.watch(fd[0], EventMachine::ZeroMQ::Socket, zmq_socket, socket_type)
       end
       
     end

data/lib/em-zeromq/event_emitter.rb

@@ -0,0 +1,31 @@
+module EventMachine
+  module ZeroMQ
+    module EventEmitter
+      def on(event, &listener)
+        _listeners[event] << listener
+      end
+
+      def emit(event, *args)
+        _listeners[event].each { |l| l.call(*args) }
+      end
+
+      def remove_listener(event, &listener)
+        _listeners[event].delete(listener)
+      end
+
+      def remove_all_listeners(event)
+        _listeners.delete(event)
+      end
+
+      def listeners(event)
+        _listeners[event]
+      end
+
+      private
+
+      def _listeners
+        @_listeners ||= Hash.new { |h,k| h[k] = [] }
+      end
+    end
+  end
+end

data/lib/em-zeromq/socket.rb

@@ -1,13 +1,19 @@
 module EventMachine
   module ZeroMQ
     class Socket < EventMachine::Connection
-      attr_accessor :on_readable, :on_writable, :handler
+      READABLES = [ ZMQ::SUB, ZMQ::PULL, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ, ZMQ::PAIR ]
+      WRITABLES = [ ZMQ::PUB, ZMQ::PUSH, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ, ZMQ::PAIR ]
+
+      include EventEmitter
+
       attr_reader   :socket, :socket_type      
 
-      def initialize(socket, socket_type, handler)
+      def initialize(socket, socket_type)
         @socket      = socket
         @socket_type = socket_type
-        @handler     = handler
+
+        self.notify_readable = true if READABLES.include?(socket_type)
+        self.notify_writable = true if WRITABLES.include?(socket_type)
       end
       
       def self.map_sockopt(opt, name)
@@ -96,26 +102,10 @@ module EventMachine
       def setsockopt(opt, value)
         @socket.setsockopt(opt, value)
       end
-      
-      # cleanup when ending loop
-      def unbind
-        detach_and_close
-      end
-      
-      # Make this socket available for reads
-      def register_readable
-        # Since ZMQ is event triggered I think this is necessary
-        if readable?
-          notify_readable
-        end
-        # Subscribe to EM read notifications
-        self.notify_readable = true
-      end
 
-      # Trigger on_readable when socket is readable
-      def register_writable
-        # Subscribe to EM write notifications
-        self.notify_writable = true
+      def unbind
+        detach
+        @socket.close
       end
 
       def notify_readable
@@ -124,25 +114,9 @@ module EventMachine
         # I'm leaving this is because its in the docs, but it could probably
         # be taken out.
         return unless readable?
-         
-        loop do
-          msg_parts = []
-          msg       = get_message
-          if msg
-            msg_parts << msg
-            while @socket.more_parts?
-              msg = get_message
-              if msg
-                msg_parts << msg
-              else
-                raise "Multi-part message missing a message!"
-              end
-            end
-            
-            @handler.on_readable(self, msg_parts)
-          else
-            break
-          end
+
+        while (message = get_message)
+          emit(:message, *message)
         end
       end
       
@@ -154,9 +128,7 @@ module EventMachine
         # write events
         self.notify_writable = false
         
-        if @handler.respond_to?(:on_writable)
-          @handler.on_writable(self)
-        end
+        emit(:writable)
       end
       def readable?
         (getsockopt(ZMQ::EVENTS) & ZMQ::POLLIN) == ZMQ::POLLIN
@@ -169,20 +141,11 @@ module EventMachine
       end
      
     private
-    
-      # internal methods
 
       def get_message
-        msg       = ZMQ::Message.new
-        msg_recvd = @socket.recv(msg, ZMQ::NOBLOCK)
-        msg_recvd != -1 ? msg : nil
-      end
-      
-      # Detaches the socket from the EM loop,
-      # then closes the socket
-      def detach_and_close
-        detach
-        @socket.close
+        parts = []
+        rc = @socket.recvmsgs(parts, ZMQ::NOBLOCK)
+        rc >= 0 ? parts : nil
       end
     end
   end

data/lib/em-zeromq/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module EmZeromq
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/spec/pub_sub_spec.rb

@@ -1,22 +1,12 @@
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe EventMachine::ZeroMQ do
-  class EMTestSubHandler
-    attr_reader :received
-    def initialize
-      @received = []
-    end
-    def on_readable(socket, messages)
-      @received += messages
-    end
-  end
-
   it "Should instantiate a connection given valid opts" do
     sub_conn = nil
     address = rand_addr
     
-    run_reactor(1) do
-      sub_conn = SPEC_CTX.socket(ZMQ::PUB, EMTestSubHandler.new)
+    run_reactor do
+      sub_conn = SPEC_CTX.socket(ZMQ::PUB)
       sub_conn.bind(address)
     end
     sub_conn.should be_a(EventMachine::ZeroMQ::Socket)
@@ -24,42 +14,43 @@ describe EventMachine::ZeroMQ do
 
   describe "sending/receiving a single message via PUB/SUB" do
     before(:all) do
-      results = {}
+      @results = {}
+      @received = []
       @test_message = test_message = "TMsg#{rand(999)}"
       
-      run_reactor(0.5) do
+      run_reactor do
         address = rand_addr
         
-        results[:sub_hndlr] = pull_hndlr = EMTestSubHandler.new
-        sub_conn  = SPEC_CTX.socket(ZMQ::SUB, pull_hndlr)
+        sub_conn  = SPEC_CTX.socket(ZMQ::SUB)
         sub_conn.bind(address)
         sub_conn.subscribe('')
+        sub_conn.on(:message) { |m|
+          @received << m
+        }
         
-        pub_conn  = SPEC_CTX.socket(ZMQ::PUB, EMTestSubHandler.new)
+        pub_conn  = SPEC_CTX.socket(ZMQ::PUB)
         pub_conn.connect(address)
         
         pub_conn.socket.send_string test_message, ZMQ::NOBLOCK
         
-        EM::Timer.new(0.1) { results[:specs_ran] = true }
+        EM::Timer.new(0.1) { @results[:specs_ran] = true }
       end
-      
-      @results = results
     end
   
     it "should run completely" do
-      @results[:specs_ran].should be_true
+      @received.should be_true
     end
     
     it "should receive one message" do
-      @results[:sub_hndlr].received.length.should == 1
+      @received.length.should == 1
     end
     
     it "should receive the message as a ZMQ::Message" do
-      @results[:sub_hndlr].received.first.should be_a(ZMQ::Message)
+      @received.first.should be_a(ZMQ::Message)
     end
     
     it "should receive the message intact" do
-      @results[:sub_hndlr].received.first.copy_out_string.should == @test_message
+      @received.first.copy_out_string.should == @test_message
     end
   end
 end

data/spec/push_pull_spec.rb

@@ -1,20 +1,10 @@
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe EventMachine::ZeroMQ do
-  class EMTestPullHandler
-    attr_reader :received
-    def initialize
-      @received = []
-    end
-    def on_readable(socket, messages)
-      @received += messages
-    end
-  end
-
   it "Should instantiate a connection given valid opts" do
     pull_conn = nil
     run_reactor do
-      pull_conn = SPEC_CTX.socket(ZMQ::PULL, EMTestPullHandler.new)
+      pull_conn = SPEC_CTX.socket(ZMQ::PULL)
       pull_conn.bind(rand_addr)
     end
     pull_conn.should be_a(EventMachine::ZeroMQ::Socket)
@@ -22,26 +12,26 @@ describe EventMachine::ZeroMQ do
 
   describe "sending/receiving a single message via PUB/SUB" do
     before(:all) do
-      results = {}
+      @results = {}
+      @received = []
       @test_message = test_message = "TMsg#{rand(999)}"
       
-      run_reactor(0.5) do
-        
+      run_reactor(0.2) do
         address = rand_addr
         
-        results[:pull_hndlr] = pull_hndlr = EMTestPullHandler.new
-        pull_conn = SPEC_CTX.socket(ZMQ::PULL, pull_hndlr)
+        pull_conn = SPEC_CTX.socket(ZMQ::PULL)
         pull_conn.bind(address)
+        pull_conn.on(:message) { |m|
+          @received << m
+        }
         
         push_conn  = SPEC_CTX.socket(ZMQ::PUSH)
         push_conn.connect(address)
         
         push_conn.socket.send_string test_message, ZMQ::NOBLOCK
         
-        EM::Timer.new(0.1) { results[:specs_ran] = true }
+        EM::Timer.new(0.1) { @results[:specs_ran] = true }
       end
-      
-      @results = results
     end
 
     it "should run completely" do
@@ -49,9 +39,9 @@ describe EventMachine::ZeroMQ do
     end
     
     it "should receive the message intact" do
-      @results[:pull_hndlr].received.should_not be_empty
-      @results[:pull_hndlr].received.first.should be_a(ZMQ::Message)
-      @results[:pull_hndlr].received.first.copy_out_string.should == @test_message
+      @received.should_not be_empty
+      @received.first.should be_a(ZMQ::Message)
+      @received.first.copy_out_string.should == @test_message
     end
   end
 end

data/spec/router_dealer_spec.rb

@@ -1,39 +1,10 @@
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe EventMachine::ZeroMQ do
-  class EMTestRouterHandler
-    attr_reader :received
-    def initialize
-      @received = []
-    end
-    def on_writable(socket)
-    end
-    def on_readable(socket, messages)
-      @received += messages
-    end
-  end
-
-  class EMTestDealerHandler
-    attr_reader :received
-    def initialize(&block)
-      @received = []
-      @on_writable_callback = block
-    end
-    def on_writable(socket)
-      @on_writable_callback.call(socket) if @on_writable_callback
-    end
-    def on_readable(socket, messages)
-      _, message = messages.map(&:copy_out_string)
-      @received += [message].map {|s| ZMQ::Message.new(s)}
-      
-      socket.send_msg('', "re:#{message}")
-    end
-  end
-
   it "Should instantiate a connection given valid opts for Router/Dealer" do
     router_conn = nil
-    run_reactor(1) do
-      router_conn = SPEC_CTX.socket(ZMQ::ROUTER, EMTestRouterHandler.new)
+    run_reactor do
+      router_conn = SPEC_CTX.socket(ZMQ::ROUTER)
       router_conn.bind(rand_addr)
     end
     router_conn.should be_a(EventMachine::ZeroMQ::Socket)
@@ -41,32 +12,38 @@ describe EventMachine::ZeroMQ do
 
   describe "sending/receiving a single message via Router/Dealer" do
     before(:all) do
-      results = {}
+      @results = {}
+      @dealer_received, @router_received = [], []
       @test_message = test_message = "M#{rand(999)}"
       
-      run_reactor(2) do
-        results[:dealer_hndlr] = dealer_hndlr = EMTestDealerHandler.new
-        results[:router_hndlr] = router_hndlr = EMTestRouterHandler.new
-
+      run_reactor(0.3) do
         addr = rand_addr
-        dealer_conn = SPEC_CTX.socket(ZMQ::DEALER, dealer_hndlr)
+        dealer_conn = SPEC_CTX.socket(ZMQ::DEALER)
         dealer_conn.identity = "dealer1"
         dealer_conn.bind(addr)
+        dealer_conn.on(:message) { |message|
+          # 2. Dealer receives messages, sends reply back to router
+          @dealer_received << message
+          dealer_conn.send_msg("re:#{message.copy_out_string}")
+        }
         
-        router_conn = SPEC_CTX.socket(ZMQ::ROUTER, router_hndlr)
+        router_conn = SPEC_CTX.socket(ZMQ::ROUTER)
         router_conn.identity = "router1"
         router_conn.connect(addr)
+        router_conn.on(:message) { |*parts|
+          # 3. Message received in router identifies the sending dealer
+          @router_received << parts
+        }
         
         EM::add_timer(0.1) do
-          router_conn.send_msg('dealer1','', test_message)
+          # 1. Send message to the dealer
+          router_conn.send_msg('dealer1', test_message)
         end
          
         EM::Timer.new(0.2) do
-          results[:specs_ran] = true
+          @results[:specs_ran] = true
         end
       end
-      
-      @results = results
     end
 
     it "should run completely" do
@@ -74,15 +51,16 @@ describe EventMachine::ZeroMQ do
     end
     
     it "should receive the message intact on the dealer" do
-      @results[:dealer_hndlr].received.should_not be_empty
-      @results[:dealer_hndlr].received.last.should be_a(ZMQ::Message)
-      @results[:dealer_hndlr].received.last.copy_out_string.should == @test_message
+      @dealer_received.should_not be_empty
+      @dealer_received.last.should be_a(ZMQ::Message)
+      @dealer_received.last.copy_out_string.should == @test_message
     end
 
-    it "the router should be echoed its original message" do
-      @results[:router_hndlr].received.should_not be_empty
-      @results[:router_hndlr].received.last.should be_a(ZMQ::Message)
-      @results[:router_hndlr].received.last.copy_out_string.should == "re:#{@test_message}"
+    it "the router should be echoed its original message with the dealer identity" do
+      @router_received.size.should == 1
+      parts = @router_received[0]
+      parts[0].copy_out_string.should == "dealer1"
+      parts[1].copy_out_string.should == "re:#{@test_message}"
     end
   end
 end

data/spec/spec_helper.rb

@@ -10,7 +10,7 @@ end
 require File.expand_path(
     File.join(File.dirname(__FILE__), %w[.. lib em-zeromq]))
 
-def run_reactor(time=0.2,&block)
+def run_reactor(time=0.1,&block)
   Thread.new do
     EM.run do
       yield

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-zeromq
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,24 +10,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-01 00:00:00.000000000 Z
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.4
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.4
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -122,9 +122,13 @@ files:
 - README.md
 - Rakefile
 - em-zeromq.gemspec
+- example/multi-part.rb
 - example/simple.rb
+- example/simpler.rb
+- example/terminating.rb
 - lib/em-zeromq.rb
 - lib/em-zeromq/context.rb
+- lib/em-zeromq/event_emitter.rb
 - lib/em-zeromq/socket.rb
 - lib/em-zeromq/version.rb
 - spec/context_spec.rb
@@ -148,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3380199177389627233
+      hash: 4479496977537005722
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -157,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3380199177389627233
+      hash: 4479496977537005722
 requirements: []
 rubyforge_project: em-zeromq
 rubygems_version: 1.8.24