u-observers 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f8cf4c9f76af4b9438412dc60fa7b4156fa84afec92f89a12bb40b90d1ed32
-  data.tar.gz: 1c1ad202a47f467e468186b58671bed796656180660302f057005a7387bdcc7f
+  metadata.gz: e7da28034b714bb64baf033cf43705ed585fa007659964dc36bec440436292f0
+  data.tar.gz: cd2b40e92cdfd12708ab36f1ed8a7726ecfbc2c6e96223ca090aedc7758f44f8
 SHA512:
-  metadata.gz: c2f779070c6e11ef08c71b85f9d90342907cef3e910e7f6a7b61bbebeeec283baf56d197df1edf3bb4bb7437424e43d74208d97fed1e745b76367b2c14fb2206
-  data.tar.gz: 7995b96fe8868e126fd053e05e831b92adc421325b133324222591c74a288ba4de9677dc59b2b5f57a8d8a437c04a342f04a9548ed460546e9f56b571e4ac3c5
+  metadata.gz: 51be920a8f6f0123e0a94fbf180fb85517ddccb107f729f6eaa38ac840e14a9d207cb82e8f3f76e018e3836f4a7cc0b47b7ea6320ffd0615d22df49c6b693d73
+  data.tar.gz: 66c73487b724149f640e096b24a1e9ecf5e5d8780e9679f1d182823eda377e8b289ed88c98d73f6a81147e945eba7a8ce24278244ab50c1a191ebba1b912e265

data/README.md

@@ -42,6 +42,10 @@ Because of this issue, I decided to create a gem that encapsulates the pattern w
     - [Using a callable as an observer](#using-a-callable-as-an-observer)
     - [Calling the observers](#calling-the-observers)
     - [Notifying observers without marking them as changed](#notifying-observers-without-marking-them-as-changed)
+    - [Defining observers that execute only once](#defining-observers-that-execute-only-once)
+      - [`observers.attach(*args, perform_once: true)`](#observersattachargs-perform_once-true)
+      - [`observers.once(event:, call:, ...)`](#observersonceevent-call-)
+    - [Detaching observers](#detaching-observers)
     - [ActiveRecord and ActiveModel integrations](#activerecord-and-activemodel-integrations)
       - [notify_observers_on()](#notify_observers_on)
       - [notify_observers()](#notify_observers)
@@ -63,7 +67,7 @@ gem 'u-observers'
 | u-observers | branch  | ruby     | activerecord  |
 | ----------- | ------- | -------- | ------------- |
 | unreleased  | main    | >= 2.2.0 | >= 3.2, < 6.1 |
-| 2.1.0       | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.2.0       | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 | 1.0.0       | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
 > **Note**: The ActiveRecord isn't a dependency, but you could add a module to enable some static methods that were designed to be used with its [callbacks](https://guides.rubyonrails.org/active_record_callbacks.html).
@@ -109,7 +113,7 @@ end
 order = Order.new
 #<Order:0x00007fb5dd8fce70 @code="X0o9yf1GsdQFvLR4", @status=:draft>
 
-order.observers.attach(OrderEvents)          # attaching multiple observers. e.g. observers.attach(A, B, C)
+order.observers.attach(OrderEvents)  # attaching multiple observers. e.g. observers.attach(A, B, C)
 # <#Micro::Observers::Set @subject=#<Order:0x00007fb5dd8fce70> @subject_changed=false @subscribers=[OrderEvents]>
 
 order.canceled?
@@ -122,7 +126,7 @@ order.cancel!
 order.canceled?
 # true
 
-order.observers.detach(OrderEvents)          # detaching multiple observers. e.g. observers.detach(A, B, C)
+order.observers.detach(OrderEvents)  # detaching multiple observers. e.g. observers.detach(A, B, C)
 # <#Micro::Observers::Set @subject=#<Order:0x00007fb5dd8fce70> @subject_changed=false @subscribers=[]>
 
 order.canceled?
@@ -286,12 +290,12 @@ class Order
   end
 end
 
-OrderCancellation = -> (order) { puts "The order #(#{order.object_id}) has been canceled." }
+NotifyAfterCancel = -> (order) { puts "The order #(#{order.object_id}) has been canceled." }
 
 order = Order.new
-order.observers.attach(OrderCancellation)
+order.observers.attach(NotifyAfterCancel)
 order.cancel!
-# The message below will be printed by the observer (OrderCancellation):
+# The message below will be printed by the observer (NotifyAfterCancel):
 # The order #(70196221441820) has been canceled.
 ```
 
@@ -307,6 +311,106 @@ If you use the methods `#notify!` or `#call!` you won't need to mark observers w
 
 [⬆️ &nbsp; Back to Top](#table-of-contents-)
 
+### Defining observers that execute only once
+
+There are two ways to attach an observer and define it to be performed only once.
+
+The first way to do this is passing the `perform_once: true` option to the `observers.attach()` method. e.g.
+
+#### `observers.attach(*args, perform_once: true)`
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+module OrderNotifications
+  def self.canceled(order)
+    puts "The order #(#{order.object_id}) has been canceled."
+  end
+end
+
+order = Order.new
+order.observers.attach(OrderNotifications, perform_once: true) # you can also pass an array of observers with this option
+
+order.observers.some? # true
+order.cancel!         # The order #(70291642071660) has been canceled.
+
+order.observers.some? # false
+order.cancel!         # Nothing will happen because there aren't observers.
+```
+
+#### `observers.once(event:, call:, ...)`
+
+The second way to achieve this is using `observers.once()` that has the same API of [`observers.on()`](#using-a-callable-as-an-observer). But the difference of the `#once()` method is that it will remove the observer after its execution.
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+module NotifyAfterCancel
+  def self.call(event)
+    puts "The order #(#{event.subject.object_id}) has been canceled."
+  end
+end
+
+order = Order.new
+order.observers.once(event: :canceled, call: NotifyAfterCancel)
+
+order.observers.some? # true
+order.cancel!         # The order #(70301497466060) has been canceled.
+
+order.observers.some? # false
+order.cancel!         # Nothing will happen because there aren't observers.
+```
+
+[⬆️ &nbsp; Back to Top](#table-of-contents-)
+
+### Detaching observers
+
+As shown in the first example, you can use the `observers.detach()` to remove observers.
+
+But, there is an alternative method to remove observer objects or remove callables by their event names. The method to do this is: `observers.off()`.
+
+```ruby
+class Order
+  include Micro::Observers
+end
+
+NotifyAfterCancel = -> {}
+
+module OrderNotifications
+  def self.canceled(_order)
+  end
+end
+
+order = Order.new
+order.observers.on(event: :canceled, call: NotifyAfterCancel)
+order.observers.attach(OrderNotifications)
+
+order.observers.some? # true
+order.observers.count # 2
+
+order.observers.off(:canceled) # removing the callable (NotifyAfterCancel).
+order.observers.some? # true
+order.observers.count # 1
+
+order.observers.off(OrderNotifications)
+order.observers.some? # false
+order.observers.count # 0
+```
+
+[⬆️ &nbsp; Back to Top](#table-of-contents-)
+
 ### ActiveRecord and ActiveModel integrations
 
 To make use of this feature you need to require an additional module.
@@ -318,7 +422,6 @@ gem 'u-observers', require: 'u-observers/for/active_record'
 
 This feature will expose modules that could be used to add macros (static methods) that were designed to work with `ActiveModel`/`ActiveRecord` callbacks. e.g:
 
-
 #### notify_observers_on()
 
 The `notify_observers_on` allows you to define one or more `ActiveModel`/`ActiveRecord` callbacks, that will be used to notify your object observers.

data/README.pt-BR.md

@@ -38,9 +38,13 @@ Por causa desse problema, decidi criar uma gem que encapsula o padrão sem alter
     - [Compartilhando um contexto com seus observadores](#compartilhando-um-contexto-com-seus-observadores)
     - [Compartilhando dados ao notificar os observadores](#compartilhando-dados-ao-notificar-os-observadores)
     - [O que é `Micro::Observers::Event`?](#o-que-é-microobserversevent)
-    - [Usando um calleable como um observador](#usando-um-calleable-como-um-observador)
+    - [Usando um callable como um observador](#usando-um-callable-como-um-observador)
     - [Chamando os observadores](#chamando-os-observadores)
     - [Notificar observadores sem marcá-los como alterados](#notificar-observadores-sem-marcá-los-como-alterados)
+    - [Definindo observers que executam apenas uma vez](#definindo-observers-que-executam-apenas-uma-vez)
+      - [`observers.attach(*args, perform_once: true)`](#observersattachargs-perform_once-true)
+      - [`observers.once(event:, call:, ...)`](#observersonceevent-call-)
+    - [Desanexando observers](#desanexando-observers)
     - [Integrações ActiveRecord e ActiveModel](#integrações-activerecord-e-activemodel)
       - [notify_observers_on()](#notify_observers_on)
       - [notify_observers()](#notify_observers)
@@ -62,7 +66,7 @@ gem 'u-observers'
 | u-observers | branch  | ruby     | activerecord  |
 | ----------- | ------- | -------- | ------------- |
 | unreleased  | main    | >= 2.2.0 | >= 3.2, < 6.1 |
-| 2.1.0       | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.2.0       | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 | 1.0.0       | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
 > **Nota**: O ActiveRecord não é uma dependência, mas você pode adicionar um módulo para habilitar alguns métodos estáticos que foram projetados para serem usados ​​com seus [callbacks](https://guides.rubyonrails.org/active_record_callbacks.html).
@@ -218,19 +222,17 @@ O `Micro::Observers::Event` é o payload do evento. Veja abaixo todas as suas pr
 
 [⬆️ Voltar para o índice](#índice-)
 
-### Usando um calleable como um observador
+### Usando um callable como um observador
 
 O método `observers.on()` permite que você anexe um callable (objeto que responda ao método `call`) como um observador.
 
-Um callable tende a ter uma responsabilidade bem definida, promovendo assim o uso de [SRP (Single-responsibility principle).
-
 Normalmente, um callable tem uma responsabilidade bem definida (faz apenas uma coisa), por isso, tende a ser mais amigável com o [SRP (princípio de responsabilidade única)](https://en.wikipedia.org/wiki/Single-responsibility_principle) do que um observador convencional (que poderia ter N métodos para responder a diferentes tipos de notificação).
 
 Este método recebe as opções abaixo:
 1. `:event` o nome do evento esperado.
 2. `:call` o próprio callable.
 3. `:with` (opcional) pode definir o valor que será usado como argumento do objeto callable. Portanto, se for um `Proc`, uma instância de `Micro::Observers::Event` será recebida como o argumento `Proc` e sua saída será o argumento que pode ser chamado. Mas se essa opção não for definida, a instância `Micro::Observers::Event` será o argumento do callable.
-4. `#context` serão os dados de contexto que foram definidos no momento em que você anexa o *observer*.
+4. `:context` serão os dados de contexto que foram definidos no momento em que você anexa o *observer*.
 
 ```ruby
 class Person
@@ -260,7 +262,8 @@ person = Person.new('Aristóteles')
 person.observers.on(
   event: :name_has_been_changed,
   call: PrintPersonName,
-  with: -> event { {person: event.subject, number: rand} }
+  with: -> event { {person: event.subject, number: event.context} },
+  context: rand
 )
 
 person.name = 'Coutinho'
@@ -308,6 +311,106 @@ Se você usar os métodos `#notify!` ou `#call!` você não precisará marcar ob
 
 [⬆️ Voltar para o índice](#índice-)
 
+### Definindo observers que executam apenas uma vez
+
+Existem duas formas de anexar um observer e definir que ele executará apenas uma vez.
+
+A primeira forma de fazer isso é passando a opção `perform_once: true` para o método `observers.attach()`. Exemplo:
+
+#### `observers.attach(*args, perform_once: true)`
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+module OrderNotifications
+  def self.canceled(order)
+    puts "The order #(#{order.object_id}) has been canceled."
+  end
+end
+
+order = Order.new
+order.observers.attach(OrderNotifications, perform_once: true) # you can also pass an array of observers with this option
+
+order.observers.some? # true
+order.cancel!         # The order #(70291642071660) has been canceled.
+
+order.observers.some? # false
+order.cancel!         # Nothing will happen because there aren't observers.
+```
+
+#### `observers.once(event:, call:, ...)`
+
+A segunda forma de conseguir isso é usando o método `observers.once()` que tem a mesma API do [`observers.on()`](#usando-um-callable-como-um-observador). Mas a diferença é que o método `#once()` removerá o observer após a sua execução.
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+module NotifyAfterCancel
+  def self.call(event)
+    puts "The order #(#{event.subject.object_id}) has been canceled."
+  end
+end
+
+order = Order.new
+order.observers.once(event: :canceled, call: NotifyAfterCancel)
+
+order.observers.some? # true
+order.cancel!         # The order #(70301497466060) has been canceled.
+
+order.observers.some? # false
+order.cancel!         # Nothing will happen because there aren't observers.
+```
+
+[⬆️ &nbsp; Back to Top](#table-of-contents-)
+
+### Desanexando observers
+
+Como mostrado no primeiro exemplo, você pode usar o `observers.detach()` para remove observers.
+
+Mas, existe uma alternativa a esse método que permite remover objetos observers ou remover callables pelo nome de seus eventos. O método para fazer isso é: `observers.off()`.
+
+```ruby
+class Order
+  include Micro::Observers
+end
+
+NotifyAfterCancel = -> {}
+
+module OrderNotifications
+  def self.canceled(_order)
+  end
+end
+
+order = Order.new
+order.observers.on(event: :canceled, call: NotifyAfterCancel)
+order.observers.attach(OrderNotifications)
+
+order.observers.some? # true
+order.observers.count # 2
+
+order.observers.off(:canceled) # removing the callable (NotifyAfterCancel).
+order.observers.some? # true
+order.observers.count # 1
+
+order.observers.off(OrderNotifications)
+order.observers.some? # false
+order.observers.count # 0
+```
+
+[⬆️ &nbsp; Back to Top](#table-of-contents-)
+
 ### Integrações ActiveRecord e ActiveModel
 
 Para fazer uso deste recurso, você precisa de um módulo adicional.

data/lib/micro/observers.rb

@@ -4,6 +4,8 @@ module Micro
   module Observers
     require 'micro/observers/utils'
     require 'micro/observers/event'
+    require 'micro/observers/subscribers'
+    require 'micro/observers/broadcast'
     require 'micro/observers/set'
 
     def observers

data/lib/micro/observers/broadcast.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Micro
+  module Observers
+
+    module Broadcast
+      extend self
+
+      def call(subscribers, subject, data, event_names)
+        subscribers_list = subscribers.list
+        subscribers_to_be_deleted = ::Set.new
+
+        event_names.each(&BroadcastWith[subscribers_list, subject, data, subscribers_to_be_deleted])
+
+        subscribers_to_be_deleted.each { |subscriber| subscribers_list.delete(subscriber) }
+      end
+
+      private
+
+        BroadcastWith = -> (subscribers, subject, data, subscribers_to_be_deleted) do
+          -> (event_name) do
+            subscribers.each do |subscriber|
+              notified = NotifySubscriber.(subscriber, subject, data, event_name)
+              perform_once = subscriber[3]
+
+              subscribers_to_be_deleted.add(subscriber) if notified && perform_once
+            end
+          end
+        end
+
+        NotifySubscriber = -> (subscriber, subject, data, event_name) do
+          NotifyObserver.(subscriber, subject, data, event_name) ||
+          NotifyCallable.(subscriber, subject, data, event_name) ||
+          false
+        end
+
+        NotifyObserver = -> (subscriber, subject, data, event_name) do
+          strategy, observer, context = subscriber
+
+          return unless strategy == :observer && observer.respond_to?(event_name)
+
+          event = Event.new(event_name, subject, context, data)
+
+          handler = observer.is_a?(Proc) ? observer : observer.method(event.name)
+          handler.arity == 1 ? handler.call(event.subject) : handler.call(event.subject, event)
+
+          true
+        end
+
+        NotifyCallable = -> (subscriber, subject, data, event_name) do
+          strategy, observer, options = subscriber
+
+          return unless strategy == :callable && observer == event_name
+
+          callable, with, context = options[0], options[1], options[2]
+
+          return callable.call(with) if with && !with.is_a?(Proc)
+
+          event = Event.new(event_name, subject, context, data)
+
+          callable.call(with.is_a?(Proc) ? with.call(event) : event)
+
+          true
+        end
+
+      private_constant :BroadcastWith, :NotifySubscriber, :NotifyCallable, :NotifyObserver
+    end
+
+    private_constant :Broadcast
+  end
+end

data/lib/micro/observers/for/active_model.rb

@@ -18,7 +18,7 @@ module Micro
           end
 
           def notify_observers_on(*callback_methods)
-            Utils::Arrays.flatten_and_compact(callback_methods).each do |callback_method|
+            Utils::Arrays.fetch_from_args(callback_methods).each do |callback_method|
               self.public_send(callback_method, &notify_observers!([callback_method]))
             end
           end

data/lib/micro/observers/set.rb

@@ -4,42 +4,19 @@ module Micro
   module Observers
 
     class Set
-      EMPTY_HASH = {}.freeze
-
-      MapSubscriber = -> (observer, options) { [:observer, observer, options[:context]] }
-
-      MapSubscribers = -> (value) do
-        array = Utils::Arrays.flatten_and_compact(value.kind_of?(Array) ? value : [])
-        array.map { |observer| MapSubscriber[observer, EMPTY_HASH] }
-      end
-
-      GetObserver = -> subscriber { subscriber[0] == :observer ? subscriber[1] : subscriber[2][0] }
-
-      EqualTo = -> (observer) { -> subscriber { GetObserver[subscriber] == observer } }
-
       def self.for(subject)
         new(subject)
       end
 
       def initialize(subject, subscribers: nil)
         @subject = subject
-
         @subject_changed = false
-
-        @subscribers = MapSubscribers.call(subscribers)
-      end
-
-      def count
-        @subscribers.size
+        @subscribers = Subscribers.new(subscribers)
       end
 
-      def none?
-        @subscribers.empty?
-      end
-
-      def some?
-        !none?
-      end
+      def count; @subscribers.count; end
+      def none?; @subscribers.none?; end
+      def some?; !none?; end
 
       def subject_changed?
         @subject_changed
@@ -57,121 +34,66 @@ module Micro
         subject_changed(true)
       end
 
-      def included?(observer)
-        @subscribers.any?(&EqualTo[observer])
-      end
-
-      def attach(*args)
-        options = args.last.is_a?(Hash) ? args.pop : EMPTY_HASH
-
-        Utils::Arrays.flatten_and_compact(args).each do |observer|
-          @subscribers << MapSubscriber[observer, options] unless included?(observer)
-        end
-
-        self
-      end
-
-      def detach(*args)
-        Utils::Arrays.flatten_and_compact(args).each do |observer|
-          @subscribers.delete_if(&EqualTo[observer])
-        end
-
-        self
+      def include?(observer)
+        @subscribers.include?(observer)
       end
+      alias included? include?
 
-      def on(options = EMPTY_HASH)
-        event, callable, with, context = options[:event], options[:call], options[:with], options[:context]
-
-        return self unless event.is_a?(Symbol) && callable.respond_to?(:call)
+      def attach(*args); @subscribers.attach(args) and self; end
+      def detach(*args); @subscribers.detach(args) and self; end
 
-        @subscribers << [:callable, event, [callable, with, context]] unless included?(callable)
+      def on(options = Utils::EMPTY_HASH); @subscribers.on(options) and self; end
+      def once(options = Utils::EMPTY_HASH); @subscribers.once(options) and self; end
 
-        self
+      def off(*args)
+        @subscribers.off(args) and self
       end
 
       def notify(*events, data: nil)
         broadcast_if_subject_changed(Event::Names.fetch(events), data)
-
-        self
       end
 
       def notify!(*events, data: nil)
         broadcast(Event::Names.fetch(events), data)
-
-        self
       end
 
       CALL_EVENT = [:call].freeze
 
       def call(*events, data: nil)
         broadcast_if_subject_changed(Event::Names[events, default: CALL_EVENT], data)
-
-        self
       end
 
       def call!(*events, data: nil)
         broadcast(Event::Names[events, default: CALL_EVENT], data)
-
-        self
       end
 
       def inspect
-        subs = @subscribers.empty? ? @subscribers : @subscribers.map(&GetObserver)
+        subs = @subscribers.to_inspect
 
-        '<#%s @subject=%s @subject_changed=%p @subscribers=%p>' % [self.class, @subject, @subject_changed, subs]
+        '#<%s @subject=%s @subject_changed=%p @subscribers=%p>' % [self.class, @subject, @subject_changed, subs]
       end
 
       private
 
-        def broadcast_if_subject_changed(events, data = nil)
-          return unless subject_changed?
+        def broadcast_if_subject_changed(event_names, data = nil)
+          return self if none? || !subject_changed?
 
-          broadcast(events, data)
+          broadcast(event_names, data)
 
           subject_changed(false)
-        end
 
-        def broadcast(event_names, data)
-          return if @subscribers.empty?
-
-          event_names.each do |event_name|
-            @subscribers.each do |strategy, observer, context|
-              case strategy
-              when :observer then notify_observer(observer, event_name, context, data)
-              when :callable then notify_callable(observer, event_name, context, data)
-              end
-            end
-          end
+          self
         end
 
-        def notify_observer(observer, event_name, context, data)
-          return unless observer.respond_to?(event_name)
-
-          handler = observer.is_a?(Proc) ? observer : observer.method(event_name)
-
-          return handler.call(@subject) if handler.arity == 1
-
-          handler.call(@subject, Event.new(event_name, @subject, context, data))
-        end
-
-        def notify_callable(expected_event_name, event_name, opt, data)
-          return if expected_event_name != event_name
-
-          callable, with, context = opt[0], opt[1], opt[2]
-          callable_arg =
-            if with && !with.is_a?(Proc)
-              with
-            else
-              event = Event.new(event_name, @subject, context, data)
+        def broadcast(event_names, data)
+          return self if none?
 
-              with.is_a?(Proc) ? with.call(event) : event
-            end
+          Broadcast.call(@subscribers, @subject, data, event_names)
 
-          callable.call(callable_arg)
+          self
         end
 
-      private_constant :EMPTY_HASH, :INVALID_BOOLEAN_MSG, :CALL_EVENT
-      private_constant :MapSubscriber, :MapSubscribers, :GetObserver, :EqualTo
+      private_constant :INVALID_BOOLEAN_MSG, :CALL_EVENT
     end
 
   end

data/lib/micro/observers/subscribers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+
+    class Subscribers
+      EqualTo = -> (observer) { -> subscriber { GetObserver[subscriber] == observer } }
+      GetObserver = -> subscriber { subscriber[0] == :observer ? subscriber[1] : subscriber[2][0] }
+      MapObserver = -> (observer, options, once) { [:observer, observer, options[:context], once] }
+      MapObserversToInitialize = -> arg do
+        Utils::Arrays.flatten_and_compact(arg).map do |observer|
+          MapObserver[observer, Utils::EMPTY_HASH, false]
+        end
+      end
+
+      attr_reader :list
+
+      def initialize(arg)
+        @list = arg.is_a?(Array) ? MapObserversToInitialize[arg] : []
+      end
+
+      def to_inspect
+        none? ? @list : @list.map(&GetObserver)
+      end
+
+      def count
+        @list.size
+      end
+
+      def none?
+        @list.empty?
+      end
+
+      def include?(subscriber)
+        @list.any?(&EqualTo[subscriber])
+      end
+
+      def attach(args)
+        options = args.last.is_a?(Hash) ? args.pop : Utils::EMPTY_HASH
+
+        once = options.frozen? ? false : options.delete(:perform_once)
+
+        Utils::Arrays.fetch_from_args(args).each do |observer|
+          @list << MapObserver[observer, options, once] unless include?(observer)
+        end
+
+        true
+      end
+
+      def detach(args)
+        Utils::Arrays.fetch_from_args(args).each do |observer|
+          delete_observer(observer)
+        end
+
+        true
+      end
+
+      def on(options)
+        on!(options, once: false)
+      end
+
+      def once(options)
+        on!(options, once: true)
+      end
+
+      EventNameToCall = -> event_name { -> subscriber { subscriber[0] == :callable && subscriber[1] == event_name } }
+
+      def off(args)
+        Utils::Arrays.fetch_from_args(args).each do |value|
+          if value.is_a?(Symbol)
+            @list.delete_if(&EventNameToCall[value])
+          else
+            delete_observer(value)
+          end
+        end
+      end
+
+      private
+
+        def delete_observer(observer)
+          @list.delete_if(&EqualTo[observer])
+        end
+
+        def on!(options, once:)
+          event, callable, with, context = options[:event], options[:call], options[:with], options[:context]
+
+          return true unless event.is_a?(Symbol) && callable.respond_to?(:call)
+
+          observer = [callable, with, context]
+
+          @list << [:callable, event, observer, once] unless include_callable?(event, observer)
+
+          true
+        end
+
+        CallableHaving = -> (event, observer) do
+          -> subs { subs[0] == :callable && subs[1] == event && subs[2] == observer }
+        end
+
+        def include_callable?(event, observer)
+          @list.any?(&CallableHaving[event, observer])
+        end
+
+      private_constant :EqualTo, :EventNameToCall, :CallableHaving
+      private_constant :GetObserver, :MapObserver, :MapObserversToInitialize
+    end
+
+    private_constant :Subscribers
+  end
+end

data/lib/micro/observers/utils.rb

@@ -4,9 +4,19 @@ module Micro
   module Observers
 
     module Utils
+      EMPTY_HASH = {}.freeze
+
       module Arrays
+        def self.fetch_from_args(args)
+          args.size == 1 && (first = args[0]).is_a?(::Array) ? first : args
+        end
+
         def self.flatten_and_compact(value)
-          Array(value).flatten.tap(&:compact!)
+          return [] unless value
+
+          array = Array(value).flatten
+          array.compact!
+          array
         end
       end
     end

data/lib/micro/observers/version.rb

@@ -1,5 +1,5 @@
 module Micro
   module Observers
-    VERSION = '2.1.0'
+    VERSION = '2.2.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-observers
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2020-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,11 +58,13 @@ files:
 - bin/console
 - bin/setup
 - lib/micro/observers.rb
+- lib/micro/observers/broadcast.rb
 - lib/micro/observers/event.rb
 - lib/micro/observers/event/names.rb
 - lib/micro/observers/for/active_model.rb
 - lib/micro/observers/for/active_record.rb
 - lib/micro/observers/set.rb
+- lib/micro/observers/subscribers.rb
 - lib/micro/observers/utils.rb
 - lib/micro/observers/version.rb
 - lib/u-observers.rb