wor-simple_crud 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b40c7867a484ffc3807b8dceac29ac1f6cc49ccca6d8a9bb067f93f839703e0c
-  data.tar.gz: 5a72d84147fc1f149695fe0244a11e7f99f2c9b4debb0b99a291e16439b873ac
+  metadata.gz: 32e4043eb57f025e3a834a364be09cae1e35fa401bbf95bac88351272297d4f9
+  data.tar.gz: bb88b34edd232839b1b760a2bcb834bd25f8a244d3ad02c4a91097f14d85b377
 SHA512:
-  metadata.gz: 2354c67d6866dd82b70172279fd47a65bced5a950ce4385df97a1d3ab3373724d7f49a2ee7185e9cca3f86f403892e732afeade705c74337d7ae32ed53815632
-  data.tar.gz: 851104267914cd47c8312723af3361a13e5ee5fa2a323f73add55a0a09e04d965492f870c66ffc81f24c5851239afd35485b367633192c80ce8b3d8d90a7753a
+  metadata.gz: e173f6052e2c1674896a08067369068d2ab9f3c50c082f4a52bf8f4d7db3a9e27f548df1a55fd12bc22e9cc4a360095033d4693ecd5b6957fae7c6b09bd24224
+  data.tar.gz: a1ffc6e33056614ff6806f2b15716d21e749777de66619f23ef0025b4e5561c60e89bbb2d0df27abc3817f248cf21aa8a6ed7cbcdcc0dad67a561411084ba2f0

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## Change log
 
+### V0.7.0
+
+Serializer support:
+* `serializer:` accepts a plain class exposing a `.render` class method, with no base class or gem dependency. simple_crud calls `serializer.render(record, **options)`, so a `def self.render(record, key: default)` signature works untouched. It checks this after Blueprinter's `render_as_hash` and before the ActiveModelSerializers fallback, leaving existing Blueprinter and AMS apps unaffected.
+
+New options:
+* `owned_by:` (Symbol): names an association on `Config.user_method` (`current_user.posts` for `owned_by: :posts`) and supplies the default `finder:`/`build:`/index `scope:` from it, so an owned resource stops spelling out `finder: ->(params) { current_user.posts.find(params[:id]) }` and `build: -> { current_user.posts.build }` on every action. An explicit `finder:`/`build:`/`scope:` overrides the default for that option alone. On `:index`, `owned_by:` takes precedence over the Pundit `policy_scope`, and an explicit `scope:` overrides both. With no current user, an owned `:index` returns no records and an owned `:show`/`:update`/`:destroy` returns `not_found`.
+* `parent:` names a nested route's parent and derives the same defaults from `parent.public_send(parent_association)`. A Symbol resolves a controller method first, then an `@ivar`, so a conventional `before_action` works unchanged; a `Proc` runs in controller context. `parent_association:` defaults to the controller model's plural (`ExamsController` gives `@category.exams`). An explicit `finder:`/`build:`/`scope:` overrides the default, and a nil parent fails closed (404 on find/build, empty index). `parent:` and `owned_by:` both resolve a relation from an owner, so setting both raises `ArgumentError`.
+
+Behavior changes:
+* `scope:` on `:index` accepts a `Symbol` naming a class method on the model, called as `klass.send(scope, user, params)`. Query composition can live on the model instead of inline in the controller.
+* `scope:` lambdas run with the controller as `self`, so a scope can read `@ivars` and route-parent state. Arity 0 receives no arguments (it previously errored by being passed two), arity 1 the user, anything else the user and params.
+* `simple_crud_for` accepts an Array of actions to declare several at once: `simple_crud_for %i[show create update destroy], owned_by: :tasks, serializer: TaskSerializer`.
+* `notice:`/`alert:` on HTML `:create`/`:update`/`:destroy`: set a flash message on the success redirect (`notice`) or the failure re-render (`alert`).
+
 ### V0.6.0
 
 Serializer support:

data/README.md

@@ -18,6 +18,8 @@ SimpleCrud
         - [Serializer](#serializer)
         - [HTML](#html)
         - [Finder](#finder)
+        - [Owned by](#owned-by)
+        - [Parent](#parent)
         - [Cache](#cache)
       - [Controller-level defaults](#controller-level-defaults)
       - [Shared examples](#shared-examples)
@@ -94,6 +96,12 @@ simple_crud_for :new
 simple_crud_for :edit
 ```
 
+Declare several actions with the same options at once by passing an Array:
+```ruby
+simple_crud_for %i[show create update destroy], owned_by: :tasks, serializer: TaskSerializer
+simple_crud_for :destroy, status: :no_content # per-action override on top of the batch
+```
+
 Each method supports different options, as in:
 ```
 simple_crud_for :index, paginate: false, authorize: false, serializer: CustomSerializer
@@ -108,11 +116,13 @@ simple_crud_for :index, paginate: false, authorize: false, serializer: CustomSer
 - Status: only valid for `:create`, `:update` and `:destroy`. Overrides the success status (`:created`, `:ok` and `:ok` by default). `status: :no_content` responds with an empty body
 - After_persist: only valid for `:create`, `:update` and `:destroy`. A `Proc`/`lambda` `->(record, saved) { ... }` that runs with the controller as `self`, after the write and before rendering. Use it for side effects like cache invalidation. It still runs when you pass a render block
 - Html: renders the action's ERB template instead of JSON (valid for `:index`, `:show`, `:new`, `:edit`, `:create`, `:update` and `:destroy`). Only meaningful in controllers that render templates
-- Scope: only valid for `:index`. A `Proc`/`lambda` taking `current_user` (plus the controller's `params` if it takes a second argument) that returns the relation to list, overriding the default `policy_scope`. The user is resolved via `SimpleCrud::Config.user_method` (`:current_user` by default; set it to e.g. `:current_admin`)
+- Scope: only valid for `:index`. A `Proc`/`lambda` that runs with the controller as `self` (so `@ivars` and route-parent state are available) and returns the relation to list, overriding the default `policy_scope`. It takes `current_user` (plus the controller's `params` when it takes a second argument); an arity-0 lambda gets no arguments. The user is resolved via `SimpleCrud::Config.user_method` (`:current_user` by default; set it to e.g. `:current_admin`)
 - Finder: only valid for `:show`, `:update`, `:destroy` and `:edit`. A `Proc`/`lambda` (invoked with the controller's params) or a `Symbol` naming a class method on the model, used to look up the record instead of `klass.find(params[:id])`.
 - Build: only valid for `:new` and `:create`. A `Proc`/`lambda` that builds the record (invoked with the controller as `self`, so `current_user`, `params` and any instance variables are available), for building nested or owner-scoped records like `current_user.projects.build`. `:create` then assigns the permitted params to the built record before saving
 - Raise_on_invalid: only valid for `:create` and `:update`. Keeps the strict `create!`/`update!` semantics (raising on invalid input) instead of returning `422` with the validation errors
 - Redirect: only valid for HTML-mode `:create`, `:update` and `:destroy`. A `Proc`/`lambda` (called with the record) or a literal path used as the success redirect target. Defaults to the record (`:create`/`:update`) or the model's collection path (`:destroy`)
+- Notice: only valid for HTML-mode `:create`, `:update` and `:destroy`. A flash message set on the success redirect. No-op when the controller has no `flash`
+- Alert: only valid for HTML-mode `:create`, `:update` and `:destroy`. A `flash.now` message set before re-rendering on failure. No-op when the controller has no `flash`
 
 #### Controller-level defaults
 
@@ -203,12 +213,19 @@ end
 
 ```
 
-When `authorize: true`, the `:index` action paginates the Pundit `policy_scope` of the model (falling back to the full relation when no `Scope` is defined) instead of `klass.all`, so "only my records" scoping works out of the box. Override the scope per action with the `scope:` option, a callable that receives the user resolved via `SimpleCrud::Config.user_method` (`nil` when there is none, and `params` too when it takes a second argument):
+When `authorize: true`, the `:index` action paginates the Pundit `policy_scope` of the model (falling back to the full relation when no `Scope` is defined) instead of `klass.all`, so "only my records" scoping works out of the box. Override the scope per action with `scope:`: a callable that receives the user resolved via `SimpleCrud::Config.user_method` (`nil` when there is none, and `params` too when it takes a second argument), or a `Symbol` naming a class method on the model so query composition lives on the model:
 
 ```ruby
 SimpleCrud.configure { |c| c.user_method = :current_admin } # non-Devise naming conventions
 simple_crud_for :index, scope: ->(user) { Model.visible_to(user) }
 simple_crud_for :index, scope: ->(user, params) { Model.where(status: params[:status]).visible_to(user) }
+simple_crud_for :index, scope: :visible_to # calls Model.visible_to(user, params)
+```
+
+A `scope:` lambda runs with the controller as `self`, so it can reach `@ivars` and route-parent context. Arity 0 receives no arguments, arity 1 the user, anything else the user and params:
+
+```ruby
+simple_crud_for :index, scope: -> { @category.exams.includes(:questions).order(:title) }
 ```
 
 Prefer CanCanCan or Action Policy instead? Both have adapters ready to go:
@@ -272,7 +289,7 @@ simple_crud_defaults authenticate: false, authenticate_headers: true
 ```
 
 #### Serializer
-`serializer:` picks the serializer for JSON responses on every action. Pass either an [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers) serializer class, which simple_crud builds per record with `serializer.new(record, serializer_options)`, or a [Blueprinter](https://github.com/blueprinter/blueprinter) blueprint class, which it renders with `blueprint.render_as_hash(record, serializer_options)`.
+`serializer:` picks the serializer for JSON responses on every action. Pass an [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers) serializer class, which simple_crud builds per record with `serializer.new(record, serializer_options)`; a [Blueprinter](https://github.com/blueprinter/blueprinter) blueprint class, rendered with `blueprint.render_as_hash(record, serializer_options)`; or any plain class of your own that responds to `.render`, called as `serializer.render(record, **serializer_options)`, with no base class or extra gem required.
 
 Without `serializer:`, the response uses the record's `as_json`. The shared examples expect an `:id` attribute. Paginated `:index` with Blueprinter needs wor-paginate ≥ 0.5.
 
@@ -286,6 +303,13 @@ class AuthorBlueprint < Blueprinter::Base
   fields :email, :first_name, :last_name
 end
 
+# A plain class works too, with no dependency on either gem above:
+class AuthorPlainSerializer
+  def self.render(author, **)
+    { id: author.id, email: author.email, first_name: author.first_name, last_name: author.last_name }
+  end
+end
+
 simple_crud_for :show, serializer: AuthorBlueprint
 simple_crud_for :index, serializer: AuthorBlueprint, serializer_options: -> { { current_user: current_user } }
 ```
@@ -306,11 +330,13 @@ simple_crud_for :index, html: true
 simple_crud_for :show, html: true
 simple_crud_for :new, html: true
 simple_crud_for :edit, html: true
-simple_crud_for :create, html: true
-simple_crud_for :update, html: true
-simple_crud_for :destroy, html: true
+simple_crud_for :create, html: true, notice: 'Created!', alert: 'Could not create.'
+simple_crud_for :update, html: true, redirect: ->(record) { record_path(record) }, notice: 'Saved!'
+simple_crud_for :destroy, html: true, notice: 'Removed.'
 ```
 
+`notice:` sets a flash message on the success redirect; `alert:` sets a `flash.now` message before the failure re-render. Both are skipped when the controller has no `flash` (e.g. `ActionController::API`).
+
 Or pass a block that renders explicitly, overriding the auto-render. The block receives the records for `:index`, the record for `:show`/`:new`, or the record plus a saved flag for `:create`/`:update`/`:destroy`. Blocks do not change the `html:` default; pass it explicitly so the shared examples know which request format to use:
 
 ```ruby
@@ -357,6 +383,63 @@ 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.
 
+#### Owned by
+`owned_by:` covers a resource scoped to the current user's own records. It names an association on `Config.user_method` (`current_user` by default) and derives `finder:`, `build:` and the index `scope:` from it:
+
+```ruby
+class PostsController < ApplicationController
+  simple_crud_defaults owned_by: :posts
+  simple_crud_for :index
+  simple_crud_for :show
+  simple_crud_for :create
+  simple_crud_for :update
+  simple_crud_for :destroy
+end
+```
+
+This is equivalent to writing, on every action:
+
+```ruby
+simple_crud_for :index, scope: ->(user) { user.posts }
+simple_crud_for :show, finder: ->(params) { current_user.posts.find(params[:id]) }
+simple_crud_for :create, build: -> { current_user.posts.build }
+simple_crud_for :update, finder: ->(params) { current_user.posts.find(params[:id]) }
+simple_crud_for :destroy, finder: ->(params) { current_user.posts.find(params[:id]) }
+```
+
+An explicit `finder:`, `build:` or `scope:` on an action overrides the `owned_by:` default for that option alone, so an owned `:show`/`:update`/`:destroy` can use a hand-written `:index` scope that needs extra filtering or eager loading. On `:index`, `owned_by:` takes precedence over the Pundit `policy_scope`; an explicit `scope:` overrides both. With no current user, an owned `:index` returns no records and an owned `:show`/`:update`/`:destroy` returns `not_found`, instead of falling back to the unscoped relation.
+
+Keep the owner's foreign key out of strong params. If `owned_by: :posts` sets the owner through the built association, `params.permit(:user_id)` lets a request override it.
+
+#### Parent
+`parent:` covers a nested route. It derives the same `finder:`, `build:` and index `scope:` from an association on a parent resource instead of on the current user. Both options resolve an association on some owner, so setting them together raises `ArgumentError`.
+
+`parent:` takes a `Symbol` that resolves a controller method first, then an `@ivar`. A `before_action` that sets `@category` works unchanged:
+
+```ruby
+class ExamsController < ApplicationController
+  before_action :set_category
+
+  simple_crud_defaults parent: :category   # reads the category method, else @category
+  simple_crud_for %i[index show new create], serializer: ExamSerializer, html: true
+
+  private
+
+  def set_category = @category = Category.find_by!(slug: params.expect(:category_slug))
+end
+```
+
+The association comes from the controller's model, so `ExamsController` gets `@category.exams`. Pass `parent_association:` when the name differs, or a `Proc` (run in controller context) for a parent that isn't an ivar or method:
+
+```ruby
+simple_crud_for :show, parent: :category, parent_association: :published_exams
+simple_crud_for :show, parent: -> { @listing.interview }
+```
+
+As with `owned_by:`, an explicit `finder:`/`build:`/`scope:` overrides the derived default for that option, and a nil parent fails closed: `:show`/`:update`/`:destroy` return `not_found` and `:index` returns no records.
+
+The same strong-params caveat applies: `:create` builds through the parent association and then assigns the permitted params, so never permit the parent's foreign key (for a `@category.exams` controller, don't permit `:category_id`).
+
 #### Cache
 Pass `cache: { key:, ttl: }` on `:show` or `:index` to skip the DB on cache hits.
 

data/lib/simple_crud/action_context.rb

@@ -57,11 +57,25 @@ module SimpleCrud
     end
 
     def find_by_id
-      klass.find(controller.params[:id])
+      finder_scope.find(controller.params[:id])
     end
 
     def build_record
-      parameters[:build] ? controller.instance_exec(&parameters[:build]) : klass.new
+      return controller.instance_exec(&parameters[:build]) if parameters[:build]
+      return relation_source.relation!.build if relation_source.configured?
+
+      klass.new
+    end
+
+    # Falls back to klass when owned_by:/parent: is unset.
+    def finder_scope
+      return klass unless relation_source.configured?
+
+      relation_source.relation!
+    end
+
+    def relation_source
+      @relation_source ||= SimpleCrud::RelationSource.new(controller, klass, parameters)
     end
 
     def permitted_params

data/lib/simple_crud/index_context.rb

@@ -46,20 +46,31 @@ module SimpleCrud
     end
 
     def index_relation
-      if parameters[:scope]
-        call_scope
-      elsif parameters[:authorize]
-        SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass)
-      else
-        klass.all
-      end
+      return call_scope if parameters[:scope]
+      return relation_source.relation || klass.none if relation_source.configured?
+
+      default_index_relation
+    end
+
+    def default_index_relation
+      return SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass) if parameters[:authorize]
+
+      klass.all
     end
 
     def call_scope
-      user_method = SimpleCrud::Config.user_method
-      user = controller.respond_to?(user_method, true) ? controller.send(user_method) : nil
       scope = parameters[:scope]
-      scope.arity == 1 ? scope.call(user) : scope.call(user, controller.params)
+      return klass.send(scope, relation_source.user, controller.params) unless scope.respond_to?(:call)
+
+      controller.instance_exec(*scope_arguments(scope), &scope)
+    end
+
+    def scope_arguments(scope)
+      case scope.arity
+      when 0 then []
+      when 1 then [relation_source.user]
+      else [relation_source.user, controller.params]
+      end
     end
 
     def index_records(relation, opts)

data/lib/simple_crud/persistence_context.rb

@@ -19,11 +19,22 @@ module SimpleCrud
     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
+      return render_html_failure(options) unless saved
+
+      set_flash(:notice, parameters[:notice])
+      controller.redirect_to(redirect_target(record, options[:redirect]))
+    end
+
+    def render_html_failure(options)
+      set_flash(:alert, parameters[:alert], now: true)
+      controller.render(options[:failure_template])
+    end
+
+    def set_flash(key, message, now: false)
+      return if message.nil? || !controller.respond_to?(:flash)
+
+      target = now ? controller.flash.now : controller.flash
+      target[key] = message
     end
 
     def redirect_target(record, target)

data/lib/simple_crud/relation_source.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Resolves the owner shared by owned_by: and parent:.
+  class RelationSource
+    def initialize(controller, klass, parameters)
+      @controller = controller
+      @klass      = klass
+      @parameters = parameters
+    end
+
+    def configured?
+      !owned_by.nil? || !parent.nil?
+    end
+
+    # nil when the owner can't be resolved.
+    def relation
+      return owner.relation if owned_by
+      return parent_source.relation if parent
+
+      nil
+    end
+
+    def relation!
+      relation || raise(ActiveRecord::RecordNotFound, "no #{description} to scope the record to")
+    end
+
+    def user
+      Source.user(controller)
+    end
+
+    private
+
+    attr_reader :controller, :klass, :parameters
+
+    def owned_by = parameters[:owned_by]
+
+    def parent = parameters[:parent]
+
+    def description
+      owned_by ? "owner for #{owned_by}" : "parent for #{parent}"
+    end
+
+    def owner
+      OwnerSource.new(controller, parameters[:owned_by])
+    end
+
+    def parent_source
+      ParentSource.new(controller, klass, parameters)
+    end
+
+    # Shared by both relation sources.
+    module Source
+      def self.user(controller)
+        user_method = SimpleCrud::Config.user_method
+        controller.respond_to?(user_method, true) ? controller.send(user_method) : nil
+      end
+    end
+
+    # nil without a user.
+    class OwnerSource
+      def initialize(controller, association)
+        @controller  = controller
+        @association = association
+      end
+
+      def relation
+        Source.user(@controller)&.public_send(@association)
+      end
+    end
+
+    # A Symbol resolves method then @ivar.
+    class ParentSource
+      def initialize(controller, klass, parameters)
+        @controller = controller
+        @klass      = klass
+        @parameters = parameters
+      end
+
+      def relation
+        resolved&.public_send(association)
+      end
+
+      private
+
+      def resolved
+        reference = @parameters[:parent]
+        return @controller.instance_exec(&reference) if reference.respond_to?(:call)
+
+        by_method_or_ivar(reference)
+      end
+
+      def by_method_or_ivar(reference)
+        return @controller.send(reference) if @controller.respond_to?(reference, true)
+
+        ivar = :"@#{reference}"
+        return @controller.instance_variable_get(ivar) if @controller.instance_variable_defined?(ivar)
+
+        raise ArgumentError, "parent: #{reference} is neither a controller method nor an @#{reference} ivar"
+      end
+
+      def association
+        @parameters[:parent_association] || @klass.model_name.plural.to_sym
+      end
+    end
+  end
+end

data/lib/simple_crud/rspec/helpers/controller_options.rb

@@ -11,7 +11,7 @@ module SimpleCrud
         end
 
         %i[paginate authorize authenticate serializer serializer_options status after_persist html finder
-           scope build raise_on_invalid block authenticate_headers].each do |option|
+           scope build raise_on_invalid block authenticate_headers owned_by parent].each do |option|
           define_method("check_#{option}") { |method| get_option(method, option) }
         end
 

data/lib/simple_crud/rspec.rb

@@ -27,6 +27,8 @@ require_relative '../spec/shared_examples/simple_crud_for_destroy_with_finder'
 require_relative '../spec/shared_examples/simple_crud_not_found_with_finder'
 require_relative '../spec/shared_examples/simple_crud_for_new_with_build'
 require_relative '../spec/shared_examples/simple_crud_for_create_with_build'
+require_relative '../spec/shared_examples/simple_crud_for_owned_resource'
+require_relative '../spec/shared_examples/simple_crud_for_nested_resource'
 require_relative '../spec/shared_examples/authorization_adapter_authorize'
 require_relative '../spec/matchers/have_been_serialized_with'
 

data/lib/simple_crud/serializer.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
 module SimpleCrud
-  # Renders a record with the app's serializer stack.
-  #
-  # Blueprinter blueprints respond to `render_as_hash` and receive the
-  # render options, so a blueprint can read `url_builder:` (or any other
-  # option) from them. For anything else, simple_crud assumes an
-  # ActiveModelSerializers-style serializer and calls `new(record, options)`.
-  # A `nil` serializer renders `record.as_json`.
+  # Precedence: Blueprinter, then a plain class .render, then ActiveModelSerializers.
   module Serializer
     def self.render(serializer, record, options = {})
       return record.as_json if serializer.nil?
       return serializer.render_as_hash(record, options) if serializer.respond_to?(:render_as_hash)
+      return serializer.render(record, **options) if serializer.is_a?(Class) && serializer.respond_to?(:render)
 
       serializer.new(record, options).as_json
     end

data/lib/simple_crud/simple_crud_controller.rb

@@ -4,6 +4,7 @@ require 'active_support/all'
 require_relative 'config'
 require_relative 'serializer'
 require_relative 'cache_helpers'
+require_relative 'relation_source'
 require_relative 'action_context'
 require_relative 'persistence_context'
 require_relative 'show_context'
@@ -32,16 +33,26 @@ module SimpleCrudController
   ### serializer: use a particular serializer (both each_serializer and serializer)
   ### html: render the action's ERB template instead of JSON (index/show/new/edit/create/update/destroy)
   ### finder: custom record lookup (Proc/lambda or Symbol) for :show/:update/:destroy/:edit
-  ### scope: custom index scope (Proc/lambda taking current_user and optional params), overrides policy_scope
+  ### scope: custom index scope for :index, overriding policy_scope. A Proc/lambda run with the
+  ###   controller as self (arity 0 no args, arity 1 the user, else user and params), or a Symbol
+  ###   naming a model class method taking (current_user, params)
   ### build: custom record builder (Proc/lambda) for :new/:create, invoked with the controller as self
+  ### owned_by: association on Config.user_method for the default finder/build/index-scope
+  ### parent: nested-route parent for the same defaults; exclusive with owned_by:
+  ### parent_association: parent association when it differs from the controller model's plural
+  ### notice:/alert: flash on the html: create/update/destroy success redirect / failure re-render
   ### raise_on_invalid: use strict create!/update! semantics instead of returning 422
   ### A block given to simple_crud_for renders explicitly: it receives the records for :index,
   ### the record for :show/:new/:edit, or the record and a saved flag for :create/:update/:destroy
+  ### An Array of actions declares several at once with the same options
   def simple_crud_for(method, parameters = {}, &block)
+    return method.each { |name| simple_crud_for(name, parameters.dup, &block) } if method.is_a?(Array)
+
     parameters[:block] = true if block
     parameters = parameters_with_defaults(parameters)
     klass = simple_crud_controller_model
     check_valid_method(method)
+    check_relation_source(parameters)
     check_policies(parameters)
     check_serializer(parameters)
     define_method(method, send("crud_lambda_for_#{method}", klass, parameters, &block))
@@ -62,18 +73,22 @@ module SimpleCrudController
   end
 
   def parameters_with_defaults(parameters)
-    defaults = {
-      authorize: true, paginate: true, authenticate: true, authenticate_headers: nil,
-      serializer: nil, serializer_options: nil, status: nil, after_persist: nil, html: false,
-      finder: nil, scope: nil, build: nil, raise_on_invalid: false
-    }
     defaults.merge(simple_crud_inherited_defaults).each do |key, value|
       parameters[key] = value unless parameters.key?(key)
     end
-    parameters[:authenticate_headers] = parameters[:authenticate] if parameters[:authenticate_headers].nil?
+    parameters[:authenticate_headers] ||= parameters[:authenticate]
     parameters
   end
 
+  def defaults
+    {
+      authorize: true, paginate: true, authenticate: true, authenticate_headers: nil,
+      serializer: nil, serializer_options: nil, status: nil, after_persist: nil, html: false,
+      finder: nil, scope: nil, build: nil, owned_by: nil, parent: nil, parent_association: nil,
+      notice: nil, alert: nil, raise_on_invalid: false
+    }
+  end
+
   def write_metadata(method, parameters)
     @simple_crud_metadata ||= {}
     @simple_crud_metadata[method] = parameters
@@ -87,6 +102,12 @@ module SimpleCrudController
     raise ArgumentError, 'invalid method' unless %i[show index create update destroy new edit].include? method
   end
 
+  def check_relation_source(parameters)
+    return unless parameters[:owned_by] && parameters[:parent]
+
+    raise ArgumentError, 'owned_by: and parent: are mutually exclusive, they both scope the same action'
+  end
+
   def check_policies(parameters)
     return if !parameters.key?(:authorize) || !parameters[:authorize]
 

data/lib/simple_crud/version.rb

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

data/lib/spec/shared_examples/simple_crud_for_nested_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# For a parent: controller. The parent in route_params must match the record's owner_association.
+RSpec.shared_examples 'simple crud for nested resource' do
+  describe 'parent: scoping' do
+    include_context 'with authenticated user' if check_authenticate(:show)
+
+    it 'finds a record inside the parent' do
+      get :show, params: with_route_params(record_param(:show, model)), format: format_param(:show)
+
+      expect(response).to have_http_status(:ok)
+    end
+
+    it 'returns not found for a record outside the parent' do
+      outside = create_record(model_class, model_attributes.merge(owner_association => other_user))
+      get :show, params: with_route_params(record_param(:show, outside)), format: format_param(:show)
+
+      expect(response).to have_http_status(:not_found)
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_owned_resource.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Include alongside the per-action examples for a controller using owned_by:.
+RSpec.shared_examples 'simple crud for owned resource' do
+  describe 'owned_by: scoping' do
+    include_context 'with authenticated user'
+
+    let!(:someone_elses_model) do
+      create_record(model_class, model_attributes.merge(owner_association => other_user))
+    end
+
+    it 'returns not found for a record owned by another user' do
+      get :show, params: with_route_params(record_param(:show, someone_elses_model)), format: format_param(:show)
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it 'ignores an attempt to update a record owned by another user', :aggregate_failures do
+      params = with_route_params(record_param(:update, someone_elses_model)).merge(body_params(model_params))
+      patch :update, params: params, format: format_param(:update)
+
+      expect(response).to have_http_status(:not_found)
+      expect(someone_elses_model.reload.public_send(required_attribute))
+        .not_to eq(model_params[required_attribute])
+    end
+
+    it 'attributes a created record to the current user regardless of the request', :aggregate_failures do
+      body = body_params(model_params.merge(owner_association => other_user.id))
+      post :create, params: with_route_params(body), format: format_param(:create)
+
+      expect(response).to have_http_status(check_status(:create) || :created)
+      expect(model_class_object.last.public_send(owner_association)).to eq(current_user)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HtmlNotice
+  class DummyModelsController < HtmlModes::BaseController
+    simple_crud_for :create, html: true, authenticate: false, authorize: false,
+                             notice: 'created', alert: 'invalid'
+    simple_crud_for :update, html: true, authenticate: false, authorize: false,
+                             notice: 'updated', alert: 'invalid'
+    simple_crud_for :destroy, html: true, authenticate: false, authorize: false, notice: 'removed'
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Owned
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    # No :user_id: a permitted FK would let a request override the owner set by owned_by:.
+    def dummy_model_params
+      params.permit(:name, :something, :slug)
+    end
+
+    simple_crud_defaults owned_by: :dummy_models, authorize: false
+    simple_crud_for :index
+    simple_crud_for :show
+    simple_crud_for :create
+    simple_crud_for :update
+    simple_crud_for :destroy
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Parented
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    # The default association for this model is @user.dummy_models.
+    def owner = @owner ||= User.find(params[:owner_id])
+
+    def dummy_model_params
+      params.permit(:name, :something, :slug)
+    end
+
+    simple_crud_defaults parent: :owner, authorize: false
+    simple_crud_for :index
+    simple_crud_for :show
+    simple_crud_for :create
+    simple_crud_for :update
+    simple_crud_for :destroy
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ScopedSymbol
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    simple_crud_for :index, scope: :visible_to
+  end
+end

data/spec/dummy/app/models/dummy_model.rb

@@ -8,4 +8,8 @@ class DummyModel < ApplicationRecord
   def self.find_by_slug(params)
     find_by!(slug: params[:slug])
   end
+
+  def self.visible_to(user, _params)
+    where(user: user)
+  end
 end

data/spec/dummy/app/serializers/dummy_model_plain_serializer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Exercises the plain-class serializer path.
+class DummyModelPlainSerializer
+  def self.render(record, **options)
+    { id: record.id, name: record.name, something: record.something, root: options[:root] }.compact
+  end
+end

data/spec/dummy/app/views/html_notice/dummy_models/edit.html.erb

@@ -0,0 +1 @@
+Edit

data/spec/dummy/config/routes.rb

@@ -40,6 +40,14 @@ Rails.application.routes.draw do
     resources :dummy_models, only: :index
   end
 
+  namespace :owned do
+    resources :dummy_models
+  end
+
+  namespace :scoped_symbol do
+    resources :dummy_models, only: :index
+  end
+
   namespace :unpaginated_scoped do
     resources :dummy_models, only: :index
   end
@@ -88,6 +96,10 @@ Rails.application.routes.draw do
     resources :dummy_models, only: :destroy
   end
 
+  namespace :html_notice do
+    resources :dummy_models, only: %i[create update destroy]
+  end
+
   namespace :block_destroy do
     resources :dummy_models, only: :destroy
   end
@@ -133,4 +145,8 @@ Rails.application.routes.draw do
       resources :dummy_models, param: :slug, only: %i[show create destroy]
     end
   end
+
+  namespace :parented do
+    resources :dummy_models
+  end
 end

data/spec/html_notice/dummy_models_controller_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe HtmlNotice::DummyModelsController, type: :controller do
+  describe 'POST #create' do
+    it 'flashes the notice on success' do
+      post :create, params: attributes_for(:dummy_model).merge(user_id: create(:user).id), format: :html
+
+      expect(flash[:notice]).to eq('created')
+    end
+  end
+
+  describe 'PUT #update' do
+    let(:record) { create(:dummy_model) }
+
+    it 'flashes the notice on success' do
+      put :update, params: { id: record.id, name: 'renamed' }, format: :html
+
+      expect(flash[:notice]).to eq('updated')
+    end
+
+    it 'flashes the alert on failure' do
+      put :update, params: { id: record.id, name: nil }, format: :html
+
+      expect(flash.now[:alert]).to eq('invalid')
+    end
+  end
+
+  describe 'DELETE #destroy' do
+    it 'flashes the notice on success' do
+      record = create(:dummy_model)
+      delete :destroy, params: { id: record.id }, format: :html
+
+      expect(flash[:notice]).to eq('removed')
+    end
+  end
+end

data/spec/owned/dummy_models_controller_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Owned::DummyModelsController, type: :controller do
+  include_examples 'simple crud for show'
+  include_examples 'simple crud for create'
+  include_examples 'simple crud for update'
+  include_examples 'simple crud for destroy'
+  include_examples 'simple crud for index'
+  include_examples 'simple crud for owned resource'
+end

data/spec/parented/dummy_models_controller_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Parented::DummyModelsController, simple_crud: {
+  route_params: -> { { owner_id: current_user.id } }
+}, type: :controller do
+  let(:owner) { create(:user) }
+
+  include_examples 'simple crud for nested resource'
+
+  describe 'POST #create' do
+    include_context 'with authenticated user'
+
+    it 'builds the record through the parent association' do
+      post :create, params: { owner_id: owner.id, name: 'from parent' }, format: :json
+
+      expect(owner.dummy_models.find(response.parsed_body['id']).name).to eq('from parent')
+    end
+  end
+
+  describe 'POST #create with parent: and owned_by: together' do
+    it 'raises, they are the same relation source' do
+      expect do
+        described_class.simple_crud_for(:show, parent: :owner, owned_by: :dummy_models)
+      end.to raise_error(ArgumentError, /mutually exclusive/)
+    end
+  end
+end

data/spec/scoped_symbol/dummy_models_controller_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ScopedSymbol::DummyModelsController, type: :controller do
+  include_examples 'simple crud for index with scope'
+end

data/spec/simple_crud/action_context_spec.rb

@@ -20,6 +20,21 @@ describe SimpleCrud::ActionContext do
     end
   end
 
+  describe '#build_record' do
+    it 'raises not found when owned_by has no owner to build from' do
+      ctx = described_class.new(double(params: {}), DummyModel, { owned_by: :dummy_models })
+      expect { ctx.send(:build_record) }.to raise_error(ActiveRecord::RecordNotFound, /no owner/)
+    end
+
+    it 'builds through the scoped relation when configured' do
+      relation = double(build: :built)
+      ctrl = double(params: {})
+      ctrl.instance_variable_set(:@owner, double(dummy_models: relation))
+
+      expect(described_class.new(ctrl, DummyModel, { parent: :owner }).send(:build_record)).to eq(:built)
+    end
+  end
+
   describe '#serializer_options' do
     let(:record) { DummyModel.new(name: 'widget') }
 

data/spec/simple_crud/index_context_spec.rb

@@ -27,5 +27,54 @@ describe SimpleCrud::IndexContext do
       ctx = described_class.new(ctrl, DummyModel, { scope: ->(u) { u }, authorize: false })
       expect(ctx.send(:call_scope)).to eq(admin)
     end
+
+    it 'runs an arity-zero scope with the controller as self and no arguments' do
+      ctrl = double(params: {}, listing: DummyModel.none)
+      ctx = described_class.new(ctrl, DummyModel, { scope: -> { listing }, authorize: false })
+
+      expect(ctx.send(:call_scope)).to eq(DummyModel.none)
+    end
+
+    it 'dispatches a Symbol scope to the model with user and params' do
+      ctrl = double(params: { status: 'active' })
+      allow(DummyModel).to receive(:visible_to).with(nil, { status: 'active' }).and_return(DummyModel.none)
+      ctx = described_class.new(ctrl, DummyModel, { scope: :visible_to, authorize: false })
+
+      expect(ctx.send(:call_scope)).to eq(DummyModel.none)
+    end
+  end
+
+  describe '#index_relation' do
+    let(:owned_records) { DummyModel.none }
+
+    it 'scopes to the owned_by relation even when authorize is on' do
+      ctrl = double(params: {}, current_user: double(dummy_models: owned_records))
+      ctx = described_class.new(ctrl, DummyModel, { owned_by: :dummy_models, authorize: true })
+
+      expect(ctx.send(:index_relation)).to eq(owned_records)
+    end
+
+    it 'returns no records when there is no user to own them' do
+      ctx = described_class.new(double(params: {}), DummyModel, { owned_by: :dummy_models, authorize: false })
+
+      expect(ctx.send(:index_relation)).to be_empty
+    end
+
+    it 'scopes to the parent relation' do
+      parent = double(dummy_models: owned_records)
+      ctrl = double(params: {})
+      ctrl.instance_variable_set(:@owner, parent)
+      ctx = described_class.new(ctrl, DummyModel, { parent: :owner, authorize: false })
+
+      expect(ctx.send(:index_relation)).to eq(owned_records)
+    end
+
+    it 'returns no records when the parent association is empty' do
+      ctrl = double(params: {})
+      ctrl.instance_variable_set(:@owner, double(dummy_models: nil))
+      ctx = described_class.new(ctrl, DummyModel, { parent: :owner, authorize: false })
+
+      expect(ctx.send(:index_relation)).to be_empty
+    end
   end
 end

data/spec/simple_crud/relation_source_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SimpleCrud::RelationSource do
+  after { SimpleCrud::Config.user_method = :current_user }
+
+  let(:controller) { double(params: {}) }
+  let(:source) { described_class.new(controller, DummyModel, parameters) }
+
+  describe '#configured?' do
+    it 'is true for owned_by' do
+      expect(described_class.new(controller, DummyModel, { owned_by: :dummy_models })).to be_configured
+    end
+
+    it 'is true for parent' do
+      expect(described_class.new(controller, DummyModel, { parent: :owner })).to be_configured
+    end
+
+    it 'is false when neither is set' do
+      expect(described_class.new(controller, DummyModel, {})).not_to be_configured
+    end
+  end
+
+  describe '#relation' do
+    it 'is nil when neither option is set' do
+      expect(described_class.new(controller, DummyModel, {}).relation).to be_nil
+    end
+
+    context 'with owned_by' do
+      let(:parameters) { { owned_by: :dummy_models } }
+
+      it 'resolves the association on the user' do
+        models = DummyModel.none
+        allow(controller).to receive(:current_user).and_return(double(dummy_models: models))
+
+        expect(source.relation).to eq(models)
+      end
+
+      it 'is nil without a current user' do
+        expect(source.relation).to be_nil
+      end
+
+      it 'resolves the user via overridden Config.user_method' do
+        SimpleCrud::Config.user_method = :current_admin
+        models = DummyModel.none
+        allow(controller).to receive(:current_admin).and_return(double(dummy_models: models))
+
+        expect(source.relation).to eq(models)
+      end
+    end
+
+    context 'with parent' do
+      let(:parameters) { { parent: :owner } }
+
+      it 'prefers a controller method over an ivar' do
+        parent = double(dummy_models: DummyModel.none)
+        allow(controller).to receive(:owner).and_return(parent)
+
+        expect(source.relation).to eq(DummyModel.none)
+      end
+
+      it 'falls back to the ivar when there is no method' do
+        parent = double(dummy_models: DummyModel.none)
+        controller.instance_variable_set(:@owner, parent)
+
+        expect(source.relation).to eq(DummyModel.none)
+      end
+
+      it 'runs a Proc parent in controller context' do
+        parent = double(dummy_models: DummyModel.none)
+        allow(controller).to receive(:owner).and_return(parent)
+        proc_source = described_class.new(controller, DummyModel, { parent: -> { owner } })
+
+        expect(proc_source.relation).to eq(DummyModel.none)
+      end
+
+      it 'is nil when the parent resolves to nil' do
+        controller.instance_variable_set(:@owner, nil)
+
+        expect(source.relation).to be_nil
+      end
+
+      it 'derives the association from the model' do
+        parent = double
+        controller.instance_variable_set(:@owner, parent)
+        allow(parent).to receive(:dummy_models).and_return(DummyModel.none)
+
+        expect(source.relation).to eq(DummyModel.none)
+      end
+
+      it 'honors parent_association:' do
+        models = DummyModel.none
+        controller.instance_variable_set(:@owner, double(special: models))
+        source = described_class.new(controller, DummyModel, { parent: :owner, parent_association: :special })
+
+        expect(source.relation).to eq(models)
+      end
+    end
+  end
+
+  describe '#relation!' do
+    let(:parameters) { { owned_by: :dummy_models } }
+
+    it 'raises not found when the owner cannot be resolved' do
+      expect { source.relation! }.to raise_error(ActiveRecord::RecordNotFound, /no owner for dummy_models/)
+    end
+  end
+
+  describe '#user' do
+    let(:parameters) { {} }
+
+    it 'returns nil when the controller has no user method' do
+      expect(source.user).to be_nil
+    end
+  end
+
+  describe 'unresolvable parent' do
+    let(:parameters) { { parent: :owner } }
+
+    it 'raises when the parent is neither a method nor an ivar' do
+      expect { source.relation }.to raise_error(ArgumentError, /neither a controller method nor an @owner ivar/)
+    end
+  end
+end

data/spec/simple_crud/serializer_spec.rb

@@ -4,6 +4,17 @@ require 'spec_helper'
 
 describe SimpleCrud::Serializer do
   let(:record) { DummyModel.new(id: 1, name: 'widget', something: 'thing', user_id: 9) }
+  let(:non_class_serializer) do
+    Module.new do
+      def self.render(_record, **)
+        :plain
+      end
+
+      def self.new(*)
+        Struct.new(:as_json).new(:ams)
+      end
+    end
+  end
 
   describe '.render' do
     it 'falls back to the record as_json when there is no serializer' do
@@ -16,6 +27,16 @@ describe SimpleCrud::Serializer do
       expect(result).to include(id: record.id, name: record.name, something: record.something, user_id: record.user_id)
     end
 
+    it 'calls a plain class .render method with the options splatted as keywords' do
+      result = described_class.render(DummyModelPlainSerializer, record, { root: false })
+
+      expect(result).to eq(id: record.id, name: record.name, something: record.something, root: false)
+    end
+
+    it 'falls through to the AMS path for a non-class that responds to render' do
+      expect(described_class.render(non_class_serializer, record)).to eq(:ams)
+    end
+
     it 'instantiates an AMS-style serializer with the given options', :aggregate_failures do
       allow(DummyModelSerializer).to receive(:new).and_call_original
 

data/spec/simple_crud/show_context_spec.rb

@@ -10,5 +10,10 @@ describe SimpleCrud::ShowContext do
       expect { ctx.send(:find_record) }
         .to raise_error(ActiveRecord::RecordNotFound, /must return a single record/)
     end
+
+    it 'raises not found when owned_by has no owner to scope the lookup to' do
+      ctx = described_class.new(double(params: { id: 1 }), DummyModel, { owned_by: :dummy_models, authorize: false })
+      expect { ctx.send(:find_record) }.to raise_error(ActiveRecord::RecordNotFound, /no owner/)
+    end
   end
 end

data/spec/simple_crud_controller_spec.rb

@@ -16,7 +16,22 @@ end
 class InheritingController < BaseWithDefaultsController
 end
 
+class MultiActionModel; end
+
+class MultiActionModelsController
+  extend SimpleCrudController
+end
+
 describe SimpleCrudController do
+  describe '.simple_crud_for' do
+    it 'declares every action when given an array', :aggregate_failures do
+      MultiActionModelsController.simple_crud_for(%i[show create], authorize: false, authenticate: false)
+
+      expect(MultiActionModelsController.method_defined?(:show)).to be true
+      expect(MultiActionModelsController.method_defined?(:create)).to be true
+    end
+  end
+
   describe '.check_policies' do
     it 'returns when a matching policy exists' do
       expect { DummyModelsController.check_policies(authorize: true) }.not_to raise_error

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wor-simple_crud
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - icoluccio
 bindir: bin
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -67,6 +67,7 @@ files:
 - 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/relation_source.rb
 - lib/simple_crud/rspec.rb
 - lib/simple_crud/rspec/config.rb
 - lib/simple_crud/rspec/helpers.rb
@@ -95,9 +96,11 @@ files:
 - lib/spec/shared_examples/simple_crud_for_index.rb
 - lib/spec/shared_examples/simple_crud_for_index_with_block.rb
 - lib/spec/shared_examples/simple_crud_for_index_with_scope.rb
+- lib/spec/shared_examples/simple_crud_for_nested_resource.rb
 - lib/spec/shared_examples/simple_crud_for_new.rb
 - lib/spec/shared_examples/simple_crud_for_new_with_block.rb
 - lib/spec/shared_examples/simple_crud_for_new_with_build.rb
+- lib/spec/shared_examples/simple_crud_for_owned_resource.rb
 - lib/spec/shared_examples/simple_crud_for_show.rb
 - lib/spec/shared_examples/simple_crud_for_show_with_block.rb
 - lib/spec/shared_examples/simple_crud_for_show_with_finder.rb
@@ -148,16 +151,20 @@ files:
 - spec/dummy/app/controllers/html_finder/dummy_models_controller.rb
 - spec/dummy/app/controllers/html_modes/base_controller.rb
 - spec/dummy/app/controllers/html_new/dummy_models_controller.rb
+- spec/dummy/app/controllers/html_notice/dummy_models_controller.rb
 - spec/dummy/app/controllers/html_scoped/dummy_models_controller.rb
 - spec/dummy/app/controllers/html_show/dummy_models_controller.rb
 - spec/dummy/app/controllers/html_update/dummy_models_controller.rb
 - spec/dummy/app/controllers/invalid_status/dummy_models_controller.rb
 - spec/dummy/app/controllers/nested/dummy_models_controller.rb
 - spec/dummy/app/controllers/nested_route/dummy_models_controller.rb
+- spec/dummy/app/controllers/owned/dummy_models_controller.rb
+- spec/dummy/app/controllers/parented/dummy_models_controller.rb
 - spec/dummy/app/controllers/redirect/dummy_models_controller.rb
 - spec/dummy/app/controllers/redirect_auth/dummy_models_controller.rb
 - spec/dummy/app/controllers/scoped/dummy_models_controller.rb
 - spec/dummy/app/controllers/scoped_params/dummy_models_controller.rb
+- spec/dummy/app/controllers/scoped_symbol/dummy_models_controller.rb
 - spec/dummy/app/controllers/strict/dummy_models_controller.rb
 - spec/dummy/app/controllers/unpaginated_scoped/dummy_models_controller.rb
 - spec/dummy/app/controllers/without_pagination/dummy_models_controller.rb
@@ -166,6 +173,7 @@ files:
 - spec/dummy/app/models/dummy_model.rb
 - spec/dummy/app/models/dummy_model_policy.rb
 - spec/dummy/app/models/user.rb
+- spec/dummy/app/serializers/dummy_model_plain_serializer.rb
 - spec/dummy/app/serializers/dummy_model_serializer.rb
 - spec/dummy/app/views/block/dummy_models/index.html.erb
 - spec/dummy/app/views/block_new/dummy_models/new.html.erb
@@ -177,6 +185,7 @@ files:
 - spec/dummy/app/views/html_finder/dummy_models/new.html.erb
 - spec/dummy/app/views/html_finder/dummy_models/show.html.erb
 - spec/dummy/app/views/html_new/dummy_models/new.html.erb
+- spec/dummy/app/views/html_notice/dummy_models/edit.html.erb
 - spec/dummy/app/views/html_scoped/dummy_models/index.html.erb
 - spec/dummy/app/views/html_show/dummy_models/show.html.erb
 - spec/dummy/app/views/html_update/dummy_models/edit.html.erb
@@ -221,22 +230,27 @@ files:
 - spec/html_destroy/dummy_models_controller_spec.rb
 - spec/html_finder/dummy_models_controller_spec.rb
 - spec/html_new/dummy_models_controller_spec.rb
+- spec/html_notice/dummy_models_controller_spec.rb
 - spec/html_scoped/dummy_models_controller_spec.rb
 - spec/html_show/dummy_models_controller_spec.rb
 - spec/html_update/dummy_models_controller_spec.rb
 - spec/invalid_status/dummy_models_controller_spec.rb
 - spec/nested/dummy_models_controller_spec.rb
 - spec/nested_route/dummy_models_controller_spec.rb
+- spec/owned/dummy_models_controller_spec.rb
+- spec/parented/dummy_models_controller_spec.rb
 - spec/redirect/dummy_models_controller_spec.rb
 - spec/redirect_auth/dummy_models_controller_spec.rb
 - spec/scoped/dummy_models_controller_spec.rb
 - spec/scoped_params/dummy_models_controller_spec.rb
+- spec/scoped_symbol/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/index_context_spec.rb
 - spec/simple_crud/pagination/adapters_spec.rb
+- spec/simple_crud/relation_source_spec.rb
 - spec/simple_crud/rspec_config_spec.rb
 - spec/simple_crud/serializer_spec.rb
 - spec/simple_crud/show_context_spec.rb