easy-admin-rails 0.1.15 → 0.2.1

data/lib/easy_admin/permissions.rb

@@ -0,0 +1,113 @@
+# EasyAdmin Permission Engine
+# A lightweight permission management system that works with Action Policy
+
+module EasyAdmin
+  module Permissions
+    extend ActiveSupport::Autoload
+
+    autoload :Engine
+    autoload :Models
+    autoload :DSL
+    autoload :Controller
+    autoload :Component
+    autoload :Cache
+    autoload :Configuration
+    autoload :UserExtensions
+    autoload :ResourcePermissions
+    autoload :RoleDefinition
+    autoload :RoleDSL
+
+    class << self
+      attr_writer :configuration, :role_definitions
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      # Check if permissions are enabled
+      def enabled?
+        configuration.enabled
+      end
+
+      # Restore the original define method for the DSL
+      def define(&block)
+        DSL.evaluate(&block).tap do |data|
+          DSL.seed_database(data)
+        end
+      end
+
+      # DSL for defining roles
+      def define_roles(&block)
+        @role_definitions = RoleDSL.new
+        @role_definitions.instance_eval(&block)
+        @role_definitions
+      end
+
+      # Get defined roles
+      def role_definitions
+        @role_definitions ||= RoleDSL.new
+      end
+
+      # Get all available roles
+      def available_roles
+        role_definitions.all_roles
+      end
+
+      # Get role by slug
+      def get_role(slug)
+        role_definitions.get_role(slug)
+      end
+
+      # Core permission check - used by Action Policy policies
+      def authorized?(user, permission_name, context: nil)
+        return true unless enabled?
+        return true if user.id == 1
+        
+        user&.has_permission?(permission_name, context: context) || false
+      end
+
+      # Check if user has role
+      def has_role?(user, role_name, context: nil)
+        return false unless user
+        user.has_role?(role_name, context: context)
+      end
+
+      # Get user permissions based on role
+      def user_permissions_for_role(role_slug)
+        role = get_role(role_slug)
+        return {} unless role
+        role.permissions
+      end
+
+      # Get available EasyAdmin resources
+      def available_resources
+        ResourcePermissions.available_resources
+      end
+
+      # Get actions for a specific resource
+      def actions_for_resource(resource_name)
+        ResourcePermissions.actions_for_resource(resource_name)
+      end
+
+      # Generate all possible permissions for available resources
+      def generate_all_permissions
+        permissions = {}
+        available_resources.each do |resource|
+          actions_for_resource(resource).each do |action|
+            permission_key = "#{resource}:#{action}"
+            permissions[permission_key] = {
+              resource: resource,
+              action: action,
+              name: permission_key
+            }
+          end
+        end
+        permissions
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/base.rb

@@ -0,0 +1,119 @@
+module EasyAdmin
+  module ResourceModules
+    # Base module that provides the core resource functionality
+    # This module serves as the orchestrator for all resource modules
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        include EasyAdmin::Versioning
+        include EasyAdmin::ResourceModules::Configuration
+        include EasyAdmin::ResourceModules::DSL
+        include EasyAdmin::ResourceModules::FieldRegistry
+        include EasyAdmin::ResourceModules::LayoutBuilder
+        include EasyAdmin::ResourceModules::ScopeManager
+        
+        # Class attributes for core functionality
+        class_attribute :resource_name, :custom_title
+        
+        # Initialize configurations when resource is inherited
+        def self.inherited(subclass)
+          super
+          subclass.setup_resource_defaults
+          EasyAdmin::ResourceRegistry.register(subclass)
+        end
+
+        # Set up default configurations for new resource classes
+        def self.setup_resource_defaults
+          self.resource_name = name.demodulize.gsub(/Resource$/, '')
+          initialize_configurations
+          initialize_field_registry
+          initialize_layout_builder
+          initialize_scope_manager
+        end
+      end
+
+      class_methods do
+        # Get the associated model class
+        def 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 title
+          return custom_title.pluralize if custom_title.present?
+          resource_name.underscore.humanize.pluralize
+        end
+
+        def singular_title
+          return custom_title.singularize if custom_title.present?
+          resource_name.underscore.humanize
+        end
+
+        # Route helpers
+        def route_key
+          resource_name.underscore.pluralize
+        end
+
+        def param_key
+          resource_name.underscore
+        end
+
+        # DSL for setting custom title
+        def resource_title(title_name)
+          self.custom_title = title_name.to_s
+        end
+
+        # Query methods - delegated to field registry
+        def 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 find_record(id)
+          model_class.find(id)
+        end
+
+        def 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
+
+        # Versioning DSL - Simple API for enabling version viewing
+        def versioning(enabled = true, **options)
+          if enabled
+            enable_versioning(options)
+          else
+            self.versioning_enabled = false
+          end
+        end
+        
+        def has_versioning?
+          model_has_versions?
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/configuration.rb

@@ -0,0 +1,148 @@
+module EasyAdmin
+  module ResourceModules
+    # Configuration module for handling resource settings
+    # Manages pagination, includes, batch actions, and row actions
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        # Core configuration class attributes
+        class_attribute :model_class_name, :pagination_config, :includes_config, 
+                        :batch_actions_config, :batch_actions_enabled, :row_actions_config
+
+        # Initialize default configurations
+        def self.initialize_configurations
+          self.model_class_name = resource_name
+          self.pagination_config = {
+            type: :standard,
+            per_page: 20,
+            max_per_page: 100
+          }
+          self.includes_config = {
+            index: [],
+            show: [],
+            form: []
+          }
+          self.batch_actions_config = []
+          self.batch_actions_enabled = false
+          self.row_actions_config = []
+        end
+      end
+
+      class_methods do
+        # Pagination configuration
+        def 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 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 per_page(count)
+          pagination(per_page: count)
+        end
+
+        def infinite_scroll(**options)
+          pagination(type: :infinite_scroll, infinite_scroll: true, **options)
+        end
+
+        def countless_pagination(**options)
+          pagination(countless: true, **options)
+        end
+
+        # Pagination helper methods
+        def items_per_page
+          pagination_config[:per_page]
+        end
+
+        def max_items_per_page
+          pagination_config[:max_per_page]
+        end
+
+        def pagination_type
+          pagination_config[:type]
+        end
+
+        def infinite_scroll_enabled?
+          pagination_config[:infinite_scroll]
+        end
+
+        def countless_enabled?
+          pagination_config[:countless]
+        end
+
+        # Includes configuration helpers
+        def index_includes
+          includes_config[:index] || []
+        end
+
+        def show_includes
+          includes_config[:show] || []
+        end
+
+        def form_includes
+          includes_config[:form] || []
+        end
+
+        # Batch Actions configuration
+        def add_batch_action(action_class, options = {})
+          self.batch_actions_config = (self.batch_actions_config || []) + [{
+            class: action_class,
+            condition: options[:if]
+          }]
+        end
+
+        def batch_actions
+          batch_actions_config || []
+        end
+
+        def has_batch_actions?
+          batch_actions_enabled && batch_actions_config.any?
+        end
+
+        # Row Actions configuration
+        def add_row_action(action_class, options = {})
+          self.row_actions_config = (self.row_actions_config || []) + [{
+            class: action_class,
+            condition: options[:if]
+          }]
+        end
+        
+        def row_actions
+          row_actions_config || []
+        end
+        
+        def has_row_actions?
+          row_actions_config.present?
+        end
+
+        # Available actions based on context conditions
+        def available_row_actions(context = {})
+          return [] unless has_row_actions?
+          
+          row_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
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/dsl.rb

@@ -0,0 +1,117 @@
+module EasyAdmin
+  module ResourceModules
+    # DSL module for defining fields and convenience methods
+    # Handles all field definition methods and form building
+    module DSL
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # DSL for setting custom model name
+        def model(model_name)
+          self.model_class_name = model_name.to_s
+        end
+
+        # Core field definition method
+        def field(name, type = :string, **options)
+          register_field(name, type, **options)
+        end
+
+        # Convenience methods for common field types
+        def id_field(**options)
+          field(:id, :number, readonly: true, **options)
+        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
+
+        # Password field with confirmation - new convenience method
+        def password_field(name = :password, **options)
+          field(name, :password, **options)
+          field("#{name}_confirmation".to_sym, :password, 
+                label: options[:confirmation_label] || "Confirm #{name.to_s.humanize}",
+                **options.except(:confirmation_label))
+        end
+
+        # Form building DSL
+        def form(&block)
+          form_builder = EasyAdmin::ResourceModules::FormBuilder.new(self)
+          form_builder.instance_eval(&block)
+        end
+
+        # Show layout building DSL  
+        def show(&block)
+          show_builder = EasyAdmin::ResourceModules::ShowBuilder.new(self)
+          show_builder.instance_eval(&block)
+        end
+
+        # Batch Actions DSL
+        def enable_batch_actions
+          self.batch_actions_enabled = true
+        end
+        
+        def batch_action(action_class, options = {})
+          add_batch_action(action_class, options)
+        end
+        
+        def 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 row_action(action_class, options = {})
+          add_row_action(action_class, options)
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/field_registry.rb

@@ -0,0 +1,189 @@
+module EasyAdmin
+  module ResourceModules
+    # FieldRegistry module for centralized field management
+    # Handles field registration, categorization, and retrieval
+    module FieldRegistry
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :fields_config
+
+        def self.initialize_field_registry
+          self.fields_config = []
+        end
+      end
+
+      class_methods do
+        # Core field registration method
+        def register_field(name, type = :string, **options)
+          field_config = build_field_config(name, type, **options)
+          add_field_to_registry(field_config)
+        end
+
+        # Build field configuration hash
+        def build_field_config(name, type, **options)
+          {
+            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
+
+        # Add field to the registry
+        def add_field_to_registry(field_config)
+          # Prevent duplicate fields by name
+          current_fields = self.fields_config || []
+          unless current_fields.any? { |f| f[:name] == field_config[:name] }
+            self.fields_config = current_fields + [field_config]
+          end
+        end
+
+        # Field categorization methods
+        def index_fields
+          fields_config.select { |field| ![:text, :has_many, :file].include?(field[:type]) }
+        end
+
+        def sortable_fields
+          fields_config.select { |field| field[:sortable] }
+        end
+
+        def filterable_fields
+          fields_config.select { |field| field[:filterable] }
+        end
+
+        def searchable_fields
+          fields_config.select { |field| field[:searchable] }
+        end
+
+        def show_fields
+          fields_config
+        end
+
+        def form_fields
+          if has_form_tabs?
+            # 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
+
+        # Field lookup methods
+        def find_field_config(field_name)
+          fields_config.find { |field| field[:name].to_s == field_name.to_s }
+        end
+
+        def field_exists?(field_name)
+          find_field_config(field_name).present?
+        end
+
+        def field_type(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:type)
+        end
+
+        def field_editable?(field_name)
+          field_config = find_field_config(field_name)
+          return false unless field_config
+          !field_config[:readonly] && field_config.fetch(:editable, true)
+        end
+
+        # Field validation methods
+        def required_fields
+          fields_config.select { |field| field[:required] }
+        end
+
+        def readonly_fields
+          fields_config.select { |field| field[:readonly] }
+        end
+
+        # Field grouping by type
+        def fields_by_type(type)
+          fields_config.select { |field| field[:type] == type }
+        end
+
+        def association_fields
+          fields_config.select { |field| [:belongs_to, :has_many].include?(field[:type]) }
+        end
+
+        def belongs_to_fields
+          fields_by_type(:belongs_to)
+        end
+
+        def has_many_fields
+          fields_by_type(:has_many)
+        end
+
+        def select_fields
+          fields_by_type(:select)
+        end
+
+        def json_fields
+          fields_by_type(:json)
+        end
+
+        # Field options helpers
+        def field_options(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:options) || []
+        end
+
+        def field_suggest_config(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:suggest) || {}
+        end
+
+        def field_display_method(field_name)
+          field_config = find_field_config(field_name)
+          field_config&.dig(:display_method) || :name
+        end
+
+        # Advanced field queries
+        def fields_with_suggest
+          fields_config.select { |field| field[:suggest].present? }
+        end
+
+        def multiple_select_fields
+          fields_config.select { |field| field[:type] == :select && field[:multiple] }
+        end
+
+        def file_fields
+          fields_by_type(:file)
+        end
+
+        def password_fields
+          fields_by_type(:password)
+        end
+
+        # Field count helpers
+        def total_fields_count
+          fields_config.count
+        end
+
+        def editable_fields_count
+          fields_config.count { |field| field_editable?(field[:name]) }
+        end
+
+        def association_fields_count
+          association_fields.count
+        end
+      end
+    end
+  end
+end