easy-admin-rails 0.1.14 → 0.2.0

data/lib/easy_admin/resource/field_registry.rb

@@ -0,0 +1,189 @@
+module EasyAdmin
+  module ResourceModules
+    # FieldRegistry module for centralized field management
+    # Handles field registration, categorization, and retrieval
+    module FieldRegistry
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :fields_config
+
+        def self.initialize_field_registry
+          self.fields_config = []
+        end
+      end
+
+      class_methods do
+        # Core field registration method
+        def register_field(name, type = :string, **options)
+          field_config = build_field_config(name, type, **options)
+          add_field_to_registry(field_config)
+        end
+
+        # Build field configuration hash
+        def build_field_config(name, type, **options)
+          {
+            name: name,
+            type: type,
+            label: options[:label] || name.to_s.humanize,
+            sortable: options.fetch(:sortable, true),
+            searchable: options.fetch(:searchable, false),
+            filterable: options.fetch(:filterable, false),
+            required: options.fetch(:required, false),
+            readonly: options.fetch(:readonly, false),
+            format: options[:format],
+            options: options[:options], # for select fields
+            multiple: options[:multiple], # for select fields
+            placeholder: options[:placeholder], # for select fields
+            suggest: options[:suggest], # for dynamic option loading
+            display_method: options[:display_method], # for association fields
+            help_text: options[:help_text],
+            editable: options[:editable],
+            association: options[:association],
+            foreign_key: options[:foreign_key] # for belongs_to fields
+          }
+        end
+
+        # Add field to the registry
+        def add_field_to_registry(field_config)
+          # Prevent duplicate fields by name
+          current_fields = self.fields_config || []
+          unless current_fields.any? { |f| f[:name] == field_config[:name] }
+            self.fields_config = current_fields + [field_config]
+          end
+        end
+
+        # Field categorization methods
+        def index_fields
+          fields_config.select { |field| ![:text, :has_many, :file].include?(field[:type]) }
+        end
+
+        def sortable_fields
+          fields_config.select { |field| field[:sortable] }
+        end
+
+        def filterable_fields
+          fields_config.select { |field| field[:filterable] }
+        end
+
+        def searchable_fields
+          fields_config.select { |field| field[:searchable] }
+        end
+
+        def show_fields
+          fields_config
+        end
+
+        def form_fields
+          if has_form_tabs?
+            # If tabs are configured, return fields from all tabs
+            form_tabs_config.flat_map { |tab| tab[:fields] }.reject { |field| field[:readonly] }
+          else
+            # Default behavior: return all non-readonly fields
+            fields_config.reject { |field| field[:readonly] }
+          end
+        end
+
+        # Field lookup methods
+        def find_field_config(field_name)
+          fields_config.find { |field| field[:name].to_s == field_name.to_s }
+        end
+
+        def field_exists?(field_name)
+          find_field_config(field_name).present?
+        end
+
+        def field_type(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:type)
+        end
+
+        def field_editable?(field_name)
+          field_config = find_field_config(field_name)
+          return false unless field_config
+          !field_config[:readonly] && field_config.fetch(:editable, true)
+        end
+
+        # Field validation methods
+        def required_fields
+          fields_config.select { |field| field[:required] }
+        end
+
+        def readonly_fields
+          fields_config.select { |field| field[:readonly] }
+        end
+
+        # Field grouping by type
+        def fields_by_type(type)
+          fields_config.select { |field| field[:type] == type }
+        end
+
+        def association_fields
+          fields_config.select { |field| [:belongs_to, :has_many].include?(field[:type]) }
+        end
+
+        def belongs_to_fields
+          fields_by_type(:belongs_to)
+        end
+
+        def has_many_fields
+          fields_by_type(:has_many)
+        end
+
+        def select_fields
+          fields_by_type(:select)
+        end
+
+        def json_fields
+          fields_by_type(:json)
+        end
+
+        # Field options helpers
+        def field_options(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:options) || []
+        end
+
+        def field_suggest_config(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:suggest) || {}
+        end
+
+        def field_display_method(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:display_method) || :name
+        end
+
+        # Advanced field queries
+        def fields_with_suggest
+          fields_config.select { |field| field[:suggest].present? }
+        end
+
+        def multiple_select_fields
+          fields_config.select { |field| field[:type] == :select && field[:multiple] }
+        end
+
+        def file_fields
+          fields_by_type(:file)
+        end
+
+        def password_fields
+          fields_by_type(:password)
+        end
+
+        # Field count helpers
+        def total_fields_count
+          fields_config.count
+        end
+
+        def editable_fields_count
+          fields_config.count { |field| field_editable?(field[:name]) }
+        end
+
+        def association_fields_count
+          association_fields.count
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/form_builder.rb

@@ -0,0 +1,123 @@
+module EasyAdmin
+  module ResourceModules
+    # FormBuilder class for form DSL
+    # Handles all form tab and field definitions within forms
+    class FormBuilder
+      def initialize(resource_class)
+        @resource_class = resource_class
+        @current_tab = nil
+      end
+
+      def tab(name = "General", **options, &block)
+        tab_config = {
+          name: name,
+          label: options[:label] || name,
+          icon: options[:icon],
+          fields: []
+        }
+
+        @current_tab = tab_config
+        @resource_class.add_form_tab(tab_config)
+
+        instance_eval(&block) if block_given?
+        @current_tab = nil
+      end
+
+      # Field definition methods within tabs - delegate to resource
+      def field(name, type = :string, **options)
+        field_config = @resource_class.build_field_config(name, type, **options)
+
+        if @current_tab
+          @current_tab[:fields] << field_config
+        end
+
+        # Also add to main fields_config for compatibility
+        @resource_class.add_field_to_registry(field_config)
+      end
+
+      # Convenience methods for form fields
+      def text_field(name, **options)
+        field(name, :string, **options)
+      end
+
+      def textarea_field(name, **options)
+        field(name, :text, **options)
+      end
+
+      def number_field(name, **options)
+        field(name, :number, **options)
+      end
+
+      def email_field(name, **options)
+        field(name, :email, **options)
+      end
+
+      def date_field(name, **options)
+        field(name, :date, **options)
+      end
+
+      def datetime_field(name, **options)
+        field(name, :datetime, **options)
+      end
+
+      def boolean_field(name, **options)
+        field(name, :boolean, **options)
+      end
+
+      def select_field(name, options:, **other_options)
+        field(name, :select, options: options, **other_options)
+      end
+
+      def belongs_to_field(name, **options)
+        field(name, :belongs_to, **options)
+      end
+
+      def has_many_field(name, **options)
+        field(name, :has_many, **options)
+      end
+
+      def file_field(name, **options)
+        field(name, :file, **options)
+      end
+
+      def json_field(name, **options)
+        field(name, :json, **options)
+      end
+
+      def password_field(name = :password, **options)
+        field(name, :password, **options)
+        field("#{name}_confirmation".to_sym, :password, 
+              label: options[:confirmation_label] || "Confirm #{name.to_s.humanize}",
+              **options.except(:confirmation_label))
+      end
+
+      # Support for rendering custom components in forms
+      def render(component_class_or_instance, **options)
+        content_config = {
+          type: :custom_component,
+          component_class: component_class_or_instance.class,
+          component_options: options,
+          component_instance: component_class_or_instance
+        }
+        
+        if @current_tab
+          @current_tab[:fields] << content_config
+        end
+        
+        component_class_or_instance
+      end
+
+      # Support for custom content blocks in forms  
+      def content(&block)
+        content_config = {
+          type: :custom_content,
+          block: block
+        }
+        
+        if @current_tab
+          @current_tab[:fields] << content_config
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/layout_builder.rb

@@ -0,0 +1,249 @@
+module EasyAdmin
+  module ResourceModules
+    # LayoutBuilder module for handling form and show layout configuration
+    # Manages form tabs and show page layout elements
+    module LayoutBuilder
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :form_tabs_config, :show_layout_config
+
+        def self.initialize_layout_builder
+          self.form_tabs_config = []
+          self.show_layout_config = []
+        end
+      end
+
+      class_methods do
+        # Form tabs management
+        def add_form_tab(tab_config)
+          self.form_tabs_config = (self.form_tabs_config || []) + [tab_config]
+        end
+
+        def form_tabs
+          form_tabs_config
+        end
+
+        def has_form_tabs?
+          form_tabs_config.any?
+        end
+
+        def clear_form_tabs
+          self.form_tabs_config = []
+        end
+
+        # Show layout management
+        def add_show_layout_element(element_config)
+          self.show_layout_config = (self.show_layout_config || []) + [element_config]
+        end
+
+        def show_layout
+          show_layout_config
+        end
+
+        def has_show_layout?
+          show_layout_config.any?
+        end
+
+        def clear_show_layout
+          self.show_layout_config = []
+        end
+
+        # Form tab utilities
+        def find_form_tab(tab_name)
+          form_tabs_config.find { |tab| tab[:name].to_s == tab_name.to_s }
+        end
+
+        def form_tab_names
+          form_tabs_config.map { |tab| tab[:name] }
+        end
+
+        def form_tab_fields(tab_name)
+          tab = find_form_tab(tab_name)
+          tab ? tab[:fields] : []
+        end
+
+        def total_form_tabs_count
+          form_tabs_config.count
+        end
+
+        # Show layout utilities
+        def show_layout_rows
+          show_layout_config.select { |element| element[:type] == :row }
+        end
+
+        def show_layout_elements_count
+          count = 0
+          show_layout_config.each do |element|
+            count += count_nested_elements(element)
+          end
+          count
+        end
+
+        def find_show_layout_element(element_type)
+          find_element_in_layout(show_layout_config, element_type)
+        end
+
+        def has_show_layout_tabs?
+          find_show_layout_element(:tabs).present?
+        end
+
+        def has_show_layout_cards?
+          find_show_layout_element(:card).present?
+        end
+
+        def has_metric_cards?
+          find_show_layout_element(:metric_card).present?
+        end
+
+        def has_chart_cards?
+          find_show_layout_element(:chart_card).present?
+        end
+
+        # Layout validation
+        def validate_form_structure
+          errors = []
+          
+          if has_form_tabs?
+            form_tabs_config.each_with_index do |tab, index|
+              unless tab[:name].present?
+                errors << "Form tab at index #{index} is missing a name"
+              end
+              
+              unless tab[:fields].is_a?(Array)
+                errors << "Form tab '#{tab[:name]}' fields must be an array"
+              end
+            end
+          end
+          
+          errors
+        end
+
+        def validate_show_layout_structure
+          errors = []
+          
+          show_layout_config.each_with_index do |element, index|
+            case element[:type]
+            when :row
+              unless element[:columns].is_a?(Array)
+                errors << "Row at index #{index} must have columns array"
+              end
+              
+              if element[:columns].empty?
+                errors << "Row at index #{index} cannot have empty columns"
+              end
+            when :column
+              unless element[:elements].is_a?(Array)
+                errors << "Column at index #{index} must have elements array"
+              end
+            end
+          end
+          
+          errors
+        end
+
+        # Layout rebuild methods
+        def rebuild_form_from_fields
+          return if fields_config.empty?
+          
+          # Create a default tab with all non-readonly fields
+          default_tab = {
+            name: "General",
+            label: "General",
+            icon: nil,
+            fields: fields_config.reject { |field| field[:readonly] }
+          }
+          
+          self.form_tabs_config = [default_tab]
+        end
+
+        def rebuild_show_layout_from_fields
+          return if fields_config.empty?
+          
+          # Create a simple single-column layout with all fields
+          row_config = {
+            type: :row,
+            columns_count: 1,
+            spacing: "medium",
+            columns: [{
+              type: :column,
+              size: 12,
+              elements: [{
+                type: :card,
+                title: "Details",
+                color: "light",
+                padding: "medium",
+                shadow: "small",
+                elements: fields_config.map { |field|
+                  {
+                    type: :field,
+                    name: field[:name],
+                    label: field[:label],
+                    field_type: :default,
+                    format: field[:format],
+                    css_classes: nil,
+                    show_label: true
+                  }
+                }
+              }]
+            }]
+          }
+          
+          self.show_layout_config = [row_config]
+        end
+
+        private
+
+        def count_nested_elements(element)
+          count = 1
+          
+          case element[:type]
+          when :row
+            element[:columns]&.each { |column| count += count_nested_elements(column) }
+          when :column
+            element[:elements]&.each { |child| count += count_nested_elements(child) }
+          when :card
+            element[:elements]&.each { |child| count += count_nested_elements(child) }
+          when :tabs
+            element[:tabs]&.each { |tab| count += count_nested_elements(tab) }
+          when :tab
+            element[:elements]&.each { |child| count += count_nested_elements(child) }
+          end
+          
+          count
+        end
+
+        def find_element_in_layout(layout, element_type)
+          layout.each do |element|
+            return element if element[:type] == element_type
+            
+            case element[:type]
+            when :row
+              element[:columns]&.each do |column|
+                found = find_element_in_layout([column], element_type)
+                return found if found
+              end
+            when :column, :card
+              if element[:elements]
+                found = find_element_in_layout(element[:elements], element_type)
+                return found if found
+              end
+            when :tabs
+              element[:tabs]&.each do |tab|
+                found = find_element_in_layout([tab], element_type)
+                return found if found
+              end
+            when :tab
+              if element[:elements]
+                found = find_element_in_layout(element[:elements], element_type)
+                return found if found
+              end
+            end
+          end
+          
+          nil
+        end
+      end
+    end
+  end
+end