cztop 1.0.0 → 1.1.0.pre1

data/lib/cztop/socket/types.rb

@@ -1,29 +1,37 @@
+# frozen_string_literal: true
+
 module CZTop
   class Socket
+
     #  Socket types. Each constant in this namespace holds the type code used
     #  for the zsock_new() function.
     module Types
-      PAIR = 0
-      PUB = 1
-      SUB = 2
-      REQ = 3
-      REP = 4
+
+      PAIR   = 0
+      PUB    = 1
+      SUB    = 2
+      REQ    = 3
+      REP    = 4
       DEALER = 5
       ROUTER = 6
-      PULL = 7
-      PUSH = 8
-      XPUB = 9
-      XSUB = 10
+      PULL   = 7
+      PUSH   = 8
+      XPUB   = 9
+      XSUB   = 10
       STREAM = 11
       SERVER = 12
       CLIENT = 13
+
     end
 
+
     # All the available type codes, mapped to their Symbol equivalent.
     # @return [Hash<Integer, Symbol>]
-    TypeNames = Hash[
-      Types.constants.map { |name| i = Types.const_get(name); [ i, name ] }
-    ].freeze
+    TypeNames = Types.constants.to_h do |name|
+      i = Types.const_get(name)
+      [i, name]
+    end.freeze
+
 
     # @param type [Symbol, Integer] type from {Types} or like +:PUB+
     # @return [REQ, REP, PUSH, PULL, ... ] the new socket
@@ -33,75 +41,108 @@ module CZTop
     def self.new_by_type(type)
       case type
       when Integer
-        type_code = type
-        type_name = TypeNames[type_code] or
-          raise ArgumentError, "invalid type %p" % type
+        type_code  = type
+        type_name  = TypeNames[type_code] or
+          raise ArgumentError, format('invalid type %p', type)
         type_class = Socket.const_get(type_name)
       when Symbol
-        type_code = Types.const_get(type)
+        type_code  = Types.const_get(type)
         type_class = Socket.const_get(type)
       else
-        raise ArgumentError, "invalid socket type: %p" % type
+        raise ArgumentError, format('invalid socket type: %p', type)
       end
       ffi_delegate = Zsock.new(type_code)
-      sock = type_class.allocate
+      sock         = type_class.allocate
       sock.attach_ffi_delegate(ffi_delegate)
       sock
     end
 
+
+    def initialize(endpoints = nil); end
+
+
     # Client socket for the ZeroMQ Client-Server Pattern.
     # @see http://rfc.zeromq.org/spec:41
     class CLIENT < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_client(endpoints))
       end
+
     end
 
+
     # Server socket for the ZeroMQ Client-Server Pattern.
     # @see http://rfc.zeromq.org/spec:41
     class SERVER < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_server(endpoints))
       end
+
     end
 
+
     # Request socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class REQ < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_req(endpoints))
       end
+
     end
 
+
     # Reply socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class REP < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_rep(endpoints))
       end
+
     end
 
+
     # Dealer socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class DEALER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_dealer(endpoints))
       end
+
     end
 
+
     # Router socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class ROUTER < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_router(endpoints))
       end
 
+
       # Send a message to a specific receiver. This is a shorthand for when
       # you send a message to a specific receiver with no hops in between.
       # @param receiver [String] receiving peer's socket identity
@@ -110,32 +151,42 @@ module CZTop
       #   destroyed.
       def send_to(receiver, message)
         message = Message.coerce(message)
-        message.prepend ""       # separator frame
+        message.prepend ''       # separator frame
         message.prepend receiver # receiver envelope
         self << message
       end
+
     end
 
+
     # Publish socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class PUB < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pub(endpoints))
       end
+
     end
 
+
     # Subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class SUB < Socket
+
       # @param endpoints [String] endpoints to connect to
       # @param subscription [String] what to subscribe to
       def initialize(endpoints = nil, subscription = nil)
+        super(endpoints)
+
         attach_ffi_delegate(Zsock.new_sub(endpoints, subscription))
       end
 
       # @return [String] subscription prefix to subscribe to everything
-      EVERYTHING = ""
+      EVERYTHING = ''
 
       # Subscribes to the given prefix string.
       # @param prefix [String] prefix string to subscribe to
@@ -144,86 +195,128 @@ module CZTop
         ffi_delegate.set_subscribe(prefix)
       end
 
+
       # Unsubscribes from the given prefix.
       # @param prefix [String] prefix string to unsubscribe from
       # @return [void]
       def unsubscribe(prefix)
         ffi_delegate.set_unsubscribe(prefix)
       end
+
     end
 
+
     # Extended publish socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class XPUB < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_xpub(endpoints))
       end
+
     end
 
+
     # Extended subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class XSUB < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_xsub(endpoints))
       end
+
     end
 
+
     # Push socket for the ZeroMQ Pipeline Pattern.
     # @see http://rfc.zeromq.org/spec:30
     class PUSH < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_push(endpoints))
       end
+
     end
 
+
     # Pull socket for the ZeroMQ Pipeline Pattern.
     # @see http://rfc.zeromq.org/spec:30
     class PULL < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pull(endpoints))
       end
+
     end
 
+
     # Pair socket for inter-thread communication.
     # @see http://rfc.zeromq.org/spec:31
     class PAIR < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pair(endpoints))
       end
+
     end
 
+
     # Stream socket for the native pattern. This is useful when
     # communicating with a non-ZMQ peer over TCP.
     # @see http://api.zeromq.org/4-2:zmq-socket#toc16
     class STREAM < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_stream(endpoints))
       end
+
     end
 
+
     # Group-based pub/sub (vs topic-based). This is the publisher socket.
     # @see https://github.com/zeromq/libzmq/pull/1727
     class RADIO < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_radio(endpoints))
       end
+
     end
 
+
     # Group-based pub/sub (vs topic-based). This is the subscriber socket.
     # @see https://github.com/zeromq/libzmq/pull/1727
     class DISH < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_dish(endpoints))
       end
 
+
       # Joins the given group.
       # @param group [String] group to join, up to 15 characters
       # @return [void]
@@ -232,9 +325,10 @@ module CZTop
       # @raise [SystemCallError] in case of failure
       def join(group)
         rc = ffi_delegate.join(group)
-        raise_zmq_err("unable to join group %p" % group) if rc == -1
+        raise_zmq_err(format('unable to join group %p', group)) if rc == -1
       end
 
+
       # Leaves the given group.
       # @param group [String] group to leave
       # @return [void]
@@ -242,26 +336,38 @@ module CZTop
       # @raise [SystemCallError] in case of another failure
       def leave(group)
         rc = ffi_delegate.leave(group)
-        raise_zmq_err("unable to leave group %p" % group) if rc == -1
+        raise_zmq_err(format('unable to leave group %p', group)) if rc == -1
       end
+
     end
 
+
     # Scatter/gather pattern.
     # @see https://github.com/zeromq/libzmq/pull/1909
     class SCATTER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_scatter(endpoints))
       end
+
     end
 
+
     # Scatter/gather pattern.
     # @see https://github.com/zeromq/libzmq/pull/1909
     class GATHER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_gather(endpoints))
       end
+
     end
+
   end
 end

data/lib/cztop/socket.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CZTop
   # Represents a CZMQ::FFI::Zsock.
   class Socket
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ZsockOptions
@@ -21,6 +24,7 @@ module CZTop
       cert.apply(self) # NOTE: desired: raises if no secret key in cert
     end
 
+
     # Enables CURVE security and makes this socket a CURVE client.
     # @param client_cert [Certificate] client's certificate, to secure
     #   communication (and be authenticated by the server)
@@ -31,9 +35,7 @@ module CZTop
     #   which means it's not secret anymore
     # @raise [SystemCallError] if there's no secret key in client_cert
     def CURVE_client!(client_cert, server_cert)
-      if server_cert.secret_key
-        raise SecurityError, "server's secret key not secret"
-      end
+      raise SecurityError, "server's secret key not secret" if server_cert.secret_key
 
       client_cert.apply(self) # NOTE: desired: raises if no secret key in cert
       options.CURVE_serverkey = server_cert.public_key
@@ -41,30 +43,34 @@ module CZTop
 
     # @!endgroup
 
+
     # @return [String] last bound endpoint, if any
     # @return [nil] if not bound
     def last_endpoint
       ffi_delegate.endpoint
     end
 
+
     # Connects to an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def connect(endpoint)
-      rc = ffi_delegate.connect("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.connect('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Disconnects from an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def disconnect(endpoint)
-      rc = ffi_delegate.disconnect("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.disconnect('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Closes and destroys the native socket.
     # @return [void]
     # @note Don't try to use it anymore afterwards.
@@ -83,30 +89,29 @@ module CZTop
     # @return [void]
     # @raise [SystemCallError] in case of failure
     def bind(endpoint)
-      rc = ffi_delegate.bind("%s", :string, endpoint)
-      raise_zmq_err("unable to bind to %p" % endpoint) if rc == -1
-      @last_tcp_port = rc if rc > 0
+      rc = ffi_delegate.bind('%s', :string, endpoint)
+      raise_zmq_err(format('unable to bind to %p', endpoint)) if rc == -1
+      @last_tcp_port = rc if rc.positive?
     end
 
+
     # Unbinds from an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def unbind(endpoint)
-      rc = ffi_delegate.unbind("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.unbind('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Inspects this {Socket}.
     # @return [String] shows class, native address, and {#last_endpoint}
     def inspect
-      "#<%s:0x%x last_endpoint=%p>" % [
-        self.class,
-        to_ptr.address,
-        last_endpoint
-      ]
+      format('#<%s:0x%x last_endpoint=%p>', self.class, to_ptr.address, last_endpoint)
     rescue Zsock::DestroyedError
-      "#<%s: invalid>" % self.class
+      format('#<%s: invalid>', self.class)
     end
+
   end
 end

data/lib/cztop/version.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
 module CZTop
-  VERSION = "1.0.0"
+
+  VERSION = '1.1.0.pre1'
+
 end

data/lib/cztop/z85/padded.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Z85 with simple padding. This allows you to {#encode} input of any
 # length.
 #
@@ -29,7 +31,9 @@
 #
 # @see https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7
 class CZTop::Z85::Padded < CZTop::Z85
+
   class << self
+
     # Same as {Z85::Padded#encode}, but without the need to create an
     # instance first.
     #
@@ -41,6 +45,7 @@ class CZTop::Z85::Padded < CZTop::Z85
       default.encode(input)
     end
 
+
     # Same as {Z85::Padded#decode}, but without the need to create an
     # instance first.
     #
@@ -59,6 +64,7 @@ class CZTop::Z85::Padded < CZTop::Z85
     def default
       @default ||= CZTop::Z85::Padded.new
     end
+
   end
 
   # Encododes to Z85, with padding if needed.
@@ -72,14 +78,15 @@ class CZTop::Z85::Padded < CZTop::Z85
     padding_bytes = 4 - (input.bytesize % 4)
 
     # if 0, make it 4. we MUST append padding.
-    padding_bytes = 4 if padding_bytes == 0
+    padding_bytes = 4 if padding_bytes.zero?
 
     # generate and append padding
-    padding = [padding_bytes].pack("C") * padding_bytes
+    padding = [padding_bytes].pack('C') * padding_bytes
 
     super("#{input}#{padding}")
   end
 
+
   # Decodes from Z85 with padding.
   #
   # @param input [String] Z85 encoded data (including padding, or empty
@@ -88,11 +95,13 @@ class CZTop::Z85::Padded < CZTop::Z85
   # @raise [SystemCallError] if this fails
   def decode(input)
     return super if input.empty?
+
     decoded = super
 
     # last byte contains number of padding bytes
     padding_bytes = decoded.byteslice(-1).ord
 
-    decoded.byteslice( 0 ... -padding_bytes )
+    decoded.byteslice(0...-padding_bytes)
   end
+
 end