omq-cli 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c13378d48e8072d5537c35b476340431cd3c735f4a9ef6bea93036b776da2fa5
-  data.tar.gz: 6fffa2d883b8a332b81307c874bc59ac6600997bc2cf954159aa82c14db9ed1a
+  metadata.gz: 92ca3f7bf414254b6ab93d4ff6282e1ca714292f6d7119c85cdb8d5f8e2e85c5
+  data.tar.gz: '021193bf3cf3785355f9592087ca1b182b50e4fb43fb8cf4a5590b9b75390da5'
 SHA512:
-  metadata.gz: e35a88c00fdfbee35163bfc6bf7059f5b89fa97c735523932e76a61b87eafb84bbb9be29ba918cc81f394ff0879cd8978d5075d84ef234d75b30bde09b458c28
-  data.tar.gz: 728b01ef1873bf8f7651f7cc56f0c88c6d8d147a1ee5a0b42c99b6eb0762b9c8159d921c1db6a0dd352cd2c040529bbd33d0b1be527997fc70156595fe1b2bfc
+  metadata.gz: 34500b01e5928851464136a9aeb9a5e2d6c76df95ae14f221068fcc399546b48abe662f0fdd68a9b1a73bde52b2fb20b3085dd9d1a14a08426f7baa40c0f224f
+  data.tar.gz: '0319a006c9bfe02acc713676f6db87dfb93314b059af1cc0c25a8a7efb2abfa70ecaf9b5817047332861a8a71f77a5711608fe6fab7d111b7349b02704029e5f'

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.19.0 — 2026-08-03
+
+- **Rust backend selection via `--backend rust`.** Loads
+  `omq-backend-rust` and passes `backend: :rust` to socket
+  constructors.
+- **Monorepo import.** `omq-cli` now lives under `gems/omq-cli` in
+  `omq.rb` and participates in monorepo test and release tasks.
+
 ## 0.17.1 — 2026-05-04
 
 - bump deps

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://img.shields.io/gem/v/omq-cli?color=e9573f)](https://rubygems.org/gems/omq-cli)
 [![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)
+[![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%204.0-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
 A command-line tool that speaks every ZeroMQ socket pattern, transforms
 messages with inline Ruby, parallelizes across Ractors, encrypts with CURVE,
@@ -75,6 +75,21 @@ omq push -c@work                     # IPC abstract namespace (@name → ipc://@
 Multiple endpoints are allowed — `omq pull -b tcp://:5557 -b tcp://:5558` binds both.
 Pipe takes two positional endpoints (input, output) or uses `--in`/`--out` for multiple per side.
 
+## Backends
+
+The default backend is the pure Ruby engine.
+
+| Flag | Backend |
+|------|---------|
+| `--backend ruby` | Pure Ruby backend, default |
+| `--backend rust` | Rust backend from `omq-backend-rust` |
+| `--backend libzmq` | libzmq backend from `omq-backend-libzmq` |
+| `--backend ffi` or `--ffi` | Compatibility name for the libzmq backend |
+
+Optional backends must be installed next to `omq-cli`.
+Set `OMQ_BACKEND=ruby|rust|libzmq` to choose a default backend.
+Use `-v` to print the effective backend at startup.
+
 ## Socket types
 
 ### Unidirectional (send-only / recv-only)

data/lib/omq/cli/base_runner.rb

@@ -25,6 +25,7 @@ module OMQ
       # @return [void]
       def call(task)
         set_process_title
+        log_backend
         setup_socket
         start_event_monitor
         maybe_start_transient_monitor(task)
@@ -557,6 +558,11 @@ module OMQ
       end
 
 
+      def log_backend
+        log("backend: #{SocketSetup.backend_name(config)}")
+      end
+
+
       # Always attached so protocol-level disconnect events can kill
       # the socket. Verbose gating lives inside the callback:
       #   -vv  log connect/disconnect/retry/timeout events

data/lib/omq/cli/cli_parser.rb

@@ -277,7 +277,8 @@ module OMQ
         recv_maxsz:       nil,
         curve_server:     false,
         curve_server_key: nil,
-        crypto:     nil,
+        crypto:           nil,
+        backend:          :ruby,
         ffi:              false,
       }.freeze
 
@@ -331,6 +332,7 @@ module OMQ
       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
+        explicit_backend = false
 
         parser = OptionParser.new do |o|
           o.banner = "Usage: omq TYPE [options]\n\n" \
@@ -462,8 +464,6 @@ module OMQ
           o.on("--curve-server-key KEY", "Enable CURVE as client (server's Z85 public key)") { |v| opts[:curve_server_key] = v }
           o.on("--crypto BACKEND", "Crypto backend: rbnacl (default) or nuckle (pure Ruby, DANGEROUS)") { |v| opts[:crypto] = v }
           o.separator "  Install libsodium: apt install libsodium-dev / brew install libsodium"
-          o.separator "  Env vars: OMQ_SERVER_KEY (client), OMQ_SERVER_PUBLIC + OMQ_SERVER_SECRET (server)"
-          o.separator "            OMQ_CRYPTO (backend: rbnacl or nuckle)"
 
           o.separator "\nOther:"
           o.on("-v", "--verbose",   "Verbosity: -v endpoints, -vv events, -vvv messages") { opts[:verbose] += 1 }
@@ -472,20 +472,22 @@ module OMQ
           }
           o.on("-q", "--quiet",     "Suppress message output")           { opts[:quiet] = true }
           o.on(      "--transient", "Exit when all peers disconnect")    { opts[:transient] = true }
-          o.on(      "--ffi",       "Use libzmq FFI backend (requires omq-ffi gem + system libzmq 4.x)") do
-            begin
-              require "omq/ffi"
-            rescue LoadError => e
-              abort "omq: --ffi requires the omq-ffi gem and system libzmq 4.x (#{e.message})"
-            end
+          o.on(      "--backend BACKEND", %w[ruby rust libzmq ffi],
+                     "Socket backend: ruby, rust, or libzmq") do |v|
+            backend = normalize_backend(v.to_sym)
+            load_socket_backend!(backend)
+            opts[:backend] = backend
+            opts[:ffi] = false
+            explicit_backend = true
+          end
+          o.on(      "--ffi",       "Alias for --backend libzmq") do
+            load_socket_backend!(:libzmq)
+            opts[:backend] = :libzmq
             opts[:ffi] = true
+            explicit_backend = true
           end
           o.on("-V", "--version") {
-            if ENV["OMQ_DEV"]
-              require_relative "../../../../omq/lib/omq/version"
-            else
-              require "omq/version"
-            end
+            require "omq/version"
             puts "omq-cli #{OMQ::CLI::VERSION} (omq #{OMQ::VERSION})"
             exit
           }
@@ -496,6 +498,12 @@ module OMQ
           o.on("--examples")    { CLI.page EXAMPLES
                                    exit }
 
+          o.separator "\nEnv vars:"
+          o.separator "  OMQ_BACKEND (socket backend: ruby, rust, or libzmq)"
+          o.separator "  OMQ_SERVER_KEY (client CURVE server key)"
+          o.separator "  OMQ_SERVER_PUBLIC + OMQ_SERVER_SECRET (server CURVE keypair)"
+          o.separator "  OMQ_CRYPTO (CURVE crypto backend: rbnacl or nuckle)"
+
           o.separator "\nExit codes: 0 = success, 1 = error, 2 = timeout"
         end
 
@@ -517,6 +525,8 @@ module OMQ
           opts[:type_name] = type_name.downcase
         end
 
+        apply_env_backend!(opts) if opts[:type_name] && !explicit_backend
+
         # Host shorthand (tcp://*:PORT, tcp://:PORT, tcp://localhost:PORT)
         # is normalized inside OMQ::Transport::TCP — see its
         # #normalize_bind_host / #normalize_connect_host / #loopback_host.
@@ -567,6 +577,53 @@ module OMQ
       end
 
 
+      # Loads an optional OMQ socket backend while parsing backend flags.
+      #
+      def load_socket_backend!(backend)
+        case backend
+        when :ruby
+          nil
+        when :rust
+          require "omq/backend/rust"
+        when :libzmq
+          require "omq/backend/libzmq"
+        end
+      rescue LoadError => e
+        case backend
+        when :rust
+          abort "omq: --backend rust requires the omq-backend-rust gem (#{e.message})"
+        when :libzmq
+          abort "omq: --backend #{backend} requires the omq-backend-libzmq gem and system libzmq 4.x (#{e.message})"
+        else
+          abort "omq: could not load backend #{backend} (#{e.message})"
+        end
+      end
+
+
+      # Applies OMQ_BACKEND when no explicit backend flag was given.
+      #
+      def apply_env_backend!(opts)
+        env_backend = ENV["OMQ_BACKEND"]
+        return if env_backend.nil? || env_backend.empty?
+
+        unless %w[ruby rust libzmq].include?(env_backend)
+          abort "omq: invalid OMQ_BACKEND=#{env_backend.inspect} (use ruby, rust, or libzmq)"
+        end
+
+        backend = env_backend.to_sym
+        load_socket_backend!(backend)
+        opts[:backend] = backend
+        opts[:ffi] = false
+      end
+
+
+      # Maps legacy CLI spelling to the backend name supported by omq.
+      #
+      def normalize_backend(backend)
+        backend == :ffi ? :libzmq : backend
+      end
+
+
       # Validates option combinations, aborting on invalid combos.
       #
       # @param opts [Hash] parsed options from {#parse}
@@ -625,7 +682,7 @@ module OMQ
         end
 
         (opts[:connects] + opts[:binds]).each do |url|
-          abort "inproc not supported, use tcp:// or ipc://" if url.include?("inproc://")
+          abort "ruby:// not supported in CLI, use tcp:// or ipc://" if url.include?("ruby://")
         end
 
         all_urls = if type_name == "pipe"

data/lib/omq/cli/config.rb

@@ -62,6 +62,7 @@ module OMQ
       :curve_server,
       :curve_server_key,
       :crypto,
+      :backend,
       :ffi,
       :stdin_is_tty,
     ) do

data/lib/omq/cli/parallel_worker.rb

@@ -48,7 +48,7 @@ module OMQ
 
 
       def setup_socket
-        @sock = @config.ffi ? OMQ.const_get(@socket_sym).new(backend: :ffi) : OMQ.const_get(@socket_sym).new
+        @sock = OMQ.const_get(@socket_sym).new(**OMQ::CLI::SocketSetup.backend_kwargs(@config))
         OMQ::CLI::SocketSetup.apply_options(@sock, @config)
         OMQ::CLI::SocketSetup.apply_recv_maxsz(@sock, @config)
         @sock.identity = @config.identity if @config.identity

data/lib/omq/cli/pipe.rb

@@ -46,6 +46,7 @@ module OMQ
 
       def run_sequential(task)
         set_pipe_process_title
+        log_backend
         in_eps, out_eps = resolve_endpoints
         @pull, @push = build_pull_push(in_eps, out_eps)
         compile_expr
@@ -83,7 +84,7 @@ module OMQ
 
 
       def build_pull_push(in_eps, out_eps)
-        kwargs = config.ffi ? { backend: :ffi } : {}
+        kwargs = SocketSetup.backend_kwargs(config)
 
         pull = OMQ::PULL.new(**kwargs).tap do |sock|
           SocketSetup.apply_options(sock, config)
@@ -152,6 +153,7 @@ module OMQ
 
       def run_parallel(task)
         set_pipe_process_title
+        log_backend
         OMQ.freeze_for_ractors!
 
         in_eps, out_eps      = resolve_endpoints
@@ -240,6 +242,12 @@ module OMQ
         end
       end
 
+
+      def log_backend
+        return unless config.verbose >= 1
+        $stderr.write("#{Term.log_prefix(config.timestamps)}omq: backend: #{SocketSetup.backend_name(config)}\n")
+      end
+
     end
   end
 end

data/lib/omq/cli/pipe_worker.rb

@@ -38,7 +38,7 @@ module OMQ
 
 
       def setup_sockets
-        kwargs = @config.ffi ? { backend: :ffi } : {}
+        kwargs = OMQ::CLI::SocketSetup.backend_kwargs(@config)
         @pull = OMQ::PULL.new(**kwargs)
         @push = OMQ::PUSH.new(**kwargs)
         OMQ::CLI::SocketSetup.apply_options(@pull, @config)

data/lib/omq/cli/socket_setup.rb

@@ -86,6 +86,31 @@ module OMQ
       end
 
 
+      # Returns socket constructor kwargs for the selected backend.
+      #
+      def self.backend_kwargs(config)
+        backend = backend_name(config)
+        return {} if backend.nil? || backend == :ruby
+
+        { backend: backend }
+      end
+
+
+      # Returns the effective backend name after legacy --ffi handling.
+      #
+      def self.backend_name(config)
+        backend = if config.respond_to?(:ffi) && config.ffi
+                    :libzmq
+                  elsif config.respond_to?(:backend)
+                    config.backend
+                  else
+                    :ruby
+                  end
+        backend = :libzmq if backend == :ffi
+        backend || :ruby
+      end
+
+
       # Apply common socket options from +config+ to +sock+.
       #
       def self.apply_options(sock, config)
@@ -105,7 +130,7 @@ module OMQ
       # Create and fully configure a socket from +klass+ and +config+.
       #
       def self.build(klass, config)
-        sock = config.ffi ? klass.new(backend: :ffi) : klass.new
+        sock = klass.new(**backend_kwargs(config))
         sock.conflate = true if config.conflate && %w[pub radio].include?(config.type_name)
         apply_options(sock, config)
         apply_recv_maxsz(sock, config)

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.18.0"
+    VERSION = "0.19.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: '0.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: '0.28'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -132,7 +132,7 @@ files:
 - lib/omq/cli/term.rb
 - lib/omq/cli/transient_monitor.rb
 - lib/omq/cli/version.rb
-homepage: https://github.com/paddor/omq-cli
+homepage: https://github.com/zeromq/omq.rb/tree/main/gems/omq-cli
 licenses:
 - ISC
 metadata: {}
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: ZeroMQ CLI — pipe, filter, and transform messages from the terminal
 test_files: []