emittance 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04b42fbe154e0d5cde79009304ca822446cdab4a
-  data.tar.gz: 7ab0a1d41824b4ac72b0eea7ffb452a1d4023434
+  metadata.gz: 5aa08e8db74f9be24f08a38983291c67293c204e
+  data.tar.gz: 738f991042e17d4414fc491bdf74df4360801f30
 SHA512:
-  metadata.gz: f7a2c245677fbedd995c14a097111051f9b5e545d72d3653e5ffa18eb7b931531453c050c8d8f6cfd58b9c1dec2a55637a63b1a21f374e56ac7e86754e3f3d03
-  data.tar.gz: b96f64c4b769476dab89bd3922db4db33b3cb14a5f4c7f6d91b7db3263148e2fcc25cac845c0915452afc696bf34604c6ee65da9575fc196c8350711ae71900b
+  metadata.gz: 86045a1315babc710189b66ddde7e800ff830048c3bbcd954469adb915d689ebcd4d3dea42dc91a2ceca3c5e3932da5c260bb955c8381b02342e97a1579cfabc
+  data.tar.gz: ec7772819f3e6e0e47a367667b2fb986547ebe293a1ccb5a318eaf05ac279f2bb480f6d66e30c172f1de92ea1f966e0096f7cb438d838cebcafe7f21489a55ef

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    emittance (0.0.6)
+    emittance (0.1.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/emittance/dispatcher/registration_collection_proxy.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Emittance
+  class Dispatcher
+    ##
+    # A collection proxy for registrations. Can include multiple key/value pairs.
+    #
+    class RegistrationCollectionProxy
+      # @param lookup_term the term initially used to lookup the registrations
+      # @param mappings [Hash] the mappings of identifiers to their respective registrations
+      def initialize(lookup_term, mappings)
+        @lookup_term = lookup_term
+        @mappings = mappings
+      end
+
+      # @param args args passed to +Array#each+
+      # @param blk block passed to +Array#each+
+      # @return [RegistrationCollectionProxy] self
+      def each(*args, &blk)
+        arrays = mappings.values.map(&:to_a)
+        arrays.flatten.each(*args, &blk)
+        self
+      end
+
+      # @return [Boolean] true if there are no registrations at all, false otherwise
+      def empty?
+        mappings.values.all?(&:empty?)
+      end
+
+      # @return [RegistrationCollectionProxy] self
+      def <<(item)
+        mappings[lookup_term] << item
+        self
+      end
+
+      # @return [RegistrationCollectionProxy] self
+      def clear
+        mappings.values.each(&:clear)
+        self
+      end
+
+      private
+
+      attr_reader :lookup_term, :mappings
+    end
+  end
+end

data/lib/emittance/dispatcher/registration_map.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'emittance/dispatcher/registration_collection_proxy'
+
+module Emittance
+  class Dispatcher
+    ##
+    # A proxy for a hash. Identifies special identifiers.
+    #
+    class RegistrationMap
+      SPECIAL_IDENTIFIER_REGEX = /^\@/
+
+      class << self
+        # @param identifier the identifier we want to know information about
+        # @return [Boolean] true if the identifier is a special one, false otherwise
+        def special_identifier?(identifier)
+          identifier.to_s =~ SPECIAL_IDENTIFIER_REGEX
+        end
+      end
+
+      # Build a registration map.
+      def initialize
+        @reg_map = {}
+      end
+
+      # @param identifier the identifier you wish to lookup registrations for
+      # @return [RegistrationCollectionProxy] a collection of registrations for that identifier
+      def [](identifier)
+        lookup_term, keys = keys_for(identifier)
+        collection_for(lookup_term, keys)
+      end
+
+      # @param args args passed to +Hash#each_key+
+      # @param blk block passed to +Hash#each_key+
+      # @return [RegistrationMap] self
+      def each_key(*args, &blk)
+        reg_map.each_key(*args, &blk)
+        self
+      end
+
+      private
+
+      attr_reader :reg_map
+
+      def keys_for(identifier)
+        if special_identifier?(identifier)
+          keys_for_special_identifier(identifier)
+        else
+          keys_for_event_identifier(identifier)
+        end
+      end
+
+      def keys_for_special_identifier(identifier)
+        keys = [identifier.to_sym]
+
+        case identifier.to_s
+        when '@all'
+          keys += reg_map.keys.select { |key| key.is_a?(Class) }
+        end
+
+        [identifier.to_sym, keys]
+      end
+
+      def keys_for_event_identifier(identifier)
+        klass = Emittance::EventLookup.find_event_klass(identifier)
+        keys = [klass] + keys_matching_event_klass(klass)
+        [klass, keys]
+      end
+
+      def keys_matching_event_klass(_klass)
+        [:@all]
+      end
+
+      def collection_for(lookup_term, keys)
+        mappings = Hash[
+          keys.map do |key|
+            reg_map[key] ||= empty_registration
+            [key, reg_map[key]]
+          end
+        ]
+
+        RegistrationCollectionProxy.new(lookup_term, mappings)
+      end
+
+      def empty_registration
+        Set.new
+      end
+
+      def special_identifier?(identifier)
+        self.class.special_identifier?(identifier)
+      end
+    end
+  end
+end

data/lib/emittance/dispatcher.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require 'emittance/dispatcher/registration_map'
+
+module Emittance
+  ##
+  # Abstract class for dispatchers. Subclasses must implement the following methods:
+  #
+  # - +._process_event+
+  # - +._register+
+  # - +._register_method_call+
+  #
+  # These methods can be private. These methods will have access to +.registrations_for+, which takes an identifier
+  # and returns an enumerable object with each object registered to that identifier. These objects can be anything
+  # you want, but typically represent the callback you would like to run whenever an event of a certain type is
+  # emitted.
+  #
+  class Dispatcher
+    class << self
+      # @private
+      def inherited(subklass)
+        subklass.instance_variable_set '@registrations', RegistrationMap.new
+      end
+
+      # Calls the subclass's +_process_event+ method.
+      def process_event(event)
+        _process_event(event)
+      end
+
+      # Calls the subclass's +_register+ method.
+      def register(identifier, &callback)
+        _register(identifier, &callback)
+      end
+
+      # Calls the subclass's +_register_method_call+ method.
+      def register_method_call(identifier, object, method_name)
+        _register_method_call(identifier, object, method_name)
+      end
+
+      # @param identifier the identifier the registrations for which you would like to look up
+      # @return [RegistrationCollectionProxy] an enumerable containing all registrations for a given identifier
+      def registrations_for(identifier)
+        registrations[identifier]
+      end
+
+      # @return [RegistrationMap] the registrations
+      def clear_registrations!
+        registrations.each_key { |key| clear_registrations_for! key }
+        registrations
+      end
+
+      # @param identifier the identifier the registrations for hwich you would like to clear
+      # @return [RegistrationCollectionProxy] the cleared registration proxy
+      def clear_registrations_for!(identifier)
+        registrations_for(identifier).clear
+      end
+
+      private
+
+      attr_reader :registrations
+
+      def _process_event(_event)
+        raise NotImplementedError
+      end
+
+      def _register(_identifier, &_callback)
+        raise NotImplementedError
+      end
+
+      def _register_method_call(_identifier, _object, _method_name)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/emittance/dispatchers/synchronous.rb

@@ -5,76 +5,30 @@ module Emittance
     ##
     # The synchronous dispatcher. Runs callbacks one-by-one, in series.
     #
-    class Dispatcher
-      @registrations = {}
-      @enabled = true
-
+    class Dispatcher < Emittance::Dispatcher
       class << self
-        def process_event(event)
+        private
+
+        def _process_event(event)
           registrations_for(event).each do |registration|
             registration.call event
           end
         end
 
-        def registrations_for(identifier)
-          event_klass = find_event_klass identifier
-          registrations[event_klass] ||= empty_registration
-          registrations[event_klass]
-        end
-
-        def register(identifier, &callback)
-          event_klass = find_event_klass identifier
-          registrations[event_klass] ||= empty_registration
-          registrations_for(event_klass) << Registration.new(event_klass, &callback)
-
+        def _register(identifier, &callback)
+          registrations = registrations_for identifier
+          registrations << callback
           callback
         end
 
-        def register_method_call(identifier, object, method_name)
+        def _register_method_call(identifier, object, method_name)
           register identifier, &lambda_for_method_call(object, method_name)
         end
 
-        def clear_registrations!
-          registrations.each_key do |event_klass|
-            clear_registrations_for! event_klass
-          end
-        end
-
-        def clear_registrations_for!(identifier)
-          event_klass = find_event_klass identifier
-          registrations[event_klass].clear
-        end
-
-        private
-
-        attr_accessor :registrations
-
-        def empty_registration
-          Set.new
-        end
-
-        def find_event_klass(event)
-          Emittance::EventLookup.find_event_klass(event)
-        end
-
         def lambda_for_method_call(object, method_name)
           ->(event) { object.send method_name, event }
         end
       end
-
-      # @private
-      class Registration
-        attr_reader :event_klass
-
-        def initialize(event_klass, &callback)
-          @event_klass = event_klass
-          @callback = callback
-        end
-
-        def call(event)
-          @callback.call event
-        end
-      end
     end
   end
 end

data/lib/emittance/emitter.rb

@@ -114,7 +114,7 @@ module Emittance
       end
 
       def _method_patch_str(method_name, non_emitting_method, identifier)
-        <<~RUBY
+        <<-RUBY
           def #{method_name}(*args, &blk)
             return_value = #{non_emitting_method}(*args, &blk)
             if #{!identifier.nil? ? true : false}

data/lib/emittance/notifier.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Emittance
+  ##
+  # Like +Emittance::Action+, this is a convenience module that you can mix-in to any class that provides a shortuct
+  # for a common pattern. An object (usually, a class) that mixes in +Emittance::Notifier+ will watch for all events
+  # and call the method on that object with the same name as the event's identifier. For example:
+  #
+  #   class MyNotifier
+  #     extend Emittance::Notifier
+  #
+  #     def self.something_happened(event)
+  #       puts 'something definitely happened!'
+  #     end
+  #   end
+  #
+  # Whenever an event whose identifiers include +something_happened+ is emitted, +MyNotifier.something_happened+ will
+  # be invoked.
+  #
+  #   foo.emit :something_happened
+  #   # Prints:
+  #   # something definitely happened!
+  #
+  #   foo.emit :something_else_happened
+  #   # (nothing)
+  #
+  # Notice that (1) +MyNotifier+ doesn't need to explicitly listen to `:something_happened`, and (2) no errors or
+  # anything occur when an event is emitted for which +MyNotifier+ doesn't have a method defined.
+  #
+  module Notifier
+    # @private
+    class << self
+      def extended(extender)
+        extender.extend Emittance::Watcher
+
+        extender.watch :@all, :_emittance_handle_event
+      end
+    end
+
+    private
+
+    def _emittance_handle_event(event)
+      identifiers = event.identifiers
+      identifiers.each do |identifier|
+        formatted_identifier = _emittance_format_identifier(identifier)
+        send(formatted_identifier) if respond_to?(formatted_identifier)
+      end
+    end
+
+    def _emittance_format_identifier(identifier)
+      identifier.to_s.split('/').last
+    end
+  end
+end

data/lib/emittance/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Emittance
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end

data/lib/emittance.rb

@@ -6,11 +6,13 @@ require 'emittance/errors'
 require 'emittance/helpers/string_helpers'
 require 'emittance/helpers/constant_helpers'
 require 'emittance/event_lookup'
+require 'emittance/dispatcher'
 require 'emittance/brokerage'
 require 'emittance/broker'
 require 'emittance/event'
 require 'emittance/emitter'
 require 'emittance/watcher'
+require 'emittance/notifier'
 require 'emittance/action'
 
 ##

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emittance
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Tyler Guillen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-15 00:00:00.000000000 Z
+date: 2017-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,6 +120,9 @@ files:
 - lib/emittance/broker.rb
 - lib/emittance/brokerage.rb
 - lib/emittance/brokers/synchronous.rb
+- lib/emittance/dispatcher.rb
+- lib/emittance/dispatcher/registration_collection_proxy.rb
+- lib/emittance/dispatcher/registration_map.rb
 - lib/emittance/dispatchers/synchronous.rb
 - lib/emittance/emitter.rb
 - lib/emittance/errors.rb
@@ -127,6 +130,7 @@ files:
 - lib/emittance/event_lookup.rb
 - lib/emittance/helpers/constant_helpers.rb
 - lib/emittance/helpers/string_helpers.rb
+- lib/emittance/notifier.rb
 - lib/emittance/version.rb
 - lib/emittance/watcher.rb
 homepage: https://github.com/aastronautss/emittance