cztop 0.14.1 → 1.1.0.pre1

data/lib/cztop/certificate.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CZTop
   # Represents a CZMQ::FFI::Zcert.
   class Certificate
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ::CZMQ::FFI
@@ -9,9 +12,11 @@ module CZTop
     # @return [void]
     def self.check_curve_availability
       return if Zsys.has_curve
+
       warn "CZTop: CURVE isn't available. Consider installing libsodium."
     end
 
+
     # Loads a certificate from a file.
     # @param filename [String, Pathname, #to_s] path to certificate file
     # @return [Certificate] the loaded certificate
@@ -20,6 +25,7 @@ module CZTop
       from_ffi_delegate(ptr)
     end
 
+
     # Creates a new certificate from the given keys (either binary or in Z85
     # format).
     # @param public_key [String] binary public key (32 or 40 bytes)
@@ -29,25 +35,28 @@ module CZTop
     # @raise [ArgumentError] if keys passed are invalid
     # @raise [SystemCallError] if this fails
     def self.new_from(public_key, secret_key = nil)
-      raise ArgumentError, "no public key given" unless public_key
+      raise ArgumentError, 'no public key given' unless public_key
+
       secret_key ||= "\x00" * 32 # no secret key given, provide 32 null bytes
 
       # convert Z85 => binary
       public_key = Z85.decode(public_key) if public_key.bytesize == 40
       secret_key = Z85.decode(secret_key) if secret_key.bytesize == 40
 
-      raise ArgumentError, "invalid public key size" if public_key.bytesize != 32
-      raise ArgumentError, "invalid secret key size" if secret_key.bytesize != 32
+      raise ArgumentError, 'invalid public key size' if public_key.bytesize != 32
+      raise ArgumentError, 'invalid secret key size' if secret_key.bytesize != 32
 
       ptr = Zcert.new_from(public_key, secret_key)
       from_ffi_delegate(ptr)
     end
 
+
     # Initialize a new in-memory certificate with random keys.
     def initialize
       attach_ffi_delegate(Zcert.new)
     end
 
+
     # Returns the public key either as Z85-encoded ASCII string (default) or
     # binary string.
     # @param format [Symbol] +:z85+ for Z85, +:binary+ for binary
@@ -59,10 +68,11 @@ module CZTop
       when :binary
         ffi_delegate.public_key.read_string(32)
       else
-        raise ArgumentError, "invalid format: %p" % format
+        raise ArgumentError, format('invalid format: %p', format)
       end
     end
 
+
     # Returns the secret key either as Z85-encoded ASCII string (default) or
     # binary string.
     # @param format [Symbol] +:z85+ for Z85, +:binary+ for binary
@@ -73,16 +83,17 @@ module CZTop
       case format
       when :z85
         key = ffi_delegate.secret_txt.force_encoding(Encoding::ASCII)
-        return nil if key.count("0") == 40
+        return nil if key.count('0') == 40
       when :binary
         key = ffi_delegate.secret_key.read_string(32)
         return nil if key.count("\0") == 32
       else
-        raise ArgumentError, "invalid format: %p" % format
+        raise ArgumentError, format('invalid format: %p', format)
       end
       key
     end
 
+
     # Get metadata.
     # @param key [String] metadata key
     # @return [String] value for meta key
@@ -90,32 +101,38 @@ module CZTop
     def [](key)
       ffi_delegate.meta(key)
     end
+
+
     # Set metadata.
     # @param key [String] metadata key
     # @param value [String] metadata value
     # @return [value]
     def []=(key, value)
       if value
-        ffi_delegate.set_meta(key, "%s", :string, value)
+        ffi_delegate.set_meta(key, '%s', :string, value)
       else
         ffi_delegate.unset_meta(key)
       end
     end
 
+
     # Returns meta keys set.
     # @return [Array<String>]
     def meta_keys
-      zlist = ffi_delegate.meta_keys
+      zlist     = ffi_delegate.meta_keys
       first_key = zlist.first
       return [] if first_key.null?
+
       keys = [first_key.read_string]
-      while key = zlist.next
+      while (key = zlist.next)
         break if key.null?
+
         keys << key.read_string
       end
       keys
     end
 
+
     # Save full certificate (public + secret) to files.
     # @param filename [String, #to_s] path/filename to public file
     # @return [void]
@@ -126,55 +143,67 @@ module CZTop
     def save(filename)
       # see https://github.com/zeromq/czmq/issues/1244
       raise ArgumentError, "filename can't be empty" if filename.to_s.empty?
+
       rc = ffi_delegate.save(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to file %p', filename))
     end
 
+
     # Saves the public key to file in ZPL ({Config}) format.
     # @param filename [String, #to_s] path/filename to public file
     # @return [void]
     # @raise [SystemCallError] if this fails
     def save_public(filename)
       rc = ffi_delegate.save_public(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to the file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to the file %p', filename))
     end
 
+
     # Saves the secret key to file in ZPL ({Config}) format.
     # @param filename [String, #to_s] path/filename to secret file
     # @return [void]
     # @raise [SystemCallError] if this fails
     def save_secret(filename)
       rc = ffi_delegate.save_secret(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to the file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to the file %p', filename))
     end
 
+
     # Applies this certificate on a {Socket} or {Actor}.
     # @param zocket [Socket, Actor] path/filename to secret file
     # @return [void]
     # @raise [SystemCallError] if secret key is undefined
     def apply(zocket)
-      raise ArgumentError, "invalid zocket argument %p" % zocket unless zocket
+      raise ArgumentError, format('invalid zocket argument %p', zocket) unless zocket
       return ffi_delegate.apply(zocket) unless secret_key.nil?
-      raise_zmq_err("secret key is undefined")
+
+      raise_zmq_err('secret key is undefined')
     end
 
+
     # Duplicates the certificate.
     # @return [Certificate]
     # @raise [SystemCallError] if this fails
     def dup
       ptr = ffi_delegate.dup
       return from_ffi_delegate(ptr) unless ptr.null?
-      raise_zmq_err("unable to duplicate certificate")
+
+      raise_zmq_err('unable to duplicate certificate')
     end
 
+
     # Compares this certificate to another.
     # @param other [Cert] other certificate
     # @return [Boolean] whether they have the same keys
     def ==(other)
       ffi_delegate.eq(other.ffi_delegate)
     end
+
   end
 end

data/lib/cztop/config/comments.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   class Config
 
@@ -7,11 +9,13 @@ module CZTop
     #   are accessible.
     # @return [CommentsAccessor]
     def comments
-      return CommentsAccessor.new(self)
+      CommentsAccessor.new(self)
     end
 
+
     # Used to access a {Config}'s comments.
     class CommentsAccessor
+
       include Enumerable
 
       # @param config [Config]
@@ -19,26 +23,30 @@ module CZTop
         @config = config
       end
 
+
       # Adds a new comment.
       # @param new_comment [String]
       # @return [self]
       def <<(new_comment)
-        @config.ffi_delegate.set_comment("%s", :string, new_comment)
-        return self
+        @config.ffi_delegate.set_comment('%s', :string, new_comment)
+        self
       end
 
+
       # Deletes all comments for this {Config} item.
       # @return [void]
       def delete_all
         @config.ffi_delegate.set_comment(nil)
       end
 
+
       # Yields all comments for this {Config} item.
       # @yieldparam comment [String]
       # @return [void]
       def each
         while comment = _zlist.next
           break if comment.null?
+
           yield comment.read_string
         end
       rescue CZMQ::FFI::Zlist::DestroyedError
@@ -46,6 +54,7 @@ module CZTop
         nil
       end
 
+
       # Returns the number of comments for this {Config} item.
       # @return [Integer] number of comments
       def size
@@ -61,6 +70,8 @@ module CZTop
       def _zlist
         @config.ffi_delegate.comments
       end
+
     end
+
   end
 end

data/lib/cztop/config/serialization.rb

@@ -1,19 +1,25 @@
+# frozen_string_literal: true
+
 # Methods used around serialization of {CZTop::Config} items.
 module CZTop::Config::Serialization
+
   # Serialize to a string in the ZPL format.
   # @return [String]
   def to_s
     ffi_delegate.str_save.read_string
   end
 
+
   # Returns the path/filename of the file this {Config} tree was loaded from.
   # @return [String]
   def filename
     ffi_delegate.filename
   end
 
+
   # Some class methods for {Config} related to serialization.
   module ClassMethods
+
     # Loads a {Config} tree from a string.
     # @param string [String] the tree
     # @return [Config]
@@ -21,6 +27,7 @@ module CZTop::Config::Serialization
       from_ffi_delegate CZMQ::FFI::Zconfig.str_load(string)
     end
 
+
     # Loads a {Config} tree from a file.
     # @param path [String, Pathname, #to_s] the path to the ZPL config file
     # @raise [SystemCallError] if this fails
@@ -28,10 +35,13 @@ module CZTop::Config::Serialization
     def load(path)
       ptr = CZMQ::FFI::Zconfig.load(path.to_s)
       return from_ffi_delegate(ptr) unless ptr.null?
+
       CZTop::HasFFIDelegate.raise_zmq_err(
-        "error while reading the file %p" % path.to_s)
+        format('error while reading the file %p', path.to_s)
+      )
     end
 
+
     # Loads a {Config} tree from a marshalled string.
     # @note This method is automatically used by Marshal.load.
     # @param string [String] marshalled {Config}
@@ -39,18 +49,22 @@ module CZTop::Config::Serialization
     def _load(string)
       from_string(string)
     end
+
   end
 
+
   # Saves the Config tree to a file.
   # @param path [String, Pathname, #to_s] the path to the ZPL config file
   # @return [void]
   # @raise [SystemCallError] if this fails
   def save(path)
     rc = ffi_delegate.save(path.to_s)
-    return if rc == 0
-    raise_zmq_err("error while saving to the file %s" % path)
+    return if rc.zero?
+
+    raise_zmq_err(format('error while saving to the file %s', path))
   end
 
+
   # Reload config tree from same file that it was previously loaded from.
   # @raise [TypeError] if this is an in-memory config
   # @raise [SystemCallError] if this fails (no existing data will be
@@ -62,11 +76,13 @@ module CZTop::Config::Serialization
     # swap out the FFI delegate.
     filename = filename() or
       raise TypeError, "can't reload in-memory config"
-    ptr = CZMQ::FFI::Zconfig.load(filename)
+    ptr      = CZMQ::FFI::Zconfig.load(filename)
     return attach_ffi_delegate(ptr) unless ptr.null?
-    raise_zmq_err("error while reloading from the file %p" % filename)
+
+    raise_zmq_err(format('error while reloading from the file %p', filename))
   end
 
+
   # Serialize (marshal) this Config and all its children.
   #
   # @note This method is automatically used by Marshal.dump.
@@ -74,9 +90,13 @@ module CZTop::Config::Serialization
   def _dump(_level)
     to_s
   end
+
 end
 
+
 class CZTop::Config
+
   include Serialization
   extend Serialization::ClassMethods
+
 end

data/lib/cztop/config/traversing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Methods used to traverse a {CZTop::Config} tree.
 module CZTop::Config::Traversing
 
@@ -12,24 +14,25 @@ module CZTop::Config::Traversing
   # @raise [Exception] the block's exception, in case it raises (it won't
   #   call the block any more after that)
   def execute
-    raise ArgumentError, "no block given" unless block_given?
-    exception = nil
-    block_value = nil
-    ret = nil
-    callback = CZMQ::FFI::Zconfig.fct do |zconfig, _arg, level|
+    raise ArgumentError, 'no block given' unless block_given?
+
+    exception                           = nil
+    block_value                         = nil
+    ret                                 = nil
+    callback                            = CZMQ::FFI::Zconfig.fct do |zconfig, _arg, level|
       begin
         # NOTE: work around JRuby and Rubinius bug, where it'd keep calling
         # this FFI::Function, even when the block `break`ed
         if ret != -1
-          config = from_ffi_delegate(zconfig)
+          config      = from_ffi_delegate(zconfig)
           block_value = yield config, level
-          ret = 0 # report success to keep zconfig_execute() going
+          ret         = 0 # report success to keep zconfig_execute() going
         end
-      rescue
+      rescue StandardError
         # remember exception, so we can raise it later to the ruby code
         # (it can't be raised now, as we have to report failure to
         # zconfig_execute())
-        exception = $!
+        exception = $ERROR_INFO
 
         ret = -1 # report failure to stop zconfig_execute() immediately
       ensure
@@ -39,15 +42,18 @@ module CZTop::Config::Traversing
     end
     ffi_delegate.execute(callback, _arg = nil)
     raise exception if exception
-    return block_value
+
+    block_value
   end
 
+
   # Access to this config item's direct children.
   # @return [ChildrenAccessor]
   def children
     ChildrenAccessor.new(self)
   end
 
+
   # Access to this config item's siblings.
   # @note Only the "younger" (later in the ZPL file) config items are
   #   considered.
@@ -56,9 +62,11 @@ module CZTop::Config::Traversing
     SiblingsAccessor.new(self)
   end
 
+
   # Used to give access to a {Config} item's children or siblings.
   # @abstract
   class FamilyAccessor
+
     include Enumerable
 
     # @param config [Config] the relative starting point (either parent or
@@ -67,25 +75,30 @@ module CZTop::Config::Traversing
       @config = config
     end
 
+
     # This is supposed to return the first relevant config item.
     # @abstract
     # @return [Config, nil]
     def first; end
 
+
     # Yields all direct children/younger siblings. Starts with {#first}, if
     # set.
     # @yieldparam config [Config]
     def each
-      current = first()
+      current = first
       return if current.nil?
+
       yield current
-      current_delegate = current.ffi_delegate
+      current_delegate       = current.ffi_delegate
       while current_delegate = current_delegate.next
         break if current_delegate.null?
+
         yield CZTop::Config.from_ffi_delegate(current_delegate)
       end
     end
 
+
     # Recursively compares these config items with the ones of the other.
     # @param other [FamilyAccessor]
     def ==(other)
@@ -94,30 +107,39 @@ module CZTop::Config::Traversing
       these.size == those.size && these.zip(those) do |this, that|
         this.tree_equal?(that) or return false
       end
-      return true
+      true
     end
+
   end
 
+
   # Accesses the younger siblings of a given {Config} item.
   class SiblingsAccessor < FamilyAccessor
+
     # Returns the first sibling.
     # @return [Config]
     # @return [nil] if no younger siblings
     def first
       ptr = @config.ffi_delegate.next
       return nil if ptr.null?
+
       CZTop::Config.from_ffi_delegate(ptr)
     end
+
   end
 
+
   # Accesses the direct children of a given {Config} item.
   class ChildrenAccessor < FamilyAccessor
+
     def first
       ptr = @config.ffi_delegate.child
       return nil if ptr.null?
+
       CZTop::Config.from_ffi_delegate(ptr)
     end
 
+
     # Adds a new Config item and yields it, so it can be configured in
     # a block.
     # @param name [String] name for new config item
@@ -129,8 +151,10 @@ module CZTop::Config::Traversing
       yield config if block_given?
       config
     end
+
   end
 
+
   # Finds a config item along a path, relative to the current item.
   # @param path [String] path (leading slash is optional and will be
   #   ignored)
@@ -139,19 +163,26 @@ module CZTop::Config::Traversing
   def locate(path)
     ptr = ffi_delegate.locate(path)
     return nil if ptr.null?
+
     from_ffi_delegate(ptr)
   end
 
+
   # Finds last item at given level (0 = root).
   # @return [Config] the last config item at given level
   # @return [nil] if there's no config item at given level
   def last_at_depth(level)
     ptr = ffi_delegate.at_depth(level)
     return nil if ptr.null?
+
     from_ffi_delegate(ptr)
   end
+
 end
 
+
 class CZTop::Config
+
   include Traversing
+
 end

data/lib/cztop/config.rb

@@ -1,11 +1,14 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # Represents a CZMQ::FFI::Zconfig item.
   # @see http://rfc.zeromq.org/spec:4/ZPL
   class Config
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
 
+
     # Initializes a new {Config} item. Takes an optional block to initialize
     # the item further.
     # @param name [String] config item name
@@ -17,7 +20,7 @@ module CZTop
     #   {Config} object is garbage collected).
     def initialize(name = nil, value = nil, parent: nil)
       if parent
-        parent = parent.ffi_delegate if parent.is_a?(Config)
+        parent   = parent.ffi_delegate if parent.is_a?(Config)
         delegate = ::CZMQ::FFI::Zconfig.new(name, parent)
         attach_ffi_delegate(delegate)
 
@@ -42,9 +45,11 @@ module CZTop
     def name
       ptr = ffi_delegate.name
       return nil if ptr.null? # NOTE: for unnamed elements
+
       ptr.read_string
     end
 
+
     # Sets a new name.
     # @param new_name [String, #to_s]
     # @return [new_name]
@@ -52,28 +57,33 @@ module CZTop
       ffi_delegate.set_name(new_name.to_s)
     end
 
+
     # Get the value of the config item.
     # @return [String]
     # @note This returns an empty string if the value is unset.
     def value
       ptr = ffi_delegate.value
-      return "" if ptr.null? # NOTE: for root elements
+      return '' if ptr.null? # NOTE: for root elements
+
       ptr.read_string
     end
 
+
     # Set or update the value of the config item.
     # @param new_value [String, #to_s]
     # @return [new_value]
     def value=(new_value)
-      ffi_delegate.set_value("%s", :string, new_value.to_s)
+      ffi_delegate.set_value('%s', :string, new_value.to_s)
     end
 
+
     # Inspects this {Config} item.
     # @return [String] shows class, name, and value
     def inspect
       "#<#{self.class.name}: name=#{name.inspect} value=#{value.inspect}>"
     end
 
+
     # Update the value of a config item by path.
     # @param path [String, #to_s] path to config item
     # @param value [String, #to_s] path to config item
@@ -81,7 +91,7 @@ module CZTop
     def []=(path, value)
       ffi_delegate.put(path.to_s, value.to_s)
     end
-    alias_method :put, :[]=
+    alias put []=
 
     # Get the value of the current config item.
     # @param path [String, #to_s] path to config item
@@ -92,30 +102,34 @@ module CZTop
     # @note The default value is not returned when the config item exists but
     #   just doesn't have a value. In that case, it'll return the empty
     #   string.
-    def [](path, default = "")
+    def [](path, default = '')
       ptr = ffi_delegate.get(path, default)
       return nil if ptr.null?
+
       ptr.read_string
     end
-    alias_method :get, :[]
+    alias get []
 
     # @!endgroup
 
+
     # Compares this config item to another. Only the name and value are
     # considered. If you need to compare a config tree, use {#tree_equal?}.
     # @param other [Config] the other config item
     # @return [Boolean] whether they're equal
     def ==(other)
       name == other.name &&
-      value == other.value
+        value == other.value
     end
 
+
     # Compares this config tree to another tree or subtree. Names, values, and
     # children are considered.
     # @param other [Config] the other config tree
     # @return [Boolean] whether they're equal
     def tree_equal?(other)
-      self == other && self.children == other.children
+      self == other && children == other.children
     end
+
   end
 end