omnes 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68a21237b0a6749b982b68b732e134e79198654e92bc92824053c103280dd2bc
-  data.tar.gz: a282239e0f4eb501e3eb113066f1753ebfc859364cddbf07fc9200efbcad6bad
+  metadata.gz: fa683052724423d76ee0b417e84e2d0ed954c47b50382eead7e8e85942eea8c0
+  data.tar.gz: e0690f6d8852c9ab3ff1d4e2fb7c6e68f82aca657fe6b684a503f14a085e0efc
 SHA512:
-  metadata.gz: 929b7a25696e1eaeb3ece983d46ccada028530f859483ebf80a65ce0b603360696a7b8304dfb8d801d543f26206024163154baa6223991a79f06fa58329cf2eb
-  data.tar.gz: fe5a4306002b44153992db90f13c54b76b211cfb7eb22975dfe2eb01a8fafd04bd7421dad414e2f82b38c5af00b0c466f52a624f0c0ce27f3ac1e7e711dbb382
+  metadata.gz: 41a41801b5b133640bca4c98f004163382fe6747848595a70fa1404c9638cca304cb8e95c0f7b6b81ebcebe15df1df32a4c28274b252d38d8d66fac572d988dd
+  data.tar.gz: 76a23f76d4a007cfadcf59140168934f2653804f65c7cbdad21a70e3dcd71177438b4eb2174da4b421d07fe694d793da271a5e40c2e61a2d5b77bd915e8869ce

data/CHANGELOG.md

@@ -4,8 +4,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.0] - 2022-04-15
+
+### Added
+- Be able to fetch subscriptions by id from the bus [#1](https://github.com/nebulab/omnes/pull/1).
+- Use ad-hoc configuration system (and make Omnes zero-deps) [#2](https://github.com/nebulab/omnes/pull/2).
+- Bind a publication context to subscriptions [#3](https://github.com/nebulab/omnes/pull/3).
 
 ## [0.1.0] - 2022-03-23
 
-[Unreleased]: https://github.com/nebulab/omnes/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/nebulab/omnes/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/nebulab/omnes/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/nebulab/omnes/releases/tag/v0.1.0

data/Gemfile.lock

@@ -2,7 +2,6 @@ PATH
   remote: .
   specs:
     omnes (0.1.0)
-      dry-configurable (~> 0.14)
 
 GEM
   remote: https://rubygems.org/
@@ -19,11 +18,6 @@ GEM
     concurrent-ruby (1.1.9)
     connection_pool (2.2.5)
     diff-lcs (1.5.0)
-    dry-configurable (0.14.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.6)
-    dry-core (0.7.1)
-      concurrent-ruby (~> 1.0)
     globalid (1.0.0)
       activesupport (>= 5.0)
     i18n (1.10.0)

data/README.md

@@ -37,7 +37,7 @@ The following examples will use the direct `Omnes::Bus` instance. The only
 difference for the mixing use case is that the methods are directly called in
 the including instance.
 
-### Registering events
+## Registering events
 
 Before being able to work with a given event, its name (which must be a
 `Symbol`) must be registered:
@@ -46,9 +46,9 @@ Before being able to work with a given event, its name (which must be a
 bus.register(:order_created)
 ```
 
-### Publishing events
+## Publishing events
 
-An event can be anything responding to a method `:name`, which must match with a
+An event can be anything responding to a method `:omnes_event_name`, which must match with a
 registered name.
 
 Typically, there're two main ways to generate events.
@@ -73,8 +73,7 @@ features, such as event persistence, can't be reliably built on top of them.
 
 You can also publish an instance of a class including
 [`Omnes::Event`](lib/omnes/event.rb). The only fancy thing it provides is an
-OOTB event name generated based on the class name. In fact, you can use
-anything responding to `#omnes_event_name`.
+OOTB event name generated based on the class name.
 
 ```ruby
 class OrderCreatedEvent
@@ -105,7 +104,7 @@ Omnes.config.event.name_builder = event_name_as_class
 Instance-backed events provide a well-defined structure, and other features,
 like event persistence, can be added on top of them.
 
-### Subscribing to events
+## Subscribing to events
 
 You can subscribe to a specific event to run some code whenever it's published.
 The event is yielded to the subscription block:
@@ -150,7 +149,7 @@ bus.subscribe(:order_created, OrderCreationEmailSubscription.new)
 However, see [Event subscribers](#event-subscribers) section bellow for a more powerful way
 to define standalone event handlers.
 
-#### Global subscriptions
+### Global subscriptions
 
 You can also create a subscription that will run for all events:
 
@@ -170,7 +169,7 @@ end
 bus.subscribe_to_all(LogEventsSubscription.new)
 ```
 
-#### Custom matcher subscriptions
+### Custom matcher subscriptions
 
 Custom event matchers can be defined. A matcher is something responding to
 `#call` and taking the event as an argument. It must return `true` or `false`
@@ -184,6 +183,22 @@ bus.subscribe_with_matcher(ORDER_EVENTS_MATCHER) do |event|
 end
 ```
 
+### Referencing subscriptions
+
+For all subscription methods we've seen, an `Omnes::Subscription` instance is
+returned. Holding that reference can be useful for [debugging](#debugging) and
+[testing](#testing) purposes.
+
+Often though, you won't have the reference at hand when you need it.
+Thankfully, you can provide a subscription identifier on subscription time and
+use it later to fetch the subscription instance from the bus. A subscription
+identifier needs to be a `Symbol`:
+
+```ruby
+bus.subscribe(:order_created, OrderCreationEmailSubscription.new, id: :order_created_email)
+subscription = bus.subscription(:send_confirmation_email)
+```
+
 ## Event subscribers
 
 Events subscribers offer a way to define event subscriptions from a custom
@@ -207,7 +222,11 @@ class OrderCreationEmailSubscriber
     service.send(number: event.number, email: event.user_email)
   end
 end
+```
 
+You add the subscriptions by calling the `#subscribe_to` method on an instance:
+
+```ruby
 OrderCreationEmailSubscriber.new.subscribe_to(bus)
 ```
 
@@ -246,6 +265,21 @@ class OrderSubscriber
 end
 ```
 
+Likewise, you can provide [identifiers to reference
+subscriptions](#referencing-subscriptions):
+
+```ruby
+handle :order_created, with: :send_confirmation_email, id: :order_creation_email_subscriber
+```
+
+As you can subscribe multiple instances of a subscriber to the same bus, you
+might need to create a different identifier for each of them. For those cases,
+you can pass a lambda taking the subscriber instance:
+
+```ruby
+handle :order_created, with: :send_confirmation_email, id: ->(subscriber) { :"#{subscriber.id}_order_creation_email_subscriber" }
+```
+
 ### Autodiscovering event handlers
 
 You can let the event handlers to be automatically discovered.You need to
@@ -292,6 +326,12 @@ class OrderCreationEmailSubscriber
 end
 ```
 
+The strategy can also be globally set:
+
+```ruby
+Omnes.config.subscriber.autodiscover_strategy = AUTODISCOVER_STRATEGY
+```
+
 ### Adapters
 
 Subscribers are not limited to use a method as event handler. They can interact
@@ -389,7 +429,8 @@ Omnes.config.subscriber.adapter.active_job.serializer = :serialized_payload.to_p
 #### Custom adapters
 
 Custom adapters can be built. They need to implement a method `#call` taking
-the instance of `Omnes::Subscriber` and the event.
+the instance of `Omnes::Subscriber`, the event and, optionally, the publication
+context (see [debugging subscriptions](#subscription)).
 
 Here's a custom adapter executing a subscriber method in a different
 thread (we add an extra argument for the method name, and we partially apply it
@@ -402,7 +443,6 @@ end
 
 class OrderCreationEmailSubscriber
   include Omnes::Subscriber
-  include Sidekiq::Job
   
   handle :order_created, with: THREAD_ADAPTER.curry[:order_created]
   
@@ -413,8 +453,8 @@ end
 ```
 
 Alternatively, adapters can be curried and only take the instance as an
-argument, returning a one-argument callable taking the event. For instance, we
-could also have defined the thread adapter like this:
+argument, returning a callable taking the event. For instance, we could also
+have defined the thread adapter like this:
 
 ```ruby
 class ThreadAdapter
@@ -440,10 +480,8 @@ handle :order_created, with: ThreadAdapter.new(:order_created)
 
 ### Unsubscribing
 
-When you create a subscription, an instance of
-[`Omnes::Subscription`](lib/omnes/subscription.rb) is returned (or an array for
-`Omnes::Subscriber`). It can be used to unsubscribe it in case you need to
-debug some behavior.
+You can unsubscribe a given subscription by passing its
+[reference](#referencing-subscriptions) to `Omnes::Bus#unsubscribe`:
 
 ```ruby
 subscription = bus.subscribe(:order_created, OrderCreationEmailSubscription.new)
@@ -478,10 +516,10 @@ When you publish an event, you get back an
 attributes that allow observing what happened:
 
 - `#event` contains the event instance that has been published.
-- `#caller_location` refers to the publication caller.
-- `#time` is the time stamp for the publication.
 - `#executions` contains an array of
   `Omnes::Execution`(lib/omnes/execution.rb). Read more below.
+- `#context` is an instance of
+  [`Omnes::PublicationContext`](lib/omnes/publication_context.rb).
   
 `Omnes::Execution` represents a subscription individual execution. It contains
 the following attributes:
@@ -491,6 +529,40 @@ the following attributes:
 - `#benchmark` of the operation.
 - `#time` is the time where the execution started.
 
+`Omnes::PublicationContext` represents the shared context for all triggered
+executions. See [Subscription][#subscription] for details.
+
+### Subscription
+
+If your subscription block or callable object takes a second argument, it'll
+contain an instance of an
+[`Omnes::PublicationContext`](lib/omnes/publication_context.rb). It allows you
+to inspect what triggered a given execution from within that execution code. It
+contains:
+
+- `#caller_location` refers to the publication caller.
+- `#time` is the time stamp for the publication.
+
+```ruby
+class OrderCreationEmailSubscriber
+  include Omnes::Subscriber
+  
+  handle :order_created, with: :send_confirmation_email
+
+  def send_confirmation_email(event, publication_context)
+    # debugging
+    abort(publication_context.caller_location.inspect)
+
+    OrderCreationEmail.send(number: event.number, email: event.user_email)
+  end
+end
+```
+
+In case you're developing your own async adapter, you can call `#serialized` on
+an instance of `Omnes::PublicationContext` to get a serialized version of it.
+It'll return a `Hash` with `"caller_location"` and `"time"` keys, and the
+respective `String` representations as values.
+
 ## Testing
 
 Ideally, you wouldn't need big setups to test your event-driven behavior. You
@@ -521,11 +593,30 @@ end
 bus.publish(:order_deleted, number: order.number) # `deletion_subscription` will run
 ```
 
-Remember that the array of created subscriptions is returned on `Omnes::Subscriber#subscribe_to`.
+Remember that you can get previous [subscription
+references](#referencing-subscriptions) thanks to
+subscription identifiers.
 
 There's also a specialized `Omnes::Bus#performing_nothing` method that runs no
 subscriptions for the duration of the block.
 
+## Configuration
+
+We've seen the relevant configurable settings in the corresponding sections.
+You can also access the configuration in the habitual block syntax:
+
+```ruby
+Omnes.configure do |config|
+  config.subscriber.adapter.sidekiq.serializer = :serialized_payload.to_proc
+end
+```
+
+Finally, nested settings can also be set directly from the affected class. E.g.:
+
+```ruby
+Omnes::Subscriber::Adapter::Sidekiq.config.serializer = :serialized_payload.to_proc
+```
+
 ## Recipes
 
 ### Rails

data/lib/omnes/bus.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "omnes/publication"
+require "omnes/publication_context"
 require "omnes/registry"
 require "omnes/subscription"
 require "omnes/unstructured_event"
@@ -22,8 +23,8 @@ module Omnes
   # bus.register(:foo)
   # ```
   #
-  # An event can be anything responding to a method `:name` which, needless to
-  # say, must match with a registered name.
+  # An event can be anything responding to a method `:omes_event_name` which,
+  # needless to say, must match with a registered name.
   #
   # Typically, there're two main ways to generate events.
   #
@@ -104,6 +105,21 @@ module Omnes
   #
   # bus.subscribe_with_matcher(matcher, MySubscription.new)
   # ```
+  #
+  # For all previous subscription methods, a subscription object is returned.
+  # You can supply a subscription id to it to be able to fetch it from the bus
+  # later on:
+  #
+  # ```
+  # subscription = bus.subscribe(:foo, MySubscription.new, id: :foo_sub)
+  # bus.subscription(:foo_sub) == subscription #=> true
+  # ```
+  #
+  # A subscription can be referenced when you want to unsubscribe:
+  #
+  # ```
+  # bus.unsubscribe(subscription)
+  # ```
   class Bus
     # @api private
     def self.EventType(value, **payload)
@@ -168,13 +184,13 @@ module Omnes
       publication_time = Time.now.utc
       event = self.class.EventType(event, **payload)
       registry.check_event_name(event.omnes_event_name)
-      executions = execute_subscriptions_for_event(event)
+      publication_context = PublicationContext.new(caller_location: caller_location, time: publication_time)
+      executions = execute_subscriptions_for_event(event, publication_context)
 
       Publication.new(
         event: event,
         executions: executions,
-        caller_location: caller_location,
-        time: publication_time
+        context: publication_context
       )
     end
 
@@ -182,37 +198,42 @@ module Omnes
     #
     # @param event_name [Symbol] Name of the event
     # @param callable [#call] Subscription callback taking the event
+    # @param id [Symbol] Unique identifier for the subscription
     # @yield [event] Subscription callback if callable is not given
     #
     # @return [Omnes::Subscription]
     #
     # @raise [Omnes::UnknownEventError] When event name has not been registered
-    def subscribe(event_name, callable = nil, &block)
+    def subscribe(event_name, callable = nil, id: Subscription.random_id, &block)
       registry.check_event_name(event_name)
 
-      subscribe_with_matcher(Subscription::SINGLE_EVENT_MATCHER.curry[event_name], callable, &block)
+      subscribe_with_matcher(Subscription::SINGLE_EVENT_MATCHER.curry[event_name], callable, id: id, &block)
     end
 
     # Adds a subscription for all events
     #
     # @param callable [#call] Subscription callback taking the event
+    # @param id [Symbol] Unique identifier for the subscription
     # @yield [event] Subscription callback if callable is not given
     #
     # @return [Omnes::Subscription]
-    def subscribe_to_all(callable = nil, &block)
-      subscribe_with_matcher(Subscription::ALL_EVENTS_MATCHER, callable, &block)
+    def subscribe_to_all(callable = nil, id: Subscription.random_id, &block)
+      subscribe_with_matcher(Subscription::ALL_EVENTS_MATCHER, callable, id: id, &block)
     end
 
     # Adds a subscription with given matcher
     #
     # @param matcher [#call] Callable taking the event and returning a boolean
     # @param callable [#call] Subscription callback taking the event
+    # @param id [Symbol] Unique identifier for the subscription
     # @yield [event] Subscription callback if callable is not given
     #
     # @return [Omnes::Subscription]
-    def subscribe_with_matcher(matcher, callable = nil, &block)
+    def subscribe_with_matcher(matcher, callable = nil, id: Subscription.random_id, &block)
+      raise DuplicateSubscriptionIdError.new(id: id, bus: self) if subscription(id)
+
       callback = callable || block
-      Subscription.new(matcher: matcher, callback: callback).tap do |subscription|
+      Subscription.new(matcher: matcher, callback: callback, id: id).tap do |subscription|
         @subscriptions << subscription
       end
     end
@@ -257,11 +278,20 @@ module Omnes
       performing_only(&block)
     end
 
+    # Fetch a subscription by its identifier
+    #
+    # @param id [Symbol] Subscription identifier
+    #
+    # @return [Omnes::Subscription]
+    def subscription(id)
+      subscriptions.find { |subscription| subscription.id == id }
+    end
+
     private
 
-    def execute_subscriptions_for_event(event)
+    def execute_subscriptions_for_event(event, publication_context)
       subscriptions_for_event(event).map do |subscription|
-        subscription.(event)
+        subscription.(event, publication_context)
       end
     end
 

data/lib/omnes/configurable.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Omnes
+  # Ad-hoc configurable behavior for Omnes
+  #
+  # Example:
+  #
+  # ```
+  # Omnes.configure do |config|
+  #   config.event.name_builder = MY_NAME_BUILDER
+  # end
+  # ```
+  #
+  # or
+  #
+  # ```
+  # Omnes::Event.config.name_builder = MY_NAME_BUILDER
+  # ```
+  module Configurable
+    # Class where readers and writers are defined
+    class Config
+      # @api private
+      attr_reader :settings
+
+      # @api private
+      def initialize
+        @_mutex = Mutex.new
+        @settings = {}
+      end
+
+      # @api private
+      def add_setting(name, default)
+        @_mutex.synchronize do
+          @settings[name] = default
+          define_setting_reader(name)
+          define_setting_writter(name)
+        end
+      end
+
+      # @api private
+      def add_nesting(constant, name = default_nesting_name(constant))
+        @_mutex.synchronize do
+          define_nesting_reader(constant, name)
+        end
+      end
+
+      private
+
+      def define_setting_reader(name)
+        define_singleton_method(name) { @settings[name] }
+      end
+
+      def define_setting_writter(name)
+        define_singleton_method(:"#{name}=") do |value|
+          @_mutex.synchronize do
+            @settings[name] = value
+          end
+        end
+      end
+
+      def define_nesting_reader(constant, name)
+        define_singleton_method(name) { constant.config }
+      end
+    end
+
+    # @api private
+    def self.extended(klass)
+      klass.instance_variable_set(:@config, Config.new)
+    end
+
+    # Returns the configuration class
+    #
+    # Use this class to access readers and writers for the defined settings or
+    # nested configurations
+    #
+    # @return [Configurable::Config]
+    def config
+      @config
+    end
+
+    # Yields the configuration class
+    #
+    # @see #config
+    def configure
+      yield @config
+    end
+
+    # @api private
+    def setting(name, default:)
+      config.add_setting(name, default)
+    end
+
+    # @api private
+    def nest_config(constant, name: default_nesting_name(constant))
+      config.add_nesting(constant, name)
+    end
+
+    private
+
+    def default_nesting_name(constant)
+      constant.name
+              .split("::")
+              .last
+              .gsub(/([[:alpha:]])([[:upper:]])/, '\1_\2')
+              .downcase
+    end
+  end
+end

data/lib/omnes/errors.rb

@@ -98,4 +98,42 @@ module Omnes
       MSG
     end
   end
+
+  # Raised when given subscription id is already in use
+  class DuplicateSubscriptionIdError < Error
+    attr_reader :id, :bus
+
+    def initialize(id:, bus:)
+      @id = id
+      @bus = bus
+      super(default_message)
+    end
+
+    private
+
+    def default_message
+      <<~MSG
+        #{id} has already been used as a subscription identifier
+      MSG
+    end
+  end
+
+  # Raised when trying to set an invalid subscription identifier
+  class InvalidSubscriptionNameError < Error
+    attr_reader :id
+
+    def initialize(id:)
+      @id = id
+      super(default_message)
+    end
+
+    private
+
+    def default_message
+      <<~MSG
+        #{id.inspect} is not a valid subscription identifier. Only symbols are
+        #allowed.
+      MSG
+    end
+  end
 end

data/lib/omnes/event.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "dry/configurable"
+require "omnes/configurable"
 
 module Omnes
   # Event mixin for custom classes
@@ -27,7 +27,7 @@ module Omnes
   # bus.publish(MyEvent.new(1))
   # ```
   module Event
-    extend Dry::Configurable
+    extend Configurable
 
     # Generates the event name for an event instance
     #

data/lib/omnes/publication.rb

@@ -19,25 +19,16 @@ module Omnes
     # @return [Array<Omnes::Execution>]
     attr_reader :executions
 
-    # Location for the event caller
+    # Publication context, shared by all triggered executions
     #
-    # It's usually set by {Omnes::Bus#publish}, and it points to the caller of
-    # that method.
-    #
-    # @return [Thread::Backtrace::Location]
-    attr_reader :caller_location
-
-    # Time of the event publication
-    #
-    # @return [Time]
-    attr_reader :time
+    # @return [Omnes::PublicationContext]
+    attr_reader :context
 
     # @api private
-    def initialize(event:, executions:, caller_location:, time:)
+    def initialize(event:, executions:, context:)
       @event = event
       @executions = executions
-      @caller_location = caller_location
-      @time = time
+      @context = context
     end
   end
 end

data/lib/omnes/publication_context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Omnes
+  # Context for an event publication
+  #
+  # An instance of this class is shared between all the executions that are
+  # triggered by the publication of a given event. It's provided to the
+  # subscriptions as their second argument when they take it.
+  #
+  # This class is useful mainly for debugging and logging purposes.
+  class PublicationContext
+    # Location for the event publisher
+    #
+    # It's set by {Omnes::Bus#publish}, and it points to the caller of that
+    # method.
+    #
+    # @return [Thread::Backtrace::Location]
+    attr_reader :caller_location
+
+    # Time of the event publication
+    #
+    # @return [Time]
+    attr_reader :time
+
+    # @api private
+    def initialize(caller_location:, time:)
+      @caller_location = caller_location
+      @time = time
+    end
+
+    # Serialized version of a publication context
+    #
+    # @return Hash<String, String>
+    def serialized
+      {
+        "caller_location" => caller_location.to_s,
+        "time" => time.to_s
+      }
+    end
+  end
+end

data/lib/omnes/subscriber/adapter/active_job.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "dry/configurable"
+require "omnes/configurable"
 
 module Omnes
   module Subscriber
@@ -42,7 +42,7 @@ module Omnes
       # Omnes.config.subscriber.adapter.active_job.serializer = :serialized_payload.to_proc
       # ```
       module ActiveJob
-        extend Dry::Configurable
+        extend Configurable
 
         setting :serializer, default: :payload.to_proc
 
@@ -52,8 +52,8 @@ module Omnes
         end
 
         # @api private
-        def self.call(instance, event)
-          self.[].(instance, event)
+        def self.call(instance, event, publication_context)
+          self.[].(instance, event, publication_context)
         end
 
         # @api private
@@ -64,8 +64,12 @@ module Omnes
             @serializer = serializer
           end
 
-          def call(instance, event)
-            instance.class.perform_later(serializer.(event))
+          def call(instance, event, publication_context)
+            if Subscription.takes_publication_context?(instance.method(:perform))
+              instance.class.perform_later(serializer.(event), publication_context.serialized)
+            else
+              instance.class.perform_later(serializer.(event))
+            end
           end
         end
       end

data/lib/omnes/subscriber/adapter/method.rb

@@ -7,7 +7,7 @@ module Omnes
     module Adapter
       # Builds a callback from a method of the instance
       #
-      # You can use instance of this class as the adapter:
+      # You can use an instance of this class as the adapter:
       #
       # ```ruby
       # handle :foo, with: Adapter::Method.new(:foo)
@@ -29,7 +29,7 @@ module Omnes
         def call(instance)
           check_method(instance)
 
-          ->(event) { instance.method(name).(event) }
+          instance.method(name)
         end
 
         private

data/lib/omnes/subscriber/adapter/sidekiq.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "dry/configurable"
+require "omnes/configurable"
 
 module Omnes
   module Subscriber
@@ -49,7 +49,7 @@ module Omnes
       # @example
       #   handle :my_event, with: Adapter::Sidekiq.in(60)
       module Sidekiq
-        extend Dry::Configurable
+        extend Configurable
 
         setting :serializer, default: :payload.to_proc
 
@@ -59,8 +59,8 @@ module Omnes
         end
 
         # @api private
-        def self.call(instance, event)
-          self.[].(instance, event)
+        def self.call(instance, event, publication_context)
+          self.[].(instance, event, publication_context)
         end
 
         # @param seconds [Integer]
@@ -76,15 +76,29 @@ module Omnes
             @serializer = serializer
           end
 
-          def call(instance, event)
-            instance.class.perform_async(serializer.(event))
+          def call(instance, event, publication_context)
+            if takes_publication_context?(instance)
+              instance.class.perform_async(serializer.(event), publication_context.serialized)
+            else
+              instance.class.perform_async(serializer.(event))
+            end
           end
 
           def in(seconds)
-            lambda do |instance, event|
-              instance.class.perform_in(seconds, serializer.(event))
+            lambda do |instance, event, publication_context|
+              if takes_publication_context?(instance)
+                instance.class.perform_in(seconds, serializer.(event), publication_context.serialized)
+              else
+                instance.class.perform_in(seconds, serializer.(event))
+              end
             end
           end
+
+          private
+
+          def takes_publication_context?(instance)
+            Subscription.takes_publication_context?(instance.method(:perform))
+          end
         end
       end
     end

data/lib/omnes/subscriber/adapter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "omnes/configurable"
 require "omnes/subscriber/adapter/active_job"
 require "omnes/subscriber/adapter/method"
 require "omnes/subscriber/adapter/sidekiq"
@@ -14,6 +15,11 @@ module Omnes
     # Alternatively, they can be curried and only take the instance as an
     # argument, returning a one-argument callable taking the event.
     module Adapter
+      extend Configurable
+
+      nest_config Sidekiq
+      nest_config ActiveJob
+
       # @api private
       # TODO: Simplify when when we can take callables and Proc in a polymorphic
       # way: https://bugs.ruby-lang.org/issues/18644

data/lib/omnes/subscriber/state.rb

@@ -10,6 +10,11 @@ module Omnes
     class State
       attr_reader :subscription_definitions, :calling_cache, :autodiscover_strategy
 
+      # @api private
+      def self.IdType(value)
+        value.respond_to?(:call) ? value : ->(_instance) { value }
+      end
+
       def initialize(autodiscover_strategy:, subscription_definitions: [], calling_cache: [])
         @subscription_definitions = subscription_definitions
         @calling_cache = calling_cache
@@ -21,7 +26,7 @@ module Omnes
 
         autodiscover_subscription_definitions(bus, instance) unless autodiscover_strategy.nil?
 
-        definitions = subscription_definitions.map { |defn| defn.(bus) }
+        definitions = subscription_definitions.map { |defn| defn.(bus, instance) }
 
         subscribe_definitions(definitions, bus, instance).tap do
           mark_as_called(bus, instance)
@@ -50,18 +55,19 @@ module Omnes
           add_subscription_definition do |_bus|
             [
               Subscription::SINGLE_EVENT_MATCHER.curry[event_name],
-              Adapter.Type(Adapter::Method.new(method_name))
+              Adapter.Type(Adapter::Method.new(method_name)),
+              Subscription.random_id
             ]
           end
         end
       end
 
       def subscribe_definitions(definitions, bus, instance)
-        matcher_with_callbacks = definitions.map do |(matcher, adapter)|
-          [matcher, adapter.curry[instance]]
+        matcher_with_callbacks = definitions.map do |(matcher, adapter, id)|
+          [matcher, adapter.curry[instance], id]
         end
 
-        matcher_with_callbacks.map { |matcher, callback| bus.subscribe_with_matcher(matcher, callback) }
+        matcher_with_callbacks.map { |matcher, callback, id| bus.subscribe_with_matcher(matcher, callback, id: id) }
       end
     end
   end

data/lib/omnes/subscriber.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/configurable"
 require "omnes/subscriber/adapter"
 require "omnes/subscriber/state"
 require "omnes/subscription"
@@ -122,14 +121,14 @@ module Omnes
   # bus. However, you can subscribe distinct instances to the same bus or the
   # same instance to different buses.
   module Subscriber
-    extend Dry::Configurable
+    extend Configurable
 
     # @api private
     ON_PREFIX_STRATEGY = ->(event_name) { :"on_#{event_name}" }
 
     setting :autodiscover, default: false
-
     setting :autodiscover_strategy, default: ON_PREFIX_STRATEGY
+    nest_config Adapter
 
     # Includes with options
     #
@@ -193,11 +192,12 @@ module Omnes
       #
       # @param event_name [Symbol]
       # @param with [Symbol, #call] Public method in the class or an adapter
-      def handle(event_name, with:)
+      # @param id [Symbol] Unique identifier for the subscription
+      def handle(event_name, with:, id: Subscription.random_id)
         @_mutex.synchronize do
-          @_state.add_subscription_definition do |bus|
+          @_state.add_subscription_definition do |bus, instance|
             bus.registry.check_event_name(event_name)
-            [Subscription::SINGLE_EVENT_MATCHER.curry[event_name], Adapter.Type(with)]
+            [Subscription::SINGLE_EVENT_MATCHER.curry[event_name], Adapter.Type(with), State.IdType(id).(instance)]
           end
         end
       end
@@ -205,10 +205,11 @@ module Omnes
       # Handles all events
       #
       # @param with [Symbol, #call] Public method in the class or an adapter
-      def handle_all(with:)
+      # @param id [Symbol] Unique identifier for the subscription
+      def handle_all(with:, id: Subscription.random_id)
         @_mutex.synchronize do
-          @_state.add_subscription_definition do |_bus|
-            [Subscription::ALL_EVENTS_MATCHER, Adapter.Type(with)]
+          @_state.add_subscription_definition do |_bus, instance|
+            [Subscription::ALL_EVENTS_MATCHER, Adapter.Type(with), State.IdType(id).(instance)]
           end
         end
       end
@@ -217,10 +218,11 @@ module Omnes
       #
       # @param matcher [#call]
       # @param with [Symbol, #call] Public method in the class or an adapter
-      def handle_with_matcher(matcher, with:)
+      # @param id [Symbol] Unique identifier for the subscription
+      def handle_with_matcher(matcher, with:, id: Subscription.random_id)
         @_mutex.synchronize do
-          @_state.add_subscription_definition do |_bus|
-            [matcher, Adapter.Type(with)]
+          @_state.add_subscription_definition do |_bus, instance|
+            [matcher, Adapter.Type(with), State.IdType(id).(instance)]
           end
         end
       end

data/lib/omnes/subscription.rb

@@ -2,6 +2,7 @@
 
 require "benchmark"
 require "omnes/execution"
+require "securerandom"
 
 module Omnes
   # Subscription to an event
@@ -24,19 +25,39 @@ module Omnes
     ALL_EVENTS_MATCHER = ->(_candidate) { true }
 
     # @api private
-    attr_reader :matcher, :callback
+    def self.random_id
+      SecureRandom.uuid.to_sym
+    end
+
+    # @api private
+    def self.takes_publication_context?(callable)
+      callable.parameters.count == 2
+    end
 
     # @api private
-    def initialize(matcher:, callback:)
+    attr_reader :matcher, :callback, :id
+
+    # @api private
+    def initialize(matcher:, callback:, id:)
+      raise Omnes::InvalidSubscriptionNameError.new(id: id) unless id.is_a?(Symbol)
+
       @matcher = matcher
       @callback = callback
+      @id = id
     end
 
     # @api private
-    def call(event)
+    def call(event, publication_context)
       result = nil
       benchmark = Benchmark.measure do
-        result = @callback.(event)
+        # work around Ruby not being able to tell remaining arity for a curried
+        # function (or uncurrying), because we want to be able to create subscriber
+        # adapters partially applying the subscriber instance
+        result = begin
+          @callback.(event, publication_context)
+        rescue ArgumentError
+          @callback.(event)
+        end
       end
 
       Execution.new(subscription: self, result: result, benchmark: benchmark)

data/lib/omnes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnes
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/omnes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "omnes/bus"
+require "omnes/configurable"
 require "omnes/event"
 require "omnes/subscriber"
 require "omnes/version"
@@ -33,43 +34,10 @@ require "omnes/version"
 # Refer to {Omnes::Subscriber} for how to provide event handlers through methods
 # defined in a class.
 module Omnes
-  # Shortcut to access the configuration for different Omnes components
-  #
-  # TODO: Make automation for it
-  #
-  # @return [Omnes::Config]
-  def self.config
-    Config
-  end
-
-  # Wrapper for the configuration of Omnes components
-  module Config
-    # {Omnes::Subscriber} configuration
-    #
-    # @return [Dry::Configurable::Config]
-    def self.subscriber
-      Omnes::Subscriber.config.tap do |klass|
-        klass.define_singleton_method(:adapter) do
-          Module.new do
-            def self.sidekiq
-              Omnes::Subscriber::Adapter::Sidekiq.config
-            end
+  extend Configurable
 
-            def self.active_job
-              Omnes::Subscriber::Adapter::ActiveJob.config
-            end
-          end
-        end
-      end
-    end
-
-    # {Omnes::Event} configuration
-    #
-    # @return [Dry::Configurable::Config]
-    def self.event
-      Omnes::Event.config
-    end
-  end
+  nest_config Subscriber
+  nest_config Event
 
   # @api private
   def self.included(klass)

data/omnes.gemspec

@@ -36,8 +36,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "dry-configurable", "~> 0.14"
-
   spec.add_development_dependency "activejob", "~> 7.0"
   spec.add_development_dependency "redcarpet", "~> 3.5"
   spec.add_development_dependency "sidekiq", "~> 6.4"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: omnes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Marc Busqué
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-04-15 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: dry-configurable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
@@ -109,10 +95,12 @@ files:
 - bin/setup
 - lib/omnes.rb
 - lib/omnes/bus.rb
+- lib/omnes/configurable.rb
 - lib/omnes/errors.rb
 - lib/omnes/event.rb
 - lib/omnes/execution.rb
 - lib/omnes/publication.rb
+- lib/omnes/publication_context.rb
 - lib/omnes/registry.rb
 - lib/omnes/subscriber.rb
 - lib/omnes/subscriber/adapter.rb
@@ -135,7 +123,7 @@ metadata:
   source_code_uri: https://github.com/nebulab/omnes
   changelog_uri: https://github.com/nebulab/omnes/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -150,8 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: Pub/Sub for ruby
 test_files: []