wor-simple_crud 0.5.0 → 0.7.0

data/spec/blueprint_unpaginated/dummy_models_controller_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlueprintUnpaginated::DummyModelsController, type: :controller do
+  let(:serializer) { DummyModelBlueprint }
+
+  include_examples 'simple crud for index'
+end

data/spec/dummy/app/blueprints/dummy_model_blueprint.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class DummyModelBlueprint < Blueprinter::Base
+  identifier :id
+  fields :name, :something, :user_id
+
+  field :url do |record, options|
+    options[:url_builder]&.dummy_model_url(record)
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Blueprint
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    def dummy_model_params
+      params.permit(:name, :something, :user_id, :slug)
+    end
+
+    SERIALIZER_OPTIONS = -> { { url_builder: self } }
+
+    simple_crud_for :index, serializer: DummyModelBlueprint
+    simple_crud_for :show, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :create, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :update, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :destroy, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module BlueprintUnpaginated
+  class DummyModelsController < ApplicationController
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    simple_crud_for :index, paginate: false, serializer: DummyModelBlueprint
+  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
@@ -120,9 +132,21 @@ Rails.application.routes.draw do
     resources :dummy_models, only: :create
   end
 
+  namespace :blueprint do
+    resources :dummy_models
+  end
+
+  namespace :blueprint_unpaginated do
+    resources :dummy_models, only: :index
+  end
+
   namespace :nested_route do
     resources :classrooms, only: [], param: :slug do
       resources :dummy_models, param: :slug, only: %i[show create destroy]
     end
   end
+
+  namespace :parented do
+    resources :dummy_models
+  end
 end

data/spec/dummy_model_blueprint_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DummyModelBlueprint do
+  let(:dummy_model) { DummyModel.new(id: 3, name: 'widget', something: 'thing', user_id: 7) }
+  let(:full_response) { described_class.render_as_hash(dummy_model) }
+
+  it 'matches a response including all blueprint attributes' do
+    expect(full_response).to have_been_serialized_with(described_class)
+  end
+
+  it 'does not match a response missing blueprint attributes' do
+    expect({ 'id' => dummy_model.id }).not_to have_been_serialized_with(described_class)
+  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

@@ -19,4 +19,38 @@ describe SimpleCrud::ActionContext do
       expect(key).to eq('dummy_model:show:v1:/dummy_models/1')
     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') }
+
+    it 'returns an empty hash when no callable is configured' do
+      ctx = described_class.new(double, DummyModel, {})
+      expect(ctx.send(:serializer_options, record)).to eq({})
+    end
+
+    it 'calls a zero-arity callable without the record' do
+      ctx = described_class.new(double, DummyModel, { serializer_options: -> { { prefix: :none } } })
+      expect(ctx.send(:serializer_options, record)).to eq(prefix: :none)
+    end
+
+    it 'calls an arity-one callable with the record' do
+      ctx = described_class.new(double, DummyModel, { serializer_options: ->(record) { { name: record.name } } })
+      expect(ctx.send(:serializer_options, record)).to eq(name: 'widget')
+    end
+  end
 end

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/rspec_config_spec.rb

@@ -58,6 +58,19 @@ describe SimpleCrud::RSpec do
       SimpleCrud::RSpec.configure { |c| c.required_attribute = original }
       expect(config.required_attribute).to eq(:name)
     end
+
+    describe 'the default serializer_class' do
+      it 'prefers the AMS serializer when the constant exists' do
+        expect(config.serializer_class.call(DummyModel.new)).to eq(DummyModelSerializer)
+      end
+
+      it 'falls back to the Blueprint when there is no AMS serializer' do
+        allow(Kernel).to receive(:const_defined?).and_call_original
+        allow(Kernel).to receive(:const_defined?).with('DummyModelSerializer').and_return(false)
+
+        expect(config.serializer_class.call(DummyModel.new)).to eq(DummyModelBlueprint)
+      end
+    end
   end
 
   describe SimpleCrud::RSpec::Helpers do

data/spec/simple_crud/serializer_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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
+      expect(described_class.render(nil, record)).to eq(record.as_json)
+    end
+
+    it 'renders through a Blueprinter blueprint with the given options' do
+      result = described_class.render(DummyModelBlueprint, record, { url_builder: nil })
+
+      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
+
+      result = described_class.render(DummyModelSerializer, record, { root: false })
+
+      expect(DummyModelSerializer).to have_received(:new).with(record, { root: false })
+      expect(result).to include(id: record.id, something: record.something)
+    end
+  end
+end

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