rails_lens 0.5.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 792f89c06b8c11b77fb6892aa7488397d068104e2f30b7c343e38039660b0a2f
-  data.tar.gz: d808455520cffa29f877e43ca8492a1e6dae238e231c641fe8ddd36663ba3d07
+  metadata.gz: 0f010a15d0d3afdf64754e866cac571fcb1c91e4bd3981c8aa9bdece8d30f85a
+  data.tar.gz: 11e8b6ad7da6461bdc846952151537d3495d67cd812cd9f7e4b3ca40dbc37fbb
 SHA512:
-  metadata.gz: a754d8353f7a75e11283af18fb2c128bdedec40bf673b5c2cae042d48c14d98dd3c7f26c118d81e0af09a836e0624a4ad2dbd5d092b7b64e4c8664aa9540df0f
-  data.tar.gz: 821f26b9307bfd92914e9c1e6266c3bad0db90c16593e98eb91c1878f9662b3409485a0f32d03d8a007fd1d73bb9f114faec367ce533c41699f01cc2b0b12dc9
+  metadata.gz: 22963fce37978c1a4157d9c1ffe236a3ca41c0a97d8b492a832729b467c91923810cc70126c4717c17cbbac9596dfbcd620a34cdb482092b34a8692a37351c23
+  data.tar.gz: 4c5bd10154b4d44b4dfda08ec21ebcd3632b6a740e7a9d28ddd7d5a35289fec248fcf76b61bc19db8a53f548691a5597df326bda48f25ad0cc200c94468f94bf

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.0](https://github.com/seuros/rails_lens/compare/rails_lens/v0.5.4...rails_lens/v0.10.0) (2026-08-10)
+
+
+### Features
+
+* composite primary keys ([#45](https://github.com/seuros/rails_lens/issues/45)) ([8d934b5](https://github.com/seuros/rails_lens/commit/8d934b51b310252ce42f3db9aa85894161d562f3))
+
+## [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/README.md

@@ -120,7 +120,7 @@ erDiagram
 ## Requirements
 
 - Ruby >= 3.4.0
-- Rails >= 7.2.0
+- Rails >= 8.0.0
 
 ## Installation
 

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

@@ -4,22 +4,10 @@ module RailsLens
   module Analyzers
     class CompositeKeys < Base
       def analyze
-        # First try Rails native support
-        if model_class.respond_to?(:primary_keys) && model_class.primary_keys.is_a?(Array)
-          keys = model_class.primary_keys
-          return format_composite_keys(keys) if keys.length > 1
-        end
+        pk = model_class.primary_key
+        return nil unless pk.is_a?(Array)
 
-        # For PostgreSQL, check the actual database constraints
-        if adapter_name == 'PostgreSQL'
-          keys = detect_composite_primary_key_from_db
-          return format_composite_keys(keys) if keys && keys.length > 1
-        end
-
-        nil
-      rescue NoMethodError => e
-        RailsLens.logger.debug { "Failed to analyze composite keys for #{model_class.name}: #{e.message}" }
-        nil
+        format_composite_keys(pk)
       rescue ActiveRecord::ConnectionNotEstablished => e
         RailsLens.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
         nil
@@ -29,31 +17,9 @@ 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
-
-      def detect_composite_primary_key_from_db
-        # Query PostgreSQL system catalogs to find composite primary keys
-        sql = <<~SQL.squish
-          SELECT a.attname
-          FROM pg_index i
-          JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
-          WHERE i.indrelid = '#{table_name}'::regclass
-            AND i.indisprimary
-          ORDER BY array_position(i.indkey, a.attnum)
-        SQL
-
-        result = connection.execute(sql)
-        keys = result.pluck('attname')
-        keys.empty? ? nil : keys
-      rescue ActiveRecord::StatementInvalid => e
-        RailsLens.logger.debug { "Failed to detect composite keys from database for #{table_name}: #{e.message}" }
-        nil
-      rescue PG::Error => e
-        RailsLens.logger.debug { "PostgreSQL error detecting composite keys: #{e.message}" }
-        nil
-      end
     end
   end
 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