rails_lens 0.0.0 → 0.2.2

data/lib/rails_lens/analyzers/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'error_handling'
+
+module RailsLens
+  module Analyzers
+    class Base
+      include ErrorHandling
+
+      attr_reader :model_class
+
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def analyze
+        raise NotImplementedError, 'Subclasses must implement #analyze'
+      end
+
+      protected
+
+      def table_name
+        @table_name ||= model_class.table_name
+      end
+
+      def connection
+        @connection ||= model_class.connection
+      end
+
+      def adapter_name
+        @adapter_name ||= connection.adapter_name
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/best_practices_analyzer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class BestPracticesAnalyzer < Base
+      def analyze
+        notes = []
+        notes.concat(analyze_timestamps)
+        notes.concat(analyze_soft_deletes)
+        notes.concat(analyze_sti_columns)
+        notes.concat(analyze_naming_conventions)
+        notes
+      end
+
+      private
+
+      def analyze_timestamps
+        notes = []
+
+        notes << 'Missing timestamp columns (created_at, updated_at)' unless has_timestamps?
+
+        if has_column?('created_at') && !has_column?('updated_at')
+          notes << 'Has created_at but missing updated_at'
+        elsif !has_column?('created_at') && has_column?('updated_at')
+          notes << 'Has updated_at but missing created_at'
+        end
+
+        notes
+      end
+
+      def analyze_soft_deletes
+        notes = []
+
+        soft_delete_columns.each do |column|
+          notes << "Soft delete column '#{column.name}' should be indexed" unless indexed?(column)
+        end
+
+        notes
+      end
+
+      def analyze_sti_columns
+        notes = []
+
+        if sti_model? && type_column
+          notes << "STI type column '#{type_column.name}' should be indexed" unless indexed?(type_column)
+
+          notes << "STI type column '#{type_column.name}' should have NOT NULL constraint" if type_column.null
+        end
+
+        notes
+      end
+
+      def analyze_naming_conventions
+        notes = []
+
+        # Check for non-conventional column names
+        columns.each do |column|
+          if column.name.match?(/^(is|has)_/i)
+            notes << "Column '#{column.name}' uses non-conventional prefix - consider removing 'is_' or 'has_'"
+          end
+
+          if column.name.match?(/Id$/) # Capital I
+            notes << "Column '#{column.name}' should use snake_case (e.g., '#{column.name.underscore}')"
+          end
+        end
+
+        # Check table naming
+        if !table_name.match?(/^[a-z_]+$/) || table_name != table_name.pluralize
+          notes << "Table name '#{table_name}' doesn't follow Rails conventions (should be plural, snake_case)"
+        end
+
+        notes
+      end
+
+      def has_timestamps?
+        has_column?('created_at') && has_column?('updated_at')
+      end
+
+      def soft_delete_columns
+        columns.select { |c| c.name.match?(/deleted_at|archived_at|discarded_at/i) }
+      end
+
+      def sti_model?
+        model_class.base_class != model_class || has_column?('type')
+      end
+
+      def type_column
+        columns.find { |c| c.name == 'type' }
+      end
+
+      def has_column?(name)
+        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/column_analyzer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class ColumnAnalyzer < Base
+      def analyze
+        notes = []
+        notes.concat(analyze_null_constraints)
+        notes.concat(analyze_default_values)
+        notes.concat(analyze_column_types)
+        notes
+      end
+
+      private
+
+      def analyze_null_constraints
+        columns_needing_not_null.map do |column|
+          "Column '#{column.name}' should probably have NOT NULL constraint"
+        end
+      end
+
+      def analyze_default_values
+        notes = []
+
+        columns.each do |column|
+          if column.type == :boolean && column.default.nil? && column.null
+            notes << "Boolean column '#{column.name}' should have a default value"
+          end
+
+          if status_column?(column) && column.default.nil?
+            notes << "Status column '#{column.name}' should have a default value"
+          end
+        end
+
+        notes
+      end
+
+      def analyze_column_types
+        notes = []
+
+        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"
+          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}"
+          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"
+          end
+        end
+
+        notes
+      end
+
+      def columns_needing_not_null
+        columns.select do |column|
+          column.null &&
+            !column.name.end_with?('_id') && # Foreign keys might be nullable
+            !optional_column?(column) &&
+            !timestamp_column?(column)
+        end
+      end
+
+      def money_column?(column)
+        column.name.match?(/price|cost|amount|fee|rate|salary|budget|revenue|profit|balance/i)
+      end
+
+      def counter_column?(column)
+        column.name.end_with?('_count', '_counter', '_total')
+      end
+
+      def status_column?(column)
+        column.name.match?(/status|state/i) || column.name == 'workflow_state'
+      end
+
+      def optional_column?(column)
+        column.name.match?(/optional|nullable|maybe|perhaps/i) ||
+          column.name.end_with?('_at', '_on', '_date') ||
+          column.name.start_with?('last_', 'next_', 'previous_')
+      end
+
+      def timestamp_column?(column)
+        %w[created_at updated_at deleted_at].include?(column.name)
+      end
+
+      def columns
+        @columns ||= model_class.columns
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/composite_keys.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'error_handling'
+
+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
+
+        # 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
+        Rails.logger.debug { "Failed to analyze composite keys for #{model_class.name}: #{e.message}" }
+        nil
+      rescue ActiveRecord::ConnectionNotEstablished => e
+        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        nil
+      end
+
+      private
+
+      def format_composite_keys(keys)
+        lines = ['== Composite Primary Key']
+        lines << "Primary Keys: #{keys.join(', ')}"
+        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
+        Rails.logger.debug { "Failed to detect composite keys from database for #{table_name}: #{e.message}" }
+        nil
+      rescue PG::Error => e
+        Rails.logger.debug { "PostgreSQL error detecting composite keys: #{e.message}" }
+        nil
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/database_constraints.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'error_handling'
+
+module RailsLens
+  module Analyzers
+    class DatabaseConstraints < Base
+      def analyze
+        return nil unless connection.respond_to?(:check_constraints)
+
+        constraints = []
+
+        # Get check constraints
+        check_constraints = connection.check_constraints(table_name)
+        return nil if check_constraints.empty?
+
+        constraints << '== Check Constraints'
+        check_constraints.each do |constraint|
+          name = constraint.options[:name] || constraint.name
+          expression = constraint.expression || constraint.options[:validate]
+          constraints << "- #{name}: #{expression}"
+        end
+
+        constraints.empty? ? nil : constraints.join("\n")
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
+        nil
+      rescue NoMethodError => e
+        Rails.logger.debug { "Check constraints not supported by adapter: #{e.message}" }
+        nil
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/delegated_types.rb

@@ -0,0 +1,129 @@
+# 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']
+
+        # 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]}"
+        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.join("\n")
+      end
+
+      private
+
+      def delegated_type_model?
+        # Check if model uses delegated_type by looking for the Rails-provided class methods
+        # Rails delegated_type creates a "prefix_types" class method
+
+        # Skip abstract models that don't have tables configured
+        return false unless model_class.respond_to?(:table_exists?) && model_class.table_exists?
+
+        columns = model_class.column_names
+
+        # Look for columns ending with _type that have corresponding _id columns
+        # and check if the model has the corresponding delegated type class method
+        columns.any? do |col|
+          if col.end_with?('_type')
+            prefix = col.sub(/_type$/, '')
+            if columns.include?("#{prefix}_id")
+              # Check if Rails delegated_type created the "prefix_types" class method
+              model_class.respond_to?("#{prefix}_types")
+            end
+          end
+        end
+      end
+
+      def find_delegated_type_info
+        # Find columns that match the delegated type pattern and have the Rails class method
+        # Skip abstract models that don't have tables configured
+        return nil unless model_class.respond_to?(:table_exists?) && model_class.table_exists?
+
+        columns = model_class.column_names
+
+        # Find the delegated type by checking for the Rails-provided class method
+        delegated_info = nil
+        columns.each do |col|
+          next unless col.end_with?('_type')
+
+          prefix = col.sub(/_type$/, '')
+          id_column = "#{prefix}_id"
+
+          next unless columns.include?(id_column) && model_class.respond_to?("#{prefix}_types")
+
+          # Use the Rails-provided method to get the types
+          types = model_class.send("#{prefix}_types")
+
+          delegated_info = {
+            type_column: col,
+            id_column: id_column,
+            types: types
+          }
+          break
+        end
+
+        delegated_info
+      rescue NoMethodError => e
+        Rails.logger.debug { "Failed to find delegated type info for #{model_class.name}: #{e.message}" }
+        nil
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Database error finding delegated type info: #{e.message}" }
+        nil
+      end
+
+      def polymorphic_association?(prefix)
+        # Check if this is a polymorphic association by looking at the model's reflections
+        model_class.reflections.values.any? do |reflection|
+          reflection.polymorphic? && reflection.name.to_s == prefix
+        end
+      end
+
+      def infer_delegated_types(prefix)
+        # First try to read from the model file to find delegated_type declaration
+        model_file = "app/models/#{model_class.name.underscore}.rb"
+        if File.exist?(model_file)
+          content = File.read(model_file)
+          if (match = content.match(/delegated_type\s+:#{prefix}.*types:\s*%(w|W)\[([^\]]+)\]/))
+            types_string = match[2]
+            return types_string.scan(/\w+/)
+          end
+        end
+
+        # Fallback to database
+        if model_class.table_exists?
+          model_class
+            .where.not("#{prefix}_type" => nil)
+            .distinct
+            .pluck("#{prefix}_type")
+            .compact
+            .sort
+        else
+          []
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Database error inferring delegated types: #{e.message}" }
+        []
+      rescue Errno::ENOENT => e
+        Rails.logger.debug { "File not found when inferring delegated types: #{e.message}" }
+        []
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/enums.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class Enums < Base
+      def analyze
+        return nil unless model_class.respond_to?(:defined_enums) && model_class.defined_enums.any?
+
+        lines = []
+        lines << '== Enums'
+
+        model_class.defined_enums.each do |name, values|
+          # Detect if it's using integer or string values
+          formatted_values = if values.values.all? { |v| v.is_a?(Integer) }
+                               # Integer-based enum
+                               values.map { |k, v| "#{k}: #{v}" }.join(', ')
+                             else
+                               # String-based enum
+                               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
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/error_handling.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    # Mixin for consistent error handling across analyzers
+    module ErrorHandling
+      def safe_analyze
+        analyze
+      rescue ActiveRecord::StatementInvalid => e
+        handle_database_error(e)
+      rescue NameError, NoMethodError => e
+        handle_method_error(e)
+      rescue StandardError => e
+        handle_unexpected_error(e)
+      end
+
+      private
+
+      def handle_database_error(error)
+        ErrorReporter.report(error, {
+                               analyzer: self.class.name,
+                               model: model_class.name,
+                               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
+                             })
+        []
+      end
+
+      def handle_unexpected_error(error)
+        ErrorReporter.report(error, {
+                               analyzer: self.class.name,
+                               model: model_class.name,
+                               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'
+                             })
+        default
+      rescue NoMethodError, NameError => e
+        ErrorReporter.report(e, {
+                               analyzer: self.class.name,
+                               model: model_class.name,
+                               operation: 'method_call'
+                             })
+        default
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/foreign_key_analyzer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Analyzers
+    class ForeignKeyAnalyzer < Base
+      def analyze
+        return [] unless connection.supports_foreign_keys?
+
+        notes = []
+        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
+
+          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}'"
+          end
+        end
+
+        notes
+      end
+
+      private
+
+      def belongs_to_associations
+        model_class.reflect_on_all_associations(:belongs_to)
+      end
+
+      def foreign_key_exists?(column, referenced_table, existing_foreign_keys)
+        existing_foreign_keys.any? do |fk|
+          fk.column == column.to_s && fk.to_table == referenced_table
+        end
+      end
+
+      def connection
+        model_class.connection
+      end
+
+      def table_name
+        model_class.table_name
+      end
+    end
+  end
+end

data/lib/rails_lens/analyzers/generated_columns.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'error_handling'
+
+module RailsLens
+  module Analyzers
+    class GeneratedColumns < Base
+      def analyze
+        return nil unless adapter_name == 'PostgreSQL'
+
+        generated_columns = detect_generated_columns
+        return nil if generated_columns.empty?
+
+        lines = ['== Generated Columns']
+        generated_columns.each do |column|
+          lines << "- #{column[:name]} (#{column[:expression]})"
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def detect_generated_columns
+        # PostgreSQL system query to find generated columns
+        sql = <<-SQL.squish
+          SELECT#{' '}
+            a.attname AS column_name,
+            pg_get_expr(d.adbin, d.adrelid) AS generation_expression
+          FROM pg_attribute a
+          JOIN pg_class c ON a.attrelid = c.oid
+          LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+          WHERE c.relname = '#{table_name}'
+            AND a.attgenerated != ''
+            AND NOT a.attisdropped
+          ORDER BY a.attnum
+        SQL
+
+        result = connection.execute(sql)
+        result.map do |row|
+          {
+            name: row['column_name'],
+            expression: row['generation_expression']
+          }
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.debug { "Failed to detect generated columns for #{table_name}: #{e.message}" }
+        []
+      rescue PG::Error => e
+        Rails.logger.debug { "PostgreSQL error detecting generated columns: #{e.message}" }
+        []
+      end
+    end
+  end
+end