rails_lens 0.0.0 → 0.2.0

data/lib/rails_lens/analyzers/index_analyzer.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class IndexAnalyzer < Base
+      def analyze
+        notes = []
+        notes.concat(analyze_missing_indexes)
+        notes.concat(analyze_redundant_indexes)
+        notes.concat(analyze_composite_indexes)
+        notes
+      end
+
+      private
+
+      def analyze_missing_indexes
+        notes = []
+
+        # Check for missing indexes on foreign keys
+        foreign_key_columns.each do |column|
+          next if indexed?(column)
+
+          notes << "Missing index on foreign key '#{column}'"
+        end
+
+        # Check for missing indexes on polymorphic associations
+        polymorphic_associations.each do |assoc|
+          type_column = "#{assoc.name}_type"
+          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}]"
+          end
+        end
+
+        notes
+      end
+
+      def analyze_redundant_indexes
+        notes = []
+        indexes = connection.indexes(table_name)
+
+        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}'"
+            end
+          end
+        end
+
+        notes
+      end
+
+      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) }
+
+        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"
+          end
+        end
+
+        notes
+      end
+
+      def foreign_key_columns
+        model_class.reflect_on_all_associations(:belongs_to)
+                   .reject(&:polymorphic?)
+                   .map(&:foreign_key)
+      end
+
+      def polymorphic_associations
+        model_class.reflect_on_all_associations(:belongs_to)
+                   .select(&:polymorphic?)
+      end
+
+      def indexed?(column)
+        connection.indexes(table_name).any? do |index|
+          index.columns.include?(column.to_s)
+        end
+      end
+
+      def composite_index_exists?(columns)
+        connection.indexes(table_name).any? do |index|
+          index.columns == columns.map(&:to_s)
+        end
+      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
+          index2.columns[0...index1.columns.length] == index1.columns
+        else
+          index1.columns[0...index2.columns.length] == index2.columns
+        end
+      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
+
+      def connection
+        model_class.connection
+      end
+
+      def table_name
+        model_class.table_name
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/inheritance.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'error_handling'
+
+module RailsLens
+  module Analyzers
+    class Inheritance < Base
+      def analyze
+        results = []
+
+        results << analyze_sti if sti_model?
+        results << analyze_delegated_type if delegated_type_model?
+        results << analyze_polymorphic if polymorphic_associations?
+
+        return nil if results.empty?
+
+        results.compact.join("\n\n")
+      end
+
+      private
+
+      def sti_model?
+        return false if model_class.abstract_class?
+
+        # Check if this model uses STI
+        model_class.inheritance_column &&
+          model_class.column_names.include?(model_class.inheritance_column)
+      end
+
+      def delegated_type_model?
+        # Check for delegated_type declaration
+        model_class.respond_to?(:delegated_type_reflection) &&
+          model_class.delegated_type_reflection.present?
+      rescue NoMethodError => e
+        Rails.logger.debug { "Failed to check delegated type for #{model_class.name}: #{e.message}" }
+        false
+      rescue NameError => e
+        Rails.logger.debug { "Name error checking delegated type: #{e.message}" }
+        false
+      end
+
+      def analyze_sti
+        lines = []
+        lines << '== Inheritance (STI)'
+        lines << "Type Column: #{model_class.inheritance_column}"
+
+        # Check if this is a base class or subclass
+        if model_class.base_class == model_class
+          # This is the base class
+          subclasses = find_sti_subclasses
+          lines << "Known Subclasses: #{subclasses.join(', ')}" if subclasses.any?
+          lines << 'Base Class: Yes'
+        else
+          # This is a subclass
+          lines << "Base Class: #{model_class.base_class.name}"
+          lines << "Type Value: #{model_class.sti_name}"
+
+          # Find siblings
+          siblings = find_sti_siblings
+          lines << "Sibling Classes: #{siblings.join(', ')}" if siblings.any?
+        end
+
+        lines.join("\n")
+      end
+
+      def analyze_delegated_type
+        reflection = model_class.delegated_type_reflection
+        return nil unless reflection
+
+        lines = []
+        lines << '== Delegated Type'
+        lines << "Delegate: #{reflection.name}"
+        lines << "Type Column: #{reflection.foreign_type}"
+        lines << "ID Column: #{reflection.foreign_key}"
+
+        # Try to find known types
+        types = find_delegated_types(reflection)
+        lines << "Known Types: #{types.join(', ')}" if types.any?
+
+        lines.join("\n")
+      end
+
+      def find_sti_subclasses
+        # Find all direct subclasses
+        subclasses = []
+
+        ObjectSpace.each_object(Class) do |klass|
+          subclasses << klass.name if klass < model_class && klass != model_class && klass.base_class == model_class
+        end
+
+        subclasses.sort
+      rescue NoMethodError => e
+        Rails.logger.debug { "Failed to find STI subclasses for #{model_class.name}: #{e.message}" }
+        []
+      rescue NameError => e
+        Rails.logger.debug { "Name error finding STI subclasses: #{e.message}" }
+        []
+      end
+
+      def find_sti_siblings
+        return [] unless model_class.base_class != model_class
+
+        siblings = []
+        base = model_class.base_class
+
+        ObjectSpace.each_object(Class) do |klass|
+          siblings << klass.name if klass < base && klass != model_class && klass.base_class == base
+        end
+
+        siblings.sort
+      rescue NoMethodError => e
+        Rails.logger.debug { "Failed to find STI siblings for #{model_class.name}: #{e.message}" }
+        []
+      rescue NameError => e
+        Rails.logger.debug { "Name error finding STI siblings: #{e.message}" }
+        []
+      end
+
+      def find_delegated_types(reflection)
+        # Try to find models that could be delegated types
+        types = []
+        type_column = reflection.foreign_type
+
+        # Look for records in the database to see what types exist
+        if model_class.table_exists?
+          existing_types = model_class
+                           .where.not(type_column => nil)
+                           .distinct
+                           .pluck(type_column)
+                           .compact
+                           .sort
+
+          types.concat(existing_types)
+        end
+
+        types.uniq.sort
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Database error finding delegated types for #{model_class.name}: #{e.message}" }
+        []
+      rescue ActiveRecord::ConnectionNotEstablished => e
+        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        []
+      end
+
+      def polymorphic_associations?
+        model_class.reflect_on_all_associations.any? do |reflection|
+          reflection.options[:polymorphic] || reflection.options[:as]
+        end
+      end
+
+      def analyze_polymorphic
+        lines = []
+        lines << '== Polymorphic Associations'
+
+        # Find polymorphic belongs_to associations
+        polymorphic_belongs_to = model_class.reflect_on_all_associations(:belongs_to).select do |r|
+          r.options[:polymorphic]
+        end
+
+        if polymorphic_belongs_to.any?
+          lines << 'Polymorphic References:'
+          polymorphic_belongs_to.each do |reflection|
+            lines << "- #{reflection.name} (#{reflection.foreign_type}/#{reflection.foreign_key})"
+
+            # Try to find what types are actually used
+            next unless model_class.table_exists? && model_class.columns_hash[reflection.foreign_type.to_s]
+
+            types = find_polymorphic_types(reflection)
+            lines << "  Types: #{types.join(', ')}" if types.any?
+          end
+        end
+
+        # Find associations that reference this model polymorphically
+        polymorphic_has_many = model_class.reflect_on_all_associations.select do |r|
+          r.options[:as]
+        end
+
+        if polymorphic_has_many.any?
+          lines << '' if polymorphic_belongs_to.any?
+          lines << 'Polymorphic Targets:'
+          polymorphic_has_many.each do |reflection|
+            as_name = reflection.options[:as]
+            lines << "- #{reflection.name} (as: :#{as_name})"
+          end
+        end
+
+        return nil if lines.size == 1 # Only header
+
+        lines.join("\n")
+      end
+
+      def find_polymorphic_types(reflection)
+        return [] unless model_class.table_exists?
+
+        type_column = reflection.foreign_type
+        model_class
+          .where.not(type_column => nil)
+          .distinct
+          .pluck(type_column)
+          .compact
+          .sort
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Database error finding polymorphic types for #{model_class.name}: #{e.message}" }
+        []
+      rescue ActiveRecord::ConnectionNotEstablished => e
+        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        []
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/notes.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'error_handling'
+
+module RailsLens
+  module Analyzers
+    class Notes < Base
+      def initialize(model_class)
+        super
+        @connection = model_class.connection
+        @table_name = model_class.table_name
+      rescue ActiveRecord::ConnectionNotEstablished => e
+        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        @connection = nil
+        @table_name = nil
+      rescue NoMethodError => e
+        Rails.logger.debug { "Failed to initialize Notes analyzer for #{model_class.name}: #{e.message}" }
+        @connection = nil
+        @table_name = nil
+      rescue RuntimeError => e
+        Rails.logger.debug { "Runtime error initializing Notes analyzer for #{model_class.name}: #{e.message}" }
+        @connection = nil
+        @table_name = nil
+      end
+
+      def analyze
+        return nil unless @connection && @table_name
+
+        notes = []
+
+        notes.concat(analyze_indexes)
+        notes.concat(analyze_foreign_keys)
+        notes.concat(analyze_associations)
+        notes.concat(analyze_columns)
+        notes.concat(analyze_performance)
+        notes.concat(analyze_best_practices)
+
+        notes.compact.uniq
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Database error analyzing notes for #{@table_name}: #{e.message}" }
+        nil
+      rescue NoMethodError => e
+        Rails.logger.debug { "Method error analyzing notes for #{@table_name}: #{e.message}" }
+        nil
+      end
+
+      private
+
+      def analyze_indexes
+        notes = []
+
+        # Check for missing indexes on foreign keys
+        foreign_key_columns.each do |column|
+          notes << "Missing index on foreign key '#{column}'" unless has_index?(column)
+        end
+
+        # Check for missing composite indexes
+        common_query_patterns.each do |columns|
+          unless has_composite_index?(columns)
+            notes << "Consider composite index on (#{columns.join(', ')}) for common queries"
+          end
+        end
+
+        # Check for redundant indexes
+        redundant_indexes.each do |index|
+          notes << "Index '#{index.name}' might be redundant"
+        end
+
+        notes
+      end
+
+      def analyze_foreign_keys
+        notes = []
+
+        # Check for missing foreign key constraints
+        belongs_to_associations.each do |association|
+          column = association.foreign_key
+          next unless column_exists?(column)
+
+          unless has_foreign_key_constraint?(column)
+            notes << "Missing foreign key constraint for '#{column}' (#{association.name})"
+          end
+        end
+
+        notes
+      end
+
+      def analyze_associations
+        # Check for missing inverse_of
+        notes = associations_needing_inverse.map do |association|
+          "Association '#{association.name}' should specify inverse_of"
+        end
+
+        # Check for N+1 query risks
+        has_many_associations.each do |association|
+          if likely_n_plus_one?(association)
+            notes << "Association '#{association.name}' has N+1 query risk - consider includes/preload"
+          end
+        end
+
+        # Check for missing counter caches
+        associations_needing_counter_cache.each do |association|
+          notes << "Consider adding counter cache for '#{association.name}'"
+        end
+
+        notes
+      end
+
+      def analyze_columns
+        # Check for missing NOT NULL constraints
+        notes = columns_needing_not_null.map do |column|
+          "Column '#{column.name}' should probably have NOT NULL constraint"
+        end
+
+        # Check for missing defaults
+        columns_needing_defaults.each do |column|
+          notes << "Column '#{column.name}' should have a default value"
+        end
+
+        # Check for inappropriate column types
+        columns.each do |column|
+          if column.name.end_with?('_count') && column.type != :integer
+            notes << "Counter column '#{column.name}' should be integer type"
+          end
+
+          if column.name.match?(/price|amount|cost/) && column.type == :float
+            notes << "Monetary column '#{column.name}' should use decimal type, not float"
+          end
+        end
+
+        notes
+      end
+
+      def analyze_performance
+        # Large text columns without separate storage
+        notes = large_text_columns.map do |column|
+          "Large text column '#{column.name}' might benefit from separate storage"
+        end
+
+        # Polymorphic associations without indexes
+        polymorphic_associations.each do |association|
+          # For polymorphic belongs_to associations
+          next unless association.macro == :belongs_to && association.polymorphic?
+
+          foreign_key = association.foreign_key.to_s
+          type_column = "#{association.foreign_type || association.name}_type"
+          unless has_composite_index?([foreign_key, type_column])
+            notes << "Polymorphic association '#{association.name}' needs composite index on (#{foreign_key}, #{type_column})"
+          end
+        end
+
+        # UUID columns without proper indexes
+        uuid_columns.each do |column|
+          if column.name.end_with?('_id') && !has_index?(column.name)
+            notes << "UUID column '#{column.name}' needs an index"
+          end
+        end
+
+        notes
+      end
+
+      def analyze_best_practices
+        notes = []
+
+        # Check for updated_at/created_at
+        notes << "Missing 'created_at' timestamp column" unless column_exists?('created_at')
+
+        notes << "Missing 'updated_at' timestamp column" unless column_exists?('updated_at')
+
+        # Check for soft deletes without index
+        if column_exists?('deleted_at') && !has_index?('deleted_at')
+          notes << "Soft delete column 'deleted_at' needs an index"
+        end
+
+        # Check for STI without index
+        if model_class.inheritance_column && column_exists?(model_class.inheritance_column) && !has_index?(model_class.inheritance_column)
+          notes << "STI column '#{model_class.inheritance_column}' needs an index"
+        end
+
+        notes
+      end
+
+      # Helper methods
+
+      def columns
+        @columns ||= connection.columns(table_name)
+      end
+
+      def indexes
+        @indexes ||= connection.indexes(table_name)
+      end
+
+      def foreign_keys
+        @foreign_keys ||= if connection.respond_to?(:foreign_keys)
+                            connection.foreign_keys(table_name)
+                          else
+                            []
+                          end
+      end
+
+      def associations
+        @associations ||= model_class.reflect_on_all_associations
+      end
+
+      def belongs_to_associations
+        associations.select { |a| a.macro == :belongs_to }
+      end
+
+      def has_many_associations
+        associations.select { |a| a.macro == :has_many }
+      end
+
+      def polymorphic_associations
+        associations.select(&:polymorphic?)
+      end
+
+      def column_exists?(column_name)
+        columns.any? { |c| c.name == column_name.to_s }
+      end
+
+      def has_index?(column_name)
+        indexes.any? { |index| index.columns.include?(column_name.to_s) }
+      end
+
+      def has_composite_index?(column_names)
+        indexes.any? { |index| index.columns == column_names.map(&:to_s) }
+      end
+
+      def has_foreign_key_constraint?(column_name)
+        foreign_keys.any? { |fk| fk.column == column_name.to_s }
+      end
+
+      def foreign_key_columns
+        columns.select { |c| c.name.end_with?('_id') }.map(&:name)
+      end
+
+      def common_query_patterns
+        patterns = []
+
+        # Common patterns for most models
+        patterns << %w[user_id created_at] if column_exists?('created_at') && column_exists?('user_id')
+
+        patterns << %w[status created_at] if column_exists?('status') && column_exists?('created_at')
+
+        patterns
+      end
+
+      def redundant_indexes
+        redundant = []
+
+        indexes.each do |index|
+          indexes.each do |other_index|
+            next if index.name == other_index.name
+
+            # Check if index is a prefix of other_index
+            redundant << index if other_index.columns[0...index.columns.length] == index.columns
+          end
+        end
+
+        redundant.uniq
+      end
+
+      def associations_needing_inverse
+        associations.select do |association|
+          association.options[:inverse_of].nil? &&
+            !association.options[:through] &&
+            !association.options[:as] &&
+            association.macro != :has_and_belongs_to_many
+        end
+      end
+
+      def likely_n_plus_one?(association)
+        # Simple heuristic: has_many without conditions/scopes that would limit results
+        association.macro == :has_many &&
+          !association.options[:limit] &&
+          !association.scope
+      end
+
+      def associations_needing_counter_cache
+        belongs_to_associations.select do |association|
+          # Check if the inverse association exists and is commonly counted
+          inverse = association.klass.reflect_on_association(association.inverse_of&.name || model_class.name.underscore.pluralize)
+          inverse && inverse.macro == :has_many && !association.options[:counter_cache]
+        rescue NameError => e
+          Rails.logger.debug { "Failed to check counter cache for association: #{e.message}" }
+          false
+        rescue NoMethodError => e
+          Rails.logger.debug { "Method error checking counter cache: #{e.message}" }
+          false
+        end
+      end
+
+      def columns_needing_not_null
+        columns.select do |column|
+          column.null &&
+            !column.name.end_with?('_at') &&
+            !column.name.end_with?('_id') &&
+            %w[id created_at updated_at].exclude?(column.name) &&
+            column.type != :text &&
+            column.type != :json
+        end
+      end
+
+      def columns_needing_defaults
+        columns.select do |column|
+          column.default.nil? &&
+            column.type == :boolean
+        end
+      end
+
+      def large_text_columns
+        columns.select do |column|
+          %i[text json jsonb].include?(column.type)
+        end
+      end
+
+      def uuid_columns
+        columns.select do |column|
+          column.type == :uuid || (column.type == :string && column.name.match?(/uuid|guid/))
+        end
+      end
+    end
+  end
+end