omq 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94402697e206444e39655869c1382cea2a2839732d373d6cbcc237dcb125cd44
-  data.tar.gz: dbcaa10eb1213e935325d0290611716552d28394dd479d8fc79564a0af6f0e4d
+  metadata.gz: d2e17e1a12c0f44bec5af914b8df2f810029e75c7da17e79e862428a7b0aa99d
+  data.tar.gz: 4a8d06116bad67adc4411cb3281302fd6190ecce46ceb47f21cc15a32c3e9006
 SHA512:
-  metadata.gz: 9a4b4eab9767b52f874bf85816589558bf42e9730da827220490e80ca9dd499ae5ae604c06022d3db07402042a1b52ea1c88737e2c1556b4d78af90391dc1d2f
-  data.tar.gz: e2db5e6aaea16af48024be90af8353a81f4d77a4b0b1973131f74dbd915b9aaf52fdd06d08cc57749ffb74b6bd70214ffb2ab04063925887c8a1b72afd4582cb
+  metadata.gz: 1dad86f1ad0648690bc5a01d3b7258b89f301d4768bac0831495d27f0a0e3c84f5a30af049732f8cc6885bcd6105654d41708d519da69c30a62739ca58a27418
+  data.tar.gz: a71f54aa26dd3e7dea3b249d027c03aeff896c7ded7b0581067fbda609d114c976c8d35a5f7f7e630cbbc34fbb839c7d43f6d445e8f2bb50f1348cb46f8d0e51

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.7.0 — 2026-03-30
+
+### Breaking
+
+- **`-e` is now `--recv-eval`** — evaluates incoming messages only.
+  Send-only sockets (PUSH, PUB, SCATTER, RADIO) must use `-E` /
+  `--send-eval` instead of `-e`.
+
+### Added
+
+- **`-E` / `--send-eval`** — eval Ruby for each outgoing message.
+  REQ can now transform requests independently from replies.
+  ROUTER/SERVER/PEER: `-E` does dynamic routing (first element =
+  identity), mutually exclusive with `--target`.
+- **`OMQ.outgoing` / `OMQ.incoming`** — registration API for script
+  handlers loaded via `-r`. Blocks receive message parts as a block
+  argument (`|msg|`). Setup via closures, teardown via `at_exit`.
+  CLI flags override registered handlers.
+- **[CLI.md](CLI.md)** — comprehensive CLI documentation.
+- **[GETTING_STARTED.md](GETTING_STARTED.md)** — renamed from
+  `ZGUIDE_SUMMARY.md` for discoverability.
+- **Multi-peer pipe with `--in`/`--out`** — modal switches that assign
+  subsequent `-b`/`-c` to the PULL (input) or PUSH (output) side.
+  Enables fan-in, fan-out, and mixed bind/connect per side.
+  Backward compatible — without `--in`/`--out`, the positional
+  2-endpoint syntax works as before.
+
+### Improved
+
+- **YJIT recv pump** — replaced lambda/proc `transform:` parameter in
+  `Engine#start_recv_pump` with block captures. No-transform path
+  (PUSH/PULL, PUB/SUB) is now branch-free. ~2.5x YJIT speedup on
+  inproc, ~2x on ipc/tcp.
+
+### Fixed
+
+- **Frozen array from `recv_msg_raw`** — ROUTER/SERVER receiver crashed
+  with `FrozenError` when shifting identity off frozen message arrays.
+  `#recv_msg_raw` now dups the array.
+
 ## 0.6.5 — 2026-03-30
 
 ### Fixed

data/README.md

@@ -1,39 +1,44 @@
-# OMQ! Where did the C dependency go?!
+# OMQ — ZeroMQ in pure Ruby
 
 [![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/omq?color=e9573f)](https://rubygems.org/gems/omq)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
-Pure Ruby implementation of the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire protocol ([ZeroMQ](https://zeromq.org/)) using the [Async](https://github.com/socketry/async) gem. No native libraries required.
+`gem install omq` — that's it. No libzmq, no compiler, no system packages. Just Ruby.
 
-> **244k msg/s** inproc | **47k msg/s** ipc | **36k msg/s** tcp
+OMQ implements the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire protocol from scratch using [Async](https://github.com/socketry/async) fibers. It speaks native ZeroMQ on the wire and interoperates with libzmq, pyzmq, CZMQ, and everything else in the ZMQ ecosystem.
+
+> **234k msg/s** inproc | **49k msg/s** ipc | **36k msg/s** tcp
 >
-> **9 µs** inproc latency | **47 µs** ipc | **61 µs** tcp
+> **12 µs** inproc latency | **51 µs** ipc | **62 µs** tcp
 >
-> Ruby 4.0 + YJIT on a Linux VM on a 2019 MacBook Pro (Intel) — [~340k msg/s with io_uring](bench/README.md#io_uring)
+> Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
 
 ---
 
-## Highlights
+## What is ZeroMQ?
+
+Brokerless message-oriented middleware. No central server, no extra hop — processes talk directly to each other, cutting latency in half compared to broker-based systems. You get the patterns you'd normally build on top of RabbitMQ or Redis — pub/sub, work distribution, request/reply, fan-out — but decentralized, with no single point of failure.
 
-- **Pure Ruby** — no C extensions, no FFI, no libzmq/libczmq dependency
-- **All socket types** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair + draft types (client/server, radio/dish, scatter/gather, peer, channel)
-- **Async-native** — built on [Async](https://github.com/socketry/async) fibers, also works with plain threads
-- **Ruby-idiomatic API** — messages as `Array<String>`, errors as exceptions, timeouts as `IO::TimeoutError`
-- **All transports** — tcp, ipc, inproc
+Networking is hard. ZeroMQ abstracts away reconnection, queuing, load balancing, and framing so you can focus on what your system actually does. Start with threads talking over `inproc://`, split into processes with `ipc://`, scale across machines with `tcp://` — same code, same API, just change the URL.
 
-## Why pure Ruby?
+If you've ever wired up services with raw TCP, HTTP polling, or Redis pub/sub and wished it was simpler, this is what you've been looking for.
 
-Modern Ruby has closed the gap:
+See [GETTING_STARTED.md](GETTING_STARTED.md) for a ~30 min walkthrough of all major patterns with working code.
 
-- **YJIT** — JIT-compiled hot paths close the throughput gap with C extensions
-- **Fiber Scheduler** — non-blocking I/O without callbacks or threads (`Async` builds on this)
-- **`io-stream`** — buffered I/O with read-ahead, from the Async ecosystem
+## Highlights
 
-When [CZTop](https://github.com/paddor/cztop) was written, none of this existed. Today, a pure Ruby ZMTP implementation is fast enough for production use — and you get `gem install` with no compiler toolchain, no system packages, and no segfaults.
+- **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install` just works everywhere
+- **Fast** — YJIT-optimized hot paths, batched sends, 234k msg/s inproc with 12 µs latency
+- **`omq` CLI** — pipe, filter, and transform messages from the terminal with Ruby eval, Ractor parallelism, and [script handlers](CLI.md#script-handlers--r)
+- **Every socket pattern** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair, and all draft types
+- **Every transport** — tcp, ipc (Unix domain sockets), inproc (in-process queues)
+- **Async-native** — built on fibers, non-blocking from the ground up. A shared IO thread handles sockets outside of Async — no reactor needed for simple scripts
+- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ over tcp and ipc
+- **Bind/connect order doesn't matter** — connect before bind, bind before connect, peers come and go. ZeroMQ reconnects and requeues automatically
 
-See [DESIGN.md](DESIGN.md) for architecture details: task trees, send pump batching, the ZMTP wire protocol, and how OMQ handles the fallacies of distributed computing.
+For architecture internals, see [DESIGN.md](DESIGN.md).
 
 ## Install
 
@@ -45,10 +50,6 @@ gem install omq
 gem 'omq'
 ```
 
-## Learning ZeroMQ
-
-New to ZeroMQ? See [ZGUIDE_SUMMARY.md](ZGUIDE_SUMMARY.md) — a ~30 min read covering all major patterns with working OMQ code examples.
-
 ## Quick Start
 
 ### Request / Reply
@@ -67,7 +68,7 @@ Async do |task|
   end
 
   req << 'hello'
-  puts req.receive.inspect  # => ["HELLO"]
+  p req.receive  # => ["HELLO"]
 ensure
   req&.close
   rep&.close
@@ -83,7 +84,7 @@ Async do |task|
   sub.subscribe('')  # subscribe to all
 
   task.async { pub << 'news flash' }
-  puts sub.receive.inspect  # => ["news flash"]
+  p sub.receive  # => ["news flash"]
 ensure
   pub&.close
   sub&.close
@@ -98,51 +99,56 @@ Async do
   pull = OMQ::PULL.bind('inproc://pipeline')
 
   push << 'work item'
-  puts pull.receive.inspect  # => ["work item"]
+  p pull.receive  # => ["work item"]
 ensure
   push&.close
   pull&.close
 end
 ```
 
-## Socket Types
+### Without Async (IO thread)
 
-| Pattern | Classes | Direction | Multipart |
-|---------|---------|-----------|-----------|
-| Request/Reply | `REQ`, `REP` | bidirectional | yes |
-| Publish/Subscribe | `PUB`, `SUB`, `XPUB`, `XSUB` | unidirectional | yes |
-| Pipeline | `PUSH`, `PULL` | unidirectional | yes |
-| Routing | `DEALER`, `ROUTER` | bidirectional | yes |
-| Exclusive pair | `PAIR` | bidirectional | yes |
-| Client/Server | `CLIENT`, `SERVER` | bidirectional | no |
-| Group messaging | `RADIO`, `DISH` | unidirectional | no |
-| Pipeline (draft) | `SCATTER`, `GATHER` | unidirectional | no |
-| Peer-to-peer | `PEER` | bidirectional | no |
-| Channel (draft) | `CHANNEL` | bidirectional | no |
-
-All classes live under `OMQ::`. For the purists, `ØMQ` is an alias:
+OMQ spawns a shared `omq-io` thread when used outside an Async reactor — no boilerplate needed:
 
 ```ruby
-req = ØMQ::REQ.new(">tcp://localhost:5555")
+require 'omq'
+
+push = OMQ::PUSH.bind('tcp://127.0.0.1:5557')
+pull = OMQ::PULL.connect('tcp://127.0.0.1:5557')
+
+push << 'hello'
+p pull.receive  # => ["hello"]
+
+push.close
+pull.close
 ```
 
-## Performance
+The IO thread runs all pumps, reconnection, and heartbeating in the background. When you're inside an `Async` block, OMQ uses the existing reactor instead.
 
-Benchmarked with benchmark-ips on Linux x86_64 (Ruby 4.0.2 +YJIT):
+## Socket Types
 
-#### Throughput (push/pull, 64 B messages)
+All sockets are thread-safe. Default HWM is 1000 messages per socket. Classes live under `OMQ::` (alias: `ØMQ`).
 
-| inproc | ipc | tcp |
-|--------|-----|-----|
-| 244k/s | 47k/s | 36k/s |
+#### Standard (multipart messages)
 
-#### Latency (req/rep roundtrip)
+| Pattern | Send | Receive | When HWM full |
+|---------|------|---------|---------------|
+| **REQ** / **REP** | Round-robin / route-back | Fair-queue | Block |
+| **PUB** / **SUB** | Fan-out to subscribers | Subscription filter | Drop |
+| **PUSH** / **PULL** | Round-robin to workers | Fair-queue | Block |
+| **DEALER** / **ROUTER** | Round-robin / identity-route | Fair-queue | Block |
+| **XPUB** / **XSUB** | Fan-out (subscription events) | Fair-queue | Drop |
+| **PAIR** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
 
-| inproc | ipc | tcp |
-|--------|-----|-----|
-| 9 µs | 47 µs | 61 µs |
+#### Draft (single-frame only)
 
-See [`bench/`](bench/) for full results and scripts.
+| Pattern | Send | Receive | When HWM full |
+|---------|------|---------|---------------|
+| **CLIENT** / **SERVER** | Round-robin / routing-ID | Fair-queue | Block |
+| **RADIO** / **DISH** | Group fan-out | Group filter | Drop |
+| **SCATTER** / **GATHER** | Round-robin | Fair-queue | Block |
+| **PEER** | Routing-ID | Fair-queue | Block |
+| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
 
 ## omq — CLI tool
 
@@ -152,7 +158,7 @@ See [`bench/`](bench/) for full results and scripts.
 # Echo server
 omq rep -b tcp://:5555 --echo
 
-# Upcase server in one line
+# Upcase server — -e evals Ruby on each incoming message
 omq rep -b tcp://:5555 -e '$F.map(&:upcase)'
 
 # Client
@@ -163,50 +169,39 @@ echo "hello" | omq req -c tcp://localhost:5555
 omq sub -b tcp://:5556 -s "weather."  &
 echo "weather.nyc 72F" | omq pub -c tcp://localhost:5556 -d 0.3
 
-# Pipeline with filtering ($F = message parts, $_ = first part)
-# /regexp/ matches against $_, next skips, break stops
+# Pipeline with filtering
 tail -f /var/log/syslog | omq push -c tcp://collector:5557
 omq pull -b tcp://:5557 -e 'next unless /error/; $F'
 
+# Transform outgoing messages with -E
+echo hello | omq push -c tcp://localhost:5557 -E '$F.map(&:upcase)'
+
+# REQ: transform request and reply independently
+echo hello | omq req -c tcp://localhost:5555 \
+  -E '$F.map(&:upcase)' -e '$F.map(&:reverse)'
+
 # Pipe: PULL → eval → PUSH in one process
 omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
 
 # Pipe with Ractor workers for CPU parallelism (-P = all CPUs)
 omq pipe -c ipc://@work -c ipc://@sink -P -r./fib -e 'fib(Integer($_)).to_s'
+```
 
-# Exit when all peers disconnect (pipeline workers, sinks)
-omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F'
-
-# JSONL for structured data
-echo '["key","value"]' | omq push -c tcp://localhost:5557 -J
-omq pull -b tcp://:5557 -J
+`-e` (recv-eval) transforms incoming messages, `-E` (send-eval) transforms outgoing messages. `$F` is the message parts array, `$_` is the first part. Use `-r` to require gems or load scripts that register handlers via `OMQ.incoming` / `OMQ.outgoing`:
 
-# Zstandard compression
-omq push -c tcp://remote:5557 -z < data.txt
-omq pull -b tcp://:5557 -z
+```ruby
+# my_handler.rb
+db = DB.connect("postgres://localhost/app")
 
-# CURVE encryption
-omq rep -b tcp://:5555 -D "secret" --curve-server
-# prints: OMQ_SERVER_KEY='...'
-omq req -c tcp://localhost:5555 --curve-server-key '...'
+OMQ.incoming { db.query($F.first) }
+at_exit { db.close }
 ```
 
-The `-e` flag runs Ruby inside the socket instance — the full socket API (`self <<`, `send`, `subscribe`, ...) is available. `$F` is the message parts array, `$_` is the first part. Use `-r` to require gems:
-
 ```sh
-omq sub -c tcp://localhost:5556 -s "" -r json \
-  -e 'JSON.parse($F.first)["temperature"]'
-
-# BEGIN/END blocks (like awk) — accumulate and summarize
-omq pull -b tcp://:5557 \
-  -e 'BEGIN{ @sum = 0 } @sum += Integer($_); next END{ puts @sum }'
+omq pull -b tcp://:5557 -r./my_handler.rb
 ```
 
-Formats: `--ascii` (default, tab-separated), `--quoted`, `--raw`, `--jsonl`, `--msgpack`, `--marshal`. See `omq --help` for all options.
-
-## Interop with native ZMQ
-
-OMQ speaks ZMTP 3.1 on the wire and interoperates with libzmq, CZMQ, pyzmq, etc. over **tcp** and **ipc**. The `inproc://` transport is OMQ-internal (in-process Ruby queues) and is not visible to native ZMQ running in the same process — use `ipc://` to talk across library boundaries.
+See [CLI.md](CLI.md) for full documentation, or `omq --help` / `omq --examples`.
 
 ## Development
 

data/lib/omq/cli/base_runner.rb

@@ -28,9 +28,11 @@ module OMQ
         sleep(config.delay) if config.delay && config.recv_only?
         wait_for_peer if needs_peer_wait?
 
-        @sock.instance_exec(&@begin_proc) if @begin_proc
+        @sock.instance_exec(&@send_begin_proc) if @send_begin_proc
+        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
         run_loop(task)
-        @sock.instance_exec(&@end_proc) if @end_proc
+        @sock.instance_exec(&@send_end_proc) if @send_end_proc
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
       ensure
         @sock&.close
       end
@@ -201,19 +203,19 @@ module OMQ
             end
           end
         elsif config.data || config.file
-          parts = eval_expr(read_next)
+          parts = eval_send_expr(read_next)
           send_msg(parts) if parts
         elsif stdin_ready?
           loop do
             parts = read_next
             break unless parts
-            parts = eval_expr(parts)
+            parts = eval_send_expr(parts)
             send_msg(parts) if parts
             i += 1
             break if n && n > 0 && i >= n
           end
-        elsif @eval_proc
-          parts = eval_expr(nil)
+        elsif @send_eval_proc
+          parts = eval_send_expr(nil)
           send_msg(parts) if parts
         end
       end
@@ -221,11 +223,11 @@ module OMQ
 
       def send_tick
         raw = read_next_or_nil
-        if raw.nil? && !@eval_proc
+        if raw.nil? && !@send_eval_proc
           @send_tick_eof = true
           return 0
         end
-        parts = eval_expr(raw)
+        parts = eval_send_expr(raw)
         send_msg(parts) if parts
         1
       end
@@ -237,7 +239,7 @@ module OMQ
         loop do
           parts = recv_msg
           break if parts.nil?
-          parts = eval_expr(parts)
+          parts = eval_recv_expr(parts)
           output(parts)
           i += 1
           break if n && n > 0 && i >= n
@@ -246,7 +248,7 @@ module OMQ
 
 
       def wait_for_loops(receiver, sender)
-        if config.data || config.file || config.expr || config.target
+        if config.data || config.file || config.send_expr || config.recv_expr || config.target
           sender.wait
           receiver.stop
         elsif config.count && config.count > 0
@@ -281,7 +283,8 @@ module OMQ
 
 
       def recv_msg_raw
-        @sock.receive
+        msg = @sock.receive
+        msg&.dup
       end
 
 
@@ -320,7 +323,7 @@ module OMQ
       def read_next_or_nil
         if config.data || config.file
           read_next
-        elsif @eval_proc
+        elsif @send_eval_proc
           nil
         else
           read_next
@@ -358,11 +361,30 @@ module OMQ
 
 
       def compile_expr
-        return unless config.expr
-        expr, begin_body, end_body = extract_blocks(config.expr)
-        @begin_proc = eval("proc { #{begin_body} }") if begin_body
-        @end_proc   = eval("proc { #{end_body} }")   if end_body
-        @eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
+        compile_one_expr(:send, config.send_expr)
+        compile_one_expr(:recv, config.recv_expr)
+        @send_eval_proc ||= wrap_registered_proc(OMQ.outgoing_proc)
+        @recv_eval_proc ||= wrap_registered_proc(OMQ.incoming_proc)
+      end
+
+
+      def wrap_registered_proc(block)
+        return unless block
+        proc do |msg|
+          $_ = msg&.first
+          block.call(msg)
+        end
+      end
+
+
+      def compile_one_expr(direction, src)
+        return unless src
+        expr, begin_body, end_body = extract_blocks(src)
+        instance_variable_set(:"@#{direction}_begin_proc", eval("proc { #{begin_body} }")) if begin_body
+        instance_variable_set(:"@#{direction}_end_proc",   eval("proc { #{end_body} }"))   if end_body
+        if expr && !expr.strip.empty?
+          instance_variable_set(:"@#{direction}_eval_proc", eval("proc { $_ = $F&.first; #{expr} }"))
+        end
       end
 
 
@@ -398,10 +420,21 @@ module OMQ
 
       SENT = Object.new.freeze # sentinel: eval already sent the reply
 
-      def eval_expr(parts)
-        return parts unless @eval_proc
+      def eval_send_expr(parts)
+        return parts unless @send_eval_proc
+        run_eval(@send_eval_proc, parts)
+      end
+
+
+      def eval_recv_expr(parts)
+        return parts unless @recv_eval_proc
+        run_eval(@recv_eval_proc, parts)
+      end
+
+
+      def run_eval(eval_proc, parts)
         $F = parts
-        result = @sock.instance_exec(&@eval_proc)
+        result = @sock.instance_exec(parts, &eval_proc)
         return nil if result.nil?
         return SENT if result.equal?(@sock)
         return [result] if config.format == :marshal
@@ -411,7 +444,7 @@ module OMQ
         else             [result.to_str]
         end
       rescue => e
-        $stderr.puts "omq: -e error: #{e.message} (#{e.class})"
+        $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
         exit 3
       end
 

data/lib/omq/cli/client_server.rb

@@ -11,7 +11,7 @@ module OMQ
 
 
       def run_loop(task)
-        if config.echo || config.expr || config.data || config.file || !config.stdin_is_tty
+        if config.echo || config.recv_expr || @recv_eval_proc || config.data || config.file || !config.stdin_is_tty
           reply_loop
         else
           monitor_loop(task)
@@ -28,8 +28,8 @@ module OMQ
           routing_id = parts.shift
           body       = @fmt.decompress(parts)
 
-          if config.expr
-            reply = eval_expr(body)
+          if config.recv_expr || @recv_eval_proc
+            reply = eval_recv_expr(body)
             output([display_routing_id(routing_id), *(reply || [""])])
             @sock.send_to(routing_id, @fmt.compress(reply || [""]).first)
           elsif config.echo
@@ -56,7 +56,7 @@ module OMQ
             break if parts.nil?
             routing_id = parts.shift
             parts      = @fmt.decompress(parts)
-            result = eval_expr([display_routing_id(routing_id), *parts])
+            result = eval_recv_expr([display_routing_id(routing_id), *parts])
             output(result)
             i += 1
             break if n && n > 0 && i >= n
@@ -71,18 +71,18 @@ module OMQ
             Async::Loop.quantized(interval: config.interval) do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
           elsif config.data || config.file
             parts = read_next
-            send_targeted_or_plain(parts) if parts
+            send_targeted_or_eval(parts) if parts
           else
             loop do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
@@ -93,8 +93,13 @@ module OMQ
       end
 
 
-      def send_targeted_or_plain(parts)
-        if config.target
+      def send_targeted_or_eval(parts)
+        if @send_eval_proc
+          parts = eval_send_expr(parts)
+          return unless parts
+          routing_id = resolve_target(parts.shift)
+          @sock.send_to(routing_id, @fmt.compress(parts).first || "")
+        elsif config.target
           parts = @fmt.compress(parts)
           @sock.send_to(resolve_target(config.target), parts.first || "")
         else

data/lib/omq/cli/config.rb

@@ -2,6 +2,9 @@
 
 module OMQ
   module CLI
+    SEND_ONLY = %w[pub push scatter radio].freeze
+    RECV_ONLY = %w[sub pull gather dish].freeze
+
     Endpoint = Data.define(:url, :bind?) do
       def connect? = !bind?
     end
@@ -12,6 +15,8 @@ module OMQ
       :endpoints,
       :connects,
       :binds,
+      :in_endpoints,
+      :out_endpoints,
       :data,
       :file,
       :format,
@@ -29,7 +34,8 @@ module OMQ
       :heartbeat_ivl,
       :conflate,
       :compress,
-      :expr,
+      :send_expr,
+      :recv_expr,
       :parallel,
       :transient,
       :verbose,
@@ -41,9 +47,6 @@ module OMQ
       :has_zstd,
       :stdin_is_tty,
     ) do
-      SEND_ONLY = %w[pub push scatter radio].freeze
-      RECV_ONLY = %w[sub pull gather dish].freeze
-
       def send_only? = SEND_ONLY.include?(type_name)
       def recv_only? = RECV_ONLY.include?(type_name)
     end

data/lib/omq/cli/pair.rb

@@ -13,7 +13,7 @@ module OMQ
           loop do
             parts = recv_msg
             break if parts.nil?
-            parts = eval_expr(parts)
+            parts = eval_recv_expr(parts)
             output(parts)
             i += 1
             break if n && n > 0 && i >= n

data/lib/omq/cli/pipe.rb

@@ -24,9 +24,22 @@ module OMQ
       private
 
 
+      def resolve_endpoints
+        if config.in_endpoints.any?
+          [config.in_endpoints, config.out_endpoints]
+        else
+          [[config.endpoints[0]], [config.endpoints[1]]]
+        end
+      end
+
+
+      def attach_endpoints(sock, endpoints)
+        endpoints.each { |ep| ep.bind? ? sock.bind(ep.url) : sock.connect(ep.url) }
+      end
+
+
       def run_sequential(task)
-        pull_ep = config.endpoints[0]
-        push_ep = config.endpoints[1]
+        in_eps, out_eps = resolve_endpoints
 
         @pull = OMQ::PULL.new(linger: config.linger, recv_timeout: config.timeout)
         @push = OMQ::PUSH.new(linger: config.linger, send_timeout: config.timeout)
@@ -35,11 +48,11 @@ module OMQ
         @pull.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
         @push.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
 
-        pull_ep.bind? ? @pull.bind(pull_ep.url) : @pull.connect(pull_ep.url)
-        push_ep.bind? ? @push.bind(push_ep.url) : @push.connect(push_ep.url)
+        attach_endpoints(@pull, in_eps)
+        attach_endpoints(@push, out_eps)
 
         compile_expr
-        @sock = @pull  # for eval_expr instance_exec
+        @sock = @pull  # for eval instance_exec
 
         with_timeout(config.timeout) do
           @push.peer_connected.wait
@@ -54,7 +67,7 @@ module OMQ
           end
         end
 
-        @sock.instance_exec(&@begin_proc) if @begin_proc
+        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
 
         n = config.count
         i = 0
@@ -62,7 +75,7 @@ module OMQ
           parts = @pull.receive
           break if parts.nil?
           parts = @fmt.decompress(parts)
-          parts = eval_expr(parts)
+          parts = eval_recv_expr(parts)
           if parts && !parts.empty?
             @push.send(@fmt.compress(parts))
           end
@@ -70,7 +83,7 @@ module OMQ
           break if n && n > 0 && i >= n
         end
 
-        @sock.instance_exec(&@end_proc) if @end_proc
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
       ensure
         @pull&.close
         @push&.close
@@ -86,7 +99,7 @@ module OMQ
             Sync do |task|
               # Parse BEGIN/END blocks and per-message expression
               begin_proc = end_proc = eval_proc = nil
-              if cfg.expr
+              if cfg.recv_expr
                 extract = ->(src, kw) {
                   s = src.index(/#{kw}\s*\{/)
                   return [src, nil] unless s
@@ -97,7 +110,7 @@ module OMQ
                   end
                   [src[0...s] + src[j..], src[(i + 1)..(j - 2)]]
                 }
-                expr, begin_body = extract.(cfg.expr, "BEGIN")
+                expr, begin_body = extract.(cfg.recv_expr, "BEGIN")
                 expr, end_body   = extract.(expr, "END")
                 begin_proc = eval("proc { #{begin_body} }") if begin_body
                 end_proc   = eval("proc { #{end_body} }")   if end_body
@@ -115,8 +128,10 @@ module OMQ
               push.reconnect_interval  = cfg.reconnect_ivl if cfg.reconnect_ivl
               pull.heartbeat_interval  = cfg.heartbeat_ivl if cfg.heartbeat_ivl
               push.heartbeat_interval  = cfg.heartbeat_ivl if cfg.heartbeat_ivl
-              pull.connect(cfg.endpoints[0].url)
-              push.connect(cfg.endpoints[1].url)
+              in_eps  = cfg.in_endpoints.any? ? cfg.in_endpoints : [cfg.endpoints[0]]
+              out_eps = cfg.out_endpoints.any? ? cfg.out_endpoints : [cfg.endpoints[1]]
+              in_eps.each  { |ep| pull.connect(ep.url) }
+              out_eps.each { |ep| push.connect(ep.url) }
 
               if cfg.timeout
                 task.with_timeout(cfg.timeout) do
@@ -187,11 +202,12 @@ module OMQ
 
 
       def compile_expr
-        return unless config.expr
-        expr, begin_body, end_body = extract_blocks(config.expr)
-        @begin_proc = eval("proc { #{begin_body} }") if begin_body
-        @end_proc   = eval("proc { #{end_body} }")   if end_body
-        @eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
+        src = config.recv_expr
+        return unless src
+        expr, begin_body, end_body = extract_blocks(src)
+        @recv_begin_proc = eval("proc { #{begin_body} }") if begin_body
+        @recv_end_proc   = eval("proc { #{end_body} }")   if end_body
+        @recv_eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
       end
 
 
@@ -224,10 +240,10 @@ module OMQ
       end
 
 
-      def eval_expr(parts)
-        return parts unless @eval_proc
+      def eval_recv_expr(parts)
+        return parts unless @recv_eval_proc
         $F = parts
-        result = @sock.instance_exec(&@eval_proc)
+        result = @sock.instance_exec(&@recv_eval_proc)
         return nil if result.nil? || result.equal?(@sock)
         return [result] if config.format == :marshal
         case result
@@ -236,7 +252,7 @@ module OMQ
         else             [result.to_str]
         end
       rescue => e
-        $stderr.puts "omq: -e error: #{e.message} (#{e.class})"
+        $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
         exit 3
       end
 

data/lib/omq/cli/req_rep.rb

@@ -14,10 +14,12 @@ module OMQ
           loop do
             parts = read_next
             break unless parts
+            parts = eval_send_expr(parts)
+            next unless parts
             send_msg(parts)
             reply = recv_msg
             break if reply.nil?
-            reply = eval_expr(reply)
+            reply = eval_recv_expr(reply)
             output(reply)
             i += 1
             break if n && n > 0 && i >= n
@@ -29,10 +31,12 @@ module OMQ
           loop do
             parts = read_next
             break unless parts
+            parts = eval_send_expr(parts)
+            next unless parts
             send_msg(parts)
             reply = recv_msg
             break if reply.nil?
-            reply = eval_expr(reply)
+            reply = eval_recv_expr(reply)
             output(reply)
             i += 1
             break if n && n > 0 && i >= n
@@ -53,8 +57,8 @@ module OMQ
         loop do
           msg = recv_msg
           break if msg.nil?
-          if config.expr
-            reply = eval_expr(msg)
+          if config.recv_expr || @recv_eval_proc
+            reply = eval_recv_expr(msg)
             unless reply.equal?(SENT)
               output(reply)
               send_msg(reply || [""])

data/lib/omq/cli/router_dealer.rb

@@ -20,7 +20,7 @@ module OMQ
             identity = parts.shift
             parts.shift if parts.first == ""
             parts = @fmt.decompress(parts)
-            result = eval_expr([display_routing_id(identity), *parts])
+            result = eval_recv_expr([display_routing_id(identity), *parts])
             output(result)
             i += 1
             break if n && n > 0 && i >= n
@@ -35,18 +35,18 @@ module OMQ
             Async::Loop.quantized(interval: config.interval) do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
           elsif config.data || config.file
             parts = read_next
-            send_targeted_or_plain(parts) if parts
+            send_targeted_or_eval(parts) if parts
           else
             loop do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
@@ -57,8 +57,14 @@ module OMQ
       end
 
 
-      def send_targeted_or_plain(parts)
-        if config.target
+      def send_targeted_or_eval(parts)
+        if @send_eval_proc
+          parts = eval_send_expr(parts)
+          return unless parts
+          identity = resolve_target(parts.shift)
+          payload  = @fmt.compress(parts)
+          @sock.send([identity, "", *payload])
+        elsif config.target
           payload = @fmt.compress(parts)
           @sock.send([resolve_target(config.target), "", *payload])
         else

data/lib/omq/cli.rb

@@ -17,6 +17,15 @@ require_relative "cli/peer"
 require_relative "cli/pipe"
 
 module OMQ
+
+  class << self
+    attr_reader :outgoing_proc, :incoming_proc
+
+    def outgoing(&block) = @outgoing_proc = block
+    def incoming(&block) = @incoming_proc = block
+  end
+
+
   module CLI
     SOCKET_TYPE_NAMES = %w[
       req rep pub sub push pull pair dealer router
@@ -56,7 +65,7 @@ module OMQ
         └─────┘  "HELLO"    └─────┘
 
         # terminal 1: echo server
-        omq rep --bind tcp://:5555 --eval '$F.map(&:upcase)'
+        omq rep --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
 
         # terminal 2: send a request
         echo "hello" | omq req --connect tcp://localhost:5555
@@ -79,7 +88,7 @@ module OMQ
 
       ── Periodic Publish ───────────────────────────────────────────
 
-        ┌─────┐  "tick 1"   ┌─────┐
+        ┌─────┐  "tick 1"    ┌─────┐
         │ PUB │──(every 1s)─→│ SUB │
         └─────┘              └─────┘
 
@@ -121,27 +130,31 @@ module OMQ
 
         # terminal 2: worker — uppercase each message
         omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
-
         # terminal 3: collector
         omq pull --bind ipc://@sink
 
         # 4 Ractor workers in a single process (-P)
-        omq pipe -c ipc://@work -c ipc://@sink -P 4 \
-          -r ./fib.rb -e 'fib(Integer($_)).to_s'
+        omq pipe -c ipc://@work -c ipc://@sink -P4 -r./fib -e 'fib(Integer($_)).to_s'
 
         # exit when producer disconnects (--transient)
-        omq pipe -c ipc://@work -c ipc://@sink --transient \
-          -e '$F.map(&:upcase)'
+        omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.map(&:upcase)'
+
+        # fan-in: multiple sources → one sink
+        omq pipe --in -c ipc://@work1 -c ipc://@work2 \
+          --out -c ipc://@sink -e '$F.map(&:upcase)'
+
+        # fan-out: one source → multiple sinks (round-robin)
+        omq pipe --in -b tcp://:5555 --out -c ipc://@sink1 -c ipc://@sink2 -e '$F'
 
       ── CLIENT / SERVER (draft) ──────────────────────────────────
 
         ┌────────┐  "hello"   ┌────────┐
-        │ CLIENT │───────────→│ SERVER │ --eval '$F.map(&:upcase)'
+        │ CLIENT │───────────→│ SERVER │ --recv-eval '$F.map(&:upcase)'
         │        │←───────────│        │
         └────────┘  "HELLO"   └────────┘
 
         # terminal 1: upcasing server
-        omq server --bind tcp://:5555 --eval '$F.map(&:upcase)'
+        omq server --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
 
         # terminal 2: client
         echo "hello" | omq client --connect tcp://localhost:5555
@@ -187,30 +200,45 @@ module OMQ
         omq router --bind tcp://:5555
 
         # terminal 2: dealer with identity
-        echo "hello" | omq dealer --connect tcp://localhost:5555 \
-          --identity worker-1
+        echo "hello" | omq dealer --connect tcp://localhost:5555 --identity worker-1
 
       ── Ruby Eval ────────────────────────────────────────────────
 
-        # filter: only pass messages containing "error"
-        omq pull --bind tcp://:5557 \
-          --eval '$F.first.include?("error") ? $F : nil'
+        # filter incoming: only pass messages containing "error"
+        omq pull -b tcp://:5557 --recv-eval '$F.first.include?("error") ? $F : nil'
 
-        # transform with gems
-        omq sub --connect tcp://localhost:5556 --require json \
-          --eval 'JSON.parse($F.first)["temperature"]'
+        # transform incoming with gems
+        omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse($F.first)["temperature"]'
 
-        # require a local file, use its methods in --eval
-        omq rep --bind tcp://:5555 --require ./transform.rb \
-          --eval 'upcase_all($F)'
+        # require a local file, use its methods
+        omq rep --bind tcp://:5555 --require ./transform.rb -e 'upcase_all($F)'
 
         # next skips, break stops — regexps match against $_
-        omq pull --bind tcp://:5557 \
-          --eval 'next if /^#/; break if /quit/; $F'
+        omq pull -b tcp://:5557 -e 'next if /^#/; break if /quit/; $F'
 
         # BEGIN/END blocks (like awk) — accumulate and summarize
-        omq pull --bind tcp://:5557 \
-          --eval 'BEGIN{ @sum = 0 } @sum += Integer($_); next END{ puts @sum }'
+        omq pull -b tcp://:5557 -e 'BEGIN{@sum = 0} @sum += Integer($_); nil END{puts @sum}'
+
+        # transform outgoing messages
+        echo hello | omq push -c tcp://localhost:5557 --send-eval '$F.map(&:upcase)'
+
+        # REQ: transform request and reply independently
+        echo hello | omq req -c tcp://localhost:5555 -E '$F.map(&:upcase)' -e '$_'
+
+      ── Script Handlers (-r) ────────────────────────────────────
+
+        # handler.rb — register transforms from a file
+        #   db = PG.connect("dbname=app")
+        #   OMQ.incoming { |first_part, _| db.exec(first_part).values.flatten }
+        #   at_exit { db.close }
+        omq pull --bind tcp://:5557 -r./handler.rb
+
+        # combine script handlers with inline eval
+        omq req -c tcp://localhost:5555 -r./handler.rb -E '$F.map(&:upcase)'
+
+        # OMQ.outgoing { |msg| ... }   — registered outgoing transform
+        # OMQ.incoming { |msg| ... }   — registered incoming transform
+        # CLI flags (-e/-E) override registered handlers
     TEXT
 
     module_function
@@ -299,6 +327,8 @@ module OMQ
         endpoints:        [],
         connects:         [],
         binds:            [],
+        in_endpoints:     [],
+        out_endpoints:    [],
         data:             nil,
         file:             nil,
         format:           :ascii,
@@ -316,7 +346,8 @@ module OMQ
         heartbeat_ivl:    nil,
         conflate:         false,
         compress:         false,
-        expr:             nil,
+        send_expr:        nil,
+        recv_expr:        nil,
         parallel:         nil,
         transient:        false,
         verbose:          false,
@@ -326,6 +357,8 @@ module OMQ
         curve_server_key: nil,
       }
 
+      pipe_side = nil  # nil = legacy positional mode; :in/:out = modal
+
       parser = OptionParser.new do |o|
         o.banner = "Usage: omq TYPE [options]\n\n" \
                    "Types:    req, rep, pub, sub, push, pull, pair, dealer, router\n" \
@@ -333,8 +366,24 @@ module OMQ
                    "Virtual:  pipe (PULL → eval → PUSH)\n\n"
 
         o.separator "Connection:"
-        o.on("-c", "--connect URL", "Connect to endpoint (repeatable)")   { |v| opts[:endpoints] << Endpoint.new(v, false); opts[:connects] << v }
-        o.on("-b", "--bind URL",    "Bind to endpoint (repeatable)")      { |v| opts[:endpoints] << Endpoint.new(v, true);  opts[:binds] << v }
+        o.on("-c", "--connect URL", "Connect to endpoint (repeatable)") { |v|
+          ep = Endpoint.new(v, false)
+          case pipe_side
+          when :in  then opts[:in_endpoints] << ep
+          when :out then opts[:out_endpoints] << ep
+          else           opts[:endpoints] << ep; opts[:connects] << v
+          end
+        }
+        o.on("-b", "--bind URL", "Bind to endpoint (repeatable)") { |v|
+          ep = Endpoint.new(v, true)
+          case pipe_side
+          when :in  then opts[:in_endpoints] << ep
+          when :out then opts[:out_endpoints] << ep
+          else           opts[:endpoints] << ep; opts[:binds] << v
+          end
+        }
+        o.on("--in",  "Pipe: subsequent -b/-c attach to input (PULL) side")  { pipe_side = :in }
+        o.on("--out", "Pipe: subsequent -b/-c attach to output (PUSH) side") { pipe_side = :out }
 
         o.separator "\nData source (REP: reply source):"
         o.on(      "--echo",        "Echo received messages back (REP)")   { opts[:echo] = true }
@@ -380,9 +429,11 @@ module OMQ
         o.separator "\nCompression:"
         o.on("-z", "--compress", "Zstandard compression per frame") { opts[:compress] = true }
 
-        o.separator "\nProcessing:"
-        o.on("-e", "--eval EXPR",    "Eval Ruby for each message ($F = parts)") { |v| opts[:expr] = v }
-        o.on("-r", "--require LIB",  "Require library or file (-r./lib.rb)")    { |v|
+        o.separator "\nProcessing (-e = incoming, -E = outgoing):"
+        o.on("-e", "--recv-eval EXPR", "Eval Ruby for each incoming message ($F = parts)") { |v| opts[:recv_expr] = v }
+        o.on("-E", "--send-eval EXPR", "Eval Ruby for each outgoing message ($F = parts)") { |v| opts[:send_expr] = v }
+        o.on("-r", "--require LIB",  "Require lib/file; scripts can register OMQ.outgoing/incoming") { |v|
+          require_relative "../omq" unless defined?(OMQ::VERSION)
           v.start_with?("./", "../") ? require(File.expand_path(v)) : require(v)
         }
         o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (pipe only, default: nproc)") { |v|
@@ -421,10 +472,13 @@ module OMQ
 
       opts[:type_name] = type_name.downcase
 
-      normalize = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://localhost:") }
+      normalize    = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://localhost:") }
+      normalize_ep = ->(ep) { Endpoint.new(normalize.call(ep.url), ep.bind?) }
       opts[:binds].map!(&normalize)
       opts[:connects].map!(&normalize)
-      opts[:endpoints].map! { |ep| Endpoint.new(normalize.call(ep.url), ep.bind?) }
+      opts[:endpoints].map!(&normalize_ep)
+      opts[:in_endpoints].map!(&normalize_ep)
+      opts[:out_endpoints].map!(&normalize_ep)
 
       opts
     end
@@ -436,8 +490,16 @@ module OMQ
       type_name = opts[:type_name]
 
       if type_name == "pipe"
-        abort "pipe requires exactly 2 endpoints (pull-side and push-side)" if opts[:endpoints].size != 2
+        has_in_out = opts[:in_endpoints].any? || opts[:out_endpoints].any?
+        if has_in_out
+          abort "pipe --in requires at least one endpoint"              if opts[:in_endpoints].empty?
+          abort "pipe --out requires at least one endpoint"             if opts[:out_endpoints].empty?
+          abort "pipe: don't mix --in/--out with bare -b/-c endpoints"  unless opts[:endpoints].empty?
+        else
+          abort "pipe requires exactly 2 endpoints (pull-side and push-side), or use --in/--out" if opts[:endpoints].size != 2
+        end
       else
+        abort "--in/--out are only valid for pipe" if opts[:in_endpoints].any? || opts[:out_endpoints].any?
         abort "At least one --connect or --bind is required" if opts[:connects].empty? && opts[:binds].empty?
       end
       abort "--data and --file are mutually exclusive"        if opts[:data] && opts[:file]
@@ -447,11 +509,15 @@ module OMQ
       abort "--identity is only valid for DEALER/ROUTER"      if opts[:identity] && !%w[dealer router].include?(type_name)
       abort "--target is only valid for ROUTER/SERVER/PEER"   if opts[:target] && !%w[router server peer].include?(type_name)
       abort "--conflate is only valid for PUB/RADIO"          if opts[:conflate] && !%w[pub radio].include?(type_name)
+      abort "--recv-eval is not valid for send-only sockets (use --send-eval / -E)" if opts[:recv_expr] && SEND_ONLY.include?(type_name)
+      abort "--send-eval is not valid for recv-only sockets (use --recv-eval / -e)" if opts[:send_expr] && RECV_ONLY.include?(type_name)
+      abort "--send-eval and --target are mutually exclusive"  if opts[:send_expr] && opts[:target]
 
       if opts[:parallel]
         abort "-P/--parallel is only valid for pipe"                                    unless type_name == "pipe"
         abort "-P/--parallel must be >= 2"                                              if opts[:parallel] < 2
-        abort "-P/--parallel requires both endpoints to use --connect (not --bind)" if opts[:endpoints].any?(&:bind?)
+        all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
+        abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
       end
 
       (opts[:connects] + opts[:binds]).each do |url|

data/lib/omq/version.rb

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

data/lib/omq/zmtp/engine.rb

@@ -215,29 +215,50 @@ module OMQ
       # fast path when the connection is a DirectPipe.
       #
       # @param conn [Connection, Transport::Inproc::DirectPipe]
+      # Starts a recv pump that dequeues messages from a connection
+      # and enqueues them into the routing strategy's recv queue.
+      #
+      # When a block is given, each message is yielded for transformation
+      # before enqueueing. The block is compiled at the call site, giving
+      # YJIT a monomorphic call per routing strategy instead of a shared
+      # megamorphic `transform.call` dispatch.
+      #
+      # @param conn [Connection, Transport::Inproc::DirectPipe]
       # @param recv_queue [Async::LimitedQueue] routing strategy's recv queue
-      # @param transform [#call, nil] optional message transform
+      # @yield [msg] optional per-message transform
       # @return [#stop, nil] pump task handle, or nil for DirectPipe bypass
       #
-      def start_recv_pump(conn, recv_queue, transform: nil)
+      def start_recv_pump(conn, recv_queue, &transform)
         if conn.is_a?(Transport::Inproc::DirectPipe) && conn.peer
           conn.peer.direct_recv_queue = recv_queue
           conn.peer.direct_recv_transform = transform
           return nil
         end
 
-        Reactor.spawn_pump(annotation: "recv pump") do
-          loop do
-            msg = conn.receive_message
-            msg = transform ? transform.call(msg).freeze : msg
-            recv_queue.enqueue(msg)
+        if transform
+          Reactor.spawn_pump(annotation: "recv pump") do
+            loop do
+              msg = conn.receive_message
+              msg = transform.call(msg).freeze
+              recv_queue.enqueue(msg)
+            end
+          rescue Async::Stop
+          rescue ProtocolError, *CONNECTION_LOST
+            connection_lost(conn)
+          rescue => error
+            signal_fatal_error(error)
+          end
+        else
+          Reactor.spawn_pump(annotation: "recv pump") do
+            loop do
+              recv_queue.enqueue(conn.receive_message)
+            end
+          rescue Async::Stop
+          rescue ProtocolError, *CONNECTION_LOST
+            connection_lost(conn)
+          rescue => error
+            signal_fatal_error(error)
           end
-        rescue Async::Stop
-          # normal shutdown
-        rescue ProtocolError, *CONNECTION_LOST
-          connection_lost(conn)
-        rescue => error
-          signal_fatal_error(error)
         end
       end
 

data/lib/omq/zmtp/routing/peer.rb

@@ -34,8 +34,9 @@ module OMQ
           routing_id = SecureRandom.bytes(4)
           @connections_by_routing_id[routing_id] = connection
 
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: ->(msg) { [routing_id, *msg] })
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            [routing_id, *msg]
+          end
           @tasks << task if task
 
           start_send_pump unless @send_pump_started

data/lib/omq/zmtp/routing/rep.rb

@@ -29,14 +29,13 @@ module OMQ
         # @param connection [Connection]
         #
         def connection_added(connection)
-          transform = ->(msg) {
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
             delimiter = msg.index(&:empty?) || msg.size
             envelope  = msg[0, delimiter]
             body      = msg[(delimiter + 1)..] || []
             @pending_replies << { conn: connection, envelope: envelope }
             body
-          }
-          task = @engine.start_recv_pump(connection, @recv_queue, transform: transform)
+          end
           @tasks << task if task
           start_send_pump unless @send_pump_started
         end

data/lib/omq/zmtp/routing/req.rb

@@ -28,8 +28,9 @@ module OMQ
         def connection_added(connection)
           @connections << connection
           signal_connection_available
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: method(:transform_recv))
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            msg.first&.empty? ? msg[1..] : msg
+          end
           @tasks << task if task
           start_send_pump unless @send_pump_started
         end
@@ -58,11 +59,6 @@ module OMQ
         #
         def transform_send(parts) = ["".b, *parts]
 
-        # REQ strips the leading empty delimiter frame on receive.
-        #
-        def transform_recv(msg)
-          msg.first&.empty? ? msg[1..] : msg
-        end
       end
     end
   end

data/lib/omq/zmtp/routing/router.rb

@@ -35,8 +35,9 @@ module OMQ
           identity = SecureRandom.bytes(5) if identity.nil? || identity.empty?
           @connections_by_identity[identity] = connection
 
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: ->(msg) { [identity, *msg] })
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            [identity, *msg]
+          end
           @tasks << task if task
 
           start_send_pump unless @send_pump_started

data/lib/omq/zmtp/routing/server.rb

@@ -34,8 +34,9 @@ module OMQ
           routing_id = SecureRandom.bytes(4)
           @connections_by_routing_id[routing_id] = connection
 
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: ->(msg) { [routing_id, *msg] })
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            [routing_id, *msg]
+          end
           @tasks << task if task
 
           start_send_pump unless @send_pump_started

data/lib/omq.rb

@@ -17,6 +17,7 @@ module OMQ
   #
   class SocketDeadError < RuntimeError; end
 end
+
 require_relative "omq/zmtp"
 require_relative "omq/socket"
 require_relative "omq/req_rep"

metadata

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