em-zmq-tp10 0.1.17 → 0.1.18

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be62a1ea0af2e99a3b6a974a2a3e2da94d4a548b
+  data.tar.gz: e11e1a7b60f8736e5686dc16a3b735e7c5292bc4
+SHA512:
+  metadata.gz: 8fbde09f3e2ae2d9fc1912365c7fcbdc66abc7ea72a9113d8e3a0aa834fe7a1bd9314ee92759cf11c15faa79103a99262610e4950137cd0cbc9ceaa032105094
+  data.tar.gz: 67e2778866ed15fac8c1ce186a4b0d0f7b47be93958319c5d8377743fe73cc1992ab97ccfb69dd280640fdf59fad71c93263a5b4338653a522f613ab98257916

data/README.md

@@ -48,95 +48,99 @@ And you could do any crazy thing using base `EM::Protocols::Zmq2::Socket` class
 
 ### Dealer
 
-      class MyPreDealer < EM::Protocols::Zmq2::PreDealer
-        def receive_message(message)
-          puts "Message received: #{message.inspect}"
-        end
-      end
-      dealer = MyPreDealer.new
-      dealer.connect('tcp://127.0.0.1:8000')
-      dealer.bind('unix://dealer.sock')
-      EM.schedule {
-        if !dealer.send_message(['asdf','fdas'])
-          puts "Could not send message (no free peers)"
-        end
-      }
-
-      class MyDealer < EM::Protocols::Zmq2::Dealer
-        def receive_message(message)
-          puts "Message received: #{message.inspect}"
-        end
-      end
-      dealer = MyDealer.new(hwm: 1000, hwm_strategy: :drop_last)
-      dealer.connect('tcp://127.0.0.1:8000')
-      EM.schedule {
-        if !dealer.send_message(['asdf','fdas'])
-          puts "No free peers and outgoing queue is full"
-        end
-      }
-
-      dealer = EM::Protocols::Zmq2::DealerCb.new do |message|
-         puts "Receive message #{message.inspect}"
-      end
-      dealer.connect('ipc://rep')
-      EM.schedule {
-        dealer.send_message(['hello','world'])
-      }
+```ruby
+class MyPreDealer < EM::Protocols::Zmq2::PreDealer
+  def receive_message(message)
+    puts "Message received: #{message.inspect}"
+  end
+end
+dealer = MyPreDealer.new
+dealer.connect('tcp://127.0.0.1:8000')
+dealer.bind('unix://dealer.sock')
+EM.schedule {
+  if !dealer.send_message(['asdf','fdas'])
+    puts "Could not send message (no free peers)"
+  end
+}
+
+class MyDealer < EM::Protocols::Zmq2::Dealer
+  def receive_message(message)
+    puts "Message received: #{message.inspect}"
+  end
+end
+dealer = MyDealer.new(hwm: 1000, hwm_strategy: :drop_last)
+dealer.connect('tcp://127.0.0.1:8000')
+EM.schedule {
+  if !dealer.send_message(['asdf','fdas'])
+    puts "No free peers and outgoing queue is full"
+  end
+}
+
+dealer = EM::Protocols::Zmq2::DealerCb.new do |message|
+   puts "Receive message #{message.inspect}"
+end
+dealer.connect('ipc://rep')
+EM.schedule {
+  dealer.send_message(['hello','world'])
+}
+```
 
 ### Req
 
-      class MyPreReq < EM::Protocols::Zmq2::PreReq
-        def receive_reply(message, data, request_id)
-          puts "Received message #{message} and stored data #{data}
-        end
-      end
-      req = MyPreReq.new
-      req.bind(...)
-      req.connect(...)
-      if request_id = req.send_request(['this is', 'message'], 'saved_data')
-        puts "Message sent"
-      else
-        puts "there is no free peer"
-      end
-
-      class MyReq < EM::Protocols::Zmq2::PreReq
-        def receive_reply(message, data, request_id)
-          puts "Received message #{message} and stored data #{data}
-        end
-      end
-      req = MyReq.new
-      req.bind(...)
-      req.connect(...)
-      if request_id = req.send_request(['hi'], 'ho')
-        puts "Message sent"
-      end
-
-      req = EM::Protocols::Zmq2::ReqCb.new
-      req.bind('ipc://req')
-      timer = nil
-      request_id = req.send_request(['hello', 'world']) do |message|
-        EM.cancel_timer(timer)
-        puts "Message #{message}"
-      end
-      if request_id
-        timer = EM.add_timer(1) {
-          req.cancel_request(request_id)
-        }
-      end
-
-      req = EM::Protocols::Zmq2::ReqDefer.new
-      req.bind('ipc://req')
-      data = {hi: 'ho'}
-      deferable = req.send_request(['hello', 'world'], data) do |reply, data|
-        puts "Reply received #{reply} #{data}"
-      end
-      deferable.timeout 1
-      deferable.errback do
-        puts "Message canceled"
-      end
-      deferable.callback do |reply, data|
-        puts "Another callback #{reply} #{data}"
-      end
+```ruby
+class MyPreReq < EM::Protocols::Zmq2::PreReq
+  def receive_reply(message, data, request_id)
+    puts "Received message #{message} and stored data #{data}"
+  end
+end
+req = MyPreReq.new
+req.bind(...)
+req.connect(...)
+if request_id = req.send_request(['this is', 'message'], 'saved_data')
+  puts "Message sent"
+else
+  puts "there is no free peer"
+end
+
+class MyReq < EM::Protocols::Zmq2::PreReq
+  def receive_reply(message, data, request_id)
+    puts "Received message #{message} and stored data #{data}"
+  end
+end
+req = MyReq.new
+req.bind(...)
+req.connect(...)
+if request_id = req.send_request(['hi'], 'ho')
+  puts "Message sent"
+end
+
+req = EM::Protocols::Zmq2::ReqCb.new
+req.bind('ipc://req')
+timer = nil
+request_id = req.send_request(['hello', 'world']) do |message|
+  EM.cancel_timer(timer)
+  puts "Message #{message}"
+end
+if request_id
+  timer = EM.add_timer(1) {
+    req.cancel_request(request_id)
+  }
+end
+
+req = EM::Protocols::Zmq2::ReqDefer.new
+req.bind('ipc://req')
+data = {hi: 'ho'}
+deferable = req.send_request(['hello', 'world'], data) do |reply, data|
+  puts "Reply received #{reply} #{data}"
+end
+deferable.timeout 1
+deferable.errback do
+  puts "Message canceled"
+end
+deferable.callback do |reply, data|
+  puts "Another callback #{reply} #{data}"
+end
+```
 
 ### Router
 
@@ -144,51 +148,55 @@ Router stores peer identity in a message, as ZMQ router do.
 And it sends message to a peer, which idenitity equals to first message string.
 `PreRouter` does no any queue caching, `Router` saves message in queue per peer, controlled by highwatermark strategy.
 
-      class MyPreRouter < EM::Protocols::Zmq2::PreRouter
-        def receive_message(message)
-          puts "Received message #{message} (and it contains envelope)"
-        end
-      end
-      router = MyPreRouter.new
-      router.bind(...)
-      router.send_message(message)
-
-      class MyRouter < EM::Protocols::Zmq2::Router
-        def receive_message(message)
-          puts "Received message #{message}"
-          message[-1] = 'reply'
-          send_message(message)
-        end
-      end
-      router = MyPreRouter.new(hwm: 1000, hwm_strategy: :drop_first)
-      router.bind(...)
-      router.send_message(message)
+```ruby
+class MyPreRouter < EM::Protocols::Zmq2::PreRouter
+  def receive_message(message)
+    puts "Received message #{message} (and it contains envelope)"
+  end
+end
+router = MyPreRouter.new
+router.bind(...)
+router.send_message(message)
+
+class MyRouter < EM::Protocols::Zmq2::Router
+  def receive_message(message)
+    puts "Received message #{message}"
+    message[-1] = 'reply'
+    send_message(message)
+  end
+end
+router = MyPreRouter.new(hwm: 1000, hwm_strategy: :drop_first)
+router.bind(...)
+router.send_message(message)
+```
 
 ### Rep
 
 REP differs from Router mainly in methods signature.
 
-      class EchoBangPreRep < EM::Protocols::Zmq2::PreRep
-        def receive_request(message, envelope)
-          message << "!"
-          if send_reply(message, envelope)
-            puts "reply sent successfuly"
-          end
-        end
-      end
-      rep = EchoBangPreRep.new
-      rep.bind('ipc://rep')
-
-      class EchoBangRep < EM::Protocols::Zmq2::Rep
-        def receive_request(message, envelope)
-          message << "!"
-          if send_reply(message, envelope)
-            puts "reply sent successfuly"
-          end
-        end
-      end
-      rep = EchoBangRep.new
-      rep.bind('ipc://rep')
+```ruby
+class EchoBangPreRep < EM::Protocols::Zmq2::PreRep
+  def receive_request(message, envelope)
+    message << "!"
+    if send_reply(message, envelope)
+      puts "reply sent successfuly"
+    end
+  end
+end
+rep = EchoBangPreRep.new
+rep.bind('ipc://rep')
+
+class EchoBangRep < EM::Protocols::Zmq2::Rep
+  def receive_request(message, envelope)
+    message << "!"
+    if send_reply(message, envelope)
+      puts "reply sent successfuly"
+    end
+  end
+end
+rep = EchoBangRep.new
+rep.bind('ipc://rep')
+```
 
 ### Sub
 
@@ -197,19 +205,21 @@ Note that as in ZMQ 2.x filtering occurs on Sub side.
 
 Since subscriptions could be defined with callback passed to `:subscribe` option, `subscribe` or `subscribe_many` methods, you could use this class without overloading.
 
-      class MySub < EM::Protocols::Zmq2::Sub
-        def receive_message(message)
-          puts "default handler"
-        end
-      end
-      sub = MySub.new(subscribe: ['this', 'that'])
-      sub.subscribe /^callback/i, do |message|
-        puts "Callback subscribe #{message}"
-      end
-      sub.subscribe_many(
-        proc{|s| s.end_with?("END")} => proc{|message| puts "TILL END #{message}"},
-        '' => nil # also to default
-      )
+```ruby
+class MySub < EM::Protocols::Zmq2::Sub
+  def receive_message(message)
+    puts "default handler"
+  end
+end
+sub = MySub.new(subscribe: ['this', 'that'])
+sub.subscribe /^callback/i, do |message|
+  puts "Callback subscribe #{message}"
+end
+sub.subscribe_many(
+  proc{|s| s.end_with?("END")} => proc{|message| puts "TILL END #{message}"},
+  '' => nil # also to default
+)
+```
 
 ### Pub
 
@@ -219,14 +229,15 @@ Since subscriptions could be defined with callback passed to `:subscribe` option
 
 Since there is no incoming data, there is no need to overload methods.
 
-      pub = EM::Protocols::Zmq2::PrePub.new
-      pub.bind(...)
-      pub.send_message(['hi', 'you'])
-
-      pub = EM::Protocols::Zmq2::Pub.new
-      pub.bind(...)
-      pub.send_message(['hi', 'you'])
+```ruby
+pub = EM::Protocols::Zmq2::PrePub.new
+pub.bind(...)
+pub.send_message(['hi', 'you'])
 
+pub = EM::Protocols::Zmq2::Pub.new
+pub.bind(...)
+pub.send_message(['hi', 'you'])
+```
 
 ## Contributing
 

data/lib/em/protocols/zmq2/socket.rb

@@ -12,7 +12,11 @@ module EM
         attr :identity, :hwm
         attr_accessor :hwm_strategy
         attr_accessor :do_balance
-        GENERATED = '%GN%'.freeze
+        if String.method_defined?(:b)
+          GENERATED = '%GN%'.b.freeze
+        else
+          GENERATED = '%GN%'.force_encoding('BINARY').freeze
+        end
 
         # Accept options, which are dependend on socket type
         # Common options are:

data/lib/em/protocols/zmq2/version.rb

@@ -1,7 +1,7 @@
 module EventMachine
   module Protocols
     module Zmq2
-      VERSION = '0.1.17'
+      VERSION = '0.1.18'
     end
   end
 end

metadata

@@ -1,48 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: em-zmq-tp10
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.1.17
+  version: 0.1.18
 platform: ruby
 authors:
 - Sokolov Yura 'funny-falcon'
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-12 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  type: :runtime
+  name: eventmachine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: eventmachine
 - !ruby/object:Gem::Dependency
-  type: :development
+  name: ffi-rzmq
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: ffi-rzmq
 description: Implementation of ZMQ2.x transport protocol - ZMTP1.0
 email:
 - funny.falcon@gmail.com
@@ -50,7 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -81,27 +76,26 @@ files:
 - tests/test_router.rb
 homepage: https://github.com/funny-falcon/em-zmq-tp10
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.4.4
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Implementation of ZMQ2.1 transport protocol and main socket types using EventMachine
   for managing TCP/UNIX connections, doing nonblocking writes and calling callback
   on incoming messages.