easy-admin-rails 0.2.5 → 0.2.7

data/lib/easy_admin/field.rb

@@ -92,9 +92,9 @@ module EasyAdmin
 
         begin
           action_component_name.constantize
-        rescue NameError
+        rescue NameError => e
           # Fallback to base text component for the action
-          case action
+          fallback_class = case action
           when :index
             EasyAdmin::Fields::Index::TextComponent
           when :show
@@ -104,6 +104,7 @@ module EasyAdmin
           else
             EasyAdmin::Fields::Index::TextComponent
           end
+          fallback_class
         end
       end
     end

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

@@ -0,0 +1,245 @@
+module EasyAdmin
+  module Layouts
+    module Builders
+      # Base builder for constructing layout AST
+      class BaseLayoutBuilder
+        attr_reader :root_node, :resource_class
+        attr_accessor :current_container_stack
+        
+        def initialize(layout_type = :show, resource_class: nil)
+          @root_node = Nodes::Root.new(layout_type: layout_type)
+          @current_container_stack = [@root_node]
+          @resource_class = resource_class
+        end
+        
+        # Get current container for adding nodes
+        def current_container
+          @current_container_stack.last
+        end
+        
+        # Add node to current container
+        def add_node(node)
+          current_container.add_child(node)
+          node
+        end
+        
+        # Execute block with new container
+        def with_container(container_node, &block)
+          add_node(container_node)
+          @current_container_stack.push(container_node)
+          instance_exec(&block) if block_given?
+          @current_container_stack.pop
+          container_node
+        end
+        
+        # DSL Methods
+        
+        # Add tabs container
+        def tabs(type: :horizontal, **attributes, &block)
+          tabs_node = Nodes::Tabs.new(attributes.merge(type: type))
+          add_node(tabs_node)
+          
+          if block_given?
+            @current_container_stack.push(tabs_node)
+            tabs_builder = TabsBuilder.new(self, tabs_node)
+            tabs_builder.instance_exec(&block)
+            @current_container_stack.pop
+          end
+          
+          tabs_node
+        end
+        
+        # Add section
+        def section(title = nil, **attributes, &block)
+          section_node = Nodes::Section.new(title, attributes)
+          
+          if block_given?
+            with_container(section_node, &block)
+          else
+            add_node(section_node)
+          end
+          
+          section_node
+        end
+        
+        # Add grid layout
+        def grid(columns: 2, **attributes, &block)
+          grid_node = Nodes::Grid.new(attributes.merge(columns: columns))
+          
+          if block_given?
+            with_container(grid_node, &block)
+          else
+            add_node(grid_node)
+          end
+          
+          grid_node
+        end
+        
+        # Add field
+        def field(name, **options)
+          field_node = Nodes::FieldNode.new(name, options)
+          add_node(field_node)
+        end
+        
+        # Add multiple fields at once
+        def fields(*names, **common_options)
+          names.each do |name|
+            field(name, **common_options)
+          end
+        end
+        
+        # Render custom component
+        def render(component_class, **props)
+          render_node = Nodes::RenderNode.new(component_class, props)
+          add_node(render_node)
+        end
+        
+        # Add divider
+        def divider(**attributes)
+          add_node(Nodes::Divider.new(attributes))
+        end
+        
+        # Add spacer
+        def spacer(size: 4, **attributes)
+          add_node(Nodes::Spacer.new(attributes.merge(size: size)))
+        end
+        
+        # Build and return the AST
+        def build
+          @root_node
+        end
+        
+        # Allow custom DSL extensions
+        def method_missing(method, *args, &block)
+          # Check if it's a registered component type
+          if EasyAdmin::Layouts.registered_components.key?(method)
+            component_class = EasyAdmin::Layouts.registered_components[method]
+            render(component_class, *args)
+          else
+            super
+          end
+        end
+        
+        def respond_to_missing?(method, include_private = false)
+          EasyAdmin::Layouts.registered_components.key?(method) || 
+          field_method?(method) || 
+          super
+        end
+        
+        # Field DSL delegation methods - delegate to resource class
+        
+        def id_field(**options)
+          delegate_to_resource(:id_field, **options)
+          field(:id, type: :number, **options)
+        end
+
+        def text_field(name, **options)
+          delegate_to_resource(:text_field, name, **options)
+          field(name, type: :string, **options)
+        end
+
+        def textarea_field(name, **options)
+          delegate_to_resource(:textarea_field, name, **options)
+          field(name, type: :text, **options)
+        end
+
+        def number_field(name, **options)
+          delegate_to_resource(:number_field, name, **options)
+          field(name, type: :number, **options)
+        end
+
+        def email_field(name, **options)
+          delegate_to_resource(:email_field, name, **options)
+          field(name, type: :email, **options)
+        end
+
+        def date_field(name, **options)
+          delegate_to_resource(:date_field, name, **options)
+          field(name, type: :date, **options)
+        end
+
+        def datetime_field(name, **options)
+          delegate_to_resource(:datetime_field, name, **options)
+          field(name, type: :datetime, **options)
+        end
+
+        def boolean_field(name, **options)
+          delegate_to_resource(:boolean_field, name, **options)
+          field(name, type: :boolean, **options)
+        end
+
+        def select_field(name, **options)
+          delegate_to_resource(:select_field, name, **options)
+          field(name, type: :select, **options)
+        end
+
+        def belongs_to_field(name, **options)
+          delegate_to_resource(:belongs_to_field, name, **options)
+          field(name, type: :belongs_to, **options)
+        end
+
+        def has_many_field(name, **options)
+          delegate_to_resource(:has_many_field, name, **options)
+          field(name, type: :has_many, **options)
+        end
+
+        def file_field(name, **options)
+          delegate_to_resource(:file_field, name, **options)
+          field(name, type: :file, **options)
+        end
+
+        def json_field(name, **options)
+          delegate_to_resource(:json_field, name, **options)
+          field(name, type: :json, **options)
+        end
+
+        def password_field(name = :password, **options)
+          delegate_to_resource(:password_field, name, **options)
+          field(name, type: :password, **options)
+        end
+        
+        # Delegate content method calls 
+        def content(&block)
+          content_node = Nodes::Content.new(block: block)
+          add_node(content_node)
+        end
+        
+        private
+        
+        def field_method?(method)
+          method.to_s.end_with?('_field') && resource_class&.respond_to?(method)
+        end
+        
+        def delegate_to_resource(method, *args, **options)
+          if resource_class
+            resource_class.send(method, *args, **options)
+          else
+            raise "Resource class not available for field delegation"
+          end
+        end
+      end
+      
+      # Specialized builder for tabs
+      class TabsBuilder
+        def initialize(parent_builder, tabs_node)
+          @parent_builder = parent_builder
+          @tabs_node = tabs_node
+        end
+        
+        def tab(name, **attributes, &block)
+          tab_node = Nodes::Tab.new(name, attributes)
+          @tabs_node.add_child(tab_node)
+          
+          if block_given?
+            # Push tab as current container and execute block in parent builder context
+            @parent_builder.current_container_stack.push(tab_node)
+            @parent_builder.instance_exec(&block)
+            @parent_builder.current_container_stack.pop
+          end
+          
+          tab_node
+        end
+      end
+    end
+  end
+end

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