propel_api 0.3.1.6 → 0.3.3

data/lib/generators/propel_api/core/named_base.rb

@@ -13,6 +13,17 @@ module PropelApi
     include PropelApi::ConfigurationMethods
     include PropelApi::PathGenerationMethods
     
+    # Shared class options for dependency management
+    class_option :no_auto_fix,
+                 type: :boolean,
+                 default: false,
+                 desc: "Skip automatic dependency cleanup (not recommended)"
+                 
+    class_option :dry_run,
+                 type: :boolean,
+                 default: false,
+                 desc: "Show what would be destroyed without actually doing it"
+    
     protected
 
     def model_exists?
@@ -250,37 +261,33 @@ module PropelApi
       end
     end
 
-    def create_propel_tests(test_types: [])
+    # Rails-reversible shared methods - no conditional logic!
+    def create_propel_model_test
+      template "tests/model_test_template.rb.tt", "test/models/#{file_name}_test.rb"
+    end
+
+    def create_propel_controller_test  
+      template "tests/controller_test_template.rb.tt", "test/controllers/#{controller_path}/#{controller_file_name}_test.rb"
+    end
+
+    def create_propel_integration_test
+      template "tests/integration_test_template.rb.tt", "test/integration/#{file_name}_api_test.rb"  
+    end
+
+    def create_propel_fixtures
       if behavior == :revoke
-        # Remove test files
-        test_types.each do |test_type|
-          case test_type
-          when :model
-            remove_file "test/models/#{file_name}_test.rb"
-          when :controller
-            remove_file "test/controllers/#{controller_path}/#{controller_file_name}_test.rb"
-          when :integration
-            remove_file "test/integration/#{file_name}_api_test.rb"
-          when :fixtures
-            remove_file "test/fixtures/#{table_name}.yml"
-          end
-        end
+        # Rails convention: Keep stub fixture for 'fixtures :all' compatibility
+        empty_fixture_content = "# Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html\n\n# This file was emptied when #{class_name} resource was destroyed\n# Keeping stub file so Rails fixtures :all doesn't break\n"
+        create_file "test/fixtures/#{table_name}.yml", empty_fixture_content
       else
-        # Generate test files
-        test_types.each do |test_type|
-          case test_type
-          when :model
-            template "tests/model_test_template.rb.tt", "test/models/#{file_name}_test.rb"
-          when :controller
-            template "tests/controller_test_template.rb.tt", "test/controllers/#{controller_path}/#{controller_file_name}_test.rb"
-          when :integration
-            template "tests/integration_test_template.rb.tt", "test/integration/#{file_name}_api_test.rb"
-          when :fixtures
-            template "tests/fixtures_template.yml.tt", "test/fixtures/#{table_name}.yml"
-          end
-        end
+        template "tests/fixtures_template.yml.tt", "test/fixtures/#{table_name}.yml"
       end
     end
+    
+    def create_propel_controller_template
+      initialize_propel_api_settings
+      template "scaffold/facet_controller_template.rb.tt", "app/controllers/#{controller_path}/#{controller_file_name}.rb"
+    end
 
     def show_propel_completion_message(resource_type:, generated_files:, next_steps:)
       if behavior == :revoke
@@ -376,41 +383,937 @@ module PropelApi
       false
     end
 
-    # Route management helper methods
-    def insert_routes
-      routes_file = File.join(destination_root, "config/routes.rb")
-      return unless File.exist?(routes_file)
+    # Smart dependency management - automatically fixes dependencies by default
+    def check_for_critical_dependencies
+      if options[:dry_run]
+        show_dry_run_preview
+        return
+      end
       
-      routes_content = File.read(routes_file)
+      critical_dependencies = find_critical_dependencies
       
-      if @api_namespace.present? && @api_version.present?
-        # Both namespace and version: insert into existing or create new structure
-        if has_nested_namespace?(routes_content, @api_namespace, @api_version)
-          resource_line = "    resources :#{route_name}"
-          insert_into_nested_namespace(routes_content, @api_namespace, @api_version, resource_line)
+      if critical_dependencies.any?
+        if options[:no_auto_fix]
+          show_dependency_solution(critical_dependencies)
         else
-          # Create new nested namespace structure
-          # Rails route method adds 2 spaces to each line, so we need to adjust for that
-          route_content = "namespace :#{@api_namespace} do\n  namespace :#{@api_version} do\n    resources :#{route_name}\n  end\nend"
-          route route_content
+          # Default behavior: Auto-fix dependencies (Rails convention over configuration)
+          attempt_auto_fix(critical_dependencies)
         end
-      elsif @api_namespace.present?
-        # Only namespace: insert into existing or create new
-        if has_single_namespace?(routes_content, @api_namespace)
-          resource_line = "  resources :#{route_name}"
-          insert_into_single_namespace(routes_content, @api_namespace, resource_line)
+      end
+      
+      # Note: Targeted fixture repair is handled by individual dependency fixes
+      # No need for system-wide fixture validation
+    end
+
+    def find_critical_dependencies
+      # Only look for actual breaking dependencies, not every mention
+      critical_deps = []
+      
+      # 1. Look for has_many relationships pointing to this resource
+      Dir.glob("#{destination_root}/app/models/*.rb").each do |file|
+        content = File.read(file) rescue next
+        if content.match?(/has_many\s+:#{table_name}/)
+          critical_deps << {
+            type: :has_many_relationship,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "has_many :#{table_name} relationship will break",
+            auto_fixable: true
+          }
+        end
+        
+        # EXACT belongs_to detection - avoid false positives like :meeting_link_parent
+        # Only match EXACT association names: belongs_to :meeting (not :meeting_link_parent)
+        if content.match?(/belongs_to\s+:#{file_name}\b(?!_)/)
+          critical_deps << {
+            type: :belongs_to_relationship,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "belongs_to :#{file_name} relationship will break when #{class_name} model is removed",
+            auto_fixable: true
+          }
+        end
+        
+        # NEW: Model configuration dependencies (facets, validations, etc.)
+        if content.match?(/json_facet.*:#{file_name}/) || content.match?(/json_facet.*:#{file_name}_id/) || content.match?(/include:\s*\[.*:#{file_name}/)
+          critical_deps << {
+            type: :model_configuration,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Model configuration references #{file_name} in json_facet or other config",
+            auto_fixable: true
+          }
+        end
+      end
+      
+      # 2. Look for test setup methods that reference this resource's fixtures
+      Dir.glob("#{destination_root}/test/**/*.rb").each do |file|
+        next if file.include?("#{file_name}_test.rb") # Skip the test we're destroying
+        next if file.include?("#{file_name}_controller_test.rb")
+        next if file.include?("#{file_name}_api_test.rb")
+        
+        content = File.read(file) rescue next
+        # Look for fixture references: transcripts(:one), transcripts(:some_name)  
+        if content.match?(/#{table_name}\(:[^)]+\)/)
+          critical_deps << {
+            type: :test_setup_dependency,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Test setup references #{table_name} fixtures which will no longer exist",
+            auto_fixable: true
+          }
+        end
+        
+        # Use DRY utility for comprehensive test dependency detection
+        if test_reference_patterns(file_name).any? { |pattern| content.match?(Regexp.new(pattern)) }
+          critical_deps << {
+            type: :test_method_dependency,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Test methods reference destroyed #{file_name} fields/associations",
+            auto_fixable: true
+          }
+        end
+      end
+      
+      # 3. Look for fixtures referencing this resource  
+      Dir.glob("#{destination_root}/test/fixtures/*.yml").each do |file|
+        next if file.include?("#{table_name}.yml") # Skip the fixture we're destroying
+        
+        content = File.read(file) rescue next
+        # Use DRY utility for exact fixture pattern detection  
+        fixture_patterns = ["#{file_name}:", "#{file_name}_id:", "#{file_name}_type:"]
+        if fixture_patterns.any? { |pattern| content.include?(pattern) }
+          critical_deps << {
+            type: :fixture_reference,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Fixture references #{file_name} which will no longer exist",
+            auto_fixable: true
+          }
+        end
+        
+        # NEW: Polymorphic fixture syntax: meeting_link_parent: one (Meeting)
+        if content.match?(/.*_parent:\s+\w+\s+\(#{class_name}\)/)
+          critical_deps << {
+            type: :polymorphic_fixture_reference,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Polymorphic fixture references #{class_name} which will no longer exist",
+            auto_fixable: true
+          }
+        end
+      end
+      
+      # 4. Look for class constant references in test files (more common and safer to fix)
+      Dir.glob("#{destination_root}/test/**/*.rb").each do |file|
+        next if file.include?("#{file_name}_test.rb") # Skip the test we're destroying
+        next if file.include?("#{file_name}_controller_test.rb")
+        next if file.include?("#{file_name}_api_test.rb")
+        
+        content = File.read(file) rescue next
+        # Look for is_a?(Agenda) patterns in assertions and polymorphic type checks
+        if content.match?(/\.is_a\?\(#{class_name}\)/)
+          critical_deps << {
+            type: :class_constant_in_test,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Test assertions reference #{class_name} class in polymorphic type checks",
+            auto_fixable: true
+          }
+        end
+      end
+      
+      # 5. Look for direct class constant references (in models, controllers, serialization)  
+      Dir.glob("#{destination_root}/app/**/*.rb").each do |file|
+        content = File.read(file) rescue next
+        # Look for direct class references: Agenda, ::Agenda, class_name: 'Agenda'
+        if content.match?(/\b#{class_name}\b/) && !content.match?(/class\s+#{class_name}/)
+          critical_deps << {
+            type: :class_constant_reference,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Code directly references #{class_name} class which will no longer exist",
+            auto_fixable: false  # Too dangerous to auto-fix class references
+          }
+        end
+      end
+      
+      # 6. Look for polymorphic parent configurations that mention this resource
+      Dir.glob("#{destination_root}/app/models/*.rb").each do |file|
+        content = File.read(file) rescue next
+        # Look for polymorphic parent type arrays or configurations
+        if content.match?(/#{class_name}/) && content.match?(/polymorphic|parent_types|commentable_types/)
+          critical_deps << {
+            type: :polymorphic_parent_config,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Polymorphic configuration references #{class_name} as valid parent type",
+            auto_fixable: true
+          }
+        end
+      end
+
+      # 7. Look for migration files that create references to this resource
+      Dir.glob("#{destination_root}/db/migrate/*.rb").each do |file|
+        content = File.read(file) rescue next
+        if content.match?(/t\.references\s+:#{file_name}/) || content.match?(/add_foreign_key.*#{table_name}/)
+          critical_deps << {
+            type: :migration_reference,
+            file: file.gsub(destination_root + "/", ""),
+            issue: "Migration creates references to #{table_name} table which will not exist",
+            auto_fixable: true  # We can generate cleanup migrations
+          }
+        end
+      end
+      
+      critical_deps
+    end
+
+    def show_dependency_solution(deps)
+      say "\n" + "="*80, :red
+      say "🚫 CANNOT SAFELY DESTROY #{class_name.upcase()}", :red
+      say "="*80, :red
+      say "\n💥 This would break #{deps.size} critical dependencies:", :red
+      
+      deps.each do |dep|
+        say "\n   📁 #{dep[:file]}", :yellow
+        say "      ❌ #{dep[:issue]}", :red
+        if dep[:auto_fixable]
+          say "      ✅ Auto-fixable", :green
+        else
+          say "      ⚠️  Requires manual fix", :yellow
+        end
+      end
+      
+      auto_fixable_count = deps.count { |d| d[:auto_fixable] }
+      
+      if auto_fixable_count > 0
+        say "\n🛠️  Suggested approach:", :blue
+        say "   rails destroy propel_api:resource #{class_name}", :green
+        say "   (Auto-fixes #{auto_fixable_count} of #{deps.size} dependencies by default)", :blue
+      end
+      
+      say "\n💡 Preview first:", :blue  
+      say "   rails destroy propel_api:resource #{class_name} --dry-run", :cyan
+      say "   (See exactly what would be destroyed and fixed)", :blue
+      
+      say "\n" + "="*80, :red
+      exit 1
+    end
+
+    def attempt_auto_fix(deps)
+      say "\n🔧 Auto-fixing #{deps.size} dependencies...", :blue
+      
+      deps.each do |dep|
+        if dep[:auto_fixable]
+          case dep[:type]
+          when :has_many_relationship
+            fix_has_many_relationship(dep)
+          when :belongs_to_relationship
+            fix_belongs_to_relationship(dep)
+          when :test_setup_dependency
+            fix_test_setup_dependency(dep)
+          when :class_constant_in_test
+            fix_class_constant_in_test(dep)
+          when :polymorphic_parent_config
+            fix_polymorphic_parent_config(dep)
+          when :migration_reference
+            fix_migration_reference(dep)
+          when :fixture_reference  
+            fix_fixture_reference(dep)
+          when :model_configuration
+            fix_model_configuration(dep)
+          when :test_method_dependency
+            fix_test_method_dependency(dep)
+          when :polymorphic_fixture_reference
+            fix_polymorphic_fixture_reference(dep)
+          end
+        else
+          say "⚠️  Cannot auto-fix #{dep[:file]}: #{dep[:issue]}", :yellow
+        end
+      end
+    end
+
+    def fix_has_many_relationship(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      
+      # Much more precise pattern that preserves file structure
+      # Match entire line including leading whitespace but preserve surrounding newlines
+      patterns_to_try = [
+        # Pattern 1: Full line with newline
+        /^(\s*)has_many\s+:#{table_name}[^\n]*\n/,
+        # Pattern 2: Line without trailing newline (end of file)
+        /^(\s*)has_many\s+:#{table_name}[^\n]*$/,
+        # Pattern 3: Inline in comment (like our bug)
+        /(\s+)has_many\s+:#{table_name}[^\n]*/
+      ]
+      
+      updated_content = content
+      removed = false
+      
+      patterns_to_try.each do |pattern|
+        if updated_content.match?(pattern)
+          updated_content = updated_content.gsub(pattern) do |match|
+            # If it's an inline match, preserve the leading whitespace as a newline
+            if match.include?('#') && !match.start_with?('#')
+              # This is an inline comment case, replace with just newline
+              "\n"
+            else
+              # This is a full line, remove completely but preserve structure
+              ''
+            end
+          end
+          removed = true
+          break
+        end
+      end
+      
+      if removed
+        # Clean up any resulting double newlines
+        updated_content = updated_content.gsub(/\n\n+/, "\n\n")
+        File.write(file_path, updated_content)
+        say "   ✅ Removed has_many :#{table_name} from #{dep[:file]}", :green
+      else
+        say "   ⚠️  Could not find has_many :#{table_name} in #{dep[:file]}", :yellow
+      end
+    end
+
+    def fix_belongs_to_relationship(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      
+      # Remove belongs_to relationships to the deleted resource
+      # belongs_to :meeting → (removed completely)
+      patterns_to_try = [
+        # Pattern 1: Full line with newline
+        /^(\s*)belongs_to\s+:#{file_name}[^\n]*\n/,
+        # Pattern 2: Line without trailing newline (end of file)
+        /^(\s*)belongs_to\s+:#{file_name}[^\n]*$/
+      ]
+      
+      updated_content = content
+      removed = false
+      
+      patterns_to_try.each do |pattern|
+        if updated_content.match?(pattern)
+          updated_content = updated_content.gsub(pattern, '')
+          removed = true
+          break
+        end
+      end
+      
+      if removed
+        # Clean up any resulting double newlines
+        updated_content = updated_content.gsub(/\n\n+/, "\n\n")
+        File.write(file_path, updated_content)
+        say "   ✅ Removed belongs_to :#{file_name} from #{dep[:file]}", :green
+      else
+        say "   ⚠️  Could not find belongs_to :#{file_name} in #{dep[:file]}", :yellow
+      end
+    end
+
+    def fix_test_setup_dependency(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      # Smart semantic analysis: understand variable relationships
+      # Example: @agenda = agendas(:one); @section_parent = @agenda
+      
+      changes_made = []
+      alternative_fixture = find_alternative_fixture_for_tests
+      
+      # 1. Find what variables use the deleted resource (BROADER: any variable name)
+      # Match ANY variable assigned from destroyed fixtures: @any_name = meetings(:fixture)
+      resource_var_pattern = /@(\w+)\s*=\s*#{table_name}\([^)]+\)/
+      resource_variables = content.scan(resource_var_pattern).flatten
+      
+      # 2. For each variable, find what other variables depend on it
+      dependent_variables = {}
+      resource_variables.each do |var_name|
+        # Look for: @section_parent = @agenda
+        dependent_pattern = /@(\w+)\s*=\s*@#{var_name}\b/
+        dependencies = content.scan(dependent_pattern).flatten
+        dependent_variables[var_name] = dependencies
+      end
+      
+      # 3. Handle fixture assignments with proper Rails polymorphic pattern recognition
+      assignment_pattern = /^(\s*)(@\w+)\s*=\s*#{table_name}\([^)]+\)(.*?)$/
+      
+      updated_content = content.gsub(assignment_pattern) do |match|
+        indentation = $1
+        variable_name = $2    # "@meeting" or "@agenda_parent" or "@commentable"
+        comment_part = $3     # "  # was @meeting  # Default polymorphic parent for tests"
+        
+        # Rails polymorphic pattern recognition: _parent, _able, _ible suffixes
+        is_polymorphic = variable_name.match?(/_parent$|_able$|_ible$/)
+        
+        if is_polymorphic && alternative_fixture
+          # Polymorphic association: Keep same variable name, change fixture
+          "#{indentation}#{variable_name} = #{alternative_fixture}  # was #{table_name}(:one)#{comment_part}"
+        elsif alternative_fixture
+          # Direct association: Rename variable to match new fixture type and update assignment
+          # @meeting = meetings(:one) → @organization = organizations(:acme_org) 
+          new_fixture_type = alternative_fixture.split('(').first  # "organizations(:acme_org)" → "organizations"
+          new_variable_name = "@#{simple_singularize(new_fixture_type)}"   # "@organization"
+          "#{indentation}#{new_variable_name} = #{alternative_fixture}  # was #{variable_name} = #{table_name}(:one)#{comment_part}"
+        else
+          # No alternative available: Comment out entirely
+          "#{indentation}# #{variable_name} = #{table_name}(:one) - REMOVED: #{table_name} resource destroyed#{comment_part}"
+        end
+      end
+      
+      if updated_content != content
+        changes_made << "handled #{table_name} fixture assignments (polymorphic vs direct)"
+        content = updated_content
+      end
+      
+      # 4. Update dependent variables to use alternative fixtures
+      resource_variables.each do |var_name|
+        dependent_variables[var_name].each do |dependent_var|
+          if alternative_fixture
+            # @section_parent = @agenda → @section_parent = meetings(:one)
+            pattern = /(@#{dependent_var}\s*=\s*)@#{var_name}\b/
+            updated_content = content.gsub(pattern) do |match|
+              assignment_part = $1
+              "#{assignment_part}#{alternative_fixture}  # was @#{var_name}"
+            end
+            if updated_content != content
+              changes_made << "updated @#{dependent_var} to use #{alternative_fixture.split('(').first}"
+              content = updated_content
+            end
+          else
+            # Remove the dependent assignment if no alternative available
+            updated_content = content.gsub(/^(\s*)@#{dependent_var}\s*=\s*@#{var_name}\b.*$\n?/, '')
+            if updated_content != content
+              changes_made << "removed @#{dependent_var} assignment"
+              content = updated_content
+            end
+          end
+        end
+      end
+      
+      # 5. Remove any remaining references to the deleted variables
+      resource_variables.each do |var_name|
+        # Remove lines that call methods on the deleted variable
+        var_usage_pattern = /^.*@#{var_name}\..*$\n?/
+        updated_content = content.gsub(var_usage_pattern, '')
+        if updated_content != content
+          changes_made << "removed lines using @#{var_name}"
+          content = updated_content
+        end
+      end
+      
+      # 6. Clean up formatting
+      updated_content = content.gsub(/\n\n+/, "\n\n")
+      
+      if updated_content != original_content
+        File.write(file_path, updated_content)
+        say "   ✅ Cleaned up #{dep[:file]} (#{changes_made.join(', ')})", :green
+      else
+        say "   ⚠️  No changes needed in #{dep[:file]}", :blue
+      end
+    end
+
+    def find_alternative_fixture_for_tests
+      # Dynamically find available fixture files (works for any Rails app schema)
+      fixture_files = Dir.glob("#{destination_root}/test/fixtures/*.yml")
+      
+      # Filter out the resource we're destroying and system fixtures
+      available_fixtures = fixture_files.map { |f| File.basename(f, '.yml') }
+        .reject { |name| name == table_name }  # Skip the one we're destroying
+        .reject { |name| name.start_with?('noticed_') }  # Skip notification system fixtures
+        .reject { |name| name == 'active_storage_blobs' || name == 'active_storage_attachments' }  # Skip Active Storage
+      
+      return nil if available_fixtures.empty?
+      
+      # Prioritize by Rails naming patterns (generic approach)
+      # 1. Look for fixtures that commonly serve as polymorphic parents (by naming patterns)
+      organization_like = available_fixtures.find { |name| name.include?('organization') || name.include?('company') || name.include?('account') }
+      user_like = available_fixtures.find { |name| name.include?('user') || name.include?('person') || name.include?('member') }
+      project_like = available_fixtures.find { |name| name.include?('project') || name.include?('workspace') || name.include?('team') }
+      
+      # Get the prioritized fixture file name
+      chosen_fixture_file = [organization_like, user_like, project_like].compact.first ||
+                           available_fixtures.sort.first
+      
+      return nil unless chosen_fixture_file
+      
+      # CRITICAL FIX: Read the actual fixture file to find real fixture names
+      fixture_path = "#{destination_root}/test/fixtures/#{chosen_fixture_file}.yml"
+      begin
+        require 'yaml'
+        fixture_data = YAML.load_file(fixture_path) || {}
+        first_fixture_name = fixture_data.keys.first
+        
+        return first_fixture_name ? "#{chosen_fixture_file}(:#{first_fixture_name})" : nil
+      rescue => e
+        # Fallback: assume :one exists (old behavior)
+        say "   ⚠️  Could not read #{fixture_path}: #{e.message}. Using fallback.", :yellow
+        return "#{chosen_fixture_file}(:one)"
+      end
+    end
+
+    def fix_class_constant_in_test(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      # Remove this class from polymorphic type assertions
+      # assert(@obj.is_a?(Agenda) || @obj.is_a?(Meeting)) → assert(@obj.is_a?(Meeting))
+      
+      changes_made = []
+      
+      # Pattern 1: Remove from OR chains: @obj.section_parent.is_a?(Agenda) || @obj.is_a?(Other)
+      # Handle complex object paths like @section.section_parent.is_a?(Class)
+      or_pattern = /(\|\|\s*)?@[\w.]+\.is_a\?\(#{class_name}\)(\s*\|\|)?/
+      updated_content = content.gsub(or_pattern) do |match|
+        has_leading_or = $1.present?
+        has_trailing_or = $2.present?
+        
+        if has_leading_or && has_trailing_or
+          # Middle of chain: || @obj.is_a?(Agenda) || → ||
+          ' || '
+        elsif has_leading_or
+          # End of chain: || @obj.is_a?(Agenda) → (remove)
+          ''
+        elsif has_trailing_or
+          # Start of chain: @obj.is_a?(Agenda) || → (remove)
+          ''
+        else
+          # Only item: @obj.is_a?(Agenda) → (remove completely)
+          ''
+        end
+      end
+      
+      if updated_content != content
+        changes_made << "removed #{class_name} from polymorphic type assertions"
+        content = updated_content
+      end
+      
+      # Pattern 2: Clean up malformed OR chains (|| ||, leading ||, trailing ||)
+      updated_content = content.gsub(/\|\|\s*\|\|/, '||')  # Fix double ORs
+      updated_content = updated_content.gsub(/\(\s*\|\|/, '(')  # Fix leading OR in parentheses
+      updated_content = updated_content.gsub(/\|\|\s*\)/, ')')  # Fix trailing OR in parentheses
+      
+      if updated_content != content
+        changes_made << "cleaned up assertion syntax"
+        content = updated_content
+      end
+      
+      if changes_made.any?
+        File.write(file_path, content)
+        say "   ✅ Fixed class constants in #{dep[:file]} (#{changes_made.join(', ')})", :green
+      else
+        say "   ⚠️  Could not find class constant patterns in #{dep[:file]}", :yellow
+      end
+    end
+
+    def fix_polymorphic_parent_config(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      changes_made = []
+      
+      # 1. Look for inclusion validations: validates :type, inclusion: { in: %w[Agenda Meeting] }
+      inclusion_pattern = /(validates\s+:\w+.*inclusion:\s*\{\s*in:\s*%w\[)([^\]]*)(.*)/
+      updated_content = content.gsub(inclusion_pattern) do |match|
+        prefix = $1
+        type_list = $2
+        suffix = $3
+        
+        # Remove our class from the list
+        updated_list = type_list.split.reject { |type| type == class_name }.join(' ')
+        
+        if updated_list != type_list
+          changes_made << "removed #{class_name} from validation inclusion list"
+          "#{prefix}#{updated_list}#{suffix}"
+        else
+          match  # No change needed
+        end
+      end
+      
+      # 2. Look for other array configurations that might list parent types
+      # VALID_PARENT_TYPES = %w[Agenda Meeting Project]
+      array_config_pattern = /(\w+\s*=\s*%w\[)([^\]]*)(.*)/
+      updated_content = content.gsub(array_config_pattern) do |match|
+        prefix = $1
+        type_list = $2
+        suffix = $3
+        
+        if type_list.include?(class_name)
+          updated_list = type_list.split.reject { |type| type == class_name }.join(' ')
+          changes_made << "removed #{class_name} from parent type configuration"
+          "#{prefix}#{updated_list}#{suffix}"
+        else
+          match  # No change needed
+        end
+      end
+      
+      if updated_content != original_content
+        File.write(file_path, updated_content)
+        say "   ✅ Updated polymorphic configurations in #{dep[:file]} (#{changes_made.join(', ')})", :green
+      else
+        say "   ⚠️  Could not find polymorphic configurations to fix in #{dep[:file]}", :yellow
+        say "      Look for #{class_name} in parent type lists and remove it manually", :cyan
+      end
+    end
+
+    def fix_migration_reference(dep)
+      # Generate a cleanup migration to remove foreign key constraints
+      # This is safer than editing existing migration files
+      migration_file = dep[:file]
+      table_with_reference = extract_table_name_from_migration_file(migration_file)
+      
+      if table_with_reference
+        # Generate cleanup migration with CURRENT timestamp (Rails-standard sequential approach)
+        # This runs AFTER problematic migrations and cleans up orphaned foreign keys
+        base_timestamp = Time.current.utc.strftime("%Y%m%d%H%M%S")
+        timestamp = generate_unique_timestamp(base_timestamp)
+        cleanup_migration_name = "RemoveOrphanedForeignKeyFrom#{table_with_reference.classify}To#{class_name.pluralize}"
+        cleanup_migration_file = "#{timestamp}_#{cleanup_migration_name.underscore}.rb"
+        cleanup_migration_path = "db/migrate/#{cleanup_migration_file}"
+        
+        cleanup_content = <<~MIGRATION
+          class #{cleanup_migration_name} < ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]
+            def up
+              # Rails-standard sequential cleanup: Remove orphaned foreign key references
+              # This runs AFTER creation migrations that may have failed due to missing #{table_name} table
+              
+              # Remove foreign key constraint if it exists (may not exist if creation migration failed)
+              if foreign_key_exists?(:#{table_with_reference}, :#{table_name})
+                remove_foreign_key :#{table_with_reference}, :#{table_name}
+                say "✅ Removed foreign key constraint from #{table_with_reference} to #{table_name}"
+              else
+                say "ℹ️  No foreign key constraint found from #{table_with_reference} to #{table_name} (may have failed during creation)"
+              end
+              
+              # Remove the #{file_name}_id column if it exists
+              if column_exists?(:#{table_with_reference}, :#{file_name}_id)
+                remove_column :#{table_with_reference}, :#{file_name}_id
+                say "✅ Removed #{file_name}_id column from #{table_with_reference}"
+              else
+                say "ℹ️  No #{file_name}_id column found in #{table_with_reference}"
+              end
+            end
+            
+            def down
+              # Cannot reverse removal of orphaned foreign key references
+              raise ActiveRecord::IrreversibleMigration, "Cannot restore foreign key to deleted #{table_name} table"
+            end
+          end
+        MIGRATION
+        
+        File.write(File.join(destination_root, cleanup_migration_path), cleanup_content)
+        say "   ✅ Generated cleanup migration: #{cleanup_migration_file}", :green
+        say "      Rails-standard approach: Cleans up orphaned #{file_name}_id references", :blue
+      else
+        say "   ⚠️  Could not determine table name from #{migration_file}", :yellow
+      end
+    end
+
+    def extract_table_name_from_migration_file(migration_file)
+      # Extract table name from migration file name: create_action_item_reports.rb → action_item_reports
+      basename = File.basename(migration_file, '.rb')
+      if basename.match?(/create_(\w+)/)
+        basename.match(/create_(\w+)/)[1]
+      else
+        nil
+      end
+    end
+
+    def generate_unique_timestamp(base_timestamp)
+      # Ensure we generate a unique 14-digit timestamp by incrementing seconds if needed
+      timestamp = base_timestamp
+      counter = 0
+      
+      while Dir.glob("#{destination_root}/db/migrate/#{timestamp}_*.rb").any?
+        # Increment timestamp by 1 second to avoid collision
+        time = Time.strptime(base_timestamp, "%Y%m%d%H%M%S")
+        timestamp = (time + counter + 1).utc.strftime("%Y%m%d%H%M%S")
+        counter += 1
+        
+        # Safety check to prevent infinite loop
+        break if counter > 60
+      end
+      
+      timestamp
+    end
+
+    def fix_fixture_reference(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      changes_made = []
+      
+      # Parse and fix YAML fixture file using simple, direct approach
+      begin
+        require 'yaml'
+        
+        # Load YAML while preserving structure and comments
+        yaml_data = YAML.load(content) || {}
+        
+        # Direct removal of destroyed resource references (simplified approach)
+        yaml_data.each do |fixture_name, fixture_data|
+          next unless fixture_data.is_a?(Hash)
+          
+          # Use DRY utility for exact fixture key cleanup
+          [file_name, "#{file_name}_id", "#{file_name}_type"].each do |exact_key|
+            if fixture_data.key?(exact_key)
+              fixture_data.delete(exact_key)
+              changes_made << "removed #{exact_key} reference from #{fixture_name}"
+            end
+          end
+        end
+        
+        if changes_made.any?
+          # Write back to file while preserving YAML structure
+          updated_content = YAML.dump(yaml_data)
+          
+          # Preserve original file header if it exists
+          if content.start_with?('# Read about fixtures')
+            header_lines = content.lines.take_while { |line| line.strip.start_with?('#') || line.strip.empty? }
+            updated_content = header_lines.join + "\n" + updated_content
+          end
+          
+          File.write(file_path, updated_content)
+          say "   ✅ Fixed fixture references in #{dep[:file]} (#{changes_made.join(', ')})", :green
         else
-          # Create new namespace
-          # Rails route method adds 2 spaces to each line, so we need to adjust for that
-          route_content = "namespace :#{@api_namespace} do\n  resources :#{route_name}\nend"
-          route route_content
+          say "   ℹ️  No #{file_name} references found in #{dep[:file]}", :blue
+        end
+        
+      rescue => e
+        # Fallback to manual review if YAML parsing fails
+        say "   ⚠️  Could not auto-fix fixture file #{dep[:file]}: #{e.message}", :yellow
+        say "      Please manually remove '#{file_name}:' and '#{file_name}_id:' references", :cyan
+      end
+    end
+
+    def get_valid_fixture_keys_for_model(model_class)
+      # Get valid fixture keys: database columns + Rails association names
+      valid_keys = []
+      
+      # 1. Add all actual database columns
+      valid_keys += model_class.columns.map(&:name)
+      
+      # 2. Add Rails association names (fixtures can reference associations)
+      # belongs_to :organization allows fixture to use: organization: fixture_name
+      model_class.reflect_on_all_associations.each do |association|
+        # Only include associations where the target model actually exists
+        begin
+          association.class_name.constantize  # Check if target model exists
+          valid_keys << association.name.to_s
+        rescue NameError
+          # Target model doesn't exist - this IS an invalid reference
+          # Don't include it in valid_keys so it gets removed
+        end
+      end
+      
+      valid_keys.uniqnt w
+    end
+
+    def show_dry_run_preview
+      say "\n" + "="*70, :blue
+      say "🔍 DRY RUN: What would be destroyed", :blue  
+      say "="*70, :blue
+      
+      files_to_destroy = [
+        "app/models/#{file_name}.rb",
+        "app/controllers/#{controller_path}/#{controller_file_name}.rb",
+        "test/models/#{file_name}_test.rb",
+        "test/controllers/#{controller_path}/#{controller_file_name}_test.rb",
+        "test/integration/#{file_name}_api_test.rb",
+        "test/fixtures/#{table_name}.yml"
+      ]
+      
+      say "\n📁 Files that would be removed:", :green
+      files_to_destroy.each { |file| say "   ❌ #{file}", :red }
+      
+      critical_deps = find_critical_dependencies
+      if critical_deps.any?
+        say "\n💥 Dependencies that would break:", :red
+        critical_deps.each do |dep|
+          say "   📁 #{dep[:file]} - #{dep[:issue]}", :yellow
         end
       else
-        # No namespace: simple resources
+        say "\n✅ No critical dependencies found - safe to destroy", :green
+      end
+      
+      say "\n" + "="*70, :blue
+      exit 0
+    end
+
+    # Database migration management methods - available to all generators
+    def generate_removal_migration
+      # Generate a proper Rails migration to remove the table and foreign keys
+      # This follows Rails conventions and maintains database integrity
+      
+      # Use current timestamp - Rails-standard sequential approach
+      base_timestamp = Time.current.utc.strftime("%Y%m%d%H%M%S")
+      timestamp = generate_unique_timestamp(base_timestamp)
+      migration_name = "Remove#{class_name.pluralize}Table"
+      migration_file = "#{timestamp}_#{migration_name.underscore}.rb"
+      migration_path = "db/migrate/#{migration_file}"
+      
+      # Check if table exists in database before generating removal migration
+      if table_exists_in_database?
+        say "Generating removal migration for #{class_name}...", :blue
+        
+        migration_content = build_removal_migration_content(migration_name)
+        # Use File.write instead of create_file to avoid Rails auto-reversal
+        File.write(File.join(destination_root, migration_path), migration_content)
+        
+        say "✅ Generated removal migration: #{migration_file}", :green
+        say "💡 Run 'rails db:migrate' to execute the removal", :blue
+      else
+        say "Table #{table_name} doesn't exist in database - skipping removal migration", :yellow
+        say "💡 Note: If you have unused creation migrations, remove them manually when safe", :blue
+      end
+    end
+
+    def table_exists_in_database?
+      return false unless defined?(ActiveRecord::Base)
+      
+      begin
+        ActiveRecord::Base.connection.table_exists?(table_name)
+      rescue => e
+        # If we can't check (database not connected, etc.), assume it doesn't exist
+        false
+      end
+    end
+
+    def build_removal_migration_content(migration_name)
+      # Note: Don't duplicate foreign key removal here since cleanup migrations handle it
+      # The cleanup migrations generated by fix_migration_reference already remove foreign keys safely
+      
+      content = <<~MIGRATION
+        class #{migration_name} < ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]
+          def up
+            # Drop the #{table_name} table (foreign keys already removed by cleanup migrations)
+            drop_table :#{table_name} if table_exists?(:#{table_name})
+          end
+          
+          def down
+            # Note: This is a destructive migration. 
+            # Reversing it would require recreating the original table structure
+            # and data, which is beyond the scope of automated generation.
+            raise ActiveRecord::IrreversibleMigration, "Cannot reverse removal of #{table_name}"
+          end
+        end
+      MIGRATION
+      
+      content
+    end
+
+    def find_foreign_keys_to_table
+      return [] unless defined?(ActiveRecord::Base)
+      
+      begin
+        # Find all foreign keys that point to our table
+        foreign_keys = []
+        
+        ActiveRecord::Base.connection.tables.each do |table|
+          next if table == table_name  # Skip our own table
+          
+          ActiveRecord::Base.connection.foreign_keys(table).each do |fk|
+            if fk.to_table == table_name
+              foreign_keys << {
+                from_table: table,
+                to_table: table_name,
+                column: fk.column
+              }
+            end
+          end
+        end
+        
+        foreign_keys
+      rescue => e
+        # If we can't introspect the database, return empty array
+        []
+      end
+    end
+
+    def show_destroy_completion_message
+      say "\n" + "="*70, :red
+      say "🗑️  Resource Destroyed Successfully!", :red
+      say "="*70, :red
+      
+      say "\n📦 Files removed:", :red
+      removed_files = [
+        "📄 Model: app/models/#{file_name}.rb",
+        "🎮 Controller: app/controllers/#{controller_path}/#{controller_file_name}.rb", 
+        "🧪 Tests: test/models/#{file_name}_test.rb and related",
+        "📋 Fixtures: test/fixtures/#{table_name}.yml",
+        "🌱 Seeds: db/seeds/#{table_name}_seeds.rb"
+      ]
+      removed_files.each { |file| say "   #{file}", :red }
+      
+      if table_exists_in_database?
+        say "\n🗄️  Database removal:", :blue
+        say "   📋 Generated removal migration for #{table_name} table", :blue
+        say "   🧹 Generated cleanup migrations for orphaned foreign keys", :blue
+        say "   ⚙️  Run 'rails db:migrate' to execute removal and cleanup", :yellow
+      else
+        say "\n🗄️  Database cleanup:", :blue  
+        say "   🧹 Generated cleanup migrations for orphaned foreign key references", :blue
+        say "   ⚙️  Run 'rails db:migrate' to clean up broken references", :yellow
+        say "   💡 This follows Rails-standard sequential migration approach", :cyan
+      end
+      
+      say "\n💡 Next steps (Rails-standard workflow):", :blue
+      say "   1. rails db:migrate  (apply cleanup migrations)", :yellow
+      say "   2. Check for any manual customizations to remove", :blue
+      say "   3. Manually remove old migration files when safe", :cyan
+      say "      (#{class_name} creation migration can be removed after cleanup)"
+      
+      say "="*70, :red
+    end
+
+    # Route management helper methods - using Rails' gsub_file for proper insertion
+    def insert_routes
+      return if route_already_exists?
+
+      if @api_namespace.present? && @api_version.present?
+        insert_nested_namespace_route
+      elsif @api_namespace.present?
+        insert_single_namespace_route
+      else
         route "resources :#{route_name}"
       end
     end
 
+    private
+
+    def insert_nested_namespace_route
+      routes_file = File.join(destination_root, "config/routes.rb")
+      routes_content = File.read(routes_file)
+      
+      # Look for the nested namespace pattern and insert after it (flexible whitespace matching)
+      nested_pattern = /namespace\s+:#{@api_namespace}\s+do\s*\n\s*namespace\s+:#{@api_version}\s+do\s*\n/
+      
+      if routes_content.match?(nested_pattern)
+        # Use gsub_file to replace the namespace opening with namespace + our resource
+        gsub_file "config/routes.rb", nested_pattern do |match|
+          match + "      resources :#{route_name}\n"
+        end
+      else
+        # Create new namespace block using Rails' route method
+        route "namespace :#{@api_namespace} do\n  namespace :#{@api_version} do\n    resources :#{route_name}\n  end\nend"
+      end
+    end
+
+    def insert_single_namespace_route
+      routes_file = File.join(destination_root, "config/routes.rb")
+      routes_content = File.read(routes_file)
+      
+      # Look for the single namespace pattern and insert after it
+      single_pattern = /namespace\s+:#{@api_namespace}\s+do\s*\n/
+      
+      if routes_content.match?(single_pattern)
+        # Use gsub_file to replace the namespace opening with namespace + our resource
+        gsub_file "config/routes.rb", single_pattern do |match|
+          match + "    resources :#{route_name}\n"
+        end
+      else
+        # Create new namespace block using Rails' route method
+        route "namespace :#{@api_namespace} do\n  resources :#{route_name}\nend"
+      end
+    end
+
     def remove_routes
       routes_file = File.join(destination_root, "config/routes.rb")
       return unless File.exist?(routes_file)
@@ -449,58 +1352,13 @@ module PropelApi
       end
     end
 
-    def has_nested_namespace?(content, namespace, version)
-      content.match?(/namespace\s+:#{namespace}\s+do.*?namespace\s+:#{version}\s+do/m)
-    end
-    
-    def has_single_namespace?(content, namespace)
-      content.match?(/namespace\s+:#{namespace}\s+do/)
-    end
-    
-    def insert_into_nested_namespace(content, namespace, version, resource_line)
-      # Check if resource already exists
-      existing_pattern = /namespace\s+:#{namespace}\s+do.*?namespace\s+:#{version}\s+do.*?resources\s+:#{route_name}/m
-      
-      if content.match?(existing_pattern)
-        say "Route for #{route_name} already exists in #{namespace}/#{version} namespace", :yellow
-        return
-      end
-      
-      # Find the position to insert the resource line
-      # Look for the end of the nested namespace's opening line
-      after_pattern = /namespace\s+:#{namespace}\s+do\s*\n\s*namespace\s+:#{version}\s+do\s*\n/
-      
-      if content.match?(after_pattern)
-        # Insert the resource line with proper indentation (4 spaces for nested namespace)
-        insert_into_file "config/routes.rb", "#{resource_line}\n", :after => after_pattern
-      else
-        # This shouldn't happen if has_nested_namespace? returned true, but handle it
-        route_content = "namespace :#{namespace} do\n  namespace :#{version} do\n#{resource_line}\n  end\nend"
-        route route_content
-      end
-    end
-
-    def insert_into_single_namespace(content, namespace, resource_line)
-      # Check if resource already exists
-      existing_pattern = /namespace\s+:#{namespace}\s+do.*?resources\s+:#{route_name}/m
-      
-      if content.match?(existing_pattern)
-        say "Route for #{route_name} already exists in #{namespace} namespace", :yellow
-        return
-      end
-      
-      # Find the position to insert the resource line
-      # Look for the end of the namespace's opening line
-      after_pattern = /namespace\s+:#{namespace}\s+do\s*\n/
+    def route_already_exists?
+      routes_file = File.join(destination_root, "config/routes.rb")
+      return false unless File.exist?(routes_file)
       
-      if content.match?(after_pattern)
-        # Insert the resource line with proper indentation (resource_line already has correct 2 spaces)
-        insert_into_file "config/routes.rb", "#{resource_line}\n", :after => after_pattern
-      else
-        # This shouldn't happen if has_single_namespace? returned true, but handle it
-        route_content = "namespace :#{namespace} do\n    resources :#{route_name}\n  end"
-        route route_content
-      end
+      routes_content = File.read(routes_file)
+      # Check for actual route declarations (not comments) - must be at start of line or after whitespace  
+      routes_content.match?(/^\s*resources\s+:#{Regexp.escape(route_name)}(\s|$)/)
     end
 
     def cleanup_empty_namespaces(content)
@@ -597,12 +1455,74 @@ module PropelApi
         type_field: poly_assoc[:type_field],
         parent_type: parent_type,
         parent_table: parent_type.underscore.pluralize,
-        fixture_name: fixture_name
+        fixture_name: fixture_name,
+        fixture_id: fixture_index + 1  # Rails standard: fixtures one=1, two=2, three=3
       }
     end
 
     private
 
+    # === REUSABLE REGEX UTILITIES ===
+    # DRY: Common pattern matching used across multiple fix methods
+    
+    def exact_field_patterns(field_name)
+      # EXACT symbol matches only (prevents false positives like :meeting_link_parent)
+      [
+        ":#{field_name}_id\\b",       # :meeting_id (exact symbol)
+        ":#{field_name}\\b(?!\\w)",   # :meeting (exact, not :meeting_history)  
+        ":#{field_name}_type\\b"      # :meeting_type (polymorphic)
+      ]
+    end
+
+    def test_reference_patterns(field_name)
+      # Common test reference patterns across all test types
+      [
+        "\\.#{field_name}_id\\b",               # @obj.meeting_id
+        "\\.#{field_name}\\s*=",                # @obj.meeting = nil
+        "\\.#{field_name}\\(",                  # @obj.meeting()
+        ":#{field_name}\\)",                    # assert_respond_to(@obj, :meeting)
+        "#{field_name}:",                       # meeting: @meeting (test data)
+        "#{field_name}_id:",                    # meeting_id: 123 (test data)
+        "\"#{field_name}\"",                    # "meeting" (string expectations)
+        "'#{field_name}'",                      # 'meeting' (string expectations)
+        "assert_includes.*#{field_name}",       # assert_includes(..., "meeting")
+      ]
+    end
+
+    def apply_content_replacements(content, field_name, class_name)
+      # DRY: Common content replacement logic used across fix methods
+      changes_made = []
+      
+      # Field access cleanup
+      if content.gsub!(/.*\.#{field_name}_id\b.*\n/, "      # #{field_name}_id field removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name}_id field access"
+      end
+      
+      if content.gsub!(/.*\.#{field_name}\s*=.*\n/, "      # #{field_name} assignment removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name} assignment"
+      end
+      
+      # Assertion cleanup  
+      if content.gsub!(/.*assert_respond_to.*:#{field_name}\b.*\n/, "      # #{field_name} assertion removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name} assertion"
+      end
+      
+      if content.gsub!(/.*assert_includes.*["']#{field_name}["'].*\n/, "      # #{field_name} expectation removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name} facet expectation"
+      end
+      
+      # Test data cleanup
+      if content.gsub!(/.*#{field_name}:.*\n/, "      # #{field_name}: removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name} test data"
+      end
+      
+      if content.gsub!(/.*#{field_name}_id:.*\n/, "      # #{field_name}_id: removed when #{class_name} destroyed\n")
+        changes_made << "removed #{field_name}_id test data"
+      end
+      
+      changes_made
+    end
+
     def parse_polymorphic_parent_types
       return {} unless defined?(options) && options[:parents]
       
@@ -629,5 +1549,173 @@ module PropelApi
       # Ensure we always return at least one model as fallback
       models.empty? ? [] : models
     end
+
+    # DRY: Fix model configuration using reusable utilities
+    def fix_model_configuration(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      changes_made = []
+      
+      # Use DRY utility for exact field pattern matching
+      exact_field_patterns(file_name).each do |pattern|
+        # Apply pattern with word boundaries to prevent partial matches
+        regex_pattern = /#{pattern},?\s*/
+        updated_content = content.gsub(regex_pattern, '')
+        
+        if updated_content != content
+          changes_made << "removed field reference"
+          content = updated_content
+        end
+      end
+      
+      # Clean up trailing commas and empty arrays
+      content = content.gsub(/,\s*\]/, ']').gsub(/\[\s*,/, '[').gsub(/,\s*,/, ',')
+      
+      if content != original_content
+        File.write(file_path, content)
+        say "   ✅ Fixed model configuration in #{dep[:file]} (#{changes_made.join(', ')})", :green
+      else
+        say "   ℹ️  No #{file_name} configuration found in #{dep[:file]}", :blue
+      end
+    end
+
+    # DRY: Comprehensive test cleanup using reusable utilities
+    def fix_test_method_dependency(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      changes_made = []
+      
+      # 1. Remove test methods that test destroyed associations (IMPROVED: proper method structure)
+      # Match complete test method from declaration to matching end with proper indentation
+      test_method_pattern = /^(\s*)test\s+"[^"]*#{file_name}[^"]*"\s+do\s*$.*?^\1end\s*$/m
+      
+      updated_content = content.gsub(test_method_pattern) do |match|
+        indentation = $1 || "  "  # Preserve original indentation
+        changes_made << "removed test method testing #{file_name} association"
+        "#{indentation}# Test removed: #{file_name} association no longer exists after resource destruction\n"
+      end
+      content = updated_content if updated_content != content
+      
+      # 2. Apply common content replacements using DRY utility
+      replacement_changes = apply_content_replacements(content, file_name, class_name)
+      changes_made.concat(replacement_changes)
+      
+      if content != original_content
+        File.write(file_path, content)
+        say "   ✅ Enhanced test cleanup in #{dep[:file]} (#{changes_made.join(', ')})", :green
+      else
+        say "   ℹ️  No #{file_name} test dependencies found in #{dep[:file]}", :blue
+      end
+    end
+
+    # NEW: Fix polymorphic fixture references (parent: one (DestroyedClass))
+    def fix_polymorphic_fixture_reference(dep)
+      file_path = File.join(destination_root, dep[:file])
+      content = File.read(file_path)
+      original_content = content.dup
+      
+      changes_made = []
+      
+      begin
+        require 'yaml'
+        
+        # Load YAML while preserving structure and comments  
+        yaml_data = YAML.load(content) || {}
+        
+        # Find and replace polymorphic references while preserving Rails syntax
+        changes_to_apply = []
+        alternative_fixture = find_alternative_fixture_for_tests
+        
+        yaml_data.each do |fixture_name, fixture_data|
+          next unless fixture_data.is_a?(Hash)
+          
+          # Look for polymorphic patterns: some_parent: one (DestroyedClass)
+          fixture_data.each do |key, value|
+            if key.end_with?('_parent') && value.to_s.include?(class_name)
+              changes_to_apply << {
+                fixture_name: fixture_name,
+                key: key,
+                old_value: value.to_s,
+                new_value: alternative_fixture ? convert_to_polymorphic_syntax(alternative_fixture) : nil
+              }
+            end
+          end
+        end
+        
+        # Apply changes safely - preserve Rails polymorphic syntax format
+        changes_to_apply.each do |change|
+          fixture_data = yaml_data[change[:fixture_name]]
+          
+          if change[:new_value]
+            # Replace with alternative while preserving Rails format: parent_name (Type)
+            fixture_data[change[:key]] = change[:new_value]
+            changes_made << "replaced #{change[:key]} with #{change[:new_value]} in #{change[:fixture_name]}"
+          else
+            # Comment out if no alternative available
+            fixture_data.delete(change[:key])
+            changes_made << "removed #{change[:key]} reference from #{change[:fixture_name]} (no alternative available)"
+          end
+        end
+        
+        if changes_made.any?
+          # Write back to file while preserving YAML structure
+          updated_content = YAML.dump(yaml_data)
+          
+          # Preserve original file header if it exists  
+          if content.start_with?('# Read about fixtures')
+            header_lines = content.lines.take_while { |line| line.strip.start_with?('#') || line.strip.empty? }
+            updated_content = header_lines.join + "\n" + updated_content
+          end
+          
+          File.write(file_path, updated_content)
+          say "   ✅ Fixed polymorphic fixture references in #{dep[:file]} (#{changes_made.join(', ')})", :green
+        else
+          say "   ℹ️  No polymorphic #{class_name} references found in #{dep[:file]}", :blue
+        end
+        
+      rescue => e
+        say "   ⚠️  Could not auto-fix polymorphic fixture #{dep[:file]}: #{e.message}", :yellow
+        say "      Please manually review polymorphic references to #{class_name}", :cyan
+      end
+    end
+
+    private
+
+    def simple_singularize(word)
+      # Simple singularization for common Rails patterns (fallback if ActiveSupport not available)
+      return word.singularize if word.respond_to?(:singularize)
+      
+      # Basic singularization rules
+      case word
+      when /ies$/
+        word.sub(/ies$/, 'y')
+      when /s$/
+        word.sub(/s$/, '')
+      else
+        word
+      end
+    end
+
+    def convert_to_polymorphic_syntax(alternative_fixture)
+      # Convert "organizations(:acme_org)" to "acme_org (Organization)"
+      # Extract fixture type and name using regex
+      if match = alternative_fixture.match(/^(\w+)\(:(\w+)\)$/)
+        fixture_type = match[1]        # "organizations"  
+        fixture_name = match[2]        # "acme_org"
+        
+        # Singularize and capitalize type
+        singular_type = simple_singularize(fixture_type).capitalize
+        
+        # Return Rails polymorphic format
+        "#{fixture_name} (#{singular_type})"
+      else
+        # Fallback if pattern doesn't match
+        alternative_fixture
+      end
+    end
   end
 end