omq 0.19.2 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19b283aa20e543617cd7be9c899d2954c219631fd57417536be4fb26798e6e85
-  data.tar.gz: a39d1c870e6171726a00a5f1809556e3ce7c3a8c0e4b0e84722eae15f83f93b6
+  metadata.gz: 77ae2b0a529e29f7c7c48478db4b9b0d81955b28dca48cd17c4f5dfb1dbfd118
+  data.tar.gz: 2ec4f56b9893527d6458e366835878902d3ec254893de2fa0e7579d52be73438
 SHA512:
-  metadata.gz: 7a020d02b2a1da25dd37f6ff92836348985fb7bcd7b8c17392bacb4c23d0ee443b2dd294f8e30d5df5724e11049462d428efb6d2b5a3313b479ab7a3e7e71388
-  data.tar.gz: 3b9724342594f22aabe00d1b13d7aa71bfe652ca21954c6b4789556e95743fd03d1c62214a164be8cad717405766a5d0acdbb4c3fd73a0f95aa14738cfb17d81
+  metadata.gz: af73f9a2031c776167a616fe2e63775cd036c6f02f24cdb65059a4ffb81572e2747a9a4f662b96bd7574ecac3d48114f7ea3569bfbc1f6f3bc0f571a523df1ca
+  data.tar.gz: e919e6bce582848096c692a76e63081b038fb77a9796e914f2265c1825d36017278d46b014b639bbc100935be3ae82af1ac1bfde29951e49e2643ac942d6c251

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.19.3 — 2026-04-13
+
+### Changed
+
+- Engine no longer reaches into `routing.recv_queue` directly.
+  Routing strategies now expose `#dequeue_recv` and `#unblock_recv`
+  as the engine-facing recv contract. `FairRecv` provides the
+  shared implementation for fair-queued sockets; sub/xsub/xpub
+  delegate inline; write-only push/pub raise on dequeue and no-op
+  on unblock. Sharpens the routing interface and keeps Engine out
+  of queue internals.
+- `Writable#freeze_message` collapsed: single `all?` predicate
+  check drives three outcomes (already-frozen-array fast path,
+  freeze-in-place, convert-via-map/map!) instead of mirrored
+  fast/slow branches that each repeated the predicate.
+- Hot-path optimized. Avoid the overhead of `parts.sum(&:bytesize)`
+  and use `parts.sum { |p| p.bytesize }` instead.
+
 ## 0.19.2 — 2026-04-13
 
 ### Added

data/lib/omq/engine/recv_pump.rb

@@ -91,18 +91,22 @@ module OMQ
           loop do
             count = 0
             bytes = 0
+
             while count < FAIRNESS_MESSAGES && bytes < FAIRNESS_BYTES
               msg = conn.receive_message
               msg = transform.call(msg).freeze
+
               # Emit the verbose trace BEFORE enqueueing so the monitor
               # fiber is woken before the application fiber -- the
               # async scheduler is FIFO on the ready list, so this
               # preserves log-before-stdout ordering for -vvv traces.
               engine.emit_verbose_msg_received(conn, msg)
               recv_queue.enqueue(msg)
+
               count += 1
-              bytes += msg.sum(&:bytesize) if count_bytes
+              bytes += msg.sum { |part| part.bytesize } if count_bytes
             end
+
             task.yield
           end
         rescue Async::Stop, Async::Cancel
@@ -133,7 +137,7 @@ module OMQ
               engine.emit_verbose_msg_received(conn, msg)
               recv_queue.enqueue(msg)
               count += 1
-              bytes += msg.sum(&:bytesize) if count_bytes
+              bytes += msg.sum { |part| part.bytesize } if count_bytes
             end
             task.yield
           end

data/lib/omq/engine.rb

@@ -80,6 +80,7 @@ module OMQ
     #
     attr_reader :connections, :tasks, :lifecycle
 
+
     # @!attribute [w] monitor_queue
     #   @param value [Async::Queue, nil] queue for monitor events
     #
@@ -116,7 +117,9 @@ module OMQ
     def spawn_inproc_retry(endpoint)
       ri  = @options.reconnect_interval
       ivl = ri.is_a?(Range) ? ri.begin : ri
-      @tasks << @lifecycle.barrier.async(transient: true, annotation: "inproc reconnect #{endpoint}") do
+      ann = "inproc reconnect #{endpoint}"
+
+      @tasks << @lifecycle.barrier.async(transient: true, annotation: ann) do
         yield ivl
       rescue Async::Stop, Async::Cancel
       end
@@ -134,7 +137,9 @@ module OMQ
       capture_parent_task(parent: parent)
       transport = transport_for(endpoint)
       listener  = transport.bind(endpoint, self)
+
       start_accept_loops(listener)
+
       @listeners << listener
       @last_endpoint = listener.endpoint
       @last_tcp_port = listener.respond_to?(:port) ? listener.port : nil
@@ -155,6 +160,7 @@ module OMQ
       capture_parent_task(parent: parent)
       validate_endpoint!(endpoint)
       @dialed.add(endpoint)
+
       if endpoint.start_with?("inproc://")
         # Inproc connect is synchronous and instant
         transport = transport_for(endpoint)
@@ -188,6 +194,7 @@ module OMQ
     def unbind(endpoint)
       listener = @listeners.find { |l| l.endpoint == endpoint }
       return unless listener
+
       listener.stop
       @listeners.delete(listener)
       close_connections_at(endpoint)
@@ -235,8 +242,10 @@ module OMQ
     #
     def dequeue_recv
       raise @fatal_error if @fatal_error
-      msg = routing.recv_queue.dequeue
+
+      msg = routing.dequeue_recv
       raise @fatal_error if msg.nil? && @fatal_error
+
       msg
     end
 
@@ -245,7 +254,7 @@ module OMQ
     # pending {#dequeue_recv} with a nil return value.
     #
     def dequeue_recv_sentinel
-      routing.recv_queue.push(nil)
+      routing.unblock_recv
     end
 
 
@@ -274,6 +283,7 @@ module OMQ
       # pumps when the connection is lost.
       parent = @connections[conn]&.barrier || @lifecycle.barrier
       task   = RecvPump.start(parent, conn, recv_queue, self, transform)
+
       @tasks << task if task
       task
     end
@@ -316,11 +326,20 @@ module OMQ
     #
     def close
       return unless @lifecycle.open?
+
       @lifecycle.start_closing!
       stop_listeners unless @connections.empty?
-      drain_send_queues(@options.linger) if @options.linger.nil? || @options.linger > 0
+
+      if @options.linger.nil? || @options.linger > 0
+        drain_send_queues(@options.linger)
+      end
+
       @lifecycle.finish_closing!
-      Reactor.untrack_linger(@options.linger) if @lifecycle.on_io_thread
+
+      if @lifecycle.on_io_thread
+        Reactor.untrack_linger(@options.linger)
+      end
+
       stop_listeners
       tear_down_barrier
       routing.stop rescue nil
@@ -337,9 +356,14 @@ module OMQ
     #
     def stop
       return unless @lifecycle.alive?
+
       @lifecycle.start_closing! if @lifecycle.open?
       @lifecycle.finish_closing!
-      Reactor.untrack_linger(@options.linger) if @lifecycle.on_io_thread
+
+      if @lifecycle.on_io_thread
+        Reactor.untrack_linger(@options.linger)
+      end
+
       stop_listeners
       tear_down_barrier
       routing.stop rescue nil
@@ -407,8 +431,9 @@ module OMQ
     #
     def signal_fatal_error(error)
       return unless @lifecycle.open?
+
       @fatal_error = build_fatal_error(error)
-      routing.recv_queue.push(nil) rescue nil
+      routing.unblock_recv rescue nil
       @lifecycle.peer_connected.resolve(nil) rescue nil
     end
 
@@ -442,7 +467,10 @@ module OMQ
     # @param parent [#async, nil] optional Async parent
     #
     def capture_parent_task(parent: nil)
-      return unless @lifecycle.capture_parent_task(parent: parent, linger: @options.linger)
+      task = @lifecycle.capture_parent_task(parent: parent, linger: @options.linger)
+
+      return unless task
+
       Maintenance.start(@lifecycle.barrier, @options.mechanism, @tasks)
     end
 
@@ -491,8 +519,13 @@ module OMQ
     # +last_wire_size_in+.
     def emit_verbose_msg_received(conn, parts)
       return unless @verbose_monitor
+
       detail = { parts: parts }
-      detail[:wire_size] = conn.last_wire_size_in if conn.respond_to?(:last_wire_size_in)
+
+      if conn.respond_to?(:last_wire_size_in)
+        detail[:wire_size] = conn.last_wire_size_in
+      end
+
       emit_monitor_event(:message_received, detail: detail)
     end
 
@@ -504,9 +537,14 @@ module OMQ
     # @raise [ArgumentError] if the scheme is not registered
     #
     def transport_for(endpoint)
-      scheme = endpoint[/\A([^:]+):\/\//, 1]
-      self.class.transports[scheme] or
+      scheme    = endpoint[/\A([^:]+):\/\//, 1]
+      transport = self.class.transports[scheme]
+
+      unless transport
         raise ArgumentError, "unsupported transport: #{endpoint}"
+      end
+
+      transport
     end
 
 
@@ -528,6 +566,7 @@ module OMQ
       ensure
         lifecycle&.close!
       end
+
       @tasks << task if task
     end
 
@@ -539,7 +578,11 @@ module OMQ
     # every routing strategy, so it is flagged rather than fixed here.
     def drain_send_queues(timeout)
       return unless @routing.respond_to?(:send_queues_drained?)
-      deadline = timeout ? Async::Clock.now + timeout : nil
+
+      if timeout
+        deadline = Async::Clock.now + timeout
+      end
+
       until @routing.send_queues_drained?
         break if deadline && (deadline - Async::Clock.now) <= 0
         sleep 0.001
@@ -554,12 +597,16 @@ module OMQ
 
     def validate_endpoint!(endpoint)
       transport = transport_for(endpoint)
-      transport.validate_endpoint!(endpoint) if transport.respond_to?(:validate_endpoint!)
+
+      if transport.respond_to?(:validate_endpoint!)
+        transport.validate_endpoint!(endpoint)
+      end
     end
 
 
     def start_accept_loops(listener)
       return unless listener.respond_to?(:start_accept_loops)
+
       listener.start_accept_loops(@lifecycle.barrier) do |io|
         handle_accepted(io, endpoint: listener.endpoint)
       end

data/lib/omq/routing/conn_send_pump.rb

@@ -37,6 +37,7 @@ module OMQ
         tasks << task
         task
       end
+
     end
   end
 end

data/lib/omq/routing/dealer.rb

@@ -11,6 +11,11 @@ module OMQ
       include FairRecv
 
 
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -21,11 +26,6 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
-      #
-      attr_reader :recv_queue
-
-
       # @param connection [Connection]
       #
       def connection_added(connection)
@@ -58,6 +58,7 @@ module OMQ
         @tasks.each(&:stop)
         @tasks.clear
       end
+
     end
   end
 end

data/lib/omq/routing/fair_queue.rb

@@ -74,7 +74,9 @@ module OMQ
         return try_dequeue if timeout == 0
 
         loop do
-          return nil if @closed && @drain.empty? && @queues.all?(&:empty?)
+          if @closed && @drain.empty? && @queues.all? { |q| q.empty? }
+            return nil
+          end
 
           msg = try_dequeue
           return msg if msg
@@ -101,7 +103,7 @@ module OMQ
       # @return [Boolean]
       #
       def empty?
-        @drain.empty? && @queues.all?(&:empty?)
+        @drain.empty? && @queues.all? { |q| q.empty? }
       end
 
 
@@ -132,6 +134,7 @@ module OMQ
           msg = q.dequeue(timeout: 0)
           return msg if msg
         end
+
         nil
       end
     end

data/lib/omq/routing/fair_recv.rb

@@ -7,6 +7,26 @@ module OMQ
     # Including classes must have @engine, @recv_queue (FairQueue), and @tasks.
     #
     module FairRecv
+      # Dequeues the next received message. Blocks until one is available.
+      # Engine-facing contract — Engine must not touch @recv_queue directly.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      # Wakes a blocked {#dequeue_recv} with a nil sentinel. Called by
+      # Engine on close (close_read) or fatal-error propagation.
+      #
+      # @return [void]
+      #
+      def unblock_recv
+        @recv_queue.push(nil)
+      end
+
+
       private
 
       # Creates a per-connection recv queue, registers it with @recv_queue,
@@ -18,10 +38,16 @@ module OMQ
       def add_fair_recv_connection(conn, &transform)
         conn_q    = Routing.build_queue(@engine.options.recv_hwm, :block)
         signaling = SignalingQueue.new(conn_q, @recv_queue)
+
         @recv_queue.add_queue(conn, conn_q)
-        task      = @engine.start_recv_pump(conn, signaling, &transform)
-        @tasks << task if task
+
+        task = @engine.start_recv_pump(conn, signaling, &transform)
+
+        if task
+          @tasks << task
+        end
       end
+
     end
   end
 end

data/lib/omq/routing/fan_out.rb

@@ -134,7 +134,9 @@ module OMQ
           loop do
             frame = conn.read_frame
             next unless frame.command?
+
             cmd = Protocol::ZMTP::Codec::Command.from_body(frame.body)
+
             case cmd.name
             when "SUBSCRIBE"
               on_subscribe(conn, cmd.data)
@@ -157,7 +159,13 @@ module OMQ
       #
       def start_conn_send_pump(conn, q)
         use_wire = conn.respond_to?(:write_wire) && !conn.encrypted?
-        task     = @conflate ? start_conn_send_pump_conflate(conn, q) : start_conn_send_pump_normal(conn, q, use_wire)
+
+        if @conflate
+          task = start_conn_send_pump_conflate(conn, q)
+        else
+          task = start_conn_send_pump_normal(conn, q, use_wire)
+        end
+
         @conn_send_tasks[conn] = task
         @tasks << task
       end
@@ -177,6 +185,7 @@ module OMQ
           loop do
             batch = [q.dequeue]
             Routing.drain_send_queue(q, batch)
+
             if write_matching_batch(conn, batch, use_wire)
               conn.flush
               batch.each { |parts| @engine.emit_verbose_msg_sent(conn, parts) }
@@ -193,15 +202,19 @@ module OMQ
       #
       def write_matching_batch(conn, batch, use_wire)
         sent = false
+
         batch.each do |parts|
           next unless subscribed?(conn, parts.first || EMPTY_BINARY)
+
           if use_wire
             conn.write_wire(Protocol::ZMTP::Codec::Frame.encode_message(parts))
           else
             conn.write_message(parts)
           end
+
           sent = true
         end
+
         sent
       end
 

data/lib/omq/routing/pair.rb

@@ -12,6 +12,12 @@ module OMQ
     class Pair
       include FairRecv
 
+
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -24,10 +30,6 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
-      #
-      attr_reader :recv_queue
-
       # @param connection [Connection]
       # @raise [RuntimeError] if a connection already exists
       #
@@ -83,24 +85,32 @@ module OMQ
         @send_queue.empty?
       end
 
+
       private
 
+
       def start_send_pump(conn)
         @send_pump = @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
           loop do
             batch = [@send_queue.dequeue]
             Routing.drain_send_queue(@send_queue, batch)
+
             if batch.size == 1
               conn.write_message(batch[0])
             else
               conn.write_messages(batch)
             end
+
             conn.flush
-            batch.each { |parts| @engine.emit_verbose_msg_sent(conn, parts) }
+            batch.each do |parts|
+              @engine.emit_verbose_msg_sent(conn, parts)
+            end
           end
         end
+
         @tasks << @send_pump
       end
+
     end
   end
 end

data/lib/omq/routing/pub.rb

@@ -20,13 +20,23 @@ module OMQ
       end
 
 
-      # PUB is write-only.
+      # PUB is write-only. Engine-facing recv contract: dequeue raises,
+      # unblock is a no-op (fatal-error propagation still calls it).
       #
       def recv_queue
         raise "PUB sockets cannot receive"
       end
 
 
+      def dequeue_recv
+        raise "PUB sockets cannot receive"
+      end
+
+
+      def unblock_recv
+      end
+
+
       # @param connection [Connection]
       #
       def connection_added(connection)
@@ -61,6 +71,7 @@ module OMQ
         @tasks.each(&:stop)
         @tasks.clear
       end
+
     end
   end
 end

data/lib/omq/routing/pull.rb

@@ -6,6 +6,8 @@ module OMQ
     #
     class Pull
       include FairRecv
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -19,6 +21,7 @@ module OMQ
       #
       attr_reader :recv_queue
 
+
       # @param connection [Connection]
       #
       def connection_added(connection)
@@ -49,6 +52,7 @@ module OMQ
         @tasks.each(&:stop)
         @tasks.clear
       end
+
     end
   end
 end

data/lib/omq/routing/push.rb

@@ -7,6 +7,7 @@ module OMQ
     class Push
       include RoundRobin
 
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -16,13 +17,23 @@ module OMQ
       end
 
 
-      # PUSH is write-only.
+      # PUSH is write-only. Engine-facing recv contract: dequeue raises,
+      # unblock is a no-op (fatal-error propagation still calls it).
       #
       def recv_queue
         raise "PUSH sockets cannot receive"
       end
 
 
+      def dequeue_recv
+        raise "PUSH sockets cannot receive"
+      end
+
+
+      def unblock_recv
+      end
+
+
       # @param connection [Connection]
       #
       def connection_added(connection)
@@ -53,6 +64,7 @@ module OMQ
         @tasks.clear
       end
 
+
       private
 
 
@@ -66,6 +78,7 @@ module OMQ
           conn.receive_message # blocks until peer disconnects; then exits
         end
       end
+
     end
   end
 end

data/lib/omq/routing/rep.rb

@@ -14,6 +14,11 @@ module OMQ
       EMPTY_FRAME = "".b.freeze
 
 
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -26,17 +31,14 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
-      #
-      attr_reader :recv_queue
-
       # @param connection [Connection]
       #
       def connection_added(connection)
         add_fair_recv_connection(connection) do |msg|
-          delimiter = msg.index(&:empty?) || msg.size
+          delimiter = msg.index { |p| p.empty? } || msg.size
           envelope  = msg[0, delimiter]
           body      = msg[(delimiter + 1)..] || []
+
           @pending_replies << { conn: connection, envelope: envelope }
           body
         end

data/lib/omq/routing/req.rb

@@ -14,6 +14,11 @@ module OMQ
       EMPTY_BINARY = ::Protocol::ZMTP::Codec::EMPTY_BINARY
 
 
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -25,11 +30,6 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
-      #
-      attr_reader :recv_queue
-
-
       # @param connection [Connection]
       #
       def connection_added(connection)

data/lib/omq/routing/round_robin.rb

@@ -19,6 +19,9 @@ module OMQ
     # their #initialize.
     #
     module RoundRobin
+      BATCH_MSG_CAP  = 256
+      BATCH_BYTE_CAP = 512 * 1024
+
       # @return [Boolean] true when the shared send queue is empty
       #   and no pump fiber is mid-write with a dequeued batch.
       #
@@ -26,8 +29,10 @@ module OMQ
         @send_queue.empty? && @in_flight == 0
       end
 
+
       private
 
+
       # Initializes the shared send queue for the including class.
       #
       # @param engine [Engine]
@@ -83,6 +88,7 @@ module OMQ
       #
       def enqueue_round_robin(parts)
         pipe = @direct_pipe
+
         if pipe&.direct_recv_queue
           pipe.send_message(transform_send(parts))
         else
@@ -97,7 +103,9 @@ module OMQ
       # @param parts [Array<String>]
       # @return [Array<String>]
       #
-      def transform_send(parts) = parts
+      def transform_send(parts)
+        parts
+      end
 
 
       # Spawns a send pump for one connection. Drains the shared send
@@ -129,23 +137,26 @@ module OMQ
             batch = [@send_queue.dequeue]
             drain_send_queue_capped(batch)
             @in_flight += batch.size
+
             begin
               write_batch(conn, batch)
             ensure
               @in_flight -= batch.size
             end
-            batch.each { |parts| @engine.emit_verbose_msg_sent(conn, parts) }
+
+            batch.each do |parts|
+              @engine.emit_verbose_msg_sent(conn, parts)
+            end
+
             Async::Task.current.yield
           end
         end
+
         @conn_send_tasks[conn] = task
         @tasks << task
       end
 
 
-      BATCH_MSG_CAP  = 256
-      BATCH_BYTE_CAP = 512 * 1024
-
       def drain_send_queue_capped(batch)
         bytes = batch_bytes(batch[0])
         while batch.size < BATCH_MSG_CAP && bytes < BATCH_BYTE_CAP
@@ -175,6 +186,7 @@ module OMQ
           conn.flush
         end
       end
+
     end
   end
 end

data/lib/omq/routing/router.rb

@@ -12,6 +12,13 @@ module OMQ
     #
     class Router
       include FairRecv
+
+
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -25,10 +32,6 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
-      #
-      attr_reader :recv_queue
-
       # @param connection [Connection]
       #
       def connection_added(connection)

data/lib/omq/routing/sub.rb

@@ -8,6 +8,11 @@ module OMQ
     #
     class Sub
 
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -19,9 +24,17 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
+      # Engine-facing recv contract. Delegates to the FairQueue.
       #
-      attr_reader :recv_queue
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      def unblock_recv
+        @recv_queue.push(nil)
+      end
+
 
       # @param connection [Connection]
       #
@@ -85,6 +98,7 @@ module OMQ
         @tasks.each(&:stop)
         @tasks.clear
       end
+
     end
   end
 end

data/lib/omq/routing/xpub.rb

@@ -14,6 +14,11 @@ module OMQ
     class XPub
       include FanOut
 
+      # @return [Async::LimitedQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -24,9 +29,17 @@ module OMQ
       end
 
 
-      # @return [Async::LimitedQueue]
+      # Engine-facing recv contract. Delegates to the bounded queue.
       #
-      attr_reader :recv_queue
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      def unblock_recv
+        @recv_queue.push(nil)
+      end
+
 
       # @param connection [Connection]
       #
@@ -63,8 +76,10 @@ module OMQ
         @tasks.clear
       end
 
+
       private
 
+
       # Expose subscription to application as data message.
       #
       def on_subscribe(conn, prefix)
@@ -79,6 +94,7 @@ module OMQ
         super
         @recv_queue.enqueue(["\x00#{prefix}".b])
       end
+
     end
   end
 end

data/lib/omq/routing/xsub.rb

@@ -10,6 +10,11 @@ module OMQ
     #
     class XSub
 
+      # @return [FairQueue]
+      #
+      attr_reader :recv_queue
+
+
       # @param engine [Engine]
       #
       def initialize(engine)
@@ -22,9 +27,17 @@ module OMQ
       end
 
 
-      # @return [FairQueue]
+      # Engine-facing recv contract. Delegates to the FairQueue.
       #
-      attr_reader :recv_queue
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      def unblock_recv
+        @recv_queue.push(nil)
+      end
+
 
       # @param connection [Connection]
       #
@@ -58,7 +71,9 @@ module OMQ
       # @param parts [Array<String>]
       #
       def enqueue(parts)
-        @connections.each { |conn| @conn_queues[conn]&.enqueue(parts) }
+        @connections.each do |conn|
+          @conn_queues[conn]&.enqueue(parts)
+        end
       end
 
 
@@ -78,16 +93,21 @@ module OMQ
         @conn_queues.values.all?(&:empty?)
       end
 
+
       private
 
+
       def start_conn_send_pump(conn, q)
         task = @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
           loop do
             parts = q.dequeue
             frame = parts.first&.b
+
             next if frame.nil? || frame.empty?
+
             flag   = frame.getbyte(0)
             prefix = frame.byteslice(1..) || "".b
+
             case flag
             when 0x01
               conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
@@ -96,9 +116,11 @@ module OMQ
             end
           end
         end
+
         @conn_send_tasks[conn] = task
         @tasks << task
       end
+
     end
   end
 end

data/lib/omq/routing.rb

@@ -110,5 +110,6 @@ module OMQ
         @registry[socket_type] or raise ArgumentError, "unknown socket type: #{socket_type.inspect}"
       end
     end
+
   end
 end

data/lib/omq/single_frame.rb

@@ -19,5 +19,6 @@ module OMQ
       end
       super
     end
+
   end
 end

data/lib/omq/socket.rb

@@ -6,6 +6,30 @@ module OMQ
   # Socket base class.
   #
   class Socket
+    extend Forwardable
+
+    # Creates a new socket and binds it to the given endpoint.
+    #
+    # @param endpoint [String]
+    # @param opts [Hash] keyword arguments forwarded to {#initialize}
+    # @return [Socket]
+    #
+    def self.bind(endpoint, **opts)
+      new("@#{endpoint}", **opts)
+    end
+
+
+    # Creates a new socket and connects it to the given endpoint.
+    #
+    # @param endpoint [String]
+    # @param opts [Hash] keyword arguments forwarded to {#initialize}
+    # @return [Socket]
+    #
+    def self.connect(endpoint, **opts)
+      new(">#{endpoint}", **opts)
+    end
+
+
     # @return [Options]
     #
     attr_reader :options
@@ -25,8 +49,6 @@ module OMQ
 
     # Delegate socket option accessors to @options.
     #
-    extend Forwardable
-
     def_delegators :@options,
       :send_hwm,              :send_hwm=,
       :recv_hwm,              :recv_hwm=,
@@ -49,28 +71,6 @@ module OMQ
       :mechanism,             :mechanism=
 
 
-    # Creates a new socket and binds it to the given endpoint.
-    #
-    # @param endpoint [String]
-    # @param opts [Hash] keyword arguments forwarded to {#initialize}
-    # @return [Socket]
-    #
-    def self.bind(endpoint, **opts)
-      new("@#{endpoint}", **opts)
-    end
-
-
-    # Creates a new socket and connects it to the given endpoint.
-    #
-    # @param endpoint [String]
-    # @param opts [Hash] keyword arguments forwarded to {#initialize}
-    # @return [Socket]
-    #
-    def self.connect(endpoint, **opts)
-      new(">#{endpoint}", **opts)
-    end
-
-
     # @param endpoints [String, nil] optional endpoint with prefix convention
     #   (+@+ for bind, +>+ for connect, plain uses subclass default)
     # @param linger [Integer] linger period in seconds (default 0)
@@ -141,19 +141,27 @@ module OMQ
 
 
     # @return [Async::Promise] resolves when first peer completes handshake
-    def peer_connected   = @engine.peer_connected
+    def peer_connected
+      @engine.peer_connected
+    end
 
 
     # @return [Async::Promise] resolves when first subscriber joins (PUB/XPUB only)
-    def subscriber_joined = @engine.routing.subscriber_joined
+    def subscriber_joined
+      @engine.routing.subscriber_joined
+    end
 
 
     # @return [Async::Promise] resolves when all peers disconnect (after having had peers)
-    def all_peers_gone   = @engine.all_peers_gone
+    def all_peers_gone
+      @engine.all_peers_gone
+    end
 
 
     # @return [Integer] current number of peer connections
-    def connection_count = @engine.connections.size
+    def connection_count
+      @engine.connections.size
+    end
 
 
     # Signals end-of-stream on the receive side. A subsequent
@@ -270,6 +278,7 @@ module OMQ
     #
     def attach_endpoints(endpoints, default:)
       return unless endpoints
+
       case endpoints
       when /\A@(.+)\z/
         bind($1)
@@ -318,5 +327,6 @@ module OMQ
     def ensure_parent_task(parent: nil)
       @engine.capture_parent_task(parent: parent)
     end
+
   end
 end

data/lib/omq/transport/inproc/direct_pipe.rb

@@ -110,14 +110,18 @@ module OMQ
 
         # @return [Boolean] always false; inproc pipes are never encrypted
         #
-        def encrypted? = false
+        def encrypted?
+          false
+        end
 
 
         # No-op — inproc has no IO buffer to flush.
         #
         # @return [nil]
         #
-        def flush = nil
+        def flush
+          nil
+        end
 
 
         # Receives a multi-frame message.

data/lib/omq/transport/tcp.rb

@@ -210,6 +210,7 @@ module OMQ
           @tasks.each(&:stop)
           @servers.each { |s| s.close rescue nil }
         end
+
       end
     end
   end

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.19.2"
+  VERSION = "0.19.3"
 end

data/lib/omq/writable.rb

@@ -7,6 +7,11 @@ module OMQ
   #
   module Writable
     include QueueWritable
+
+
+    EMPTY_PART = "".b.freeze
+
+
     # Sends a message.
     #
     # @param message [String, Array<String>] message parts
@@ -33,8 +38,20 @@ module OMQ
       send(message)
     end
 
+
+    # Waits until the socket is writable.
+    #
+    # @param timeout [Numeric, nil] timeout in seconds
+    # @return [true]
+    #
+    def wait_writable(timeout = @options.write_timeout)
+      true
+    end
+
+
     private
 
+
     # Converts a message into a frozen array of frozen binary strings.
     #
     # @param message [String, Array<String>]
@@ -44,21 +61,23 @@ module OMQ
       parts = message.is_a?(Array) ? message : [message]
       raise ArgumentError, "message has no parts" if parts.empty?
 
-      # Fast path: skip map when all parts are already frozen binary.
+      all_ready = parts.all? { |p| p.is_a?(String) && p.frozen? && p.encoding == Encoding::BINARY }
+
+      # Already a frozen array of frozen binary strings → return as-is.
+      return parts if all_ready && parts.frozen?
+
+      # Items are ready; just freeze the outer array.
+      return parts.freeze if all_ready
+
+      # Items need conversion. Mutate in place when we can.
       if parts.frozen?
-        return parts if parts.all? { |p| p.is_a?(String) && p.frozen? && p.encoding == Encoding::BINARY }
-        parts = parts.map { |p| frozen_binary(p) }
+        parts.map { |p| frozen_binary(p) }.freeze
       else
-        unless parts.all? { |p| p.is_a?(String) && p.frozen? && p.encoding == Encoding::BINARY }
-          parts.map! { |p| frozen_binary(p) }
-        end
+        parts.map! { |p| frozen_binary(p) }.freeze
       end
-      parts.freeze
     end
 
 
-    EMPTY_PART = "".b.freeze
-
     def frozen_binary(obj)
       return EMPTY_PART if obj.nil?
       s = obj.to_s
@@ -66,15 +85,5 @@ module OMQ
       s.b.freeze
     end
 
-    public
-
-    # Waits until the socket is writable.
-    #
-    # @param timeout [Numeric, nil] timeout in seconds
-    # @return [true]
-    #
-    def wait_writable(timeout = @options.write_timeout)
-      true
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.19.2
+  version: 0.19.3
 platform: ruby
 authors:
 - Patrik Wenger