celluloid-zmq 0.16.1 → 0.17.0

data/culture/rubocop/README.md

@@ -0,0 +1,38 @@
+# About
+[RuboCop](https://github.com/bbatsov/rubocop) is a ruby static code analyzer.
+It's more than just a lint. It verifies the code against ruby best practices and performs code correctness analysis.
+Celluloid culture doesn't always agree with all rubocop default policies and so we provide a rubocop configuration file that overrides its default behavior.
+
+# Integration
+
+[Integrate `celluloid/culture`](../README.md#integration), then include `culture/rupocop/.rubocop.yml` in your default rubocop config.
+
+##### Add celluloid/culture as GIT submodule:
+
+* See instructions: [Integrate the `celluloid/culture` sub-module](../README.md#integration)
+
+##### Include `culture/rupocop/rubocop.yml` in the `.rubocop.yml` in the root of your project:
+```yml
+inherit_from:
+  - culture/rubocop/rubocop.yml
+```
+
+# How to add rubocop to your project
+
+The `rubocop` gem is automatically included by `Celluloid::Sync.gems` when that is [implemented](../SYNC.md).
+
+##### Add a 'rubocop' target in your `Rakefile`
+
+# Hints
+It's possible to use rubocop for autocorrection of minor problems.
+
+Always verify these changes by running:
+
+```sh
+bundle exec rubocop
+```
+
+Once you are ready to auto-corret the issues you are shown, run it with the `-a` option:
+```sh
+bundle exec rubocop -a
+```

data/culture/rubocop/lint.yml

@@ -0,0 +1,8 @@
+Lint/HandleExceptions:
+  Enabled: false
+
+Lint/LiteralInCondition:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false

data/culture/rubocop/metrics.yml

@@ -0,0 +1,15 @@
+Metrics/MethodLength:
+  CountComments: false
+  Max: 20
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/CyclomaticComplexity:
+  Max: 9
+
+Metrics/PerceivedComplexity:
+  Max: 9
+
+Metrics/AbcSize:
+  Max: 20

data/culture/rubocop/rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from:
+    - lint.yml
+    - metrics.yml
+    - style.yml

data/culture/rubocop/style.yml

@@ -0,0 +1,48 @@
+Style/Documentation:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: true
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/EachWithObject:
+  Enabled: true
+
+Style/InfiniteLoop:
+  Enabled: false
+
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+Style/SpaceInsideBlockBraces:
+  Enabled: false
+
+Style/AccessModifierIndentation:
+  Enabled: false
+
+Style/TrailingComma:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Style/SpaceInsideBlockBraces:
+  Enabled: true
+  EnforcedStyle: space
+
+Style/SpaceInsideHashLiteralBraces:
+  Enabled: true
+  EnforcedStyle: no_space
+
+Style/EmptyLinesAroundAccessModifier:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false

data/culture/spec/gems_spec.rb

@@ -0,0 +1,2 @@
+Rspec.describe Celluloid::Gems do
+end

data/culture/spec/sync_spec.rb

@@ -0,0 +1,2 @@
+Rspec.describe Celluloid::Sync do
+end

data/culture/sync.rb

@@ -0,0 +1,56 @@
+require "forwardable"
+
+module Celluloid
+  module Sync
+    class << self
+      undef gem_path rescue nil
+      def gem_path
+        File.expand_path("../../", __FILE__)
+      end
+
+      undef gem_name rescue nil
+      def gem_name
+        Dir["#{File.expand_path('../../', __FILE__)}/*.gemspec"].first.gsub(".gemspec", "").split("/").last
+      end
+
+      undef gem_name? rescue nil
+      def gem_name?
+        !gem_name.nil?
+      end
+
+      undef lib_path rescue nil
+      def lib_path
+        File.expand_path("../../lib", __FILE__)
+      end
+
+      undef lib_gempath rescue nil
+      def lib_gempath
+        "#{lib_path}/#{gem_name.split('-').join('/')}"
+      end
+
+      undef scenario rescue nil
+      def scenario
+        File.basename($PROGRAM_NAME)
+      end
+
+      undef bundler? rescue nil
+      def bundler?
+        scenario == "bundle"
+      end
+    end
+
+    fail "Missing gemspec." unless gem_name?
+    $LOAD_PATH.push(gem_path)
+    $LOAD_PATH.push(lib_path)
+
+    # TODO: This will likely need to be done differently if INSIDE a cut gem.
+    if scenario == "bundle"
+      `cd #{gem_path}/culture; git pull origin master` if ARGV.first == "update"
+    end
+
+    require("#{gem_path}/culture/gems/loader")
+    if File.exist?(version = "#{lib_gempath}/version.rb")
+      require(version)
+    end
+  end
+end

data/culture/tasks/rspec.rake

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end

data/culture/tasks/rubocop.rake

@@ -0,0 +1,2 @@
+require "rubocop/rake_task"
+RuboCop::RakeTask.new

data/examples/publish_subscribe.rb

@@ -1,4 +1,6 @@
-require 'celluloid/zmq'
+require 'celluloid/zmq/current'
+
+Celluloid::ZMQ.init
 
 class PublishSubscribe
   include Celluloid::ZMQ
@@ -6,11 +8,11 @@ class PublishSubscribe
   def run
     link = "tcp://127.0.0.1:5555"
 
-    s1 = PubSocket.new
-    s2 = SubSocket.new
-    s3 = SubSocket.new
-    s4 = SubSocket.new
-    s5 = SubSocket.new
+    s1 = Socket::Pub.new
+    s2 = Socket::Sub.new
+    s3 = Socket::Sub.new
+    s4 = Socket::Sub.new
+    s5 = Socket::Sub.new
 
     s1.linger = 100
     s2.subscribe('') # receive all

data/lib/celluloid/zmq.rb

@@ -1,16 +1,23 @@
 require 'ffi-rzmq'
 
-require 'celluloid'
+$CELLULOID_ZMQ_BACKPORTED = (ENV["CELLULOID_ZMQ_BACKPORTED"] != "false") unless defined?($CELLULOID_ZMQ_BACKPORTED)
+
+require ($CELLULOID_ZMQ_BACKPORTED) ? 'celluloid' : 'celluloid/current'
+
 require 'celluloid/zmq/mailbox'
 require 'celluloid/zmq/reactor'
-require 'celluloid/zmq/sockets'
+require 'celluloid/zmq/socket'
 require 'celluloid/zmq/version'
 require 'celluloid/zmq/waker'
 
+require 'celluloid/zmq/socket/readable'
+require 'celluloid/zmq/socket/writable'
+require 'celluloid/zmq/socket/types'
+
 module Celluloid
   # Actors which run alongside 0MQ sockets
   module ZMQ
-    UninitializedError = Class.new StandardError
+    class UninitializedError < Celluloid::Error; end
 
     class << self
       attr_writer :context
@@ -65,5 +72,12 @@ module Celluloid
     end
     module_function :wait_writable
 
+    def result_ok?(result)
+      ::ZMQ::Util.resultcode_ok?(result)
+    end
+    module_function :result_ok?
+
   end
 end
+
+require 'celluloid/zmq/deprecate' unless $CELLULOID_BACKPORTED == false || $CELLULOID_ZMQ_BACKPORTED == false

data/lib/celluloid/zmq/current.rb

@@ -0,0 +1,2 @@
+$CELLULOID_ZMQ_BACKPORTED = false
+require "celluloid/zmq"

data/lib/celluloid/zmq/deprecate.rb

@@ -0,0 +1,15 @@
+module Celluloid
+  module ZMQ
+    ReadableSocket = Socket::Readable
+    WritableSocket = Socket::Writable
+    RepSocket = Socket::Rep
+    ReqSocket = Socket::Req
+    DealerSocket = Socket::Dealer
+    RouterSocket = Socket::Router
+    PushSocket = Socket::Push
+    PullSocket = Socket::Pull
+    PubSocket = Socket::Pub
+    XPubSocket = Socket::XPub
+    SubSocket = Socket::Sub
+  end
+end

data/lib/celluloid/zmq/mailbox.rb

@@ -1,7 +1,7 @@
 module Celluloid
   module ZMQ
     # Replacement mailbox for Celluloid::ZMQ actors
-    class Mailbox < Celluloid::EventedMailbox
+    class Mailbox < Celluloid::Mailbox::Evented
       def initialize
         super(Reactor)
       end

data/lib/celluloid/zmq/reactor.rb

@@ -3,10 +3,11 @@ module Celluloid
     # React to incoming 0MQ and Celluloid events. This is kinda sorta supposed
     # to resemble the Reactor design pattern.
     class Reactor
-      extend Forwardable
 
+      extend Forwardable
       def_delegator :@waker, :signal, :wakeup
       def_delegator :@waker, :cleanup, :shutdown
+      def_delegator ZMQ, :result_ok?
 
       def initialize
         @waker = Waker.new
@@ -15,7 +16,7 @@ module Celluloid
         @writers = {}
 
         rc = @poller.register @waker.socket, ::ZMQ::POLLIN
-        unless ::ZMQ::Util.resultcode_ok? rc
+        unless result_ok? rc
           raise "0MQ poll error: #{::ZMQ::Util.error_string}"
         end
       end
@@ -55,7 +56,7 @@ module Celluloid
 
         rc = @poller.poll(timeout)
 
-        unless ::ZMQ::Util.resultcode_ok? rc
+        unless result_ok? rc
           raise IOError, "0MQ poll error: #{::ZMQ::Util.error_string}"
         end
 

data/lib/celluloid/zmq/socket.rb

@@ -0,0 +1,75 @@
+module Celluloid
+  module ZMQ
+    class Socket
+      extend Forwardable
+      def_delegator ZMQ, :result_ok?
+      # Create a new socket
+      def initialize(type)
+        @socket = Celluloid::ZMQ.context.socket ::ZMQ.const_get(type.to_s.upcase)
+        @linger = 0
+      end
+      attr_reader :linger
+
+      # Connect to the given 0MQ address
+      # Address should be in the form: tcp://1.2.3.4:5678/
+      def connect(addr)
+        unless result_ok? @socket.connect addr
+          raise IOError, "error connecting to #{addr}: #{::ZMQ::Util.error_string}"
+        end
+        true
+      end
+
+      def linger=(value)
+        @linger = value || -1
+
+        unless result_ok? @socket.setsockopt(::ZMQ::LINGER, value)
+          raise IOError, "couldn't set linger: #{::ZMQ::Util.error_string}"
+        end
+      end
+
+      def identity=(value)
+        unless result_ok? @socket.setsockopt(::ZMQ::IDENTITY, "#{value}")     
+          raise IOError, "couldn't set identity: #{::ZMQ::Util.error_string}"   
+        end
+        #de @socket.identity = value
+      end
+
+      def identity
+        #de @socket.identity
+        get(::ZMQ::IDENTITY)
+      end
+
+      def set(option, value, length = nil)
+        unless result_ok? @socket.setsockopt(option, value, length)
+          raise IOError, "couldn't set value for option #{option}: #{::ZMQ::Util.error_string}"
+        end
+      end
+
+      def get(option)
+        option_value = []
+
+        unless result_ok? @socket.getsockopt(option, option_value)
+          raise IOError, "couldn't get value for option #{option}: #{::ZMQ::Util.error_string}"
+        end
+
+        option_value[0]
+      end
+
+      # Bind to the given 0MQ address
+      # Address should be in the form: tcp://1.2.3.4:5678/
+      def bind(addr)
+        unless result_ok? @socket.bind(addr)
+          raise IOError, "couldn't bind to #{addr}: #{::ZMQ::Util.error_string}"
+        end
+      end
+
+      # Close the socket
+      def close
+        @socket.close
+      end
+
+      # Hide ffi-rzmq internals
+      alias_method :inspect, :to_s
+    end
+  end
+end

data/lib/celluloid/zmq/socket/readable.rb

@@ -0,0 +1,46 @@
+module Celluloid
+  module ZMQ
+    class Socket
+      # Readable 0MQ sockets have a read method
+      module Readable
+        extend Forwardable
+        def_delegator ZMQ, :result_ok?
+
+        # always set LINGER on readable sockets
+        def bind(addr)
+          self.linger = @linger
+          super(addr)
+        end
+
+        def connect(addr)
+          self.linger = @linger
+          super(addr)
+        end
+
+        # Read a message from the socket
+        def read(buffer = '')
+          ZMQ.wait_readable(@socket) if ZMQ.evented?
+
+          unless result_ok? @socket.recv_string buffer
+            raise IOError, "error receiving ZMQ string: #{::ZMQ::Util.error_string}"
+          end
+          buffer
+        end
+
+        # Multiparts message ?
+        def_delegator :@socket, :more_parts?
+
+        # Reads a multipart message, stores it into the given buffer and returns
+        # the buffer.
+        def read_multipart(buffer = [])
+          ZMQ.wait_readable(@socket) if ZMQ.evented?
+
+          unless result_ok? @socket.recv_strings buffer
+            raise IOError, "error receiving ZMQ string: #{::ZMQ::Util.error_string}"
+          end
+          buffer
+        end
+      end
+    end
+  end
+end