u-observers 2.2.1 → 3.0.0

data/README.pt-BR.md

@@ -1,29 +1,28 @@
 <p align="center">
   <h1 align="center">👀 μ-observers</h1>
   <p align="center"><i>Implementação simples e poderosa do padrão observer.</i></p>
-  <br>
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/ruby->%3D%202.2.0-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
-
   <a href="https://rubygems.org/gems/u-observers">
     <img alt="Gem" src="https://img.shields.io/gem/v/u-observers.svg?style=flat-square">
   </a>
-
-  <a href="https://travis-ci.com/serradura/u-observers">
-    <img alt="Build Status" src="https://travis-ci.com/serradura/u-observers.svg?branch=main">
-  </a>
-
-  <a href="https://codeclimate.com/github/serradura/u-observers/maintainability">
-    <img alt="Maintainability" src="https://api.codeclimate.com/v1/badges/e72ffa84bc95c59823f2/maintainability">
-  </a>
-
-  <a href="https://codeclimate.com/github/serradura/u-observers/test_coverage">
-    <img alt="Test Coverage" src="https://api.codeclimate.com/v1/badges/e72ffa84bc95c59823f2/test_coverage">
+  <a href="https://github.com/u-gems/u-observers/actions/workflows/ci.yml">
+    <img alt="Build Status" src="https://github.com/u-gems/u-observers/actions/workflows/ci.yml/badge.svg">
   </a>
+  <br/>
+  <a href="https://qlty.sh/gh/u-gems/projects/u-observers"><img src="https://qlty.sh/gh/u-gems/projects/u-observers/maintainability.svg" alt="Maintainability" /></a>
+  <a href="https://qlty.sh/gh/u-gems/projects/u-observers"><img src="https://qlty.sh/gh/u-gems/projects/u-observers/coverage.svg" alt="Code Coverage" /></a>
+  <br/>
+  <img src="https://img.shields.io/badge/Ruby%20%3E%3D%202.7%2C%20%3C%3D%20Head-ruby.svg?colorA=444&colorB=333" alt="Ruby">
+  <img src="https://img.shields.io/badge/Rails%20%3E%3D%206.0%2C%20%3C%3D%20Edge-rails.svg?colorA=444&colorB=333" alt="Rails">
 </p>
 
+> [!IMPORTANT]
+> **Nenhuma mudança que quebre a API — nunca.** `u-observers` é uma gem sem dependências da qual muitos projetos dependem (direta ou transitivamente). Seu papel é permanecer uma base estável e retrocompatível — toda mudança mantém o código existente funcionando.
+>
+> Saltos de versão major sinalizam apenas que uma versão de Ruby ou Rails foi removida da matriz suportada — pela SemVer, uma mudança no piso de dependências. Seu código continua funcionando.
+
 Esta gem implementa o padrão observer[[1]](https://en.wikipedia.org/wiki/Observer_pattern)[[2]](https://refactoring.guru/design-patterns/observer) (também conhecido como publicar/assinar). Ela fornece um mecanismo simples para um objeto informar um conjunto de objetos de terceiros interessados ​​quando seu estado muda.
 
 A biblioteca padrão do Ruby [tem uma abstração](https://ruby-doc.org/stdlib-2.7.1/libdoc/observer/rdoc/Observable.html) que permite usar esse padrão, mas seu design pode entrar em conflito com outras bibliotecas convencionais, como [`ActiveModel`/`ActiveRecord`](https://api.rubyonrails.org/classes/ActiveModel/Dirty.html#method-i-changed), que também tem o método [`changed`](https://ruby-doc.org/stdlib-2.7.1/libdoc/observer/rdoc/Observable.html#method-i-changed). Nesse caso, o comportamento ficaria comprometido por conta dessa sobrescrita de métodos.
@@ -44,10 +43,15 @@ Por causa desse problema, decidi criar uma gem que encapsula o padrão sem alter
     - [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-)
+    - [Definindo observers com blocos](#definindo-observers-com-blocos)
+      - [`observers.on()`](#observerson)
+      - [`observers.once()`](#observersonce)
+      - [Substituindo um bloco por um `lambda`/`proc`](#substituindo-um-bloco-por-um-lambdaproc)
     - [Desanexando observers](#desanexando-observers)
     - [Integrações ActiveRecord e ActiveModel](#integrações-activerecord-e-activemodel)
-      - [notify_observers_on()](#notify_observers_on)
-      - [notify_observers()](#notify_observers)
+      - [`.notify_observers_on()`](#notify_observers_on)
+      - [Anexando observers no nível da classe (`.notify_observers!()`)](#anexando-observers-no-nível-da-classe-notify_observers)
+      - [`.notify_observers()`](#notify_observers)
   - [Desenvolvimento](#desenvolvimento)
   - [Contribuindo](#contribuindo)
   - [License](#license)
@@ -63,11 +67,24 @@ gem 'u-observers'
 
 # Compatibilidade
 
-| u-observers | branch  | ruby     | activerecord  |
-| ----------- | ------- | -------- | ------------- |
-| unreleased  | main    | >= 2.2.0 | >= 3.2, < 6.1 |
-| 2.2.1       | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
-| 1.0.0       | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
+| u-observers | branch | ruby     | activerecord    |
+| ----------- | ------ | -------- | --------------- |
+| 3.0.0       | main   | >= 2.7.0 | >= 6.0, <= Edge |
+| 2.3.0       | v2.x   | >= 2.2.0 | >= 3.2, < 6.1   |
+| 1.0.0       | v1.x   | >= 2.2.0 | >= 3.2, < 6.1   |
+
+Esta biblioteca é testada (CI matrix) contra:
+
+| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | 7.2 | 8.0 | 8.1 | Edge |
+| ------------ | --- | --- | --- | --- | --- | --- | --- | ---- |
+| 2.7          | ✅  | ✅  | ✅  | ✅  |     |     |     |      |
+| 3.0          | ✅  | ✅  | ✅  | ✅  |     |     |     |      |
+| 3.1          |     |     | ✅  | ✅  | ✅  |     |     |      |
+| 3.2          |     |     | ✅  | ✅  | ✅  | ✅  |     |      |
+| 3.3          |     |     | ✅  | ✅  | ✅  | ✅  | ✅  | ✅   |
+| 3.4          |     |     |     |     | ✅  | ✅  | ✅  | ✅   |
+| 4.x          |     |     |     |     |     |     | ✅  | ✅   |
+| Head         |     |     |     |     |     |     | ✅  | ✅   |
 
 > **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).
 
@@ -154,7 +171,7 @@ order.observers.notify
 
 ### Compartilhando um contexto com seus observadores
 
-Para compartilhar um valor de contexto (qualquer tipo de objeto Ruby) com um ou mais observadores, você precisará usar a palavra-chave `:context` como o último argumento do  método `#attach`. Este recurso oferece a você uma oportunidade única de compartilhar um valor no momento de anexar um *observer*.
+Para compartilhar um valor de contexto (qualquer tipo de objeto Ruby) com um ou mais observadores, você precisará usar a palavra-chave `:context` como o último argumento do método `#attach`. Este recurso oferece a você uma oportunidade única de compartilhar um valor no momento de anexar um _observer_.
 
 Quando o método do observer receber dois argumentos, o primeiro será o sujeito e o segundo uma instância `Micro::Observers::Event` que terá o valor do contexto.
 
@@ -186,7 +203,7 @@ order.cancel!
 
 ### Compartilhando dados ao notificar os observadores
 
-Como mencionado anteriormente, o [`event context`](#compartilhando-um-contexto-com-seus-observadores) é um valor armazenado quando você anexa seu *observer*. Mas, às vezes, será útil enviar alguns dados adicionais ao transmitir um evento aos seus *observers*. O `event data` dá a você esta oportunidade única de compartilhar algum valor no momento da notificação.
+Como mencionado anteriormente, o [`event context`](#compartilhando-um-contexto-com-seus-observadores) é um valor armazenado quando você anexa seu _observer_. Mas, às vezes, será útil enviar alguns dados adicionais ao transmitir um evento aos seus _observers_. O `event data` dá a você esta oportunidade única de compartilhar algum valor no momento da notificação.
 
 ```ruby
 class Order
@@ -213,12 +230,13 @@ order.observers.notify(:changed, data: 1)
 ### O que é `Micro::Observers::Event`?
 
 O `Micro::Observers::Event` é o payload do evento. Veja abaixo todas as suas propriedades:
+
 - `#name` será o evento transmitido.
 - `#subject` será o sujeito observado.
-- `#context` serão [os dados de contexto](#compartilhando-um-contexto-com-seus-observadores) que foram definidos no momento em que você anexa o *observer*.
+- `#context` serão [os dados de contexto](#compartilhando-um-contexto-com-seus-observadores) que foram definidos no momento em que você anexa o _observer_.
 - `#data` será [o valor compartilhado na notificação dos observadores](#compartilhando-dados-ao-notificar-os-observadores).
 - `#ctx` é um apelido para o método `#context`.
-- `#subj` é um *alias* para o método `#subject`.
+- `#subj` é um _alias_ para o método `#subject`.
 
 [⬆️ Voltar para o índice](#índice-)
 
@@ -229,10 +247,11 @@ O método `observers.on()` permite que você anexe um callable (objeto que respo
 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
@@ -276,7 +295,7 @@ person.name = 'Coutinho'
 
 ### Chamando os observadores
 
-Você pode usar um callable (uma classe, módulo ou objeto que responda ao método `call`) para ser seu *observer*. Para fazer isso, você só precisa usar o método `#call` em vez de `#notify`.
+Você pode usar um callable (uma classe, módulo ou objeto que responda ao método `call`) para ser seu _observer_. Para fazer isso, você só precisa usar o método `#call` em vez de `#notify`.
 
 ```ruby
 class Order
@@ -373,7 +392,84 @@ order.observers.some? # false
 order.cancel!         # Nothing will happen because there aren't observers.
 ```
 
-[⬆️ &nbsp; Back to Top](#table-of-contents-)
+[⬆️ Voltar para o índice](#índice-)
+
+### Definindo observers com blocos
+
+Os métodos `#on()` e `#once()` podem receber um evento (a `symbol`) e um bloco para definir observers.
+
+#### `observers.on()`
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+order = Order.new
+order.observers.on(:canceled) do |event|
+  puts "The order #(#{event.subject.object_id}) has been canceled."
+end
+
+order.observers.some? # true
+
+order.cancel!         # The order #(70301497466060) has been canceled.
+
+order.observers.some? # true
+```
+
+#### `observers.once()`
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+order = Order.new
+order.observers.once(:canceled) do |event|
+  puts "The order #(#{event.subject.object_id}) has been canceled."
+end
+
+order.observers.some? # true
+
+order.cancel!         # The order #(70301497466060) has been canceled.
+
+order.observers.some? # false
+```
+
+#### Substituindo um bloco por um `lambda`/`proc`
+
+Ruby permite que você substitua qualquer bloco com um `lambda`/`proc`. Portanto, será possível usar este tipo de recurso para definir seus observers. Exemplo:
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.notify!(:canceled)
+  end
+end
+
+NotifyAfterCancel = -> event { puts "The order #(#{event.subject.object_id}) has been canceled." }
+
+order = Order.new
+order.observers.once(:canceled, &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.
+```
+
+[⬆️ Voltar para o índice](#índice-)
 
 ### Desanexando observers
 
@@ -394,11 +490,12 @@ module OrderNotifications
 end
 
 order = Order.new
+order.observers.on(:canceled) { |_event| }
 order.observers.on(event: :canceled, call: NotifyAfterCancel)
 order.observers.attach(OrderNotifications)
 
 order.observers.some? # true
-order.observers.count # 2
+order.observers.count # 3
 
 order.observers.off(:canceled) # removing the callable (NotifyAfterCancel).
 order.observers.some? # true
@@ -409,22 +506,23 @@ order.observers.some? # false
 order.observers.count # 0
 ```
 
-[⬆️ &nbsp; Back to Top](#table-of-contents-)
+[⬆️ Voltar para o índice](#índice-)
 
 ### Integrações ActiveRecord e ActiveModel
 
 Para fazer uso deste recurso, você precisa de um módulo adicional.
 
 Exemplo de Gemfile:
+
 ```ruby
 gem 'u-observers', require: 'u-observers/for/active_record'
 ```
 
 Este recurso irá expor módulos que podem ser usados ​​para adicionar macros (métodos estáticos) que foram projetados para funcionar com os callbacks do `ActiveModel`/`ActiveRecord`. Exemplo:
 
-#### notify_observers_on()
+#### `.notify_observers_on()`
 
-O `notify_observers_on` permite que você defina um ou mais callbacks do `ActiveModel`/`ActiveRecord`, que serão usados ​​para notificar seus *observers*.
+O `notify_observers_on` permite que você defina um ou mais callbacks do `ActiveModel`/`ActiveRecord`, que serão usados ​​para notificar seus _observers_.
 
 ```ruby
 class Post < ActiveRecord::Base
@@ -465,7 +563,62 @@ end
 
 [⬆️ Voltar para o índice](#índice-)
 
-#### notify_observers()
+#### Anexando observers no nível da classe (`.notify_observers!()`)
+
+Enquanto o `notify_observers_on` apenas conecta o callback a um broadcast (você ainda precisa chamar `attach` em cada instância), o `notify_observers!` também **vincula os _observers_ ao modelo no nível da classe** através da opção obrigatória `with:` — assim você nunca chama `observers.attach`. A opção `event:` nomeia o callback a ser usado; use `context:` para encaminhar um contexto para esses _observers_, e passe qualquer opção extra (por exemplo, `on:`) diretamente para o callback subjacente.
+
+```ruby
+class Post < ActiveRecord::Base
+  include ::Micro::Observers::For::ActiveRecord
+
+  # Anexa TitlePrinter (e TitlePrinterWithContext) em todo after_commit
+  # disparado por um update — sem precisar de `observers.attach` por instância.
+  notify_observers!(
+    on: :update,
+    with: [TitlePrinter, TitlePrinterWithContext],
+    event: :after_commit,
+    context: { from: 'class-level' }
+  )
+
+  # Equivalente a:
+  #
+  # after_commit(on: :update) do |record|
+  #   record.observers.attach(TitlePrinter, TitlePrinterWithContext, context: { from: 'class-level' })
+  #   record.observers.subject_changed!
+  #   record.observers.notify(:after_commit)
+  # end
+end
+
+Post.transaction { Post.create(title: 'Hello world') } # nada — `on: :update`
+
+post = Post.first
+Post.transaction { post.update(title: 'Hello again') }
+# Title: Hello again
+# Title: Hello again (de: class-level)
+```
+
+> **Nota**: `event:` e `with:` são obrigatórios (`with:` aceita um único _observer_ ou um array). Sem _observers_ para anexar, use o `notify_observers_on`.
+
+Os _observers_ declarados são inspecionáveis e removíveis no nível da classe:
+
+```ruby
+Post.observers_to_notify
+# { after_commit: [TitlePrinter, TitlePrinterWithContext] }
+
+# Para de notificar um dado observer (de todos os callbacks, ou use `from:` para limitar)
+Post.detach_observers_to_notify(TitlePrinterWithContext)
+# { after_commit: [TitlePrinter] }
+
+Post.detach_observers_to_notify(TitlePrinter, from: :after_commit)
+# {}
+
+# Sem observers, remove o(s) callback(s) por completo:
+Post.detach_observers_to_notify(from: :after_commit)
+```
+
+[⬆️ Voltar para o índice](#índice-)
+
+#### `.notify_observers()`
 
 O `notify_observers` permite definir um ou mais eventos, que serão utilizados para notificar após a execução de algum callback do `ActiveModel`/`ActiveRecord`.
 
@@ -483,12 +636,6 @@ class Post < ActiveRecord::Base
   # end
 end
 
-module TitlePrinter
-  def self.transaction_completed(post)
-    puts("Title: #{post.title}")
-  end
-end
-
 module TitlePrinterWithContext
   def self.transaction_completed(post, event)
     puts("Title: #{post.title} (from: #{event.ctx[:from]})")
@@ -497,7 +644,11 @@ end
 
 Post.transaction do
   post = Post.new(title: 'Olá mundo')
-  post.observers.attach(TitlePrinter, TitlePrinterWithContext, context: { from: 'example #7' })
+
+  post.observers.on(:transaction_completed) { |event| puts("Title: #{event.subject.title}") }
+
+  post.observers.attach(TitlePrinterWithContext, context: { from: 'example #7' })
+
   post.save
 end
 
@@ -518,7 +669,7 @@ Para instalar esta gem em sua máquina local, execute `bundle exec rake install`
 
 ## Contribuindo
 
-Reportar bugs e solicitações de pull-requests são bem-vindos no GitHub em https://github.com/serradura/u-observers. Este projeto pretende ser um espaço seguro e acolhedor para colaboração, e espera-se que os colaboradores sigam o [código de conduta](https://github.com/serradura/u-observers/blob/master/CODE_OF_CONDUCT.md).
+Reportar bugs e solicitações de pull-requests são bem-vindos no GitHub em https://github.com/u-gems/u-observers. Este projeto pretende ser um espaço seguro e acolhedor para colaboração, e espera-se que os colaboradores sigam o [código de conduta](https://github.com/u-gems/u-observers/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -526,4 +677,4 @@ A gem está disponível como código aberto sob os termos da [Licença MIT](http
 
 ## Código de conduta
 
-Espera-se que todos que interagem nas bases de código do projeto `Micro::Observers`, rastreadores de problemas, salas de bate-papo e listas de discussão sigam o [código de conduta](https://github.com/serradura/u-observers/blob/master/CODE_OF_CONDUCT.md).
+Espera-se que todos que interagem nas bases de código do projeto `Micro::Observers`, rastreadores de problemas, salas de bate-papo e listas de discussão sigam o [código de conduta](https://github.com/u-gems/u-observers/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -7,4 +7,34 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+require 'appraisal/task'
+
+Appraisal::Task.new
+
+desc 'Run the full test suite against every supported Rails version'
+task :matrix do
+  appraisals =
+    if RUBY_VERSION < '3.1'
+      %w[rails-6-0 rails-6-1 rails-7-0 rails-7-1]
+    elsif RUBY_VERSION < '3.2'
+      %w[rails-7-0 rails-7-1 rails-7-2]
+    elsif RUBY_VERSION < '3.3'
+      %w[rails-7-0 rails-7-1 rails-7-2 rails-8-0]
+    elsif RUBY_VERSION < '3.4'
+      %w[rails-7-0 rails-7-1 rails-7-2 rails-8-0 rails-8-1 rails-edge]
+    elsif RUBY_VERSION < '4.0'
+      %w[rails-7-2 rails-8-0 rails-8-1 rails-edge]
+    else
+      %w[rails-8-1 rails-edge]
+    end
+
+  # Baseline (no activerecord)
+  sh 'bundle exec rake test'
+
+  # Each activerecord appraisal
+  appraisals.each do |appraisal|
+    sh "bundle exec appraisal #{appraisal} rake test"
+  end
+end
+
+task default: :test

data/bin/matrix

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+ruby -v
+
+rm -f Gemfile.lock
+
+bundle install
+
+bundle exec appraisal update
+
+bundle exec rake matrix
+
+ruby -v

data/bin/setup

@@ -3,6 +3,10 @@ set -euo pipefail
 IFS=$'\n\t'
 set -vx
 
+rm -f Gemfile.lock
+
 bundle install
 
+bundle exec appraisal install
+
 # Do any other automated setup that you need to do here

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

@@ -6,7 +6,7 @@ module Micro
 
       module ActiveModel
         module ClassMethods
-          def notify_observers!(events)
+          def notify_observers_proc(events)
             proc do |object|
               object.observers.subject_changed!
               object.observers.send(:broadcast_if_subject_changed, events)
@@ -14,19 +14,133 @@ module Micro
           end
 
           def notify_observers(*events)
-            notify_observers!(Event::Names.fetch(events))
+            notify_observers_proc(Event::Names.fetch(events))
           end
 
           def notify_observers_on(*callback_methods)
             Utils::Arrays.fetch_from_args(callback_methods).each do |callback_method|
-              self.public_send(callback_method, &notify_observers!([callback_method]))
+              self.public_send(callback_method, &notify_observers_proc([callback_method]))
             end
           end
+
+          NO_OBSERVERS_TO_NOTIFY_MSG =
+            'no observers (expected at least one observer in `with:`)'.freeze
+
+          NO_EVENT_TO_NOTIFY_MSG =
+            'no event (expected a callback name in `event:`)'.freeze
+
+          def notify_observers!(event:, with:, context: nil, **callback_options)
+            observers = Utils::Arrays.flatten_and_compact(with)
+
+            raise ArgumentError, NO_OBSERVERS_TO_NOTIFY_MSG if observers.empty?
+
+            events = Utils::Arrays.flatten_and_compact(event)
+
+            raise ArgumentError, NO_EVENT_TO_NOTIFY_MSG if events.empty?
+
+            events.each do |callback_method|
+              register_observers_to_notify(callback_method, observers, context)
+
+              install_observers_to_notify_callback(callback_method, callback_options)
+            end
+          end
+
+          # Introspection: the observers declared via `notify_observers!`, keyed
+          # by the callback they fire on. e.g. { after_commit: [TitlePrinter] }
+          def observers_to_notify
+            __observers_to_notify.each_with_object({}) do |(event, entries), result|
+              result[event] = entries.map { |observer, _context| observer } unless entries.empty?
+            end
+          end
+
+          # Remove previously declared observers. Without `from:` they are
+          # removed from every callback; pass `from:` (a callback name or an
+          # array of them) to scope it. With no observers, clears the callback(s).
+          def detach_observers_to_notify(*observers, from: nil)
+            observers = Utils::Arrays.flatten_and_compact(observers)
+            events = from ? Utils::Arrays.flatten_and_compact(from) : __observers_to_notify.keys
+
+            events.each do |event|
+              entries = __observers_to_notify[event]
+
+              next unless entries
+
+              if observers.empty?
+                __observers_to_notify.delete(event)
+              else
+                entries.reject! { |observer, _context| observers.include?(observer) }
+                __observers_to_notify.delete(event) if entries.empty?
+              end
+            end
+
+            observers_to_notify
+          end
+
+          def register_observers_to_notify(event, observers, context)
+            entries = (__observers_to_notify[event] ||= [])
+
+            observers.each do |observer|
+              entries << [observer, context] unless entries.any? { |existing, _| existing == observer }
+            end
+          end
+
+          def install_observers_to_notify_callback(event, callback_options)
+            installed = __observers_to_notify_callbacks
+
+            return if installed[event]
+
+            installed[event] = true
+
+            declaring_class = self
+
+            callback_block = proc do |record|
+              declaring_class.send(:notify_registered_observers, record, event)
+            end
+
+            if callback_options.empty?
+              self.public_send(event, &callback_block)
+            else
+              self.public_send(event, **callback_options, &callback_block)
+            end
+          end
+
+          def notify_registered_observers(record, event)
+            entries = __observers_to_notify[event]
+
+            return if entries.nil? || entries.empty?
+
+            set = record.observers
+
+            entries.each do |observer, context|
+              context ? set.attach(observer, context: context) : set.attach(observer)
+            end
+
+            set.subject_changed!
+            set.send(:broadcast_if_subject_changed, [event])
+          end
+
+          def __observers_to_notify
+            @__observers_to_notify ||= {}
+          end
+
+          def __observers_to_notify_callbacks
+            @__observers_to_notify_callbacks ||= {}
+          end
+
+          private_constant :NO_OBSERVERS_TO_NOTIFY_MSG, :NO_EVENT_TO_NOTIFY_MSG
         end
 
         def self.included(base)
           base.extend(ClassMethods)
-          base.send(:private_class_method, :notify_observers!)
+          base.send(
+            :private_class_method,
+            :notify_observers_proc,
+            :register_observers_to_notify,
+            :install_observers_to_notify_callback,
+            :notify_registered_observers,
+            :__observers_to_notify,
+            :__observers_to_notify_callbacks
+          )
           base.send(:include, ::Micro::Observers)
         end
       end

data/lib/micro/observers/set.rb

@@ -42,13 +42,20 @@ module Micro
       def attach(*args); @subscribers.attach(args) and self; end
       def detach(*args); @subscribers.detach(args) and self; end
 
-      def on(options = Utils::EMPTY_HASH); @subscribers.on(options) and self; end
-      def once(options = Utils::EMPTY_HASH); @subscribers.once(options) and self; end
+      CallableOptions = -> (arg, block) do
+        arg.is_a?(Symbol) && block ? { event: arg, call: block } : arg
+      end
+
+      def on(arg = Utils::EMPTY_HASH, &block)
+        @subscribers.on(CallableOptions[arg, block]) and self
+      end
 
-      def off(*args)
-        @subscribers.off(args) and self
+      def once(arg = Utils::EMPTY_HASH, &block)
+        @subscribers.once(CallableOptions[arg, block]) and self
       end
 
+      def off(*args); @subscribers.off(args) and self; end
+
       def notify(*events, data: nil)
         broadcast_if_subject_changed(Event::Names.fetch(events), data)
       end
@@ -93,7 +100,7 @@ module Micro
           self
         end
 
-      private_constant :INVALID_BOOLEAN_MSG, :CALL_EVENT
+      private_constant :INVALID_BOOLEAN_MSG, :CALL_EVENT; :CallableOptions
     end
 
   end

data/lib/micro/observers/version.rb

@@ -1,5 +1,5 @@
 module Micro
   module Observers
-    VERSION = '2.2.1'
+    VERSION = '3.0.0'
   end
 end

data/u-observers.gemspec

@@ -8,12 +8,13 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Simple and powerful implementation of the observer pattern.}
   spec.description   = %q{Simple and powerful implementation of the observer pattern.}
-  spec.homepage      = 'https://github.com/serradura/u-observers'
+  spec.homepage      = 'https://github.com/u-gems/u-observers'
   spec.license       = 'MIT'
 
   spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/serradura/u-observers'
-  spec.metadata['changelog_uri'] = 'https://github.com/serradura/u-observers/releases'
+  spec.metadata['source_code_uri'] = 'https://github.com/u-gems/u-observers'
+  spec.metadata['changelog_uri'] = 'https://github.com/u-gems/u-observers/blob/main/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -24,8 +25,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.2.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
 
+  spec.add_development_dependency 'appraisal', '~> 2.5'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 13.0'
 end