u-observers 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2268ebc8924bf446ca73f3b1fbdb0cb4a8fba9f60eb01173e68fa7486747b1ed
-  data.tar.gz: 329fad95d53450a550c9fc964fec4bb3732f5a63d684835f0ef6d766df839d15
+  metadata.gz: 4c90f3338948cf8db02bdb1a882e3191adfd52f106fc2b4c1acf873447abd82a
+  data.tar.gz: 2db659fbaee101e1af2838bdb89dc85838f0e9686d14fe14fd9782fc568ee1f6
 SHA512:
-  metadata.gz: d3a2f1895221f171ca6499bca6284a9d349e77b9d6661b41a0b15c662d9f400af86d7d0b77e4331ca9a985b6db2d6628415be5422944cb09aba32d676aa537eb
-  data.tar.gz: 82daa067cd2cf85c3b00c0aca546131e38c1ee365336d5f01cb868b81d7b91be806ecb606c61ad5e56d2364f9341f8636d093f02d6b6f424ddccc0702b11f7e7
+  metadata.gz: 674b8dabdc6cfca0a982c1f72582bf1fcaab34ead0f0de29d4975cc62e164c13bbded5e6118152951584fb5855b6c539510ca393b36f9cf56622bf663d7b22e2
+  data.tar.gz: ff1e33f5029a40745172c7196d7e21552e8f4d534c71f057bf5643e3262fe8fa243fb55219eed352195a09abc51c337476f9f8bfcd5bce5f61cee416c2ec8de7

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.5

data/.travis.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+ruby_v=$(ruby -v)
+
+bundle update
+bundle exec rake test
+
+ACTIVERECORD_VERSION='3.2' bundle update
+ACTIVERECORD_VERSION='3.2' bundle exec rake test
+
+ACTIVERECORD_VERSION='4.0' bundle update
+ACTIVERECORD_VERSION='4.0' bundle exec rake test
+
+ACTIVERECORD_VERSION='4.1' bundle update
+ACTIVERECORD_VERSION='4.1' bundle exec rake test
+
+ACTIVERECORD_VERSION='4.2' bundle update
+ACTIVERECORD_VERSION='4.2' bundle exec rake test
+
+ACTIVERECORD_VERSION='5.0' bundle update
+ACTIVERECORD_VERSION='5.0' bundle exec rake test
+
+ACTIVERECORD_VERSION='5.1' bundle update
+ACTIVERECORD_VERSION='5.1' bundle exec rake test
+
+if [[ ! $ruby_v =~ '2.2.0' ]]; then
+  ACTIVERECORD_VERSION='5.2' bundle update
+  ACTIVERECORD_VERSION='5.2' bundle exec rake test
+fi
+
+if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
+  ACTIVERECORD_VERSION='6.0' bundle update
+  ACTIVERECORD_VERSION='6.0' bundle exec rake test
+fi

data/.travis.yml

@@ -1,6 +1,30 @@
 ---
 language: ruby
-cache: bundler
+
+sudo: false
+
 rvm:
-  - 2.6.5
-before_install: gem install bundler -v 2.1.4
+- 2.2.0
+- 2.3.0
+- 2.4.0
+- 2.5.0
+- 2.6.0
+- 2.7.0
+
+cache: bundler
+
+before_install:
+  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
+  - gem install bundler -v '< 2'
+
+install: bundle install --jobs=3 --retry=3
+
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - "./cc-test-reporter before-build"
+
+script: "./.travis.sh"
+
+after_success:
+  - "./cc-test-reporter after-build -t simplecov"

data/Gemfile

@@ -3,12 +3,38 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in u-observers.gemspec
 gemspec
 
-gem 'rake', '~> 12.0'
-gem 'minitest', '~> 5.0'
+activerecord_version = ENV.fetch('ACTIVERECORD_VERSION', '6.1')
+
+activerecord = case activerecord_version
+              when '3.2' then '3.2.22'
+              when '4.0' then '4.0.13'
+              when '4.1' then '4.1.16'
+              when '4.2' then '4.2.11'
+              when '5.0' then '5.0.7'
+              when '5.1' then '5.1.7'
+              when '5.2' then '5.2.3'
+              when '6.0' then '6.0.3'
+              end
+
+simplecov_version =
+  case RUBY_VERSION
+  when /\A2.[23]/ then '~> 0.17.1'
+  when /\A2.4/ then '~> 0.18.5'
+  else '~> 0.19'
+  end
 
 group :test do
-  gem 'activerecord', require: 'active_record'
-  gem 'sqlite3'
+  gem 'minitest', activerecord_version < '4.1' ? '~> 4.2' : '~> 5.0'
+  gem 'simplecov', simplecov_version, require: false
+
+  if activerecord
+    sqlite3 =
+      case activerecord
+      when /\A6\.0/, nil then '~> 1.4.0'
+      else '~> 1.3.0'
+      end
 
-  gem 'simplecov', '~> 0.19', require: false
+    gem 'sqlite3', sqlite3
+    gem 'activerecord', activerecord, require: 'active_record'
+  end
 end

data/README.md

@@ -1,28 +1,288 @@
-# Micro::Observers
+<p align="center">
+  <h1 align="center">👀 μ-observers</h1>
+  <p align="center"><i>Simple and powerful implementation of the observer pattern.</i></p>
+  <br>
+</p>
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/micro/observers`. To experiment with that code, run `bin/console` for an interactive prompt.
+<p align="center">
+  <img src="https://img.shields.io/badge/ruby->%3D%202.2.0-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
 
-TODO: Delete this and the text above, and describe your gem
+  <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>
 
-## Installation
+  <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>
 
-Add this line to your application's Gemfile:
+  <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>
+</p>
+
+This gem implements the observer pattern [[1]](https://en.wikipedia.org/wiki/Observer_pattern)[[2]](https://refactoring.guru/design-patterns/observer) (also known as publish/subscribe). It provides a simple mechanism for one object to inform a set of interested third-party objects when its state changes.
+
+Ruby's standard library [has an abstraction](https://ruby-doc.org/stdlib-2.7.1/libdoc/observer/rdoc/Observable.html) that enables you to use this pattern. But its design can conflict with other mainstream libraries, like the [`ActiveModel`/`ActiveRecord`](https://api.rubyonrails.org/classes/ActiveModel/Dirty.html#method-i-changed), which also has the [`changed`](https://ruby-doc.org/stdlib-2.7.1/libdoc/observer/rdoc/Observable.html#method-i-changed) method. In this case, the behavior of the Stdlib will be been compromised.
+
+Because of this issue, I decided to create a gem that encapsulates the pattern without changing the object's implementation so much. The `Micro::Observers` includes just one instance method in the target class (its instance will be the observed subject).
+
+# Table of contents <!-- omit in toc -->
+- [Installation](#installation)
+- [Compatibility](#compatibility)
+  - [Usage](#usage)
+    - [Passing a context for your observers](#passing-a-context-for-your-observers)
+    - [Calling the observers](#calling-the-observers)
+    - [Notifying observers without marking them as changed](#notifying-observers-without-marking-them-as-changed)
+    - [ActiveRecord and ActiveModel integrations](#activerecord-and-activemodel-integrations)
+      - [notify_observers_on()](#notify_observers_on)
+      - [notify_observers()](#notify_observers)
+  - [Development](#development)
+  - [Contributing](#contributing)
+  - [License](#license)
+  - [Code of Conduct](#code-of-conduct)
+
+# Installation
+
+Add this line to your application's Gemfile and `bundle install`:
 
 ```ruby
-gem 'micro-observers'
+gem 'u-observers'
 ```
 
-And then execute:
+# Compatibility
 
-    $ bundle install
+| u-observers | branch  | ruby     | activerecord  |
+| ----------- | ------- | -------- | ------------- |
+| 1.0.0       | main    | >= 2.2.0 | >= 3.2, < 6.1 |
 
-Or install it yourself as:
+> **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).
 
-    $ gem install u-observers
+[⬆️ Back to Top](#table-of-contents-)
 
 ## Usage
 
-TODO: Write usage instructions here
+Any class with `Micro::Observers` module included can notify events to attached observers.
+
+```ruby
+require 'securerandom'
+
+class Order
+  include Micro::Observers
+
+  attr_reader :code
+
+  def initialize
+    @code, @status = SecureRandom.alphanumeric, :draft
+  end
+
+  def canceled?
+    @status == :canceled
+  end
+
+  def cancel!
+    return self if canceled?
+
+    @status = :canceled
+
+    observers.subject_changed!
+    observers.notify(:canceled) and return self
+  end
+end
+
+module OrderEvents
+  def self.canceled(order)
+    puts "The order #(#{order.code}) has been canceled."
+  end
+end
+
+order = Order.new
+#<Order:0x00007fb5dd8fce70 @code="X0o9yf1GsdQFvLR4", @status=:draft>
+
+order.observers.attach(OrderEvents) # attaching multiple observers. e.g. observers.attach(A, B, C)
+# <#Micro::Observers::Manager @subject=#<Order:0x00007fb5dd8fce70> @subject_changed=false @subscribers=[OrderEvents]
+
+order.canceled?
+# false
+
+order.cancel!
+# The message below will be printed by the observer (OrderEvents):
+# The order #(X0o9yf1GsdQFvLR4) has been canceled
+
+order.canceled?
+# true
+```
+
+**Highlights of the previous example:**
+
+To avoid an undesired behavior, do you need to mark the subject as changed before notify your observers about some event.
+
+You can do this when using the `#subject_changed!` method. It will automatically mark the subject as changed.
+
+But if you need to apply some conditional to mark a change, you can use the `#subject_changed` method. e.g. `observers.subject_changed(name != new_name)`
+
+The `#notify` method always requires an event to make a broadcast. So, if you try to use it without one or more events (symbol values) you will get an exception.
+
+```ruby
+order.observers.notify
+# ArgumentError (no events (expected at least 1))
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Passing a context for your observers
+
+To pass a context (any kind of Ruby object) for one or more observers, you will need to use the `context:` keyword as the last argument of the `#attach` method.
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.subject_changed!
+    observers.notify(:canceled)
+    self
+  end
+end
+
+module OrderEvents
+  def self.canceled(order, context)
+    puts "The order #(#{order.code}) has been canceled. (from: #{context[:from]})"
+  end
+end
+
+order = Order.new
+order.observers.attach(OrderEvents, context: { from: 'example #2' ) # attaching multiple observers. e.g. observers.attach(A, B, context: {hello: :world})
+order.cancel!
+# The message below will be printed by the observer (OrderEvents):
+# The order #(70196221441820) has been canceled. (from: example #2)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Calling the observers
+
+You can use a callable (a class, module, or object that responds to the call method) to be your observers.
+To do this, you only need make use of the method `#call` instead of `#notify`.
+
+```ruby
+class Order
+  include Micro::Observers
+
+  def cancel!
+    observers.subject_changed!
+    observers.call # in practice, this is a shortcut to observers.notify(:call)
+    self
+  end
+end
+
+OrderCancellation = -> (order) { puts "The order #(#{order.object_id}) has been canceled." }
+
+order = Order.new
+order.observers.attach(OrderCancellation)
+order.cancel!
+# The message below will be printed by the observer (OrderEvents):
+# The order #(70196221441820) has been canceled.
+```
+
+PS: The `observers.call` can receive one or more events, but in this case, the default event (`call`) won't be transmitted.a
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Notifying observers without marking them as changed
+
+This feature needs to be used with caution!
+
+If you use the methods `#notify!` or `#call!` you won't need to mark observers with `#subject_changed`.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### ActiveRecord and ActiveModel integrations
+
+To make use of this feature you need to require an additional module (`require 'u-observers/for/active_record'`).
+
+Gemfile example:
+```ruby
+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 pass one or more `ActiveModel`/`ActiveRecord` callbacks, that will be used to notify your object observers.
+
+```ruby
+class Post < ActiveRecord::Base
+  include ::Micro::Observers::For::ActiveRecord
+
+  notify_observers_on(:after_commit) # passing multiple callbacks. e.g. notify_observers_on(:before_save, :after_commit)
+end
+
+module TitlePrinter
+  def self.after_commit(post)
+    puts "Title: #{post.title}"
+  end
+end
+
+module TitlePrinterWithContext
+  def self.after_commit(post, context)
+    puts "Title: #{post.title} (from: #{context[:from]})"
+  end
+end
+
+Post.transaction do
+  post = Post.new(title: 'Hello world')
+  post.observers.attach(TitlePrinter, TitlePrinterWithContext, context: { from: 'example 4' })
+  post.save
+end
+# The message below will be printed by the observer (OrderEvents):
+# Title: Hello world
+# Title: Hello world (from: example 4)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+#### notify_observers()
+
+The `notify_observers` allows you to pass one or more *events*, that will be used to notify after the execution of some `ActiveModel`/`ActiveRecord` callback.
+
+```ruby
+class Post < ActiveRecord::Base
+  include ::Micro::Observers::For::ActiveRecord
+
+  after_commit(&notify_observers(:transaction_completed))
+end
+
+module TitlePrinter
+  def self.transaction_completed(post)
+    puts("Title: #{post.title}")
+  end
+end
+
+module TitlePrinterWithContext
+  def self.transaction_completed(post, context)
+    puts("Title: #{post.title} (from: #{context[:from]})")
+  end
+end
+
+Post.transaction do
+  post = Post.new(title: 'Olá mundo')
+  post.observers.attach(TitlePrinter, TitlePrinterWithContext, context: { from: 'example 5' })
+  post.save
+end
+# The message below will be printed by the observer (OrderEvents):
+# Title: Olá mundo
+# Title: Olá mundo (from: example 5)
+```
+
+PS: You can use `include ::Micro::Observers::For::ActiveModel` if your class only makes use of the `ActiveModel` and all the previous examples will work.
+
+[⬆️ Back to Top](#table-of-contents-)
 
 ## Development
 

data/lib/micro/observers.rb

@@ -3,31 +3,11 @@ require 'micro/observers/version'
 module Micro
   module Observers
     require 'micro/observers/utils'
-    require 'micro/observers/events_or_actions'
+    require 'micro/observers/events'
     require 'micro/observers/manager'
 
-    module ClassMethods
-      def notify_observers!(with:)
-        proc { |object| with.each { |evt_or_act| object.observers.notify(evt_or_act) } }
-      end
-
-      def notify_observers(*events)
-        notify_observers!(with: EventsOrActions[events])
-      end
-
-      def call_observers(options = Utils::EMPTY_HASH)
-        notify_observers!(with: EventsOrActions.fetch_actions(options))
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:private_class_method, :notify_observers!)
-    end
-
     def observers
-      @observers ||= Observers::Manager.for(self)
+      @__observers ||= Observers::Manager.for(self)
     end
-
   end
 end

data/lib/micro/observers/events.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+
+    module Events
+      def self.[](value, default: Utils::EMPTY_ARRAY)
+        values = Utils.compact_array(value)
+
+        values.empty? ? default : values
+      end
+
+      NO_EVENTS_MSG = 'no events (expected at least 1)'.freeze
+
+      def self.fetch(value)
+        values = self[value]
+
+        return values unless values.empty?
+
+        raise ArgumentError, NO_EVENTS_MSG
+      end
+
+      private_constant :NO_EVENTS_MSG
+    end
+
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+    module For
+
+      module ActiveModel
+        module ClassMethods
+          def notify_observers!(events)
+            proc do |object|
+              object.observers.subject_changed!
+              object.observers.send(:broadcast_if_subject_changed, events)
+            end
+          end
+
+          def notify_observers(*events)
+            notify_observers!(Events.fetch(events))
+          end
+
+          def notify_observers_on(*callback_methods)
+            Utils.compact_array(callback_methods).each do |callback_method|
+              self.public_send(callback_method, &notify_observers!([callback_method]))
+            end
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.send(:private_class_method, :notify_observers!)
+          base.send(:include, ::Micro::Observers)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+    module For
+      require 'micro/observers/for/active_model'
+
+      module ActiveRecord
+        def self.included(base)
+          base.send(:include, ::Micro::Observers::For::ActiveModel)
+        end
+      end
+
+    end
+  end
+end

data/lib/micro/observers/manager.rb

@@ -4,27 +4,78 @@ module Micro
   module Observers
 
     class Manager
-      EqualTo = -> (observer) do
-        -> item { item[0] == :observer && item[1] == observer }
+      MapSubscriber = -> (observer, options) { [:observer, observer, options[:context]] }
+
+      MapSubscribers = -> (value) do
+        array = Utils.compact_array(value.kind_of?(Array) ? value : [])
+        array.map { |observer| MapSubscriber[observer, Utils::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, list = nil)
+      def initialize(subject, subscribers: nil)
         @subject = subject
 
-        @list = Utils.compact_array(list.kind_of?(Array) ? list : [])
+        @subject_changed = false
+
+        @subscribers = MapSubscribers.call(subscribers)
+      end
+
+      def count
+        @subscribers.size
+      end
+
+      def none?
+        @subscribers.empty?
+      end
+
+      def some?
+        !none?
+      end
+
+      def subject_changed?
+        @subject_changed
+      end
+
+      INVALID_BOOLEAN_MSG = 'expected a boolean (true, false)'.freeze
+
+      def subject_changed(state)
+        if state == true || state == false
+          @subject_changed = state
+
+          return self
+        end
+
+        raise ArgumentError, INVALID_BOOLEAN_MSG
+      end
+
+      def subject_changed!
+        subject_changed(true)
       end
 
       def included?(observer)
-        @list.any?(&EqualTo[observer])
+        @subscribers.any?(&EqualTo[observer])
       end
 
-      def attach(observer, options = Utils::EMPTY_HASH)
-        if options[:allow_duplication] || !included?(observer)
-          @list << [:observer, observer, options[:data]]
+      def attach(*args)
+        options = args.last.is_a?(Hash) ? args.pop : Utils::EMPTY_HASH
+
+        Utils.compact_array(args).each do |observer|
+          @subscribers << MapSubscriber[observer, options] unless included?(observer)
+        end
+
+        self
+      end
+
+      def detach(*args)
+        Utils.compact_array(args).each do |observer|
+          @subscribers.delete_if(&EqualTo[observer])
         end
 
         self
@@ -35,50 +86,86 @@ module Micro
 
         return self unless event.is_a?(Symbol) && callable.respond_to?(:call)
 
-        arg = with.is_a?(Proc) ? with.call(@subject) : (arg || subject)
+        @subscribers << [:callable, event, [callable, with]] unless included?(callable)
 
-        @list << [:callable, event, [callable, arg]]
+        self
       end
 
-      def detach(observer)
-        @list.delete_if(&EqualTo[observer])
+      def notify(*events)
+        broadcast_if_subject_changed(Events.fetch(events))
 
         self
       end
 
-      def notify(*events)
-        EventsOrActions[events].each { |act| notify!(act) }
+      def notify!(*events)
+        broadcast(Events.fetch(events))
+
+        self
+      end
+
+      CALL_EVENT = [:call].freeze
+
+      def call(*events)
+        broadcast_if_subject_changed(Events[events, default: CALL_EVENT])
 
         self
       end
 
-      def call(options = Utils::EMPTY_HASH)
-        EventsOrActions.fetch_actions(options).each { |act| notify!(act) }
+      def call!(*events)
+        broadcast(Events[events, default: CALL_EVENT])
 
         self
       end
 
+      def inspect
+        subs = @subscribers.empty? ? @subscribers : @subscribers.map(&GetObserver)
+
+        '<#%s @subject=%s @subject_changed=%p @subscribers=%p>' % [self.class, @subject, @subject_changed, subs]
+      end
+
       private
 
-        def notify!(evt_or_act)
-          @list.each do |strategy, observer, data|
-            call!(observer, strategy, data, with: evt_or_act)
+        def broadcast_if_subject_changed(events)
+          return unless subject_changed?
+
+          broadcast(events)
+
+          subject_changed(false)
+        end
+
+        def broadcast(events)
+          return if @subscribers.empty?
+
+          events.each do |event|
+            @subscribers.each do |strategy, observer, context|
+              case strategy
+              when :observer then notify_observer(observer, event, context)
+              when :callable then notify_callable(observer, event, context)
+              end
+            end
           end
         end
 
-        def call!(observer, strategy, data, with:)
-          return data[0].call(data[1]) if strategy == :callable && observer == with
+        def notify_observer(observer, method_name, context)
+          return unless observer.respond_to?(method_name)
 
-          if strategy == :observer && observer.respond_to?(with)
-            handler = observer.method(with)
+          handler = observer.is_a?(Proc) ? observer : observer.method(method_name)
 
-            return handler.call(@subject) if handler.arity == 1
+          handler.arity == 1 ? handler.call(@subject) : handler.call(@subject, context)
+        end
 
-            handler.call(@subject, data)
-          end
+        def notify_callable(expected_event, event, context)
+          return if expected_event != event
+
+          callable, with = context[0], context[1]
+
+          arg = with.is_a?(Proc) ? with.call(@subject) : (with || @subject)
+
+          callable.call(arg)
         end
 
-      private_constant :EqualTo
+      private_constant :INVALID_BOOLEAN_MSG, :CALL_EVENT
+      private_constant :MapSubscriber, :MapSubscribers, :GetObserver, :EqualTo
     end
 
   end

data/lib/micro/observers/utils.rb

@@ -5,6 +5,7 @@ module Micro
 
     module Utils
       EMPTY_HASH = {}.freeze
+      EMPTY_ARRAY = [].freeze
 
       def self.compact_array(value)
         Array(value).flatten.tap(&:compact!)

data/lib/micro/observers/version.rb

@@ -1,5 +1,5 @@
 module Micro
   module Observers
-    VERSION = '0.5.0'
+    VERSION = '1.0.0'
   end
 end

data/lib/u-observers/for/active_model.rb

@@ -0,0 +1,2 @@
+require 'micro/observers'
+require 'micro/observers/for/active_model'

data/lib/u-observers/for/active_record.rb

@@ -0,0 +1,2 @@
+require 'micro/observers'
+require 'micro/observers/for/active_record'

data/test.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+bundle
+
+rm Gemfile.lock
+
+source $(dirname $0)/.travis.sh
+
+rm Gemfile.lock
+
+bundle

data/u-observers.gemspec

@@ -10,7 +10,6 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Simple and powerful implementation of the observer pattern.}
   spec.homepage      = 'https://github.com/serradura/u-observers'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.2.0')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/serradura/u-observers'
@@ -24,4 +23,9 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   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.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 13.0'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: u-observers
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-26 00:00:00.000000000 Z
-dependencies: []
+date: 2020-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 description: Simple and powerful implementation of the observer pattern.
 email:
 - rodrigo.serradura@gmail.com
@@ -18,6 +46,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
+- ".travis.sh"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -27,11 +57,16 @@ files:
 - bin/console
 - bin/setup
 - lib/micro/observers.rb
-- lib/micro/observers/events_or_actions.rb
+- lib/micro/observers/events.rb
+- lib/micro/observers/for/active_model.rb
+- lib/micro/observers/for/active_record.rb
 - lib/micro/observers/manager.rb
 - lib/micro/observers/utils.rb
 - lib/micro/observers/version.rb
 - lib/u-observers.rb
+- lib/u-observers/for/active_model.rb
+- lib/u-observers/for/active_record.rb
+- test.sh
 - u-observers.gemspec
 homepage: https://github.com/serradura/u-observers
 licenses:

data/lib/micro/observers/events_or_actions.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Micro
-  module Observers
-
-    module EventsOrActions
-      DEFAULTS = [:call]
-
-      def self.[](value)
-        values = Utils.compact_array(value)
-
-        values.empty? ? DEFAULTS : values
-      end
-
-      def self.fetch_actions(hash)
-        return self[hash.fetch(:actions) { hash.fetch(:action) }] if hash.is_a?(Hash)
-
-        raise ArgumentError, 'expected a hash with the key :action or :actions'
-      end
-
-      private_constant :DEFAULTS
-    end
-
-  end
-end