omq 0.28.2 → 0.28.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fdf548893d2ef3a060964a37aba4c6e7b28ef375376a98d1d609e8495801bf9
-  data.tar.gz: 3e0f418d932b6d1575dfeeae27b90faf70cddd1dcceeb47b82e9792164044e5c
+  metadata.gz: 8e5b7537e4771c3cf95f34bc0d6e48f5bcd49234234c7a4a2d7053e7dae0ce62
+  data.tar.gz: 2999ee7d27ae3e9c0b8235106d46aab741d5c17d4aa98ffd798ea91c2baa7082
 SHA512:
-  metadata.gz: 9310c7e4c955c5157a161032f93faadf9acc4a7beb0c20caf47470881de1a439354a728278016e79e16c9bd83eb2c1d99ebd5be6c9fef5f465a5b909c331328e
-  data.tar.gz: 48053e2af3a4a5925ff8adaacac87345dbf32dbceaa418035a945fa047752dd30d6dd0422a5947583b245aba754c04ae89e6e9415ee308cfbd4dbfa6b4c8e536
+  metadata.gz: 35164b7ce34f04f267124da8347979b481712d2127ba49ae2fbee180b55c48fa93aaa82955e66a8215204d90b9b5163dbb6b278565da504bb41cefb977888d43
+  data.tar.gz: c5529115fd854bb87e987feba2767491f3c85bc643e855aae0f1359df889966718613596a4807a6dd4a58c4134e641b89762ebc6d209e362523692ac072f7c35

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [0.28.3] - 2026-07-30
+
+### Added
+
+- Made `inproc://` a compatibility alias for `ruby://` when no backend or
+  plugin registers a real `inproc` transport.
+- Lazy-load the Rust backend from `omq/backend/rust`, matching
+  `omq/backend/libzmq`.
+
+### Removed
+
+- Removed the old `omq/rust` backend load path.
+- Removed the old `omq/ffi` backend load path and `backend: :ffi` alias.
+
 ## 0.28.2 - 2026-07-28
 
 ### Fixed

data/README.md

@@ -34,8 +34,9 @@ walkthrough of every major pattern with working code.
   knife for ØMQ. `gem install omq-cli`
 - **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)
+- **Every transport**: tcp, ipc (Unix domain sockets), ruby/inproc
+  (in-process queues). `inproc://` aliases `ruby://` unless a backend
+  provides native inproc
 - **Async-native**: built on fibers, non-blocking from the ground up
 - **Works outside Async too**: a shared IO thread handles sockets for callers
   that aren't inside a reactor, so simple scripts just work
@@ -214,6 +215,16 @@ echo "hello" | omq req -c tcp://localhost:5555
 
 See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentation.
 
+## Optional Rust backend
+
+Install `omq-backend-rust` for a Rust/omq-tokio backend. Same socket API,
+but connection handling runs in native code on a Tokio runtime.
+
+```ruby
+require "omq/backend/rust"
+push = OMQ::PUSH.new(backend: :rust)
+```
+
 ## Optional libzmq backend
 
 Install `omq-backend-libzmq` for a Ruby 4.0+ libzmq backend. Same socket
@@ -227,8 +238,7 @@ push = OMQ::PUSH.new(backend: :libzmq)
 ```
 
 Requires the `ffi` gem and a system libzmq 4.x. `ffi` is not a runtime
-dependency of `omq`. The old `require "omq/ffi"` and `backend: :ffi`
-names still work.
+dependency of `omq`.
 
 ## Companion Gems
 

data/lib/omq/engine.rb

@@ -192,8 +192,8 @@ module OMQ
     def bind(endpoint, parent: nil, **opts)
       OMQ.freeze_for_ractors!
       capture_parent_task(parent: parent)
-      transport = transport_for(endpoint)
-      listener  = transport.listener(endpoint, self, **opts)
+      endpoint, transport = resolve_endpoint(endpoint)
+      listener            = transport.listener(endpoint, self, **opts)
 
       start_accept_loops(listener)
 
@@ -214,15 +214,14 @@ module OMQ
     def connect(endpoint, parent: nil, **opts)
       OMQ.freeze_for_ractors!
       capture_parent_task(parent: parent)
-      validate_endpoint!(endpoint)
+      endpoint, transport = resolve_endpoint(endpoint)
+      validate_endpoint!(endpoint, transport)
 
       if endpoint.start_with?("ruby://")
         # Ruby in-process connect is synchronous and instant — no Dialer
-        transport = transport_for(endpoint)
         transport.connect(endpoint, self, **opts)
         @dialers[endpoint] = :ruby  # sentinel for reconnect intent
       else
-        transport = transport_for(endpoint)
         @dialers[endpoint] = transport.dialer(endpoint, self, **opts)
         emit_monitor_event(:connect_delayed, endpoint: endpoint)
         schedule_reconnect(endpoint, delay: 0)
@@ -239,6 +238,7 @@ module OMQ
     # @return [void]
     #
     def disconnect(endpoint)
+      endpoint = canonical_endpoint(endpoint)
       @dialers.delete(endpoint)
       close_connections_at(endpoint)
     end
@@ -251,6 +251,7 @@ module OMQ
     # @return [void]
     #
     def unbind(endpoint)
+      endpoint = canonical_endpoint(endpoint)
       listener = @listeners.delete(endpoint) or return
 
       listener.stop
@@ -608,8 +609,8 @@ module OMQ
     # @raise [ArgumentError] if the scheme is not registered
     #
     def transport_for(endpoint)
-      scheme    = endpoint[/\A([^:]+):\/\//, 1]
-      transport = self.class.transports[scheme]
+      scheme    = scheme_for(endpoint)
+      transport = registered_transport(scheme)
 
       unless transport
         raise ArgumentError, "unsupported transport: #{endpoint}"
@@ -701,15 +702,65 @@ module OMQ
     # @param endpoint [String]
     # @raise [ArgumentError] if the transport rejects the endpoint
     #
-    def validate_endpoint!(endpoint)
-      transport = transport_for(endpoint)
-
+    def validate_endpoint!(endpoint, transport)
       if transport.respond_to?(:validate_endpoint!)
         transport.validate_endpoint!(endpoint)
       end
     end
 
 
+    # Resolves transport aliases before the endpoint is stored in
+    # listener, dialer, or connection maps.
+    #
+    # @param endpoint [String]
+    # @return [Array(String, Module)]
+    #
+    def resolve_endpoint(endpoint)
+      transport = transport_for(endpoint)
+      if transport.respond_to?(:canonical_endpoint)
+        endpoint = transport.canonical_endpoint(endpoint)
+      end
+
+      [endpoint, transport]
+    end
+
+
+    # Best-effort normalization for disconnect/unbind. Unknown schemes
+    # stay as-is so those calls remain no-ops instead of raising.
+    #
+    # @param endpoint [String]
+    # @return [String]
+    #
+    def canonical_endpoint(endpoint)
+      transport = registered_transport(scheme_for(endpoint))
+      return endpoint unless transport&.respond_to?(:canonical_endpoint)
+
+      transport.canonical_endpoint(endpoint)
+    end
+
+
+    # Looks up a registered transport. If no real inproc transport is
+    # registered, inproc:// falls back to the Ruby in-process transport.
+    #
+    # @param scheme [String, nil]
+    # @return [Module, nil]
+    #
+    def registered_transport(scheme)
+      self.class.transports[scheme] ||
+        (scheme == "inproc" ? self.class.transports["ruby"] : nil)
+    end
+
+
+    # Extracts the URI scheme from an endpoint.
+    #
+    # @param endpoint [String]
+    # @return [String, nil]
+    #
+    def scheme_for(endpoint)
+      endpoint[/\A([^:]+):\/\//, 1]
+    end
+
+
     # Starts the listener's accept loops on the socket-level barrier
     # and routes accepted IOs through {#handle_accepted}.
     #

data/lib/omq/socket.rb

@@ -330,8 +330,7 @@ module OMQ
     def require_backend(name)
       path = case name
              when :libzmq then "omq/backend/libzmq"
-             when :ffi then "omq/ffi"
-             when :rust then "omq/rust"
+             when :rust then "omq/backend/rust"
              end
       return unless path
 

data/lib/omq/transport/inproc.rb

@@ -13,8 +13,8 @@ module OMQ
     # serialization. Parts are already frozen by Writable#send, so the
     # receiver sees the same immutable contract as ZMTP transports.
     #
-    # The inproc:// scheme is reserved for native backends (FFI/libzmq,
-    # Rust/omq-tokio) which have their own in-process registries.
+    # inproc:// is treated as a compatibility alias by the Ruby backend
+    # unless a backend or plugin registers a real inproc transport.
     #
     module Inproc
       Engine.transports["ruby"] = self
@@ -38,6 +38,17 @@ module OMQ
         attr_reader :registry
 
 
+        # Canonicalizes compatibility aliases so ruby:// and inproc://
+        # share the same in-process endpoint namespace.
+        #
+        # @param endpoint [String]
+        # @return [String]
+        #
+        def canonical_endpoint(endpoint)
+          endpoint.sub(/\Ainproc:\/\//, "ruby://")
+        end
+
+
         # Creates a bound inproc listener.
         #
         # @param endpoint [String] e.g. "ruby://my-endpoint"
@@ -46,6 +57,8 @@ module OMQ
         # @raise [ArgumentError] if endpoint is already bound
         #
         def listener(endpoint, engine, **)
+          endpoint = canonical_endpoint(endpoint)
+
           @mutex.synchronize do
             if @registry.key?(endpoint)
               raise ArgumentError, "endpoint already bound: #{endpoint}"
@@ -68,6 +81,7 @@ module OMQ
         # @return [void]
         #
         def connect(endpoint, engine, **)
+          endpoint     = canonical_endpoint(endpoint)
           bound_engine = @mutex.synchronize { @registry[endpoint] }
           bound_engine ||= await_bind(endpoint, engine) or return
           establish_link(engine, bound_engine, endpoint)
@@ -80,6 +94,7 @@ module OMQ
         # @return [void]
         #
         def unbind(endpoint)
+          endpoint = canonical_endpoint(endpoint)
           @mutex.synchronize { @registry.delete(endpoint) }
         end
 

data/lib/omq/version.rb

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

metadata

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