active_manageable 0.1.0

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

@@ -0,0 +1,59 @@
+module ActiveManageable
+  module Methods
+    module Auxiliary
+      module Scopes
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Sets the default scope(s) to use when fetching records in the index method
+          # if the index :options argument does not contain a :scopes key;
+          # accepting a scope name, a hash containing scope name and argument, or an array of names/hashes;
+          # also accepting a lambda/proc to execute to return a scope name or hash or array.
+          #
+          # For example:-
+          #   default_scopes :electronic
+          #   default_scopes {released_in_year: "1980"}
+          #   default_scopes :rock, :electronic, {released_in_year: "1980"}
+          #   default_scopes -> { index_scopes }
+          def default_scopes(*args)
+            defaults[:scopes] = args.first.is_a?(Proc) ? args.first : args
+          end
+        end
+
+        included do
+          private
+
+          def scopes(scopes)
+            get_scopes(scopes).each { |name, args| @target = @target.send(name, *args) }
+            @target
+          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]
+            scopes = scopes.is_a?(Hash) ? [scopes] : Array(scopes)
+
+            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(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
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ActiveManageable
+  module Methods
+    module Auxiliary
+      module Select
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Sets the default attributes to return in the SELECT statement used
+          # when fetching records in the index, show and edit methods
+          # if the methods :options argument does not contain a :select key;
+          # accepting either an array of attribute names or a lambda/proc
+          # to execute to return an array of attribute names;
+          # and optional :methods in which to use the attributes.
+          #
+          # For example:-
+          #   default_select :name
+          #   default_select :id, :name, methods: :show
+          #   default_select -> { select_attributes }
+          #   default_select -> { select_attributes }, methods: [:index, :edit]
+          def default_select(*attributes)
+            options = attributes.extract_options!.dup
+            attrs = attributes.first.is_a?(Proc) ? attributes.first : attributes
+            add_method_defaults(key: :select, value: attrs, methods: options[:methods])
+          end
+        end
+
+        included do
+          private
+
+          def select(attributes)
+            @target = @target.select(attributes || get_default_select_attributes)
+          end
+
+          # 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module ActiveManageable
+  module Methods
+    module Auxiliary
+      module UniqueSearch
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Specifies whether to use the distinct method when fetching records in the index method;
+          # accepting no argument to always return unique records or a hash with :if or :unless keyword
+          # and method name or lambda/proc to execute each time the index method is called.
+          #
+          # For example:-
+          #   has_unique_search
+          #   has_unique_search if: :method_name
+          #   has_unique_search unless: -> { lambda }
+          def has_unique_search(**args)
+            self.unique_search = args.present? ? args.assert_valid_keys(:if, :unless) : true
+          end
+        end
+
+        included do
+          class_attribute :unique_search, instance_writer: false, instance_predicate: false
+
+          private
+
+          def unique_search?
+            case unique_search
+            when nil
+              false
+            when TrueClass, FalseClass
+              unique_search
+            when Hash
+              evaluate_condition(*unique_search.first)
+            end
+          end
+
+          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
+    end
+  end
+end

data/lib/active_manageable/methods/create.rb

@@ -0,0 +1,20 @@
+module ActiveManageable
+  module Methods
+    module Create
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::ModelAttributes
+
+        def create(attributes:)
+          initialize_state(attributes: attributes)
+
+          @target = model_class.new(attribute_values)
+          authorize(record: @target)
+
+          @target.save
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/destroy.rb

@@ -0,0 +1,23 @@
+module ActiveManageable
+  module Methods
+    module Destroy
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::Includes
+
+        def destroy(id:, options: {})
+          initialize_state(options: options)
+
+          @target = model_class
+          includes(@options[:includes])
+
+          @target = @target.find(id)
+          authorize(record: @target)
+
+          @target.destroy
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/edit.rb

@@ -0,0 +1,25 @@
+module ActiveManageable
+  module Methods
+    module Edit
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::Includes
+        include ActiveManageable::Methods::Auxiliary::Select
+
+        def edit(id:, options: {})
+          initialize_state(options: options)
+
+          @target = model_class
+          includes(@options[:includes])
+          select(@options[:select])
+
+          @target = @target.find(id)
+          authorize(record: @target)
+
+          @target
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/index.rb

@@ -0,0 +1,49 @@
+module ActiveManageable
+  module Methods
+    module Index
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::Order
+        include ActiveManageable::Methods::Auxiliary::Scopes
+        include ActiveManageable::Methods::Auxiliary::Includes
+        include ActiveManageable::Methods::Auxiliary::Select
+        include ActiveManageable::Methods::Auxiliary::UniqueSearch
+
+        def index(options: {})
+          initialize_state(options: options)
+
+          @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?)
+
+          @target
+        end
+
+        private
+
+        def scoped_class
+          model_class
+        end
+
+        def search(opts)
+          @target
+        end
+
+        def page(opts)
+          @target
+        end
+
+        def distinct(value)
+          @target = target.distinct(value)
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/new.rb

@@ -0,0 +1,20 @@
+module ActiveManageable
+  module Methods
+    module New
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::ModelAttributes
+
+        def new(attributes: {})
+          initialize_state(attributes: attributes)
+
+          @target = model_class.new(attribute_values)
+          authorize(record: @target)
+
+          @target
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/show.rb

@@ -0,0 +1,25 @@
+module ActiveManageable
+  module Methods
+    module Show
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::Includes
+        include ActiveManageable::Methods::Auxiliary::Select
+
+        def show(id:, options: {})
+          initialize_state(options: options)
+
+          @target = model_class
+          includes(@options[:includes])
+          select(@options[:select])
+
+          @target = @target.find(id)
+          authorize(record: @target)
+
+          @target
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/methods/update.rb

@@ -0,0 +1,23 @@
+module ActiveManageable
+  module Methods
+    module Update
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveManageable::Methods::Auxiliary::Includes
+
+        def update(id:, attributes:, options: {})
+          initialize_state(attributes: attributes, options: options)
+
+          @target = model_class
+          includes(@options[:includes])
+
+          @target = @target.find(id)
+          authorize(record: @target)
+
+          @target.update(@attributes)
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/pagination/kaminari.rb

@@ -0,0 +1,39 @@
+#
+# Pagination methods for Kaminari
+# https://github.com/kaminari/kaminari
+#
+module ActiveManageable
+  module Pagination
+    module Kaminari
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Sets the default page size to use when fetching records in the index method
+        # if the index :options argument does not contain a :page hash with :size key;
+        # accepting an integer.
+        #
+        # For example:-
+        #   default_page_size 5
+        def default_page_size(page_size)
+          defaults[:page] = {size: page_size.to_i}
+        end
+      end
+
+      included do
+        private
+
+        def page(opts)
+          @target = @target.page(page_number(opts)).per(page_size(opts))
+        end
+
+        def page_number(opts)
+          opts.try(:[], :number)
+        end
+
+        def page_size(opts)
+          opts.try(:[], :size) || defaults.dig(:page, :size)
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/search/ransack.rb

@@ -0,0 +1,38 @@
+#
+# Search methods for Ransack
+# https://github.com/activerecord-hackery/ransack
+#
+module ActiveManageable
+  module Search
+    module Ransack
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :ransack
+
+        initialize_state_methods :initialize_ransack_state
+
+        private
+
+        def initialize_ransack_state
+          @ransack = nil
+        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
+        end
+      end
+    end
+  end
+end

data/lib/active_manageable/version.rb

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

data/lib/active_manageable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Active Support Core Extensions
+# https://guides.rubyonrails.org/active_support_core_extensions.html
+require "active_support/core_ext"
+# rails-i18n required for "number.format.separator"
+require "rails-i18n"
+# flexitime required to parse date & datetime attribute values
+require "flexitime"
+
+require_relative "active_manageable/version"
+require_relative "active_manageable/configuration"
+require_relative "active_manageable/base"
+require_relative "active_manageable/methods/index"
+require_relative "active_manageable/methods/show"
+require_relative "active_manageable/methods/new"
+require_relative "active_manageable/methods/create"
+require_relative "active_manageable/methods/edit"
+require_relative "active_manageable/methods/update"
+require_relative "active_manageable/methods/destroy"
+require_relative "active_manageable/methods/auxiliary/includes"
+require_relative "active_manageable/methods/auxiliary/model_attributes"
+require_relative "active_manageable/methods/auxiliary/order"
+require_relative "active_manageable/methods/auxiliary/scopes"
+require_relative "active_manageable/methods/auxiliary/select"
+require_relative "active_manageable/methods/auxiliary/unique_search"
+require_relative "active_manageable/authorization/pundit"
+require_relative "active_manageable/authorization/cancancan"
+require_relative "active_manageable/search/ransack"
+require_relative "active_manageable/pagination/kaminari"
+
+module ActiveManageable
+  ALL_METHODS = "*"
+
+  thread_mattr_accessor :current_user
+
+  mattr_accessor :configuration
+  @@configuration = Configuration.new
+
+  def self.config
+    yield configuration
+  end
+end