u-observers 1.0.0 → 2.3.0

data/lib/micro/observers.rb

@@ -3,11 +3,13 @@ require 'micro/observers/version'
 module Micro
   module Observers
     require 'micro/observers/utils'
-    require 'micro/observers/events'
-    require 'micro/observers/manager'
+    require 'micro/observers/event'
+    require 'micro/observers/subscribers'
+    require 'micro/observers/broadcast'
+    require 'micro/observers/set'
 
     def observers
-      @__observers ||= Observers::Manager.for(self)
+      @__observers ||= Observers::Set.for(self)
     end
   end
 end

data/lib/micro/observers/broadcast.rb

@@ -0,0 +1,77 @@
+# 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]
+
+          if with && !with.is_a?(Proc)
+            callable.call(with)
+
+            return true
+          end
+
+          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/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/{events.rb → event/names.rb}

@@ -3,9 +3,11 @@
 module Micro
   module Observers
 
-    module Events
-      def self.[](value, default: Utils::EMPTY_ARRAY)
-        values = Utils.compact_array(value)
+    class Event::Names
+      EMPTY_ARRAY = [].freeze
+
+      def self.[](value, default: EMPTY_ARRAY)
+        values = Utils::Arrays.flatten_and_compact(value)
 
         values.empty? ? default : values
       end

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

@@ -14,11 +14,11 @@ module Micro
           end
 
           def notify_observers(*events)
-            notify_observers!(Events.fetch(events))
+            notify_observers!(Event::Names.fetch(events))
           end
 
           def notify_observers_on(*callback_methods)
-            Utils.compact_array(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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Micro
+  module Observers
+
+    class Set
+      def self.for(subject)
+        new(subject)
+      end
+
+      def initialize(subject, subscribers: nil)
+        @subject = subject
+        @subject_changed = false
+        @subscribers = Subscribers.new(subscribers)
+      end
+
+      def count; @subscribers.count; end
+      def none?; @subscribers.none?; 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 include?(observer)
+        @subscribers.include?(observer)
+      end
+      alias included? include?
+
+      def attach(*args); @subscribers.attach(args) and self; end
+      def detach(*args); @subscribers.detach(args) 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 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
+
+      def notify!(*events, data: nil)
+        broadcast(Event::Names.fetch(events), data)
+      end
+
+      CALL_EVENT = [:call].freeze
+
+      def call(*events, data: nil)
+        broadcast_if_subject_changed(Event::Names[events, default: CALL_EVENT], data)
+      end
+
+      def call!(*events, data: nil)
+        broadcast(Event::Names[events, default: CALL_EVENT], data)
+      end
+
+      def inspect
+        subs = @subscribers.to_inspect
+
+        '#<%s @subject=%s @subject_changed=%p @subscribers=%p>' % [self.class, @subject, @subject_changed, subs]
+      end
+
+      private
+
+        def broadcast_if_subject_changed(event_names, data = nil)
+          return self if none? || !subject_changed?
+
+          broadcast(event_names, data)
+
+          subject_changed(false)
+
+          self
+        end
+
+        def broadcast(event_names, data)
+          return self if none?
+
+          Broadcast.call(@subscribers, @subject, data, event_names)
+
+          self
+        end
+
+      private_constant :INVALID_BOOLEAN_MSG, :CALL_EVENT; :CallableOptions
+    end
+
+  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

@@ -5,10 +5,19 @@ module Micro
 
     module Utils
       EMPTY_HASH = {}.freeze
-      EMPTY_ARRAY = [].freeze
 
-      def self.compact_array(value)
-        Array(value).flatten.tap(&:compact!)
+      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)
+          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 = '1.0.0'
+    VERSION = '2.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-observers
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,14 +53,18 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- README.pt-BR.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/micro/observers.rb
-- lib/micro/observers/events.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/manager.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

data/lib/micro/observers/manager.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-module Micro
-  module Observers
-
-    class Manager
-      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, 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)
-        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)
-        @subscribers.any?(&EqualTo[observer])
-      end
-
-      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
-      end
-
-      def on(options = Utils::EMPTY_HASH)
-        event, callable, with = options[:event], options[:call], options[:with]
-
-        return self unless event.is_a?(Symbol) && callable.respond_to?(:call)
-
-        @subscribers << [:callable, event, [callable, with]] unless included?(callable)
-
-        self
-      end
-
-      def notify(*events)
-        broadcast_if_subject_changed(Events.fetch(events))
-
-        self
-      end
-
-      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!(*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 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 notify_observer(observer, method_name, context)
-          return unless observer.respond_to?(method_name)
-
-          handler = observer.is_a?(Proc) ? observer : observer.method(method_name)
-
-          handler.arity == 1 ? handler.call(@subject) : handler.call(@subject, context)
-        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 :INVALID_BOOLEAN_MSG, :CALL_EVENT
-      private_constant :MapSubscriber, :MapSubscribers, :GetObserver, :EqualTo
-    end
-
-  end
-end