cztop 1.0.0 → 1.1.0.pre1

data/lib/cztop/message.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CZTop
   # Represents a CZMQ::FFI::Zmsg.
   class Message
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ::CZMQ::FFI
@@ -12,14 +15,15 @@ module CZTop
     def self.coerce(msg)
       case msg
       when Message
-        return msg
+        msg
       when String, Frame, Array
-        return new(msg)
+        new(msg)
       else
-        raise ArgumentError, "cannot coerce message: %p" % msg
+        raise ArgumentError, format('cannot coerce message: %p', msg)
       end
     end
 
+
     # @param parts [String, Frame, Array<String>, Array<Frame>] initial parts
     #   of the message
     def initialize(parts = nil)
@@ -27,11 +31,13 @@ module CZTop
       Array(parts).each { |part| self << part } if parts
     end
 
+
     # @return [Boolean] if this message is empty or not
     def empty?
       content_size.zero?
     end
 
+
     # Send {Message} to a {Socket} or {Actor}.
     #
     # @note Do NOT use this {Message} anymore afterwards. Its native
@@ -56,12 +62,14 @@ module CZTop
     #
     def send_to(destination)
       rc = Zmsg.send(ffi_delegate, destination)
-      return if rc == 0
+      return if rc.zero?
+
       raise_zmq_err
     rescue Errno::EAGAIN
       raise IO::EAGAINWaitWritable
     end
 
+
     # Receive a {Message} from a {Socket} or {Actor}.
     # @param source [Socket, Actor]
     # @return [Message] the newly received message
@@ -73,11 +81,13 @@ module CZTop
     def self.receive_from(source)
       delegate = Zmsg.recv(source)
       return from_ffi_delegate(delegate) unless delegate.null?
+
       HasFFIDelegate.raise_zmq_err
     rescue Errno::EAGAIN
       raise IO::EAGAINWaitReadable
     end
 
+
     # Append a frame to this message.
     # @param frame [String, Frame] what to append
     # @raise [ArgumentError] if frame has an invalid type
@@ -90,16 +100,17 @@ module CZTop
       when String
         # NOTE: can't use addstr because the data might be binary
         mem = FFI::MemoryPointer.from_string(frame)
-        rc = ffi_delegate.addmem(mem, mem.size - 1) # without NULL byte
+        rc  = ffi_delegate.addmem(mem, mem.size - 1) # without NULL byte
       when Frame
         rc = ffi_delegate.append(frame.ffi_delegate)
       else
-        raise ArgumentError, "invalid frame: %p" % frame
+        raise ArgumentError, format('invalid frame: %p', frame)
       end
-      raise_zmq_err unless rc == 0
+      raise_zmq_err unless rc.zero?
       self
     end
 
+
     # Prepend a frame to this message.
     # @param frame [String, Frame] what to prepend
     # @raise [ArgumentError] if frame has an invalid type
@@ -112,30 +123,34 @@ module CZTop
       when String
         # NOTE: can't use pushstr because the data might be binary
         mem = FFI::MemoryPointer.from_string(frame)
-        rc = ffi_delegate.pushmem(mem, mem.size - 1) # without NULL byte
+        rc  = ffi_delegate.pushmem(mem, mem.size - 1) # without NULL byte
       when Frame
         rc = ffi_delegate.prepend(frame.ffi_delegate)
       else
-        raise ArgumentError, "invalid frame: %p" % frame
+        raise ArgumentError, format('invalid frame: %p', frame)
       end
-      raise_zmq_err unless rc == 0
+      raise_zmq_err unless rc.zero?
     end
 
+
     # Removes first part from message and returns it as a string.
     # @return [String, nil] first part, if any, or nil
     def pop
       # NOTE: can't use popstr because the data might be binary
       ptr = ffi_delegate.pop
       return nil if ptr.null?
+
       Frame.from_ffi_delegate(ptr).to_s
     end
 
+
     # @return [Integer] size of this message in bytes
     # @see size
     def content_size
       ffi_delegate.content_size
     end
 
+
     # Returns all frames as strings in an array. This is useful if for quick
     # inspection of the message.
     # @note It'll read all frames in the message and turn them into Ruby
@@ -143,30 +158,27 @@ module CZTop
     # @return [Array<String>] all frames
     def to_a
       ffi_delegate = ffi_delegate()
-      frame = ffi_delegate.first
+      frame        = ffi_delegate.first
       return [] if frame.null?
 
-      arr = [ frame.data.read_bytes(frame.size) ]
-      while frame = ffi_delegate.next and not frame.null?
+      arr          = [frame.data.read_bytes(frame.size)]
+      while (frame = ffi_delegate.next) && !frame.null?
         arr << frame.data.read_bytes(frame.size)
       end
 
-      return arr
+      arr
     end
 
+
     # Inspects this {Message}.
     # @return [String] shows class, number of frames, content size, and
     #   content (only if it's up to 200 bytes)
     def inspect
-      "#<%s:0x%x frames=%i content_size=%i content=%s>" % [
-        self.class,
-        to_ptr.address,
-        size,
-        content_size,
-        content_size <= 500 ? to_a.inspect : "[...]"
-      ]
+      format('#<%s:0x%x frames=%i content_size=%i content=%s>', self.class, to_ptr.address, size, content_size,
+             content_size <= 500 ? to_a.inspect : '[...]')
     end
 
+
     # Return a frame's content.
     # @return [String] the frame's content, if it exists
     # @return [nil] if frame doesn't exist at given index
@@ -193,8 +205,10 @@ module CZTop
 
       # need to raise manually, as FFI lacks this feature.
       # @see https://github.com/ffi/ffi/issues/473
-      raise RangeError if new_routing_id < 0
+      raise RangeError if new_routing_id.negative?
+
       ffi_delegate.set_routing_id(new_routing_id)
     end
+
   end
 end

data/lib/cztop/metadata.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module CZTop
@@ -13,12 +15,15 @@ module CZTop
   #
   # @see https://rfc.zeromq.org/spec:23/ZMTP
   class Metadata
-    VALUE_MAXLEN = 2**31-1
+
+    VALUE_MAXLEN = (2**31) - 1
+
 
     # Raised when decoding malformed metadata.
     class InvalidData < StandardError
     end
 
+
     # regular expression used to validate property names
     NAME_REGEX = /\A[[:alnum:]_.+-]{1,255}\Z/.freeze
 
@@ -29,47 +34,49 @@ module CZTop
     # @return [String]
     def self.dump(metadata)
       ic_names = Set.new
+
       metadata.map do |k, v|
         ic_name = k.to_sym.downcase
-        if ic_names.include?(ic_name)
-          raise ArgumentError, "property #{k.inspect}: duplicate name"
-        else
-          ic_names << ic_name
-        end
+        raise ArgumentError, "property #{k.inspect}: duplicate name" if ic_names.include? ic_name
+
+        ic_names << ic_name
+
         name = k.to_s
-        if NAME_REGEX !~ name
-          raise ArgumentError, "property #{k.inspect}: invalid name"
-        end
+        raise ArgumentError, "property #{k.inspect}: invalid name" if NAME_REGEX !~ name
+
         value = v.to_s
-        if value.bytesize > VALUE_MAXLEN
-          raise ArgumentError, "property #{k.inspect}: value too long"
-        end
-        [name.size, name, value.bytesize, value].pack("CA*NA*")
+        raise ArgumentError, "property #{k.inspect}: value too long" if value.bytesize > VALUE_MAXLEN
+
+        [name.size, name, value.bytesize, value].pack('CA*NA*')
       end.join
     end
 
+
     # @param data [String, Frame, #to_s] the data representing the metadata
     # @return [Hash]
     def self.load(data)
       properties = {}
-      consumed = 0
+      consumed   = 0
+
       while consumed < data.bytesize # while there are bytes to read
         # read property name
-        name_length = data.byteslice(consumed).unpack("C").first # never nil
-        raise InvalidData, "zero-length property name" if name_length.zero?
+        name_length = data.byteslice(consumed).unpack1('C') # never nil
+        raise InvalidData, 'zero-length property name' if name_length.zero?
+
         name = data.byteslice(consumed + 1, name_length)
-        raise InvalidData, "incomplete name" if name.bytesize != name_length
+        raise InvalidData, 'incomplete name' if name.bytesize != name_length
+
         name_sym = name.to_sym.downcase
-        if properties.has_key?(name_sym)
-          raise InvalidData, "property #{name.inspect}: duplicate name"
-        end
+        raise InvalidData, "property #{name.inspect}: duplicate name" if properties.key?(name_sym)
+
         consumed += 1 + name.bytesize
 
         # read property value
-        value_length = data.byteslice(consumed, 4).unpack("N").first or
-          raise InvalidData, "incomplete length"
-        value = data.byteslice(consumed + 4, value_length)
-        raise InvalidData, "incomplete value" if value.bytesize != value_length
+        value_length = data.byteslice(consumed, 4).unpack1('N') or
+          raise InvalidData, 'incomplete length'
+        value        = data.byteslice(consumed + 4, value_length)
+        raise InvalidData, 'incomplete value' if value.bytesize != value_length
+
         consumed += 4 + value.bytesize
 
         # remember
@@ -78,12 +85,14 @@ module CZTop
       new(properties)
     end
 
+
     # @param properties [Hash<Symbol, String>] the properties as loaded by
     #   {load}
     def initialize(properties)
       @properties = properties
     end
 
+
     # Gets the value corresponding to a property name. The case of the name
     # is insignificant.
     # @param name [Symbol, String] the property name
@@ -92,9 +101,11 @@ module CZTop
       @properties[name.to_sym.downcase]
     end
 
+
     # @return [Hash<Symbol, String] all properties
     def to_h
       @properties
     end
+
   end
 end

data/lib/cztop/monitor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # CZMQ monitor. Listen for socket events.
   #
@@ -8,11 +10,12 @@ module CZTop
   # @see http://api.zeromq.org/czmq3-0:zmonitor
   # @see http://api.zeromq.org/4-1:zmq-socket-monitor
   class Monitor
+
     include ::CZMQ::FFI
 
     # function pointer to the +zmonitor()+ function
     ZMONITOR_FPTR = ::CZMQ::FFI.ffi_libraries.each do |dl|
-      fptr = dl.find_function("zmonitor")
+      fptr = dl.find_function('zmonitor')
       break fptr if fptr
     end
     raise LoadError, "couldn't find zmonitor()" if ZMONITOR_FPTR.nil?
@@ -31,10 +34,11 @@ module CZTop
       @actor.terminate
     end
 
+
     # Enable verbose logging of commands and activity.
     # @return [void]
     def verbose!
-      @actor << "VERBOSE"
+      @actor << 'VERBOSE'
     end
 
     # @return [Array<String>] types of valid events
@@ -55,7 +59,7 @@ module CZTop
       HANDSHAKE_FAILED_NO_DETAIL
       HANDSHAKE_FAILED_PROTOCOL
       HANDSHAKE_FAILED_AUTH
-    ]
+    ].freeze
 
     # Configure monitor to listen for specific events.
     # @param events [String] one or more events from {EVENTS}
@@ -65,16 +69,18 @@ module CZTop
         EVENTS.include?(event) or
           raise ArgumentError, "invalid event: #{event.inspect}"
       end
-      @actor << [ "LISTEN", *events ]
+      @actor << ['LISTEN', *events]
     end
 
+
     # Start the monitor. After this, you can read events using {#next}.
     # @return [void]
     def start
-      @actor << "START"
+      @actor << 'START'
       @actor.wait
     end
 
+
     # Useful for registration in an event-loop.
     # @return [Integer] the FD
     # @see ZsockOptions#fd
@@ -82,11 +88,13 @@ module CZTop
       @actor.fd
     end
 
+
     # @return [Boolean] whether there's at least one event available
     def readable?
       @actor.readable?
     end
 
+
     # Get next event. This blocks until the next event is available.
     # @example
     #   socket = CZTop::Socket::ROUTER.new("tcp://127.0.0.1:5050")
@@ -112,5 +120,6 @@ module CZTop
     def next
       @actor.receive
     end
+
   end
 end

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