rails_lens 0.2.12 → 0.5.0

data/lib/rails_lens/schema/adapters/postgresql.rb

@@ -29,6 +29,7 @@ module RailsLens
           add_indexes_toml(lines) if show_indexes?
           add_foreign_keys_toml(lines) if show_foreign_keys?
           add_check_constraints_toml(lines) if show_check_constraints?
+          add_triggers_toml(lines) if show_triggers?
           add_table_comment_toml(lines) if show_comments?
 
           lines.join("\n")
@@ -294,23 +295,24 @@ module RailsLens
 
         # Fetch all view metadata in a single consolidated query
         def fetch_view_metadata
+          target_schema = schema_name || 'public'
           result = connection.exec_query(<<~SQL.squish, 'PostgreSQL View Metadata')
             WITH view_info AS (
-              -- Check for materialized view
               SELECT
                 'materialized' as view_type,
                 false as is_updatable,
                 mv.matviewname as view_name
               FROM pg_matviews mv
               WHERE mv.matviewname = '#{connection.quote_string(unqualified_table_name)}'
+                AND mv.schemaname = '#{connection.quote_string(target_schema)}'
               UNION ALL
-              -- Check for regular view
               SELECT
                 'regular' as view_type,
                 CASE WHEN v.is_updatable = 'YES' THEN true ELSE false END as is_updatable,
                 v.table_name as view_name
               FROM information_schema.views v
               WHERE v.table_name = '#{connection.quote_string(unqualified_table_name)}'
+                AND v.table_schema = '#{connection.quote_string(target_schema)}'
             ),
             dependencies AS (
               SELECT DISTINCT c2.relname as dependency_name
@@ -336,10 +338,19 @@ module RailsLens
           return nil if result.rows.empty?
 
           row = result.rows.first
+          # Parse PostgreSQL array string (e.g., "{table1,table2}" or "{}")
+          deps_raw = row[2]
+          deps = if deps_raw.is_a?(Array)
+                   deps_raw
+                 elsif deps_raw.is_a?(String) && deps_raw.start_with?('{')
+                   deps_raw.gsub(/[{}]/, '').split(',').map(&:strip).reject(&:empty?)
+                 else
+                   []
+                 end
           {
             type: row[0],
             updatable: ['t', true].include?(row[1]),
-            dependencies: row[2] || []
+            dependencies: deps
           }
         rescue ActiveRecord::StatementInvalid, PG::Error => e
           RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
@@ -401,6 +412,115 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid, PG::Error
           nil
         end
+
+        # Fetch triggers for the table, excluding extension-owned triggers
+        def fetch_triggers
+          result = connection.exec_query(<<~SQL.squish, 'PostgreSQL Table Triggers')
+            SELECT
+              t.tgname AS name,
+              CASE t.tgtype::integer & 66
+                WHEN 2 THEN 'BEFORE'
+                WHEN 64 THEN 'INSTEAD OF'
+                ELSE 'AFTER'
+              END AS timing,
+              CASE t.tgtype::integer & 60
+                WHEN 4 THEN 'INSERT'
+                WHEN 8 THEN 'DELETE'
+                WHEN 16 THEN 'UPDATE'
+                WHEN 20 THEN 'INSERT OR UPDATE'
+                WHEN 24 THEN 'UPDATE OR DELETE'
+                WHEN 12 THEN 'INSERT OR DELETE'
+                WHEN 28 THEN 'INSERT OR UPDATE OR DELETE'
+                WHEN 32 THEN 'TRUNCATE'
+                ELSE 'UNKNOWN'
+              END AS event,
+              CASE WHEN t.tgtype::integer & 1 = 1 THEN 'ROW' ELSE 'STATEMENT' END AS for_each,
+              p.proname AS function_name,
+              n.nspname AS function_schema,
+              pg_get_triggerdef(t.oid) AS definition
+            FROM pg_trigger t
+            JOIN pg_class c ON t.tgrelid = c.oid
+            JOIN pg_namespace cn ON c.relnamespace = cn.oid
+            JOIN pg_proc p ON t.tgfoid = p.oid
+            JOIN pg_namespace n ON p.pronamespace = n.oid
+            WHERE c.relname = '#{connection.quote_string(unqualified_table_name)}'
+              AND cn.nspname = '#{connection.quote_string(schema_name || 'public')}'
+              AND NOT t.tgisinternal
+              -- Exclude triggers owned by extensions
+              AND NOT EXISTS (
+                SELECT 1 FROM pg_depend d
+                JOIN pg_extension e ON d.refobjid = e.oid
+                WHERE d.objid = t.oid
+                  AND d.deptype = 'e'
+              )
+            ORDER BY t.tgname
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              timing: row[1],
+              event: row[2],
+              for_each: row[3],
+              function: row[5] == 'public' ? row[4] : "#{row[5]}.#{row[4]}",
+              definition: row[6],
+              condition: extract_trigger_condition(row[6])
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, PG::Error => e
+          RailsLens.logger.debug { "Failed to fetch triggers for #{table_name}: #{e.message}" }
+          []
+        end
+
+        # Extract WHEN condition from trigger definition if present
+        def extract_trigger_condition(definition)
+          return nil unless definition
+
+          match = definition.match(/WHEN\s*\((.+?)\)\s*EXECUTE/i)
+          match ? match[1] : nil
+        end
+
+        # Fetch all user-defined functions, excluding extension-owned functions
+        # This is a database-level operation, returns all functions in user schemas
+        def self.fetch_functions(connection)
+          result = connection.exec_query(<<~SQL.squish, 'PostgreSQL Functions')
+            SELECT
+              p.proname AS name,
+              n.nspname AS schema,
+              l.lanname AS language,
+              CASE
+                WHEN p.prorettype = 'trigger'::regtype THEN 'trigger'
+                ELSE pg_catalog.format_type(p.prorettype, NULL)
+              END AS return_type,
+              pg_get_functiondef(p.oid) AS definition,
+              obj_description(p.oid, 'pg_proc') AS description
+            FROM pg_proc p
+            JOIN pg_namespace n ON p.pronamespace = n.oid
+            JOIN pg_language l ON p.prolang = l.oid
+            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+              AND NOT EXISTS (
+                SELECT 1 FROM pg_depend d
+                JOIN pg_extension e ON d.refobjid = e.oid
+                WHERE d.objid = p.oid
+                  AND d.deptype = 'e'
+              )
+            ORDER BY n.nspname, p.proname
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              schema: row[1],
+              language: row[2],
+              return_type: row[3],
+              definition: row[4],
+              description: row[5]
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, PG::Error => e
+          RailsLens.logger.debug { "Failed to fetch functions: #{e.message}" }
+          []
+        end
       end
     end
   end

data/lib/rails_lens/schema/annotation_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../file_insertion_helper'
-
 module RailsLens
   module Schema
     class AnnotationManager
@@ -140,19 +138,63 @@ module RailsLens
           annotation.add_lines(section[:content].split("\n"))
         end
 
-        # Add notes
+        # Add notes as TOML array (already in compact format from analyzers)
         if results[:notes].any?
           annotation.add_line('')
-          annotation.add_line('== Notes')
-          results[:notes].uniq.each do |note|
-            annotation.add_line("- #{note}")
-          end
+          annotation.add_line("notes = [#{results[:notes].uniq.map { |n| "\"#{n}\"" }.join(', ')}]")
         end
 
         annotation.to_s
       end
 
       def self.annotate_all(options = {})
+        results = { annotated: [], skipped: [], failed: [] }
+
+        # Iterate through all model sources
+        ModelSourceLoader.load_sources.each do |source|
+          puts "Annotating #{source.source_name} models..." if options[:verbose]
+          source_results = annotate_source(source, options)
+          merge_results(results, source_results)
+        end
+
+        results
+      end
+
+      # Annotate models from a specific source
+      def self.annotate_source(source, options = {})
+        results = { annotated: [], skipped: [], failed: [] }
+
+        begin
+          models = source.models(options)
+          puts "  Found #{models.size} #{source.source_name} models" if options[:verbose]
+
+          models.each do |model|
+            result = source.annotate_model(model, options)
+            case result[:status]
+            when :annotated
+              results[:annotated] << result[:model]
+            when :skipped
+              results[:skipped] << result[:model]
+            when :failed
+              results[:failed] << { model: result[:model], error: result[:message] }
+            end
+          end
+        rescue StandardError => e
+          puts "  Error processing #{source.source_name} source: #{e.message}" if options[:verbose]
+        end
+
+        results
+      end
+
+      # Merge source results into main results
+      def self.merge_results(main, source)
+        main[:annotated].concat(source[:annotated] || [])
+        main[:skipped].concat(source[:skipped] || [])
+        main[:failed].concat(source[:failed] || [])
+      end
+
+      # Original ActiveRecord-specific annotation logic (used by ActiveRecordSource)
+      def self.annotate_active_record_models(options = {})
         # Convert models option to include option for ModelDetector
         if options[:models]
           options[:include] = options[:models]
@@ -194,16 +236,8 @@ module RailsLens
           end
         end
 
-        # Get all connection pools first
-        all_pools = get_all_connection_pools(models_by_connection_pool)
-
-        # Log initial connection status (removed verbose output)
-
         models_by_connection_pool.each do |connection_pool, pool_models|
           if connection_pool
-            # Disconnect all OTHER connection pools before processing this one
-            disconnect_other_pools(connection_pool, all_pools, options)
-
             # Process all models for this database using a single connection
             connection_pool.with_connection do |connection|
               pool_models.each do |model|
@@ -278,60 +312,81 @@ module RailsLens
       end
 
       def self.remove_all(options = {})
-        models = ModelDetector.detect_models(options)
         results = { removed: [], skipped: [], failed: [] }
 
-        models.each do |model|
-          manager = new(model)
-          if manager.remove_annotations
-            results[:removed] << model.name
-          else
-            results[:skipped] << model.name
-          end
-        rescue StandardError => e
-          results[:failed] << { model: model.name, error: e.message }
+        # Iterate through all model sources
+        ModelSourceLoader.load_sources.each do |source|
+          puts "Removing annotations from #{source.source_name} models..." if options[:verbose]
+          source_results = remove_source(source, options)
+          merge_remove_results(results, source_results)
         end
 
         results
       end
 
-      def self.disconnect_other_pools(current_pool, all_pools, options = {})
-        all_pools.each do |pool|
-          next if pool == current_pool || pool.nil?
+      # Remove annotations from a specific source
+      def self.remove_source(source, options = {})
+        results = { removed: [], skipped: [], failed: [] }
 
-          begin
-            if pool.connected?
-              pool.disconnect!
+        begin
+          models = source.models(options.merge(include_abstract: true))
+          puts "  Found #{models.size} #{source.source_name} models" if options[:verbose]
+
+          models.each do |model|
+            result = source.remove_annotation(model)
+            case result[:status]
+            when :removed
+              results[:removed] << result[:model]
+            when :skipped
+              results[:skipped] << result[:model]
+            when :failed
+              results[:failed] << { model: result[:model], error: result[:message] }
             end
-          rescue StandardError => e
-            warn "Failed to disconnect pool: #{e.message}"
           end
+        rescue StandardError => e
+          puts "  Error removing from #{source.source_name} source: #{e.message}" if options[:verbose]
         end
-      end
 
-      def self.get_all_connection_pools(models_by_pool)
-        models_by_pool.keys.compact
+        results
       end
 
-      def self.log_connection_status(all_pools, options = {})
-        return unless options[:verbose]
+      # Merge removal results into main results
+      def self.merge_remove_results(main, source)
+        main[:removed].concat(source[:removed] || [])
+        main[:skipped].concat(source[:skipped] || [])
+        main[:failed].concat(source[:failed] || [])
+      end
 
-        puts "\n=== Connection Pool Status ==="
-        all_pools.each do |pool|
-          next unless pool
+      # Original filesystem-based removal (kept for backwards compatibility)
+      def self.remove_all_by_filesystem(options = {})
+        base_path = options[:models_path] || default_models_path
+        results = { removed: [], skipped: [], failed: [] }
+        pattern = File.join(base_path, '**', '*.rb')
+        files = Dir.glob(pattern)
 
-          begin
-            name = pool.db_config&.name || 'unknown'
-            connected = pool.connected?
-            size = pool.size
-            checked_out = pool.stat[:busy]
+        files.each do |file_path|
+          content = File.read(file_path)
+          next unless Annotation.extract(content)
 
-            puts "Pool #{name}: connected=#{connected}, size=#{size}, busy=#{checked_out}"
-          rescue StandardError => e
-            puts "Pool status error: #{e.message}"
+          cleaned = Annotation.remove(content)
+          if cleaned == content
+            results[:skipped] << File.basename(file_path, '.rb').camelize
+          else
+            File.write(file_path, cleaned)
+            model_name = File.basename(file_path, '.rb').camelize
+            results[:removed] << model_name
           end
+        rescue StandardError => e
+          results[:failed] << { model: File.basename(file_path, '.rb').camelize, error: e.message }
         end
-        puts "================================\n"
+
+        results
+      end
+
+      def self.default_models_path
+        return Rails.root.join('app/models') if defined?(Rails.root)
+
+        File.join(Dir.pwd, 'app', 'models')
       end
 
       private

data/lib/rails_lens/schema/database_annotator.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Schema
+    # Annotates abstract base classes (ApplicationRecord, etc.) with database-level objects
+    # like functions, sequences, types, etc.
+    class DatabaseAnnotator
+      attr_reader :base_class
+
+      def initialize(base_class)
+        @base_class = base_class
+      end
+
+      def annotate_file(file_path = nil)
+        file_path ||= model_file_path
+        return unless file_path && File.exist?(file_path)
+
+        annotation_text = generate_annotation
+        return if annotation_text.empty?
+
+        # Remove existing annotations
+        content = File.read(file_path)
+        Annotation.remove(content) if Annotation.extract(content)
+
+        # Use Prism-based insertion
+        class_name = base_class.name.split('::').last
+        if FileInsertionHelper.insert_at_class_definition(file_path, class_name, annotation_text)
+          true
+        else
+          false
+        end
+      end
+
+      def remove_annotations(file_path = nil)
+        file_path ||= model_file_path
+        return unless file_path && File.exist?(file_path)
+
+        content = File.read(file_path)
+        cleaned_content = Annotation.remove(content)
+
+        if cleaned_content == content
+          false
+        else
+          File.write(file_path, cleaned_content)
+          true
+        end
+      end
+
+      def generate_annotation
+        annotation = Annotation.new
+
+        # Detect adapter
+        adapter_name = base_class.connection.adapter_name
+
+        # Always add database dialect for abstract classes
+        annotation.add_line("database_dialect = \"#{adapter_name}\"")
+
+        case adapter_name
+        when /PostgreSQL/i
+          add_postgresql_functions(annotation)
+        when /MySQL/i
+          add_mysql_functions(annotation)
+        when /SQLite/i
+          # SQLite doesn't have stored functions
+        end
+
+        annotation.to_s
+      end
+
+      # Class methods for batch operations
+      def self.annotate_all(options = {})
+        results = { annotated: [], skipped: [], failed: [] }
+
+        abstract_classes = detect_abstract_base_classes
+
+        abstract_classes.each do |klass|
+          annotator = new(klass)
+
+          begin
+            if annotator.annotate_file
+              results[:annotated] << klass.name
+            else
+              results[:skipped] << klass.name
+            end
+          rescue StandardError => e
+            results[:failed] << { model: klass.name, error: e.message }
+          end
+        end
+
+        results
+      end
+
+      def self.remove_all(options = {})
+        results = { removed: [], skipped: [], failed: [] }
+
+        begin
+          abstract_classes = detect_abstract_base_classes
+        rescue StandardError => e
+          RailsLens.logger.error { "Failed to detect abstract base classes: #{e.message}" }
+          return results
+        end
+
+        abstract_classes.each do |klass|
+          annotator = new(klass)
+          if annotator.remove_annotations
+            results[:removed] << klass.name
+          else
+            results[:skipped] << klass.name
+          end
+        rescue StandardError => e
+          results[:failed] << { model: klass.name, error: e.message }
+        end
+
+        results
+      end
+
+      def self.detect_abstract_base_classes
+        return [] unless defined?(Rails)
+
+        classes = []
+
+        # Load all models
+        Rails.application.eager_load!
+
+        # Find abstract base classes that inherit from ActiveRecord::Base
+        ActiveRecord::Base.descendants.each do |klass|
+          next unless klass.abstract_class?
+          next if klass == ActiveRecord::Base
+
+          classes << klass
+        end
+
+        classes
+      end
+
+      private_class_method :detect_abstract_base_classes
+
+      private
+
+      def add_postgresql_functions(annotation)
+        return unless RailsLens.config.schema[:format_options][:show_functions]
+
+        require_relative 'adapters/postgresql'
+        functions = Adapters::Postgresql.fetch_functions(base_class.connection)
+        add_functions_annotation(annotation, functions)
+      end
+
+      def add_mysql_functions(annotation)
+        return unless RailsLens.config.schema[:format_options][:show_functions]
+
+        require_relative 'adapters/mysql'
+        functions = Adapters::Mysql.fetch_functions(base_class.connection)
+        add_functions_annotation(annotation, functions)
+      end
+
+      def add_functions_annotation(annotation, functions)
+        return if functions.empty?
+
+        annotation.add_line('[database_functions]')
+        annotation.add_line('functions = [')
+
+        functions.each_with_index do |func, index|
+          line = '  { '
+          attrs = []
+          attrs << "name = \"#{escape_toml_string(func[:name])}\""
+          attrs << "schema = \"#{escape_toml_string(func[:schema])}\""
+          attrs << "language = \"#{escape_toml_string(func[:language])}\""
+          attrs << "return_type = \"#{escape_toml_string(func[:return_type])}\""
+          attrs << "description = \"#{escape_toml_string(func[:description])}\"" if func[:description]
+          line += attrs.join(', ')
+          line += ' }'
+          line += ',' if index < functions.length - 1
+          annotation.add_line(line)
+        end
+
+        annotation.add_line(']')
+      end
+
+      def escape_toml_string(str)
+        return '' unless str
+
+        str.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+      end
+
+      def model_file_path
+        return nil unless base_class.name
+
+        # Convert class name to file path (e.g., ApplicationRecord -> application_record.rb)
+        file_name = "#{base_class.name.underscore}.rb"
+
+        # Look in app/models
+        path = Rails.root.join('app', 'models', file_name) if defined?(Rails.root)
+        path if path && File.exist?(path)
+      end
+    end
+  end
+end

data/lib/rails_lens/tasks/annotate.rake

@@ -21,9 +21,38 @@ namespace :rails_lens do
     end
   end
 
+  desc 'Remove all annotations from models'
+  task remove: :environment do
+    require 'rails_lens/schema/annotation_manager'
+
+    results = RailsLens::Schema::AnnotationManager.remove_all
+
+    puts "Removed annotations from #{results[:removed].length} models" if results[:removed].any?
+    puts "Skipped #{results[:skipped].length} models (no annotations)" if results[:skipped].any?
+    if results[:failed].any?
+      puts "Failed to remove annotations from #{results[:failed].length} models:"
+      results[:failed].each do |failure|
+        puts "  - #{failure[:model]}: #{failure[:error]}"
+      end
+    end
+  end
+
+  desc 'List registered model sources'
+  task sources: :environment do
+    require 'rails_lens'
+
+    puts 'Registered model sources:'
+    RailsLens::ModelSourceLoader.list_sources.each do |source|
+      puts "  - #{source[:name]} (#{source[:class]})"
+      source[:patterns].each do |pattern|
+        puts "      #{pattern}"
+      end
+    end
+  end
+
   desc 'Annotate all Rails files (models, routes, and mailers)'
   task all: :environment do
-    # Annotate models
+    # Annotate models (includes all registered model sources)
     Rake::Task['rails_lens:annotate'].invoke
 
     # Annotate routes
@@ -32,4 +61,16 @@ namespace :rails_lens do
     # Annotate mailers
     Rake::Task['rails_lens:mailers:annotate'].invoke
   end
+
+  desc 'Remove all annotations from Rails files (models, routes, and mailers)'
+  task remove_all: :environment do
+    # Remove model annotations (includes all registered model sources)
+    Rake::Task['rails_lens:remove'].invoke
+
+    # Remove route annotations
+    Rake::Task['rails_lens:routes:remove'].invoke
+
+    # Remove mailer annotations
+    Rake::Task['rails_lens:mailers:remove'].invoke
+  end
 end

data/lib/rails_lens/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsLens
-  VERSION = '0.2.12'
+  VERSION = '0.5.0'
 end

data/lib/rails_lens.rb

@@ -60,7 +60,7 @@ module RailsLens
 
         current_value = config.send(section)
         if current_value.is_a?(Hash)
-          config.send("#{section}=", current_value.merge(settings.symbolize_keys))
+          config.send("#{section}=", current_value.deep_merge(settings.symbolize_keys))
         else
           config.send("#{section}=", settings.symbolize_keys)
         end