active_manageable 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8645a9930ecc8e01e70b9a98c188c832ffe543b0599d9e819f640cc64d6d88fd
-  data.tar.gz: 8354ce84a33378e123b3a299c1e6db2218b1f9611898275340ea003a2cae608e
+  metadata.gz: 33e6916eea9e70cfa5c04813328b8e1cb21e93f3f2638705b2ec0b37748de51c
+  data.tar.gz: 37122950ad83b210bd043ce2fc556032451df60deef18dc4f58cead9917f1f1f
 SHA512:
-  metadata.gz: 2334299accc2984ac5e590b3dd9d253b67188302ef4d86688a56cc8c6f29a5b893ac29076a00d871bf3dd87c0e3e1067c317d799ec4adfc356fe231bd86ebaad
-  data.tar.gz: 3dc07fc9f551910ce7250f44901222ffffb04b0183b163fcc23067c574a50132703b43aab3df1fcc5347b077039a64f39f7e3b444a8064b6687db109eda6bb87
+  metadata.gz: d2afeaad9032f497b31208e0e4c8b21e209b40d81346dc1468a3eefdb251e1d6c5c01f6759d58e2cab99782116920845077fd62bcb90a54e20ac7c322c556647
+  data.tar.gz: 608affa3ab36c003c03c0af6f27d09b404cfd6e8b987bd6ec57b3605b7f93910b95409073afda386f1e4fb33998cb07bdcc1428ddcf23ae3bac5eb2e2b0eefb7

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change Log
 
+## 0.2.0 - 2022-09-27
+
+* Allow the configuration library options to accept a module
+* Add `action_scope` method that can be overridden in order to retrieve and maintain records using a scope
+* Rename `scoped_class` method to `authorization_scope`
+* Move instance method definitions out of the ActiveSupport::Concern included block so that they can be overridden
+* Split action methods into smaller overridable methods
+* Add a yield to each of the action methods
+* Perform yield and object create, update & destroy within a transaction
+* Add public instance methods to return the default options
+* When using the Kaminari library provide the ability to use the `without_count` mode to create a paginatable collection without counting the total number of records; either via the index method options or a class option or configuration option
+
 ## 0.1.2 - 2022-08-25
 
 * Upgrade gems including activerecord, actionpack, actionview, nokogiri & rack to resolve security advisory alerts

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_manageable (0.1.2)
+    active_manageable (0.2.0)
       activerecord (>= 6.0)
       activesupport (>= 6.0)
       flexitime (~> 1.0)

data/README.md

@@ -49,7 +49,7 @@ def index
 end
 ```
 
-The manager classes provide standard implementations of the seven core CRUD methods. These can be overwritten to perform custom business logic and the classes can also be extended to include the business logic for additional actions, both making use of the internal ActiveManageable methods and variables described in the [Adding Bespoke Methods](#adding-bespoke-methods) section.
+The manager classes provide standard implementations of the seven core CRUD methods. These can be extended or overwritten to perform custom business logic and the classes can also be extended to include the business logic for additional actions, both making use of the internal ActiveManageable methods and variables described in the [Adding Bespoke Methods](#adding-bespoke-methods) section.
 
 With an Activity model in a CRM application to manage meetings & tasks, a complete action may be required. This could be implemented as follows:
 
@@ -110,6 +110,7 @@ gem install active_manageable
   - [Default Scopes](#default-scopes)
   - [Unique Search](#unique-search)
   - [Default Page Size](#default-page-size)
+  - [Paginate Without Count](#paginate-without-count)
   - [Current Method](#current-method)
 - [Index Method](#index-method)
   - [Authorization Scope](#index-authorization-scope)
@@ -131,6 +132,8 @@ gem install active_manageable
   - [Includes Option](#update-includes-option)
 - [Destroy Method](#destroy-method)
   - [Includes Option](#destroy-includes-option)
+- [Extending the CRUD Methods](#extending-the-crud-methods)
+- [Build and Retrieve Scoped Records](#build-and-retrieve-scoped-records)
 - [Attribute Value Parsing](#attribute-value-parsing)
   - [Date and DateTime Attribute Values](#date-and-datetime-attribute-values)
   - [Numeric Attribute Values](#numeric-attribute-values)
@@ -143,7 +146,7 @@ gem install active_manageable
 
 ## Configuration
 
-Create an initializer to configure the optional authorization, search and pagination libraries to use.
+Create an initializer to configure the optional in-built authorization, search and pagination libraries to use.
 
 ```ruby
 ActiveManageable.config do |config|
@@ -153,6 +156,8 @@ ActiveManageable.config do |config|
 end
 ```
 
+These library configuration options can also be set to a module in order to use a custom authorization, search or pagination implementation.
+
 When eager loading associations the `includes` method is used by default but this can be changed via a configuration option that accepts `:includes`, `:preload` or `:eager_load`
 
 ```ruby
@@ -388,6 +393,31 @@ class AlbumManager < ActiveManageable::Base
 end
 ```
 
+### Paginate Without Count
+
+When using the [Kaminari](https://github.com/kaminari/kaminari) pagination library, the `paginate_without_count` method will result in the index method using the Kaminari `without_count` mode to create a paginatable collection without counting the total number of records.
+
+```ruby
+class AlbumManager < ActiveManageable::Base
+  manageable :index
+  paginate_without_count
+end
+```
+
+It is also possible to control whether to use the `without_count` mode globally by setting the `paginate_without_count` configuration option.
+
+```ruby
+ActiveManageable.config do |config|
+  config.paginate_without_count = true
+end
+```
+
+And it is also possible to control whether to use the `without_count` mode for an individual index method call by including the `:without_count` key within the `options` argument `:page` hash.
+
+```ruby
+manager.index(options: {page: {number: 2, size: 10, without_count: true}})
+```
+
 ### Current Method
 
 ActiveManageable includes a `current_method` attribute which returns the name of the method being executed as a symbol, which can potentially be used within methods in conjunction with a lambda for the default methods described above. Additionally, the method argument `options` and `attributes` are also accessible as attributes.
@@ -411,7 +441,7 @@ end
 
 ## Index Method
 
-The `index` method has an optional `options` keyword argument. The `options` hash can contain `:search`, `:order`, `:scopes`, `:page`, `:includes` and `:select` keys. The method performs authorization for the current user, method and model class using the configuration library; retrieves record using the various options described below; and returns the records which are also accessible via the `collection` attribute.
+The `index` method has an optional `options` keyword argument. The `options` hash can contain `:search`, `:order`, `:scopes`, `:page`, `:includes` and `:select` keys. The method performs authorization for the current user, method and model class using the configuration library; invokes a block (if provided); retrieves records using the various options described below; and returns the records which are also accessible via the `collection` attribute.
 
 ```ruby
 manager.index
@@ -490,7 +520,7 @@ If the class `has_unique_search` method has been used then this will be evaluate
 
 ## Show Method
 
-The `show` method has `id` and optional `options` keyword arguments. The `options` hash can contain `:includes` and `:select` keys. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; and returns the record which is also accessible via the `object` attribute.
+The `show` method has `id` and optional `options` keyword arguments. The `options` hash can contain `:includes` and `:select` keys. The method invokes a block (if provided); retrieves a record; performs authorization for the current user, method and record using the configuration library; and returns the record which is also accessible via the `object` attribute.
 
 ```ruby
 manager.show(id: 1)
@@ -520,7 +550,7 @@ manager.show(id: 1, options: {select: [:id, :name, :artist_id, :released_at]})
 
 ## New Method
 
-The `new` method has an optional `attributes` keyword argument. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when building the record. The method builds a record; performs authorization for the current user, method and record using the configuration library; and returns the record which is also accessible via the `object` attribute.
+The `new` method has an optional `attributes` keyword argument. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when building the record. The method builds a record; performs authorization for the current user, method and record using the configuration library; invokes a block (if provided); and returns the record which is also accessible via the `object` attribute.
 
 ```ruby
 manager.new
@@ -534,7 +564,7 @@ manager.new(attributes: {genre: "electronic", published_at: Date.current})
 
 ## Create Method
 
-The `create` method has an `attributes` keyword argument. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when building the record. The method builds a record; performs authorization for the current user, method and record using the configuration library; attempts to save the record and returns the save result. The record is also accessible via the `object` attribute.
+The `create` method has an `attributes` keyword argument. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when building the record. The method builds a record; performs authorization for the current user, method and record using the configuration library; invokes a block (if provided) and attempts to save the record within a transaction; and returns the save result. The record is also accessible via the `object` attribute.
 
 ```ruby
 manager.create(attributes: {name: "Substance", genre: "electronic", published_at: Date.current})
@@ -544,7 +574,7 @@ The `attributes` argument values are combined with the class default values and
 
 ## Edit Method
 
-The `edit` method has `id` and optional `options` keyword arguments. The `options` hash can contain `:includes` and `:select` keys. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; and returns the record which is also accessible via the `object` attribute.
+The `edit` method has `id` and optional `options` keyword arguments. The `options` hash can contain `:includes` and `:select` keys. The method invokes a block (if provided); retrieves a record; performs authorization for the current user, method and record using the configuration library; and returns the record which is also accessible via the `object` attribute.
 
 ```ruby
 manager.edit(id: 1)
@@ -566,7 +596,7 @@ manager.edit(id: 1, options: {includes: {associations: :songs, loading_method: :
 
 ## Update Method
 
-The `update` method has `id`, `attributes` and optional `options` keyword arguments. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when updating the record. The `options` hash can contain an `:includes` key. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; updates the attributes; attempts to save the record and returns the save result. The record is also accessible via the `object` attribute.
+The `update` method has `id`, `attributes` and optional `options` keyword arguments. The `attributes` argument is for an `ActionController::Parameters` or hash of attribute names and values to use when updating the record. The `options` hash can contain an `:includes` key. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; assigns the attributes; invokes a block (if provided) and attempts to save the record within a transaction; and returns the save result. The record is also accessible via the `object` attribute.
 
 ```ruby
 manager.update(id: 1, attributes: {genre: "electronic", published_at: Date.current})
@@ -588,7 +618,7 @@ manager.update(id: 1, attributes: {published_at: Date.current}, options: {includ
 
 ## Destroy Method
 
-The `destroy` method has `id` and optional `options` keyword arguments. The `options` hash can contain an `:includes` key. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; attempts to destroy the record and returns the destroy result. The record is accessible via the `object` attribute.
+The `destroy` method has `id` and optional `options` keyword arguments. The `options` hash can contain an `:includes` key. The method retrieves a record; performs authorization for the current user, method and record using the configuration library; invokes a block (if provided) and attempts to destroy the record within a transaction; and returns the destroy result. The record is accessible via the `object` attribute.
 
 ```ruby
 manager.destroy(id: 1)
@@ -608,6 +638,37 @@ The `:includes` key can also be used to vary the method used to eager load assoc
 manager.destroy(id: 1, options: {includes: {associations: :songs, loading_method: :preload}})
 ```
 
+## Extending the CRUD Methods
+
+Each of the seven core CRUD methods include a `yield` so it is possible to extend the methods by passing a block.
+
+```ruby
+def create(attributes:)
+  super do
+    @target.description = "change the object before it is created using a block"
+  end
+end
+```
+
+The logic within each of the methods has also been split into subsidiary methods so it is possible to extend or override these methods.
+
+```ruby
+def create_object
+  @target.description = "change the object before it is created via an override"
+  super
+end
+```
+
+## Build and Retrieve Scoped Records
+
+Each of the seven core CRUD methods build and retrieve records using the `action_scope` method which by default returns the model class. In order to build or retrieve records using a scope it is possible to override this method.
+
+```ruby
+def action_scope
+  current_user.albums
+end
+```
+
 ## Attribute Value Parsing
 
 ### Date and DateTime Attribute Values
@@ -693,7 +754,7 @@ ActiveManageable includes the following attributes:
 
 ## Adding Bespoke Methods
 
-The manager classes provide standard implementations of the seven core CRUD methods. These can be overwritten to perform custom business logic and the classes can also be extended to include the business logic for additional actions, both making use of the internal ActiveManageable methods and variables.
+The manager classes provide standard implementations of the seven core CRUD methods. These can be extended or overwritten to perform custom business logic and the classes can also be extended to include the business logic for additional actions, both making use of the internal ActiveManageable methods and variables.
 
 ```ruby
 def complete(id:)
@@ -737,7 +798,16 @@ After making changes:
 4. run `bundle exec appraisal rspec` to run the tests against different versions of activerecord & activesupport
 5. run `bundle exec rubocop` to check the style of files
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version:
+
+1. update the version number in `version.rb`
+2. update the change log in `CHANGELOG.md`
+3. run `bundle` to update the `Gemfile.lock` version
+4. commit the changes
+5. run `bundle exec rake release` to create & push a git tag for the version and push the `.gem` file to [rubygems.org](https://rubygems.org).
+6. create a new release for the version on GitHub
 
 ## Contributing
 

data/lib/active_manageable/authorization/cancancan.rb

@@ -7,21 +7,19 @@ module ActiveManageable
     module CanCanCan
       extend ActiveSupport::Concern
 
-      included do
-        private
+      private
 
-        def authorize(record:, action: nil)
-          action ||= @current_method
-          current_ability.authorize!(action, record)
-        end
+      def authorize(record:, action: nil)
+        action ||= @current_method
+        current_ability.authorize!(action, record)
+      end
 
-        def scoped_class
-          model_class.accessible_by(current_ability)
-        end
+      def authorization_scope
+        model_class.accessible_by(current_ability)
+      end
 
-        def current_ability
-          ::Ability.new(current_user)
-        end
+      def current_ability
+        ::Ability.new(current_user)
       end
     end
   end

data/lib/active_manageable/authorization/pundit.rb

@@ -7,21 +7,19 @@ module ActiveManageable
     module Pundit
       extend ActiveSupport::Concern
 
-      included do
-        private
+      private
 
-        def authorize(record:, action: nil)
-          action ||= authorize_action
-          ::Pundit.authorize(current_user, record, action)
-        end
+      def authorize(record:, action: nil)
+        action ||= authorize_action
+        ::Pundit.authorize(current_user, record, action)
+      end
 
-        def scoped_class
-          ::Pundit.policy_scope(current_user, model_class)
-        end
+      def authorization_scope
+        ::Pundit.policy_scope(current_user, model_class)
+      end
 
-        def authorize_action
-          "#{@current_method}?".to_sym
-        end
+      def authorize_action
+        "#{@current_method}?".to_sym
       end
     end
   end

data/lib/active_manageable/base.rb

@@ -4,12 +4,13 @@ module ActiveManageable
     class_attribute :defaults, instance_writer: false, instance_predicate: false
     class_attribute :module_initialize_state_methods, instance_writer: false, instance_predicate: false
 
-    attr_reader :target, :current_method, :attributes, :options
+    attr_accessor :target
+    attr_reader :current_method, :attributes, :options
 
     # target provides a common variable to use within the CRUD, auxiliary & library methods
     # whereas the object & collection methods provide less ambiguous external access
-    alias_method :object, :target
-    alias_method :collection, :target
+    alias_attribute :object, :target
+    alias_attribute :collection, :target
 
     class << self
       # Ruby method called when a child class inherits from a parent class
@@ -58,6 +59,8 @@ module ActiveManageable
           include ActiveManageable::Authorization::Pundit
         when :cancancan
           include ActiveManageable::Authorization::CanCanCan
+        when Module
+          include ActiveManageable.configuration.authorization_library
         end
       end
 
@@ -65,6 +68,8 @@ module ActiveManageable
         case ActiveManageable.configuration.search_library
         when :ransack
           include ActiveManageable::Search::Ransack
+        when Module
+          include ActiveManageable.configuration.search_library
         end
       end
 
@@ -72,6 +77,8 @@ module ActiveManageable
         case ActiveManageable.configuration.pagination_library
         when :kaminari
           include ActiveManageable::Pagination::Kaminari
+        when Module
+          include ActiveManageable.configuration.pagination_library
         end
       end
 
@@ -109,6 +116,10 @@ module ActiveManageable
 
     private
 
+    def action_scope
+      model_class
+    end
+
     def initialize_state(attributes: {}, options: {})
       @target = nil
       @current_method = calling_method

data/lib/active_manageable/configuration.rb

@@ -6,31 +6,32 @@ module ActiveManageable
 
   class Configuration
     attr_reader :authorization_library, :search_library, :pagination_library, :default_loading_method
-    attr_accessor :subclass_suffix
+    attr_accessor :subclass_suffix, :paginate_without_count
 
     def initialize
       @default_loading_method = :includes
       @subclass_suffix = "Manager"
+      @paginate_without_count = false
     end
 
     def authorization_library=(authorization_library)
       raise ArgumentError.new("Invalid authorization library") unless authorization_library_valid?(authorization_library)
-      @authorization_library = authorization_library.to_sym
+      @authorization_library = authorization_library
     end
 
     def search_library=(search_library)
       raise ArgumentError.new("Invalid search library") unless search_library_valid?(search_library)
-      @search_library = search_library.to_sym
+      @search_library = search_library
     end
 
     def pagination_library=(pagination_library)
       raise ArgumentError.new("Invalid pagination library") unless pagination_library_valid?(pagination_library)
-      @pagination_library = pagination_library.to_sym
+      @pagination_library = pagination_library
     end
 
     def default_loading_method=(default_loading_method)
       raise ArgumentError.new("Invalid method for eager loading") unless default_loading_method_valid?(default_loading_method)
-      @default_loading_method = default_loading_method.to_sym
+      @default_loading_method = default_loading_method
     end
 
     private
@@ -48,11 +49,19 @@ module ActiveManageable
     end
 
     def default_loading_method_valid?(default_loading_method)
-      option_valid?(LOADING_METHODS, default_loading_method)
+      symbol_option_valid?(LOADING_METHODS, default_loading_method)
     end
 
     def option_valid?(options, option)
-      option.present? && options.include?(option.to_s.to_sym)
+      symbol_option_valid?(options, option) || module_option_valid?(option)
+    end
+
+    def symbol_option_valid?(options, option)
+      option.is_a?(Symbol) && options.include?(option.to_s.to_sym)
+    end
+
+    def module_option_valid?(option)
+      option.is_a?(Module)
     end
   end
 end

data/lib/active_manageable/methods/auxiliary/includes.rb

@@ -33,7 +33,7 @@ module ActiveManageable
           # the associations and options we cannot use the array extract_options! method
           # as this removes the last element in the array if it's a hash.
           #
-          # For example :-
+          # For example:-
           # default_includes songs: :artist, loading_method: :preload, methods: :index
           # results in an argument value of :-
           # [{:songs=>:artist, :loading_method=>:preload, :methods=>:index}]
@@ -58,38 +58,36 @@ module ActiveManageable
           end
         end
 
-        included do
-          private
+        def default_includes(method: @current_method)
+          includes = defaults[:includes] || {}
+          associations = includes.dig(method.try(:to_sym), :associations) || includes.dig(:all, :associations)
+          associations.is_a?(Proc) ? instance_exec(&associations) : associations
+        end
 
-          # Accepts either an array/hash of associations
-          # or a hash with associations and loading_method keys
-          # so it's possible to specify loading_method on a per request basis.
-          # Uses associations and loading_method from opts
-          # or defaults for the method or defaults for all methods
-          # or configuration default loading_method.
-          def includes(opts)
-            unless opts.is_a?(Hash) && opts.key?(:associations)
-              opts = {associations: opts}
-            end
-            associations = opts[:associations] || get_default_includes_associations
-            if associations.present?
-              loading_method = opts[:loading_method] || get_default_includes_loading_method
-              @target = @target.send(loading_method, associations)
-            else
-              @target
-            end
-          end
+        def default_loading_method(method: @current_method)
+          includes = defaults[:includes] || {}
+          loading_method = includes.dig(method.try(:to_sym), :loading_method) || includes.dig(:all, :loading_method)
+          loading_method || ActiveManageable.configuration.default_loading_method
+        end
 
-          def get_default_includes_associations
-            includes = defaults[:includes] || {}
-            associations = includes.dig(@current_method, :associations) || includes.dig(:all, :associations)
-            associations.is_a?(Proc) ? instance_exec(&associations) : associations
-          end
+        private
 
-          def get_default_includes_loading_method
-            includes = defaults[:includes] || {}
-            loading_method = includes.dig(@current_method, :loading_method) || includes.dig(:all, :loading_method)
-            loading_method || ActiveManageable.configuration.default_loading_method
+        # Accepts either an array/hash of associations
+        # or a hash with associations and loading_method keys
+        # so it's possible to specify loading_method on a per request basis.
+        # Uses associations and loading_method from opts
+        # or defaults for the method or defaults for all methods
+        # or configuration default loading_method.
+        def includes(opts)
+          unless opts.is_a?(Hash) && opts.key?(:associations)
+            opts = {associations: opts}
+          end
+          associations = opts[:associations] || default_includes
+          if associations.present?
+            loading_method = opts[:loading_method] || default_loading_method
+            @target = @target.send(loading_method, associations)
+          else
+            @target
           end
         end
       end

data/lib/active_manageable/methods/auxiliary/model_attributes.rb

@@ -33,25 +33,23 @@ module ActiveManageable
           end
         end
 
-        included do
-          private
+        # Returns the default attribute values for the method
+        # from the class attribute that can contain a hash of attribute values
+        # or a lambda/proc to execute to return attribute values
+        def default_attribute_values(method: @current_method)
+          default_attributes = defaults[:attributes] || {}
+          attributes = default_attributes[method.try(:to_sym)] || default_attributes[:all] || {}
+          attributes = (instance_exec(&attributes) || {}) if attributes.is_a?(Proc)
+          attributes.with_indifferent_access
+        end
 
-          # Returns attribute values to use in the new and create methods
-          # consisting of a merge of the method attributes argument
-          # and class defaults with the method argument taking precedence
-          def attribute_values
-            @attributes.is_a?(Hash) ? @attributes.reverse_merge(get_default_attribute_values) : @attributes
-          end
+        private
 
-          # Get the default attribute values for the method
-          # from the class attribute that can contain a hash of attribute values
-          # or a lambda/proc to execute to return attribute values
-          def get_default_attribute_values
-            default_attributes = defaults[:attributes] || {}
-            attributes = default_attributes[@current_method] || default_attributes[:all] || {}
-            attributes = (instance_exec(&attributes) || {}) if attributes.is_a?(Proc)
-            attributes.with_indifferent_access
-          end
+        # Returns attribute values to use in the new and create methods
+        # consisting of a merge of the method attributes argument
+        # and class defaults with the method argument taking precedence
+        def attribute_values
+          @attributes.is_a?(Hash) ? @attributes.reverse_merge(default_attribute_values) : @attributes
         end
       end
     end

data/lib/active_manageable/methods/auxiliary/order.rb

@@ -19,23 +19,21 @@ module ActiveManageable
           end
         end
 
-        included do
-          private
+        # Returns the default order attributes from the class attribute
+        # that can contain an array of attribute names or name & direction strings
+        # or a lambda/proc to execute to return an array of attribute names
+        def default_order
+          defaults[:order].is_a?(Proc) ? instance_exec(&defaults[:order]) : defaults[:order]
+        end
 
-          def order(attributes)
-            @target = @target.order(get_order_attributes(attributes))
-          end
+        private
 
-          def get_order_attributes(attributes)
-            attributes || get_default_order_attributes
-          end
+        def order(attributes)
+          @target = @target.order(order_attributes(attributes))
+        end
 
-          # Get the default order attributes from the class attribute
-          # that can contain an array of attribute names or name & direction strings
-          # or a lambda/proc to execute to return an array of attribute names
-          def get_default_order_attributes
-            defaults[:order].is_a?(Proc) ? instance_exec(&defaults[:order]) : defaults[:order]
-          end
+        def order_attributes(attributes)
+          attributes || default_order
         end
       end
     end

data/lib/active_manageable/methods/auxiliary/scopes.rb

@@ -20,37 +20,44 @@ module ActiveManageable
           end
         end
 
-        included do
-          private
+        # Returns the default scopes in a hash of hashes with the key containing the scope name
+        # and value containing an array of scope arguments.
+        #
+        # For example:-
+        # {rock: [], electronic: [], released_in_year: ["1980"]}
+        def default_scopes
+          get_scopes
+        end
 
-          def scopes(scopes)
-            get_scopes(scopes).each { |name, args| @target = @target.send(name, *args) }
-            @target
-          end
+        private
 
-          # Accepts a symbol or string scope name, hash containing scope name and argument,
-          # lambda/proc to execute to return scope(s) or an array of those types
-          # and when the argument is blank it uses the class default scopes.
-          # Converts the scopes to a hash of hashes with the key containing the scope name
-          # and value containing an array of scope arguments.
-          def get_scopes(scopes = nil)
-            scopes ||= defaults[:scopes]
+        def scopes(scopes)
+          get_scopes(scopes).each { |name, args| @target = @target.send(name, *args) }
+          @target
+        end
 
-            Array.wrap(scopes).map do |scope|
-              case scope
-              when Symbol, String
-                {scope => []}
-              when Hash
-                # ensure values are an array so they can be passed to the scope using splat operator
-                scope.transform_values! { |v| Array.wrap(v) }
-              when Proc
-                # if the class default contains a lambda/proc that returns nil
-                # don't call get_scopes as we don't want to end up in an infinite loop
-                p_scopes = instance_exec(&scope)
-                get_scopes(p_scopes) if p_scopes.present?
-              end
-            end.compact.reduce({}, :merge)
-          end
+        # Accepts a symbol or string scope name, hash containing scope name and argument,
+        # lambda/proc to execute to return scope(s) or an array of those types
+        # and when the argument is blank it uses the class default scopes.
+        # Converts the scopes to a hash of hashes with the key containing the scope name
+        # and value containing an array of scope arguments.
+        def get_scopes(scopes = nil)
+          scopes ||= defaults[:scopes]
+
+          Array.wrap(scopes).map do |scope|
+            case scope
+            when Symbol, String
+              {scope => []}
+            when Hash
+              # ensure values are an array so they can be passed to the scope using splat operator
+              scope.transform_values! { |v| Array.wrap(v) }
+            when Proc
+              # if the class default contains a lambda/proc that returns nil
+              # don't call get_scopes as we don't want to end up in an infinite loop
+              p_scopes = instance_exec(&scope)
+              get_scopes(p_scopes) if p_scopes.present?
+            end
+          end.compact.reduce({}, :merge)
         end
       end
     end

data/lib/active_manageable/methods/auxiliary/select.rb

@@ -24,21 +24,19 @@ module ActiveManageable
           end
         end
 
-        included do
-          private
+        # Returns the default select attributes for the method
+        # from the class attribute that can contain an array of attribute names
+        # or a lambdas/procs to execute to return an array of attribute names
+        def default_select(method: @current_method)
+          default_selects = defaults[:select] || {}
+          attributes = default_selects[method.try(:to_sym)] || default_selects[:all] || []
+          attributes.is_a?(Proc) ? instance_exec(&attributes) : attributes
+        end
 
-          def select(attributes)
-            @target = @target.select(attributes || get_default_select_attributes)
-          end
+        private
 
-          # Get the default select attributes for the method
-          # from the class attribute that can contain an array of attribute names
-          # or a lambdas/procs to execute to return an array of attribute names
-          def get_default_select_attributes
-            default_selects = defaults[:select] || {}
-            attributes = default_selects[@current_method] || default_selects[:all] || []
-            attributes.is_a?(Proc) ? instance_exec(&attributes) : attributes
-          end
+        def select(attributes)
+          @target = @target.select(attributes || default_select)
         end
       end
     end

data/lib/active_manageable/methods/auxiliary/unique_search.rb

@@ -20,29 +20,29 @@ module ActiveManageable
 
         included do
           class_attribute :unique_search, instance_writer: false, instance_predicate: false
+        end
 
-          private
-
-          def unique_search?
-            case unique_search
-            when nil
-              false
-            when TrueClass, FalseClass
-              unique_search
-            when Hash
-              evaluate_condition(*unique_search.first)
-            end
+        def unique_search?
+          case unique_search
+          when nil
+            false
+          when TrueClass, FalseClass
+            unique_search
+          when Hash
+            evaluate_condition(*unique_search.first)
           end
+        end
+
+        private
 
-          def evaluate_condition(condition, method)
-            result = case method
-            when Symbol
-              method(method).call
-            when Proc
-              instance_exec(&method)
-            end
-            condition == :if ? result : !result
+        def evaluate_condition(condition, method)
+          result = case method
+          when Symbol
+            method(method).call
+          when Proc
+            instance_exec(&method)
           end
+          condition == :if ? result : !result
         end
       end
     end

data/lib/active_manageable/methods/create.rb

@@ -5,16 +5,31 @@ module ActiveManageable
 
       included do
         include ActiveManageable::Methods::Auxiliary::ModelAttributes
+      end
 
-        def create(attributes:)
-          initialize_state(attributes: attributes)
+      def create(attributes:)
+        initialize_state(attributes: attributes)
 
-          @target = model_class.new(attribute_values)
-          authorize(record: @target)
+        @target = build_object_for_create
+        authorize(record: @target)
 
-          @target.save
+        model_class.transaction do
+          yield if block_given?
+          create_object
+        rescue ActiveRecord::RecordInvalid
+          false
         end
       end
+
+      private
+
+      def build_object_for_create
+        action_scope.new(attribute_values)
+      end
+
+      def create_object
+        @target.save!
+      end
     end
   end
 end

data/lib/active_manageable/methods/destroy.rb

@@ -5,19 +5,34 @@ module ActiveManageable
 
       included do
         include ActiveManageable::Methods::Auxiliary::Includes
+      end
 
-        def destroy(id:, options: {})
-          initialize_state(options: options)
+      def destroy(id:, options: {})
+        initialize_state(options: options)
 
-          @target = model_class
-          includes(@options[:includes])
+        @target = action_scope
+        includes(@options[:includes])
 
-          @target = @target.find(id)
-          authorize(record: @target)
+        @target = find_object_for_destroy(id: id)
+        authorize(record: @target)
 
-          @target.destroy
+        model_class.transaction do
+          yield if block_given?
+          destroy_object
+        rescue ActiveRecord::RecordNotDestroyed
+          false
         end
       end
+
+      private
+
+      def find_object_for_destroy(id:)
+        @target.find(id)
+      end
+
+      def destroy_object
+        @target.destroy!
+      end
     end
   end
 end

data/lib/active_manageable/methods/edit.rb

@@ -6,19 +6,27 @@ module ActiveManageable
       included do
         include ActiveManageable::Methods::Auxiliary::Includes
         include ActiveManageable::Methods::Auxiliary::Select
+      end
+
+      def edit(id:, options: {})
+        initialize_state(options: options)
+
+        @target = action_scope
+        includes(@options[:includes])
+        select(@options[:select])
 
-        def edit(id:, options: {})
-          initialize_state(options: options)
+        yield if block_given?
 
-          @target = model_class
-          includes(@options[:includes])
-          select(@options[:select])
+        @target = find_object_for_edit(id: id)
+        authorize(record: @target)
+
+        @target
+      end
 
-          @target = @target.find(id)
-          authorize(record: @target)
+      private
 
-          @target
-        end
+      def find_object_for_edit(id:)
+        @target.find(id)
       end
     end
   end

data/lib/active_manageable/methods/index.rb

@@ -9,40 +9,42 @@ module ActiveManageable
         include ActiveManageable::Methods::Auxiliary::Includes
         include ActiveManageable::Methods::Auxiliary::Select
         include ActiveManageable::Methods::Auxiliary::UniqueSearch
+      end
+
+      def index(options: {})
+        initialize_state(options: options)
 
-        def index(options: {})
-          initialize_state(options: options)
+        @target = authorization_scope
+        authorize(record: model_class)
+        search(@options[:search])
+        order(@options[:order])
+        scopes(@options[:scopes])
+        page(@options[:page])
+        includes(@options[:includes])
+        select(@options[:select])
+        distinct(unique_search?)
 
-          @target = scoped_class
-          authorize(record: model_class)
-          search(@options[:search])
-          order(@options[:order])
-          scopes(@options[:scopes])
-          page(@options[:page])
-          includes(@options[:includes])
-          select(@options[:select])
-          distinct(unique_search?)
+        yield if block_given?
 
-          @target
-        end
+        @target
+      end
 
-        private
+      private
 
-        def scoped_class
-          model_class
-        end
+      def authorization_scope
+        action_scope
+      end
 
-        def search(opts)
-          @target
-        end
+      def search(opts)
+        @target
+      end
 
-        def page(opts)
-          @target
-        end
+      def page(opts)
+        @target
+      end
 
-        def distinct(value)
-          @target = target.distinct(value)
-        end
+      def distinct(value)
+        @target = target.distinct(value)
       end
     end
   end

data/lib/active_manageable/methods/new.rb

@@ -5,15 +5,23 @@ module ActiveManageable
 
       included do
         include ActiveManageable::Methods::Auxiliary::ModelAttributes
+      end
+
+      def new(attributes: {})
+        initialize_state(attributes: attributes)
+
+        @target = build_object_for_new
+        authorize(record: @target)
 
-        def new(attributes: {})
-          initialize_state(attributes: attributes)
+        yield if block_given?
+
+        @target
+      end
 
-          @target = model_class.new(attribute_values)
-          authorize(record: @target)
+      private
 
-          @target
-        end
+      def build_object_for_new
+        action_scope.new(attribute_values)
       end
     end
   end

data/lib/active_manageable/methods/show.rb

@@ -6,19 +6,27 @@ module ActiveManageable
       included do
         include ActiveManageable::Methods::Auxiliary::Includes
         include ActiveManageable::Methods::Auxiliary::Select
+      end
+
+      def show(id:, options: {})
+        initialize_state(options: options)
+
+        @target = action_scope
+        includes(@options[:includes])
+        select(@options[:select])
 
-        def show(id:, options: {})
-          initialize_state(options: options)
+        yield if block_given?
 
-          @target = model_class
-          includes(@options[:includes])
-          select(@options[:select])
+        @target = find_object_for_show(id: id)
+        authorize(record: @target)
+
+        @target
+      end
 
-          @target = @target.find(id)
-          authorize(record: @target)
+      private
 
-          @target
-        end
+      def find_object_for_show(id:)
+        @target.find(id)
       end
     end
   end

data/lib/active_manageable/methods/update.rb

@@ -5,19 +5,40 @@ module ActiveManageable
 
       included do
         include ActiveManageable::Methods::Auxiliary::Includes
+      end
+
+      def update(id:, attributes:, options: {})
+        initialize_state(attributes: attributes, options: options)
 
-        def update(id:, attributes:, options: {})
-          initialize_state(attributes: attributes, options: options)
+        @target = action_scope
+        includes(@options[:includes])
 
-          @target = model_class
-          includes(@options[:includes])
+        @target = find_object_for_update(id: id)
+        authorize(record: @target)
 
-          @target = @target.find(id)
-          authorize(record: @target)
+        assign_attributes_for_update
 
-          @target.update(@attributes)
+        model_class.transaction do
+          yield if block_given?
+          update_object
+        rescue ActiveRecord::RecordInvalid
+          false
         end
       end
+
+      private
+
+      def find_object_for_update(id:)
+        @target.find(id)
+      end
+
+      def assign_attributes_for_update
+        @target.assign_attributes(@attributes)
+      end
+
+      def update_object
+        @target.save!
+      end
     end
   end
 end

data/lib/active_manageable/pagination/kaminari.rb

@@ -17,22 +17,42 @@ module ActiveManageable
         def default_page_size(page_size)
           defaults[:page] = {size: page_size.to_i}
         end
+
+        # Class option used when determining whether to create a paginatable collection without counting the total number of records
+        # within the order of precedence based on the (1) method option, or (2) class option, or (3) configuration option
+        def paginate_without_count(without_count = true)
+          self.without_count = without_count
+        end
       end
 
       included do
-        private
+        class_attribute :without_count, instance_writer: false, instance_predicate: false
+      end
 
-        def page(opts)
-          @target = @target.page(page_number(opts)).per(page_size(opts))
-        end
+      private
 
-        def page_number(opts)
-          opts.try(:[], :number)
+      def page(opts)
+        @target = @target.page(page_number(opts)).per(page_size(opts)).tap do |target|
+          target.without_count if paginate_without_count?(opts)
         end
+      end
 
-        def page_size(opts)
-          opts.try(:[], :size) || defaults.dig(:page, :size)
-        end
+      def page_number(opts)
+        opts.try(:[], :number)
+      end
+
+      def page_size(opts)
+        opts.try(:[], :size) || defaults.dig(:page, :size)
+      end
+
+      # Determine whether to create a paginatable collection without counting the total number of records
+      # in order of precedence based on the (1) method option, or (2) class option, or (3) configuration option
+      def paginate_without_count?(opts)
+        [
+          opts.try(:[], :without_count),
+          without_count,
+          ActiveManageable.configuration.paginate_without_count
+        ].compact.first
       end
     end
   end

data/lib/active_manageable/search/ransack.rb

@@ -11,26 +11,24 @@ module ActiveManageable
         attr_reader :ransack
 
         initialize_state_methods :initialize_ransack_state
+      end
 
-        private
-
-        def initialize_ransack_state
-          @ransack = nil
-        end
+      def initialize_ransack_state
+        @ransack = nil
+      end
 
-        def search(opts)
-          @ransack = @target.ransack(opts)
-          @target = @ransack.result
-        end
+      def search(opts)
+        @ransack = @target.ransack(opts)
+        @target = @ransack.result
+      end
 
-        # Perform standard index module ordering when no ransack search params provided
-        # or no ransack sorts params provided
-        def order(attributes)
-          if @ransack.blank? || @ransack.sorts.empty?
-            @target = @target.order(get_order_attributes(attributes))
-          else
-            @target
-          end
+      # Perform standard index module ordering when no ransack search params provided
+      # or no ransack sorts params provided
+      def order(attributes)
+        if @ransack.blank? || @ransack.sorts.empty?
+          @target = @target.order(order_attributes(attributes))
+        else
+          @target
         end
       end
     end

data/lib/active_manageable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveManageable
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_manageable
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Hilton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-25 00:00:00.000000000 Z
+date: 2022-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord