easy-admin-rails 0.1.0

data/lib/easy_admin/resource.rb

@@ -0,0 +1,806 @@
+module EasyAdmin
+  class Resource
+    class_attribute :model_class_name, :resource_name, :fields_config, :form_tabs_config, :show_layout_config, :scopes_config, :pagination_config, :includes_config, :batch_actions_config, :batch_actions_enabled, :row_actions_config
+    
+    def self.inherited(subclass)
+      super
+      # Automatically set model class from resource name
+      subclass.resource_name = subclass.name.demodulize.gsub(/Resource$/, '')
+      subclass.model_class_name = subclass.resource_name
+      subclass.fields_config = []
+      subclass.form_tabs_config = []
+      subclass.show_layout_config = []
+      subclass.scopes_config = []
+      subclass.pagination_config = {
+        type: :standard,
+        per_page: 20,
+        max_per_page: 100
+      }
+      subclass.includes_config = {
+        index: [],
+        show: [],
+        form: []
+      }
+      subclass.batch_actions_config = []
+      subclass.batch_actions_enabled = false
+      
+      # Register the resource
+      EasyAdmin::ResourceRegistry.register(subclass)
+    end
+
+    # DSL for defining fields
+    def self.field(name, type = :string, **options)
+      self.fields_config += [{
+        name: name,
+        type: type,
+        label: options[:label] || name.to_s.humanize,
+        sortable: options.fetch(:sortable, true),
+        searchable: options.fetch(:searchable, false),
+        filterable: options.fetch(:filterable, false),
+        required: options.fetch(:required, false),
+        readonly: options.fetch(:readonly, false),
+        format: options[:format],
+        options: options[:options], # for select fields
+        multiple: options[:multiple], # for select fields
+        placeholder: options[:placeholder], # for select fields
+        suggest: options[:suggest], # for dynamic option loading
+        display_method: options[:display_method], # for association fields
+        help_text: options[:help_text],
+        editable: options[:editable]
+      }]
+    end
+
+    # Convenience methods for common field types
+    def self.id_field(**options)
+      field(:id, :number, readonly: true, **options)
+    end
+
+    def self.text_field(name, **options)
+      field(name, :string, **options)
+    end
+
+    def self.textarea_field(name, **options)
+      field(name, :text, **options)
+    end
+
+    def self.number_field(name, **options)
+      field(name, :number, **options)
+    end
+
+    def self.email_field(name, **options)
+      field(name, :email, **options)
+    end
+
+    def self.date_field(name, **options)
+      field(name, :date, **options)
+    end
+
+    def self.datetime_field(name, **options)
+      field(name, :datetime, **options)
+    end
+
+    def self.boolean_field(name, **options)
+      field(name, :boolean, **options)
+    end
+
+    def self.select_field(name, options:, **other_options)
+      field(name, :select, options: options, **other_options)
+    end
+
+    def self.belongs_to_field(name, **options)
+      field(name, :belongs_to, **options)
+    end
+
+    def self.has_many_field(name, **options)
+      field(name, :has_many, **options)
+    end
+
+    def self.file_field(name, **options)
+      field(name, :file, **options)
+    end
+
+    def self.json_field(name, **options)
+      field(name, :json, **options)
+    end
+
+    # Scope definition
+    def self.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)
+      }
+      
+      self.scopes_config += [scope_config]
+    end
+
+    # Pagination configuration
+    def self.pagination(type: :standard, per_page: 20, **options)
+      self.pagination_config = {
+        type: type,
+        per_page: per_page,
+        max_per_page: options[:max_per_page] || 100,
+        infinite_scroll: options[:infinite_scroll] || false,
+        countless: options[:countless] || false
+      }
+    end
+
+    # Configure eager loading for associations
+    def self.includes(associations, actions: [:index, :show, :form])
+      actions = Array(actions)
+      
+      actions.each do |action|
+        if self.includes_config.key?(action)
+          self.includes_config = self.includes_config.merge(
+            action => Array(associations)
+          )
+        end
+      end
+    end
+
+    # Convenience methods for pagination configuration
+    def self.per_page(count)
+      pagination(per_page: count)
+    end
+
+    def self.infinite_scroll(**options)
+      pagination(type: :infinite_scroll, infinite_scroll: true, **options)
+    end
+
+    def self.countless_pagination(**options)
+      pagination(countless: true, **options)
+    end
+
+    # Get the associated model class
+    def self.model_class
+      model_class_name.constantize
+    rescue NameError
+      raise "Model class #{model_class_name} not found. Make sure the model exists."
+    end
+
+    # Get resource title/name
+    def self.title
+      resource_name.humanize.pluralize
+    end
+
+    def self.singular_title
+      resource_name.humanize
+    end
+
+    # Get fields for different contexts
+    def self.index_fields
+      fields_config.select { |field| ![:text, :has_many, :file].include?(field[:type]) }
+    end
+
+    def self.sortable_fields
+      fields_config.select { |field| field[:sortable] }
+    end
+
+    def self.filterable_fields
+      fields_config.select { |field| field[:filterable] }
+    end
+
+    def self.show_fields
+      fields_config
+    end
+
+    def self.form_fields
+      if form_tabs_config.any?
+        # If tabs are configured, return fields from all tabs
+        form_tabs_config.flat_map { |tab| tab[:fields] }.reject { |field| field[:readonly] }
+      else
+        # Default behavior: return all non-readonly fields
+        fields_config.reject { |field| field[:readonly] }
+      end
+    end
+
+    def self.form_tabs
+      form_tabs_config
+    end
+
+    def self.has_form_tabs?
+      form_tabs_config.any?
+    end
+
+    # DSL for defining form with tabs
+    def self.form(&block)
+      form_builder = FormBuilder.new(self)
+      form_builder.instance_eval(&block)
+    end
+
+    # DSL for defining show layout
+    def self.show(&block)
+      show_builder = ShowBuilder.new(self)
+      show_builder.instance_eval(&block)
+    end
+
+    def self.show_layout
+      show_layout_config
+    end
+
+    def self.has_show_layout?
+      show_layout_config.any?
+    end
+
+    def self.scopes
+      scopes_config
+    end
+
+    def self.has_scopes?
+      scopes_config.any?
+    end
+
+    def self.default_scope
+      scopes_config.find { |scope| scope[:default] } || scopes_config.first
+    end
+
+    # Pagination helper methods
+    def self.items_per_page
+      pagination_config[:per_page]
+    end
+
+    def self.max_items_per_page
+      pagination_config[:max_per_page]
+    end
+
+    def self.pagination_type
+      pagination_config[:type]
+    end
+
+    def self.infinite_scroll_enabled?
+      pagination_config[:infinite_scroll]
+    end
+
+    def self.countless_enabled?
+      pagination_config[:countless]
+    end
+
+    # Includes configuration helpers
+    def self.index_includes
+      includes_config[:index] || []
+    end
+
+    def self.show_includes
+      includes_config[:show] || []
+    end
+
+    def self.form_includes
+      includes_config[:form] || []
+    end
+
+    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.form_tabs_config << tab_config
+
+        instance_eval(&block) if block_given?
+        @current_tab = nil
+      end
+
+      # Field definition methods within tabs
+      def field(name, type = :string, **options)
+        field_config = {
+          name: name,
+          type: type,
+          label: options[:label] || name.to_s.humanize,
+          sortable: options.fetch(:sortable, true),
+          searchable: options.fetch(:searchable, false),
+          filterable: options.fetch(:filterable, false),
+          required: options.fetch(:required, false),
+          readonly: options.fetch(:readonly, false),
+          format: options[:format],
+          options: options[:options],
+          multiple: options[:multiple],
+          placeholder: options[:placeholder],
+          help_text: options[:help_text],
+          editable: options[:editable]
+        }
+
+        if @current_tab
+          @current_tab[:fields] << field_config
+        end
+
+        # Also add to main fields_config for compatibility
+        @resource_class.fields_config << field_config unless @resource_class.fields_config.any? { |f| f[:name] == name }
+      end
+
+      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
+    end
+
+    class ShowBuilder
+      PREDEFINED_COLORS = %w[primary secondary success danger warning info light dark white transparent].freeze
+      COLUMN_SIZES = [1, 2, 3, 4, 6, 8, 12].freeze
+      SPACING_OPTIONS = %w[none small medium large].freeze
+      PADDING_OPTIONS = %w[none small medium large].freeze
+      HEADING_SIZES = %w[small medium large].freeze
+      DIVIDER_STYLES = %w[default dashed dotted thick].freeze
+      SHADOW_OPTIONS = %w[none small medium large].freeze
+      
+      def initialize(resource_class)
+        @resource_class = resource_class
+        @context_stack = []
+        @current_row = nil
+        @current_column = nil
+        @current_card = nil
+        @current_tab_container = nil
+        @current_tab = nil
+      end
+
+      # Layout methods
+      def row(columns: 1, spacing: "medium", &block)
+        validate_spacing!(spacing)
+        
+        row_config = {
+          type: :row,
+          columns_count: columns,
+          spacing: spacing,
+          columns: []
+        }
+
+        # Save current context
+        push_context
+        @current_row = row_config
+        
+        # Add to parent context
+        if @current_column
+          @current_column[:elements] << row_config
+        else
+          @resource_class.show_layout_config << row_config
+        end
+
+        instance_eval(&block) if block_given?
+        
+        # Restore context
+        pop_context
+      end
+
+      def column(size: nil, &block)
+        raise "column must be called within a row block" unless @current_row
+        
+        # Auto-calculate size if not provided
+        calculated_size = size || (12 / [@current_row[:columns_count], 1].max)
+        validate_column_size!(calculated_size)
+
+        column_config = {
+          type: :column,
+          size: calculated_size,
+          elements: []
+        }
+
+        # Save current context
+        push_context
+        @current_column = column_config
+        @current_row[:columns] << column_config
+
+        instance_eval(&block) if block_given?
+        
+        # Restore context
+        pop_context
+      end
+
+      # Card methods
+      def card(title: nil, color: "light", padding: "medium", shadow: "small", &block)
+        raise "card must be called within a column block" unless @current_column
+        validate_color!(color)
+        validate_padding!(padding)
+        validate_shadow!(shadow)
+
+        card_config = {
+          type: :card,
+          title: title,
+          color: color,
+          padding: padding,
+          shadow: shadow,
+          elements: []
+        }
+
+        # Save current context
+        push_context
+        @current_card = card_config
+        @current_column[:elements] << card_config
+
+        instance_eval(&block) if block_given?
+        
+        # Restore context
+        pop_context
+      end
+
+      def metric_card(title:, value:, color: "primary", icon: nil, trend: nil)
+        raise "metric_card must be called within a column block" unless @current_column
+        validate_color!(color)
+
+        metric_config = {
+          type: :metric_card,
+          title: title,
+          value: value,
+          icon: icon,
+          color: color,
+          trend: trend
+        }
+
+        @current_column[:elements] << metric_config
+      end
+
+      def chart_card(title:, chart_type:, **options, &block)
+        raise "chart_card must be called within a column block" unless @current_column
+
+        chart_config = {
+          type: :chart_card,
+          title: title,
+          chart_type: chart_type, # :line, :bar, :pie, :donut, :area
+          height: options[:height] || 350,
+          data_source: options[:data_source],
+          css_classes: options[:class] || "card",
+          config: {}
+        }
+
+        if block_given?
+          chart_builder = ChartBuilder.new
+          chart_builder.instance_eval(&block)
+          chart_config[:config] = chart_builder.config
+        end
+
+        @current_column[:elements] << chart_config
+      end
+
+      # Tab methods
+      def tabs(**options, &block)
+        container = @current_card || @current_column
+        raise "tabs must be called within a card or column block" unless container
+
+        tabs_config = {
+          type: :tabs,
+          css_classes: options[:class] || "tabs-menu",
+          tabs: []
+        }
+
+        # Save current context
+        push_context
+        @current_tab_container = tabs_config
+        container[:elements] << tabs_config
+
+        instance_eval(&block) if block_given?
+        
+        # Restore context
+        pop_context
+      end
+
+      def tab(name, **options, &block)
+        raise "tab must be called within a tabs block" unless @current_tab_container
+
+        tab_config = {
+          name: name,
+          label: options[:label] || name,
+          icon: options[:icon],
+          active: options[:active] || false,
+          elements: []
+        }
+
+        # Save current context
+        push_context
+        @current_tab = tab_config
+        @current_tab_container[:tabs] << tab_config
+
+        instance_eval(&block) if block_given?
+        
+        # Restore context
+        pop_context
+      end
+
+      # Field display methods
+      def field(name, **options)
+        container = @current_tab || @current_card || @current_column
+        raise "field must be called within a tab, card, or column block" unless container
+
+        # Allow hiding labels with label: false
+        label_value = if options.key?(:label) && options[:label] == false
+                       nil
+                     else
+                       options[:label] || name.to_s.humanize
+                     end
+
+        field_config = {
+          type: :field,
+          name: name,
+          label: label_value,
+          field_type: options[:field_type] || :default,
+          format: options[:format],
+          css_classes: options[:class],
+          show_label: options.fetch(:show_label, true)
+        }
+
+        container[:elements] << field_config
+      end
+
+      def fields(*field_names, **options)
+        field_names.each do |name|
+          field(name, **options)
+        end
+      end
+
+      # Content methods
+      def content(html = nil, **options, &block)
+        container = @current_tab || @current_card || @current_column
+        raise "content must be called within a tab, card, or column block" unless container
+
+        content_config = {
+          type: :content,
+          html: html,
+          css_classes: options[:class],
+          block: block
+        }
+
+        container[:elements] << content_config
+      end
+
+      def heading(text, level: 2, size: "medium")
+        container = @current_tab || @current_card || @current_column
+        raise "heading must be called within a tab, card, or column block" unless container
+        
+        validate_heading_level!(level)
+        validate_heading_size!(size)
+
+        heading_config = {
+          type: :heading,
+          text: text,
+          level: level,
+          size: size
+        }
+
+        container[:elements] << heading_config
+      end
+
+      def divider(style: "default")
+        container = @current_tab || @current_card || @current_column
+        raise "divider must be called within a tab, card, or column block" unless container
+        
+        validate_divider_style!(style)
+
+        divider_config = {
+          type: :divider,
+          style: style
+        }
+
+        container[:elements] << divider_config
+      end
+
+      private
+
+      def validate_color!(color)
+        return if PREDEFINED_COLORS.include?(color.to_s)
+        raise ArgumentError, "Invalid color '#{color}'. Available colors: #{PREDEFINED_COLORS.join(', ')}"
+      end
+
+      def validate_column_size!(size)
+        return if COLUMN_SIZES.include?(size)
+        raise ArgumentError, "Invalid column size '#{size}'. Available sizes: #{COLUMN_SIZES.join(', ')}"
+      end
+
+      def validate_spacing!(spacing)
+        return if SPACING_OPTIONS.include?(spacing.to_s)
+        raise ArgumentError, "Invalid spacing '#{spacing}'. Available options: #{SPACING_OPTIONS.join(', ')}"
+      end
+      
+      def validate_padding!(padding)
+        return if PADDING_OPTIONS.include?(padding.to_s)
+        raise ArgumentError, "Invalid padding '#{padding}'. Available options: #{PADDING_OPTIONS.join(', ')}"
+      end
+      
+      def validate_shadow!(shadow)
+        return if SHADOW_OPTIONS.include?(shadow.to_s)
+        raise ArgumentError, "Invalid shadow '#{shadow}'. Available options: #{SHADOW_OPTIONS.join(', ')}"
+      end
+
+      def validate_heading_level!(level)
+        return if (1..6).include?(level)
+        raise ArgumentError, "Invalid heading level '#{level}'. Must be between 1 and 6"
+      end
+
+      def validate_heading_size!(size)
+        return if HEADING_SIZES.include?(size.to_s)
+        raise ArgumentError, "Invalid heading size '#{size}'. Available sizes: #{HEADING_SIZES.join(', ')}"
+      end
+
+      def validate_divider_style!(style)
+        return if DIVIDER_STYLES.include?(style.to_s)
+        raise ArgumentError, "Invalid divider style '#{style}'. Available styles: #{DIVIDER_STYLES.join(', ')}"
+      end
+
+      def push_context
+        @context_stack.push({
+          row: @current_row,
+          column: @current_column,
+          card: @current_card,
+          tab_container: @current_tab_container,
+          tab: @current_tab
+        })
+      end
+
+      def pop_context
+        if @context_stack.any?
+          context = @context_stack.pop
+          @current_row = context[:row]
+          @current_column = context[:column]
+          @current_card = context[:card]
+          @current_tab_container = context[:tab_container]
+          @current_tab = context[:tab]
+        else
+          @current_row = nil
+          @current_column = nil
+          @current_card = nil
+          @current_tab_container = nil
+          @current_tab = nil
+        end
+      end
+    end
+
+    class ChartBuilder
+      attr_reader :config
+
+      def initialize
+        @config = {}
+      end
+
+      def series(data)
+        @config[:series] = data
+      end
+
+      def categories(data)
+        @config[:categories] = data
+      end
+
+      def colors(data)
+        @config[:colors] = data
+      end
+
+      def title(text)
+        @config[:title] = text
+      end
+
+      def subtitle(text)
+        @config[:subtitle] = text
+      end
+    end
+
+    # Query scopes
+    def self.all_records(sort_field: nil, sort_direction: 'asc')
+      records = model_class.all
+      
+      if sort_field.present? && sortable_fields.any? { |f| f[:name].to_s == sort_field.to_s }
+        records = records.order("#{sort_field} #{sort_direction}")
+      end
+      
+      records
+    end
+
+    def self.find_record(id)
+      model_class.find(id)
+    end
+
+    def self.search_records(query, sort_field: nil, sort_direction: 'asc', records: nil)
+      records ||= model_class.all
+      searchable_fields = fields_config.select { |field| field[:searchable] }
+      
+      if searchable_fields.any? && query.present?
+        conditions = searchable_fields.map do |field|
+          "#{field[:name]} ILIKE ?"
+        end.join(' OR ')
+
+        values = Array.new(searchable_fields.length, "%#{query}%")
+        records = records.where(conditions, *values)
+      end
+      
+      if sort_field.present? && sortable_fields.any? { |f| f[:name].to_s == sort_field.to_s }
+        records = records.order("#{sort_field} #{sort_direction}")
+      end
+      
+      records
+    end
+
+    # Batch Actions DSL
+    def self.enable_batch_actions
+      self.batch_actions_enabled = true
+    end
+    
+    def self.batch_action(action_class, options = {})
+      self.batch_actions_config = batch_actions_config + [{
+        class: action_class,
+        condition: options[:if]
+      }]
+    end
+    
+    def self.available_batch_actions(context = {})
+      return [] unless batch_actions_enabled
+      
+      batch_actions_config.select do |config|
+        condition = config[:condition]
+        condition.nil? || (condition.respond_to?(:call) ? context.instance_eval(&condition) : condition)
+      end.map { |config| config[:class] }
+    end
+
+    # Row Actions DSL (single record actions)
+    def self.row_action(action_class, options = {})
+      self.row_actions_config ||= []
+      
+      self.row_actions_config = row_actions_config + [{
+        class: action_class,
+        condition: options[:if]
+      }]
+    end
+    
+    def self.row_actions
+      row_actions_config || []
+    end
+    
+    def self.has_row_actions?
+      row_actions_config.present?
+    end
+    
+    # Route helpers
+    def self.route_key
+      resource_name.underscore.pluralize
+    end
+
+    def self.param_key
+      resource_name.underscore
+    end
+  end
+end