easy-admin-rails 0.1.15 → 0.2.1

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

data/lib/easy_admin/resource/scope_manager.rb

@@ -0,0 +1,252 @@
+module EasyAdmin
+  module ResourceModules
+    # ScopeManager module for handling resource scopes and filtering
+    # Manages scope definitions, default scopes, and scope-related queries
+    module ScopeManager
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :scopes_config
+
+        def self.initialize_scope_manager
+          self.scopes_config = []
+        end
+      end
+
+      class_methods do
+        # Core scope definition method
+        def scope(name, **options)
+          scope_config = {
+            name: name,
+            label: options[:label] || name.to_s.humanize,
+            scope_method: options[:scope] || name,
+            default: options.fetch(:default, false),
+            icon: options[:icon],
+            color: options[:color] || 'blue',
+            count: options.fetch(:show_count, true),
+            condition: options[:if] # Conditional scope visibility
+          }
+          
+          add_scope(scope_config)
+        end
+
+        # Add scope to configuration
+        def add_scope(scope_config)
+          self.scopes_config = (self.scopes_config || []) + [scope_config]
+        end
+
+        # Scope query methods
+        def scopes
+          scopes_config
+        end
+
+        def has_scopes?
+          scopes_config.any?
+        end
+
+        def scope_names
+          scopes_config.map { |scope| scope[:name] }
+        end
+
+        def find_scope(name)
+          scopes_config.find { |scope| scope[:name].to_s == name.to_s }
+        end
+
+        def scope_exists?(name)
+          find_scope(name).present?
+        end
+
+        # Default scope management
+        def default_scope
+          scopes_config.find { |scope| scope[:default] } || scopes_config.first
+        end
+
+        def set_default_scope(name)
+          # Remove existing default
+          scopes_config.each { |scope| scope[:default] = false }
+          
+          # Set new default
+          scope = find_scope(name)
+          scope[:default] = true if scope
+        end
+
+        def has_default_scope?
+          default_scope.present?
+        end
+
+        # Conditional scopes
+        def visible_scopes(context = {})
+          scopes_config.select do |scope_config|
+            condition = scope_config[:condition]
+            condition.nil? || (condition.respond_to?(:call) ? context.instance_eval(&condition) : condition)
+          end
+        end
+
+        def conditional_scopes
+          scopes_config.select { |scope| scope[:condition].present? }
+        end
+
+        # Scope application methods
+        def apply_scope_to_records(records, scope_name)
+          return records unless scope_exists?(scope_name)
+          
+          scope_config = find_scope(scope_name)
+          return records if scope_config[:name] == :all
+          
+          scope_method = scope_config[:scope_method]
+          if records.respond_to?(scope_method)
+            records.public_send(scope_method)
+          else
+            records
+          end
+        end
+
+        def apply_default_scope_to_records(records)
+          return records unless has_default_scope?
+          
+          default = default_scope
+          return records if default[:name] == :all
+          
+          apply_scope_to_records(records, default[:name])
+        end
+
+        # Scope counts calculation
+        def calculate_scope_counts(base_records = nil)
+          base_records ||= model_class.all
+          counts = {}
+          
+          scopes_config.each do |scope_config|
+            scope_name = scope_config[:name]
+            next unless scope_config[:count] # Skip if count is disabled
+            
+            if scope_name == :all
+              counts[scope_name] = base_records.count
+            else
+              scope_method = scope_config[:scope_method]
+              if model_class.respond_to?(scope_method)
+                counts[scope_name] = model_class.public_send(scope_method).count
+              else
+                counts[scope_name] = 0
+              end
+            end
+          end
+          
+          counts
+        end
+
+        def scope_count(scope_name, base_records = nil)
+          return 0 unless scope_exists?(scope_name)
+          
+          scope_config = find_scope(scope_name)
+          return 0 unless scope_config[:count]
+          
+          if scope_name == :all
+            base_records ||= model_class.all
+            base_records.count
+          else
+            scope_method = scope_config[:scope_method]
+            if model_class.respond_to?(scope_method)
+              model_class.public_send(scope_method).count
+            else
+              0
+            end
+          end
+        end
+
+        # Scope utilities
+        def scope_label(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config ? scope_config[:label] : scope_name.to_s.humanize
+        end
+
+        def scope_icon(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config&.dig(:icon)
+        end
+
+        def scope_color(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config&.dig(:color) || 'blue'
+        end
+
+        def scope_method_name(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config ? scope_config[:scope_method] : scope_name
+        end
+
+        # Scope validation
+        def validate_scopes
+          errors = []
+          
+          scopes_config.each do |scope_config|
+            scope_name = scope_config[:name]
+            scope_method = scope_config[:scope_method]
+            
+            # Check if scope method exists on model (skip :all)
+            if scope_name != :all && !model_class.respond_to?(scope_method)
+              errors << "Scope method '#{scope_method}' does not exist on #{model_class.name}"
+            end
+            
+            # Check for duplicate scope names
+            duplicate_count = scopes_config.count { |s| s[:name] == scope_name }
+            if duplicate_count > 1
+              errors << "Duplicate scope name '#{scope_name}' found"
+            end
+          end
+          
+          errors
+        end
+
+        def valid_scopes?
+          validate_scopes.empty?
+        end
+
+        # Scope management
+        def clear_scopes
+          self.scopes_config = []
+        end
+
+        def remove_scope(scope_name)
+          self.scopes_config = scopes_config.reject { |scope| scope[:name] == scope_name }
+        end
+
+        def total_scopes_count
+          scopes_config.count
+        end
+
+        def enabled_scope_counts_count
+          scopes_config.count { |scope| scope[:count] }
+        end
+
+        # Predefined scope helpers
+        def add_all_scope(label: "All", default: true)
+          scope(:all, label: label, scope: :all, default: default)
+        end
+
+        def add_recent_scope(days: 7, label: "Recent")
+          return unless model_class.column_names.include?('created_at')
+          
+          scope(:recent, 
+                label: label, 
+                scope: -> { where('created_at >= ?', days.days.ago) })
+        end
+
+        def add_published_scope(column: :published, label: "Published")
+          return unless model_class.column_names.include?(column.to_s)
+          
+          scope(:published, 
+                label: label, 
+                scope: -> { where(column => true) })
+        end
+
+        def add_unpublished_scope(column: :published, label: "Unpublished")
+          return unless model_class.column_names.include?(column.to_s)
+          
+          scope(:unpublished, 
+                label: label, 
+                scope: -> { where(column => [false, nil]) })
+        end
+      end
+    end
+  end
+end