goodmin 0.0.1

data/lib/goodmin/resources/resource/ordering.rb

@@ -0,0 +1,41 @@
+module Goodmin
+  module Resources
+    module Resource
+      module Ordering
+        extend ActiveSupport::Concern
+
+        def apply_order(order_param, resources)
+          if order_param.present? && order_column_method?(order_column(order_param))
+            send("order_by_#{order_column(order_param)}", resources, order_direction(order_param))
+          elsif order_param.present? && order_column_column?(order_column(order_param))
+            resources.order("#{resource_class.table_name}.#{order_column(order_param)} #{order_direction(order_param)}")
+          else
+            resources
+          end
+        end
+
+        def orderable_column?(column)
+          order_column_method?(column) || order_column_column?(column)
+        end
+
+        protected
+
+        def order_column_method?(column)
+          respond_to?("order_by_#{column}")
+        end
+
+        def order_column_column?(column)
+          resource_class.column_names.include?(column)
+        end
+
+        def order_column(order_param)
+          order_param.rpartition("_").first
+        end
+
+        def order_direction(order_param)
+          order_param.rpartition("_").last == "asc" ? "asc" : "desc"
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource/pagination.rb

@@ -0,0 +1,22 @@
+module Goodmin
+  module Resources
+    module Resource
+      module Pagination
+        extend ActiveSupport::Concern
+
+        def apply_pagination(page_param, resources)
+          @paginator = Paginator.new(resources, per_page: per_page, current_page: page_param)
+          @paginator.paginate
+        end
+
+        def paginator
+          @paginator
+        end
+
+        def per_page
+          25
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource/scopes.rb

@@ -0,0 +1,61 @@
+module Goodmin
+  module Resources
+    module Resource
+      module Scopes
+        extend ActiveSupport::Concern
+
+        delegate :scope_map, to: "self.class"
+
+        def apply_scope(scope_param, resources)
+          return resources if scope_map.empty?
+
+          self.scope = scope_param
+
+          if scope && scope_map.key?(scope.to_sym)
+            send("scope_#{@scope}", resources)
+          else
+            fail NotImplementedError, "Scope #{@scope} not implemented"
+          end
+        end
+
+        def scope=(scope)
+          @scope = scope.blank? ? default_scope : scope
+        end
+
+        def scope
+          @scope
+        end
+
+        def scoped_by?(name)
+          @scope == name.to_s
+        end
+
+        def scope_count(scope)
+          send("scope_#{scope}", resources_relation).count
+        end
+
+        protected
+
+        def default_scope
+          scope = scope_map.find -> { scope_map.first } do |_key, value|
+            value[:default] == true
+          end
+
+          scope ? scope[0].to_s : nil
+        end
+
+        module ClassMethods
+          def scope_map
+            @scope_map ||= {}
+          end
+
+          def scope(attr, options = {})
+            scope_map[attr] = {
+              default: false
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource.rb

@@ -0,0 +1,199 @@
+require "goodmin/resources/attribute"
+require "goodmin/resources/form_builder"
+require "goodmin/resources/resource/associations"
+require "goodmin/resources/resource/batch_actions"
+require "goodmin/resources/resource/filters"
+require "goodmin/resources/resource/ordering"
+require "goodmin/resources/resource/pagination"
+require "goodmin/resources/resource/scopes"
+
+module Goodmin
+  module Resources
+    module Resource
+      extend ActiveSupport::Concern
+
+      class AttributeBuilder
+        attr_reader :attributes
+
+        def initialize
+          @attributes = []
+        end
+
+        def attribute(name, field: nil, **options)
+          @attributes << Attribute.new(name, field_class: field, **options)
+        end
+      end
+
+      include Associations
+      include BatchActions
+      include Filters
+      include Ordering
+      include Pagination
+      include Scopes
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def resource_class
+        self.class.name.delete_prefix("Goodmin::Resources::").chomp("Resource").constantize
+      end
+
+      def resources_relation
+        if options[:resource_parent].present?
+          parent = options[:resource_parent]
+          association_name = resource_class.name.underscore.pluralize.to_sym
+          reflection = parent.class.reflect_on_association(association_name)
+
+          if reflection && (reflection.macro == :has_and_belongs_to_many ||
+              (reflection.macro == :has_many && reflection.options[:through].present?))
+            parent.send(association_name)
+          else
+            resource_class.where(parent.class.name.underscore => parent)
+          end
+        else
+          resource_class.all
+        end
+      end
+
+      def resources(params)
+        apply_pagination(
+          params[:page], apply_order(
+            params[:order], apply_filters(
+              params[:filter], apply_scope(
+                params[:scope], resources_relation
+              )
+            )
+          )
+        )
+      end
+
+      def find_resource(id)
+        resources_relation.find(id)
+      end
+
+      def build_resource(params)
+        resources_relation.new(params)
+      end
+
+      def create_resource(resource)
+        resource.save
+      end
+
+      def update_resource(resource, params)
+        resource.update(params)
+      end
+
+      def destroy_resource(resource)
+        resource.destroy
+      end
+
+      def attrs_for_index
+        self.class.attrs_for_index
+      end
+
+      def attrs_for_show
+        self.class.attrs_for_show
+      end
+
+      def attrs_for_form
+        self.class.attrs_for_form
+      end
+
+      def form_nodes
+        self.class.form_nodes
+      end
+
+      def form_tabs
+        self.class.form_tabs
+      end
+
+      def attrs_for_export
+        self.class.attrs_for_export
+      end
+
+      def display_name(record)
+        record.to_s
+      end
+
+      def option_text_for_association(attribute)
+        self.class.association_option_texts[attribute] || :to_s
+      end
+
+      module ClassMethods
+        def index(&block)
+          if block_given?
+            builder = AttributeBuilder.new
+            builder.instance_eval(&block)
+            @attrs_for_index = builder.attributes
+          end
+          @attrs_for_index || []
+        end
+
+        def show(&block)
+          if block_given?
+            builder = AttributeBuilder.new
+            builder.instance_eval(&block)
+            @attrs_for_show = builder.attributes
+          end
+          @attrs_for_show || []
+        end
+
+        def form(&block)
+          if block_given?
+            builder = FormBuilder.new
+            builder.instance_eval(&block)
+            @form_nodes = builder.nodes
+            @attrs_for_form = builder.attributes
+            @form_tabs = builder.tabs
+          end
+          @attrs_for_form || []
+        end
+
+        def export(&block)
+          if block_given?
+            builder = AttributeBuilder.new
+            builder.instance_eval(&block)
+            @attrs_for_export = builder.attributes
+          end
+          @attrs_for_export || []
+        end
+
+        def attrs_for_index
+          @attrs_for_index || []
+        end
+
+        def attrs_for_show
+          @attrs_for_show || []
+        end
+
+        def attrs_for_form
+          @attrs_for_form || []
+        end
+
+        def form_nodes
+          @form_nodes || attrs_for_form.map { |attr| AttributeNode.new(attr) }
+        end
+
+        def form_tabs
+          @form_tabs || []
+        end
+
+        def attrs_for_export
+          @attrs_for_export || []
+        end
+
+        def association_option_text(attribute, method_name)
+          @association_option_texts ||= {}
+          @association_option_texts[attribute] = method_name
+        end
+
+        def association_option_texts
+          @association_option_texts || {}
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_controller/batch_actions.rb

@@ -0,0 +1,49 @@
+module Goodmin
+  module Resources
+    module ResourceController
+      module BatchActions
+        extend ActiveSupport::Concern
+
+        included do
+          prepend_before_action :perform_batch_action, only: :update
+        end
+
+        protected
+
+        def perform_batch_action
+          return unless params[:batch_action].present?
+
+          set_resource_service
+          set_resource_class
+
+          if authorization_enabled?
+            authorize(batch_action_records, "batch_action_#{params[:batch_action]}?")
+          end
+
+          if @resource_service.batch_action(params[:batch_action], batch_action_records)
+            flash[:notice] = translate_scoped(
+              "flash.batch_action", number_of_records: batch_action_ids.length,
+                                    resource: @resource_class.model_name.human(count: batch_action_ids.length)
+            )
+            flash[:updated_ids] = batch_action_ids
+
+            if respond_to?("redirect_after_batch_action_#{params[:batch_action]}", true)
+              redirect_to send("redirect_after_batch_action_#{params[:batch_action]}")
+              return
+            end
+          end
+
+          redirect_back(fallback_location: root_path)
+        end
+
+        def batch_action_ids
+          @_batch_action_ids ||= params[:id].split(",").map(&:to_i)
+        end
+
+        def batch_action_records
+          @_batch_action_records ||= @resource_class.where(id: batch_action_ids)
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/associations.rb

@@ -0,0 +1,23 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module Associations
+        extend ActiveSupport::Concern
+
+        delegate :has_many_map, to: "self.class"
+
+        module ClassMethods
+          def has_many_map
+            @has_many_map ||= {}
+          end
+
+          def has_many(attr, options = {})
+            has_many_map[attr] = {
+              class_name: attr.to_s.singularize.classify
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/batch_actions.rb

@@ -0,0 +1,52 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module BatchActions
+        extend ActiveSupport::Concern
+
+        delegate :batch_action_map, to: "self.class"
+
+        def batch_action(action, records)
+          if batch_action?(action)
+            send("batch_action_#{action}", records)
+            true
+          else
+            false
+          end
+        end
+
+        def batch_action?(action)
+          batch_action_map.key?(action.to_sym)
+        end
+
+        def include_batch_action?(action)
+          options = batch_action_map[action.to_sym]
+
+          (options[:only].nil? && options[:except].nil?) ||
+            (options[:only] && options[:only].include?(scope.to_sym)) ||
+            (options[:except] && !options[:except].include?(scope.to_sym))
+        end
+
+        def include_batch_actions?
+          batch_action_map.keys.any? do |action|
+            include_batch_action?(action)
+          end
+        end
+
+        module ClassMethods
+          def batch_action_map
+            @batch_action_map ||= {}
+          end
+
+          def batch_action(attr, options = {})
+            batch_action_map[attr] = {
+              only: nil,
+              except: nil,
+              confirm: false
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/filters.rb

@@ -0,0 +1,44 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module Filters
+        extend ActiveSupport::Concern
+
+        delegate :filter_map, to: "self.class"
+
+        def apply_filters(filter_params, resources)
+          if filter_params.present?
+            filter_params.each do |name, value|
+              if apply_filter?(name, value)
+                resources = send("filter_#{name}", resources, value)
+              end
+            end
+          end
+          resources
+        end
+
+        private
+
+        def apply_filter?(name, value)
+          return false if value == [""]
+          filter_map.key?(name.to_sym) && value.present?
+        end
+
+        module ClassMethods
+          def filter_map
+            @filter_map ||= {}
+          end
+
+          def filter(attr, options = {})
+            filter_map[attr] = {
+              as: :string,
+              option_text: "to_s",
+              option_value: "id",
+              collection: nil
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/ordering.rb

@@ -0,0 +1,41 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module Ordering
+        extend ActiveSupport::Concern
+
+        def apply_order(order_param, resources)
+          if order_param.present? && order_column_method?(order_column(order_param))
+            send("order_by_#{order_column(order_param)}", resources, order_direction(order_param))
+          elsif order_param.present? && order_column_column?(order_column(order_param))
+            resources.order("#{resource_class.table_name}.#{order_column(order_param)} #{order_direction(order_param)}")
+          else
+            resources
+          end
+        end
+
+        def orderable_column?(column)
+          order_column_method?(column) || order_column_column?(column)
+        end
+
+        protected
+
+        def order_column_method?(column)
+          respond_to?("order_by_#{column}")
+        end
+
+        def order_column_column?(column)
+          resource_class.column_names.include?(column)
+        end
+
+        def order_column(order_param)
+          order_param.rpartition("_").first
+        end
+
+        def order_direction(order_param)
+          order_param.rpartition("_").last == "asc" ? "asc" : "desc"
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/pagination.rb

@@ -0,0 +1,22 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module Pagination
+        extend ActiveSupport::Concern
+
+        def apply_pagination(page_param, resources)
+          @paginator = Paginator.new(resources, per_page: per_page, current_page: page_param)
+          @paginator.paginate
+        end
+
+        def paginator
+          @paginator
+        end
+
+        def per_page
+          25
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/resource_service/scopes.rb

@@ -0,0 +1,61 @@
+module Goodmin
+  module Resources
+    module ResourceService
+      module Scopes
+        extend ActiveSupport::Concern
+
+        delegate :scope_map, to: "self.class"
+
+        def apply_scope(scope_param, resources)
+          return resources if scope_map.empty?
+
+          self.scope = scope_param
+
+          if scope && scope_map.key?(scope.to_sym)
+            send("scope_#{@scope}", resources)
+          else
+            fail NotImplementedError, "Scope #{@scope} not implemented"
+          end
+        end
+
+        def scope=(scope)
+          @scope = scope.blank? ? default_scope : scope
+        end
+
+        def scope
+          @scope
+        end
+
+        def scoped_by?(name)
+          @scope == name.to_s
+        end
+
+        def scope_count(scope)
+          send("scope_#{scope}", resources_relation).count
+        end
+
+        protected
+
+        def default_scope
+          scope = scope_map.find -> { scope_map.first } do |_key, value|
+            value[:default] == true
+          end
+
+          scope ? scope[0].to_s : nil
+        end
+
+        module ClassMethods
+          def scope_map
+            @scope_map ||= {}
+          end
+
+          def scope(attr, options = {})
+            scope_map[attr] = {
+              default: false
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end