easy-admin-rails 0.2.5 → 0.2.7

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

data/lib/easy_admin/layouts/layout_context.rb

@@ -0,0 +1,189 @@
+module EasyAdmin
+  module Layouts
+    # Context object for safe data passing through layout rendering
+    class LayoutContext
+      attr_reader :record, :resource_class, :current_user, :view_context, :request_context
+      attr_accessor :form_builder
+      
+      # Alias for form_builder to match expected API
+      def form
+        @form_builder
+      end
+      
+      def initialize(record: nil, resource_class: nil, current_user: nil, view_context: nil, form_builder: nil, request_context: {})
+        @record = record
+        @resource_class = resource_class
+        @current_user = current_user
+        @view_context = view_context
+        @form_builder = form_builder
+        @request_context = request_context
+        @data = {} # Custom data storage
+      end
+      
+      # Store custom data
+      def set(key, value)
+        @data[key.to_sym] = value
+      end
+      
+      # Retrieve custom data
+      def get(key)
+        @data[key.to_sym]
+      end
+      
+      # Check if custom data exists
+      def has?(key)
+        @data.key?(key.to_sym)
+      end
+      
+      # Merge additional context
+      def merge(additional_context)
+        additional_context.each do |key, value|
+          set(key, value)
+        end
+        self
+      end
+      
+      # Create a child context with additional data
+      def with(additional_context = {})
+        child = self.class.new(
+          record: @record,
+          resource_class: @resource_class,
+          current_user: @current_user,
+          view_context: @view_context,
+          form_builder: @form_builder,
+          request_context: @request_context
+        )
+        
+        # Copy parent data
+        @data.each { |k, v| child.set(k, v) }
+        
+        # Add new data
+        additional_context.each { |k, v| child.set(k, v) }
+        
+        child
+      end
+      
+      # Safe evaluation context for conditions
+      def instance_exec(&block)
+        CleanRoom.new(self).instance_exec(&block)
+      end
+      
+      # Check if we're in a form context
+      def form_context?
+        !@form_builder.nil?
+      end
+      
+      # Check if we're in a show context
+      def show_context?
+        @form_builder.nil? && @record.present?
+      end
+      
+      # Get current action from request context
+      def current_action
+        @request_context[:action]
+      end
+      
+      # Check if current user can perform action
+      def can?(action, subject = nil)
+        return false unless @current_user
+        
+        # If ActionPolicy is available, use it
+        if defined?(ActionPolicy) && @view_context
+          @view_context.allowed_to?(action, subject || @record)
+        else
+          # Fallback to basic checks
+          true
+        end
+      rescue
+        false
+      end
+      
+      # Access helpers from view context
+      def helpers
+        @view_context
+      end
+      
+      # Method missing to delegate to view_context helpers
+      def method_missing(method, *args, &block)
+        if @view_context && @view_context.respond_to?(method)
+          @view_context.send(method, *args, &block)
+        else
+          super
+        end
+      end
+      
+      def respond_to_missing?(method, include_private = false)
+        (@view_context && @view_context.respond_to?(method)) || super
+      end
+      
+      # Clean room for safe evaluation
+      class CleanRoom < BasicObject
+        def initialize(context)
+          @context = context
+        end
+        
+        def record
+          @context.record
+        end
+        
+        def current_user
+          @context.current_user
+        end
+        
+        def resource_class
+          @context.resource_class
+        end
+        
+        def form_builder
+          @context.form_builder
+        end
+        
+        def form
+          @context.form
+        end
+        
+        def can?(action, subject = nil)
+          @context.can?(action, subject)
+        end
+        
+        def form_context?
+          @context.form_context?
+        end
+        
+        def show_context?
+          @context.show_context?
+        end
+        
+        def get(key)
+          @context.get(key)
+        end
+        
+        def has?(key)
+          @context.has?(key)
+        end
+        
+        # Allow render method for components
+        def render(component)
+          component
+        end
+        
+        # Allow safe navigation and HTML helpers
+        def method_missing(method, *args, &block)
+          if [:record, :current_user, :resource_class].include?(method)
+            @context.public_send(method)
+          elsif @context.view_context && @context.view_context.respond_to?(method)
+            # Allow HTML helper methods from view context
+            @context.view_context.send(method, *args, &block)
+          else
+            ::Kernel.raise ::NoMethodError, "undefined method `#{method}' in layout context"
+          end
+        end
+        
+        def respond_to_missing?(method, include_private = false)
+          [:record, :current_user, :resource_class, :form_builder, :form, :can?, :form_context?, :show_context?, :get, :has?, :render].include?(method) ||
+          (@context.view_context && @context.view_context.respond_to?(method))
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/base_node.rb

@@ -0,0 +1,88 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Base class for all layout AST nodes
+      class BaseNode
+        attr_reader :attributes, :children, :visible_if, :metadata
+        
+        def initialize(attributes = {}, &block)
+          @attributes = attributes.dup
+          @visible_if = @attributes.delete(:visible_if)
+          @metadata = @attributes.delete(:metadata) || {}
+          @children = []
+        end
+        
+        # Check if node should be visible based on context
+        def visible?(context)
+          return true unless visible_if
+          
+          case visible_if
+          when Proc
+            # Evaluate in safe context
+            context.instance_exec(&visible_if)
+          when Symbol
+            # Call method on record
+            context.record.public_send(visible_if) if context.record.respond_to?(visible_if)
+          when String
+            # Evaluate as method chain (e.g., "record.published?")
+            eval_method_chain(context, visible_if)
+          else
+            # Direct boolean value
+            !!visible_if
+          end
+        rescue => e
+          true # Default to visible on error
+        end
+        
+        # Accept visitor for traversal
+        def accept(visitor, context)
+          visitor.visit(self, context) if visible?(context)
+        end
+        
+        # Add child node
+        def add_child(node)
+          @children << node if node.is_a?(BaseNode)
+        end
+        
+        # Get attribute value
+        def [](key)
+          @attributes[key]
+        end
+        
+        # Set attribute value
+        def []=(key, value)
+          @attributes[key] = value
+        end
+        
+        # Check if node has children
+        def children?
+          @children.any?
+        end
+        
+        # Node type for identification
+        def node_type
+          self.class.name.demodulize.underscore.to_sym
+        end
+        
+        private
+        
+        def eval_method_chain(context, chain)
+          parts = chain.split('.')
+          object = context
+          
+          parts.each do |part|
+            if part.end_with?('?') || part.end_with?('!')
+              method = part.to_sym
+            else
+              method = part.to_sym
+            end
+            
+            object = object.public_send(method) if object.respond_to?(method)
+          end
+          
+          object
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/divider.rb

@@ -0,0 +1,27 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Divider node for visual separation
+      class Divider < BaseNode
+        def initialize(attributes = {})
+          super
+          @attributes[:style] ||= :solid # solid, dashed, dotted
+          @attributes[:margin] ||= 4 # Tailwind margin size
+          @attributes[:color] ||= 'gray-200'
+        end
+        
+        def style
+          @attributes[:style]
+        end
+        
+        def margin
+          @attributes[:margin]
+        end
+        
+        def color
+          @attributes[:color]
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/field_node.rb

@@ -0,0 +1,57 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Node representing a field to be rendered
+      class FieldNode < BaseNode
+        def initialize(name, attributes = {})
+          super(attributes)
+          @field_name = name.to_sym
+          @attributes[:as] ||= nil # Field type override
+          @attributes[:label] ||= nil # Custom label
+          @attributes[:readonly] ||= false
+          @attributes[:required] ||= false
+          @attributes[:hint] ||= nil
+          @attributes[:placeholder] ||= nil
+          @attributes[:wrapper_class] ||= nil
+        end
+        
+        def field_name
+          @field_name
+        end
+        
+        def field_type
+          @attributes[:as]
+        end
+        
+        def label
+          @attributes[:label]
+        end
+        
+        def readonly?
+          @attributes[:readonly]
+        end
+        
+        def required?
+          @attributes[:required]
+        end
+        
+        def hint
+          @attributes[:hint]
+        end
+        
+        def placeholder
+          @attributes[:placeholder]
+        end
+        
+        def wrapper_class
+          @attributes[:wrapper_class]
+        end
+        
+        # Get all field options for rendering
+        def field_options
+          @attributes.except(:visible_if, :metadata)
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/grid.rb

@@ -0,0 +1,60 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Grid layout node for responsive column layouts
+      class Grid < BaseNode
+        def initialize(attributes = {})
+          super
+          @attributes[:columns] ||= 2
+          @attributes[:gap] ||= 4 # Tailwind gap size
+          @attributes[:responsive] ||= true
+          @attributes[:css_class] ||= nil
+        end
+        
+        def columns
+          @attributes[:columns]
+        end
+        
+        def gap
+          @attributes[:gap]
+        end
+        
+        def responsive?
+          @attributes[:responsive]
+        end
+        
+        def css_class
+          @attributes[:css_class]
+        end
+        
+        # Generate Tailwind grid classes
+        def grid_classes
+          classes = []
+          
+          if responsive?
+            # Responsive grid classes
+            case columns
+            when 1
+              classes << "grid-cols-1"
+            when 2
+              classes << "grid-cols-1 md:grid-cols-2"
+            when 3
+              classes << "grid-cols-1 md:grid-cols-2 lg:grid-cols-3"
+            when 4
+              classes << "grid-cols-1 md:grid-cols-2 lg:grid-cols-4"
+            else
+              classes << "grid-cols-#{columns}"
+            end
+          else
+            classes << "grid-cols-#{columns}"
+          end
+          
+          classes << "gap-#{gap}"
+          classes << css_class if css_class
+          
+          classes.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/render_node.rb

@@ -0,0 +1,41 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Node for rendering custom components
+      class RenderNode < BaseNode
+        def initialize(component_class, props = {})
+          attributes = props.dup
+          super(attributes)
+          @component_class = component_class
+          @props = attributes
+        end
+        
+        def component_class
+          @component_class
+        end
+        
+        def props
+          @props
+        end
+        
+        # Instantiate the component with props and context
+        def build_component(context)
+          # Merge context into props if component accepts it
+          component_props = @props.dup
+          
+          # Add standard context props if not already present
+          component_props[:record] ||= context.record if context.respond_to?(:record)
+          component_props[:resource_class] ||= context.resource_class if context.respond_to?(:resource_class)
+          component_props[:current_user] ||= context.current_user if context.respond_to?(:current_user)
+          
+          # Handle form builder for form contexts
+          if context.respond_to?(:form_builder) && context.form_builder
+            component_props[:form] ||= context.form_builder
+          end
+          
+          @component_class.new(**component_props)
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/layouts/nodes/root.rb

@@ -0,0 +1,25 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Root node of the layout AST
+      class Root < BaseNode
+        def initialize(attributes = {})
+          super
+          @attributes[:layout_type] = attributes[:layout_type] || :show
+        end
+        
+        def layout_type
+          @attributes[:layout_type]
+        end
+        
+        def form_layout?
+          layout_type == :form
+        end
+        
+        def show_layout?
+          layout_type == :show
+        end
+      end
+    end
+  end
+end