wor-simple_crud 0.2.1 → 0.3.1

data/lib/simple_crud/pagination/kaminari_adapter.rb

@@ -10,10 +10,31 @@ module SimpleCrud
     class KaminariAdapter
       include Adapter
 
-      def paginate(controller, klass, options)
-        records = klass.page(controller.params[:page]).per(controller.params[:per_page])
+      def paginate(controller, relation, options)
+        records = paginated_records(controller, relation, options)
         controller.render({ json: records }.merge(options))
       end
+
+      # Manual page scope: will_paginate shadows Relation#page when both load.
+      def paginated_records(controller, relation, _options)
+        page = [controller.params[:page].to_i, 1].max
+        per_page = page_size(controller)
+
+        relation.limit(per_page).offset(per_page * (page - 1)).extending do
+          include Kaminari::ActiveRecordRelationMethods
+          include Kaminari::PageScopeMethods
+        end
+      end
+
+      private
+
+      # Params arrive as strings: coerce before arithmetic or "5" * 2 == "55".
+      def page_size(controller)
+        size = (controller.params[:per_page] || Kaminari.config.default_per_page).to_i
+        size = [size, 1].max
+        size = [size, Kaminari.config.max_per_page].min if Kaminari.config.max_per_page
+        size
+      end
     end
   end
 end

data/lib/simple_crud/pagination/pagy_adapter.rb

@@ -13,10 +13,15 @@ module SimpleCrud
       # the pre-rename 43.4.x, so pick whichever key the loaded Pagy expects.
       MAX_LIMIT_KEY = Gem::Version.new(Pagy::VERSION) >= Gem::Version.new('43.5.0') ? :max_limit : :client_max_limit
 
-      def paginate(controller, klass, options)
-        _pagy, records = controller.send(:pagy, klass.all, MAX_LIMIT_KEY => 100)
+      def paginate(controller, relation, options)
+        records = paginated_records(controller, relation, options)
         controller.render({ json: records }.merge(options))
       end
+
+      def paginated_records(controller, relation, _options)
+        _pagy, records = controller.send(:pagy, relation, MAX_LIMIT_KEY => 100)
+        records
+      end
     end
   end
 end

data/lib/simple_crud/pagination/will_paginate_adapter.rb

@@ -11,11 +11,15 @@ module SimpleCrud
     class WillPaginateAdapter
       include Adapter
 
-      def paginate(controller, klass, options)
+      def paginate(controller, relation, options)
+        records = paginated_records(controller, relation, options)
+        controller.render({ json: records }.merge(options))
+      end
+
+      def paginated_records(controller, relation, _options)
         page = controller.params[:page] || 1
         per_page = controller.params[:per_page] || WillPaginate.per_page
-        records = klass.paginate(page: page, per_page: per_page)
-        controller.render({ json: records }.merge(options))
+        relation.paginate(page: page, per_page: per_page)
       end
     end
   end

data/lib/simple_crud/pagination/wor_paginate_adapter.rb

@@ -9,8 +9,13 @@ module SimpleCrud
     class WorPaginateAdapter
       include Adapter
 
-      def paginate(controller, klass, options)
-        controller.send(:render_paginated, klass, options)
+      def paginate(controller, relation, options)
+        controller.send(:render_paginated, relation, options)
+      end
+
+      def paginated_records(controller, relation, options)
+        adapter = controller.send(:find_adapter_for_content, relation, options)
+        adapter.paginated_content
       end
     end
   end

data/lib/simple_crud/rspec/config.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Test helpers: SimpleCrud::RSpec.configure exposes the shared examples'
+  # configuration for apps on a different stack than the gem's.
+  module RSpec
+    def self.configure
+      yield Config.instance
+    end
+
+    # Configures how the shared examples create records, authenticate
+    # requests and introspect policies/serializers. The defaults match the
+    # gem's own stack (Devise-JWT + FactoryBot + Pundit + ActiveModel
+    # Serializers), so apps on a different stack can override them via
+    # SimpleCrud::RSpec.configure instead of editing the examples.
+    #
+    # Callable settings (authenticate, current_user, other_user,
+    # create_record, create_records, params_for, model_attributes,
+    # policy_class, serializer_class) run in the example-group context, so
+    # they can call helpers such as `create`, `request` and `current_user`.
+    class Config
+      DEFAULTS = {
+        authenticate: lambda {
+          headers = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+          request.headers.merge!(Devise::JWT::TestHelpers.auth_headers(headers, current_user))
+        },
+        current_user: -> { create(:user) },
+        other_user: -> { create(:user) },
+        create_record: ->(klass, attributes) { create(klass, **attributes) },
+        create_records: ->(klass, count, attributes) { create_list(klass, count, **attributes) },
+        params_for: ->(klass) { attributes_for(klass) },
+        owner_association: :user,
+        model_attributes: -> { owner_association ? { owner_association => current_user } : {} },
+        scoped_attributes: -> { model_attributes },
+        other_scoped_attributes: lambda {
+          attributes = model_attributes
+          if owner_association && !attributes.is_a?(Hash)
+            raise ArgumentError,
+                  'model_attributes must resolve to a Hash when owner_association is set; ' \
+                  'override other_scoped_attributes instead'
+          end
+
+          owner_association ? attributes.merge(owner_association => other_user) : {}
+        },
+        required_attribute: :name,
+        required_error: "Name can't be blank",
+        finder_key: :slug,
+        params_key: nil,
+        route_params: -> { {} },
+        invalid_status: :ok,
+        unauthenticated_status: :unauthorized,
+        assert_html_template: true,
+        policy_class: ->(klass) { "#{klass}Policy".constantize },
+        serializer_class: ->(model) { "#{model.class}_serializer".classify.constantize },
+        created_record_check: nil
+      }.freeze
+
+      class << self
+        def instance
+          @instance ||= new
+        end
+      end
+
+      def initialize
+        @values = {}
+      end
+
+      DEFAULTS.each_key do |key|
+        define_method(key) { @values.fetch(key, DEFAULTS[key]) }
+        define_method("#{key}=") { |value| @values[key] = value }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Current/other users, signing requests in and the owner association
+      # attributed to the current user.
+      module Authentication
+        def current_user
+          @current_user ||= instance_exec(&setting(:current_user))
+        end
+
+        def other_user
+          @other_user ||= instance_exec(&setting(:other_user))
+        end
+
+        def authenticate_request
+          instance_exec(&setting(:authenticate))
+        end
+
+        def owner_foreign_key
+          :"#{owner_association}_id"
+        end
+
+        # The owner association attributed to current_user, if the model has one.
+        def owner_params
+          owner_association ? { owner_foreign_key => current_user.id } : {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Definition-time introspection of the options each action was declared
+      # with via simple_crud_for (read from the controller's metadata).
+      module ControllerOptions
+        def get_option(method, option)
+          described_class.instance_variable_get(:@simple_crud_metadata)[method][option]
+        end
+
+        %i[paginate authorize authenticate serializer html finder scope build raise_on_invalid block].each do |option|
+          define_method("check_#{option}") { |method| get_option(method, option) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Building the record under test and the params used to persist it.
+      module Models
+        def model_class
+          described_class.to_s.split('::')
+                         .last.sub('Controller', '').singularize.underscore
+        end
+
+        def model_class_object
+          model_class.classify.constantize
+        end
+
+        def model
+          @model ||= create_record(model_class, model_attributes)
+        end
+
+        def model_attributes
+          resolve(setting(:model_attributes))
+        end
+
+        def create_record(klass, attributes)
+          instance_exec(klass, attributes, &setting(:create_record))
+        end
+
+        def create_records(klass, count, attributes)
+          instance_exec(klass, count, attributes, &setting(:create_records))
+        end
+
+        def params_for(klass)
+          instance_exec(klass, &setting(:params_for))
+        end
+
+        def model_params
+          @model_params ||= params_for(model_class)
+        end
+
+        def model_serializer
+          defined?(serializer) ? serializer : instance_exec(model, &setting(:serializer_class))
+        end
+
+        def rendered_record
+          controller.instance_variable_get(:@record)
+        end
+
+        def rendered_records
+          controller.instance_variable_get(:@records)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Locating the policy object for the model under test and stubbing it
+      # to allow or deny.
+      module Policies
+        def policy_class_object
+          instance_exec(model_class_object, &setting(:policy_class))
+        end
+
+        def make_policies_fail(method)
+          allow(policy_class_object).to receive(:new)
+            .and_return(instance_double(policy_class_object, "#{method}?" => false))
+        end
+
+        def make_policies_succeed(method)
+          allow(policy_class_object).to receive(:new)
+            .and_return(instance_double(policy_class_object, "#{method}?" => true))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Request params and format helpers shared by every action example.
+      module Requests
+        # :unprocessable_entity was renamed :unprocessable_content in Rack 3.1.
+        # Resolve the current Rack's canonical symbol for 422.
+        def unprocessable_status
+          Rack::Utils::SYMBOL_TO_STATUS_CODE.invert[422]
+        end
+
+        def request_format(action)
+          check_html(action) ? :html : :json
+        end
+
+        # Extra params (e.g. a parent slug) added to every request, for nested
+        # resources like /projects/:project_slug/tasks.
+        def route_params
+          resolve(setting(:route_params))
+        end
+
+        def with_route_params(attrs)
+          route_params.merge(attrs)
+        end
+
+        # The params that identify a record for the given action, using the
+        # configured finder_key when the action has a custom finder.
+        def record_param(action, record, not_found: false)
+          key = check_finder(action) ? finder_key : :id
+          value = not_found ? "nonexistent-#{key}" : record.public_send(key)
+          { key => value }
+        end
+
+        # Wraps a request body under the model's strong-params key when
+        # params_key is configured (nested strong params), else passes it flat.
+        def body_params(attrs)
+          key = params_key
+          key ? { key => attrs } : attrs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  module RSpec
+    module Helpers
+      # Settings resolution: `simple_crud:` example-group metadata first,
+      # falling back to the app-wide SimpleCrud::RSpec::Config singleton.
+      module Settings
+        def config
+          SimpleCrud::RSpec::Config.instance
+        end
+
+        def simple_crud_settings
+          source = ::RSpec.current_example ? ::RSpec.current_example.metadata : metadata
+          source[:simple_crud] || {}
+        end
+
+        def setting(name)
+          simple_crud_settings.fetch(name) { config.public_send(name) }
+        end
+
+        def resolve(value)
+          value.is_a?(Proc) ? instance_exec(&value) : value
+        end
+
+        %i[owner_association required_attribute required_error finder_key params_key invalid_status
+           unauthenticated_status assert_html_template scoped_attributes other_scoped_attributes].each do |name|
+          define_method(name) { resolve(setting(name)) }
+        end
+
+        def created_record_check
+          setting(:created_record_check)
+        end
+
+        # Runs the block with a config setting temporarily overridden, restoring
+        # the original value afterwards (even if the block raises). Useful when
+        # a controller's spec needs a different setting than the app-wide default.
+        def with_config_override(setting, value)
+          config_instance = SimpleCrud::RSpec::Config.instance
+          original = config_instance.public_send(setting)
+          SimpleCrud::RSpec.configure { |c| c.public_send("#{setting}=", value) }
+          yield
+        ensure
+          SimpleCrud::RSpec.configure { |c| c.public_send("#{setting}=", original) }
+        end
+      end
+    end
+  end
+end

data/lib/simple_crud/rspec/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/settings'
+require_relative 'helpers/controller_options'
+require_relative 'helpers/models'
+require_relative 'helpers/authentication'
+require_relative 'helpers/requests'
+require_relative 'helpers/policies'
+
+module SimpleCrud
+  module RSpec
+    # Helpers available to the shared examples (and to apps that include
+    # them), composed from focused sub-modules: settings resolution,
+    # controller-option introspection, record building, authentication,
+    # request params and policy access.
+    module Helpers
+      include Settings
+      include ControllerOptions
+      include Models
+      include Authentication
+      include Requests
+      include Policies
+    end
+  end
+end

data/lib/simple_crud/rspec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'rspec/config'
+require_relative 'rspec/helpers'
 require_relative '../spec/response_helper'
 require_relative '../spec/shared_contexts/authenticate_user'
 require_relative '../spec/shared_examples/simple_crud_for_update'
@@ -7,5 +9,38 @@ require_relative '../spec/shared_examples/simple_crud_for_show'
 require_relative '../spec/shared_examples/simple_crud_for_index'
 require_relative '../spec/shared_examples/simple_crud_for_destroy'
 require_relative '../spec/shared_examples/simple_crud_for_create'
+require_relative '../spec/shared_examples/simple_crud_for_new'
+require_relative '../spec/shared_examples/simple_crud_for_edit'
 require_relative '../spec/shared_examples/unauthorized_when_not_logged_in'
+require_relative '../spec/shared_examples/simple_crud_renders_template'
+require_relative '../spec/shared_examples/simple_crud_without_authenticated_user'
+require_relative '../spec/shared_examples/simple_crud_when_not_authorized'
+require_relative '../spec/shared_examples/simple_crud_for_index_with_block'
+require_relative '../spec/shared_examples/simple_crud_for_index_with_scope'
+require_relative '../spec/shared_examples/simple_crud_for_show_with_block'
+require_relative '../spec/shared_examples/simple_crud_for_new_with_block'
+require_relative '../spec/shared_examples/simple_crud_for_create_with_block'
+require_relative '../spec/shared_examples/simple_crud_for_destroy_with_block'
+require_relative '../spec/shared_examples/simple_crud_for_show_with_finder'
+require_relative '../spec/shared_examples/simple_crud_for_update_with_finder'
+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/authorization_adapter_authorize'
 require_relative '../spec/matchers/have_been_serialized_with'
+
+module SimpleCrud
+  # Opt-in wiring for the shared examples: see .install!
+  module RSpec
+    # Opt-in wiring: call from your spec support after requiring this file.
+    # extend wires definition-time helpers (check_html...), include runtime ones (model...).
+    def self.install!
+      ::RSpec.configure do |config|
+        config.extend Helpers
+        config.include Helpers
+        config.include Response::JSONParser, type: :controller
+      end
+    end
+  end
+end

data/lib/simple_crud/simple_crud_controller.rb

@@ -2,9 +2,15 @@
 
 require 'active_support/all'
 require_relative 'config'
+require_relative 'controller_helpers'
+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
+
   cattr_accessor :params, :permitted
 
   # Possible options:
@@ -12,21 +18,31 @@ module SimpleCrudController
   ### paginate: paginate the list via Config.pagination_adapter (wor-paginate by default)
   ### authenticate: use devise to authenticate
   ### serializer: use a particular serializer (both each_serializer and serializer)
-  def simple_crud_for(method, parameters = {})
+  ### 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
+  ### build: custom record builder (Proc/lambda) for :new/:create, invoked with the controller as self
+  ### 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
+  def simple_crud_for(method, parameters = {}, &block)
+    parameters[:html] = true if block && !parameters.key?(:html)
+    parameters[:block] = true if block
     parameters = parameters_with_defaults(parameters)
     klass = simple_crud_controller_model
     check_valid_method(method)
     check_policies(parameters)
     check_serializer(parameters)
-    define_method(method, send("crud_lambda_for_#{method}", klass, parameters))
+    define_method(method, send("crud_lambda_for_#{method}", klass, parameters, &block))
     write_metadata(method, parameters)
   end
 
   def parameters_with_defaults(parameters)
-    defaults = { authorize: true, paginate: true, authenticate: true, serializer: nil }
-    defaults.each do |key, value|
-      parameters[key] = value unless parameters.key?(key)
-    end
+    defaults = {
+      authorize: true, paginate: true, authenticate: true, serializer: nil,
+      html: false, finder: nil, scope: nil, build: nil, raise_on_invalid: false
+    }
+    defaults.each { |key, value| parameters[key] = value unless parameters.key?(key) }
     parameters
   end
 
@@ -35,74 +51,12 @@ module SimpleCrudController
     @simple_crud_metadata[method] = parameters
   end
 
-  def self.maybe_authorize(controller, record, parameters)
-    return unless parameters[:authorize] && parameters[:authenticate]
-
-    SimpleCrud::Config.authorization_adapter.authorize(controller, record)
-  end
-
-  def crud_lambda_for_show(klass, parameters = {})
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = klass.find(params[:id])
-
-      options = {}.merge(serializer: parameters[:serializer]).compact
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      render({ json: requested }.merge(options))
-    end
-  end
-
-  def crud_lambda_for_index(klass, parameters = {})
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      SimpleCrudController.maybe_authorize(self, klass.new, parameters)
-      options = {}.merge(each_serializer: parameters[:serializer]).compact
-      SimpleCrudController.render_index(self, klass, options, parameters)
-    end
-  end
-
-  def self.render_index(controller, klass, options, parameters)
-    if parameters[:paginate]
-      SimpleCrud::Config.pagination_adapter.paginate(controller, klass, options)
-    else
-      controller.render({ json: klass.all }.merge(options))
-    end
-  end
-
-  def crud_lambda_for_create(klass, parameters = {})
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-      SimpleCrudController.maybe_authorize(self, klass.new(permitted_params), parameters)
-      render json: klass.create!(permitted_params), status: :created
-    end
-  end
-
-  def crud_lambda_for_update(klass, parameters = {})
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = klass.find(params[:id])
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-      render json: requested.update!(permitted_params)
-    end
-  end
-
-  def crud_lambda_for_destroy(klass, parameters = {})
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = klass.find(params[:id])
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      render json: klass.find(params[:id]).destroy
-    end
-  end
-
   def simple_crud_controller_model
     to_s.split('::').last.sub('Controller', '').singularize.classify.constantize
   end
 
   def check_valid_method(method)
-    throw 'invalid method' unless %i[show index create update destroy].include? method
+    raise ArgumentError, 'invalid method' unless %i[show index create update destroy new edit].include? method
   end
 
   def check_policies(parameters)
@@ -111,15 +65,13 @@ module SimpleCrudController
     model = simple_crud_controller_model
     return if SimpleCrud::Config.authorization_adapter.policy_defined?(model)
 
-    throw "no authorization policy configured for #{model}"
+    raise ArgumentError, "no authorization policy configured for #{model}"
   end
 
   def check_serializer(parameters)
-    return if parameters[:serializer].blank?
-
-    serializer_name = parameters[:serializer].to_s
-    return if Kernel.const_defined?(serializer_name)
+    name = parameters[:serializer].to_s
+    return if name.blank? || Kernel.const_defined?(name)
 
-    throw "create a valid serializer with name #{serializer_name}"
+    raise ArgumentError, "create a valid serializer with name #{name}"
   end
 end

data/lib/simple_crud/version.rb

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

data/lib/spec/shared_contexts/authenticate_user.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
 RSpec.shared_context 'with authenticated user' do
-  let(:current_user) { create(:user) }
-
-  before do
-    headers = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
-    auth_headers = Devise::JWT::TestHelpers.auth_headers(headers, current_user)
-    request.headers.merge!(auth_headers)
-  end
+  before { authenticate_request }
 end

data/lib/spec/shared_examples/authorization_adapter_authorize.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+shared_examples 'authorization adapter #authorize' do |record_class, denied_error|
+  it 'passes for a record the adapter allows' do
+    expect { adapter.authorize(controller, record_class.new(1)) }.not_to raise_error
+  end
+
+  it 'raises for a record the adapter denies' do
+    expect { adapter.authorize(controller, record_class.new(2)) }.to raise_error(denied_error)
+  end
+end