easy-admin-rails 0.1.15 → 0.2.0

data/lib/easy_admin/resource/scope_manager.rb

@@ -0,0 +1,252 @@
+module EasyAdmin
+  module ResourceModules
+    # ScopeManager module for handling resource scopes and filtering
+    # Manages scope definitions, default scopes, and scope-related queries
+    module ScopeManager
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :scopes_config
+
+        def self.initialize_scope_manager
+          self.scopes_config = []
+        end
+      end
+
+      class_methods do
+        # Core scope definition method
+        def 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),
+            condition: options[:if] # Conditional scope visibility
+          }
+          
+          add_scope(scope_config)
+        end
+
+        # Add scope to configuration
+        def add_scope(scope_config)
+          self.scopes_config = (self.scopes_config || []) + [scope_config]
+        end
+
+        # Scope query methods
+        def scopes
+          scopes_config
+        end
+
+        def has_scopes?
+          scopes_config.any?
+        end
+
+        def scope_names
+          scopes_config.map { |scope| scope[:name] }
+        end
+
+        def find_scope(name)
+          scopes_config.find { |scope| scope[:name].to_s == name.to_s }
+        end
+
+        def scope_exists?(name)
+          find_scope(name).present?
+        end
+
+        # Default scope management
+        def default_scope
+          scopes_config.find { |scope| scope[:default] } || scopes_config.first
+        end
+
+        def set_default_scope(name)
+          # Remove existing default
+          scopes_config.each { |scope| scope[:default] = false }
+          
+          # Set new default
+          scope = find_scope(name)
+          scope[:default] = true if scope
+        end
+
+        def has_default_scope?
+          default_scope.present?
+        end
+
+        # Conditional scopes
+        def visible_scopes(context = {})
+          scopes_config.select do |scope_config|
+            condition = scope_config[:condition]
+            condition.nil? || (condition.respond_to?(:call) ? context.instance_eval(&condition) : condition)
+          end
+        end
+
+        def conditional_scopes
+          scopes_config.select { |scope| scope[:condition].present? }
+        end
+
+        # Scope application methods
+        def apply_scope_to_records(records, scope_name)
+          return records unless scope_exists?(scope_name)
+          
+          scope_config = find_scope(scope_name)
+          return records if scope_config[:name] == :all
+          
+          scope_method = scope_config[:scope_method]
+          if records.respond_to?(scope_method)
+            records.public_send(scope_method)
+          else
+            records
+          end
+        end
+
+        def apply_default_scope_to_records(records)
+          return records unless has_default_scope?
+          
+          default = default_scope
+          return records if default[:name] == :all
+          
+          apply_scope_to_records(records, default[:name])
+        end
+
+        # Scope counts calculation
+        def calculate_scope_counts(base_records = nil)
+          base_records ||= model_class.all
+          counts = {}
+          
+          scopes_config.each do |scope_config|
+            scope_name = scope_config[:name]
+            next unless scope_config[:count] # Skip if count is disabled
+            
+            if scope_name == :all
+              counts[scope_name] = base_records.count
+            else
+              scope_method = scope_config[:scope_method]
+              if model_class.respond_to?(scope_method)
+                counts[scope_name] = model_class.public_send(scope_method).count
+              else
+                counts[scope_name] = 0
+              end
+            end
+          end
+          
+          counts
+        end
+
+        def scope_count(scope_name, base_records = nil)
+          return 0 unless scope_exists?(scope_name)
+          
+          scope_config = find_scope(scope_name)
+          return 0 unless scope_config[:count]
+          
+          if scope_name == :all
+            base_records ||= model_class.all
+            base_records.count
+          else
+            scope_method = scope_config[:scope_method]
+            if model_class.respond_to?(scope_method)
+              model_class.public_send(scope_method).count
+            else
+              0
+            end
+          end
+        end
+
+        # Scope utilities
+        def scope_label(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config ? scope_config[:label] : scope_name.to_s.humanize
+        end
+
+        def scope_icon(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config&.dig(:icon)
+        end
+
+        def scope_color(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config&.dig(:color) || 'blue'
+        end
+
+        def scope_method_name(scope_name)
+          scope_config = find_scope(scope_name)
+          scope_config ? scope_config[:scope_method] : scope_name
+        end
+
+        # Scope validation
+        def validate_scopes
+          errors = []
+          
+          scopes_config.each do |scope_config|
+            scope_name = scope_config[:name]
+            scope_method = scope_config[:scope_method]
+            
+            # Check if scope method exists on model (skip :all)
+            if scope_name != :all && !model_class.respond_to?(scope_method)
+              errors << "Scope method '#{scope_method}' does not exist on #{model_class.name}"
+            end
+            
+            # Check for duplicate scope names
+            duplicate_count = scopes_config.count { |s| s[:name] == scope_name }
+            if duplicate_count > 1
+              errors << "Duplicate scope name '#{scope_name}' found"
+            end
+          end
+          
+          errors
+        end
+
+        def valid_scopes?
+          validate_scopes.empty?
+        end
+
+        # Scope management
+        def clear_scopes
+          self.scopes_config = []
+        end
+
+        def remove_scope(scope_name)
+          self.scopes_config = scopes_config.reject { |scope| scope[:name] == scope_name }
+        end
+
+        def total_scopes_count
+          scopes_config.count
+        end
+
+        def enabled_scope_counts_count
+          scopes_config.count { |scope| scope[:count] }
+        end
+
+        # Predefined scope helpers
+        def add_all_scope(label: "All", default: true)
+          scope(:all, label: label, scope: :all, default: default)
+        end
+
+        def add_recent_scope(days: 7, label: "Recent")
+          return unless model_class.column_names.include?('created_at')
+          
+          scope(:recent, 
+                label: label, 
+                scope: -> { where('created_at >= ?', days.days.ago) })
+        end
+
+        def add_published_scope(column: :published, label: "Published")
+          return unless model_class.column_names.include?(column.to_s)
+          
+          scope(:published, 
+                label: label, 
+                scope: -> { where(column => true) })
+        end
+
+        def add_unpublished_scope(column: :published, label: "Unpublished")
+          return unless model_class.column_names.include?(column.to_s)
+          
+          scope(:unpublished, 
+                label: label, 
+                scope: -> { where(column => [false, nil]) })
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/show_builder.rb

@@ -0,0 +1,359 @@
+module EasyAdmin
+  module ResourceModules
+    # ShowBuilder class for show layout DSL
+    # Handles all show page layout definitions with rows, columns, cards, and tabs
+    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: []
+        }
+
+        push_context
+        @current_row = row_config
+        
+        if @current_column
+          @current_column[:elements] << row_config
+        else
+          @resource_class.add_show_layout_element(row_config)
+        end
+
+        instance_eval(&block) if block_given?
+        pop_context
+      end
+
+      def column(size: nil, &block)
+        raise "column must be called within a row block" unless @current_row
+        
+        calculated_size = size || (12 / [@current_row[:columns_count], 1].max)
+        validate_column_size!(calculated_size)
+
+        column_config = {
+          type: :column,
+          size: calculated_size,
+          elements: []
+        }
+
+        push_context
+        @current_column = column_config
+        @current_row[:columns] << column_config
+
+        instance_eval(&block) if block_given?
+        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: []
+        }
+
+        push_context
+        @current_card = card_config
+        @current_column[:elements] << card_config
+
+        instance_eval(&block) if block_given?
+        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,
+          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: []
+        }
+
+        push_context
+        @current_tab_container = tabs_config
+        container[:elements] << tabs_config
+
+        instance_eval(&block) if block_given?
+        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: []
+        }
+
+        push_context
+        @current_tab = tab_config
+        @current_tab_container[:tabs] << tab_config
+
+        instance_eval(&block) if block_given?
+        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
+
+        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
+
+      # Component rendering support with context
+      def render(component_class_or_instance, **options)
+        container = @current_tab || @current_card || @current_column
+        raise "render must be called within a tab, card, or column block" unless container
+
+        component_config = {
+          type: :custom_component,
+          component_class: component_class_or_instance.class,
+          component_options: options,
+          component_instance: component_class_or_instance
+        }
+
+        container[:elements] << component_config
+        component_class_or_instance
+      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
+
+    # ChartBuilder class for chart configuration
+    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
+  end
+end