belt 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62b1b84b58bb017a4a127a871136dfc32b02217314bf5fc5f2b1baceb599063b
-  data.tar.gz: 2bd29c90f7380f4efa4014cc079fefacef86ed9407b19f71fb06fc0ead217bff
+  metadata.gz: 66c35b71a47f74ba7805bce24b37eb02fa6ded7246872df30a951a35be22d21f
+  data.tar.gz: 5ddc3bb756fdf782da5074abb72bd0c7275c6a90f4ba98c81963b92cb9cd6bb9
 SHA512:
-  metadata.gz: be2982d7fc1cc0bbac0a61369029801e2c95ccbb3539ca2effaa649f506cbda151d0e1b4f55284534a30d13331e36c7c215236eef5f5417c288bf282757d0afb
-  data.tar.gz: ab198a8c848feb617046b1dbe73d5887252253617da7420ecd5935a56925bd18473430dbf2f54b5f9302e7c9bee777f21416b19ea28ac37d8bdc377aa6730222
+  metadata.gz: 44320ad96e29e29a6bb9b88d2de94822f982dad01e92bc639204c38d2bb7a306463b7b570ac8c35cbf13cc00a223a55442b52171ac64f3357de98a9662a5e3e9
+  data.tar.gz: 8e176982bec58892623685d2b3bfd02cde1ab22d9fcac2c6eb1bfe58f5ae27f02d28b708cced560b803379b36bcd2bea5463fce749bde4ebd9b169cbfff878ba

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.1
+
+### Fixed
+
+- **`before_action` now halts the request when it produces a response.** The docs said
+  a callback could halt by calling `error_response`, but `dispatch` ignored callback
+  output and ran the action anyway, so the action's response replaced the error. A
+  guard like `error_response('Forbidden', 403) unless admin?` let everyone through.
+  Now, once a callback calls a response helper (`error_response`, `success_response`,
+  `html_response`, `head`, `render`) or returns a response, the remaining callbacks, the
+  action and the `after_action`s are skipped and that response is returned
+  (Rails-style). Apps that worked around this with inline guards in each action keep
+  working; the inline checks are now redundant.
+
 ## 0.6.0
 
 ### Added

data/lib/belt/authentication/controller.rb

@@ -88,9 +88,7 @@ module Belt
         false
       end
 
-      # before_action guard. Raises, because Belt discards before_action return values
-      # (see BeltController::Base#run_before_actions) — returning a response hash would
-      # let the action run anyway. Belt maps the error to 401.
+      # before_action guard. Raises NotAuthenticated, which Belt maps to 401.
       def authenticate_user!
         raise NotAuthenticated, 'Authentication required' unless user_signed_in?
       end

data/lib/belt/docs/authentication.md

@@ -71,8 +71,8 @@ end
 ```
 
 `authenticate_user!` raises `Belt::Authentication::NotAuthenticated`, which Belt already
-maps to **401**. It has to raise: `before_action` cannot halt the chain by returning a
-response — return values are discarded and the action runs anyway.
+maps to **401**. (Your own guards can also halt by calling a response helper, e.g.
+`error_response('Forbidden', 403) unless admin?`.)
 
 | Method | |
 |---|---|

data/lib/belt/docs/controllers.md

@@ -96,8 +96,19 @@ class ApplicationController < BeltController::Base
 end
 ```
 
-Callbacks run in definition order. `before_action` can halt the request by
-calling a response helper (e.g., `error_response`).
+Callbacks run in definition order. A `before_action` halts the request by
+calling a response helper (`error_response`, `success_response`, `head`,
+`render`, …). The remaining callbacks, the action and the `after_action`s are
+skipped, and that response is returned:
+
+```ruby
+def require_admin!
+  error_response('Forbidden', 403) unless admin?
+end
+```
+
+Raising works too: the exception goes through `rescue_from` as usual (e.g.
+`Belt::AuthenticationError` → 401).
 
 ## Strong Parameters
 

data/lib/belt/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 
   # Ruby version new apps run on in Lambda. Rendered into the conveyor-belt
   # provider block (`ruby_version`) by `belt new` / `belt generate environment`.

data/lib/belt_controller/base.rb

@@ -9,12 +9,15 @@ require_relative '../belt/helpers/error_logging'
 require_relative '../belt/helpers/cors_origin'
 require_relative '../belt/rendering'
 require_relative 'implicit_response'
+require_relative 'callback_halting'
 
 module BeltController
   class Base
     include Belt::Helpers::Response
     include Belt::Rendering
     include ImplicitResponse
+    # Must come after Belt::Helpers::Response / Belt::Rendering (wraps their helpers).
+    include CallbackHalting
     # Cognito identity: current_user, authenticate_user!, cognito_admin?.
     # Inert unless the app declares `cognito_authenticatable` on a model.
     include Belt::Authentication::Controller
@@ -139,7 +142,11 @@ module BeltController
         raise Belt::ActionNotFound, "The action '#{action_sym}' could not be found for #{self.class.name}"
       end
 
-      run_before_actions(action_sym)
+      # A before_action that produced a response halts the request (Rails-style):
+      # the action and after_actions don't run.
+      halted = run_before_actions(action_sym)
+      return halted if halted
+
       # Snapshot ivars so we only auto-serialize assigns set by the action (Rails-style)
       @__assigns_before = instance_variables
       result = send(action_sym)
@@ -178,14 +185,17 @@ module BeltController
 
     private
 
+    # Returns the halting response if a callback produced one, else nil.
     def run_before_actions(action_sym)
       self.class.all_before_actions.each do |callback|
         next if callback[:only] && !callback[:only].include?(action_sym)
         next if callback[:except]&.include?(action_sym)
         next if should_skip_callback?(callback[:method], action_sym)
 
-        send(callback[:method])
+        response = run_halting_callback(callback[:method])
+        return response if response
       end
+      nil
     end
 
     def run_after_actions(action_sym)

data/lib/belt_controller/callback_halting.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BeltController
+  # Rails-style halting for before_action callbacks.
+  #
+  # A before_action halts the request by producing a response. Either form works:
+  #
+  #   def require_admin!
+  #     error_response('Forbidden', 403) unless admin?
+  #   end
+  #
+  #   def require_admin!
+  #     return if admin?
+  #
+  #     error_response('Forbidden', 403)
+  #     Belt::Observability::Logger.warn('non-admin hit admin route')
+  #   end
+  #
+  # Once a callback halts, the remaining callbacks, the action and the
+  # after_actions are skipped, and that response is returned.
+  #
+  # Belt's response helpers are pure (they build and return a hash), so we
+  # record any response built while a callback is running. That catches the
+  # second form, where the response isn't the callback's return value.
+  # Included by BeltController::Base after the response helpers so these
+  # wrappers sit in front of them in the ancestor chain.
+  module CallbackHalting
+    # render builds its response via html_response, so it's covered too.
+    %i[success_response error_response html_response head].each do |helper|
+      define_method(helper) do |*args|
+        response = super(*args)
+        @__callback_response = response if @__running_callback
+        response
+      end
+    end
+
+    private
+
+    # Run one before_action. Returns the response it produced (halt), or nil.
+    # A returned response wins over one that was only built along the way.
+    def run_halting_callback(method_name)
+      @__callback_response = nil
+      @__running_callback = true
+      result = send(method_name)
+      lambda_response?(result) ? result : @__callback_response
+    ensure
+      @__running_callback = false
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Stowzilla
@@ -192,6 +192,7 @@ files:
 - lib/belt/version.rb
 - lib/belt/views/welcome/show.html.erb
 - lib/belt_controller/base.rb
+- lib/belt_controller/callback_halting.rb
 - lib/belt_controller/implicit_response.rb
 - lib/templates/dns/backend.tf.erb
 - lib/templates/dns/belt.rb.erb