wor-simple_crud 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbcb6881c359fa3b5c4ce518871a4f378d92e0698ab7d57dc489315f2f25b80b
-  data.tar.gz: 62cf8cbd6df845cd23a388e9b2a1f8ebfdae784ff91f4e57268688bce0c0bf87
+  metadata.gz: b5b50548416811b034a75f72c96d4e94c41cdb9883d7112cdf720ad3febaeb11
+  data.tar.gz: 99ae1562bae38c2fa8ff1d697859f8643e2b818aaeb66f2e14220171fa9f28dc
 SHA512:
-  metadata.gz: 4406326eab40876599274e927df02c9c3470d3f753dcd5f0f150b67a7b3087e2a965ec0fd18ad1e007bada514954f9a665d573d18da98bf7c93aee3ffebc1637
-  data.tar.gz: 1deddc698fb6008531d59e5656675086a309dbc26177b403c023e7743463425626b8e977785f6ef2cbe122d4f251ad697944d1c71f665e498666feecedbae792
+  metadata.gz: ef7dd6acb64f882534e9951a9adf2d8deab27f2264451cb1dee2613c78e4842e38d10a638a2ed9ec623984d0d571aee558e2a3626f7bf8f016eca65dc3174ae3
+  data.tar.gz: 43a9b8fb46febb90d101814a33d48049ba0a5c2df3a3b14568c5423816ebd55325966fabe8673320ef3ed89b1a7bfe0ac10f4940c16b0e412649b100dd08e051

data/.rubocop.yml

@@ -1,6 +1,10 @@
 plugins:
   - rubocop-rspec
 
+inherit_mode:
+  merge:
+    - Exclude
+
 AllCops:
   TargetRubyVersion: 3.2
   NewCops: disable
@@ -14,3 +18,14 @@ RSpec/SpecFilePathFormat:
 RSpec/SpecFilePathSuffix:
   Exclude:
     - spec/dummy_controller_spec.rb
+
+# Context class names are self-documenting; comments would be noise.
+Style/Documentation:
+  Exclude:
+    - lib/simple_crud/*_context.rb
+
+# The destroy failure spec must stub find_record on the instance to intercept
+# both default (klass.find) and custom-finder (lambda) lookup paths.
+RSpec/AnyInstance:
+  Exclude:
+    - lib/spec/shared_examples/simple_crud_for_destroy.rb

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Change log
 
+### V0.5.0
+
+New options:
+* `cache: { key:, ttl: }` on `simple_crud_for :show` and `:index` — skips the DB on cache hits. On a miss: find/query, authorize, run block, cache, render. `key` is a lambda receiving `params` or a plain string; both default when omitted (`"#{model}:#{action}:v1:#{request.fullpath}"` and 300 s). Block must return the payload hash, not call `render`. `@record`/`@records` is set before the block, so shared examples work unchanged. Controllers get a default `fetch_cached(key, ttl, &block)` backed by `Rails.cache`; override to use a different store.
+* `expire_simple_crud_cache(action, path: request.fullpath)` on controllers — deletes the default cache key for an action without constructing it by hand. Only works for the default key format; custom `key:` lambdas must be deleted directly.
+
 ### V0.4.0
 
 Breaking:

data/README.md

@@ -18,6 +18,7 @@ SimpleCrud
         - [Serializer](#serializer)
         - [HTML](#html)
         - [Finder](#finder)
+        - [Cache](#cache)
       - [Controller-level defaults](#controller-level-defaults)
       - [Shared examples](#shared-examples)
   - [Contributing](#contributing)
@@ -343,6 +344,58 @@ simple_crud_for :destroy, finder: ->(params) { current_user.models.find(params[:
 
 When omitted it defaults to `klass.find(params[:id])`, and `not_found` is still returned whenever the finder finds no record.
 
+#### Cache
+Pass `cache: { key:, ttl: }` on `:show` or `:index` to skip the DB on cache hits.
+
+`key` is a lambda receiving `params`, or a plain string. Both `key` and `ttl` are optional — defaults are `"#{model}:#{action}:v1:#{request.fullpath}"` and 300 seconds. With `cache:` the block must return the payload hash, not call `render`. `@record`/`@records` is set before the block, so shared examples work unchanged.
+
+Controllers get a default `fetch_cached(key, ttl, &block)` backed by `Rails.cache`. Override to use a different store:
+
+```ruby
+# Override with a direct Redis connection
+def fetch_cached(key, ttl)
+  cached = redis.get(key)
+  return JSON.parse(cached, symbolize_names: true) if cached
+
+  result = yield
+  redis.setex(key, ttl, result.to_json)
+  result
+end
+
+# All options explicit
+simple_crud_for :show,
+                finder: ->(p) { Article.includes(:author).find(p[:id]) },
+                cache: { key: ->(p) { "article:v1:#{p[:id]}" }, ttl: 900 } do |article|
+  article_payload(article)
+end
+
+# All defaults — key and TTL inferred from model name and params
+simple_crud_for :index, paginate: false, cache: {} do |articles|
+  articles.map { |a| article_summary(a) }
+end
+```
+
+Invalidate on write. For the default key format, `expire_simple_crud_cache(action)` deletes it without constructing it by hand:
+
+```ruby
+expire_simple_crud_cache(:show)
+expire_simple_crud_cache(:index)
+```
+
+For a custom `key:` lambda, delete the key yourself:
+
+```ruby
+def update
+  article = current_user.articles.find(params[:id])
+  if article.update(article_params)
+    redis.del("article:v1:#{article.id}")
+    render json: article_payload(article)
+  else
+    render json: { errors: article.errors.full_messages }, status: :unprocessable_entity
+  end
+end
+```
+
 ### Shared examples
 While optional, using the included shared examples saves you from writing the standard test cases for the methods. You can even use them if you didn't use `simple_crud_for`, as a set of basic tests. To include them, add `require 'simple_crud/rspec'` to your `rails_helper.rb` **after** `require "rspec/rails"`, then add the lines you need to your `*_spec.rb` files:
 ```ruby

data/lib/simple_crud/action_context.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class ActionContext
+    DEFAULT_CACHE_TTL = 300
+
+    attr_reader :controller, :klass, :parameters, :block
+
+    def self.cache_key_for(model, action, path)
+      "#{model.model_name.singular}:#{action}:v1:#{path}"
+    end
+
+    def initialize(controller, klass, parameters, &block)
+      @controller = controller
+      @klass      = klass
+      @parameters = parameters
+      @block      = block
+    end
+
+    def call
+      controller.authenticate_user! if parameters[:authenticate]
+      run
+    end
+
+    private
+
+    def run
+      raise NotImplementedError, "#{self.class} must implement run"
+    end
+
+    def action_name
+      raise NotImplementedError, "#{self.class} must implement action_name to support caching"
+    end
+
+    def maybe_authorize(object)
+      return unless parameters[:authorize]
+
+      SimpleCrud::Config.authorization_adapter.authorize(controller, object)
+    end
+
+    def find_record
+      record = lookup_record
+      raise ActiveRecord::RecordNotFound, "couldn't find #{klass}" if record.nil?
+      unless record.is_a?(ActiveRecord::Base)
+        raise ActiveRecord::RecordNotFound, "#{klass} finder must return a single record"
+      end
+
+      record
+    end
+
+    def lookup_record
+      finder = parameters[:finder]
+      return klass.find(controller.params[:id]) if finder.nil?
+      return klass.send(finder, controller.params) unless finder.respond_to?(:call)
+
+      finder.call(controller.params)
+    end
+
+    def build_record
+      parameters[:build] ? controller.instance_exec(&parameters[:build]) : klass.new
+    end
+
+    def permitted_params
+      controller.send("#{klass.model_name.singular}_params")
+    end
+
+    def serialize_opts(key)
+      { key => parameters[:serializer] }.compact
+    end
+
+    def render_record(record, template)
+      if parameters[:html] || block
+        controller.instance_variable_set(:@record, record)
+        block ? controller.instance_exec(record, &block) : controller.render(template)
+      else
+        controller.render({ json: record }.merge(serialize_opts(:serializer)))
+      end
+    end
+
+    def render_cached(cache_opts, &fetch_block)
+      key    = resolve_cache_key(cache_opts)
+      ttl    = cache_opts[:ttl] || DEFAULT_CACHE_TTL
+      result = controller.send(:fetch_cached, key, ttl, &fetch_block)
+      controller.render json: result
+    end
+
+    def resolve_cache_key(cache_opts)
+      k = cache_opts[:key]
+      return default_cache_key if k.nil?
+
+      k.respond_to?(:call) ? controller.instance_exec(controller.params, &k) : k
+    end
+
+    def default_cache_key
+      self.class.cache_key_for(klass, action_name, controller.request.fullpath)
+    end
+  end
+end

data/lib/simple_crud/action_lambdas.rb

@@ -3,78 +3,10 @@
 module SimpleCrud
   # Builds the lambda installed as each action declared with simple_crud_for.
   module ActionLambdas
-    def crud_lambda_for_show(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-
-        options = {}.merge(serializer: parameters[:serializer]).compact
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        SimpleCrudController.render_show(self, requested, options, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_new(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        record = SimpleCrudController.build_record(self, klass, parameters)
-        SimpleCrudController.maybe_authorize(self, record, parameters)
-        SimpleCrudController.render_new(self, record, parameters, &block)
-      end
-    end
-
-    # The find-instead-of-build twin of :new.
-    def crud_lambda_for_edit(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        SimpleCrudController.render_edit(self, requested, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_index(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        SimpleCrudController.maybe_authorize(self, klass, parameters)
-        options = {}.merge(each_serializer: parameters[:serializer]).compact
-        SimpleCrudController.render_index(self, klass, options, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_create(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-        record = SimpleCrudController.build_record(self, klass, parameters)
-        record.assign_attributes(permitted_params)
-        SimpleCrudController.maybe_authorize(self, record, parameters)
-        persist = ->(bang:) { bang ? record.save! : record.save }
-        options = { status: :created, failure_template: :new }
-        SimpleCrudController.save_and_render(self, record, parameters, options, persist, &block)
-      end
-    end
-
-    def crud_lambda_for_update(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-        persist = ->(bang:) { bang ? requested.update!(permitted_params) : requested.update(permitted_params) }
-        options = { status: :ok, failure_template: :edit }
-        SimpleCrudController.save_and_render(self, requested, parameters, options, persist, &block)
-      end
-    end
-
-    def crud_lambda_for_destroy(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
-        persist = ->(bang:) { bang ? requested.destroy! : requested.destroy }
-        SimpleCrudController.persist_and_render(self, requested, parameters, options, persist, &block)
+    %i[show new edit index create update destroy].each do |action|
+      ctx_class = SimpleCrud.const_get(:"#{action.to_s.capitalize}Context")
+      define_method(:"crud_lambda_for_#{action}") do |klass, parameters = {}, &block|
+        -> { ctx_class.new(self, klass, parameters, &block).call }
       end
     end
   end

data/lib/simple_crud/cache_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Default fetch_cached included into controllers that extend SimpleCrudController.
+  # Override in the controller to use a different store.
+  module CacheHelpers
+    def fetch_cached(key, ttl, &block)
+      Rails.cache.fetch(key, expires_in: ttl, &block)
+    end
+
+    def expire_simple_crud_cache(action, path: request.fullpath)
+      Rails.cache.delete(
+        SimpleCrud::ActionContext.cache_key_for(self.class.simple_crud_controller_model, action, path)
+      )
+    end
+  end
+end

data/lib/simple_crud/create_context.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class CreateContext < PersistenceContext
+    private
+
+    def run
+      attrs  = permitted_params
+      record = build_record
+      record.assign_attributes(attrs)
+      maybe_authorize(record)
+      persist = ->(bang:) { bang ? record.save! : record.save }
+      options = { status: :created, failure_template: :new, redirect: parameters[:redirect] || record }
+      persist_and_render(record, options, persist)
+    end
+  end
+end

data/lib/simple_crud/destroy_context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class DestroyContext < PersistenceContext
+    private
+
+    def run
+      record = find_record
+      maybe_authorize(record)
+      persist = ->(bang:) { bang ? record.destroy! : record.destroy }
+      options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
+      persist_and_render(record, options, persist)
+    end
+  end
+end

data/lib/simple_crud/edit_context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class EditContext < ActionContext
+    private
+
+    def run
+      record = find_record
+      maybe_authorize(record)
+      render_record(record, :edit)
+    end
+  end
+end

data/lib/simple_crud/index_context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class IndexContext < ActionContext
+    private
+
+    def action_name = :index
+
+    def run
+      maybe_authorize(klass)
+      cache_opts = parameters[:cache]
+      cache_opts ? render_cached(cache_opts) { payload } : render_index
+    end
+
+    def payload
+      opts     = serialize_opts(:each_serializer)
+      relation = index_relation
+      records  = index_records(relation, opts)
+      controller.instance_variable_set(:@records, records)
+      block ? controller.instance_exec(records, &block) : records.as_json
+    end
+
+    def render_index
+      relation = index_relation
+      opts     = serialize_opts(:each_serializer)
+      if parameters[:html] || block
+        render_records(relation, opts)
+      elsif parameters[:paginate]
+        SimpleCrud::Config.pagination_adapter.paginate(controller, relation, opts)
+      else
+        controller.render({ json: relation }.merge(opts))
+      end
+    end
+
+    def render_records(relation, opts)
+      records = index_records(relation, opts)
+      controller.instance_variable_set(:@records, records)
+      block ? controller.instance_exec(records, &block) : controller.render(:index)
+    end
+
+    def index_relation
+      if parameters[:scope]
+        call_scope
+      elsif parameters[:authorize]
+        SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass)
+      else
+        klass.all
+      end
+    end
+
+    def call_scope
+      user_method = SimpleCrud::Config.user_method
+      user = controller.respond_to?(user_method) ? controller.public_send(user_method) : nil
+      scope = parameters[:scope]
+      scope.arity == 1 ? scope.call(user) : scope.call(user, controller.params)
+    end
+
+    def index_records(relation, opts)
+      return relation unless parameters[:paginate]
+
+      SimpleCrud::Config.pagination_adapter.paginated_records(controller, relation, opts)
+    end
+  end
+end

data/lib/simple_crud/new_context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class NewContext < ActionContext
+    private
+
+    def run
+      record = build_record
+      maybe_authorize(record)
+      render_record(record, :new)
+    end
+  end
+end

data/lib/simple_crud/persistence_context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class PersistenceContext < ActionContext
+    private
+
+    def persist_and_render(record, options, persist)
+      saved = parameters[:raise_on_invalid] ? persist.call(bang: true) : persist.call(bang: false)
+      return render_persisted(record, saved, options) unless block || parameters[:html]
+
+      controller.instance_variable_set(:@record, record)
+      block ? controller.instance_exec(record, saved, &block) : render_html_redirect(record, saved, options)
+    end
+
+    def render_html_redirect(record, saved, options)
+      if saved
+        controller.redirect_to(redirect_target(record, options[:redirect]))
+      else
+        controller.render(options[:failure_template])
+      end
+    end
+
+    def redirect_target(record, target)
+      target.is_a?(Proc) ? controller.instance_exec(record, &target) : target
+    end
+
+    def render_persisted(record, saved, options)
+      return controller.render(json: record, status: options[:status]) if saved
+
+      controller.render json: { errors: record.errors.full_messages }, status: 422
+    end
+  end
+end

data/lib/simple_crud/show_context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class ShowContext < ActionContext
+    private
+
+    def action_name = :show
+
+    def run
+      cache_opts = parameters[:cache]
+      if cache_opts
+        render_cached(cache_opts) { payload }
+      else
+        record = find_record
+        maybe_authorize(record)
+        render_record(record, :show)
+      end
+    end
+
+    def payload
+      record = find_record
+      maybe_authorize(record)
+      controller.instance_variable_set(:@record, record)
+      block ? controller.instance_exec(record, &block) : record.as_json
+    end
+  end
+end

data/lib/simple_crud/simple_crud_controller.rb

@@ -2,15 +2,26 @@
 
 require 'active_support/all'
 require_relative 'config'
-require_relative 'controller_helpers'
+require_relative 'cache_helpers'
+require_relative 'action_context'
+require_relative 'persistence_context'
+require_relative 'show_context'
+require_relative 'index_context'
+require_relative 'new_context'
+require_relative 'edit_context'
+require_relative 'create_context'
+require_relative 'update_context'
+require_relative 'destroy_context'
 require_relative 'action_lambdas'
 
 # Extended onto a controller for CRUD actions.
 module SimpleCrudController
-  extend SimpleCrud::ControllerHelpers
-  # Include, not extend: controllers gain these by extending SimpleCrudController.
   include SimpleCrud::ActionLambdas
 
+  def self.extended(base)
+    base.include(SimpleCrud::CacheHelpers)
+  end
+
   # Possible options:
   ### authorize: check authorization via Config.authorization_adapter (Pundit by default)
   ### paginate: paginate the list via Config.pagination_adapter (wor-paginate by default)

data/lib/simple_crud/update_context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class UpdateContext < PersistenceContext
+    private
+
+    def run
+      record = find_record
+      maybe_authorize(record)
+      attrs   = permitted_params
+      persist = ->(bang:) { bang ? record.update!(attrs) : record.update(attrs) }
+      options = { status: :ok, failure_template: :edit, redirect: parameters[:redirect] || record }
+      persist_and_render(record, options, persist)
+    end
+  end
+end

data/lib/simple_crud/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCrud
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -52,7 +52,7 @@ RSpec.shared_examples 'simple crud for destroy' do
       before do
         model
         allow(model).to receive(:destroy).and_return(false)
-        allow(SimpleCrudController).to receive(:find_record).and_return(model)
+        allow_any_instance_of(SimpleCrud::DestroyContext).to receive(:find_record).and_return(model)
         delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
       end
 

data/spec/cached/dummy_models_controller_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cached::DummyModelsController, type: :controller do
+  before { Rails.cache.clear }
+
+  include_examples 'simple crud for show with finder'
+
+  describe 'GET #show' do
+    let!(:record) { create(:dummy_model) }
+
+    it 'serves from cache on repeated requests' do
+      get :show, params: { slug: record.slug }
+      first_body = response.parsed_body
+
+      record.update!(name: 'updated')
+      get :show, params: { slug: record.slug }
+
+      expect(response.parsed_body).to eq(first_body)
+    end
+  end
+end

data/spec/cached_defaults/dummy_models_controller_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe CachedDefaults::DummyModelsController, type: :controller do
+  before { Rails.cache.clear }
+
+  include_examples 'simple crud for show'
+
+  describe 'GET #index' do
+    before { create_list(:dummy_model, 2) }
+
+    it 'returns all records' do
+      get :index
+      expect(response.parsed_body.length).to eq(2)
+    end
+  end
+
+  describe 'expire_simple_crud_cache' do
+    let!(:record) { create(:dummy_model) }
+
+    context 'when called after a cached show' do
+      before { get :show, params: { id: record.id } }
+
+      it 'clears the entry so the next request fetches fresh data' do
+        first_body = response.parsed_body
+        record.update!(name: 'updated')
+        controller.expire_simple_crud_cache(:show)
+        get :show, params: { id: record.id }
+        expect(response.parsed_body).not_to eq(first_body)
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/cached/dummy_models_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cached
+  class DummyModelsController < ApplicationController
+    extend SimpleCrudController
+    simple_crud_defaults authorize: false, authenticate: false
+
+    simple_crud_for :show,
+                    finder: ->(p) { DummyModel.find_by!(slug: p[:slug]) },
+                    cache: { key: ->(p) { "dm:#{p[:slug]}" }, ttl: 60 } do |record|
+      { cached_id: record.id }
+    end
+  end
+end

data/spec/dummy/app/controllers/cached_defaults/dummy_models_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CachedDefaults
+  class DummyModelsController < ApplicationController
+    extend SimpleCrudController
+    simple_crud_defaults authorize: false, authenticate: false
+
+    simple_crud_for :show, cache: {}
+    simple_crud_for :index, paginate: false, cache: {}
+  end
+end

data/spec/dummy/config/routes.rb

@@ -4,6 +4,14 @@ Rails.application.routes.draw do
   devise_for :users
   resources :dummy_models
 
+  namespace :cached do
+    resources :dummy_models, only: :show, param: :slug
+  end
+
+  namespace :cached_defaults do
+    resources :dummy_models, only: %i[show index]
+  end
+
   namespace :without_pagination do
     resources :dummy_models, only: :index
   end

data/spec/simple_crud/action_context_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SimpleCrud::ActionContext do
+  let(:ctx) { described_class.new(double, double, {}) }
+
+  it 'raises NotImplementedError when run is not overridden' do
+    expect { ctx.send(:run) }.to raise_error(NotImplementedError)
+  end
+
+  it 'raises NotImplementedError when action_name is not overridden' do
+    expect { ctx.send(:action_name) }.to raise_error(NotImplementedError)
+  end
+
+  describe '.cache_key_for' do
+    it 'builds the standard cache key' do
+      key = described_class.cache_key_for(DummyModel, :show, '/dummy_models/1')
+      expect(key).to eq('dummy_model:show:v1:/dummy_models/1')
+    end
+  end
+end

data/spec/simple_crud/index_context_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SimpleCrud::IndexContext do
+  describe '#call_scope' do
+    after { SimpleCrud::Config.user_method = :current_user }
+
+    let(:controller) { double(params: { status: 'active' }) }
+
+    it 'passes nil when controller has no current_user' do
+      scope = ->(u) { u ? :scoped : :unscoped }
+      ctx = described_class.new(controller, DummyModel, { scope: scope, authorize: false })
+      expect(ctx.send(:call_scope)).to eq(:unscoped)
+    end
+
+    it 'passes params as second arg when scope has arity 2' do
+      scope = ->(u, p) { [u, p[:status]] }
+      ctx = described_class.new(controller, DummyModel, { scope: scope, authorize: false })
+      expect(ctx.send(:call_scope)).to eq([nil, 'active'])
+    end
+
+    it 'resolves user via overridden Config.user_method' do
+      SimpleCrud::Config.user_method = :current_admin
+      admin = double
+      ctrl = double(params: {}, current_admin: admin)
+      ctx = described_class.new(ctrl, DummyModel, { scope: ->(u) { u }, authorize: false })
+      expect(ctx.send(:call_scope)).to eq(admin)
+    end
+  end
+end

data/spec/simple_crud/show_context_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SimpleCrud::ShowContext do
+  describe '#find_record' do
+    it 'raises when a custom finder returns something other than a record' do
+      finder = ->(_params) { DummyModel.where(name: 'x') }
+      ctx = described_class.new(double(params: {}), DummyModel, { finder: finder, authorize: false })
+      expect { ctx.send(:find_record) }
+        .to raise_error(ActiveRecord::RecordNotFound, /must return a single record/)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wor-simple_crud
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - icoluccio
 bindir: bin
 cert_chain: []
-date: 2026-08-30 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -48,18 +48,25 @@ files:
 - README.md
 - Rakefile
 - lib/simple_crud.rb
+- lib/simple_crud/action_context.rb
 - lib/simple_crud/action_lambdas.rb
 - lib/simple_crud/authorization/action_policy_adapter.rb
 - lib/simple_crud/authorization/adapter.rb
 - lib/simple_crud/authorization/can_can_can_adapter.rb
 - lib/simple_crud/authorization/pundit_adapter.rb
+- lib/simple_crud/cache_helpers.rb
 - lib/simple_crud/config.rb
-- lib/simple_crud/controller_helpers.rb
+- lib/simple_crud/create_context.rb
+- lib/simple_crud/destroy_context.rb
+- lib/simple_crud/edit_context.rb
+- lib/simple_crud/index_context.rb
+- lib/simple_crud/new_context.rb
 - lib/simple_crud/pagination/adapter.rb
 - lib/simple_crud/pagination/kaminari_adapter.rb
 - lib/simple_crud/pagination/pagy_adapter.rb
 - lib/simple_crud/pagination/will_paginate_adapter.rb
 - lib/simple_crud/pagination/wor_paginate_adapter.rb
+- lib/simple_crud/persistence_context.rb
 - lib/simple_crud/rspec.rb
 - lib/simple_crud/rspec/config.rb
 - lib/simple_crud/rspec/helpers.rb
@@ -69,7 +76,9 @@ files:
 - lib/simple_crud/rspec/helpers/policies.rb
 - lib/simple_crud/rspec/helpers/requests.rb
 - lib/simple_crud/rspec/helpers/settings.rb
+- lib/simple_crud/show_context.rb
 - lib/simple_crud/simple_crud_controller.rb
+- lib/simple_crud/update_context.rb
 - lib/simple_crud/version.rb
 - lib/spec/matchers/have_been_serialized_with.rb
 - lib/spec/response_helper.rb
@@ -108,6 +117,8 @@ files:
 - spec/block_redirect/dummy_models_controller_spec.rb
 - spec/block_show/dummy_models_controller_spec.rb
 - spec/built/dummy_models_controller_spec.rb
+- spec/cached/dummy_models_controller_spec.rb
+- spec/cached_defaults/dummy_models_controller_spec.rb
 - spec/dummy/Rakefile
 - spec/dummy/app/assets/config/manifest.js
 - spec/dummy/app/controllers/application_controller.rb
@@ -121,6 +132,8 @@ files:
 - spec/dummy/app/controllers/block_redirect/dummy_models_controller.rb
 - spec/dummy/app/controllers/block_show/dummy_models_controller.rb
 - spec/dummy/app/controllers/built/dummy_models_controller.rb
+- spec/dummy/app/controllers/cached/dummy_models_controller.rb
+- spec/dummy/app/controllers/cached_defaults/dummy_models_controller.rb
 - spec/dummy/app/controllers/dummy_models_controller.rb
 - spec/dummy/app/controllers/finder/dummy_models_controller.rb
 - spec/dummy/app/controllers/html/dummy_models_controller.rb
@@ -211,12 +224,14 @@ files:
 - spec/redirect_auth/dummy_models_controller_spec.rb
 - spec/scoped/dummy_models_controller_spec.rb
 - spec/scoped_params/dummy_models_controller_spec.rb
+- spec/simple_crud/action_context_spec.rb
 - spec/simple_crud/authorization/action_policy_adapter_spec.rb
 - spec/simple_crud/authorization/can_can_can_adapter_spec.rb
 - spec/simple_crud/authorization/pundit_adapter_spec.rb
-- spec/simple_crud/controller_helpers_spec.rb
+- spec/simple_crud/index_context_spec.rb
 - spec/simple_crud/pagination/adapters_spec.rb
 - spec/simple_crud/rspec_config_spec.rb
+- spec/simple_crud/show_context_spec.rb
 - spec/simple_crud_configuration_spec.rb
 - spec/simple_crud_controller_spec.rb
 - spec/spec_helper.rb

data/lib/simple_crud/controller_helpers.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCrud
-  # Class-level helpers shared by the CRUD lambdas defined in SimpleCrudController.
-  module ControllerHelpers
-    def maybe_authorize(controller, record, parameters)
-      return unless parameters[:authorize]
-
-      SimpleCrud::Config.authorization_adapter.authorize(controller, record)
-    end
-
-    def render_index(controller, klass, options, parameters, &block)
-      relation = index_relation(controller, klass, parameters)
-
-      if parameters[:html] || block
-        records = index_records(controller, relation, options, parameters)
-        controller.instance_variable_set(:@records, records)
-        block ? controller.instance_exec(records, &block) : controller.render(:index)
-      elsif parameters[:paginate]
-        SimpleCrud::Config.pagination_adapter.paginate(controller, relation, options)
-      else
-        controller.render({ json: relation }.merge(options))
-      end
-    end
-
-    def render_show(controller, record, options, parameters, &block)
-      if parameters[:html] || block
-        controller.instance_variable_set(:@record, record)
-        block ? controller.instance_exec(record, &block) : controller.render(:show)
-      else
-        controller.render({ json: record }.merge(options))
-      end
-    end
-
-    def render_new(controller, record, parameters, &block)
-      render_form(controller, record, :new, parameters, &block)
-    end
-
-    def render_edit(controller, record, parameters, &block)
-      render_form(controller, record, :edit, parameters, &block)
-    end
-
-    def render_form(controller, record, template, parameters, &block)
-      if parameters[:html] || block
-        controller.instance_variable_set(:@record, record)
-        block ? controller.instance_exec(record, &block) : controller.render(template)
-      else
-        options = {}.merge(serializer: parameters[:serializer]).compact
-        controller.render({ json: record }.merge(options))
-      end
-    end
-
-    def build_record(controller, klass, parameters)
-      parameters[:build] ? controller.instance_exec(&parameters[:build]) : klass.new
-    end
-
-    def index_relation(controller, klass, parameters)
-      if parameters[:scope]
-        call_scope(parameters[:scope], controller)
-      elsif parameters[:authorize]
-        SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass)
-      else
-        klass.all
-      end
-    end
-
-    def call_scope(scope, controller)
-      user_method = SimpleCrud::Config.user_method
-      user = controller.respond_to?(user_method) ? controller.public_send(user_method) : nil
-      return scope.call(user) if scope.arity == 1
-
-      scope.call(user, controller.params)
-    end
-
-    def index_records(controller, relation, options, parameters)
-      return relation unless parameters[:paginate]
-
-      SimpleCrud::Config.pagination_adapter.paginated_records(controller, relation, options)
-    end
-
-    def find_record(klass, controller, parameters)
-      record = lookup_record(klass, controller, parameters)
-      raise ActiveRecord::RecordNotFound, "couldn't find #{klass}" if record.nil?
-      unless record.is_a?(ActiveRecord::Base)
-        raise ActiveRecord::RecordNotFound, "#{klass} finder must return a single record"
-      end
-
-      record
-    end
-
-    def lookup_record(klass, controller, parameters)
-      finder = parameters[:finder]
-      return klass.find(controller.params[:id]) if finder.nil?
-      return klass.send(finder, controller.params) unless finder.respond_to?(:call)
-
-      finder.call(controller.params)
-    end
-
-    def persist_and_render(controller, record, parameters, options, persist, &block)
-      saved = parameters[:raise_on_invalid] ? persist.call(bang: true) : persist.call(bang: false)
-      return render_persisted(controller, record, saved, options) unless block || parameters[:html]
-
-      controller.instance_variable_set(:@record, record)
-      return controller.instance_exec(record, saved, &block) if block
-
-      if saved
-        controller.redirect_to(redirect_target(controller, record, options[:redirect]))
-      else
-        controller.render(options[:failure_template])
-      end
-    end
-
-    def save_and_render(controller, record, parameters, options, persist, &block)
-      persist_and_render(controller, record, parameters,
-                         options.merge(redirect: parameters[:redirect] || record), persist, &block)
-    end
-
-    def redirect_target(controller, record, target)
-      target.is_a?(Proc) ? controller.instance_exec(record, &target) : target
-    end
-
-    def render_persisted(controller, record, saved, options)
-      return controller.render(json: record, status: options[:status]) if saved
-
-      controller.render json: { errors: record.errors.full_messages }, status: 422
-    end
-  end
-end

data/spec/simple_crud/controller_helpers_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'simple_crud/controller_helpers'
-
-describe SimpleCrud::ControllerHelpers do
-  subject(:helpers) do
-    Class.new do
-      extend SimpleCrud::ControllerHelpers
-    end
-  end
-
-  describe '.call_scope' do
-    after { SimpleCrud::Config.user_method = :current_user }
-
-    it 'passes nil as the user when the controller has no current_user' do
-      controller = double(params: { status: 'active' })
-      scope = ->(user) { user ? :scoped_to_user : :unscoped }
-
-      expect(helpers.call_scope(scope, controller)).to eq(:unscoped)
-    end
-
-    it 'still passes params as the second argument when the scope takes two' do
-      controller = double(params: { status: 'active' })
-      scope = ->(user, params) { [user, params[:status]] }
-
-      expect(helpers.call_scope(scope, controller)).to eq([nil, 'active'])
-    end
-
-    it 'resolves the user via Config.user_method when overridden' do
-      SimpleCrud::Config.user_method = :current_admin
-      admin = double
-      controller = double(params: {}, current_admin: admin)
-      scope = ->(user) { user }
-
-      expect(helpers.call_scope(scope, controller)).to eq(admin)
-    end
-  end
-
-  describe '.find_record' do
-    it 'raises when a custom finder returns something other than a record' do
-      controller = double(params: {})
-      parameters = { finder: ->(_params) { DummyModel.where(name: 'x') } }
-
-      expect { helpers.find_record(DummyModel, controller, parameters) }
-        .to raise_error(ActiveRecord::RecordNotFound, /must return a single record/)
-    end
-  end
-end