rails_lens 0.2.12 → 0.3.0

data/lib/rails_lens/analyzers/callbacks.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class Callbacks < Base
+      # ActiveRecord callback chains (Rails 8+ uses unified chains with kind attribute)
+      CALLBACK_CHAINS = %i[
+        validation
+        save
+        create
+        update
+        destroy
+        commit
+        rollback
+        touch
+        initialize
+        find
+      ].freeze
+
+      # Map kinds to full callback type names
+      KIND_PREFIXES = {
+        before: 'before_',
+        after: 'after_',
+        around: 'around_'
+      }.freeze
+
+      # Callbacks that commonly come from ActiveRecord internals (symbol-based)
+      INTERNAL_CALLBACK_PREFIXES = %w[
+        autosave_associated_records_for_
+        around_save_collection_association
+        _ensure_no_duplicate_errors
+        normalize_changed_in_place_attributes
+        clear_transaction_record_state
+        remember_transaction_record_state
+        add_to_transaction
+        sync_with_transaction_state
+        trigger_transactional_callbacks
+      ].freeze
+
+      # Known callback order for formatting output
+      CALLBACK_ORDER = %i[
+        before_validation after_validation
+        before_save around_save after_save
+        before_create around_create after_create
+        before_update around_update after_update
+        before_destroy around_destroy after_destroy
+        before_commit around_commit after_commit
+        before_rollback around_rollback after_rollback
+        after_touch
+        after_initialize after_find
+      ].freeze
+
+      def analyze
+        callbacks = extract_callbacks
+        return nil if callbacks.empty?
+
+        format_callbacks(callbacks)
+      end
+
+      private
+
+      def extract_callbacks
+        callbacks = []
+
+        CALLBACK_CHAINS.each do |chain_name|
+          chain_method = "_#{chain_name}_callbacks"
+          next unless model_class.respond_to?(chain_method)
+
+          chain = model_class.public_send(chain_method)
+          next if chain.blank?
+
+          chain.each do |callback|
+            next if internal_callback?(callback)
+            next unless defined_in_model_hierarchy?(callback)
+
+            callback_info = parse_callback(callback, chain_name)
+            callbacks << callback_info if callback_info
+          end
+        end
+
+        # Keep order, dedupe only exact duplicates (same type, method, and options hash)
+        seen = Set.new
+        callbacks.select do |c|
+          key = [c[:type], c[:method], c[:options].to_a.sort]
+          seen.add?(key)
+        end
+      end
+
+      def internal_callback?(callback)
+        filter = callback.filter
+
+        case filter
+        when Symbol
+          filter_name = filter.to_s
+          INTERNAL_CALLBACK_PREFIXES.any? { |prefix| filter_name.start_with?(prefix) }
+        when Proc
+          # Check if proc is from Rails internals (association callbacks, dependent: :destroy)
+          source_location = begin
+            filter.source_location
+          rescue
+            nil
+          end
+          return false if source_location.nil?
+
+          # Filter out procs defined in activerecord/activesupport gems
+          source_file = source_location[0].to_s
+          source_file.include?('/activerecord') || source_file.include?('/activesupport')
+        else
+          false
+        end
+      end
+
+      def defined_in_model_hierarchy?(callback)
+        filter = callback.filter
+
+        case filter
+        when Symbol
+          # Check if method is defined in the model class itself
+          return true if model_class.instance_methods(false).include?(filter)
+          return true if model_class.private_instance_methods(false).include?(filter)
+
+          # Check if defined in included concerns (non-Rails modules)
+          model_class.included_modules.each do |mod|
+            next if mod.name.nil?
+            next if mod.name.start_with?('ActiveRecord', 'ActiveModel', 'ActiveSupport')
+
+            return true if mod.instance_methods(false).include?(filter)
+            return true if mod.private_instance_methods(false).include?(filter)
+          end
+
+          # For STI: check parent classes up to (but not including) ActiveRecord::Base
+          klass = model_class.superclass
+          while klass && klass < ActiveRecord::Base
+            return true if klass.instance_methods(false).include?(filter)
+            return true if klass.private_instance_methods(false).include?(filter)
+
+            klass = klass.superclass
+          end
+
+          false
+        when Proc
+          # User-defined procs - already filtered internal ones in internal_callback?
+          true
+        else
+          # Callback objects - assume user-defined
+          true
+        end
+      end
+
+      def parse_callback(callback, chain_name)
+        filter = callback.filter
+        kind = callback.kind
+        options = extract_options(callback)
+
+        method_name = case filter
+                      when Symbol
+                        filter.to_s
+                      when Proc
+                        'proc'
+                      when String
+                        filter
+                      else
+                        # Callback object
+                        filter.class.name.demodulize.underscore
+                      end
+
+        # Build full callback type (e.g., :before + :save = :before_save)
+        callback_type = :"#{KIND_PREFIXES[kind]}#{chain_name}"
+
+        {
+          type: callback_type,
+          method: method_name,
+          kind: kind,
+          options: options
+        }
+      end
+
+      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 :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?
+        end
+
+        # Extract :on option (for validation and commit callbacks)
+        if callback.respond_to?(:options) && callback.options[:on]
+          on_value = callback.options[:on]
+          options[:on] = Array(on_value).map(&:to_s)
+        end
+
+        # Extract :prepend option
+        if callback.respond_to?(:options) && callback.options[:prepend]
+          options[:prepend] = true
+        end
+
+        options
+      end
+
+      def format_conditions(conditions)
+        Array(conditions).filter_map do |condition|
+          case condition
+          when Symbol
+            condition.to_s
+          when Proc
+            source_location = begin
+              condition.source_location
+            rescue
+              nil
+            end
+            if source_location.nil?
+              'proc'
+            elsif source_location[0].to_s.match?(%r{/active(record|support|model)})
+              # Skip Rails internal conditionals
+              nil
+            else
+              'proc'
+            end
+          when String
+            condition
+          else
+            class_name = begin
+              condition.class.name
+            rescue
+              nil
+            end
+            # Skip internal Rails callback condition classes
+            if class_name&.start_with?('ActiveSupport::Callbacks', 'ActiveRecord')
+              nil
+            else
+              class_name
+            end
+          end
+        end
+      end
+
+      def format_callbacks(callbacks)
+        lines = []
+        lines << '[callbacks]'
+
+        # Group by callback type
+        grouped = callbacks.group_by { |c| c[:type] }
+
+        # Output known types in order first
+        CALLBACK_ORDER.each do |callback_type|
+          type_callbacks = grouped.delete(callback_type)
+          next unless type_callbacks&.any?
+
+          formatted = type_callbacks.map { |c| format_single_callback(c) }
+          lines << "#{callback_type} = [#{formatted.join(', ')}]"
+        end
+
+        # Output any remaining unknown callback types (future Rails versions)
+        grouped.each do |callback_type, type_callbacks|
+          next unless type_callbacks&.any?
+
+          formatted = type_callbacks.map { |c| format_single_callback(c) }
+          lines << "#{callback_type} = [#{formatted.join(', ')}]"
+        end
+
+        lines.join("\n")
+      end
+
+      def format_single_callback(callback)
+        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
+
+        if callback[:options][:on]&.any?
+          on_values = callback[:options][:on].map { |v| "\"#{escape_toml(v)}\"" }.join(', ')
+          parts << "on = [#{on_values}]"
+        end
+
+        parts << 'prepend = true' if callback[:options][:prepend]
+
+        "{ #{parts.join(', ')} }"
+      end
+
+      def escape_toml(str)
+        str.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/column_analyzer.rb

@@ -15,7 +15,7 @@ module RailsLens
 
       def analyze_null_constraints
         columns_needing_not_null.map do |column|
-          "Column '#{column.name}' should probably have NOT NULL constraint"
+          NoteCodes.note(column.name, NoteCodes::NOT_NULL)
         end
       end
 
@@ -24,11 +24,11 @@ module RailsLens
 
         columns.each do |column|
           if column.type == :boolean && column.default.nil? && column.null
-            notes << "Boolean column '#{column.name}' should have a default value"
+            notes << NoteCodes.note(column.name, NoteCodes::DEFAULT)
           end
 
           if status_column?(column) && column.default.nil?
-            notes << "Status column '#{column.name}' should have a default value"
+            notes << NoteCodes.note(column.name, NoteCodes::DEFAULT)
           end
         end
 
@@ -41,17 +41,17 @@ module RailsLens
         columns.each do |column|
           # Check for float columns used for money
           if money_column?(column) && column.type == :float
-            notes << "Column '#{column.name}' appears to store monetary values - use decimal instead of float"
+            notes << NoteCodes.note(column.name, NoteCodes::USE_DECIMAL)
           end
 
           # Check for string columns that should be integers
           if counter_column?(column) && column.type != :integer
-            notes << "Counter column '#{column.name}' should be integer type, not #{column.type}"
+            notes << NoteCodes.note(column.name, NoteCodes::USE_INTEGER)
           end
 
           # Check for inappropriately large string columns
           if column.type == :string && column.limit.nil?
-            notes << "String column '#{column.name}' has no length limit - consider adding one"
+            notes << NoteCodes.note(column.name, NoteCodes::LIMIT)
           end
         end
 

data/lib/rails_lens/analyzers/composite_keys.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class CompositeKeys < Base
@@ -31,8 +28,8 @@ module RailsLens
       private
 
       def format_composite_keys(keys)
-        lines = ['== Composite Primary Key']
-        lines << "Primary Keys: #{keys.join(', ')}"
+        lines = ['[composite_pk]']
+        lines << "keys = [#{keys.map { |k| "\"#{k}\"" }.join(', ')}]"
         lines.join("\n")
       end
 

data/lib/rails_lens/analyzers/database_constraints.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class DatabaseConstraints < Base
@@ -15,12 +12,13 @@ module RailsLens
         check_constraints = connection.check_constraints(table_name)
         return nil if check_constraints.empty?
 
-        constraints << '== Check Constraints'
-        check_constraints.each do |constraint|
+        constraints << '[check_constraints]'
+        formatted = check_constraints.map do |constraint|
           name = constraint.options[:name] || constraint.name
           expression = constraint.expression || constraint.options[:validate]
-          constraints << "- #{name}: #{expression}"
+          "{ name = \"#{name}\", expr = \"#{expression.to_s.gsub('"', '\\"')}\" }"
         end
+        constraints << "constraints = [#{formatted.join(', ')}]"
 
         constraints.empty? ? nil : constraints.join("\n")
       rescue ActiveRecord::StatementInvalid => e

data/lib/rails_lens/analyzers/delegated_types.rb

@@ -1,28 +1,25 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class DelegatedTypes < Base
       def analyze
         return nil unless delegated_type_model?
 
-        lines = ['== Delegated Type']
+        lines = ['[delegated_type]']
 
         # Find delegated type configuration
         delegated_type_info = find_delegated_type_info
         return nil unless delegated_type_info
 
-        lines << "Type Column: #{delegated_type_info[:type_column]}"
-        lines << "ID Column: #{delegated_type_info[:id_column]}"
+        lines << "type_column = \"#{delegated_type_info[:type_column]}\""
+        lines << "id_column = \"#{delegated_type_info[:id_column]}\""
         types_list = if delegated_type_info[:types].respond_to?(:keys)
                        delegated_type_info[:types].keys
                      else
                        Array(delegated_type_info[:types])
                      end
-        lines << "Types: #{types_list.join(', ')}"
+        lines << "types = [#{types_list.map { |t| "\"#{t}\"" }.join(', ')}]"
 
         lines.join("\n")
       end

data/lib/rails_lens/analyzers/enums.rb

@@ -7,24 +7,18 @@ module RailsLens
         return nil unless model_class.respond_to?(:defined_enums) && model_class.defined_enums.any?
 
         lines = []
-        lines << '== Enums'
+        lines << '[enums]'
 
         model_class.defined_enums.each do |name, values|
-          # Detect if it's using integer or string values
+          # Format as TOML inline table: name = { key = "value", ... }
           formatted_values = if values.values.all? { |v| v.is_a?(Integer) }
                                # Integer-based enum
-                               values.map { |k, v| "#{k}: #{v}" }.join(', ')
+                               values.map { |k, v| "#{k} = #{v}" }.join(', ')
                              else
                                # String-based enum
-                               values.map { |k, v| "#{k}: \"#{v}\"" }.join(', ')
+                               values.map { |k, v| "#{k} = \"#{v}\"" }.join(', ')
                              end
-          lines << "- #{name}: { #{formatted_values} }"
-
-          # Add column type if we can detect it
-          if model_class.table_exists? && model_class.columns_hash[name.to_s]
-            column = model_class.columns_hash[name.to_s]
-            lines.last << " (#{column.type})"
-          end
+          lines << "#{name} = { #{formatted_values} }"
         end
 
         lines.join("\n")

data/lib/rails_lens/analyzers/foreign_key_analyzer.rb

@@ -10,13 +10,13 @@ module RailsLens
         existing_foreign_keys = connection.foreign_keys(table_name)
 
         belongs_to_associations.each do |association|
-          next if association.polymorphic? # Can't have FK constraints on polymorphic associations
+          next if association.polymorphic?
 
           foreign_key = association.foreign_key
           referenced_table = association.klass.table_name
 
           unless foreign_key_exists?(foreign_key, referenced_table, existing_foreign_keys)
-            notes << "Missing foreign key constraint on '#{foreign_key}' referencing '#{referenced_table}'"
+            notes << NoteCodes.note(foreign_key, NoteCodes::FK_CONSTRAINT)
           end
         end
 

data/lib/rails_lens/analyzers/generated_columns.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class GeneratedColumns < Base
@@ -12,10 +9,11 @@ module RailsLens
         generated_columns = detect_generated_columns
         return nil if generated_columns.empty?
 
-        lines = ['== Generated Columns']
-        generated_columns.each do |column|
-          lines << "- #{column[:name]} (#{column[:expression]})"
+        lines = ['[generated_columns]']
+        formatted = generated_columns.map do |column|
+          "{ name = \"#{column[:name]}\", expr = \"#{column[:expression].to_s.gsub('"', '\\"')}\" }"
         end
+        lines << "columns = [#{formatted.join(', ')}]"
 
         lines.join("\n")
       end

data/lib/rails_lens/analyzers/index_analyzer.rb

@@ -20,7 +20,7 @@ module RailsLens
         foreign_key_columns.each do |column|
           next if indexed?(column)
 
-          notes << "Missing index on foreign key '#{column}'"
+          notes << NoteCodes.note(column, NoteCodes::INDEX)
         end
 
         # Check for missing indexes on polymorphic associations
@@ -29,7 +29,7 @@ module RailsLens
           id_column = "#{assoc.name}_id"
 
           unless composite_index_exists?([type_column, id_column])
-            notes << "Missing composite index on polymorphic association '#{assoc.name}' columns [#{type_column}, #{id_column}]"
+            notes << NoteCodes.note(assoc.name.to_s, NoteCodes::POLY_INDEX)
           end
         end
 
@@ -43,7 +43,7 @@ module RailsLens
         indexes.each_with_index do |index, i|
           indexes[(i + 1)..].each do |other_index|
             if index_redundant?(index, other_index)
-              notes << "Index '#{index.name}' might be redundant with '#{other_index.name}'"
+              notes << NoteCodes.note(index.name, NoteCodes::REDUND_IDX)
             end
           end
         end
@@ -54,7 +54,6 @@ module RailsLens
       def analyze_composite_indexes
         notes = []
 
-        # Check for common query patterns that could benefit from composite indexes
         association_pairs = model_class.reflect_on_all_associations(:belongs_to)
                                        .combination(2)
                                        .select { |a, b| common_query_pattern?(a, b) }
@@ -62,7 +61,7 @@ module RailsLens
         association_pairs.each do |assoc1, assoc2|
           columns = [assoc1.foreign_key, assoc2.foreign_key].sort
           unless composite_index_exists?(columns)
-            notes << "Consider composite index on [#{columns.join(', ')}] for common query pattern"
+            notes << NoteCodes.note(columns.join('+'), NoteCodes::COMP_INDEX)
           end
         end
 
@@ -93,7 +92,6 @@ module RailsLens
       end
 
       def index_redundant?(index1, index2)
-        # An index is redundant if it's a prefix of another index
         return false if index1.unique != index2.unique
 
         if index1.columns.length < index2.columns.length
@@ -104,15 +102,11 @@ module RailsLens
       end
 
       def common_query_pattern?(assoc1, assoc2)
-        # This is a simplified heuristic - in a real app, you might analyze actual queries
-        # For now, we'll assume associations to the same model or related models are commonly queried together
         assoc1.class_name == assoc2.class_name ||
           related_models?(assoc1.class_name, assoc2.class_name)
       end
 
       def related_models?(class1, class2)
-        # Simple heuristic: models are related if they share a common prefix
-        # e.g., "UserProfile" and "UserSettings" are likely related
         class1.split('::').last[/^[A-Z][a-z]+/] == class2.split('::').last[/^[A-Z][a-z]+/]
       end