easy-admin-rails 0.2.5 → 0.2.7

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

data/lib/generators/easy_admin/rbac/rbac_generator.rb

@@ -1,244 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/migration'
-
-module EasyAdmin
-  module Generators
-    class RbacGenerator < Rails::Generators::Base
-      include Rails::Generators::Migration
-      
-      source_root File.expand_path('../templates', __FILE__)
-      
-      desc 'Generate EasyAdmin Role-Based Access Control setup'
-      
-      def self.next_migration_number(path)
-        Time.current.utc.strftime("%Y%m%d%H%M%S")
-      end
-      
-      def copy_migration
-        migration_template(
-          'add_rbac_to_admin_users.rb',
-          'db/migrate/add_rbac_to_admin_users.rb',
-          migration_version: migration_version
-        )
-      end
-      
-      def create_role_models
-        template 'super_admin.rb', 'app/models/easy_admin/super_admin.rb'
-        template 'admin.rb', 'app/models/easy_admin/admin.rb'
-        template 'editor.rb', 'app/models/easy_admin/editor.rb'
-        template 'viewer.rb', 'app/models/easy_admin/viewer.rb'
-      end
-      
-      def update_admin_user_model
-        inject_into_file 'app/models/easy_admin/admin_user.rb', after: "self.table_name = \"easy_admin_admin_users\"\n" do
-          <<-RUBY
-    
-    # STI configuration for role-based access
-    self.inheritance_column = :type
-    
-    # Associations
-    has_many :audit_logs, class_name: 'EasyAdmin::AuditLog', foreign_key: :admin_user_id, dependent: :destroy
-    
-    # Scopes
-    scope :by_role, ->(role) { where(type: "EasyAdmin::\#{role}") }
-    
-    # Cache permissions per request
-    def permissions_cache
-      @permissions_cache ||= {}
-    end
-    
-    # Core authorization methods (to be overridden by subclasses)
-    def can_access_resource?(resource_name)
-      accessible_resources.include?(resource_name.to_s)
-    end
-    
-    def can_perform_action?(resource_name, action)
-      return false unless can_access_resource?(resource_name)
-      allowed_actions_for(resource_name).include?(action.to_s)
-    end
-    
-    def can_access_field?(resource_name, field_name, action = :read)
-      return false unless can_access_resource?(resource_name)
-      !restricted_fields_for(resource_name, action).include?(field_name.to_s)
-    end
-    
-    # Override in subclasses
-    def accessible_resources
-      []
-    end
-    
-    def allowed_actions_for(resource_name)
-      [:index, :show]
-    end
-    
-    def restricted_fields_for(resource_name, action)
-      []
-    end
-    
-    def apply_resource_scope(resource_name, scope)
-      scope
-    end
-    
-    # Helper for caching expensive operations
-    def cached_permission(key, &block)
-      permissions_cache[key] ||= block.call
-    end
-          RUBY
-        end
-      end
-      
-      def create_permission_cache
-        template 'permission_cache.rb', 'lib/easy_admin/permission_cache.rb'
-      end
-      
-      def create_audit_log_model
-        template 'audit_log.rb', 'app/models/easy_admin/audit_log.rb'
-        
-        migration_template(
-          'create_audit_logs.rb',
-          'db/migrate/create_easy_admin_audit_logs.rb',
-          migration_version: migration_version
-        )
-      end
-      
-      def update_application_controller
-        inject_into_file 'app/controllers/easy_admin/application_controller.rb', 
-                        before: "include Pagy::Backend" do
-          <<-RUBY
-    class UnauthorizedError < StandardError; end
-    
-          RUBY
-        end
-        
-        inject_into_file 'app/controllers/easy_admin/application_controller.rb',
-                        after: "before_action :authenticate_easy_admin_admin_user!\n" do
-          <<-RUBY
-    before_action :check_resource_access!, except: [:index]
-    
-    rescue_from UnauthorizedError do |exception|
-      respond_to do |format|
-        format.html { redirect_to easy_admin.root_path, alert: 'You are not authorized to access this resource.' }
-        format.turbo_stream do 
-          render turbo_stream: turbo_stream.replace("notifications", 
-            EasyAdmin::NotificationComponent.new(
-              message: 'You are not authorized to access this resource', 
-              type: :error
-            ).call
-          )
-        end
-      end
-    end
-          RUBY
-        end
-        
-        inject_into_file 'app/controllers/easy_admin/application_controller.rb',
-                        before: "def authenticate_admin_user!" do
-          <<-RUBY
-    def check_resource_access!
-      return unless defined?(@resource_class)
-      
-      unless current_admin_user.can_access_resource?(@resource_class.resource_name)
-        raise UnauthorizedError, "Access denied to \#{@resource_class.resource_name}"
-      end
-      
-      check_action_permission!
-    end
-    
-    def check_action_permission!
-      action_map = {
-        'index' => :index,
-        'show' => :show,
-        'new' => :new,
-        'create' => :create,
-        'edit' => :edit,
-        'update' => :update,
-        'destroy' => :destroy,
-        'execute' => :batch_action
-      }
-      
-      mapped_action = action_map[action_name] || action_name.to_sym
-      
-      unless current_admin_user.can_perform_action?(@resource_class.resource_name, mapped_action)
-        raise UnauthorizedError, "Cannot perform \#{mapped_action} on \#{@resource_class.resource_name}"
-      end
-    end
-    
-    def apply_role_scoping(scope)
-      current_admin_user.apply_resource_scope(@resource_class.resource_name, scope)
-    end
-    
-    def permission_cache
-      @permission_cache ||= EasyAdmin::PermissionCache.new(current_admin_user)
-    end
-    
-          RUBY
-        end
-        
-        inject_into_file 'app/controllers/easy_admin/application_controller.rb',
-                        after: "helper_method :current_admin_user, :admin_user_signed_in?" do
-          ", :permission_cache"
-        end
-      end
-      
-      def create_seeds
-        create_file 'db/seeds/easy_admin_rbac.rb', <<~RUBY
-          # Create default admin users with different roles
-          if Rails.env.development?
-            # Super Admin - full access
-            EasyAdmin::SuperAdmin.find_or_create_by(email: 'super@example.com') do |admin|
-              admin.password = 'password'
-              admin.password_confirmation = 'password'
-              admin.first_name = 'Super'
-              admin.last_name = 'Admin'
-              admin.confirmed_at = Time.current
-            end
-            
-            # Standard Admin - most access except system settings
-            EasyAdmin::Admin.find_or_create_by(email: 'admin@example.com') do |admin|
-              admin.password = 'password'
-              admin.password_confirmation = 'password'
-              admin.first_name = 'Admin'
-              admin.last_name = 'User'
-              admin.confirmed_at = Time.current
-            end
-            
-            # Editor - content management only
-            EasyAdmin::Editor.find_or_create_by(email: 'editor@example.com') do |admin|
-              admin.password = 'password'
-              admin.password_confirmation = 'password'
-              admin.first_name = 'Content'
-              admin.last_name = 'Editor'
-              admin.confirmed_at = Time.current
-            end
-            
-            # Viewer - read-only access
-            EasyAdmin::Viewer.find_or_create_by(email: 'viewer@example.com') do |admin|
-              admin.password = 'password'
-              admin.password_confirmation = 'password'
-              admin.first_name = 'Read'
-              admin.last_name = 'Only'
-              admin.confirmed_at = Time.current
-            end
-            
-            puts "EasyAdmin RBAC users created!"
-            puts "Roles available:"
-            puts "  SuperAdmin - super@example.com / password (full access)"
-            puts "  Admin - admin@example.com / password (standard admin)"
-            puts "  Editor - editor@example.com / password (content only)"
-            puts "  Viewer - viewer@example.com / password (read-only)"
-          end
-        RUBY
-      end
-      
-      def show_readme
-        readme 'RBAC_README'
-      end
-      
-      private
-      
-      def migration_version
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      end
-    end
-  end
-end

data/lib/generators/easy_admin/rbac/templates/add_rbac_to_admin_users.rb

@@ -1,23 +0,0 @@
-class AddRbacToAdminUsers < ActiveRecord::Migration<%= migration_version %>
-  def change
-    # Add type column for STI
-    add_column :easy_admin_admin_users, :type, :string
-    add_column :easy_admin_admin_users, :permissions, :json, default: {}
-    add_column :easy_admin_admin_users, :resource_access, :json, default: {}
-    
-    # Add indexes for performance
-    add_index :easy_admin_admin_users, :type
-    add_index :easy_admin_admin_users, [:type, :locked_at]
-    
-    # Migrate existing users to Admin type
-    reversible do |dir|
-      dir.up do
-        execute <<-SQL
-          UPDATE easy_admin_admin_users 
-          SET type = 'EasyAdmin::Admin' 
-          WHERE type IS NULL
-        SQL
-      end
-    end
-  end
-end

data/lib/generators/easy_admin/rbac/templates/super_admin.rb

@@ -1,34 +0,0 @@
-module EasyAdmin
-  class SuperAdmin < AdminUser
-    def accessible_resources
-      cached_permission(:resources) do
-        EasyAdmin::ResourceRegistry.all_resources.map(&:resource_name)
-      end
-    end
-    
-    def allowed_actions_for(resource_name)
-      [:index, :show, :new, :create, :edit, :update, :destroy, :batch_action, :row_action].map(&:to_s)
-    end
-    
-    def restricted_fields_for(resource_name, action)
-      [] # No restrictions for super admin
-    end
-    
-    def apply_resource_scope(resource_name, scope)
-      scope # No filtering for super admin
-    end
-    
-    # Super admin specific methods
-    def super_admin?
-      true
-    end
-    
-    def role_name
-      'Super Admin'
-    end
-    
-    def role_badge_color
-      'red'
-    end
-  end
-end