rails_lens 0.2.11 → 0.3.0

data/lib/rails_lens/analyzers/inheritance.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class Inheritance < Base
@@ -42,23 +39,23 @@ module RailsLens
 
       def analyze_sti
         lines = []
-        lines << '== Inheritance (STI)'
-        lines << "Type Column: #{model_class.inheritance_column}"
+        lines << '[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'
+          lines << "subclasses = [#{subclasses.map { |s| "\"#{s}\"" }.join(', ')}]" if subclasses.any?
+          lines << 'base = true'
         else
           # This is a subclass
-          lines << "Base Class: #{model_class.base_class.name}"
-          lines << "Type Value: #{model_class.sti_name}"
+          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?
+          lines << "siblings = [#{siblings.map { |s| "\"#{s}\"" }.join(', ')}]" if siblings.any?
         end
 
         lines.join("\n")
@@ -69,14 +66,14 @@ module RailsLens
         return nil unless reflection
 
         lines = []
-        lines << '== Delegated Type'
-        lines << "Delegate: #{reflection.name}"
-        lines << "Type Column: #{reflection.foreign_type}"
-        lines << "ID Column: #{reflection.foreign_key}"
+        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 << "types = [#{types.map { |t| "\"#{t}\"" }.join(', ')}]" if types.any?
 
         lines.join("\n")
       end
@@ -151,38 +148,40 @@ module RailsLens
 
       def analyze_polymorphic
         lines = []
-        lines << '== Polymorphic Associations'
+        lines << '[polymorphic]'
 
-        # Find polymorphic belongs_to associations
+        # Find polymorphic belongs_to associations (references)
         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?
+          refs = polymorphic_belongs_to.map do |reflection|
+            types = if model_class.table_exists? && model_class.columns_hash[reflection.foreign_type.to_s]
+                      find_polymorphic_types(reflection)
+                    else
+                      []
+                    end
+            if types.any?
+              "{ name = \"#{reflection.name}\", type_col = \"#{reflection.foreign_type}\", id_col = \"#{reflection.foreign_key}\", types = [#{types.map { |t| "\"#{t}\"" }.join(', ')}] }"
+            else
+              "{ name = \"#{reflection.name}\", type_col = \"#{reflection.foreign_type}\", id_col = \"#{reflection.foreign_key}\" }"
+            end
           end
+          lines << "references = [#{refs.join(', ')}]"
         end
 
-        # Find associations that reference this model polymorphically
+        # Find associations that reference this model polymorphically (targets)
         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|
+          targets = polymorphic_has_many.map do |reflection|
             as_name = reflection.options[:as]
-            lines << "- #{reflection.name} (as: :#{as_name})"
+            "{ name = \"#{reflection.name}\", as = \"#{as_name}\" }"
           end
+          lines << "targets = [#{targets.join(', ')}]"
         end
 
         return nil if lines.size == 1 # Only header

data/lib/rails_lens/analyzers/notes.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'error_handling'
-
 module RailsLens
   module Analyzers
     class Notes < Base
@@ -61,13 +58,9 @@ module RailsLens
         notes = []
 
         # Check if this model is backed by a database view
-        if ModelDetector.view_exists?(model_class)
-          notes << '👁️ View-backed model: read-only'
-
-          # Check if model has readonly implementation
-          unless has_readonly_implementation?
-            notes << 'Add readonly? method'
-          end
+        # Only note if readonly protection is missing (view status is already obvious)
+        if ModelDetector.view_exists?(model_class) && !has_readonly_implementation?
+          notes << NoteCodes::ADD_READONLY
         end
 
         notes
@@ -81,22 +74,14 @@ module RailsLens
         view_metadata = ViewMetadata.new(model_class)
 
         # Check for materialized view specific issues
-        if view_metadata.materialized_view?
-          notes << '🔄 Materialized view: data may be stale until refreshed'
-          unless has_refresh_methods?
-            notes << 'Add refresh! method for manual updates'
-          end
+        if view_metadata.materialized_view? && !has_refresh_methods?
+          notes << NoteCodes::ADD_REFRESH
         end
 
         # Check for nested views (view depending on other views)
         dependencies = view_metadata.dependencies
         if dependencies.any? { |dep| view_exists_by_name?(dep) }
-          notes << '⚠️ Nested views detected: may impact query performance'
-        end
-
-        # Check for readonly implementation
-        unless has_readonly_implementation?
-          notes << '🔒 Add readonly protection to prevent write operations'
+          notes << NoteCodes::NESTED_VIEW
         end
 
         notes
@@ -110,19 +95,19 @@ module RailsLens
 
         # Check for missing indexes on foreign keys
         foreign_key_columns.each do |column|
-          notes << "Missing index on foreign key '#{column}'" unless has_index?(column)
+          notes << NoteCodes.note(column, NoteCodes::INDEX) 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"
+            notes << NoteCodes.note(columns.join('+'), NoteCodes::COMP_INDEX)
           end
         end
 
         # Check for redundant indexes
         redundant_indexes.each do |index|
-          notes << "Index '#{index.name}' might be redundant"
+          notes << NoteCodes.note(index.name, NoteCodes::REDUND_IDX)
         end
 
         notes
@@ -137,7 +122,7 @@ module RailsLens
           next unless column_exists?(column)
 
           unless has_foreign_key_constraint?(column)
-            notes << "Missing foreign key constraint for '#{column}' (#{association.name})"
+            notes << NoteCodes.note(column, NoteCodes::FK_CONSTRAINT)
           end
         end
 
@@ -147,19 +132,19 @@ module RailsLens
       def analyze_associations
         # Check for missing inverse_of
         notes = associations_needing_inverse.map do |association|
-          "Association '#{association.name}' should specify inverse_of"
+          NoteCodes.note(association.name.to_s, NoteCodes::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"
+            notes << NoteCodes.note(association.name.to_s, NoteCodes::N_PLUS_ONE)
           end
         end
 
         # Check for missing counter caches
         associations_needing_counter_cache.each do |association|
-          notes << "Consider adding counter cache for '#{association.name}'"
+          notes << NoteCodes.note(association.name.to_s, NoteCodes::COUNTER_CACHE)
         end
 
         notes
@@ -168,22 +153,22 @@ module RailsLens
       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"
+          NoteCodes.note(column.name, NoteCodes::NOT_NULL)
         end
 
         # Check for missing defaults
         columns_needing_defaults.each do |column|
-          notes << "Column '#{column.name}' should have a default value"
+          notes << NoteCodes.note(column.name, NoteCodes::DEFAULT)
         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"
+            notes << NoteCodes.note(column.name, NoteCodes::USE_INTEGER)
           end
 
           if column.name.match?(/price|amount|cost/) && column.type == :float
-            notes << "Monetary column '#{column.name}' should use decimal type, not float"
+            notes << NoteCodes.note(column.name, NoteCodes::USE_DECIMAL)
           end
         end
 
@@ -193,7 +178,7 @@ module RailsLens
       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"
+          NoteCodes.note(column.name, NoteCodes::STORAGE)
         end
 
         # Polymorphic associations without indexes
@@ -204,14 +189,14 @@ module RailsLens
           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})"
+            notes << NoteCodes.note(association.name.to_s, NoteCodes::POLY_INDEX)
           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"
+            notes << NoteCodes.note(column.name, NoteCodes::INDEX)
           end
         end
 
@@ -222,18 +207,23 @@ module RailsLens
         notes = []
 
         # Check for updated_at/created_at
-        notes << "Missing 'created_at' timestamp column" unless column_exists?('created_at')
+        has_created = column_exists?('created_at')
+        has_updated = column_exists?('updated_at')
 
-        notes << "Missing 'updated_at' timestamp column" unless column_exists?('updated_at')
+        if !has_created && !has_updated
+          notes << NoteCodes::NO_TIMESTAMPS
+        elsif !has_created || !has_updated
+          notes << NoteCodes::PARTIAL_TS
+        end
 
         # Check for soft deletes without index
         if column_exists?('deleted_at') && !has_index?('deleted_at')
-          notes << "Soft delete column 'deleted_at' needs an index"
+          notes << NoteCodes.note('deleted_at', NoteCodes::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"
+          notes << NoteCodes.note(model_class.inheritance_column, NoteCodes::STI_INDEX)
         end
 
         notes

data/lib/rails_lens/analyzers/performance_analyzer.rb

@@ -5,7 +5,6 @@ module RailsLens
     class PerformanceAnalyzer < Base
       def analyze
         notes = []
-        notes.concat(analyze_large_text_columns)
         notes.concat(analyze_uuid_indexes)
         notes.concat(analyze_query_performance)
         notes
@@ -13,18 +12,6 @@ module RailsLens
 
       private
 
-      def analyze_large_text_columns
-        notes = []
-
-        text_columns.each do |column|
-          if frequently_queried_column?(column)
-            notes << "Large text column '#{column.name}' is frequently queried - consider separate storage"
-          end
-        end
-
-        notes
-      end
-
       def analyze_uuid_indexes
         notes = []
 
@@ -32,7 +19,7 @@ module RailsLens
           next if column.name == 'id' # Primary keys are already indexed
 
           if should_be_indexed?(column) && !indexed?(column)
-            notes << "UUID column '#{column.name}' should be indexed for better query performance"
+            notes << NoteCodes.note(column.name, NoteCodes::INDEX)
           end
         end
 
@@ -46,34 +33,24 @@ module RailsLens
         commonly_queried_columns.each do |column|
           next if indexed?(column)
 
-          notes << "Column '#{column.name}' is commonly used in queries - consider adding an index"
+          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 << "Scope column '#{column.name}' should be indexed"
+          notes << NoteCodes.note(column.name, NoteCodes::INDEX)
         end
 
         notes
       end
 
-      def text_columns
-        model_class.columns.select { |c| c.type == :text }
-      end
-
       def uuid_columns
         model_class.columns.select { |c| c.type == :uuid || (c.type == :string && c.name.match?(/uuid|guid/i)) }
       end
 
-      def frequently_queried_column?(column)
-        # Heuristic: columns with certain names are likely to be queried frequently
-        column.name.match?(/title|name|slug|description|summary|content|body/i)
-      end
-
       def should_be_indexed?(column)
-        # UUID columns used as foreign keys or identifiers should be indexed
         column.name.end_with?('_id', '_uuid', '_guid') ||
           column.name.match?(/identifier|reference|token/i)
       end

data/lib/rails_lens/annotation_pipeline.rb

@@ -75,6 +75,7 @@ module RailsLens
       register(Providers::CompositeKeysProvider.new)
       register(Providers::DatabaseConstraintsProvider.new)
       register(Providers::GeneratedColumnsProvider.new)
+      register(Providers::CallbacksProvider.new)
 
       # Notes providers (analysis and recommendations)
       return unless RailsLens.config.schema[:include_notes]

data/lib/rails_lens/cli.rb

@@ -21,6 +21,7 @@ module RailsLens
     desc 'annotate', 'Annotate Rails models with schema information'
     option :models, type: :array, desc: 'Specific models to annotate'
     option :include_abstract, type: :boolean, desc: 'Include abstract classes'
+    option :include_database_objects, type: :boolean, default: true, desc: 'Include database objects (functions, etc.) in abstract classes'
     option :position, type: :string, enum: %w[before after top bottom], desc: 'Annotation position'
     option :routes, type: :boolean, desc: 'Annotate controller routes'
     option :mailers, type: :boolean, desc: 'Annotate mailer methods'

data/lib/rails_lens/commands.rb

@@ -24,6 +24,28 @@ module RailsLens
         end
       end
 
+      # Also annotate database-level objects (functions, etc.)
+      if options[:include_database_objects]
+        db_results = annotate_database_objects(options)
+        results.merge!(database_objects: db_results)
+      end
+
+      results
+    end
+
+    def annotate_database_objects(options = {})
+      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
+
       results
     end
 
@@ -183,7 +205,7 @@ module RailsLens
       end
 
       # Create lib/tasks directory if it doesn't exist
-      FileUtils.mkdir_p(tasks_dir) unless Dir.exist?(tasks_dir)
+      FileUtils.mkdir_p(tasks_dir)
 
       # Write the rake task
       File.write(rake_file, rake_task_template)

data/lib/rails_lens/configuration.rb

@@ -40,7 +40,10 @@ module RailsLens
           show_comments: true,
           show_foreign_keys: true,
           show_indexes: true,
-          show_check_constraints: true
+          show_check_constraints: true,
+          show_triggers: true,
+          show_functions: true,
+          show_callbacks: true
         }
       }
 

data/lib/rails_lens/erd/visualizer.rb

@@ -3,7 +3,6 @@
 module RailsLens
   module ERD
     class Visualizer
-      require_relative 'domain_color_mapper'
       attr_reader :options, :config
 
       def initialize(options: {})

data/lib/rails_lens/extensions/closure_tree_ext.rb

@@ -20,13 +20,13 @@ module RailsLens
         return nil unless model_uses_closure_tree?
 
         lines = []
-        lines << '== Hierarchy (ClosureTree)'
-        lines << "Parent Column: #{parent_column_name}"
-        lines << "Hierarchy Table: #{hierarchy_table_name}"
+        lines << '[closure_tree]'
+        lines << "parent_column = \"#{parent_column_name}\""
+        lines << "hierarchy_table = \"#{hierarchy_table_name}\""
 
-        lines << "Order Column: #{order_column}" if order_column
+        lines << "order_column = \"#{order_column}\"" if order_column
 
-        lines << "Depth Column: #{depth_column}" if depth_column && has_column?(depth_column)
+        lines << "depth_column = \"#{depth_column}\"" if depth_column && has_column?(depth_column)
 
         lines.join("\n")
       end
@@ -37,29 +37,29 @@ module RailsLens
         notes = []
 
         # Check parent column index
-        notes << "Missing index on parent column '#{parent_column_name}'" unless has_index?(parent_column_name)
+        notes << NoteCodes.note(parent_column_name, NoteCodes::INDEX) unless has_index?(parent_column_name)
 
         # Check hierarchy table existence and indexes
         if hierarchy_table_exists?
           unless has_hierarchy_indexes?
-            notes << "Hierarchy table '#{hierarchy_table_name}' needs compound index on (ancestor_id, descendant_id)"
+            notes << NoteCodes.note(hierarchy_table_name, NoteCodes::COMP_INDEX)
           end
 
           unless has_hierarchy_depth_index?
-            notes << 'Consider adding index on generations column in hierarchy table for depth queries'
+            notes << NoteCodes.note('generations', NoteCodes::INDEX)
           end
         else
-          notes << "Hierarchy table '#{hierarchy_table_name}' does not exist - run migrations"
+          notes << NoteCodes.note(hierarchy_table_name, NoteCodes::MISSING)
         end
 
         # Check for counter cache
         if should_have_counter_cache? && !has_counter_cache?
-          notes << "Consider adding counter cache '#{suggested_counter_cache_name}' for children count"
+          notes << NoteCodes.note('children', NoteCodes::COUNTER_CACHE)
         end
 
         # Check depth column
         if model_class.respond_to?(:cache_depth?) && model_class.cache_depth? && !has_column?(depth_column)
-          notes << "Depth caching enabled but column '#{depth_column}' is missing"
+          notes << NoteCodes.note(depth_column, NoteCodes::DEPTH_CACHE)
         end
 
         notes

data/lib/rails_lens/mailer/annotator.rb

@@ -7,14 +7,14 @@ module RailsLens
       def initialize(dry_run: false)
         @dry_run = dry_run
         @mailers = RailsLens::Mailer::Extractor.call
-        @changed_files = []
+        @changed_files = Set.new
       end
 
       # Annotate all mailer files with mailer information
       #
       # @param pattern [String] Glob pattern for mailer files
       # @param exclusion [String] Glob pattern for files to exclude
-      # @return [Array<String>] List of changed files
+      # @return [Set<String>] Set of changed files
       def annotate_all(pattern: '**/*_mailer.rb', exclusion: 'vendor/**/*_mailer.rb')
         # Simply annotate all mailer files we found via their source locations
         source_paths_map.each do |source_path, methods|
@@ -31,7 +31,7 @@ module RailsLens
       #
       # @param pattern [String] Glob pattern for mailer files
       # @param exclusion [String] Glob pattern for files to exclude
-      # @return [Array<String>] List of changed files
+      # @return [Set<String>] Set of changed files
       def remove_all(pattern: '**/*_mailer.rb', exclusion: 'vendor/**/*_mailer.rb')
         # Remove annotations from all mailer files we found via their source locations
         source_paths_map.each_key do |source_path|

data/lib/rails_lens/model_detector.rb

@@ -415,23 +415,69 @@ module RailsLens
       end
 
       def table_exists_with_connection?(model, connection)
-        connection.table_exists?(model.table_name)
+        table_name = model.table_name
+
+        # Handle schema-qualified table names for PostgreSQL (e.g., 'audit.audit_logs')
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.table_exists?(unqualified_name) || connection.views.include?(unqualified_name)
+          end
+        else
+          # Check both tables and views
+          return true if connection.table_exists?(table_name)
+          return true if connection.views.include?(table_name)
+
+          # Fallback for SQLite: direct sqlite_master query for views
+          if connection.adapter_name.downcase.include?('sqlite')
+            check_sqlite_view(connection, table_name)
+          else
+            false
+          end
+        end
       rescue StandardError
         false
       end
 
       def columns_empty_with_connection?(model, connection)
-        connection.columns(model.table_name).empty?
+        table_name = model.table_name
+
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.columns(unqualified_name).empty?
+          end
+        else
+          connection.columns(table_name).empty?
+        end
       rescue StandardError
         true
       end
 
       def get_column_count_with_connection(model, connection)
-        connection.columns(model.table_name).size
+        table_name = model.table_name
+
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.columns(unqualified_name).size
+          end
+        else
+          connection.columns(table_name).size
+        end
       rescue StandardError
         0
       end
 
+      # Helper to execute block with schema in PostgreSQL search_path
+      def with_schema_in_search_path(connection, qualified_table_name)
+        schema_name, unqualified_name = qualified_table_name.split('.', 2)
+        original_search_path = connection.schema_search_path
+        begin
+          connection.schema_search_path = "#{schema_name}, #{original_search_path}"
+          yield unqualified_name
+        ensure
+          connection.schema_search_path = original_search_path
+        end
+      end
+
       def has_sti_column?(model)
         return false unless model.table_exists?