rails_lens 0.2.11 → 0.3.0

data/lib/rails_lens/note_codes.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Compact note codes for LLM-readable annotations
+  # Format: "column_name:CODE" or "association:CODE"
+  module NoteCodes
+    # Column constraint codes
+    NOT_NULL = 'NOT_NULL'
+    DEFAULT = 'DEFAULT'
+    LIMIT = 'LIMIT'
+
+    # Index codes
+    INDEX = 'INDEX'
+    POLY_INDEX = 'POLY_INDEX'
+    COMP_INDEX = 'COMP_INDEX'
+    REDUND_IDX = 'REDUND_IDX'
+
+    # Type codes
+    USE_DECIMAL = 'USE_DECIMAL'
+    USE_INTEGER = 'USE_INTEGER'
+
+    # Association codes
+    INVERSE_OF = 'INVERSE_OF'
+    N_PLUS_ONE = 'N_PLUS_ONE'
+    COUNTER_CACHE = 'COUNTER_CACHE'
+    FK_CONSTRAINT = 'FK_CONSTRAINT'
+
+    # Best practices codes
+    NO_TIMESTAMPS = 'NO_TIMESTAMPS'
+    PARTIAL_TS = 'PARTIAL_TS'
+    STORAGE = 'STORAGE'
+
+    # STI codes
+    STI_INDEX = 'STI_INDEX'
+    STI_NOT_NULL = 'STI_NOT_NULL'
+
+    # View codes
+    VIEW_READONLY = 'VIEW_READONLY'
+    ADD_READONLY = 'ADD_READONLY'
+    MATVIEW_STALE = 'MATVIEW_STALE'
+    ADD_REFRESH = 'ADD_REFRESH'
+    NESTED_VIEW = 'NESTED_VIEW'
+    VIEW_PROTECT = 'VIEW_PROTECT'
+
+    # Structure codes
+    MISSING = 'MISSING'
+    DEPTH_CACHE = 'DEPTH_CACHE'
+
+    class << self
+      # Build a compact note string
+      # @param subject [String, nil] column/association name (nil for model-level)
+      # @param code [String] note code constant
+      # @return [String] formatted note
+      def note(subject, code)
+        subject ? "#{subject}:#{code}" : code
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/callbacks_provider.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    class CallbacksProvider < SectionProviderBase
+      def analyzer_class
+        Analyzers::Callbacks
+      end
+
+      def applicable?(model_class)
+        # Only applicable to non-abstract models with callbacks
+        return false if model_class.abstract_class?
+
+        # Check if model has any callbacks defined (Rails 8+ uses unified chains)
+        RailsLens::Analyzers::Callbacks::CALLBACK_CHAINS.any? do |chain_name|
+          chain_method = "_#{chain_name}_callbacks"
+          model_class.respond_to?(chain_method) && model_class.public_send(chain_method).present?
+        end
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/extensions_provider.rb

@@ -13,7 +13,7 @@ module RailsLens
         return nil if results[:annotations].empty?
 
         {
-          title: '== Extensions',
+          title: '[extensions]',
           content: results[:annotations].join("\n")
         }
       end

data/lib/rails_lens/providers/view_provider.rb

@@ -14,7 +14,7 @@ module RailsLens
         return nil unless view_metadata.view_exists?
 
         {
-          title: '== View Information',
+          title: '[view]',
           content: generate_view_content(view_metadata)
         }
       end
@@ -25,39 +25,25 @@ module RailsLens
         lines = []
 
         # View type (regular or materialized)
-        if view_metadata.view_type
-          lines << "View Type: #{view_metadata.view_type}"
-        end
+        lines << "type = \"#{view_metadata.view_type}\"" if view_metadata.view_type
 
         # Updatable status
-        lines << "Updatable: #{view_metadata.updatable? ? 'Yes' : 'No'}"
+        lines << "updatable = #{view_metadata.updatable?}"
 
         # Dependencies
         dependencies = view_metadata.dependencies
         if dependencies.any?
-          lines << "Dependencies: #{dependencies.join(', ')}"
+          lines << "dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
         end
 
         # Refresh strategy for materialized views
         if view_metadata.materialized_view? && view_metadata.refresh_strategy
-          lines << "Refresh Strategy: #{view_metadata.refresh_strategy}"
+          lines << "refresh_strategy = \"#{view_metadata.refresh_strategy}\""
         end
 
         # Last refreshed timestamp for materialized views
         if view_metadata.materialized_view? && view_metadata.last_refreshed
-          lines << "Last Refreshed: #{view_metadata.last_refreshed}"
-        end
-
-        # View definition (truncated for readability)
-        if view_metadata.view_definition
-          definition = view_metadata.view_definition
-          # Truncate long definitions
-          if definition.length > 200
-            definition = "#{definition[0..200]}..."
-          end
-          # Remove extra whitespace and newlines
-          definition = definition.gsub(/\s+/, ' ').strip
-          lines << "Definition: #{definition}"
+          lines << "last_refreshed = \"#{view_metadata.last_refreshed}\""
         end
 
         lines.join("\n")

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

@@ -175,6 +175,42 @@ module RailsLens
             connection.supports_comments?
         end
 
+        def show_triggers?
+          RailsLens.config.schema[:format_options][:show_triggers]
+        end
+
+        def fetch_triggers
+          # Override in database-specific adapters
+          []
+        end
+
+        def add_triggers_toml(lines)
+          triggers = fetch_triggers
+          return if triggers.empty?
+
+          lines << ''
+          lines << 'triggers = ['
+          triggers.each_with_index do |trigger, i|
+            line = '  { '
+            attrs = []
+            attrs << "name = \"#{trigger[:name]}\""
+            attrs << "event = \"#{trigger[:event]}\""
+            attrs << "timing = \"#{trigger[:timing]}\""
+            attrs << "function = \"#{trigger[:function]}\""
+            attrs << "for_each = \"#{trigger[:for_each]}\"" if trigger[:for_each]
+            attrs << "condition = \"#{escape_toml_string(trigger[:condition])}\"" if trigger[:condition]
+            line += attrs.join(', ')
+            line += ' }'
+            line += ',' if i < triggers.length - 1
+            lines << line
+          end
+          lines << ']'
+        end
+
+        def escape_toml_string(str)
+          str.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+        end
+
         # Structured formatting methods
         def add_columns_structured(lines)
           lines << 'COLUMNS:'
@@ -252,8 +288,9 @@ module RailsLens
             attrs = []
             attrs << "name = \"#{column.name}\""
             attrs << "type = \"#{column.type}\""
-            attrs << 'primary_key = true' if primary_key?(column)
-            attrs << "nullable = #{column.null}"
+            attrs << 'pk = true' if primary_key?(column)
+            # Only add null = false when NOT nullable (omit when nullable for brevity)
+            attrs << 'null = false' unless column.null
             attrs << "default = #{format_toml_value(column.default)}" if column.default && show_defaults?
             line += attrs.join(', ')
             line += ' }'

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

@@ -13,30 +13,24 @@ module RailsLens
 
         def generate_annotation
           lines = []
-          lines << '== Database Information'
-          lines << "Adapter: #{adapter_name}"
-          lines << "Database: #{database_name}"
-          lines << "Version: #{database_version}"
-          lines << "Encoding: #{database_encoding}" if respond_to?(:database_encoding)
-          lines << "Collation: #{database_collation}" if respond_to?(:database_collation)
-          lines << ''
+          lines << '[database_info]'
+          lines << "adapter = \"#{adapter_name}\""
+          lines << "database = \"#{database_name}\""
+          lines << "version = \"#{database_version}\""
+          enc = database_encoding
+          lines << "encoding = \"#{enc}\"" if enc
+          coll = database_collation
+          lines << "collation = \"#{coll}\"" if coll
 
           # Add extensions for PostgreSQL
           if adapter_name == 'PostgreSQL' && extensions.any?
-            lines << 'Enabled Extensions:'
-            extensions.each do |ext|
-              lines << "  - #{ext['name']} (#{ext['version']})"
-            end
-            lines << ''
+            ext_list = extensions.map { |e| "{ name = \"#{e['name']}\", version = \"#{e['version']}\" }" }
+            lines << "extensions = [#{ext_list.join(', ')}]"
           end
 
           # Add schemas for PostgreSQL
           if adapter_name == 'PostgreSQL' && schemas.any?
-            lines << 'Database Schemas:'
-            schemas.each do |schema|
-              lines << "  - #{schema}"
-            end
-            lines << ''
+            lines << "schemas = [#{schemas.map { |s| "\"#{s}\"" }.join(', ')}]"
           end
 
           lines.join("\n")

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

@@ -40,6 +40,7 @@ module RailsLens
           add_columns_toml(lines)
           add_indexes_toml(lines) if show_indexes?
           add_foreign_keys_toml(lines) if show_foreign_keys?
+          add_triggers_toml(lines) if show_triggers?
           add_partitions_toml(lines) if has_partitions?
 
           lines.join("\n")
@@ -385,6 +386,80 @@ module RailsLens
         def view_last_refreshed
           nil # MySQL doesn't have materialized views
         end
+
+        # Fetch triggers for the table
+        def fetch_triggers
+          quoted_table = connection.quote(unqualified_table_name)
+          result = connection.exec_query(<<~SQL.squish, 'MySQL Table Triggers')
+            SELECT
+              TRIGGER_NAME AS name,
+              ACTION_TIMING AS timing,
+              EVENT_MANIPULATION AS event,
+              'ROW' AS for_each,
+              ACTION_STATEMENT AS action_statement
+            FROM information_schema.TRIGGERS
+            WHERE TRIGGER_SCHEMA = DATABASE()
+              AND EVENT_OBJECT_TABLE = #{quoted_table}
+            ORDER BY TRIGGER_NAME
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              timing: row[1],
+              event: row[2],
+              for_each: row[3],
+              function: extract_function_call(row[4]),
+              definition: row[4]
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          RailsLens.logger.debug { "Failed to fetch triggers for #{table_name}: #{e.message}" }
+          []
+        end
+
+        # Extract function/procedure call from trigger action statement
+        def extract_function_call(action_statement)
+          return nil unless action_statement
+
+          # Match CALL with optional schema prefix and backticks: CALL `schema`.`proc` or CALL schema.proc or CALL proc
+          match = action_statement.match(/CALL\s+(?:`?(\w+)`?\.)?`?(\w+)`?/i)
+          if match
+            schema_part = match[1]
+            proc_name = match[2]
+            schema_part ? "#{schema_part}.#{proc_name}" : proc_name
+          else
+            'inline'
+          end
+        end
+
+        # Fetch all user-defined functions
+        def self.fetch_functions(connection)
+          result = connection.exec_query(<<~SQL.squish, 'MySQL Functions')
+            SELECT
+              ROUTINE_NAME AS name,
+              ROUTINE_SCHEMA AS `schema`,
+              DATA_TYPE AS return_type,
+              ROUTINE_COMMENT AS description
+            FROM information_schema.ROUTINES
+            WHERE ROUTINE_SCHEMA = DATABASE()
+              AND ROUTINE_TYPE = 'FUNCTION'
+            ORDER BY ROUTINE_NAME
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              schema: row[1],
+              language: 'SQL',
+              return_type: row[2],
+              description: row[3]
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          RailsLens.logger.debug { "Failed to fetch functions: #{e.message}" }
+          []
+        end
       end
     end
   end

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
@@ -16,8 +14,19 @@ module RailsLens
         return unless file_path && File.exist?(file_path)
 
         # Only annotate files within the Rails application (unless explicitly allowed)
-        if !allow_external_files && defined?(Rails.root) && !file_path.start_with?(Rails.root.to_s)
-          return
+        # For engines/gems with dummy apps, check if the file is within the parent directory
+        if !allow_external_files && defined?(Rails.root)
+          rails_root = Rails.root.to_s
+          # Check if this is a dummy app inside a gem/engine
+          parent_root = if rails_root.include?('/test/dummy')
+                          File.expand_path('../..', rails_root)
+                        else
+                          rails_root
+                        end
+
+          unless file_path.start_with?(rails_root) || file_path.start_with?(parent_root)
+            return
+          end
         end
 
         annotation_text = generate_annotation
@@ -129,13 +138,10 @@ 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
@@ -183,16 +189,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|
@@ -267,60 +265,39 @@ module RailsLens
       end
 
       def self.remove_all(options = {})
-        models = ModelDetector.detect_models(options)
+        # Use filesystem-based removal (doesn't require database)
+        remove_all_by_filesystem(options)
+      end
+
+      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)
+
+        files.each do |file_path|
+          content = File.read(file_path)
+          next unless Annotation.extract(content)
 
-        models.each do |model|
-          manager = new(model)
-          if manager.remove_annotations
-            results[:removed] << model.name
+          cleaned = Annotation.remove(content)
+          if cleaned == content
+            results[:skipped] << File.basename(file_path, '.rb').camelize
           else
-            results[:skipped] << model.name
+            File.write(file_path, cleaned)
+            model_name = File.basename(file_path, '.rb').camelize
+            results[:removed] << model_name
           end
         rescue StandardError => e
-          results[:failed] << { model: model.name, error: e.message }
+          results[:failed] << { model: File.basename(file_path, '.rb').camelize, error: e.message }
         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?
+      def self.default_models_path
+        return Rails.root.join('app/models') if defined?(Rails.root)
 
-          begin
-            if pool.connected?
-              pool.disconnect!
-            end
-          rescue StandardError => e
-            warn "Failed to disconnect pool: #{e.message}"
-          end
-        end
-      end
-
-      def self.get_all_connection_pools(models_by_pool)
-        models_by_pool.keys.compact
-      end
-
-      def self.log_connection_status(all_pools, options = {})
-        return unless options[:verbose]
-
-        puts "\n=== Connection Pool Status ==="
-        all_pools.each do |pool|
-          next unless pool
-
-          begin
-            name = pool.db_config&.name || 'unknown'
-            connected = pool.connected?
-            size = pool.size
-            checked_out = pool.stat[:busy]
-
-            puts "Pool #{name}: connected=#{connected}, size=#{size}, busy=#{checked_out}"
-          rescue StandardError => e
-            puts "Pool status error: #{e.message}"
-          end
-        end
-        puts "================================\n"
+        File.join(Dir.pwd, 'app', 'models')
       end
 
       private