omq 0.28.2 → 0.28.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fdf548893d2ef3a060964a37aba4c6e7b28ef375376a98d1d609e8495801bf9
-  data.tar.gz: 3e0f418d932b6d1575dfeeae27b90faf70cddd1dcceeb47b82e9792164044e5c
+  metadata.gz: 4a7d2541a2f4b738d4afc495979d3d9a6d36eb7dba15c16b69715a818d8a98c7
+  data.tar.gz: 5237a3a57df244d8576565600192b056d74f9cc1538c613816906f19703a11e3
 SHA512:
-  metadata.gz: 9310c7e4c955c5157a161032f93faadf9acc4a7beb0c20caf47470881de1a439354a728278016e79e16c9bd83eb2c1d99ebd5be6c9fef5f465a5b909c331328e
-  data.tar.gz: 48053e2af3a4a5925ff8adaacac87345dbf32dbceaa418035a945fa047752dd30d6dd0422a5947583b245aba754c04ae89e6e9415ee308cfbd4dbfa6b4c8e536
+  metadata.gz: 6aab453842918ebec2116dd070ad83b79a82d410cd55f6c4f198e1fce8e06cc5b050f7a3b01baadb3d09249d489ad9c9236dff9d07c5a2e26b0e3781d7c44f75
+  data.tar.gz: ef4e5e965f0aa20f9037e5bd7e782ac5fcce5bb1b939b3bf7f5b35c546ac8395a4b96670a67d0086fd0a0f201a8d3050efdb769c2f23f120316d4528607c64bc

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.28.4] - 2026-07-30
+
+### Fixed
+
+- Exposed `conflate` through the public socket option accessors.
+
+## [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

@@ -55,6 +55,7 @@ module OMQ
       :write_timeout,         :write_timeout=,
       :router_mandatory,      :router_mandatory=,
       :router_mandatory?,
+      :conflate,              :conflate=,
       :reconnect_interval,    :reconnect_interval=,
       :heartbeat_interval,    :heartbeat_interval=,
       :heartbeat_ttl,         :heartbeat_ttl=,
@@ -330,8 +331,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.4"
 end

metadata

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