cztop 0.14.1 → 1.1.0.pre1

data/lib/cztop/poller/aggregated.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # This is a poller which is able to provide a list of readable and a list
   # of writable sockets. This is useful for when you need to process socket
@@ -37,31 +39,37 @@ module CZTop
     # @return [CZTop::Poller.new] the associated (regular) poller
     attr_reader :poller
 
+
     # @return [Array<CZTop::Socket>] readable sockets
     attr_reader :readables
 
+
     # @return [Array<CZTop::Socket>] writable sockets
     attr_reader :writables
 
+
     extend Forwardable
+
     def_delegators :@poller,
-      :add,
-      :add_reader,
-      :add_writer,
-      :modify,
-      :remove,
-      :remove_reader,
-      :remove_writer,
-      :sockets
+                   :add,
+                   :add_reader,
+                   :add_writer,
+                   :modify,
+                   :remove,
+                   :remove_reader,
+                   :remove_writer,
+                   :sockets
+
 
     # Initializes the aggregated poller.
     # @param poller [CZTop::Poller] the wrapped poller
     def initialize(poller = CZTop::Poller.new)
       @readables = []
       @writables = []
-      @poller = poller
+      @poller    = poller
     end
 
+
     # Forgets all previous event information (which sockets are
     # readable/writable) and waits for events anew. After getting the first
     # event, {CZTop::Poller#wait} is called again with a zero-timeout to get
@@ -76,26 +84,29 @@ module CZTop
     #   or -1 to wait indefinitely
     # @return [Boolean] whether there have been any events
     def wait(timeout = -1)
-      @readables = []
-      @writables = []
+      @readables   = []
+      @writables   = []
       @event_masks = {}
 
-      if event = @poller.wait(timeout)
+      if (event = @poller.wait(timeout))
         extract(event)
 
         # get all other pending events, if any, but no more blocking
-        while event = @poller.wait(0)
+        while (event = @poller.wait 0)
           extract(event)
         end
 
         restore_event_masks
         return true
       end
-      return false
+
+      false
     end
 
+
     private
 
+
     # Extracts the event information, adds the socket to the correct list(s)
     # and modifies the socket's event mask for the socket to not turn up
     # again during the next call(s) to {CZTop::Poller#wait} within {#wait}.
@@ -103,24 +114,29 @@ module CZTop
     # @param event [CZTop::Poller::Event]
     # @return [void]
     def extract(event)
-      event_mask = poller.event_mask_for_socket(event.socket)
+      event_mask                 = poller.event_mask_for_socket(event.socket)
       @event_masks[event.socket] = event_mask
+
       if event.readable?
         @readables << event.socket
         event_mask &= 0xFFFF ^ CZTop::Poller::ZMQ::POLLIN
       end
+
       if event.writable?
         @writables << event.socket
         event_mask &= 0xFFFF ^ CZTop::Poller::ZMQ::POLLOUT
       end
+
       poller.modify(event.socket, event_mask)
     end
 
+
     # Restores the event mask for all registered sockets to the state they
     # were before the call to {#wait}.
     # @return [void]
     def restore_event_masks
       @event_masks.each { |socket, mask| poller.modify(socket, mask) }
     end
+
   end
 end

data/lib/cztop/poller/zmq.rb

@@ -1,5 +1,6 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # CZTop's interface to the low-level +zmq_poller_*()+ functions.
   module Poller::ZMQ
 
@@ -8,9 +9,9 @@ module CZTop
     POLLERR = 4
 
     extend ::FFI::Library
-    lib_name = 'libzmq'
-    lib_dirs = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
-    lib_dirs = [*ENV['LIBZMQ_PATH'].split(':'), *lib_dirs] if ENV['LIBZMQ_PATH']
+    lib_name  = 'libzmq'
+    lib_dirs  = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
+    lib_dirs  = [*ENV['LIBZMQ_PATH'].split(':'), *lib_dirs] if ENV['LIBZMQ_PATH']
     lib_paths = lib_dirs.map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
     ffi_lib lib_paths + [lib_name]
 
@@ -24,6 +25,7 @@ module CZTop
     #       short events;
     #   } zmq_poller_event_t;
     class PollerEvent < FFI::Struct
+
       layout :socket, :pointer,
              :fd, :int,
              :user_data, :pointer,
@@ -31,21 +33,23 @@ module CZTop
 
       # @return [Boolean] whether the socket is readable
       def readable?
-        (self[:events] & POLLIN) > 0
+        (self[:events] & POLLIN).positive?
       end
 
+
       # @return [Boolean] whether the socket is writable
       def writable?
-        (self[:events] & POLLOUT) > 0
+        (self[:events] & POLLOUT).positive?
       end
+
     end
 
-#ZMQ_EXPORT void *zmq_poller_new (void);
-#ZMQ_EXPORT int  zmq_poller_destroy (void **poller_p);
-#ZMQ_EXPORT int  zmq_poller_add (void *poller, void *socket, void *user_data, short events);
-#ZMQ_EXPORT int  zmq_poller_modify (void *poller, void *socket, short events);
-#ZMQ_EXPORT int  zmq_poller_remove (void *poller, void *socket);
-#ZMQ_EXPORT int  zmq_poller_wait (void *poller, zmq_poller_event_t *event, long timeout);
+    # ZMQ_EXPORT void *zmq_poller_new (void);
+    # ZMQ_EXPORT int  zmq_poller_destroy (void **poller_p);
+    # ZMQ_EXPORT int  zmq_poller_add (void *poller, void *socket, void *user_data, short events);
+    # ZMQ_EXPORT int  zmq_poller_modify (void *poller, void *socket, short events);
+    # ZMQ_EXPORT int  zmq_poller_remove (void *poller, void *socket);
+    # ZMQ_EXPORT int  zmq_poller_wait (void *poller, zmq_poller_event_t *event, long timeout);
 
     # Gracefully attaches a function. If it's not available, this creates
     # a placeholder class method which, when called, simply raises
@@ -53,27 +57,26 @@ module CZTop
     def self.attach_function(function_nickname, function_name, *args)
       super
     rescue ::FFI::NotFoundError
-      if $VERBOSE || $DEBUG
-        warn "CZTop: The ZMQ function #{function_name}() is not available. Don't use CZTop::Poller."
-      end
+      warn "CZTop: The ZMQ function #{function_name}() is not available. Don't use CZTop::Poller." if $VERBOSE || $DEBUG
       define_singleton_method(function_nickname) do |*|
-        raise NotImplementedError, "compile ZMQ with --enable-drafts"
+        raise NotImplementedError, 'compile ZMQ with --enable-drafts'
       end
     end
 
     opts = {
-      blocking: true  # only necessary on MRI to deal with the GIL.
+      blocking: true # only necessary on MRI to deal with the GIL.
     }
     attach_function :poller_new, :zmq_poller_new, [], :pointer, **opts
     attach_function :poller_destroy, :zmq_poller_destroy,
-      [:pointer], :int, **opts
+                    [:pointer], :int, **opts
     attach_function :poller_add, :zmq_poller_add,
-      [:pointer, :pointer, :pointer, :short], :int, **opts
+                    %i[pointer pointer pointer short], :int, **opts
     attach_function :poller_modify, :zmq_poller_modify,
-      [:pointer, :pointer, :short], :int, **opts
+                    %i[pointer pointer short], :int, **opts
     attach_function :poller_remove, :zmq_poller_remove,
-      [:pointer, :pointer], :int, **opts
+                    %i[pointer pointer], :int, **opts
     attach_function :poller_wait, :zmq_poller_wait,
-      [:pointer, :pointer, :long], :int, **opts
+                    %i[pointer pointer long], :int, **opts
+
   end
 end

data/lib/cztop/poller/zpoller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # This is the trivial poller based on zpoller. It only supports polling
   # for readability, but it also supports doing that on CLIENT/SERVER sockets,
@@ -5,6 +7,7 @@ module CZTop
   #
   # @see http://api.zeromq.org/czmq3-0:zpoller
   class Poller::ZPoller
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ::CZMQ::FFI
@@ -14,24 +17,26 @@ module CZTop
     # @param readers [Socket, Actor] any additional sockets to poll for input
     def initialize(reader, *readers)
       @sockets = {} # to keep references and return same instances
-      ptr = Zpoller.new(reader,
-                        *readers.flat_map {|r| [ :pointer, r ] },
-                        :pointer, nil)
+      ptr      = Zpoller.new(reader,
+                             *readers.flat_map { |r| [:pointer, r] },
+                             :pointer, nil)
       attach_ffi_delegate(ptr)
       remember_socket(reader)
       readers.each { |r| remember_socket(r) }
     end
 
+
     # Adds another reader socket to the poller.
     # @param reader [Socket, Actor] socket to poll for input
     # @return [void]
     # @raise [SystemCallError] if this fails
     def add(reader)
       rc = ffi_delegate.add(reader)
-      raise_zmq_err("unable to add socket %p" % reader) if rc == -1
+      raise_zmq_err(format('unable to add socket %p', reader)) if rc == -1
       remember_socket(reader)
     end
 
+
     # Removes a reader socket from the poller.
     # @param reader [Socket, Actor] socket to remove
     # @return [void]
@@ -40,10 +45,11 @@ module CZTop
     # @raise [SystemCallError] if this fails for another reason
     def remove(reader)
       rc = ffi_delegate.remove(reader)
-      raise_zmq_err("unable to remove socket %p" % reader) if rc == -1
+      raise_zmq_err(format('unable to remove socket %p', reader)) if rc == -1
       forget_socket(reader)
     end
 
+
     # Waits and returns the first socket that becomes readable.
     # @param timeout [Integer] how long to wait in ms, or 0 to avoid
     #   blocking, or -1 to wait indefinitely
@@ -54,11 +60,13 @@ module CZTop
       ptr = ffi_delegate.wait(timeout)
       if ptr.null?
         raise Interrupt if ffi_delegate.terminated
+
         return nil
       end
-      return socket_by_ptr(ptr)
+      socket_by_ptr(ptr)
     end
 
+
     # Tells the zpoller to ignore interrupts. By default, {#wait} will return
     # immediately if it detects an interrupt (when +zsys_interrupted+ is set
     # to something other than zero). Calling this method will supress this
@@ -68,6 +76,7 @@ module CZTop
       ffi_delegate.ignore_interrupts
     end
 
+
     # By default the poller stops if the process receives a SIGINT or SIGTERM
     # signal. This makes it impossible to shut-down message based architectures
     # like zactors. This method lets you switch off break handling. The default
@@ -91,6 +100,7 @@ module CZTop
       @sockets[socket.to_ptr.to_i] = socket
     end
 
+
     # Forgets the socket because it has been removed from the poller.
     # @param socket [Socket, Actor] the socket instance to forget
     # @return [void]
@@ -98,6 +108,7 @@ module CZTop
       @sockets.delete(socket.to_ptr.to_i)
     end
 
+
     # Gets the previously remembered socket associated to the given pointer.
     # @param ptr [FFI::Pointer] the pointer to a socket
     # @return [Socket, Actor] the socket associated to the given pointer
@@ -109,5 +120,6 @@ module CZTop
         # it ever returns a wrong pointer.
         raise_zmq_err("no socket known for pointer #{ptr.inspect}")
     end
+
   end
 end

data/lib/cztop/poller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # A non-trivial socket poller.
   #
@@ -9,23 +11,25 @@ module CZTop
   # * +zpoller+ can only poll for readability
   #
   class Poller
+
     include ::CZMQ::FFI
 
     # @param readers [Socket, Actor] sockets to poll for input
     def initialize(*readers)
-      @sockets = {} # needed to return the same socket objects
-      @events = {} # event masks for each socket
+      @sockets    = {} # needed to return the same socket objects
+      @events     = {} # event masks for each socket
       @poller_ptr = ZMQ.poller_new
       ObjectSpace.define_finalizer(@poller_ptr,
-        Proc.new do
-          ptr_ptr = ::FFI::MemoryPointer.new :pointer
-          ptr_ptr.write_pointer(@poller_ptr)
-          ZMQ.poller_destroy(ptr_ptr)
-        end)
+                                   proc do
+                                     ptr_ptr = ::FFI::MemoryPointer.new :pointer
+                                     ptr_ptr.write_pointer(@poller_ptr)
+                                     ZMQ.poller_destroy(ptr_ptr)
+                                   end)
       @event_ptr = FFI::MemoryPointer.new(ZMQ::PollerEvent)
       readers.each { |r| add_reader(r) }
     end
 
+
     # Adds a socket to be polled for readability.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] bitwise-OR'd events you're interested in (see
@@ -34,11 +38,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def add(socket, events)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_add(@poller_ptr, ptr, nil, events)
+      rc  = ZMQ.poller_add(@poller_ptr, ptr, nil, events)
       HasFFIDelegate.raise_zmq_err if rc == -1
       remember_socket(socket, events)
     end
 
+
     # Convenience method to register a socket for readability. See {#add}.
     # @param socket [Socket, Actor] the socket
     # @return [void]
@@ -46,6 +51,7 @@ module CZTop
       add(socket, ZMQ::POLLIN)
     end
 
+
     # Convenience method to register a socket for writability. See {#add}.
     # @param socket [Socket, Actor] the socket
     # @return [void]
@@ -53,6 +59,7 @@ module CZTop
       add(socket, ZMQ::POLLOUT)
     end
 
+
     # Modifies the events of interest for the given socket.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] events you're interested in (see constants in
@@ -61,11 +68,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def modify(socket, events)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_modify(@poller_ptr, ptr, events)
+      rc  = ZMQ.poller_modify(@poller_ptr, ptr, events)
       HasFFIDelegate.raise_zmq_err if rc == -1
       remember_socket(socket, events)
     end
 
+
     # Removes a previously registered socket. Won't raise if you're
     # trying to remove a socket that's not registered.
     # @param socket [Socket, Actor] the socket
@@ -73,11 +81,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def remove(socket)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_remove(@poller_ptr, ptr)
+      rc  = ZMQ.poller_remove(@poller_ptr, ptr)
       HasFFIDelegate.raise_zmq_err if rc == -1
       forget_socket(socket)
     end
 
+
     # Removes a reader socket that was registered for readability only.
     #
     # @param socket [Socket, Actor] the socket
@@ -88,9 +97,10 @@ module CZTop
         remove(socket)
         return
       end
-      raise ArgumentError, "not registered for readability only: %p" % socket
+      raise ArgumentError, format('not registered for readability only: %p', socket)
     end
 
+
     # Removes a reader socket that was registered for writability only.
     #
     # @param socket [Socket, Actor] the socket
@@ -101,9 +111,10 @@ module CZTop
         remove(socket)
         return
       end
-      raise ArgumentError, "not registered for writability only: %p" % socket
+      raise ArgumentError, format('not registered for writability only: %p', socket)
     end
 
+
     # Waits for registered sockets to become readable or writable, depending
     # on what you're interested in.
     #
@@ -116,7 +127,7 @@ module CZTop
       rc = ZMQ.poller_wait(@poller_ptr, @event_ptr, timeout)
       if rc == -1
         case CZMQ::FFI::Errors.errno
-        # NOTE: ETIMEDOUT for backwards compatibility, although this API is
+          # NOTE: ETIMEDOUT for backwards compatibility, although this API is
           # still DRAFT.
         when Errno::EAGAIN::Errno, Errno::ETIMEDOUT::Errno
           return nil
@@ -124,9 +135,10 @@ module CZTop
           HasFFIDelegate.raise_zmq_err
         end
       end
-      return Event.new(self, @event_ptr)
+      Event.new(self, @event_ptr)
     end
 
+
     # Simpler version of {#wait}, which just returns the first socket of
     # interest, if any. This is useful if you either have only reader sockets,
     # or only have writer sockets.
@@ -140,27 +152,30 @@ module CZTop
       return event.socket if event
     end
 
+
     # @param ptr [FFI::Pointer] pointer to the socket
     # @return [Socket, Actor] socket corresponding to given pointer
     # @raise [ArgumentError] if pointer is not known
     def socket_for_ptr(ptr)
       @sockets[ptr.to_i] or
-        raise ArgumentError, "no socket known for pointer %p" % ptr
+        raise ArgumentError, format('no socket known for pointer %p', ptr)
     end
 
+
     # @return [Array<CZTop::Socket>] all sockets registered with this poller
     # @note The actual events registered for each sockets don't matter.
     def sockets
       @sockets.values
     end
 
+
     # Returns the event mask for the given, registered socket.
     # @param socket [Socket, Actor] which socket's events to return
     # @return [Integer] event mask for the given socket
     # @raise [ArgumentError] if socket is not registered
     def event_mask_for_socket(socket)
       @events[socket] or
-        raise ArgumentError, "no event mask known for socket %p" % socket
+        raise ArgumentError, format('no event mask known for socket %p', socket)
     end
 
     private
@@ -170,17 +185,20 @@ module CZTop
     # @raise [ArgumentError] if argument is not a socket
     def ptr_for_socket(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
+
       Zsock.resolve(socket)
     end
 
+
     # Keeps a reference to the given socket, and remembers its event mask.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] the event mask
     def remember_socket(socket, events)
       @sockets[ptr_for_socket(socket).to_i] = socket
-      @events[socket] = events
+      @events[socket]                       = events
     end
 
+
     # Discards the referencel to the given socket, and forgets its event mask.
     # @param socket [Socket, Actor] the socket
     def forget_socket(socket)
@@ -188,33 +206,40 @@ module CZTop
       @events.delete(socket)
     end
 
+
     # Represents an event returned by {CZTop::Poller#wait}. This is useful to
     # find out whether the associated socket is now readable or writable, in
     # case you're interested in both. For a simpler variant, check out
     # {CZTop::Poller#simple_wait}.
     class Event
+
       # @param poller [CZTop::Poller] the poller instance
       # @param event_ptr [FFI::Pointer] pointer to the memory allocated for
       #   the event's data (a +zmq_poller_event_t+)
       def initialize(poller, event_ptr)
-        @poller = poller
+        @poller       = poller
         @poller_event = ZMQ::PollerEvent.new(event_ptr)
       end
 
+
       # @return [Socket, Actor] the associated socket
       def socket
         @socket ||= @poller.socket_for_ptr(@poller_event[:socket])
       end
 
+
       # @return [Boolean] whether it's readable
       def readable?
         @poller_event.readable?
       end
 
+
       # @return [Boolean] whether it's writable
       def writable?
         @poller_event.writable?
       end
+
     end
+
   end
 end

data/lib/cztop/polymorphic_zsock_methods.rb

@@ -1,24 +1,29 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # These are methods that can be used on a {Socket} as well as an {Actor}.
   # @see http://api.zeromq.org/czmq3-0:zsock
   module PolymorphicZsockMethods
+
     # Sends a signal.
     # @param status [Integer] signal (0-255)
     def signal(status = 0)
       ::CZMQ::FFI::Zsock.signal(ffi_delegate, status)
     end
 
+
     # Waits for a signal.
     # @return [Integer] the received signal
     def wait
       ::CZMQ::FFI::Zsock.wait(ffi_delegate)
     end
 
+
     # Set socket to use unbounded pipes (HWM=0); use this in cases when you are
     # totally certain the message volume can fit in memory.
     def set_unbounded
       ::CZMQ::FFI::Zsock.set_unbounded(ffi_delegate)
     end
+
   end
 end