active_manageable 0.1.1 → 0.2.0

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