active_manageable 0.1.2 → 0.3.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/active_manageable.gemspec

@@ -14,8 +14,7 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/CircleSD/active_manageable"
   spec.license = "MIT"
 
-  # Minimum version of Ruby compatible with Rails 7.0
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.0.0"
 
   # Metadata used on gem’s profile page on rubygems.org
   spec.metadata["homepage_uri"] = spec.homepage
@@ -41,17 +40,17 @@ Gem::Specification.new do |spec|
   # including gems that are essential to test and build this gem
 
   # rails dependencies
-  spec.add_dependency "activerecord", ">= 6.0"
-  spec.add_dependency "activesupport", ">= 6.0"
+  spec.add_dependency "activerecord", ">= 7.0"
+  spec.add_dependency "activesupport", ">= 7.0"
 
   # gem dependencies
   spec.add_dependency "rails-i18n"
   spec.add_dependency "flexitime", "~> 1.0"
 
   # test dependencies
-  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "appraisal"
-  spec.add_development_dependency "sqlite3", "~> 1.4.0"
+  spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "rails-controller-testing"
   spec.add_development_dependency "factory_bot_rails"
@@ -65,8 +64,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "kaminari"
 
   # linter dependencies
-  spec.add_development_dependency "rubocop", "1.23.0"
+  spec.add_development_dependency "rubocop"
   spec.add_development_dependency "standard"
+  spec.add_development_dependency "standard-rails"
   spec.add_development_dependency "rubocop-rails"
   spec.add_development_dependency "rubocop-rspec"
 

data/gemfiles/rails_7_0.gemfile

@@ -2,7 +2,14 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 7.0"
-gem "activesupport", "~> 7.0"
+gem "activerecord", "~> 7.0.0"
+gem "activesupport", "~> 7.0.0"
+gem "sqlite3", "~> 1.4"
+gem "logger"
+gem "base64"
+gem "bigdecimal"
+gem "mutex_m"
+gem "drb"
+gem "benchmark"
 
 gemspec path: "../"

data/gemfiles/{rails_6_1.gemfile → rails_7_1.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 6.1"
-gem "activesupport", "~> 6.1"
+gem "activerecord", "~> 7.1.0"
+gem "activesupport", "~> 7.1.0"
 
 gemspec path: "../"

data/gemfiles/{rails_6_0.gemfile → rails_7_2.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 6.0.1"
-gem "activesupport", "~> 6.0.1"
+gem "activerecord", "~> 7.2.0"
+gem "activesupport", "~> 7.2.0"
 
 gemspec path: "../"

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}?"
       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
@@ -126,8 +137,8 @@ module ActiveManageable
     # when the ransack module is included as it has its own definition of the method that calls super
     # https://www.lucascaton.com.br/2016/11/04/ruby-how-to-get-the-name-of-the-calling-method
     def calling_method
-      my_caller = caller_locations(1..1).first.label
-      caller_locations[1..].find { |location| location.label != my_caller }.label.to_sym
+      my_caller = caller_locations(1..1).first.base_label
+      caller_locations[1..].find { |location| location.base_label != my_caller }.base_label.to_sym
     end
 
     # Converts a state argument to a ActiveSupport::HashWithIndifferentAccess.

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