easy-admin-rails 0.2.6 → 0.2.7

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

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

@@ -0,0 +1,46 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Section node for grouping content
+      class Section < BaseNode
+        def initialize(title = nil, attributes = {})
+          super(attributes)
+          @attributes[:title] = title
+          @attributes[:description] ||= nil
+          @attributes[:collapsible] ||= false
+          @attributes[:collapsed] ||= false
+          @attributes[:icon] ||= nil
+          @attributes[:css_class] ||= nil
+        end
+        
+        def title
+          @attributes[:title]
+        end
+        
+        def description
+          @attributes[:description]
+        end
+        
+        def collapsible?
+          @attributes[:collapsible]
+        end
+        
+        def collapsed?
+          @attributes[:collapsed]
+        end
+        
+        def icon
+          @attributes[:icon]
+        end
+        
+        def css_class
+          @attributes[:css_class]
+        end
+        
+        def section_id
+          "section-#{(title || 'untitled').parameterize}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Spacer node for adding vertical space
+      class Spacer < BaseNode
+        def initialize(attributes = {})
+          super
+          @attributes[:size] ||= 4 # Tailwind spacing size
+        end
+        
+        def size
+          @attributes[:size]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# Stub node classes - to be fully implemented
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Show page nodes
+      class DescriptionList < BaseNode; end
+      class Card < BaseNode
+        def initialize(title: nil, **attributes)
+          super(attributes)
+          @attributes[:title] = title
+        end
+      end
+      class MetricCard < BaseNode
+        def initialize(title: nil, label: nil, value: nil, **attributes)
+          super(attributes)
+          @attributes[:title] = title || label
+          @attributes[:value] = value
+        end
+      end
+      class ActionBar < BaseNode; end
+      class Panel < BaseNode
+        def initialize(title, **attributes)
+          super(attributes)
+          @attributes[:title] = title
+        end
+      end
+      class Badge < BaseNode
+        def initialize(text, **attributes)
+          super(attributes)
+          @attributes[:text] = text
+        end
+      end
+      class RelatedResources < BaseNode
+        def initialize(resource_name, **attributes)
+          super(attributes)
+          @attributes[:resource_name] = resource_name
+        end
+      end
+      class Action < BaseNode
+        def initialize(type, **attributes)
+          super(attributes)
+          @attributes[:type] = type
+        end
+      end
+      class Dropdown < BaseNode; end
+      
+      # Form page nodes
+      class Fieldset < BaseNode
+        def initialize(legend = nil, **attributes)
+          super(attributes)
+          @attributes[:legend] = legend
+        end
+      end
+      class FormActions < BaseNode; end
+      class InlineFields < BaseNode; end
+      class ConditionalFields < BaseNode; end
+      class NestedFields < BaseNode
+        def initialize(association, **attributes)
+          super(attributes)
+          @attributes[:association] = association
+        end
+      end
+      class HelpText < BaseNode
+        def initialize(text, **attributes)
+          super(attributes)
+          @attributes[:text] = text
+        end
+      end
+      class ErrorsSummary < BaseNode; end
+      class FormAction < BaseNode
+        def initialize(type, **attributes)
+          super(attributes)
+          @attributes[:type] = type
+        end
+      end
+      
+      # Additional nodes needed by DSL
+      class Content < BaseNode
+        def initialize(attributes = {}, block: nil)
+          @block = block
+          super(attributes)
+        end
+        
+        attr_reader :block
+      end
+      
+      class Row < BaseNode
+        def initialize(attributes = {})
+          super(attributes)
+        end
+      end
+      
+      class Column < BaseNode
+        def initialize(attributes = {})
+          super(attributes)
+        end
+      end
+      
+      class Heading < BaseNode
+        def initialize(text, attributes = {})
+          @text = text
+          super(attributes)
+        end
+        
+        attr_reader :text
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module EasyAdmin
+  module Layouts
+    module Nodes
+      # Individual tab within a tabs container
+      class Tab < BaseNode
+        def initialize(name, attributes = {})
+          super(attributes)
+          @attributes[:name] = name.to_s
+          @attributes[:label] ||= name.to_s.humanize
+          @attributes[:icon] ||= nil
+          @attributes[:badge] ||= nil
+        end
+        
+        def name
+          @attributes[:name]
+        end
+        
+        def label
+          @attributes[:label]
+        end
+        
+        def icon
+          @attributes[:icon]
+        end
+        
+        def badge
+          @attributes[:badge]
+        end
+        
+        def tab_id
+          "tab-#{name.parameterize}"
+        end
+        
+        def panel_id
+          "panel-#{name.parameterize}"
+        end
+      end
+    end
+  end
+end