goodmin 0.0.1

data/lib/goodmin/paginator.rb

@@ -0,0 +1,55 @@
+module Goodmin
+  class Paginator
+    WINDOW_SIZE = 7
+
+    attr_reader :per_page, :current_page
+
+    def initialize(resources, per_page: 25, current_page: nil)
+      @resources = resources
+      @per_page = per_page
+      @current_page = current_page ? current_page.to_i : 1
+    end
+
+    def paginate
+      @resources.limit(per_page).offset(offset)
+    end
+
+    def pages
+      @pages ||= begin
+        pages = (1..total_pages).to_a
+
+        return pages unless total_pages > WINDOW_SIZE
+
+        if current_page < WINDOW_SIZE
+          pages.slice(0, WINDOW_SIZE)
+        elsif current_page > (total_pages - WINDOW_SIZE)
+          pages.slice(-WINDOW_SIZE, WINDOW_SIZE)
+        else
+          pages.slice(pages.index(current_page) - (WINDOW_SIZE / 2), WINDOW_SIZE)
+        end
+      end
+    end
+
+    def total_pages
+      @total_pages ||= (total_resources.to_f / per_page).ceil
+    end
+
+    def total_resources
+      @total_resources ||= begin
+        count = @resources.count
+
+        if count.respond_to?(:count)
+          count.count
+        else
+          count
+        end
+      end
+    end
+
+    private
+
+    def offset
+      (current_page * per_page) - per_page
+    end
+  end
+end

data/lib/goodmin/resolver.rb

@@ -0,0 +1,141 @@
+require "action_view"
+require "action_view/template/resolver"
+
+module Goodmin
+  class Resolver < ::ActionView::FileSystemResolver
+    def self.resolvers(controller_path)
+      engine_root = engine_root_for(controller_path)
+      [
+        EngineResolver.new(controller_path, engine_root),
+        GoodminResolver.new(controller_path)
+      ]
+    end
+
+    def self.engine_root_for(controller_path)
+      parts = controller_path.split("/")
+      return Rails.application.root if parts.length < 2
+
+      namespace_path = parts.first(parts.length - 1).join("/")
+
+      engine = Rails::Engine.subclasses.find do |e|
+        next unless e.railtie_namespace
+        e.railtie_namespace.name.underscore.gsub("::", "/") == namespace_path
+      rescue NameError, NoMethodError
+        nil
+      end
+
+      engine&.root || Rails.application.root
+    end
+
+    def initialize(path, controller_path)
+      super(path)
+      @controller_path = controller_path
+    end
+
+    # This function is for Rails 6 and up since the `find_templates` function
+    # is deprecated. It does the same thing, just a little differently. It's
+    # not being run by versions previous to Rails 6.
+    def _find_all(name, prefix, partial, details, key, locals)
+      templates = []
+
+      template_paths(prefix).each do |template_path|
+        break if templates.present?
+
+        templates = super(name, template_path, partial, details, key, locals)
+      end
+
+      templates
+    end
+
+    # This is how we find templates in Rails 5 and below.
+    def find_templates(name, prefix, *args)
+      templates = []
+
+      template_paths(prefix).each do |path|
+        break if templates.present?
+
+        templates = super(name, path, *args)
+      end
+
+      templates
+    end
+  end
+
+  class EngineResolver < Resolver
+    def initialize(controller_path, engine_root = Rails.application.root)
+      super(File.join(engine_root, "app/views"), controller_path)
+    end
+
+    def template_paths(prefix)
+      application_path = application_path_for_engine
+      resource_path = resource_path_for_engine(prefix)
+      shared_path = shared_path_for_engine(prefix)
+      # Always include the base shared path (without any prefix sub-path) before application_path.
+      # This ensures app/views/goodmin/shared overrides are found even when Rails invokes the
+      # resolver with a non-controller prefix (e.g. "layouts/goodmin" from the layout file),
+      # where the prefix-specific shared path won't match the user's shared partial.
+      # Using @controller_path as the prefix argument produces a sub_path of "" (no suffix),
+      # giving us the plain namespace-scoped shared directory (e.g. "shared" or "admin/shared").
+      base_shared_path = shared_path_for_engine(@controller_path)
+
+      paths = [resource_path, shared_path, base_shared_path, application_path].uniq
+      return paths if @controller_path.split("/").length > 1
+
+      [
+        "goodmin/#{resource_path}",
+        "goodmin/#{shared_path}",
+        "goodmin/#{base_shared_path}",
+        "goodmin/#{application_path}"
+      ].uniq + paths
+    end
+
+    def application_path_for_engine
+      parts = @controller_path.split("/")
+      parts.length > 1 ? "#{parts.first(parts.length - 1).join("/")}/application" : "application"
+    end
+
+    def resource_path_for_engine(prefix)
+      sub_path = prefix.delete_prefix(@controller_path).delete_prefix("/")
+      parts = @controller_path.split("/")
+      resource_base = parts.length > 1 ? "#{parts.first(parts.length - 1).join("/")}/resource" : "resource"
+      sub_path.present? ? "#{resource_base}/#{sub_path}" : resource_base
+    end
+
+    def shared_path_for_engine(prefix)
+      sub_path = prefix.delete_prefix(@controller_path).delete_prefix("/")
+      parts = @controller_path.split("/")
+      shared_base = parts.length > 1 ? "#{parts.first(parts.length - 1).join("/")}/shared" : "shared"
+      sub_path.present? ? "#{shared_base}/#{sub_path}" : shared_base
+    end
+  end
+
+  class GoodminResolver < Resolver
+    def initialize(controller_path)
+      super(File.join(Goodmin::Engine.root, "app/views/goodmin"), controller_path)
+    end
+
+    def template_paths(prefix)
+      [
+        default_path_for_goodmin(prefix),
+        resource_path_for_goodmin(prefix),
+        shared_path_for_goodmin(prefix)
+      ]
+    end
+
+    def default_path_for_goodmin(prefix)
+      sub_path = prefix.delete_prefix(@controller_path).delete_prefix("/")
+      base = File.basename(@controller_path)
+      sub_path.present? ? "#{base}/#{sub_path}" : base
+    end
+
+    def resource_path_for_goodmin(prefix)
+      sub_path = prefix.delete_prefix(@controller_path).delete_prefix("/")
+      sub_path.present? ? "resource/#{sub_path}" : "resource"
+    end
+
+    def shared_path_for_goodmin(prefix)
+      sub_path = prefix.delete_prefix(@controller_path).delete_prefix("/")
+      sub_path.present? ? "shared/#{sub_path}" : "shared"
+    end
+  end
+end

data/lib/goodmin/resources/attribute.rb

@@ -0,0 +1,46 @@
+module Goodmin
+  module Resources
+    class Attribute
+      attr_reader :name, :field_class, :options
+
+      def initialize(name, field_class: nil, **options)
+        @name = name
+        @field_class = field_class
+        @options = options
+      end
+
+      def to_field(record:, resource_service:)
+        resolved_field_class(record).new(
+          attribute: name,
+          record: record,
+          resource_service: resource_service,
+          **options
+        )
+      end
+
+      private
+
+      def resolved_field_class(record)
+        return field_class if field_class
+
+        if record.class.respond_to?(:reflect_on_association) && (reflection = record.class.reflect_on_association(name))
+          reflection.macro == :has_one ? Fields::NestedHasOne : Fields::Association
+        elsif record.class.respond_to?(:defined_enums) && record.class.defined_enums.key?(name.to_s)
+          Fields::Enum
+        elsif record.class.respond_to?(:has_attribute?) && record.class.has_attribute?(name.to_s)
+          column = record.class.column_for_attribute(name)
+          case column.type
+          when :text then Fields::Text
+          when :boolean then Fields::Boolean
+          when :date then Fields::Date
+          when :datetime, :timestamp then Fields::DateTime
+          when :integer, :float, :decimal then Fields::Number
+          else Fields::String
+          end
+        else
+          Fields::String
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_builder.rb

@@ -0,0 +1,96 @@
+require "goodmin/resources/attribute"
+
+module Goodmin
+  module Resources
+    class FormBuilder
+      HTML_TAGS = %w[
+        div span p fieldset article header footer main
+        h1 h2 h3 h4 h5 h6 ul ol li dl dt dd
+      ].freeze
+
+      attr_reader :nodes
+
+      def initialize
+        @nodes = []
+      end
+
+      def attribute(name, field: nil, **options)
+        @nodes << AttributeNode.new(Attribute.new(name, field_class: field, **options))
+      end
+
+      HTML_TAGS.each do |tag|
+        define_method(tag) do |**html_attrs, &block|
+          child_builder = FormBuilder.new
+          child_builder.instance_eval(&block) if block
+          @nodes << HtmlNode.new(tag, html_attrs, child_builder.nodes)
+        end
+      end
+
+      # Registers a custom DSL component so it can be used inside form blocks.
+      #
+      # @param name [Symbol] the method name available in the DSL
+      # @param klass [Class] a class that includes Goodmin::Resources::FormComponent
+      #
+      # Example:
+      #   Goodmin::Resources::FormBuilder.register_component(:my_component, MyComponent)
+      def self.register_component(name, klass)
+        define_method(name) do |*args, **kwargs, &block|
+          child_builder = FormBuilder.new
+          child_builder.instance_eval(&block) if block
+          @nodes << ComponentNode.new(klass.new(child_builder.nodes, *args, **kwargs))
+        end
+      end
+
+      # Extracts a flat list of Attribute objects from a node tree.
+      # Used internally and by FormComponent#attributes.
+      def self.extract_attributes(nodes)
+        nodes.flat_map do |node|
+          case node
+          when AttributeNode then [node.attribute]
+          when HtmlNode then extract_attributes(node.children)
+          when ComponentNode then node.component.attributes
+          end
+        end
+      end
+
+      # Extracts the list of Tab components from a top-level node array.
+      def self.extract_tabs(nodes)
+        nodes.select { |n| n.is_a?(ComponentNode) && n.component.tab_component? }.map(&:component)
+      end
+
+      def attributes
+        self.class.extract_attributes(@nodes)
+      end
+
+      def tabs
+        self.class.extract_tabs(@nodes)
+      end
+    end
+
+    class AttributeNode
+      attr_reader :attribute
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+    end
+
+    class HtmlNode
+      attr_reader :tag, :html_attrs, :children
+
+      def initialize(tag, html_attrs, children)
+        @tag = tag
+        @html_attrs = html_attrs
+        @children = children
+      end
+    end
+
+    class ComponentNode
+      attr_reader :component
+
+      def initialize(component)
+        @component = component
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_component.rb

@@ -0,0 +1,65 @@
+module Goodmin
+  module Resources
+    # Mixin for custom form DSL components that can be registered with
+    # FormBuilder.register_component and used inside form blocks.
+    #
+    # To create a custom component, include this module and implement:
+    #
+    #   - #initialize(children, *args, **kwargs) — receives the list of child
+    #     nodes (Array of AttributeNode / HtmlNode / ComponentNode) as the
+    #     first argument, followed by any arguments passed in the DSL.
+    #   - #render(view_context, f) — returns HTML-safe output for the component.
+    #   - (optional) #attributes — returns an Array of Goodmin::Resources::Attribute
+    #     objects contributed by this component for strong-parameter filtering.
+    #     Defaults to extracting attributes from any child nodes.
+    #
+    # Example:
+    #
+    #   class MyComponent
+    #     include Goodmin::Resources::FormComponent
+    #
+    #     def initialize(children, label:)
+    #       super(children)
+    #       @label = label
+    #     end
+    #
+    #     def render(view_context, f)
+    #       view_context.content_tag(:fieldset) do
+    #         view_context.content_tag(:legend, @label) +
+    #           view_context.render_form_nodes(children, f)
+    #       end
+    #     end
+    #   end
+    #
+    #   # Register:
+    #   Goodmin::Resources::FormBuilder.register_component(:my_component, MyComponent)
+    #
+    #   # Use in a form block:
+    #   form do
+    #     my_component(label: "Details") do
+    #       attribute :title
+    #     end
+    #   end
+    module FormComponent
+      def self.included(base)
+        base.attr_reader :children
+      end
+
+      def initialize(children, *_args, **_kwargs)
+        @children = children
+      end
+
+      # Override to return Attribute objects this component contributes.
+      # By default, attributes are extracted recursively from child nodes.
+      def attributes
+        FormBuilder.extract_attributes(children)
+      end
+
+      # Returns true for tab components. Override in tab-like components to
+      # allow FormBuilder to identify and extract them.
+      def tab_component?
+        false
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_components/col.rb

@@ -0,0 +1,33 @@
+module Goodmin
+  module Resources
+    module FormComponents
+      # Renders a Bootstrap grid column wrapping its child form nodes.
+      #
+      # Accepts an optional +size+ keyword argument (default: 12) which maps to
+      # the Bootstrap col-md-* class.
+      #
+      # Usage in a form block:
+      #
+      #   form do
+      #     row do
+      #       col(size: 6) { attribute :title }
+      #       col(size: 6) { attribute :body }
+      #     end
+      #   end
+      class Col
+        include FormComponent
+
+        def initialize(children, size: 12)
+          super(children)
+          @size = size
+        end
+
+        def render(view_context, f)
+          view_context.content_tag(:div, class: "col-md-#{@size}") do
+            view_context.render_form_nodes(children, f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_components/row.rb

@@ -0,0 +1,25 @@
+module Goodmin
+  module Resources
+    module FormComponents
+      # Renders a Bootstrap grid row wrapping its child form nodes.
+      #
+      # Usage in a form block:
+      #
+      #   form do
+      #     row do
+      #       col { attribute :title }
+      #       col { attribute :body }
+      #     end
+      #   end
+      class Row
+        include FormComponent
+
+        def render(view_context, f)
+          view_context.content_tag(:div, class: "row") do
+            view_context.render_form_nodes(children, f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_components/section.rb

@@ -0,0 +1,51 @@
+module Goodmin
+  module Resources
+    module FormComponents
+      # Renders a titled, described section wrapping its child form nodes.
+      #
+      # Accepts optional +title+ and +description+ keyword arguments which are
+      # rendered above a +<div>+ that wraps the section's child nodes. The entire
+      # output is wrapped in an outer +<div>+.
+      #
+      # Both +title+ and +description+ can be a static string or a +Proc+. When
+      # a +Proc+ is provided it is called at render time with the form's object
+      # (the resource record) as its sole argument, allowing dynamic content.
+      #
+      # Usage in a form block:
+      #
+      #   form do
+      #     section(title: "Details", description: "Fill in the details below.") do
+      #       attribute :title
+      #       attribute :body
+      #     end
+      #
+      #     section(description: ->(record) { "Editing #{record.name}" }) do
+      #       attribute :title
+      #     end
+      #   end
+      class Section
+        include FormComponent
+
+        def initialize(children, title: nil, description: nil)
+          super(children)
+          @title = title
+          @description = description
+        end
+
+        def render(view_context, f)
+          record = f.object
+          title = @title.is_a?(Proc) ? @title.call(record) : @title
+          description = @description.is_a?(Proc) ? @description.call(record) : @description
+
+          view_context.content_tag(:div) do
+            parts = []
+            parts << view_context.content_tag(:h4, title) if title.present?
+            parts << view_context.content_tag(:p, description) if description.present?
+            parts << view_context.content_tag(:div) { view_context.render_form_nodes(children, f) }
+            view_context.safe_join(parts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/resources/form_components/tab.rb

@@ -0,0 +1,49 @@
+module Goodmin
+  module Resources
+    module FormComponents
+      # Renders a form tab panel containing its child form nodes.
+      #
+      # Each tab has a +title+ and a derived +key+ (parameterized from the title)
+      # used as the URL query parameter value to identify the active tab.
+      #
+      # When the resource form has tabs defined, only one tab's content is
+      # rendered at a time based on the +?tab=<key>+ query parameter. A sidebar
+      # with links to each tab is displayed alongside the form.
+      #
+      # Usage in a form block:
+      #
+      #   form do
+      #     tab title: "General settings" do
+      #       attribute :name
+      #     end
+      #
+      #     tab title: "Config" do
+      #       row do
+      #         col { attribute :foo }
+      #       end
+      #     end
+      #   end
+      class Tab
+        include FormComponent
+
+        attr_reader :title, :key
+
+        def initialize(children, title:)
+          raise ArgumentError, "Tab requires a :title" if title.blank?
+
+          super(children)
+          @title = title
+          @key = title.parameterize(separator: "_")
+        end
+
+        def render(view_context, f)
+          view_context.render_form_nodes(children, f)
+        end
+
+        def tab_component?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Goodmin
+  module Resources
+    module Resource
+      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/batch_actions.rb

@@ -0,0 +1,56 @@
+module Goodmin
+  module Resources
+    module Resource
+      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)
+          return false unless batch_action_map.key?(action.to_sym)
+
+          options = batch_action_map[action.to_sym]
+
+          if options[:only].present?
+            options[:only].include?(@scope.to_sym)
+          elsif options[:except].present?
+            !options[:except].include?(@scope.to_sym)
+          else
+            true
+          end
+        end
+
+        def include_batch_actions?
+          batch_action_map.any? { |action, _options| include_batch_action?(action) }
+        end
+
+        module ClassMethods
+          def batch_action_map
+            @batch_action_map ||= {}
+          end
+
+          def batch_action(attr, options = {})
+            batch_action_map[attr] = {
+              confirm: false,
+              only: nil,
+              except: nil
+            }.merge(options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Goodmin
+  module Resources
+    module Resource
+      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