rails_lens 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 792f89c06b8c11b77fb6892aa7488397d068104e2f30b7c343e38039660b0a2f
-  data.tar.gz: d808455520cffa29f877e43ca8492a1e6dae238e231c641fe8ddd36663ba3d07
+  metadata.gz: 4e504fa26391d500a945947795688a4a52a23922e0ea6a760762415c698d91fc
+  data.tar.gz: 800c91d7df514dc2c745235cf9f5423a7a68d6499cee7221d5cb89adaa95157b
 SHA512:
-  metadata.gz: a754d8353f7a75e11283af18fb2c128bdedec40bf673b5c2cae042d48c14d98dd3c7f26c118d81e0af09a836e0624a4ad2dbd5d092b7b64e4c8664aa9540df0f
-  data.tar.gz: 821f26b9307bfd92914e9c1e6266c3bad0db90c16593e98eb91c1878f9662b3409485a0f32d03d8a007fd1d73bb9f114faec367ce533c41699f01cc2b0b12dc9
+  metadata.gz: 0c17d650e862adcf76e32d7a4a5398cd8c4827b8dd0e0424f01e307a76285e18001c5431561807a049695fbe3c4eaf68960add7d139427b1fcabb36ef2692e06
+  data.tar.gz: 31bf7b191ec9f5dfedabf351798d38b217a71b85c9ceba7e458ed7b45d61662b367989a40b3e311f9fc1e21f270eacbf55e6998e5b28ff0114fa0b5b37b9ab80

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.5.4](https://github.com/seuros/rails_lens/compare/rails_lens/v0.5.3...rails_lens/v0.5.4) (2026-06-26)
+
+
+### Bug Fixes
+
+* prevent duplicate extension annotation blocks on re-annotate ([0e85197](https://github.com/seuros/rails_lens/commit/0e8519742c751eb26d225a3a9a8434a4da4053b1))
+
 ## [0.5.3](https://github.com/seuros/rails_lens/compare/rails_lens/v0.5.2...rails_lens/v0.5.3) (2026-02-17)
 
 

data/lib/rails_lens/analyzers/association_analyzer.rb

@@ -71,16 +71,6 @@ module RailsLens
         false
       end
 
-      def needs_explicit_inverse_of?(association)
-        # Rails can auto-infer inverse_of for vanilla associations
-        # Only require explicit inverse_of when using custom options
-        association.options[:class_name].present? ||
-          association.options[:foreign_key].present? ||
-          association.options[:as].present? ||
-          association.options[:source].present? ||
-          association.options[:through].present?
-      end
-
       def should_have_counter_cache?(association)
         return false unless association.macro == :belongs_to
 

data/lib/rails_lens/analyzers/base.rb

@@ -30,6 +30,22 @@ module RailsLens
       def adapter_name
         @adapter_name ||= connection.adapter_name
       end
+
+      def indexed?(column)
+        connection.indexes(table_name).any? do |index|
+          index.columns.include?(column.name)
+        end
+      end
+
+      def needs_explicit_inverse_of?(association)
+        # Rails can auto-infer inverse_of for vanilla associations
+        # Only require explicit inverse_of when using custom options
+        association.options[:class_name].present? ||
+          association.options[:foreign_key].present? ||
+          association.options[:as].present? ||
+          association.options[:source].present? ||
+          association.options[:through].present?
+      end
     end
   end
 end

data/lib/rails_lens/analyzers/best_practices_analyzer.rb

@@ -71,23 +71,9 @@ module RailsLens
         model_class.column_names.include?(name)
       end
 
-      def indexed?(column)
-        connection.indexes(table_name).any? do |index|
-          index.columns.include?(column.name)
-        end
-      end
-
       def columns
         @columns ||= model_class.columns
       end
-
-      def connection
-        model_class.connection
-      end
-
-      def table_name
-        model_class.table_name
-      end
     end
   end
 end

data/lib/rails_lens/analyzers/callbacks.rb

@@ -178,18 +178,13 @@ module RailsLens
       def extract_options(callback)
         options = {}
 
-        # Extract :if condition
-        if callback.instance_variable_defined?(:@if) && callback.instance_variable_get(:@if).present?
-          conditions = callback.instance_variable_get(:@if)
-          formatted = format_conditions(conditions)
-          options[:if] = formatted if formatted.any?
-        end
+        # Extract :if / :unless conditions (stored as matching instance variables)
+        %i[if unless].each do |key|
+          ivar = :"@#{key}"
+          next unless callback.instance_variable_defined?(ivar) && callback.instance_variable_get(ivar).present?
 
-        # Extract :unless condition
-        if callback.instance_variable_defined?(:@unless) && callback.instance_variable_get(:@unless).present?
-          conditions = callback.instance_variable_get(:@unless)
-          formatted = format_conditions(conditions)
-          options[:unless] = formatted if formatted.any?
+          formatted = format_conditions(callback.instance_variable_get(ivar))
+          options[key] = formatted if formatted.any?
         end
 
         # Extract :on option (for validation and commit callbacks)
@@ -274,19 +269,12 @@ module RailsLens
         parts = []
         parts << "method = \"#{escape_toml(callback[:method])}\""
 
-        if callback[:options][:if]&.any?
-          if_values = callback[:options][:if].map { |v| "\"#{escape_toml(v)}\"" }.join(', ')
-          parts << "if = [#{if_values}]"
-        end
-
-        if callback[:options][:unless]&.any?
-          unless_values = callback[:options][:unless].map { |v| "\"#{escape_toml(v)}\"" }.join(', ')
-          parts << "unless = [#{unless_values}]"
-        end
+        %i[if unless on].each do |key|
+          values = callback[:options][key]
+          next unless values&.any?
 
-        if callback[:options][:on]&.any?
-          on_values = callback[:options][:on].map { |v| "\"#{escape_toml(v)}\"" }.join(', ')
-          parts << "on = [#{on_values}]"
+          escaped = values.map { |v| "\"#{escape_toml(v)}\"" }.join(', ')
+          parts << "#{key} = [#{escaped}]"
         end
 
         parts << 'prepend = true' if callback[:options][:prepend]

data/lib/rails_lens/analyzers/composite_keys.rb

@@ -29,7 +29,7 @@ module RailsLens
 
       def format_composite_keys(keys)
         lines = ['[composite_pk]']
-        lines << "keys = [#{keys.map { |k| "\"#{k}\"" }.join(', ')}]"
+        lines << "keys = #{TomlFormat.quoted_array(keys)}"
         lines.join("\n")
       end
 

data/lib/rails_lens/analyzers/delegated_types.rb

@@ -19,7 +19,7 @@ module RailsLens
                      else
                        Array(delegated_type_info[:types])
                      end
-        lines << "types = [#{types_list.map { |t| "\"#{t}\"" }.join(', ')}]"
+        lines << "types = #{TomlFormat.quoted_array(types_list)}"
 
         lines.join("\n")
       end

data/lib/rails_lens/analyzers/enums.rb

@@ -11,7 +11,7 @@ module RailsLens
 
         model_class.defined_enums.each do |name, values|
           # Format as TOML inline table: name = { key = "value", ... }
-          formatted_values = if values.values.all? { |v| v.is_a?(Integer) }
+          formatted_values = if values.values.all?(Integer)
                                # Integer-based enum
                                values.map { |k, v| "#{k} = #{v}" }.join(', ')
                              else

data/lib/rails_lens/analyzers/error_handling.rb

@@ -16,49 +16,35 @@ module RailsLens
 
       private
 
+      # Report an analyzer error with the shared analyzer/model context plus any
+      # call-specific +context+ keys.
+      def report_analyzer_error(error, **context)
+        ErrorReporter.report(error, { analyzer: self.class.name, model: model_class.name }.merge(context))
+      end
+
       def handle_database_error(error)
-        ErrorReporter.report(error, {
-                               analyzer: self.class.name,
-                               model: model_class.name,
-                               table: model_class.table_name
-                             })
+        report_analyzer_error(error, table: model_class.table_name)
         []
       end
 
       def handle_method_error(error)
         # These are likely bugs in our code, so we should log them prominently
-        ErrorReporter.report(error, {
-                               analyzer: self.class.name,
-                               model: model_class.name,
-                               method: error.name
-                             })
+        report_analyzer_error(error, method: error.name)
         []
       end
 
       def handle_unexpected_error(error)
-        ErrorReporter.report(error, {
-                               analyzer: self.class.name,
-                               model: model_class.name,
-                               type: 'unexpected'
-                             })
+        report_analyzer_error(error, type: 'unexpected')
         []
       end
 
       def safe_call(default = nil)
         yield
       rescue ActiveRecord::StatementInvalid => e
-        ErrorReporter.report(e, {
-                               analyzer: self.class.name,
-                               model: model_class.name,
-                               operation: 'database_query'
-                             })
+        report_analyzer_error(e, operation: 'database_query')
         default
       rescue NoMethodError, NameError => e
-        ErrorReporter.report(e, {
-                               analyzer: self.class.name,
-                               model: model_class.name,
-                               operation: 'method_call'
-                             })
+        report_analyzer_error(e, operation: 'method_call')
         default
       end
     end

data/lib/rails_lens/analyzers/inheritance.rb

@@ -46,7 +46,7 @@ module RailsLens
         if model_class.base_class == model_class
           # This is the base class
           subclasses = find_sti_subclasses
-          lines << "subclasses = [#{subclasses.map { |s| "\"#{s}\"" }.join(', ')}]" if subclasses.any?
+          lines << "subclasses = #{TomlFormat.quoted_array(subclasses)}" if subclasses.any?
           lines << 'base = true'
         else
           # This is a subclass
@@ -55,7 +55,7 @@ module RailsLens
 
           # Find siblings
           siblings = find_sti_siblings
-          lines << "siblings = [#{siblings.map { |s| "\"#{s}\"" }.join(', ')}]" if siblings.any?
+          lines << "siblings = #{TomlFormat.quoted_array(siblings)}" if siblings.any?
         end
 
         lines.join("\n")
@@ -73,7 +73,7 @@ module RailsLens
 
         # Try to find known types
         types = find_delegated_types(reflection)
-        lines << "types = [#{types.map { |t| "\"#{t}\"" }.join(', ')}]" if types.any?
+        lines << "types = #{TomlFormat.quoted_array(types)}" if types.any?
 
         lines.join("\n")
       end
@@ -163,7 +163,7 @@ module RailsLens
                       []
                     end
             if types.any?
-              "{ name = \"#{reflection.name}\", type_col = \"#{reflection.foreign_type}\", id_col = \"#{reflection.foreign_key}\", types = [#{types.map { |t| "\"#{t}\"" }.join(', ')}] }"
+              "{ name = \"#{reflection.name}\", type_col = \"#{reflection.foreign_type}\", id_col = \"#{reflection.foreign_key}\", types = #{TomlFormat.quoted_array(types)} }"
             else
               "{ name = \"#{reflection.name}\", type_col = \"#{reflection.foreign_type}\", id_col = \"#{reflection.foreign_key}\" }"
             end

data/lib/rails_lens/analyzers/notes.rb

@@ -417,16 +417,6 @@ module RailsLens
         RailsLens.logger.debug { "Error checking view existence for #{view_name}: #{e.message}" }
         false
       end
-
-      def needs_explicit_inverse_of?(association)
-        # Rails can auto-infer inverse_of for vanilla associations
-        # Only require explicit inverse_of when using custom options
-        association.options[:class_name].present? ||
-          association.options[:foreign_key].present? ||
-          association.options[:as].present? ||
-          association.options[:source].present? ||
-          association.options[:through].present?
-      end
     end
   end
 end

data/lib/rails_lens/analyzers/performance_analyzer.rb

@@ -27,23 +27,13 @@ module RailsLens
       end
 
       def analyze_query_performance
-        notes = []
-
-        # Check for columns that are commonly used in WHERE clauses
-        commonly_queried_columns.each do |column|
-          next if indexed?(column)
-
-          notes << NoteCodes.note(column.name, NoteCodes::INDEX)
-        end
-
-        # Check for missing indexes on scoped columns
-        scoped_columns.each do |column|
-          next if indexed?(column)
-
-          notes << NoteCodes.note(column.name, NoteCodes::INDEX)
-        end
+        # Flag commonly-queried and scoped columns that lack an index
+        index_notes_for(commonly_queried_columns) + index_notes_for(scoped_columns)
+      end
 
-        notes
+      def index_notes_for(columns)
+        columns.reject { |column| indexed?(column) }
+               .map { |column| NoteCodes.note(column.name, NoteCodes::INDEX) }
       end
 
       def uuid_columns
@@ -68,20 +58,6 @@ module RailsLens
             column.name.end_with?('_id')
         end
       end
-
-      def indexed?(column)
-        connection.indexes(table_name).any? do |index|
-          index.columns.include?(column.name)
-        end
-      end
-
-      def connection
-        model_class.connection
-      end
-
-      def table_name
-        model_class.table_name
-      end
     end
   end
 end

data/lib/rails_lens/annotation_pipeline.rb

@@ -20,6 +20,19 @@ module RailsLens
 
     delegate :clear, to: :@providers
 
+    # Route a single provider's result into the accumulator hash based on the
+    # provider's declared type. Shared by the pipeline and AnnotationManager.
+    def self.accumulate_result(results, provider, result)
+      case provider.type
+      when :schema
+        results[:schema] = result
+      when :section
+        results[:sections] << result if result
+      when :notes
+        results[:notes].concat(Array(result))
+      end
+    end
+
     def process(model_class)
       results = {
         schema: nil,
@@ -35,14 +48,7 @@ module RailsLens
           begin
             result = provider.process(model_class, connection)
 
-            case provider.type
-            when :schema
-              results[:schema] = result
-            when :section
-              results[:sections] << result if result
-            when :notes
-              results[:notes].concat(Array(result))
-            end
+            self.class.accumulate_result(results, provider, result)
           rescue ActiveRecord::StatementInvalid => e
             warn "Provider #{provider.class} database error for #{model_class}: #{e.message}"
           rescue ActiveRecord::ConnectionNotDefined => e

data/lib/rails_lens/cli.rb

@@ -34,13 +34,13 @@ module RailsLens
         commands = Commands.new(self)
 
         # Annotate models (default behavior or when --all is specified)
-        results[:models] = commands.annotate_models(options) if should_annotate_models?
+        results[:models] = commands.annotate_models(options) if target_models?
 
         # Annotate routes
-        results[:routes] = commands.annotate_routes(options) if should_annotate_routes?
+        results[:routes] = commands.annotate_routes(options) if target_routes?
 
         # Annotate mailers
-        results[:mailers] = commands.annotate_mailers(options) if should_annotate_mailers?
+        results[:mailers] = commands.annotate_mailers(options) if target_mailers?
 
         results
       end
@@ -58,13 +58,13 @@ module RailsLens
         commands = Commands.new(self)
 
         # Remove model annotations (default behavior or when --all is specified)
-        results[:models] = commands.remove_models(options) if should_remove_models?
+        results[:models] = commands.remove_models(options) if target_models?
 
         # Remove route annotations
-        results[:routes] = commands.remove_routes(options) if should_remove_routes?
+        results[:routes] = commands.remove_routes(options) if target_routes?
 
         # Remove mailer annotations
-        results[:mailers] = commands.remove_mailers(options) if should_remove_mailers?
+        results[:mailers] = commands.remove_mailers(options) if target_mailers?
 
         results
       end
@@ -158,28 +158,17 @@ module RailsLens
       RailsLens.config.debug = options[:debug]
     end
 
-    # Helper methods to determine what to annotate/remove
-    def should_annotate_models?
+    # Helper methods to determine what to annotate/remove. The same targeting
+    # rules apply to both the annotate and remove commands.
+    def target_models?
       (!options[:routes] && !options[:mailers]) || options[:all]
     end
 
-    def should_annotate_routes?
+    def target_routes?
       options[:routes] || options[:all]
     end
 
-    def should_annotate_mailers?
-      options[:mailers] || options[:all]
-    end
-
-    def should_remove_models?
-      (!options[:routes] && !options[:mailers]) || options[:all]
-    end
-
-    def should_remove_routes?
-      options[:routes] || options[:all]
-    end
-
-    def should_remove_mailers?
+    def target_mailers?
       options[:mailers] || options[:all]
     end
   end

data/lib/rails_lens/cli_error_handler.rb

@@ -31,32 +31,31 @@ module RailsLens
     end
 
     def handle_model_error(error)
-      say "Model Error: #{error.message}", :red
-      if options[:verbose]
-        say 'Make sure your Rails application is properly loaded', :yellow
-        say 'Try running: bundle exec rails_lens annotate', :yellow
-      end
-      exit 1
+      report_error('Model Error', error,
+                   'Make sure your Rails application is properly loaded',
+                   'Try running: bundle exec rails_lens annotate')
     end
 
     def handle_database_error(error)
-      say "Database Error: #{error.message}", :red
-      if options[:verbose]
-        say 'Possible causes:', :yellow
-        say '  - Database server is not running', :yellow
-        say '  - Invalid database credentials', :yellow
-        say '  - Table does not exist', :yellow
-        say '  - Permission denied', :yellow
-      end
-      exit 1
+      report_error('Database Error', error,
+                   'Possible causes:',
+                   '  - Database server is not running',
+                   '  - Invalid database credentials',
+                   '  - Table does not exist',
+                   '  - Permission denied')
     end
 
     def handle_annotation_error(error)
-      say "Annotation Error: #{error.message}", :red
-      if options[:verbose]
-        say 'Failed to annotate one or more files', :yellow
-        say 'Check file permissions and syntax', :yellow
-      end
+      report_error('Annotation Error', error,
+                   'Failed to annotate one or more files',
+                   'Check file permissions and syntax')
+    end
+
+    # Print a red "<label>: <message>", optional verbose-only yellow hints,
+    # then exit non-zero.
+    def report_error(label, error, *verbose_hints)
+      say "#{label}: #{error.message}", :red
+      verbose_hints.each { |hint| say hint, :yellow } if options[:verbose]
       exit 1
     end
 

data/lib/rails_lens/commands.rb

@@ -15,14 +15,7 @@ module RailsLens
       results = Schema::AnnotationManager.annotate_all(options)
 
       output.say "Annotated #{results[:annotated].length} models", :green
-      output.say "Skipped #{results[:skipped].length} models", :yellow if results[:skipped].any?
-
-      if results[:failed].any?
-        output.say "Failed to annotate #{results[:failed].length} models:", :red
-        results[:failed].each do |failure|
-          output.say "  - #{failure[:model]}: #{failure[:error]}", :red
-        end
-      end
+      report_skipped_and_failed(results, 'models')
 
       # Also annotate database-level objects (functions, etc.)
       if options[:include_database_objects]
@@ -37,36 +30,17 @@ module RailsLens
       results = Schema::DatabaseAnnotator.annotate_all(options)
 
       output.say "Annotated #{results[:annotated].length} abstract base classes with database objects", :green
-      output.say "Skipped #{results[:skipped].length} abstract classes", :yellow if results[:skipped].any?
-
-      if results[:failed].any?
-        output.say "Failed to annotate #{results[:failed].length} abstract classes:", :red
-        results[:failed].each do |failure|
-          output.say "  - #{failure[:model]}: #{failure[:error]}", :red
-        end
-      end
+      report_skipped_and_failed(results, 'abstract classes')
 
       results
     end
 
     def annotate_routes(options = {})
-      annotator = Route::Annotator.new(dry_run: options[:dry_run])
-      changed_files = annotator.annotate_all
-
-      output.say "Annotated #{changed_files.length} controller files with routes", :green
-      changed_files.each { |file| output.say "  - #{file}", :blue } if options[:verbose] && changed_files.any?
-
-      { changed_files: changed_files }
+      annotate_files(Route::Annotator.new(dry_run: options[:dry_run]), 'controller files with routes', options)
     end
 
     def annotate_mailers(options = {})
-      annotator = Mailer::Annotator.new(dry_run: options[:dry_run])
-      changed_files = annotator.annotate_all
-
-      output.say "Annotated #{changed_files.length} mailer files", :green
-      changed_files.each { |file| output.say "  - #{file}", :blue } if options[:verbose] && changed_files.any?
-
-      { changed_files: changed_files }
+      annotate_files(Mailer::Annotator.new(dry_run: options[:dry_run]), 'mailer files', options)
     end
 
     def remove_models(options = {})
@@ -76,17 +50,11 @@ module RailsLens
     end
 
     def remove_routes(options = {})
-      annotator = Route::Annotator.new(dry_run: options[:dry_run])
-      changed_files = annotator.remove_all
-      output.say "Removed route annotations from #{changed_files.length} controller files", :green
-      { changed_files: changed_files }
+      remove_files(Route::Annotator.new(dry_run: options[:dry_run]), 'route', 'controller files')
     end
 
     def remove_mailers(options = {})
-      annotator = Mailer::Annotator.new(dry_run: options[:dry_run])
-      changed_files = annotator.remove_all
-      output.say "Removed mailer annotations from #{changed_files.length} mailer files", :green
-      { changed_files: changed_files }
+      remove_files(Mailer::Annotator.new(dry_run: options[:dry_run]), 'mailer', 'mailer files')
     end
 
     def generate_erd(options = {})
@@ -227,6 +195,30 @@ module RailsLens
 
     private
 
+    # Report skipped/failed counts for a model-annotation results hash.
+    def report_skipped_and_failed(results, noun)
+      output.say "Skipped #{results[:skipped].length} #{noun}", :yellow if results[:skipped].any?
+      return unless results[:failed].any?
+
+      output.say "Failed to annotate #{results[:failed].length} #{noun}:", :red
+      results[:failed].each do |failure|
+        output.say "  - #{failure[:model]}: #{failure[:error]}", :red
+      end
+    end
+
+    def annotate_files(annotator, label, options)
+      changed_files = annotator.annotate_all
+      output.say "Annotated #{changed_files.length} #{label}", :green
+      changed_files.each { |file| output.say "  - #{file}", :blue } if options[:verbose] && changed_files.any?
+      { changed_files: changed_files }
+    end
+
+    def remove_files(annotator, kind, target)
+      changed_files = annotator.remove_all
+      output.say "Removed #{kind} annotations from #{changed_files.length} #{target}", :green
+      { changed_files: changed_files }
+    end
+
     def rake_task_template
       <<~RAKE
         # frozen_string_literal: true