easy-admin-rails 0.2.6 → 0.2.7

data/lib/easy_admin/resource/layout_builder.rb

@@ -1,249 +0,0 @@
-module EasyAdmin
-  module ResourceModules
-    # LayoutBuilder module for handling form and show layout configuration
-    # Manages form tabs and show page layout elements
-    module LayoutBuilder
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :form_tabs_config, :show_layout_config
-
-        def self.initialize_layout_builder
-          self.form_tabs_config = []
-          self.show_layout_config = []
-        end
-      end
-
-      class_methods do
-        # Form tabs management
-        def add_form_tab(tab_config)
-          self.form_tabs_config = (self.form_tabs_config || []) + [tab_config]
-        end
-
-        def form_tabs
-          form_tabs_config
-        end
-
-        def has_form_tabs?
-          form_tabs_config.any?
-        end
-
-        def clear_form_tabs
-          self.form_tabs_config = []
-        end
-
-        # Show layout management
-        def add_show_layout_element(element_config)
-          self.show_layout_config = (self.show_layout_config || []) + [element_config]
-        end
-
-        def show_layout
-          show_layout_config
-        end
-
-        def has_show_layout?
-          show_layout_config.any?
-        end
-
-        def clear_show_layout
-          self.show_layout_config = []
-        end
-
-        # Form tab utilities
-        def find_form_tab(tab_name)
-          form_tabs_config.find { |tab| tab[:name].to_s == tab_name.to_s }
-        end
-
-        def form_tab_names
-          form_tabs_config.map { |tab| tab[:name] }
-        end
-
-        def form_tab_fields(tab_name)
-          tab = find_form_tab(tab_name)
-          tab ? tab[:fields] : []
-        end
-
-        def total_form_tabs_count
-          form_tabs_config.count
-        end
-
-        # Show layout utilities
-        def show_layout_rows
-          show_layout_config.select { |element| element[:type] == :row }
-        end
-
-        def show_layout_elements_count
-          count = 0
-          show_layout_config.each do |element|
-            count += count_nested_elements(element)
-          end
-          count
-        end
-
-        def find_show_layout_element(element_type)
-          find_element_in_layout(show_layout_config, element_type)
-        end
-
-        def has_show_layout_tabs?
-          find_show_layout_element(:tabs).present?
-        end
-
-        def has_show_layout_cards?
-          find_show_layout_element(:card).present?
-        end
-
-        def has_metric_cards?
-          find_show_layout_element(:metric_card).present?
-        end
-
-        def has_chart_cards?
-          find_show_layout_element(:chart_card).present?
-        end
-
-        # Layout validation
-        def validate_form_structure
-          errors = []
-          
-          if has_form_tabs?
-            form_tabs_config.each_with_index do |tab, index|
-              unless tab[:name].present?
-                errors << "Form tab at index #{index} is missing a name"
-              end
-              
-              unless tab[:fields].is_a?(Array)
-                errors << "Form tab '#{tab[:name]}' fields must be an array"
-              end
-            end
-          end
-          
-          errors
-        end
-
-        def validate_show_layout_structure
-          errors = []
-          
-          show_layout_config.each_with_index do |element, index|
-            case element[:type]
-            when :row
-              unless element[:columns].is_a?(Array)
-                errors << "Row at index #{index} must have columns array"
-              end
-              
-              if element[:columns].empty?
-                errors << "Row at index #{index} cannot have empty columns"
-              end
-            when :column
-              unless element[:elements].is_a?(Array)
-                errors << "Column at index #{index} must have elements array"
-              end
-            end
-          end
-          
-          errors
-        end
-
-        # Layout rebuild methods
-        def rebuild_form_from_fields
-          return if fields_config.empty?
-          
-          # Create a default tab with all non-readonly fields
-          default_tab = {
-            name: "General",
-            label: "General",
-            icon: nil,
-            fields: fields_config.reject { |field| field[:readonly] }
-          }
-          
-          self.form_tabs_config = [default_tab]
-        end
-
-        def rebuild_show_layout_from_fields
-          return if fields_config.empty?
-          
-          # Create a simple single-column layout with all fields
-          row_config = {
-            type: :row,
-            columns_count: 1,
-            spacing: "medium",
-            columns: [{
-              type: :column,
-              size: 12,
-              elements: [{
-                type: :card,
-                title: "Details",
-                color: "light",
-                padding: "medium",
-                shadow: "small",
-                elements: fields_config.map { |field|
-                  {
-                    type: :field,
-                    name: field[:name],
-                    label: field[:label],
-                    field_type: :default,
-                    format: field[:format],
-                    css_classes: nil,
-                    show_label: true
-                  }
-                }
-              }]
-            }]
-          }
-          
-          self.show_layout_config = [row_config]
-        end
-
-        private
-
-        def count_nested_elements(element)
-          count = 1
-          
-          case element[:type]
-          when :row
-            element[:columns]&.each { |column| count += count_nested_elements(column) }
-          when :column
-            element[:elements]&.each { |child| count += count_nested_elements(child) }
-          when :card
-            element[:elements]&.each { |child| count += count_nested_elements(child) }
-          when :tabs
-            element[:tabs]&.each { |tab| count += count_nested_elements(tab) }
-          when :tab
-            element[:elements]&.each { |child| count += count_nested_elements(child) }
-          end
-          
-          count
-        end
-
-        def find_element_in_layout(layout, element_type)
-          layout.each do |element|
-            return element if element[:type] == element_type
-            
-            case element[:type]
-            when :row
-              element[:columns]&.each do |column|
-                found = find_element_in_layout([column], element_type)
-                return found if found
-              end
-            when :column, :card
-              if element[:elements]
-                found = find_element_in_layout(element[:elements], element_type)
-                return found if found
-              end
-            when :tabs
-              element[:tabs]&.each do |tab|
-                found = find_element_in_layout([tab], element_type)
-                return found if found
-              end
-            when :tab
-              if element[:elements]
-                found = find_element_in_layout(element[:elements], element_type)
-                return found if found
-              end
-            end
-          end
-          
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/easy_admin/resource/show_builder.rb

@@ -1,359 +0,0 @@
-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

data/lib/generators/easy_admin/permissions/templates/migrations/update_users_for_permissions.rb

@@ -1,6 +0,0 @@
-class UpdateUsersForEasyAdminPermissions < ActiveRecord::Migration<%= migration_version %>
-  def change
-    add_column :<%= user_model_name.tableize %>, :permissions_cache, :json, default: {}, null: false
-    add_index :<%= user_model_name.tableize %>, :permissions_cache, using: :gin
-  end
-end