easy-admin-rails 0.2.6 → 0.2.7

data/lib/easy_admin/layouts/builders/form_layout_builder.rb

@@ -0,0 +1,208 @@
+module EasyAdmin
+  module Layouts
+    module Builders
+      # Builder specifically for form layouts
+      class FormLayoutBuilder < BaseLayoutBuilder
+        def initialize(resource_class: nil)
+          super(:form, resource_class: resource_class)
+        end
+        
+        # Form-specific DSL methods
+        
+        # Add fieldset for grouping form fields
+        def fieldset(legend = nil, **attributes, &block)
+          fieldset_node = Nodes::Fieldset.new(legend, attributes)
+          
+          if block_given?
+            with_container(fieldset_node, &block)
+          else
+            add_node(fieldset_node)
+          end
+          
+          fieldset_node
+        end
+        
+        # Add form actions (submit, cancel, etc.)
+        def form_actions(**attributes, &block)
+          actions_node = Nodes::FormActions.new(attributes)
+          add_node(actions_node)
+          
+          if block_given?
+            @current_container_stack.push(actions_node)
+            form_actions_builder = FormActionsBuilder.new(self, actions_node)
+            form_actions_builder.instance_exec(&block)
+            @current_container_stack.pop
+          end
+          
+          actions_node
+        end
+        
+        # Add inline fields (multiple fields in one row)
+        def inline_fields(**attributes, &block)
+          inline_node = Nodes::InlineFields.new(attributes)
+          
+          if block_given?
+            with_container(inline_node, &block)
+          else
+            add_node(inline_node)
+          end
+          
+          inline_node
+        end
+        
+        # Add conditional fields
+        def conditional_fields(condition:, **attributes, &block)
+          conditional_node = Nodes::ConditionalFields.new(
+            condition: condition,
+            **attributes
+          )
+          
+          if block_given?
+            with_container(conditional_node, &block)
+          else
+            add_node(conditional_node)
+          end
+          
+          conditional_node
+        end
+        
+        # Add nested fields for associations
+        def nested_fields(association, **attributes, &block)
+          nested_node = Nodes::NestedFields.new(
+            association,
+            attributes
+          )
+          
+          if block_given?
+            with_container(nested_node, &block)
+          else
+            add_node(nested_node)
+          end
+          
+          nested_node
+        end
+        
+        # Add help text
+        def help_text(text, **attributes)
+          help_node = Nodes::HelpText.new(text, attributes)
+          add_node(help_node)
+        end
+        
+        # Add form errors summary
+        def errors_summary(**attributes)
+          errors_node = Nodes::ErrorsSummary.new(attributes)
+          add_node(errors_node)
+        end
+        
+        # Override field method to include form-specific options
+        def field(name, **options)
+          # Set default form field options
+          options[:required] = true if options[:required].nil? && required_field?(name)
+          options[:readonly] = true if readonly_field?(name)
+          
+          super(name, **options)
+        end
+        
+        # Convenience methods for specific field types
+        def text_field(name, **options)
+          field(name, field_type: :text, **options)
+        end
+        
+        def email_field(name, **options)
+          field(name, field_type: :email, **options)
+        end
+        
+        def textarea_field(name, **options)
+          field(name, field_type: :textarea, **options)
+        end
+        
+        def boolean_field(name, **options)
+          field(name, field_type: :boolean, **options)
+        end
+        
+        def select_field(name, **options)
+          field(name, field_type: :select, **options)
+        end
+        
+        def has_many_field(name, **options)
+          field(name, field_type: :has_many, **options)
+        end
+        
+        def date_field(name, **options)
+          field(name, field_type: :date, **options)
+        end
+        
+        def datetime_field(name, **options)
+          field(name, field_type: :datetime, **options)
+        end
+        
+        def number_field(name, **options)
+          field(name, field_type: :number, **options)
+        end
+        
+        def password_field(name, **options)
+          field(name, field_type: :password, **options)
+        end
+        
+        private
+        
+        def required_field?(name)
+          # Check if field is required based on model validations
+          # This would need to be implemented based on your validation setup
+          false
+        end
+        
+        def readonly_field?(name)
+          # Check if field should be readonly
+          # This would need to be implemented based on your configuration
+          false
+        end
+      end
+      
+      # Builder for form actions
+      class FormActionsBuilder
+        def initialize(parent_builder)
+          @parent_builder = parent_builder
+        end
+        
+        def submit(text = "Save", **attributes)
+          submit_node = Nodes::FormAction.new(
+            :submit,
+            text: text,
+            **attributes
+          )
+          @parent_builder.add_node(submit_node)
+        end
+        
+        def cancel(text = "Cancel", href: :back, **attributes)
+          cancel_node = Nodes::FormAction.new(
+            :cancel,
+            text: text,
+            href: href,
+            **attributes
+          )
+          @parent_builder.add_node(cancel_node)
+        end
+        
+        def reset(text = "Reset", **attributes)
+          reset_node = Nodes::FormAction.new(
+            :reset,
+            text: text,
+            **attributes
+          )
+          @parent_builder.add_node(reset_node)
+        end
+        
+        def button(text, action:, **attributes)
+          button_node = Nodes::FormAction.new(
+            :button,
+            text: text,
+            action: action,
+            **attributes
+          )
+          @parent_builder.add_node(button_node)
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/builders/index_layout_builder.rb

@@ -0,0 +1,22 @@
+module EasyAdmin
+  module Layouts
+    module Builders
+      # IndexLayoutBuilder for constructing index page layouts
+      # Specialized builder for index table field configurations
+      class IndexLayoutBuilder < BaseLayoutBuilder
+        def initialize(resource_class: nil)
+          super(:index, resource_class: resource_class)
+        end
+        
+        # Simple field method for index - only accepts field name
+        # Configuration is extracted from already registered resource fields
+        def field(name, **options)
+          # Create a simple field node with just the name
+          # The actual field configuration will be looked up from resource fields_config
+          field_node = Nodes::FieldNode.new(name, options)
+          add_node(field_node)
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/builders/show_layout_builder.rb

@@ -0,0 +1,199 @@
+module EasyAdmin
+  module Layouts
+    module Builders
+      # Builder specifically for show page layouts
+      class ShowLayoutBuilder < BaseLayoutBuilder
+        def initialize(resource_class: nil)
+          super(:show, resource_class: resource_class)
+        end
+        
+        # Show-specific DSL methods
+        
+        # Add a description list for key-value pairs
+        def description_list(**attributes, &block)
+          dl_node = Nodes::DescriptionList.new(attributes)
+          
+          if block_given?
+            with_container(dl_node, &block)
+          else
+            add_node(dl_node)
+          end
+          
+          dl_node
+        end
+        
+        # Add a card component
+        def card(title: nil, **attributes, &block)
+          card_node = Nodes::Card.new(title: title, **attributes)
+          
+          if block_given?
+            with_container(card_node, &block)
+          else
+            add_node(card_node)
+          end
+          
+          card_node
+        end
+        
+        # Add a metric card
+        def metric(label:, value:, **attributes)
+          metric_node = Nodes::MetricCard.new(
+            label: label,
+            value: value,
+            **attributes
+          )
+          add_node(metric_node)
+        end
+        
+        # Add a metric card (accepts both label and title)
+        def metric_card(title: nil, label: nil, value: nil, **attributes)
+          metric_node = Nodes::MetricCard.new(
+            title: title,
+            label: label,
+            value: value,
+            **attributes
+          )
+          add_node(metric_node)
+        end
+        
+        # Add an action bar
+        def action_bar(**attributes, &block)
+          action_bar_node = Nodes::ActionBar.new(attributes)
+          add_node(action_bar_node)
+          
+          if block_given?
+            @current_container_stack.push(action_bar_node)
+            action_builder = ActionBarBuilder.new(self, action_bar_node)
+            action_builder.instance_exec(&block)
+            @current_container_stack.pop
+          end
+          
+          action_bar_node
+        end
+        
+        # Add a panel (collapsible section)
+        def panel(title, expanded: true, **attributes, &block)
+          panel_node = Nodes::Panel.new(
+            title,
+            attributes.merge(expanded: expanded)
+          )
+          
+          if block_given?
+            with_container(panel_node, &block)
+          else
+            add_node(panel_node)
+          end
+          
+          panel_node
+        end
+        
+        # Add badge
+        def badge(text, variant: :default, **attributes)
+          badge_node = Nodes::Badge.new(
+            text,
+            attributes.merge(variant: variant)
+          )
+          add_node(badge_node)
+        end
+        
+        # Add related resources section
+        def related(resource_name, **attributes, &block)
+          related_node = Nodes::RelatedResources.new(
+            resource_name,
+            attributes
+          )
+          
+          if block_given?
+            with_container(related_node, &block)
+          else
+            add_node(related_node)
+          end
+          
+          related_node
+        end
+        
+        # Add row layout
+        def row(**attributes, &block)
+          row_node = Nodes::Row.new(attributes)
+          
+          if block_given?
+            with_container(row_node, &block)
+          else
+            add_node(row_node)
+          end
+          
+          row_node
+        end
+        
+        # Add column layout
+        def column(**attributes, &block)
+          column_node = Nodes::Column.new(attributes)
+          
+          if block_given?
+            with_container(column_node, &block)
+          else
+            add_node(column_node)
+          end
+          
+          column_node
+        end
+        
+        # Add heading
+        def heading(text, level: 2, **attributes)
+          heading_node = Nodes::Heading.new(text, attributes.merge(level: level))
+          add_node(heading_node)
+        end
+        
+        # Add content block
+        def content(&block)
+          content_node = Nodes::Content.new(block: block)
+          add_node(content_node)
+        end
+      end
+      
+      # Builder for action bars
+      class ActionBarBuilder
+        def initialize(parent_builder, action_bar_node)
+          @parent_builder = parent_builder
+          @action_bar_node = action_bar_node
+        end
+        
+        def link(text, href:, **attributes)
+          action_node = Nodes::Action.new(
+            :link,
+            text: text,
+            href: href,
+            **attributes
+          )
+          @action_bar_node.add_child(action_node)
+        end
+        
+        def button(text, action:, **attributes)
+          action_node = Nodes::Action.new(
+            :button,
+            text: text,
+            action: action,
+            **attributes
+          )
+          @action_bar_node.add_child(action_node)
+        end
+        
+        def dropdown(text, **attributes, &block)
+          dropdown_node = Nodes::Dropdown.new(
+            text: text,
+            **attributes
+          )
+          @action_bar_node.add_child(dropdown_node)
+          
+          if block_given?
+            @parent_builder.current_container_stack.push(dropdown_node)
+            @parent_builder.instance_exec(&block)
+            @parent_builder.current_container_stack.pop
+          end
+          
+          dropdown_node
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/dsl.rb

@@ -0,0 +1,200 @@
+module EasyAdmin
+  module Layouts
+    # DSL module to be included in Resource classes
+    module DSL
+      extend ActiveSupport::Concern
+      
+      included do
+        class_attribute :show_layout_definition, default: nil
+        class_attribute :form_layout_definition, default: nil
+        class_attribute :index_layout_definition, default: nil
+      end
+      
+      class_methods do
+        # Define show page layout
+        def show(component_or_block = nil, &block)
+          if component_or_block.is_a?(Class)
+            # Direct component mode
+            self.show_layout_definition = [:component, component_or_block]
+          elsif block_given?
+            # DSL mode - build AST
+            builder = Builders::ShowLayoutBuilder.new(resource_class: self)
+            builder.instance_exec(&block)
+            self.show_layout_definition = [:ast, builder.build]
+          else
+            # Return current definition
+            self.show_layout_definition
+          end
+        end
+        
+        # Define form page layout
+        def form(component_or_block = nil, &block)
+          if component_or_block.is_a?(Class)
+            # Direct component mode
+            self.form_layout_definition = [:component, component_or_block]
+          elsif block_given?
+            # DSL mode - build AST
+            builder = Builders::FormLayoutBuilder.new(resource_class: self)
+            builder.instance_exec(&block)
+            self.form_layout_definition = [:ast, builder.build]
+          else
+            # Return current definition
+            self.form_layout_definition
+          end
+        end
+        
+        # Define index page layout
+        def index(component_or_block = nil, &block)
+          if component_or_block.is_a?(Class)
+            # Direct component mode
+            self.index_layout_definition = [:component, component_or_block]
+          elsif block_given?
+            # DSL mode - build AST
+            builder = Builders::IndexLayoutBuilder.new(resource_class: self)
+            builder.instance_exec(&block)
+            self.index_layout_definition = [:ast, builder.build]
+          else
+            # Return current definition
+            self.index_layout_definition
+          end
+        end
+        
+        # Check if custom show layout is defined
+        def has_custom_show_layout?
+          !show_layout_definition.nil?
+        end
+        
+        # Check if custom form layout is defined
+        def has_custom_form_layout?
+          !form_layout_definition.nil?
+        end
+        
+        # Check if custom index layout is defined
+        def has_custom_index_layout?
+          !index_layout_definition.nil?
+        end
+        
+        # Check if form layout contains tabs
+        def has_form_tabs?
+          return false unless has_custom_form_layout?
+          
+          # Build the form layout to check if it contains tabs
+          begin
+            builder = Builders::FormLayoutBuilder.new(resource_class: self)
+            builder.instance_exec(&form_layout_content)
+            root_node = builder.build
+            
+            # Check if the AST contains any tabs nodes
+            contains_tabs_node?(root_node)
+          rescue => e
+            false
+          end
+        end
+        
+        # Get show layout type
+        def show_layout_type
+          return nil unless show_layout_definition
+          show_layout_definition[0]
+        end
+        
+        # Get form layout type
+        def form_layout_type
+          return nil unless form_layout_definition
+          form_layout_definition[0]
+        end
+        
+        # Get show layout content
+        def show_layout_content
+          return nil unless show_layout_definition
+          show_layout_definition[1]
+        end
+        
+        # Get form layout content
+        def form_layout_content
+          return nil unless form_layout_definition
+          form_layout_definition[1]
+        end
+        
+        # Get index layout type
+        def index_layout_type
+          return nil unless index_layout_definition
+          index_layout_definition[0]
+        end
+        
+        # Get index layout content
+        def index_layout_content
+          return nil unless index_layout_definition
+          index_layout_definition[1]
+        end
+        
+        # Reset layouts
+        def reset_layouts!
+          self.show_layout_definition = nil
+          self.form_layout_definition = nil
+          self.index_layout_definition = nil
+        end
+        
+        # Generate default show layout from fields
+        def generate_default_show_layout
+          builder = Builders::ShowLayoutBuilder.new(resource_class: self)
+          
+          # Group fields by category or just show all
+          if fields_config.any?
+            builder.card(title: resource_title) do
+              builder.grid(columns: 2) do
+                fields_config.each do |field_config|
+                  next if field_config[:show] == false
+                  builder.field(field_config[:name], **field_config.except(:name))
+                end
+              end
+            end
+          end
+          
+          [:ast, builder.build]
+        end
+        
+        # Generate default form layout from fields
+        def generate_default_form_layout
+          builder = Builders::FormLayoutBuilder.new(resource_class: self)
+          
+          if fields_config.any?
+            # Group editable fields
+            editable_fields = fields_config.reject { |f| f[:readonly] || f[:form] == false }
+            
+            if editable_fields.any?
+              builder.section("Details") do
+                editable_fields.each do |field_config|
+                  builder.field(field_config[:name], **field_config.except(:name))
+                end
+              end
+            end
+            
+            builder.form_actions do
+              builder.submit
+              builder.cancel
+            end
+          end
+          
+          [:ast, builder.build]
+        end
+        
+        private
+        
+        # Recursively check if AST contains tabs nodes
+        def contains_tabs_node?(node)
+          return false unless node
+          
+          # Check if current node is a tabs node
+          return true if node.is_a?(EasyAdmin::Layouts::Nodes::Tabs)
+          
+          # Check children recursively
+          if node.respond_to?(:children) && node.children
+            node.children.any? { |child| contains_tabs_node?(child) }
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end