u-observers 0.9.0 → 2.2.1

data/lib/micro/observers.rb

@@ -3,30 +3,13 @@ require 'micro/observers/version'
 module Micro
   module Observers
     require 'micro/observers/utils'
-    require 'micro/observers/events'
-    require 'micro/observers/manager'
-
-    module ClassMethods
-      def notify_observers!(events)
-        proc do |object|
-          object.observers.subject_changed!
-          object.observers.send(:notify!, events)
-        end
-      end
-
-      def notify_observers(*events)
-        notify_observers!(Events[events])
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:private_class_method, :notify_observers!)
-    end
+    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/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.fetch_from_args(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,100 @@
+# 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
+
+      def on(options = Utils::EMPTY_HASH); @subscribers.on(options) and self; end
+      def once(options = Utils::EMPTY_HASH); @subscribers.once(options) 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
+    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

@@ -6,8 +6,18 @@ module Micro
     module Utils
       EMPTY_HASH = {}.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