easy-admin-rails 0.1.14 → 0.2.0

data/lib/easy_admin/resource.rb

@@ -1,841 +1,14 @@
 module EasyAdmin
   class Resource
-    include EasyAdmin::Versioning
-    
-    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, :custom_title
-    
-    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
+    include EasyAdmin::ResourceModules::Base
 
-    # DSL for setting custom model name
-    def self.model(model_name)
-      self.model_class_name = model_name.to_s
-    end
-    
-    # DSL for setting custom title
-    def self.resource_title(title_name)
-      self.custom_title = title_name.to_s
-    end
+    # Legacy methods - kept for backward compatibility
+    # These delegate to the appropriate modules
 
-    # 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],
-        association: options[:association],
-        foreign_key: options[:foreign_key] # for belongs_to fields
-      }]
-    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
-      return custom_title.pluralize if custom_title.present?
-      resource_name.underscore.humanize.pluralize
-    end
-
-    def self.singular_title
-      return custom_title.singularize if custom_title.present?
-      resource_name.underscore.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],
-          association: options[:association],
-          foreign_key: options[:foreign_key]
-        }
-
-        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
-
-      def json_field(name, **options)
-        field(name, :json, **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
-    
-    # Versioning DSL - Simple API for enabling version viewing
-    def self.versioning(enabled = true, **options)
-      if enabled
-        enable_versioning(options)
-      else
-        self.versioning_enabled = false
-      end
-    end
-    
-    def self.has_versioning?
-      model_has_versions?
-    end
+    # Deprecated classes - kept for backward compatibility
+    # Use EasyAdmin::ResourceModules::FormBuilder instead
+    FormBuilder = EasyAdmin::ResourceModules::FormBuilder
+    ShowBuilder = EasyAdmin::ResourceModules::ShowBuilder
+    ChartBuilder = EasyAdmin::ResourceModules::ChartBuilder
   end
 end