motion 0.1.2 → 0.4.0

data/lib/motion/callback.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "motion"
+
+module Motion
+  class Callback
+    attr_reader :broadcast
+
+    NAMESPACE = "motion:callback"
+    private_constant :NAMESPACE
+
+    def self.broadcast_for(component, method)
+      [
+        NAMESPACE,
+        component.stable_instance_identifier_for_callbacks,
+        method
+      ].join(":")
+    end
+
+    def initialize(component, method)
+      @broadcast = self.class.broadcast_for(component, method)
+
+      component.stream_from(broadcast, method)
+    end
+
+    def ==(other)
+      other.is_a?(Callback) &&
+        other.broadcast == broadcast
+    end
+
+    def call(message = nil)
+      ActionCable.server.broadcast(broadcast, message)
+    end
+  end
+end

data/lib/motion/channel.rb

@@ -6,6 +6,7 @@ require "motion"
 
 module Motion
   class Channel < ActionCable::Channel::Base
+    include ActionCableExtentions::DeclarativeNotifications
     include ActionCableExtentions::DeclarativeStreams
     include ActionCableExtentions::LogSuppression
 
@@ -24,9 +25,7 @@ module Motion
     def subscribed
       state, client_version = params.values_at("state", "version")
 
-      # TODO: This is too restrictive. Introduce a protocol version and support
-      # older versions of the client that have a compatible protocol.
-      unless Motion::VERSION == client_version
+      if Gem::Version.new(Motion::VERSION) < Gem::Version.new(client_version)
         raise IncompatibleClientError.new(Motion::VERSION, client_version)
       end
 
@@ -58,14 +57,23 @@ module Motion
       synchronize
     end
 
+    def process_periodic_timer(timer)
+      component_connection.process_periodic_timer(timer)
+      synchronize
+    end
+
     private
 
     def synchronize
-      streaming_from(component_connection.broadcasts, to: :process_broadcast)
-
       component_connection.if_render_required do |component|
         transmit(renderer.render(component))
       end
+
+      streaming_from component_connection.broadcasts,
+        to: :process_broadcast
+
+      periodically_notify component_connection.periodic_timers,
+        via: :process_periodic_timer
     end
 
     def handle_error(error, context)

data/lib/motion/component.rb

@@ -5,8 +5,10 @@ require "active_support/concern"
 require "motion"
 
 require "motion/component/broadcasts"
+require "motion/component/callbacks"
 require "motion/component/lifecycle"
 require "motion/component/motions"
+require "motion/component/periodic_timers"
 require "motion/component/rendering"
 
 module Motion
@@ -14,8 +16,10 @@ module Motion
     extend ActiveSupport::Concern
 
     include Broadcasts
+    include Callbacks
     include Lifecycle
     include Motions
+    include PeriodicTimers
     include Rendering
   end
 end

data/lib/motion/component/broadcasts.rb

@@ -3,6 +3,7 @@
 require "active_support/concern"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/hash/except"
 
 require "motion"
 
@@ -11,6 +12,31 @@ module Motion
     module Broadcasts
       extend ActiveSupport::Concern
 
+      # Analogous to `module_function` (available on both class and instance)
+      module ModuleFunctions
+        def stream_from(broadcast, handler)
+          self._broadcast_handlers =
+            _broadcast_handlers.merge(broadcast.to_s => handler.to_sym).freeze
+        end
+
+        def stop_streaming_from(broadcast)
+          self._broadcast_handlers =
+            _broadcast_handlers.except(broadcast.to_s).freeze
+        end
+
+        def stream_for(model, handler)
+          stream_from(broadcasting_for(model), handler)
+        end
+
+        def stop_streaming_for(model)
+          stop_streaming_from(broadcasting_for(model))
+        end
+
+        def broadcasts
+          _broadcast_handlers.keys
+        end
+      end
+
       included do
         class_attribute :_broadcast_handlers,
           instance_reader: false,
@@ -20,26 +46,19 @@ module Motion
       end
 
       class_methods do
+        include ModuleFunctions
+
         def broadcast_to(model, message)
           ActionCable.server.broadcast(broadcasting_for(model), message)
         end
 
-        def stream_from(broadcast, handler)
-          self._broadcast_handlers =
-            _broadcast_handlers.merge(broadcast.to_s => handler.to_sym).freeze
-        end
-
-        def stream_for(model, handler)
-          stream_from(broadcasting_for(model), handler)
-        end
-
         def broadcasting_for(model)
           serialize_broadcasting([name, model])
         end
 
         private
 
-        # Taken from ActionCable::Channel::Broadcasting
+        # This definition is copied from ActionCable::Channel::Broadcasting
         def serialize_broadcasting(object)
           if object.is_a?(Array)
             object.map { |m| serialize_broadcasting(m) }.join(":")
@@ -51,31 +70,26 @@ module Motion
         end
       end
 
-      def broadcasts
-        _broadcast_handlers.keys
-      end
+      include ModuleFunctions
 
       def process_broadcast(broadcast, message)
         return unless (handler = _broadcast_handlers[broadcast])
 
-        send(handler, message)
-      end
-
-      def broadcast_to(model, message)
-        self.class.broadcast_to(model, message)
+        _run_action_callbacks(context: handler) do
+          if method(handler).arity.zero?
+            send(handler)
+          else
+            send(handler, message)
+          end
+        end
       end
 
-      def stream_from(broadcast, handler)
-        self._broadcast_handlers =
-          _broadcast_handlers.merge(broadcast.to_s => handler.to_sym).freeze
-      end
+      private
 
-      def stream_for(model, handler)
-        stream_from(self.class.broadcasting_for(model), handler)
+      def broadcasting_for(model)
+        self.class.broadcasting_for(model)
       end
 
-      private
-
       attr_writer :_broadcast_handlers
 
       def _broadcast_handlers

data/lib/motion/component/callbacks.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require "motion"
+
+module Motion
+  module Component
+    module Callbacks
+      def bind(method)
+        Callback.new(self, method)
+      end
+
+      def stable_instance_identifier_for_callbacks
+        @_stable_instance_identifier_for_callbacks ||= SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/motion/component/lifecycle.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "active_support/callbacks"
 require "active_support/concern"
+require "active_support/deprecation"
 
 require "motion"
 
@@ -9,22 +11,102 @@ module Motion
     module Lifecycle
       extend ActiveSupport::Concern
 
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :action, :connect, :disconnect
+
+        # The built-in triggers defined on the target class will override ours.
+        remove_method(:_run_action_callbacks)
+      end
+
       class_methods do
-        # TODO: "IncorrectRevisionError" doesn't make sense for this anymore.
-        # It should probably be something like "CannotUpgrade" and the error
-        # message should focus on how to handle deployments gracefully.
-        def upgrade_from(previous_revision, _instance)
-          raise IncorrectRevisionError.new(
-            Motion.config.revision,
-            previous_revision
+        def upgrade_from(previous_revision, instance)
+          raise UpgradeNotImplementedError.new(
+            instance,
+            previous_revision,
+            Motion.config.revision
           )
         end
+
+        def before_action(*methods, **options, &block)
+          set_action_callback(:before, *methods, **options, &block)
+        end
+
+        def around_action(*methods, **options, &block)
+          set_action_callback(:around, *methods, **options, &block)
+        end
+
+        def after_action(*methods, **options, &block)
+          set_action_callback(:after, *methods, **options, &block)
+        end
+
+        def after_connect(*methods, **options, &block)
+          set_callback(:connect, :after, *methods, **options, &block)
+        end
+
+        def after_disconnect(*methods, **options, &block)
+          set_callback(:disconnect, :after, *methods, **options, &block)
+        end
+
+        private
+
+        def set_action_callback(kind, *methods, **options, &block)
+          filters = Array(options.delete(:if))
+
+          if (only = Array(options.delete(:only))).any?
+            filters << action_callback_context_filter(only)
+          end
+
+          if (except = Array(options.delete(:except))).any?
+            filters << action_callback_context_filter(except, invert: true)
+          end
+
+          set_callback(:action, kind, *methods, if: filters, **options, &block)
+        end
+
+        def action_callback_context_filter(contexts, invert: false)
+          proc { contexts.include?(@_action_callback_context) ^ invert }
+        end
+      end
+
+      def process_connect
+        _run_connect_callbacks
+
+        # TODO: Remove at next minor release
+        if respond_to?(:connected)
+          ActiveSupport::Deprecation.warn(
+            "The `connected` lifecycle method is being replaced by the " \
+            "`after_connect` callback and will no longer be automatically " \
+            "invoked in the next **minor release** of Motion."
+          )
+
+          send(:connected)
+        end
       end
 
-      def connected
+      def process_disconnect
+        _run_disconnect_callbacks
+
+        # TODO: Remove at next minor release
+        if respond_to?(:disconnected)
+          ActiveSupport::Deprecation.warn(
+            "The `disconnected` lifecycle method is being replaced by the " \
+            "`after_disconnect` callback and will no longer be automatically " \
+            "invoked in the next **minor release** of Motion."
+          )
+
+          send(:disconnected)
+        end
       end
 
-      def disconnected
+      def _run_action_callbacks(context:, &block)
+        @_action_callback_context = context
+
+        run_callbacks(:action, &block)
+      ensure
+        # `@_action_callback_context = nil` would still appear in the state
+        remove_instance_variable(:@_action_callback_context)
       end
     end
   end

data/lib/motion/component/motions.rb

@@ -2,6 +2,7 @@
 
 require "active_support/concern"
 require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/hash/except"
 
 require "motion"
 
@@ -10,6 +11,23 @@ module Motion
     module Motions
       extend ActiveSupport::Concern
 
+      # Analogous to `module_function` (available on both class and instance)
+      module ModuleFunctions
+        def map_motion(motion, handler = motion)
+          self._motion_handlers =
+            _motion_handlers.merge(motion.to_s => handler.to_sym).freeze
+        end
+
+        def unmap_motion(motion)
+          self._motion_handlers =
+            _motion_handlers.except(motion.to_s).freeze
+        end
+
+        def motions
+          _motion_handlers.keys
+        end
+      end
+
       included do
         class_attribute :_motion_handlers,
           instance_reader: false,
@@ -19,33 +37,25 @@ module Motion
       end
 
       class_methods do
-        def map_motion(motion, handler = motion)
-          self._motion_handlers =
-            _motion_handlers.merge(motion.to_s => handler.to_sym).freeze
-        end
+        include ModuleFunctions
       end
 
-      def motions
-        _motion_handlers.keys
-      end
+      include ModuleFunctions
 
       def process_motion(motion, event = nil)
         unless (handler = _motion_handlers[motion])
           raise MotionNotMapped.new(self, motion)
         end
 
-        if method(handler).arity.zero?
-          send(handler)
-        else
-          send(handler, event)
+        _run_action_callbacks(context: handler) do
+          if method(handler).arity.zero?
+            send(handler)
+          else
+            send(handler, event)
+          end
         end
       end
 
-      def map_motion(motion, handler = motion)
-        self._motion_handlers =
-          _motion_handlers.merge(motion.to_s => handler.to_sym).freeze
-      end
-
       private
 
       attr_writer :_motion_handlers

data/lib/motion/component/periodic_timers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/hash/except"
+
+require "motion"
+
+module Motion
+  module Component
+    module PeriodicTimers
+      extend ActiveSupport::Concern
+
+      # Analogous to `module_function` (available on both class and instance)
+      module ModuleFunctions
+        def every(interval, handler, name: handler)
+          periodic_timer(name, handler, every: interval)
+        end
+
+        def periodic_timer(name, handler = name, every:)
+          self._periodic_timers =
+            _periodic_timers.merge(name.to_s => [handler.to_sym, every]).freeze
+        end
+
+        def stop_periodic_timer(name)
+          self._periodic_timers =
+            _periodic_timers.except(name.to_s).freeze
+        end
+
+        def periodic_timers
+          _periodic_timers.transform_values { |_handler, interval| interval }
+        end
+      end
+
+      included do
+        class_attribute :_periodic_timers,
+          instance_reader: false,
+          instance_writer: false,
+          instance_predicate: false,
+          default: {}.freeze
+      end
+
+      class_methods do
+        include ModuleFunctions
+      end
+
+      include ModuleFunctions
+
+      def process_periodic_timer(name)
+        return unless (handler, _interval = _periodic_timers[name])
+
+        _run_action_callbacks(context: handler) do
+          send(handler)
+        end
+      end
+
+      private
+
+      attr_writer :_periodic_timers
+
+      def _periodic_timers
+        return @_periodic_timers if defined?(@_periodic_timers)
+
+        self.class._periodic_timers
+      end
+    end
+  end
+end