u-observers 0.7.0 → 2.1.0

data/lib/micro/observers/event.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+
+    class Event
+      require 'micro/observers/event/names'
+
+      attr_reader :name, :subject, :context, :data
+
+      def initialize(name, subject, context, data)
+        @name, @subject = name, subject
+        @context, @data = context, data
+      end
+
+      alias ctx context
+      alias subj subject
+    end
+
+  end
+end

data/lib/micro/observers/event/names.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+
+    class Event::Names
+      EMPTY_ARRAY = [].freeze
+
+      def self.[](value, default: EMPTY_ARRAY)
+        values = Utils::Arrays.flatten_and_compact(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!(Event::Names.fetch(events))
+          end
+
+          def notify_observers_on(*callback_methods)
+            Utils::Arrays.flatten_and_compact(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/set.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+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
+      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)
+        return @subject_changed = state if state == true || state == false
+
+        raise ArgumentError, INVALID_BOOLEAN_MSG
+      end
+
+      def subject_changed!
+        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
+      end
+
+      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)
+
+        @subscribers << [:callable, event, [callable, with, context]] unless included?(callable)
+
+        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)
+
+        '<#%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?
+
+          broadcast(events, 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
+        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)
+
+              with.is_a?(Proc) ? with.call(event) : event
+            end
+
+          callable.call(callable_arg)
+        end
+
+      private_constant :EMPTY_HASH, :INVALID_BOOLEAN_MSG, :CALL_EVENT
+      private_constant :MapSubscriber, :MapSubscribers, :GetObserver, :EqualTo
+    end
+
+  end
+end

data/lib/micro/observers/utils.rb

@@ -4,10 +4,10 @@ module Micro
   module Observers
 
     module Utils
-      EMPTY_HASH = {}.freeze
-
-      def self.compact_array(value)
-        Array(value).flatten.tap(&:compact!)
+      module Arrays
+        def self.flatten_and_compact(value)
+          Array(value).flatten.tap(&:compact!)
+        end
       end
     end
 

data/lib/micro/observers/version.rb

@@ -1,5 +1,5 @@
 module Micro
   module Observers
-    VERSION = '0.7.0'
+    VERSION = '2.1.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.7.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-26 00:00:00.000000000 Z
-dependencies: []
+date: 2020-10-16 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,20 +46,29 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
+- ".travis.sh"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
+- README.pt-BR.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/micro/observers.rb
-- lib/micro/observers/events_or_actions.rb
-- lib/micro/observers/manager.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/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[: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