Class: Spree::Events::Registry

Inherits:
Object
  • Object
show all
Defined in:
lib/spree/events/registry.rb

Overview

Registry for managing event subscribers across different adapters.

The registry provides an adapter-agnostic way to track subscriptions. This allows Spree to support different event backends (ActiveSupport::Notifications, Kafka, Redis Pub/Sub, etc.) while maintaining a consistent subscription API.

Thread safety: Uses a Mutex for safe concurrent access during subscription registration/unregistration, which may happen during Rails initialization or hot reloading in development.

Examples:

registry = Spree::Events::Registry.new
registry.register('order.*', MySubscriber, async: true)
registry.subscriptions_for('order.complete') # => [Subscription]

Defined Under Namespace

Classes: Subscription

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Registry

Returns a new instance of Registry.



28
29
30
31
 
# File 'lib/spree/events/registry.rb', line 28

def initialize
  @subscriptions = []
  @mutex = Mutex.new
end

Instance Method Details

#all_subscriptions ⇒ Array<Subscription>

Returns:



74
75
76
 
# File 'lib/spree/events/registry.rb', line 74

def all_subscriptions
  @mutex.synchronize { @subscriptions.dup }
end

#clear! ⇒ Object 



94
95
96
 
# File 'lib/spree/events/registry.rb', line 94

def clear!
  @mutex.synchronize { @subscriptions.clear }
end

#patterns ⇒ Array<String>

Returns Unique patterns.

Returns:

  • (Array<String>) —

    Unique patterns



79
80
81
 
# File 'lib/spree/events/registry.rb', line 79

def patterns
  @mutex.synchronize { @subscriptions.map(&:pattern).uniq }
end

#register(pattern, subscriber, options = {}) ⇒ Subscription

Register a subscriber for an event pattern

Parameters:

  • pattern (String) —

    Event pattern (supports wildcards like ‘order.*’)

  • subscriber (Class, Proc) —

    The subscriber class or callable

  • options (Hash) (defaults to: {}) —

    Subscription options (:async, etc.)

Returns:



39
40
41
42
43
44
45
46
47
48
 
# File 'lib/spree/events/registry.rb', line 39

def register(pattern, subscriber, options = {})
  subscription = Subscription.new(
    pattern: pattern.to_s,
    subscriber: subscriber,
    options: options.freeze
  )

  @mutex.synchronize { @subscriptions << subscription }
  subscription
end

#registered?(pattern) ⇒ Boolean

Parameters:

  • pattern (String)

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/spree/events/registry.rb', line 90

def registered?(pattern)
  @mutex.synchronize { @subscriptions.any? { |s| s.pattern == pattern.to_s } }
end

#size ⇒ Integer

Returns:

  • (Integer) 


84
85
86
 
# File 'lib/spree/events/registry.rb', line 84

def size
  @mutex.synchronize { @subscriptions.size }
end

#subscriptions_for(event_name) ⇒ Array<Subscription>

Find all subscriptions matching an event name

Parameters:

  • event_name (String) —

    The event name

Returns:



67
68
69
70
71
 
# File 'lib/spree/events/registry.rb', line 67

def subscriptions_for(event_name)
  @mutex.synchronize do
    @subscriptions.select { |s| Spree::Event.matches?(event_name, s.pattern) }
  end
end

#unregister(pattern, subscriber) ⇒ Boolean

Unregister a subscriber

Parameters:

  • pattern (String) —

    Event pattern

  • subscriber (Class, Proc) —

    The subscriber to remove

Returns:

  • (Boolean) —

    true if removed



55
56
57
58
59
60
61
 
# File 'lib/spree/events/registry.rb', line 55

def unregister(pattern, subscriber)
  @mutex.synchronize do
    original_size = @subscriptions.size
    @subscriptions.reject! { |s| s.pattern == pattern.to_s && s.subscriber == subscriber }
    @subscriptions.size < original_size
  end
end