motion 0.1.1 → 0.3.0

data/lib/motion/component.rb

@@ -7,6 +7,7 @@ require "motion"
 require "motion/component/broadcasts"
 require "motion/component/lifecycle"
 require "motion/component/motions"
+require "motion/component/periodic_timers"
 require "motion/component/rendering"
 
 module Motion
@@ -16,6 +17,7 @@ module Motion
     include Broadcasts
     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/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

data/lib/motion/component/rendering.rb

@@ -24,36 +24,33 @@ module Motion
       # * If it doesn't change every time the component's state changes,
       #   things may fall out of sync unless you also call `#rerender!`
       def render_hash
-        # TODO: This implementation is trivially correct, but very wasteful.
-        #
-        # Is something with Ruby's built-in `hash` Good Enough(TM)?
-        #
-        #  instance_variables
-        #    .map { |ivar| instance_variable_get(ivar).hash }
-        #    .reduce(0, &:^)
-
-        key, _state = Motion.serializer.serialize(self)
-        key
+        Motion.serializer.weak_digest(self)
       end
 
       def render_in(view_context)
         raise BlockNotAllowedError, self if block_given?
-        clear_awaiting_forced_rerender!
 
-        html = view_context.capture { without_new_instance_variables { super } }
+        html =
+          _run_action_callbacks(context: :render) {
+            _clear_awaiting_forced_rerender!
+
+            view_context.capture { _without_new_instance_variables { super } }
+          }
+
+        raise RenderAborted, self if html == false
 
         Motion.markup_transformer.add_state_to_html(self, html)
       end
 
       private
 
-      def clear_awaiting_forced_rerender!
+      def _clear_awaiting_forced_rerender!
         return unless awaiting_forced_rerender?
 
         remove_instance_variable(RERENDER_MARKER_IVAR)
       end
 
-      def without_new_instance_variables
+      def _without_new_instance_variables
         existing_instance_variables = instance_variables
 
         yield

data/lib/motion/component_connection.rb

@@ -24,13 +24,13 @@ module Motion
       timing("Connected") do
         @render_hash = component.render_hash
 
-        component.connected
+        component.process_connect
       end
     end
 
     def close
       timing("Disconnected") do
-        component.disconnected
+        component.process_disconnect
       end
 
       true
@@ -64,6 +64,18 @@ module Motion
       false
     end
 
+    def process_periodic_timer(timer)
+      timing("Proccessed periodic timer #{timer}") do
+        component.process_periodic_timer timer
+      end
+
+      true
+    rescue => error
+      handle_error(error, "processing periodic timer #{timer}")
+
+      false
+    end
+
     def if_render_required(&block)
       timing("Rendered") do
         next_render_hash = component.render_hash
@@ -83,6 +95,10 @@ module Motion
       component.broadcasts
     end
 
+    def periodic_timers
+      component.periodic_timers
+    end
+
     private
 
     attr_reader :log_helper