easy-admin-rails 0.1.0

data/lib/easy_admin/action.rb

@@ -0,0 +1,159 @@
+module EasyAdmin
+  class Action
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+    
+    # Execution modes
+    INSTANT = :instant    # Execute immediately with optional confirmation
+    MODAL = :modal       # Show form first, then execute
+    
+    # Action types
+    SINGLE = :single     # Single row action
+    BATCH = :batch       # Batch action (for compatibility)
+    
+    class_attribute :execution_mode, :label, :icon, :style, :confirm_message
+    class_attribute :modal_title, :modal_description, :modal_form_fields
+    class_attribute :action_type, :permissions, :visibility_conditions
+    
+    # Set default execution mode
+    self.execution_mode = INSTANT
+    self.action_type = SINGLE
+    
+    # Attributes for action context
+    attribute :current_user
+    attribute :record          # For single actions
+    attribute :selected_records # For batch actions (compatibility)
+    attribute :resource_class
+    attr_accessor :params      # Use attr_accessor instead of attribute for hash
+    
+    def initialize(attributes = {})
+      super
+      @params ||= {}
+    end
+    
+    class << self
+      def instant(label:, icon: nil, style: :primary, confirm: nil, permissions: nil)
+        self.execution_mode = INSTANT
+        self.label = label
+        self.icon = icon
+        self.style = style
+        self.confirm_message = confirm
+        self.permissions = permissions
+      end
+      
+      def modal(label:, icon: nil, style: :primary, title: nil, description: nil, permissions: nil)
+        self.execution_mode = MODAL
+        self.label = label
+        self.icon = icon
+        self.style = style
+        self.modal_title = title || label
+        self.modal_description = description
+        self.permissions = permissions
+        self.modal_form_fields = []
+      end
+
+      def form_field(name, type, options = {})
+        self.modal_form_fields ||= []
+        self.modal_form_fields << { 
+          name: name, 
+          type: type, 
+          options: options 
+        }
+        
+        # Add attribute and validation dynamically
+        attribute name, get_attribute_type(type), **options.slice(:default)
+        
+        # Add validations if specified
+        if options[:required]
+          validates name, presence: true
+        end
+        
+        if options[:format]
+          validates name, format: options[:format]
+        end
+      end
+
+      private
+      
+      def get_attribute_type(type)
+        case type
+        when :string, :text, :email, :url
+          :string
+        when :integer, :number
+          :integer
+        when :boolean
+          :boolean
+        when :date
+          :date
+        when :datetime
+          :datetime
+        when :json
+          :json
+        when :belongs_to
+          :string # Will store the ID
+        else
+          :string
+        end
+      end
+      
+      def single_action
+        self.action_type = SINGLE
+      end
+      
+      def batch_action
+        self.action_type = BATCH
+      end
+      
+      def visible_if(&block)
+        self.visibility_conditions = block
+      end
+    end
+    
+    # Main execution method - must be implemented by subclasses
+    def perform
+      raise NotImplementedError, "Subclasses must implement #perform method"
+    end
+    
+    # Visibility check
+    def visible?
+      return true unless self.class.visibility_conditions
+      instance_eval(&self.class.visibility_conditions)
+    end
+    
+    # Permission check
+    def permitted?
+      return true unless self.class.permissions
+      # Integration with Permisi gem would go here
+      # For now, always return true
+      true
+    end
+    
+    # Turbo response strategy for UI updates
+    def turbo_response_strategy
+      :replace # Default strategy, can be overridden
+    end
+
+    # Helper methods
+    class << self
+      # Helper method to get field configuration
+      def field_config(field_name)
+        modal_form_fields&.find { |field| field[:name] == field_name } || {}
+      end
+      
+      # Helper method to check if action is instant or modal
+      def instant?
+        execution_mode == INSTANT
+      end
+      
+      def modal?
+        execution_mode == MODAL
+      end
+    end
+
+    # Helper method to access form parameters safely
+    def form_param(key)
+      params[key.to_s] || params[key.to_sym]
+    end
+  end
+end

data/lib/easy_admin/batch_action.rb

@@ -0,0 +1,134 @@
+module EasyAdmin
+  class BatchAction
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+    
+    attr_accessor :selected_ids, :params, :current_user, :resource_class
+    
+    # Class-level configuration
+    class_attribute :label, :icon, :style, :confirm_message, :execution_mode
+    class_attribute :modal_form_fields, :modal_title, :modal_description
+    
+    # Execution modes
+    INSTANT = :instant    # Execute immediately (toggle, delete, etc.)
+    MODAL = :modal       # Show form first, then execute
+    
+    def initialize(attributes = {})
+      super(attributes)
+      @records = nil
+      @selected_ids ||= []
+      @params ||= {}
+    end
+    
+    # Main execution method - must be implemented by subclasses
+    def perform
+      raise NotImplementedError, "Subclasses must implement #perform"
+    end
+    
+    # Validation before execution
+    def valid_for_execution?
+      selected_ids.present? && records.exists?
+    end
+    
+    # Get the selected records
+    def records
+      @records ||= resource_class.model_class.where(id: selected_ids)
+    end
+    
+    # Override for custom authorization
+    def authorized?
+      true # Override in subclasses
+    end
+    
+    # Class methods for configuration
+    class << self
+      def instant(label:, icon: nil, style: :primary, confirm: nil)
+        self.execution_mode = INSTANT
+        self.label = label
+        self.icon = icon
+        self.style = style
+        self.confirm_message = confirm
+      end
+      
+      def modal(label:, icon: nil, style: :primary, title: nil, description: nil)
+        self.execution_mode = MODAL
+        self.label = label
+        self.icon = icon
+        self.style = style
+        self.modal_title = title || label
+        self.modal_description = description
+        self.modal_form_fields = []
+      end
+      
+      def form_field(name, type, options = {})
+        self.modal_form_fields ||= []
+        self.modal_form_fields << { 
+          name: name, 
+          type: type, 
+          options: options 
+        }
+        
+        # Add attribute and validation dynamically
+        attribute name, get_attribute_type(type), **options.slice(:default)
+        
+        # Add validations if specified
+        if options[:required]
+          validates name, presence: true
+        end
+        
+        if options[:format]
+          validates name, format: options[:format]
+        end
+      end
+      
+      private
+      
+      def get_attribute_type(type)
+        case type
+        when :string, :text, :email, :url
+          :string
+        when :integer, :number
+          :integer
+        when :boolean
+          :boolean
+        when :date
+          :date
+        when :datetime
+          :datetime
+        when :json
+          :json
+        when :belongs_to
+          :string # Will store the ID
+        else
+          :string
+        end
+      end
+    end
+    
+    # Helper method to get field configuration
+    def self.field_config(field_name)
+      modal_form_fields&.find { |field| field[:name] == field_name } || {}
+    end
+    
+    # Helper method to check if action is instant or modal
+    def self.instant?
+      execution_mode == INSTANT
+    end
+    
+    def self.modal?
+      execution_mode == MODAL
+    end
+    
+    # Default success message
+    def success_message(count = nil)
+      count ||= records.count
+      "#{self.class.label} completed for #{count} item#{'s' if count != 1}"
+    end
+    
+    # Helper method to access form parameters safely
+    def form_param(key)
+      params[key.to_s] || params[key.to_sym]
+    end
+  end
+end

data/lib/easy_admin/configuration.rb

@@ -0,0 +1,75 @@
+module EasyAdmin
+  class Configuration
+    attr_accessor :app_name, :sidebar_items, :global_settings, :enable_profiler
+
+    def initialize
+      @app_name = "EasyAdmin"
+      @sidebar_items = []
+      @global_settings = false
+      @enable_profiler = Rails.env.development?
+    end
+
+    def sidebar(&block)
+      sidebar_builder = SidebarBuilder.new
+      sidebar_builder.instance_eval(&block) if block_given?
+      @sidebar_items = sidebar_builder.items
+    end
+  end
+
+  class SidebarBuilder
+    attr_reader :items
+
+    def initialize
+      @items = []
+      @current_group = nil
+    end
+
+    def item(label, path = nil, icon: nil, active: false, &block)
+      item_config = {
+        label: label,
+        path: path,
+        icon: icon,
+        active: active
+      }
+
+      if block_given?
+        # This is a parent item with children
+        old_items = @items
+        @items = []
+        @current_group = item_config
+        
+        instance_eval(&block)
+        
+        item_config[:children] = @items
+        item_config[:expanded] = item_config[:children].any? { |child| child[:active] }
+        
+        @items = old_items
+      end
+
+      @items << item_config
+    end
+
+    def group(label, icon: nil, expanded: false, &block)
+      group_config = {
+        label: label,
+        icon: icon,
+        expanded: expanded,
+        children: []
+      }
+
+      if block_given?
+        old_items = @items
+        @items = []
+        
+        instance_eval(&block)
+        
+        group_config[:children] = @items
+        group_config[:expanded] = expanded || @items.any? { |child| child[:active] }
+        
+        @items = old_items
+      end
+
+      @items << group_config
+    end
+  end
+end

data/lib/easy_admin/dashboard.rb

@@ -0,0 +1,110 @@
+module EasyAdmin
+  class Dashboard
+    class << self
+      attr_accessor :cards_config, :dashboard_name, :grid_columns
+
+      def inherited(subclass)
+        subclass.cards_config = []
+        subclass.grid_columns = 4
+        super
+        # Register will happen after class is fully defined
+      end
+
+      # DSL methods for dashboard configuration
+      def dashboard(name, **options, &block)
+        self.dashboard_name = name
+        self.grid_columns = options[:columns] || 4
+        instance_eval(&block) if block_given?
+        EasyAdmin::DashboardRegistry.register(self)
+      end
+
+      def metric_card(name, **options)
+        card(name, :metric, **options)
+      end
+
+      def chart_card(name, **options)
+        card(name, :chart, **options)
+      end
+
+      def table_card(name, **options)
+        card(name, :table, **options)
+      end
+
+      def custom_card(name, **options)
+        card(name, :custom, **options)
+      end
+
+      def card(name, type, **options)
+        self.cards_config += [{
+          name: name,
+          type: type,
+          title: options[:title] || name.to_s.humanize,
+          cols: options[:cols] || 1,
+          rows: options[:rows] || 1,
+          refresh_every: options[:refresh_every],
+          partial: options[:partial],
+          data_method: options[:data_method] || "#{name}_data",
+          visible: options.fetch(:visible, true),
+          **options
+        }]
+      end
+
+      # Helper methods
+      def title
+        dashboard_name.to_s.humanize
+      end
+
+      def route_key
+        dashboard_name.to_s.underscore
+      end
+
+      def visible_cards
+        cards_config.select { |card| card[:visible] }
+      end
+
+      def find_card(name)
+        cards_config.find { |card| card[:name].to_s == name.to_s }
+      end
+
+      # Grid configuration
+      def columns
+        grid_columns
+      end
+
+      def columns_class
+        "cols-#{grid_columns}"
+      end
+
+      # Data methods - override in subclasses
+      def method_missing(method_name, *args, &block)
+        if method_name.to_s.end_with?('_data')
+          {}
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?('_data') || super
+      end
+    end
+
+    # Instance methods for data fetching
+    def initialize(params = {})
+      @params = params
+    end
+
+    def card_data(card_name)
+      method_name = "#{card_name}_data"
+      if self.class.respond_to?(method_name)
+        self.class.send(method_name, @params)
+      else
+        {}
+      end
+    end
+
+    private
+
+    attr_reader :params
+  end
+end

data/lib/easy_admin/dashboard_registry.rb

@@ -0,0 +1,30 @@
+module EasyAdmin
+  class DashboardRegistry
+    class << self
+      def dashboards
+        @dashboards ||= {}
+      end
+
+      def register(dashboard_class)
+        route_key = dashboard_class.route_key
+        dashboards[route_key] = dashboard_class
+      end
+
+      def find(route_key)
+        dashboards[route_key.to_s]
+      end
+
+      def all
+        dashboards.values
+      end
+
+      def exists?(route_key)
+        dashboards.key?(route_key.to_s)
+      end
+
+      def clear!
+        @dashboards = {}
+      end
+    end
+  end
+end

data/lib/easy_admin/delete_action.rb

@@ -0,0 +1,22 @@
+module EasyAdmin
+  class DeleteAction < Action
+    # Configure as instant action with confirmation
+    instant(
+      label: "Delete",
+      icon: "🗑️",
+      style: :danger,
+      confirm: "Are you sure you want to delete this record? This action cannot be undone."
+    )
+    
+    def perform
+      # Delete the record
+      record.destroy!
+      
+      {
+        success: true,
+        message: "Record deleted successfully",
+        strategy: :remove # Remove the row from the table
+      }
+    end
+  end
+end

data/lib/easy_admin/engine.rb

@@ -0,0 +1,54 @@
+require "turbo-rails"
+require "devise"
+require_relative "types/json_type"
+
+module EasyAdmin
+  class Engine < ::Rails::Engine
+    isolate_namespace EasyAdmin
+
+    initializer "easy_admin.assets.precompile" do |app|
+      app.config.assets.precompile += %w[
+        easy_admin/application.css
+        easy_admin/dashboards.css
+        easy_admin/date_picker.css
+        easy_admin.base.js
+        jsoneditor-icons.svg
+      ]
+    end
+
+    initializer "easy_admin.phlex" do |app|
+      app.config.autoload_paths = app.config.autoload_paths + [root.join("app", "components").to_s]
+    end
+
+    initializer "easy_admin.register_types" do |app|
+      ActiveModel::Type.register(:json, EasyAdmin::Types::JsonType)
+    end
+
+    initializer "easy_admin.devise" do |app|
+      config.to_prepare do
+        Devise.setup do |config|
+          config.router_name = :easy_admin
+        end
+      end
+    end
+
+    # Load rack-mini-profiler if available and enabled
+    initializer 'easy_admin.rack_mini_profiler', after: :load_config_initializers do |app|
+      begin
+        require 'rack-mini-profiler'
+        # Add middleware to the stack if profiler should be enabled
+        profiler_enabled = begin
+          EasyAdmin.configuration.enable_profiler
+        rescue
+          Rails.env.development?
+        end
+        
+        if profiler_enabled && defined?(Rack::MiniProfiler)
+          app.middleware.use Rack::MiniProfiler
+        end
+      rescue LoadError
+        # rack-mini-profiler not available, skip silently
+      end
+    end
+  end
+end

data/lib/easy_admin/field.rb

@@ -0,0 +1,118 @@
+module EasyAdmin
+  class Field
+    attr_accessor :name, :type, :label, :editable, :options_adapter, :permitted_attached_attributes, :attached_param_key
+
+    def initialize(name, type, options = {})
+      @name = name
+      @type = type
+      @label = options[:label] || name.to_s.humanize
+      @editable = options[:editable]
+      @options_adapter = options[:options_adapter]
+      @permitted_attached_attributes = options[:permitted_attached_attributes] || []
+      @attached_param_key = options[:attached_param_key]
+    end
+
+    def editable?
+      editable.present?
+    end
+
+    def editable_via_menu?
+      type == :belongs_to && editable&.dig(:via) == :menu_or_modal
+    end
+
+    def editable_via_modal?
+      editable? && !editable_via_menu?
+    end
+
+    def permitted_param_key
+      case type
+      when :belongs_to
+        foreign_key || :"#{name}_id"
+      else
+        name
+      end
+    end
+
+    def foreign_key
+      @foreign_key ||= :"#{name}_id"
+    end
+
+    def normalize_input!(attrs)
+      key = permitted_param_key
+      value = attrs[key]
+
+      attrs[key] = case type
+      when :boolean
+        ActiveModel::Type::Boolean.new.cast(value)
+      when :date
+        if value.present?
+          Date.parse(value) rescue value
+        else
+          value
+        end
+      when :datetime
+        if value.present?
+          Time.zone.parse(value) rescue value
+        else
+          value
+        end
+      when :enum
+        # Validate against allowed values if needed
+        validate_enum_value(value)
+      when :json
+        # Parse JSON string to ensure valid JSON
+        if value.present? && value.is_a?(String)
+          begin
+            JSON.parse(value)
+            value
+          rescue JSON::ParserError => e
+            raise "Invalid JSON: #{e.message}"
+          end
+        else
+          value
+        end
+      else
+        value # string, email, number, etc.
+      end
+
+      attrs
+    end
+
+    class << self
+      def render(field_type, action:, **options)
+        component_class = find_component_class(field_type, action)
+        component_class.new(**options)
+      end
+
+      private
+
+      def find_component_class(field_type, action)
+        # Try to find action-specific component first, then fall back to base
+        action_component_name = "EasyAdmin::Fields::#{action.to_s.classify}::#{field_type.to_s.classify}Component"
+
+        begin
+          action_component_name.constantize
+        rescue NameError
+          # Fallback to base text component for the action
+          case action
+          when :index
+            EasyAdmin::Fields::Index::TextComponent
+          when :show
+            EasyAdmin::Fields::Show::TextComponent
+          when :form
+            EasyAdmin::Fields::Form::TextComponent
+          else
+            EasyAdmin::Fields::Index::TextComponent
+          end
+        end
+      end
+    end
+
+    private
+
+    def validate_enum_value(value)
+      return value unless respond_to?(:values) && values.present?
+      values.include?(value) ? value : raise("Invalid enum value: #{value}")
+    end
+  end
+end