throw :forbidden

app/channels/stimulus_reflex/channel.rb

@@ -25,7 +25,7 @@ def receive(data)
         if reflex
           reflex.rescue_with_handler(exception)
           reflex.logger&.error error_message
-          reflex.error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
+          reflex.broadcast_error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
         else
           if exception.is_a? StimulusReflex::Reflex::VersionMismatchError
             mismatch = "Reflex failed due to stimulus_reflex gem/NPM package version mismatch. Package versions must match exactly.\nNote that if you are using pre-release builds, gems use the \"x.y.z.preN\" version format, while NPM packages use \"x.y.z-preN\".\n\nstimulus_reflex gem: #{StimulusReflex::VERSION}\nstimulus_reflex NPM: #{data["version"]}"
@@ -73,14 +73,16 @@ def receive(data)
       end
 
       if reflex.halted?
-        reflex.halted data: data
+        reflex.broadcast_halt data: data
+      elsif reflex.forbidden?
+        reflex.broadcast_forbid data: data
       else
         begin
           reflex.broadcast(reflex_data.selectors, data)
         rescue => exception
           reflex.rescue_with_handler(exception)
           error = exception_with_backtrace(exception)
-          reflex.error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
+          reflex.broadcast_error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
           reflex.logger&.error "\e[31mReflex failed to re-render: #{error[:message]} [#{reflex_data.url}]\e[0m\n#{error[:stack]}"
         end
       end
@@ -112,7 +114,7 @@ def delegate_call_to_reflex(reflex)
   end
 
   def commit_session(reflex)
-    store = reflex.request.session.instance_variable_get("@by")
+    store = reflex.request.session.instance_variable_get(:@by)
     store.commit_session reflex.request, reflex.controller.response
   rescue => exception
     error = exception_with_backtrace(exception)

javascript/callbacks.js

@@ -86,8 +86,15 @@ const afterDOMUpdate = event => {
 const routeReflexEvent = event => {
   const { stimulusReflex, payload, name, body } = event.detail || {}
   const eventType = name.split('-')[2]
-  if (!stimulusReflex || !['nothing', 'halted', 'error'].includes(eventType))
-    return
+
+  const eventTypes = {
+    nothing: nothing,
+    halted: halted,
+    forbidden: forbidden,
+    error: error
+  }
+
+  if (!stimulusReflex || !Object.keys(eventTypes).includes(eventType)) return
 
   const { reflexId, xpathElement, xpathController } = stimulusReflex
   const reflexElement = XPathToElement(xpathElement)
@@ -100,17 +107,7 @@ const routeReflexEvent = event => {
     if (eventType === 'error') controllerElement.reflexError[reflexId] = body
   }
 
-  switch (eventType) {
-    case 'nothing':
-      nothing(event, payload, promise, reflex, reflexElement)
-      break
-    case 'error':
-      error(event, payload, promise, reflex, reflexElement)
-      break
-    case 'halted':
-      halted(event, payload, promise, reflex, reflexElement)
-      break
-  }
+  eventTypes[eventType](event, payload, promise, reflex, reflexElement)
 
   setTimeout(() =>
     dispatchLifecycleEvent(
@@ -129,7 +126,7 @@ const routeReflexEvent = event => {
 const nothing = (event, payload, promise, reflex, reflexElement) => {
   reflex.finalStage = 'after'
 
-  Log.success(event, false)
+  Log.success(event)
 
   setTimeout(() =>
     promise.resolve({
@@ -146,7 +143,24 @@ const nothing = (event, payload, promise, reflex, reflexElement) => {
 const halted = (event, payload, promise, reflex, reflexElement) => {
   reflex.finalStage = 'halted'
 
-  Log.success(event, true)
+  Log.halted(event)
+
+  setTimeout(() =>
+    promise.resolve({
+      data: promise.data,
+      element: reflexElement,
+      event,
+      payload,
+      reflexId: promise.data.reflexId,
+      toString: () => ''
+    })
+  )
+}
+
+const forbidden = (event, payload, promise, reflex, reflexElement) => {
+  reflex.finalStage = 'forbidden'
+
+  Log.forbidden(event)
 
   setTimeout(() =>
     promise.resolve({

javascript/lifecycle.js

@@ -10,6 +10,7 @@ import { reflexes } from './reflex_store'
 //   * success
 //   * error
 //   * halted
+//   * forbidden
 //   * after
 //   * finalize
 //
@@ -161,6 +162,19 @@ document.addEventListener(
   true
 )
 
+document.addEventListener(
+  'stimulus-reflex:forbidden',
+  event =>
+    invokeLifecycleMethod(
+      'forbidden',
+      event.detail.element,
+      event.detail.controller.element,
+      event.detail.reflexId,
+      event.detail.payload
+    ),
+  true
+)
+
 document.addEventListener(
   'stimulus-reflex:after',
   event =>
@@ -194,6 +208,7 @@ document.addEventListener(
 //   * success
 //   * error
 //   * halted
+//   * forbidden
 //   * after
 //   * finalize
 //

javascript/log.js

@@ -22,7 +22,7 @@ const request = (
   })
 }
 
-const success = (event, halted) => {
+const success = event => {
   const { detail } = event || {}
   const { selector, payload } = detail || {}
   const { reflexId, target, morph } = detail.stimulusReflex || {}
@@ -40,10 +40,42 @@ const success = (event, halted) => {
     .split('-')
     .slice(1)
     .join('_')
+  const output = { reflexId, morph, payload }
+  if (operation !== 'dispatch_event') output.operation = operation
   console.log(
     `\u2193 reflex \u2193 ${target} \u2192 ${selector ||
       '\u221E'}${progress} ${duration}`,
-    { reflexId, morph, operation, halted, payload }
+    output
+  )
+}
+
+const halted = event => {
+  const { detail } = event || {}
+  const { reflexId, target, payload } = detail.stimulusReflex || {}
+  const reflex = reflexes[reflexId]
+  if (Debug.disabled || reflex.promise.data.suppressLogging) return
+  const duration = reflex.timestamp
+    ? `in ${new Date() - reflex.timestamp}ms`
+    : 'CLONED'
+  console.log(
+    `\u2193 reflex \u2193 ${target} ${duration} %cHALTED`,
+    'color: #ffa500;',
+    { reflexId, payload }
+  )
+}
+
+const forbidden = event => {
+  const { detail } = event || {}
+  const { reflexId, target, payload } = detail.stimulusReflex || {}
+  const reflex = reflexes[reflexId]
+  if (Debug.disabled || reflex.promise.data.suppressLogging) return
+  const duration = reflex.timestamp
+    ? `in ${new Date() - reflex.timestamp}ms`
+    : 'CLONED'
+  console.log(
+    `\u2193 reflex \u2193 ${target} ${duration} %cFORBIDDEN`,
+    'color: #BF40BF;',
+    { reflexId, payload }
   )
 }
 
@@ -62,4 +94,4 @@ const error = event => {
   )
 }
 
-export default { request, success, error }
+export default { request, success, halted, forbidden, error }

javascript/stimulus_reflex.js

@@ -260,8 +260,4 @@ document.addEventListener('cable-ready:after-inner-html', afterDOMUpdate)
 document.addEventListener('cable-ready:after-morph', afterDOMUpdate)
 window.addEventListener('load', setupDeclarativeReflexes)
 
-export {
-  initialize,
-  register,
-  useReflex
-}
+export { initialize, register, useReflex }

lib/generators/stimulus_reflex/templates/app/javascript/controllers/%file_name%_controller.js.tt

@@ -64,6 +64,16 @@ export default class extends ApplicationController {
   //   element.innerText = "\nCouldn\'t dance!"
   // }
 
+  // danceForbidden(element, reflex, noop, reflexId) {
+  //   console.warn('danceForbidden');
+  //   element.innerText = "\nDancing is forbidden in Bomont."
+  // }
+
+  // danceHalted(element, reflex, noop, reflexId) {
+  //   console.warn('danceHalted');
+  //   element.innerText = "\nNobody puts Baby in a corner."
+  // }
+
   // afterDance(element, reflex, noop, reflexId) {
   //   element.innerText = '\nWhatever that was, it\'s over now.'
   // }
@@ -89,6 +99,10 @@ export default class extends ApplicationController {
   //   console.warn("<%= action %> halted", element, reflex, reflexId)
   // }
 
+  // <%= "#{action}_forbidden".camelize(:lower) %>(element, reflex, noop, reflexId) {
+  //   console.warn("<%= action %> forbidden", element, reflex, reflexId)
+  // }
+
   // <%= "after_#{action}".camelize(:lower) %>(element, reflex, noop, reflexId) {
   //   console.log("after <%= action %>", element, reflex, reflexId)
   // }

lib/generators/stimulus_reflex/templates/app/javascript/controllers/application_controller.js.tt

@@ -46,7 +46,12 @@ export default class extends Controller {
     // show error message
   }
 
-  reflexHalted (element, reflex, error, reflexId) {
+  reflexForbidden (element, reflex, noop, reflexId) {
+    // Reflex action did not have permission to run
+    // window.location = '/'
+  }
+
+  reflexHalted (element, reflex, noop, reflexId) {
     // handle aborted Reflex action
   }
 

lib/stimulus_reflex/broadcasters/broadcaster.rb

@@ -26,7 +26,7 @@ def selector?
       false
     end
 
-    def halted(data: {})
+    def broadcast_halt(data: {})
       operations << ["document", :dispatch_event]
       cable_ready.dispatch_event(
         name: "stimulus-reflex:morph-halted",
@@ -35,7 +35,16 @@ def halted(data: {})
       ).broadcast
     end
 
-    def error(data: {}, body: nil)
+    def broadcast_forbid(data: {})
+      operations << ["document", :dispatch_event]
+      cable_ready.dispatch_event(
+        name: "stimulus-reflex:morph-forbidden",
+        payload: payload,
+        stimulus_reflex: data.merge(morph: to_sym)
+      ).broadcast
+    end
+
+    def broadcast_error(data: {}, body: nil)
       operations << ["document", :dispatch_event]
       cable_ready.dispatch_event(
         name: "stimulus-reflex:morph-error",

lib/stimulus_reflex/callbacks.rb

@@ -6,7 +6,21 @@ module Callbacks
 
     included do
       include ActiveSupport::Callbacks
-      define_callbacks :process, skip_after_callbacks_if_terminated: true
+      define_callbacks :process, skip_after_callbacks_if_terminated: true, terminator: ->(target, result_lambda) do
+        halted = true
+        forbidden = true
+        catch(:abort) do
+          catch(:forbidden) do
+            result_lambda.call
+            forbidden = false
+          end
+          halted = false
+        end
+        forbidden = false if halted == true
+        target.instance_variable_set(:@halted, halted)
+        target.instance_variable_set(:@forbidden, forbidden)
+        halted || forbidden
+      end
     end
 
     class_methods do

lib/stimulus_reflex/reflex.rb

@@ -17,7 +17,7 @@ class VersionMismatchError < StandardError; end
 
   delegate :connection, :stream_name, to: :channel
   delegate :controller_class, :flash, :session, to: :request
-  delegate :broadcast, :halted, :error, to: :broadcaster
+  delegate :broadcast, :broadcast_halt, :broadcast_forbid, :broadcast_error, to: :broadcaster
   delegate :reflex_id, :tab_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, :version, :suppress_logging, to: :client_attributes
 
   def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, params: {}, client_attributes: {})
@@ -128,12 +128,7 @@ def render(*args)
 
   # Invoke the reflex action specified by `name` and run all callbacks
   def process(name, *args)
-    reflex_invoked = false
-    result = run_callbacks(:process) {
-      public_send(name, *args).tap { reflex_invoked = true }
-    }
-    @halted ||= result == false && !reflex_invoked
-    result
+    run_callbacks(:process) { public_send(name, *args) }
   end
 
   # Indicates if the callback chain was halted via a throw(:abort) in a before_reflex callback.
@@ -143,6 +138,11 @@ def halted?
     !!@halted
   end
 
+  # Indicates if the callback chain was halted via a throw(:forbidden) in a before_reflex callback.
+  def forbidden?
+    !!@forbidden
+  end
+
   def default_reflex
     # noop default reflex to force page reloads
   end