cccux 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c1e55d4d139414081a5c7f00ecf389054170abcf49297ec0c7d745afce027a9
-  data.tar.gz: d03b064b695aab0b20a433247eef6e076afcd301de2d1493861ce452c656f54b
+  metadata.gz: afb1191e0b22997a111737dfd7b40e7f3cfb8803cc5046b2091d711ff915dada
+  data.tar.gz: 372d9570edf0194fa3759922a6c1d18e60cd3d8ce2bf4c78fbc4ecdd0be15d61
 SHA512:
-  metadata.gz: a25c77cb991efcd84a02c215c63b9aca1514febfc055074718fb864c0d393ae6ecff3cd4d6a9149016a06107f336e1b0a84b6260e46f47b11752cf548fd8bcb9
-  data.tar.gz: dd0157441f4d61a0a6d21d6744f0c5f060d52bae907ea70751991ccab1441e463ef25ea4472c79109ffefb45eecedb83e2bcea3bb19b6bcab67c1516bac9c768
+  metadata.gz: 0d235d116f1ad65bf811c70e486b29da1d40dc354e96252db8e0d6fd8a5cfa7e99d2c30e3093e5d161c0267e115c8031a6af827ec31cba6f2b64c8b4fa1ca855
+  data.tar.gz: ba3f46415d6a00afc76907be4523a290abfa43441d6f706e4d35d30ab96a8ca664e6df1a2149a48bfe1190d6b4faf5a47bf6c7c310fbe683b34b60060bdb26e1

data/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2025-01-27
+
+### Added
+- **Multi-level Ownership Support**: Enhanced ownership system to support ownership chains (e.g., ProjectManager → Project → Task)
+- **Improved Model Discovery**: Enhanced model discovery to include all application models in role editing interface
+- **Enhanced Authorization Logic**: Improved Ability class to handle complex ownership relationships correctly
+- **Project Management Integration**: Added support for Project, Task, and ProjectManager models with proper authorization
+- **Comprehensive Test Coverage**: Added extensive test coverage for all major components and edge cases
+
+### Fixed
+- **Model Loading Issues**: Fixed Zeitwerk autoloading issues with empty model files
+- **Ownership Chain Logic**: Fixed ownership checking logic to properly traverse ownership relationships
+- **User Registration**: Fixed ActiveModel::UnknownAttributeError during user signup process
+- **Permission Inheritance**: Corrected permission inheritance for project managers and task ownership
+- **Debug Output Removal**: Cleaned up all debug output statements from production code
+- **Test Assertion Warnings**: Fixed auto-generated test methods and missing HTTP requests in tests
+
+### Technical Improvements
+- **Enhanced Test Coverage**: Improved test coverage for complex ownership scenarios
+- **Better Error Handling**: Enhanced error handling for missing models and invalid ownership configurations
+- **Performance Optimizations**: Improved model loading and authorization checking performance
+- **Code Quality**: Removed all debug statements and improved code organization
+
 ## [0.1.2] - 2025-01-27
 
 ### Added

data/app/assets/stylesheets/cccux/application.css

@@ -4,7 +4,7 @@
  * This file contains styles for the CCCUX engine components.
  */
 
-/* Basic styling for CCCUX admin interface */
+/* CCCUX Admin Styles */
 .cccux-admin {
   font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
   line-height: 1.6;
@@ -54,4 +54,73 @@
 .cccux-admin th {
   background: #f8f9fa;
   font-weight: 600;
+}
+
+/* CCCUX Footer Styles */
+.cccux-footer {
+  font-size: 0.9rem;
+  color: #6c757d;
+  margin-top: 1rem;
+  padding: .5rem 0;
+  border-top: 1px solid #e5e5e5;
+  background-color: #f8f9fa;
+}
+
+.cccux-footer .footer-link {
+  color: #red;
+  text-decoration: none;
+  margin: 0 0.5rem;
+
+}
+
+.cccux-footer .footer-link:hover {
+  color: #0056b3;
+  text-decoration: underline;
+}
+
+.cccux-footer .footer-separator {
+  color: #dee2e6;
+  margin: 0 0.25rem;
+}
+
+.cccux-footer .user-info,
+.cccux-footer .auth-links {
+  font-size: 0.85rem;
+}
+
+.cccux-footer .container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 0 1rem;
+}
+
+.cccux-footer .row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-wrap: wrap;
+}
+
+.cccux-footer .col-md-6 {
+  flex: 1;
+  min-width: 300px;
+}
+
+.cccux-footer .text-end {
+  text-align: right;
+}
+
+@media (max-width: 768px) {
+  .cccux-footer .row {
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .cccux-footer .col-md-6 {
+    text-align: center;
+  }
+
+  .cccux-footer .text-end {
+    text-align: center;
+  }
 }

data/app/controllers/cccux/ability_permissions_controller.rb

@@ -149,13 +149,26 @@ module Cccux
       
       # Add route-discovered actions
       route_actions = discover_actions_for_model(subject)
+      Rails.logger.debug "Route actions for #{subject}: #{route_actions}"
       actions += route_actions
+      # Add module-specific custom actions
+      if subject.include?('::')
+        module_name = subject.split('::').first
+        model_name = subject.split('::').last
+        
+        # Discover custom actions for this module's controllers
+        custom_actions = discover_custom_actions_for_module(module_name, model_name)
+        actions += custom_actions
+        Rails.logger.debug "Added #{module_name} custom actions: #{custom_actions}"
+      end
       
       # Add existing actions for this subject
       existing_actions = Cccux::AbilityPermission.where(subject: subject).distinct.pluck(:action).compact
       actions += existing_actions
       
-      actions.uniq.sort
+      final_actions = actions.uniq.sort
+      Rails.logger.debug "Final actions for #{subject}: #{final_actions}"
+      final_actions
     end
 
     def discover_application_models
@@ -188,11 +201,73 @@ module Cccux
       actions = []
       
       begin
-        # Convert subject to potential route patterns
-        resource_name = subject.underscore.pluralize
+        Rails.logger.debug "Discovering actions for subject: #{subject}"
         
-        # For CCCUX models, also check the engine routes
-        if subject.start_with?('Cccux::')
+        # Handle namespaced models (e.g., MegaBar::Page)
+        if subject.include?('::')
+          module_name = subject.split('::').first
+          model_name = subject.split('::').last.underscore.pluralize
+          controller_pattern = "#{module_name.underscore}/#{model_name}"
+          
+          Rails.logger.debug "Namespaced model detected. Looking for controller: #{controller_pattern}"
+          
+          # Try to find the engine for this module
+          engine_class = "#{module_name}::Engine".constantize rescue nil
+          
+          if engine_class
+            Rails.logger.debug "Found engine: #{engine_class}"
+            
+            # Look through engine routes for this namespaced controller
+            engine_class.routes.routes.each do |route|
+              controller_name = route.defaults[:controller]
+              next unless controller_name&.start_with?("#{module_name.underscore}/")
+              next unless route.defaults[:action]
+              
+              action = route.defaults[:action]
+              Rails.logger.debug "Found #{module_name} engine route: #{controller_name}##{action}"
+              
+              # Map HTTP verbs to standard actions and include custom actions
+              case action
+              when 'index' then actions << 'read'
+              when 'show' then actions << 'read'
+              when 'create' then actions << 'create'
+              when 'update' then actions << 'update'
+              when 'destroy' then actions << 'destroy'
+              when 'edit', 'new' then next # Skip these as they're UI actions
+              else
+                # Custom actions like 'move', 'administer_page', etc.
+                actions << action
+              end
+            end
+          else
+            Rails.logger.debug "No engine found for #{module_name}, checking main routes"
+            
+            # Fallback to main Rails routes
+            Rails.application.routes.routes.each do |route|
+              controller_name = route.defaults[:controller]
+              next unless controller_name&.start_with?("#{module_name.underscore}/")
+              next unless route.defaults[:action]
+              
+              action = route.defaults[:action]
+              Rails.logger.debug "Found #{module_name} route: #{controller_name}##{action}"
+              
+              # Map HTTP verbs to standard actions and include custom actions
+              case action
+              when 'index' then actions << 'read'
+              when 'show' then actions << 'read'
+              when 'create' then actions << 'create'
+              when 'update' then actions << 'update'
+              when 'destroy' then actions << 'destroy'
+              when 'edit', 'new' then next # Skip these as they're UI actions
+              else
+                # Custom actions like 'move', 'administer_page', etc.
+                actions << action
+              end
+            end
+          end
+          
+        # Handle CCCUX models
+        elsif subject.start_with?('Cccux::')
           cccux_resource_name = subject.gsub('Cccux::', '').underscore.pluralize
           
           # Look through CCCUX engine routes for this resource
@@ -216,26 +291,31 @@ module Cccux
               end
             end
           end
-        end
-        
-        # Also look through main Rails routes for this resource
-        Rails.application.routes.routes.each do |route|
-          next unless route.path.spec.to_s.include?(resource_name)
           
-          # Extract action from route
-          if route.defaults[:action]
-            action = route.defaults[:action]
-            # Map HTTP verbs to standard actions and include custom actions
-            case action
-            when 'index' then actions << 'read'
-            when 'show' then actions << 'read'
-            when 'create' then actions << 'create'
-            when 'update' then actions << 'update'
-            when 'destroy' then actions << 'destroy'
-            when 'edit', 'new' then next # Skip these as they're UI actions
-            else
-              # Custom actions
-              actions << action
+        # Handle regular models
+        else
+          resource_name = subject.underscore.pluralize
+          Rails.logger.debug "Regular model detected. Resource name: #{resource_name}"
+          
+          # Look through main Rails routes for this resource
+          Rails.application.routes.routes.each do |route|
+            next unless route.path.spec.to_s.include?(resource_name)
+            
+            # Extract action from route
+            if route.defaults[:action]
+              action = route.defaults[:action]
+              # Map HTTP verbs to standard actions and include custom actions
+              case action
+              when 'index' then actions << 'read'
+              when 'show' then actions << 'read'
+              when 'create' then actions << 'create'
+              when 'update' then actions << 'update'
+              when 'destroy' then actions << 'destroy'
+              when 'edit', 'new' then next # Skip these as they're UI actions
+              else
+                # Custom actions
+                actions << action
+              end
             end
           end
         end
@@ -247,6 +327,37 @@ module Cccux
       actions.uniq
     end
 
+    def discover_custom_actions_for_module(module_name, model_name)
+      custom_actions = []
+      
+      begin
+        # Convert model name to controller name pattern
+        controller_name = "#{module_name.downcase}/#{model_name.underscore.pluralize}"
+        
+        Rails.logger.debug "Looking for custom actions in controller: #{controller_name}"
+        
+        # Look through Rails routes for this module's controllers
+        Rails.application.routes.routes.each do |route|
+          next unless route.defaults[:controller]&.start_with?("#{module_name.downcase}/")
+          next unless route.defaults[:action]
+          
+          action = route.defaults[:action]
+          
+          # Skip standard CRUD actions and UI actions
+          next if %w[index show create update destroy new edit].include?(action)
+          
+          # Include custom actions
+          custom_actions << action
+          Rails.logger.debug "Found custom action: #{action} in #{route.defaults[:controller]}"
+        end
+        
+      rescue => e
+        Rails.logger.warn "Error discovering custom actions for #{module_name}::#{model_name}: #{e.message}"
+      end
+      
+      custom_actions.uniq
+    end
+
     def skip_model?(model_class)
       excluded_patterns = [
         /^ActiveRecord::/,

data/app/controllers/cccux/cccux_controller.rb

@@ -51,9 +51,9 @@ module Cccux
           if Rails.env.test?
             format.html { render plain: "Access denied", status: :forbidden }
           else
-            format.html { redirect_to main_app.root_path, alert: 'You must be logged in to access the admin interface.' }
+            format.html { redirect_to main_app.root_path, alert: 'You must be logged in.' }
           end
-          format.json { render json: { success: false, error: 'You must be logged in to access the admin interface.' }, status: :unauthorized }
+          format.json { render json: { success: false, error: 'You must be logged in.' }, status: :unauthorized }
         end
         return
       end

data/app/controllers/cccux/dashboard_controller.rb

@@ -53,6 +53,12 @@ module Cccux
                    alert: "No new permissions were added. Models may already have permissions."
       end
     end
+
+    def clear_model_cache
+      clear_model_discovery_cache
+      redirect_to cccux.model_discovery_path, 
+                 notice: "Model discovery cache cleared! New models should now be visible."
+    end
     
     # Handle any unmatched routes in CCCUX - redirect to home
     def not_found
@@ -62,10 +68,63 @@ module Cccux
     private
 
     def detect_application_models
+      # Use cached results if available
+      return @detected_models_cache if @detected_models_cache
+      
+      # Force Rails to reload constants for better model discovery
+      begin
+        Rails.application.eager_load! if Rails.application.config.eager_load
+      rescue => e
+        Rails.logger.warn "Could not eager load: #{e.message}"
+      end
+      
+      # Also try to load models from app/models directory
+      begin
+        app_models_path = Rails.root.join('app', 'models')
+        if Dir.exist?(app_models_path)
+          Dir.glob(File.join(app_models_path, '**', '*.rb')).each do |model_file|
+            begin
+              load model_file unless $LOADED_FEATURES.include?(model_file)
+            rescue => e
+              Rails.logger.debug "Could not load model file #{model_file}: #{e.message}"
+            end
+          end
+        end
+      rescue => e
+        Rails.logger.warn "Could not load models from app/models: #{e.message}"
+      end
+      
       models = []
       
       begin
-        # Direct approach: Get models from database tables (bypasses all autoloading issues)
+        # Primary approach: Use Rails' built-in model discovery
+        Rails.logger.info "🔍 Using Rails model discovery approach..."
+        
+        # Get all ApplicationRecord descendants (this includes all models)
+        if defined?(ApplicationRecord)
+          ApplicationRecord.descendants.each do |model_class|
+            next if model_class.abstract_class?
+            next if model_class.name.nil?
+            next if skip_model_by_name?(model_class.name)
+            
+            models << model_class.name
+            Rails.logger.debug "Found model via ApplicationRecord: #{model_class.name}"
+          end
+        end
+        
+        # Fallback: Get all ActiveRecord::Base descendants
+        ActiveRecord::Base.descendants.each do |model_class|
+          next if model_class.abstract_class?
+          next if model_class.name.nil?
+          next if skip_model_by_name?(model_class.name)
+          next if models.include?(model_class.name) # Avoid duplicates
+          
+          models << model_class.name
+          Rails.logger.debug "Found model via ActiveRecord::Base: #{model_class.name}"
+        end
+        
+        # Secondary approach: Database table discovery for any missing models
+        Rails.logger.info "🔍 Using database table discovery as backup..."
         
         application_tables = ActiveRecord::Base.connection.tables.reject do |table|
           # Skip Rails internal tables and CCCUX tables
@@ -73,32 +132,46 @@ module Cccux
           skip_table?(table)
         end
         
+        # Discover modules and their table patterns
+        module_table_patterns = discover_module_table_patterns
         
         application_tables.each do |table|
           # Convert table name to model name
           model_name = table.singularize.camelize
           
-          # Verify the model exists and is valid
-          begin
-            if Object.const_defined?(model_name)
-              model_class = Object.const_get(model_name)
-              if model_class.respond_to?(:table_name) && 
-                 model_class.table_name == table &&
-                 !skip_model_by_name?(model_name)
-                models << model_name
-              end
-            else
-              # Model constant doesn't exist yet, but table does - likely a valid model
-              unless skip_model_by_name?(model_name)
+          # Check if this table belongs to a discovered module
+          module_name = find_module_for_table(table, module_table_patterns)
+          if module_name
+            # Extract the model name from the table (e.g., 'pages' from 'mega_bar_pages')
+            # Use the module's table prefix to extract the model name
+            prefix = module_table_patterns[module_name]
+            model_part = table.gsub(prefix, '').singularize.camelize
+            model_name = "#{module_name}::#{model_part}"
+          end
+          
+          # Only add if not already found and not skipped
+          unless models.include?(model_name) || skip_model_by_name?(model_name)
+            # Try to verify the model exists
+            begin
+              if Object.const_defined?(model_name)
+                model_class = Object.const_get(model_name)
+                if model_class.respond_to?(:table_name) && model_class.table_name == table
+                  models << model_name
+                  Rails.logger.debug "Found model via table discovery: #{model_name}"
+                end
+              else
+                # Model constant doesn't exist but table does - likely a valid model
                 models << model_name
+                Rails.logger.debug "Found potential model via table: #{model_name}"
               end
+            rescue => e
+              Rails.logger.debug "Error verifying model #{model_name}: #{e.message}"
             end
-          rescue => e
           end
         end
         
       rescue => e
-        Rails.logger.error "Error detecting models from database: #{e.message}"
+        Rails.logger.error "Error detecting models: #{e.message}"
         Rails.logger.error e.backtrace.join("\n")
       end
       
@@ -112,7 +185,107 @@ module Cccux
       Rails.logger.info "  Application models: #{models.reject { |m| m.start_with?('Cccux::') }.join(', ')}"
       Rails.logger.info "  CCCUX models: #{models.select { |m| m.start_with?('Cccux::') }.join(', ')}"
       
-      models.uniq.sort
+      # Cache the results
+      @detected_models_cache = models.uniq.sort
+      @detected_models_cache
+    end
+
+    def discover_module_table_patterns
+      # Use cached results if available
+      return @module_table_patterns_cache if @module_table_patterns_cache
+      
+      patterns = {}
+      
+      # Skip Rails internal engines and third-party gems
+      skip_engines = %w[
+        Rails ActionView SolidCache Stimulus Turbo Importmap ActiveStorage 
+        ActionCable ActionMailbox BestInPlace SolidCable SolidQueue ActionText 
+        Devise Kaminari Mega132
+      ]
+      
+      # Find Rails engines by looking for Engine classes
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < Rails::Engine
+        next if klass == Rails::Engine # Skip the base class
+        
+        # Extract module name from engine class (e.g., MegaBar::Engine -> MegaBar)
+        module_name = klass.name.split('::').first
+        next if skip_engines.include?(module_name) # Skip unwanted engines
+        
+        # Convert module name to expected table prefix
+        table_prefix = module_name.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '') + '_'
+        patterns[module_name] = table_prefix
+        Rails.logger.info "Discovered engine: #{module_name} with table prefix: #{table_prefix}"
+      end
+      
+      Rails.logger.info "Module table patterns: #{patterns}"
+      
+      # Cache the results
+      @module_table_patterns_cache = patterns
+      @module_table_patterns_cache
+    end
+    
+    def find_table_prefix_for_module(module_name)
+      begin
+        # Look for models in this module
+        module_const = Object.const_get(module_name)
+        
+        # Find the first model in this module to determine the table prefix
+        module_const.constants.each do |const|
+          const_obj = module_const.const_get(const)
+          if const_obj.is_a?(Class) && const_obj < ActiveRecord::Base && const_obj != ActiveRecord::Base
+            table_name = const_obj.table_name
+            # Convert camelCase to snake_case for the prefix
+            expected_prefix = module_name.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '') + '_'
+            if table_name.start_with?(expected_prefix)
+              Rails.logger.debug "Found table prefix for #{module_name}: #{expected_prefix}"
+              return expected_prefix
+            end
+          end
+        end
+      rescue => e
+        Rails.logger.debug "Could not find table prefix for module #{module_name}: #{e.message}"
+      end
+      
+      nil
+    end
+    
+    def find_table_prefix_for_engine(engine_class)
+      begin
+        # Get the module name from the engine class
+        module_name = engine_class.name.split('::').first
+        
+        # Look for models in this module
+        module_const = Object.const_get(module_name)
+        
+        # Find the first model in this module to determine the table prefix
+        module_const.constants.each do |const|
+          const_obj = module_const.const_get(const)
+          if const_obj.is_a?(Class) && const_obj < ActiveRecord::Base && const_obj != ActiveRecord::Base
+            table_name = const_obj.table_name
+            # Convert camelCase to snake_case for the prefix
+            expected_prefix = module_name.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '') + '_'
+            if table_name.start_with?(expected_prefix)
+              Rails.logger.debug "Found table prefix for engine #{module_name}: #{expected_prefix}"
+              return expected_prefix
+            end
+          end
+        end
+      rescue => e
+        Rails.logger.debug "Could not find table prefix for engine #{engine_class.name}: #{e.message}"
+      end
+      
+      nil
+    end
+
+    def find_module_for_table(table_name, module_patterns)
+      module_patterns.each do |module_name, prefix|
+        if table_name.start_with?(prefix)
+          return module_name
+        end
+      end
+      
+      nil
     end
 
     def get_models_with_permissions
@@ -136,6 +309,9 @@ module Cccux
         /Migration/
       ]
       
+      # Don't skip any namespaced models (they should be discoverable)
+      return false if model_name.include?('::')
+      
       excluded_patterns.any? { |pattern| model_name.match?(pattern) }
     end
     
@@ -150,8 +326,18 @@ module Cccux
         'versions' # PaperTrail
       ]
       
+      # Don't skip any module-prefixed tables (they should be discoverable)
+      # This will be handled by the module discovery logic
+      return false if table_name.include?('_') && !excluded_tables.include?(table_name)
+      
       excluded_tables.include?(table_name) ||
       table_name.end_with?('_versions') # PaperTrail version tables
     end
+
+    def clear_model_discovery_cache
+      @detected_models_cache = nil
+      @module_table_patterns_cache = nil
+      Rails.logger.info "🔄 Model discovery cache cleared"
+    end
   end
 end

data/app/helpers/cccux/authorization_helper.rb

@@ -1,13 +1,11 @@
 module Cccux
   module AuthorizationHelper
     # Link helpers for common actions
-    def link_if_can_index(subject, text, path, **opts)
-      can?(:index, subject) ? link_to(text, path, **opts) : ""
-    end
-
-    def link_if_can_show(subject, text, path, **opts)
-      if can?(:show, subject)
-        link_to(text, path, **opts)
+    def link_if_can_with_wrapper(action, subject, text, path, **opts)
+      prepend = opts.delete(:prepend)
+      append = opts.delete(:append)
+      if can?(action, subject)
+        "#{prepend}#{link_to(text, path, **opts)}#{append}".html_safe
       elsif opts.delete(:show_text)
         text
       else
@@ -15,20 +13,28 @@ module Cccux
       end
     end
 
+    def link_if_can_index(subject, text, path, **opts)
+      link_if_can_with_wrapper(:index, subject, text, path, **opts)
+    end
+
+    def link_if_can_show(subject, text, path, **opts)
+      link_if_can_with_wrapper(:show, subject, text, path, **opts)
+    end
+
     def link_if_can_create(subject, text, path, **opts)
-      can?(:create, subject) ? link_to(text, path, **opts) : ""
+      link_if_can_with_wrapper(:create, subject, text, path, **opts)
     end
 
     def link_if_can_edit(subject, text, path, **opts)
-      can?(:edit, subject) ? link_to(text, path, **opts) : ""
+      link_if_can_with_wrapper(:edit, subject, text, path, **opts)
     end
 
     def link_if_can_update(subject, text, path, **opts)
-      can?(:update, subject) ? link_to(text, path, **opts) : ""
+      link_if_can_with_wrapper(:update, subject, text, path, **opts)
     end
 
     def link_if_can_destroy(subject, text, path, **opts)
-      can?(:destroy, subject) ? link_to(text, path, **opts) : ""
+      link_if_can_with_wrapper(:destroy, subject, text, path, **opts)
     end
 
     # Button helpers for common actions

data/app/models/cccux/ability.rb

@@ -172,6 +172,7 @@ module Cccux
       else
         candidates << subject
         candidates << "Cccux::#{subject}"
+      
       end
       
       # Add more candidates for common patterns