motion 0.2.0 → 0.4.1

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

data/lib/motion/component/rendering.rb

@@ -11,6 +11,15 @@ module Motion
       RERENDER_MARKER_IVAR = :@__awaiting_forced_rerender__
       private_constant :RERENDER_MARKER_IVAR
 
+      # Some changes to Motion's state are specifically supported during render.
+      ALLOWED_NEW_IVARS_DURING_RENDER = %i[
+        @_broadcast_handlers
+        @_stable_instance_identifier_for_callbacks
+        @_motion_handlers
+        @_periodic_timers
+      ].freeze
+      private_constant :ALLOWED_NEW_IVARS_DURING_RENDER
+
       def rerender!
         instance_variable_set(RERENDER_MARKER_IVAR, true)
       end
@@ -24,42 +33,42 @@ 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
       ensure
-        (instance_variables - existing_instance_variables)
-          .each(&method(:remove_instance_variable))
+        (
+          instance_variables -
+          existing_instance_variables -
+          ALLOWED_NEW_IVARS_DURING_RENDER
+        ).each(&method(:remove_instance_variable))
       end
     end
   end

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

data/lib/motion/configuration.rb

@@ -59,18 +59,23 @@ module Motion
       Rails.application.key_generator.generate_key("motion:secret")
     end
 
+    option :revision_paths do
+      require "rails"
+
+      Rails.application.config.paths.dup.tap do |paths|
+        paths.add "bin", glob: "*"
+        paths.add "Gemfile.lock"
+      end
+    end
+
     option :revision do
-      warn <<~MSG # TODO: Better message (Focus on "How do I fix this?")
-        Motion is automatically inferring the application's revision from git.
-        Depending on your deployment, this may not work for you in production.
-        If it does, add "config.revision = `git rev-parse HEAD`.chomp" to your
-        Motion initializer. If it does not, do something else (probably read an
-        env var or something).
-      MSG
-
-      `git rev-parse HEAD`.chomp
+      RevisionCalculator.new(revision_paths: revision_paths).perform
     end
 
+    # TODO: Is this always the correct key?
+    WARDEN_ENV = "warden"
+    private_constant :WARDEN_ENV
+
     option :renderer_for_connection_proc do
       ->(websocket_connection) do
         require "rack"
@@ -89,12 +94,15 @@ module Motion
         controller.renderer.new(
           websocket_connection.env.slice(
             Rack::HTTP_COOKIE,
-            Rack::RACK_SESSION
+            Rack::RACK_SESSION,
+            WARDEN_ENV
           )
         )
       end
     end
 
+    option(:error_notification_proc) { nil }
+
     option(:key_attribute) { "data-motion-key" }
     option(:state_attribute) { "data-motion-state" }