omq-cli 0.2.0 → 0.3.0

data/lib/omq/cli/cli_parser.rb

@@ -0,0 +1,470 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Parses and validates command-line arguments for the omq CLI.
+    #
+    class CliParser
+      EXAMPLES = <<~'TEXT'
+        ── Request / Reply ──────────────────────────────────────────
+
+          ┌─────┐  "hello"    ┌─────┐
+          │ REQ │────────────→│ REP │
+          │     │←────────────│     │
+          └─────┘  "HELLO"    └─────┘
+
+          # terminal 1: echo server
+          omq rep --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
+
+          # terminal 2: send a request
+          echo "hello" | omq req --connect tcp://localhost:5555
+
+          # or over IPC (unix socket, single machine)
+          omq rep --bind ipc:///tmp/echo.sock --echo &
+          echo "hello" | omq req --connect ipc:///tmp/echo.sock
+
+        ── Publish / Subscribe ──────────────────────────────────────
+
+          ┌─────┐  "weather.nyc 72F"  ┌─────┐
+          │ PUB │────────────────────→│ SUB │ --subscribe "weather."
+          └─────┘                     └─────┘
+
+          # terminal 1: subscriber (all topics by default)
+          omq sub --bind tcp://:5556
+
+          # terminal 2: publisher (needs --delay for subscription to propagate)
+          echo "weather.nyc 72F" | omq pub --connect tcp://localhost:5556 --delay 1
+
+        ── Periodic Publish ───────────────────────────────────────────
+
+          ┌─────┐  "tick 1"    ┌─────┐
+          │ PUB │──(every 1s)─→│ SUB │
+          └─────┘              └─────┘
+
+          # terminal 1: subscriber
+          omq sub --bind tcp://:5556
+
+          # terminal 2: publish a tick every second (wall-clock aligned)
+          omq pub --connect tcp://localhost:5556 --delay 1 \
+            --data "tick" --interval 1
+
+          # 5 ticks, then exit
+          omq pub --connect tcp://localhost:5556 --delay 1 \
+            --data "tick" --interval 1 --count 5
+
+        ── Pipeline ─────────────────────────────────────────────────
+
+          ┌──────┐           ┌──────┐
+          │ PUSH │──────────→│ PULL │
+          └──────┘           └──────┘
+
+          # terminal 1: worker
+          omq pull --bind tcp://:5557
+
+          # terminal 2: send tasks
+          echo "task 1" | omq push --connect tcp://localhost:5557
+
+          # or over IPC (unix socket)
+          omq pull --bind ipc:///tmp/pipeline.sock &
+          echo "task 1" | omq push --connect ipc:///tmp/pipeline.sock
+
+        ── Pipe (PULL → eval → PUSH) ────────────────────────────────
+
+          ┌──────┐         ┌──────┐         ┌──────┐
+          │ PUSH │────────→│ pipe │────────→│ PULL │
+          └──────┘         └──────┘         └──────┘
+
+          # terminal 1: producer
+          echo -e "hello\nworld" | omq push --bind ipc://@work
+
+          # 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 -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)'
+
+          # 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 │ --recv-eval '$F.map(&:upcase)'
+          │        │←───────────│        │
+          └────────┘  "HELLO"   └────────┘
+
+          # terminal 1: upcasing server
+          omq server --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
+
+          # terminal 2: client
+          echo "hello" | omq client --connect tcp://localhost:5555
+
+        ── Formats ──────────────────────────────────────────────────
+
+          # ascii (default) — non-printable replaced with dots
+          omq pull --bind tcp://:5557 --ascii
+
+          # quoted — lossless, round-trippable (uses String#dump escaping)
+          omq pull --bind tcp://:5557 --quoted
+
+          # JSON Lines — structured, multipart as arrays
+          echo '["key","value"]' | omq push --connect tcp://localhost:5557 --jsonl
+          omq pull --bind tcp://:5557 --jsonl
+
+          # multipart via tabs
+          printf "routing-key\tpayload" | omq push --connect tcp://localhost:5557
+
+        ── Compression ──────────────────────────────────────────────
+
+          # both sides must use --compress
+          omq pull --bind tcp://:5557 --compress &
+          echo "compressible data" | omq push --connect tcp://localhost:5557 --compress
+
+        ── CURVE Encryption ─────────────────────────────────────────
+
+          # server (prints OMQ_SERVER_KEY=...)
+          omq rep --bind tcp://:5555 --echo --curve-server
+
+          # client (paste the server's key)
+          echo "secret" | omq req --connect tcp://localhost:5555 \
+            --curve-server-key '<key from server>'
+
+        ── ROUTER / DEALER ──────────────────────────────────────────
+
+          ┌────────┐          ┌────────┐
+          │ DEALER │─────────→│ ROUTER │
+          │ id=w1  │          │        │
+          └────────┘          └────────┘
+
+          # terminal 1: router shows identity + message
+          omq router --bind tcp://:5555
+
+          # terminal 2: dealer with identity
+          echo "hello" | omq dealer --connect tcp://localhost:5555 --identity worker-1
+
+        ── Ruby Eval ────────────────────────────────────────────────
+
+          # filter incoming: only pass messages containing "error"
+          omq pull -b tcp://:5557 --recv-eval '$F.first.include?("error") ? $F : nil'
+
+          # transform incoming with gems
+          omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse($F.first)["temperature"]'
+
+          # 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 -b tcp://:5557 -e 'next if /^#/; break if /quit/; $F'
+
+          # BEGIN/END blocks (like awk) — accumulate and summarize
+          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
+
+
+      DEFAULT_OPTS = {
+        type_name:        nil,
+        endpoints:        [],
+        connects:         [],
+        binds:            [],
+        in_endpoints:     [],
+        out_endpoints:    [],
+        data:             nil,
+        file:             nil,
+        format:           :ascii,
+        subscribes:       [],
+        joins:            [],
+        group:            nil,
+        identity:         nil,
+        target:           nil,
+        interval:         nil,
+        count:            nil,
+        delay:            nil,
+        timeout:          nil,
+        linger:           5,
+        reconnect_ivl:    nil,
+        heartbeat_ivl:    nil,
+        conflate:         false,
+        compress:         false,
+        send_expr:        nil,
+        recv_expr:        nil,
+        parallel:         nil,
+        transient:        false,
+        verbose:          false,
+        quiet:            false,
+        echo:             false,
+        scripts:          [],
+        recv_maxsz:       nil,
+        curve_server:     false,
+        curve_server_key: nil,
+        curve_crypto:     nil,
+      }.freeze
+
+
+      # Parses +argv+ and returns a mutable options hash.
+      #
+      def self.parse(argv)
+        new.parse(argv)
+      end
+
+
+      # Validates option combinations, aborting on bad combos.
+      #
+      def self.validate!(opts)
+        new.validate!(opts)
+      end
+
+
+      # Validates that required gems are available.
+      #
+      def self.validate_gems!(config)
+        abort "--msgpack requires the msgpack gem"    if config.format == :msgpack && !config.has_msgpack
+        abort "--compress requires the zstd-ruby gem" if config.compress && !config.has_zstd
+
+        if config.recv_only? && (config.data || config.file)
+          abort "--data/--file not valid for #{config.type_name} (receive-only)"
+        end
+      end
+
+
+      # Parses +argv+ and returns a mutable options hash.
+      #
+      # @param argv [Array<String>] command-line arguments (mutated in place)
+      # @return [Hash] parsed options
+      def parse(argv)
+        opts      = DEFAULT_OPTS.transform_values { |v| v.is_a?(Array) ? v.dup : v }
+        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" \
+                     "Draft:    client, server, radio, dish, scatter, gather, channel, peer\n" \
+                     "Virtual:  pipe (PULL → eval → PUSH)\n\n"
+
+          o.separator "Connection:"
+          o.on("-c", "--connect URL", "Connect to endpoint (repeatable)") { |v|
+            ep = Endpoint.new(v, false)
+            case pipe_side
+            when :in
+              opts[:in_endpoints] << ep
+            when :out
+              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
+              opts[:in_endpoints] << ep
+            when :out
+              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 }
+          o.on("-D", "--data DATA",   "Message data (literal string)")      { |v| opts[:data] = v }
+          o.on("-F", "--file FILE",   "Read message from file (- = stdin)") { |v| opts[:file] = v }
+
+          o.separator "\nFormat (input + output):"
+          o.on("-A", "--ascii",   "Tab-separated frames, safe ASCII (default)") { opts[:format] = :ascii }
+          o.on("-Q", "--quoted",  "C-style quoted with escapes")                { opts[:format] = :quoted }
+          o.on(      "--raw",     "Raw binary, no framing")                     { opts[:format] = :raw }
+          o.on("-J", "--jsonl",   "JSON Lines (array of strings per line)")     { opts[:format] = :jsonl }
+          o.on(      "--msgpack",  "MessagePack arrays (binary stream)")         { opts[:format] = :msgpack }
+          o.on("-M", "--marshal", "Ruby Marshal stream (binary, Array<String>)") { opts[:format] = :marshal }
+
+          o.separator "\nSubscription/groups:"
+          o.on("-s", "--subscribe PREFIX", "Subscribe prefix (SUB, default all)")     { |v| opts[:subscribes] << v }
+          o.on("-j", "--join GROUP",       "Join group (repeatable, DISH only)")      { |v| opts[:joins] << v }
+          o.on("-g", "--group GROUP",      "Publish group (RADIO only)")              { |v| opts[:group] = v }
+
+          o.separator "\nIdentity/routing:"
+          o.on("--identity ID", "Set socket identity (DEALER/ROUTER)")                     { |v| opts[:identity] = v }
+          o.on("--target ID",   "Target peer (ROUTER/SERVER/PEER, 0x prefix for binary)")  { |v| opts[:target] = v }
+
+          o.separator "\nTiming:"
+          o.on("-i", "--interval SECS", Float,   "Repeat interval")                   { |v| opts[:interval] = v }
+          o.on("-n", "--count COUNT",   Integer,  "Max iterations (0=inf)")            { |v| opts[:count] = v }
+          o.on("-d", "--delay SECS",    Float,   "Delay before first send")            { |v| opts[:delay] = v }
+          o.on("-t", "--timeout SECS",  Float,   "Send/receive timeout")               { |v| opts[:timeout] = v }
+          o.on("-l", "--linger SECS",   Float,   "Drain time on close (default 5)")   { |v| opts[:linger] = v }
+          o.on("--reconnect-ivl IVL", "Reconnect interval: SECS or MIN..MAX (default 0.1)") { |v|
+            opts[:reconnect_ivl] = if v.include?("..")
+                                     lo, hi = v.split("..", 2)
+                                     Float(lo)..Float(hi)
+                                   else
+                                     Float(v)
+                                   end
+          }
+          o.on("--heartbeat-ivl SECS", Float, "ZMTP heartbeat interval (detects dead peers)") { |v| opts[:heartbeat_ivl] = v }
+          o.on("--recv-maxsz COUNT", Integer, "Max inbound message size in bytes (larger messages dropped)") { |v| opts[:recv_maxsz] = v }
+
+          o.separator "\nDelivery:"
+          o.on("--conflate", "Keep only last message per subscriber (PUB/RADIO)") { opts[:conflate] = true }
+
+          o.separator "\nCompression:"
+          o.on("-z", "--compress", "Zstandard compression per frame") { opts[:compress] = true }
+
+          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 in Async context; use '-' for stdin. Scripts can register OMQ.outgoing/incoming") { |v|
+            require "omq" unless defined?(OMQ::VERSION)
+            opts[:scripts] << (v == "-" ? :stdin : (v.start_with?("./", "../") ? File.expand_path(v) : v))
+          }
+          o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (default: nproc); for non-pipe requires --recv-eval") { |v|
+            require "etc"
+            opts[:parallel] = v || Etc.nprocessors
+          }
+
+          o.separator "\nCURVE encryption (requires rbnacl or nuckle gem):"
+          o.on("--curve-server",         "Enable CURVE as server (generates keypair)") { opts[:curve_server] = true }
+          o.on("--curve-server-key KEY", "Enable CURVE as client (server's Z85 public key)") { |v| opts[:curve_server_key] = v }
+          o.on("--curve-crypto BACKEND", "Crypto backend: rbnacl (default if installed) or nuckle") { |v| opts[:curve_crypto] = v }
+          o.separator "  Env vars: OMQ_SERVER_KEY (client), OMQ_SERVER_PUBLIC + OMQ_SERVER_SECRET (server)"
+          o.separator "            OMQ_CURVE_CRYPTO (backend: rbnacl or nuckle)"
+
+          o.separator "\nOther:"
+          o.on("-v", "--verbose",   "Print connection events to stderr") { opts[:verbose] = true }
+          o.on("-q", "--quiet",     "Suppress message output")           { opts[:quiet] = true }
+          o.on(      "--transient", "Exit when all peers disconnect")    { opts[:transient] = true }
+          o.on("-V", "--version") {
+            if ENV["OMQ_DEV"]
+              require_relative "../../../../omq/lib/omq/version"
+            else
+              require "omq/version"
+            end
+            puts "omq-cli #{OMQ::CLI::VERSION} (omq #{OMQ::VERSION})"
+            exit
+          }
+          o.on("-h")             { puts o
+                                   exit }
+          o.on("--help")        { CLI.page "#{o}\n#{EXAMPLES}"
+                                   exit }
+          o.on("--examples")    { CLI.page EXAMPLES
+                                   exit }
+
+          o.separator "\nExit codes: 0 = success, 1 = error, 2 = timeout"
+        end
+
+        begin
+          parser.parse!(argv)
+        rescue OptionParser::ParseError => e
+          abort e.message
+        end
+
+        type_name = argv.shift
+        if type_name.nil?
+          abort parser.to_s if opts[:scripts].empty?
+          # bare script mode — type_name stays nil
+        elsif !SOCKET_TYPE_NAMES.include?(type_name.downcase)
+          abort "Unknown socket type: #{type_name}. Known: #{SOCKET_TYPE_NAMES.join(', ')}"
+        else
+          opts[:type_name] = type_name.downcase
+        end
+
+        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!(&normalize_ep)
+        opts[:in_endpoints].map!(&normalize_ep)
+        opts[:out_endpoints].map!(&normalize_ep)
+
+        opts
+      end
+
+
+      # Validates option combinations, aborting on invalid combos.
+      #
+      # @param opts [Hash] parsed options from {#parse}
+      # @return [void]
+      def validate!(opts)
+        return if opts[:type_name].nil?  # bare script mode
+
+        abort "-r- (stdin script) and -F- (stdin data) cannot both be used" if opts[:scripts]&.include?(:stdin) && opts[:file] == "-"
+
+        type_name = opts[:type_name]
+
+        if type_name == "pipe"
+          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]
+        abort "--subscribe is only valid for SUB"               if !opts[:subscribes].empty? && type_name != "sub"
+        abort "--join is only valid for DISH"                   if !opts[:joins].empty? && type_name != "dish"
+        abort "--group is only valid for RADIO"                 if opts[:group] && type_name != "radio"
+        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 must be >= 2" if opts[:parallel] < 2
+          if type_name == "pipe"
+            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?)
+          elsif RECV_ONLY.include?(type_name)
+            abort "-P/--parallel on #{type_name} requires --recv-eval (-e)" unless opts[:recv_expr]
+            abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if opts[:binds].any?
+          else
+            abort "-P/--parallel is only valid for pipe or recv-only socket types (#{RECV_ONLY.join(', ')})"
+          end
+        end
+
+        (opts[:connects] + opts[:binds]).each do |url|
+          abort "inproc not supported, use tcp:// or ipc://" if url.include?("inproc://")
+        end
+      end
+    end
+  end
+end

data/lib/omq/cli/client_server.rb

@@ -2,11 +2,10 @@
 
 module OMQ
   module CLI
-    class ClientRunner < ReqRunner
-    end
-
-
+    # Runner for SERVER and PEER sockets (draft; routing-id-based messaging).
     class ServerRunner < BaseRunner
+      include RoutingHelper
+
       private
 
 
@@ -27,28 +26,40 @@ module OMQ
           break if parts.nil?
           routing_id = parts.shift
           body       = @fmt.decompress(parts)
-
-          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
-            output([display_routing_id(routing_id), *body])
-            @sock.send_to(routing_id, @fmt.compress(body).first || "")
-          elsif config.data || config.file || !config.stdin_is_tty
-            reply = read_next
-            break unless reply
-            output([display_routing_id(routing_id), *body])
-            @sock.send_to(routing_id, @fmt.compress(reply).first || "")
-          end
+          break unless handle_server_request(routing_id, body)
           i += 1
           break if n && n > 0 && i >= n
         end
       end
 
 
+      def handle_server_request(routing_id, 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
+          output([display_routing_id(routing_id), *body])
+          @sock.send_to(routing_id, @fmt.compress(body).first || "")
+        elsif config.data || config.file || !config.stdin_is_tty
+          reply = read_next
+          return false unless reply
+          output([display_routing_id(routing_id), *body])
+          @sock.send_to(routing_id, @fmt.compress(reply).first || "")
+        end
+        true
+      end
+
+
       def monitor_loop(task)
-        receiver = task.async do
+        receiver = recv_async(task)
+        sender   = async_send_loop(task)
+        wait_for_loops(receiver, sender)
+      end
+
+
+      def recv_async(task)
+        task.async do
           n = config.count
           i = 0
           loop do
@@ -62,49 +73,11 @@ module OMQ
             break if n && n > 0 && i >= n
           end
         end
-
-        sender = task.async do
-          n = config.count
-          i = 0
-          sleep(config.delay) if config.delay
-          if config.interval
-            Async::Loop.quantized(interval: config.interval) do
-              parts = read_next
-              break unless 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_eval(parts) if parts
-          else
-            loop do
-              parts = read_next
-              break unless parts
-              send_targeted_or_eval(parts)
-              i += 1
-              break if n && n > 0 && i >= n
-            end
-          end
-        end
-
-        wait_for_loops(receiver, sender)
       end
 
 
-      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
-          send_msg(parts)
-        end
+      def send_to_peer(id, parts)
+        @sock.send_to(id, @fmt.compress(parts).first || "")
       end
     end
   end

data/lib/omq/cli/config.rb

@@ -2,14 +2,20 @@
 
 module OMQ
   module CLI
+    # Socket type names that only send messages.
     SEND_ONLY = %w[pub push scatter radio].freeze
+    # Socket type names that only receive messages.
     RECV_ONLY = %w[sub pull gather dish].freeze
 
+
+    # A bind or connect endpoint with its URL and direction.
     Endpoint = Data.define(:url, :bind?) do
+      # @return [Boolean] true if this endpoint connects rather than binds
       def connect? = !bind?
     end
 
 
+    # Frozen, Ractor-shareable configuration data class for a CLI invocation.
     Config = Data.define(
       :type_name,
       :endpoints,
@@ -41,6 +47,8 @@ module OMQ
       :verbose,
       :quiet,
       :echo,
+      :scripts,
+      :recv_maxsz,
       :curve_server,
       :curve_server_key,
       :curve_crypto,
@@ -48,7 +56,9 @@ module OMQ
       :has_zstd,
       :stdin_is_tty,
     ) do
+      # @return [Boolean] true if this socket type only sends
       def send_only? = SEND_ONLY.include?(type_name)
+      # @return [Boolean] true if this socket type only receives
       def recv_only? = RECV_ONLY.include?(type_name)
     end
   end