rails_lens 0.2.0 → 0.2.3

data/lib/rails_lens/providers/base.rb

@@ -21,7 +21,7 @@ module RailsLens
       # For :schema type - returns a string with the schema content
       # For :section type - returns a hash with { title: String, content: String } or nil
       # For :notes type - returns an array of note strings
-      def process(model_class)
+      def process(model_class, connection = nil)
         raise NotImplementedError, "#{self.class} must implement #process"
       end
 

data/lib/rails_lens/providers/extension_notes_provider.rb

@@ -8,10 +8,11 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        RailsLens.config.extensions[:enabled] && model_has_table?(model_class)
+        # Only applicable to tables, not views
+        RailsLens.config.extensions[:enabled] && model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         results = ExtensionLoader.apply_extensions(model_class)
         results[:notes]
       end

data/lib/rails_lens/providers/extensions_provider.rb

@@ -7,7 +7,7 @@ module RailsLens
         :section
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         results = ExtensionLoader.apply_extensions(model_class)
 
         return nil if results[:annotations].empty?

data/lib/rails_lens/providers/index_notes_provider.rb

@@ -8,10 +8,11 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        model_has_table?(model_class)
+        # Only applicable to tables, not views
+        model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = Analyzers::IndexAnalyzer.new(model_class)
         analyzer.analyze
       end

data/lib/rails_lens/providers/inheritance_provider.rb

@@ -7,7 +7,7 @@ module RailsLens
         :section
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = Analyzers::Inheritance.new(model_class)
         content = analyzer.analyze
 

data/lib/rails_lens/providers/notes_provider_base.rb

@@ -9,14 +9,15 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        model_has_table?(model_class)
+        # Only applicable to tables, not views
+        model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
       def analyzer_class
         raise NotImplementedError, "#{self.class} must implement #analyzer_class"
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = analyzer_class.new(model_class)
         analyzer.analyze
       end

data/lib/rails_lens/providers/schema_provider.rb

@@ -11,25 +11,40 @@ module RailsLens
         true # Always applicable - handles both abstract and regular models
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
+        # Use passed connection or fall back to model's connection
+        conn = connection || model_class.connection
+
         if model_class.abstract_class?
           # For abstract classes, show database connection information in TOML format
-          connection = model_class.connection
-          adapter_name = connection.adapter_name
+          adapter_name = conn.adapter_name
 
           lines = []
+
+          # Get connection name
+          begin
+            connection_name = conn.pool.db_config.name
+            lines << "connection = \"#{connection_name}\""
+          rescue StandardError
+            lines << 'connection = "unknown"'
+          end
+
           lines << "database_dialect = \"#{adapter_name}\""
 
-          # Add basic database information
+          # Add database version information
+          begin
+            db_version = conn.database_version
+            lines << "database_version = \"#{db_version}\""
+          rescue StandardError
+            lines << 'database_version = "unknown"'
+          end
+
+          # Add database name if available
           begin
-            db_name = begin
-              connection.database_version
-            rescue StandardError
-              'unknown'
-            end
-            lines << "database_version = \"#{db_name}\""
+            db_name = conn.current_database
+            lines << "database_name = \"#{db_name}\"" if db_name
           rescue StandardError
-            # Skip if can't get version
+            # Skip if can't get database name
           end
 
           lines << ''
@@ -38,8 +53,8 @@ module RailsLens
 
           lines.join("\n")
         else
-          # Add schema information for regular models
-          adapter = Connection.adapter_for(model_class)
+          # Add schema information for regular models (tables or views)
+          adapter = Connection.adapter_for(model_class, conn)
           adapter.generate_annotation(model_class)
         end
       end

data/lib/rails_lens/providers/section_provider_base.rb

@@ -12,7 +12,7 @@ module RailsLens
         raise NotImplementedError, "#{self.class} must implement #analyzer_class"
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = analyzer_class.new(model_class)
         content = analyzer.analyze
 

data/lib/rails_lens/providers/view_notes_provider.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    # View-specific notes provider that wraps the Notes analyzer for views only
+    class ViewNotesProvider < Base
+      def type
+        :notes
+      end
+
+      def applicable?(model_class)
+        # Only applicable to views
+        model_has_table?(model_class) && ModelDetector.view_exists?(model_class)
+      end
+
+      def process(model_class, connection = nil)
+        analyzer = Analyzers::Notes.new(model_class)
+        analyzer.analyze
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/view_provider.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    class ViewProvider < SectionProviderBase
+      def applicable?(model_class)
+        # Only applicable for models backed by views
+        ModelDetector.view_exists?(model_class)
+      end
+
+      def process(model_class, connection = nil)
+        view_metadata = ViewMetadata.new(model_class)
+
+        return nil unless view_metadata.view_exists?
+
+        {
+          title: '== View Information',
+          content: generate_view_content(view_metadata)
+        }
+      end
+
+      private
+
+      def generate_view_content(view_metadata)
+        lines = []
+
+        # View type (regular or materialized)
+        if view_metadata.view_type
+          lines << "View Type: #{view_metadata.view_type}"
+        end
+
+        # Updatable status
+        lines << "Updatable: #{view_metadata.updatable? ? 'Yes' : 'No'}"
+
+        # Dependencies
+        dependencies = view_metadata.dependencies
+        if dependencies.any?
+          lines << "Dependencies: #{dependencies.join(', ')}"
+        end
+
+        # Refresh strategy for materialized views
+        if view_metadata.materialized_view? && 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}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

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

@@ -8,7 +8,15 @@ module RailsLens
           'MySQL'
         end
 
-        def generate_annotation(_model_class)
+        def generate_annotation(model_class)
+          if model_class && ModelDetector.view_exists?(model_class)
+            generate_view_annotation(model_class)
+          else
+            generate_table_annotation(model_class)
+          end
+        end
+
+        def generate_table_annotation(_model_class)
           lines = []
           lines << "table = \"#{table_name}\""
           lines << "database_dialect = \"#{database_dialect}\""
@@ -37,6 +45,27 @@ module RailsLens
           lines.join("\n")
         end
 
+        def generate_view_annotation(model_class)
+          lines = []
+          lines << "view = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Fetch all view metadata in a single query
+          view_info = fetch_view_metadata
+
+          if view_info
+            lines << "view_type = \"#{view_info[:type]}\"" if view_info[:type]
+            lines << "updatable = #{view_info[:updatable]}"
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_view_dependencies_toml(lines, view_info)
+
+          lines.join("\n")
+        end
+
         protected
 
         def format_column(column)
@@ -117,7 +146,7 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid => e
           Rails.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
           nil
-        rescue Mysql2::Error => e
+        rescue => e
           Rails.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
           nil
         end
@@ -137,7 +166,7 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid => e
           Rails.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
           nil
-        rescue Mysql2::Error => e
+        rescue => e
           Rails.logger.debug { "MySQL error fetching charset: #{e.message}" }
           nil
         end
@@ -155,7 +184,7 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid => e
           Rails.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
           nil
-        rescue Mysql2::Error => e
+        rescue => e
           Rails.logger.debug { "MySQL error fetching collation: #{e.message}" }
           nil
         end
@@ -202,7 +231,7 @@ module RailsLens
           # Table doesn't exist or no permission to query information_schema
           Rails.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
           false
-        rescue Mysql2::Error => e
+        rescue => e
           # MySQL specific errors (connection issues, etc)
           Rails.logger.debug { "MySQL error checking partitions: #{e.message}" }
           false
@@ -231,7 +260,7 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
           Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
-        rescue Mysql2::Error => e
+        rescue => e
           # MySQL specific errors
           Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
@@ -269,10 +298,93 @@ module RailsLens
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
           Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
-        rescue Mysql2::Error => e
+        rescue => e
           # MySQL specific errors
           Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
+
+        def add_view_dependencies_toml(lines, view_info)
+          return unless view_info && view_info[:dependencies]
+
+          dependencies = view_info[:dependencies]
+          return if dependencies.empty?
+
+          lines << ''
+          lines << "view_dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
+        end
+
+        # MySQL-specific view methods
+        public
+
+        # Fetch all view metadata in a single consolidated query
+        def fetch_view_metadata
+          result = connection.exec_query(<<~SQL.squish, 'MySQL View Metadata')
+            SELECT#{' '}
+              v.is_updatable,
+              COALESCE(
+                (
+                  SELECT GROUP_CONCAT(DISTINCT vtu.table_name ORDER BY vtu.table_name)
+                  FROM information_schema.view_table_usage vtu
+                  WHERE vtu.view_schema = DATABASE()
+                  AND vtu.view_name = '#{connection.quote_string(table_name)}'
+                ),
+                ''
+              ) as dependencies
+            FROM information_schema.views v
+            WHERE v.table_schema = DATABASE()
+            AND v.table_name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          return nil if result.rows.empty?
+
+          row = result.rows.first
+          {
+            type: 'regular', # MySQL only supports regular views
+            updatable: row[0] == 'YES',
+            dependencies: row[1].to_s.split(',').reject(&:empty?)
+          }
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          nil
+        end
+
+        # Legacy methods - kept for backward compatibility but now use consolidated query
+        def view_type
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:type)
+        end
+
+        def view_updatable?
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:updatable) || false
+        end
+
+        def view_dependencies
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:dependencies) || []
+        end
+
+        def view_definition
+          result = connection.exec_query(<<~SQL.squish, 'MySQL View Definition')
+            SELECT view_definition FROM information_schema.views
+            WHERE table_schema = DATABASE()
+            AND table_name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          result.rows.first&.first&.strip
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error
+          nil
+        end
+
+        def view_refresh_strategy
+          nil # MySQL doesn't have materialized views
+        end
+
+        def view_last_refreshed
+          nil # MySQL doesn't have materialized views
+        end
       end
     end
   end

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

@@ -8,7 +8,15 @@ module RailsLens
           'PostgreSQL'
         end
 
-        def generate_annotation(_model_class)
+        def generate_annotation(model_class)
+          if model_class && ModelDetector.view_exists?(model_class)
+            generate_view_annotation(model_class)
+          else
+            generate_table_annotation(model_class)
+          end
+        end
+
+        def generate_table_annotation(_model_class)
           lines = []
           lines << "table = \"#{table_name}\""
           lines << "database_dialect = \"#{database_dialect}\""
@@ -26,6 +34,35 @@ module RailsLens
           lines.join("\n")
         end
 
+        def generate_view_annotation(model_class)
+          lines = []
+          lines << "view = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Add schema information for PostgreSQL
+          lines << "schema = \"#{schema_name}\"" if schema_name && schema_name != 'public'
+
+          # Fetch all view metadata in a single query
+          view_info = fetch_view_metadata
+
+          if view_info
+            lines << "view_type = \"#{view_info[:type]}\"" if view_info[:type]
+            lines << "updatable = #{view_info[:updatable]}"
+
+            if view_info[:type] == 'materialized'
+              lines << 'materialized = true'
+              lines << 'refresh_strategy = "manual"'
+            end
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_view_dependencies_toml(lines, view_info)
+
+          lines.join("\n")
+        end
+
         protected
 
         def schema_name
@@ -191,6 +228,131 @@ module RailsLens
           lines << ''
           lines << "table_comment = \"#{comment.gsub('"', '\"')}\""
         end
+
+        def add_view_dependencies_toml(lines, view_info)
+          return unless view_info && view_info[:dependencies]
+
+          dependencies = view_info[:dependencies]
+          return if dependencies.empty?
+
+          lines << ''
+          lines << "view_dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
+        end
+
+        # PostgreSQL-specific view methods
+        public
+
+        # Fetch all view metadata in a single consolidated query
+        def fetch_view_metadata
+          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(table_name)}'
+            #{'  '}
+              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(table_name)}'
+            ),
+            dependencies AS (
+              SELECT DISTINCT c2.relname as dependency_name
+              FROM pg_class c1
+              JOIN pg_depend d ON c1.oid = d.objid
+              JOIN pg_class c2 ON d.refobjid = c2.oid
+              WHERE c1.relname = '#{connection.quote_string(table_name)}'
+              AND c1.relkind IN ('v', 'm')
+              AND c2.relkind IN ('r', 'v', 'm')
+              AND d.deptype = 'n'
+            )
+            SELECT#{' '}
+              vi.view_type,
+              vi.is_updatable,
+              COALESCE(
+                (SELECT array_agg(dependency_name ORDER BY dependency_name) FROM dependencies),
+                ARRAY[]::text[]
+              ) as dependencies
+            FROM view_info vi
+            LIMIT 1
+          SQL
+
+          return nil if result.rows.empty?
+
+          row = result.rows.first
+          {
+            type: row[0],
+            updatable: ['t', true].include?(row[1]),
+            dependencies: row[2] || []
+          }
+        rescue ActiveRecord::StatementInvalid, PG::Error => e
+          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          nil
+        end
+
+        # Legacy methods - kept for backward compatibility but now use consolidated query
+        def view_type
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:type)
+        end
+
+        def view_updatable?
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:updatable) || false
+        end
+
+        def view_dependencies
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:dependencies) || []
+        end
+
+        def view_definition
+          result = if view_type == 'materialized'
+                     connection.exec_query(<<~SQL.squish, 'PostgreSQL Materialized View Definition')
+                       SELECT definition FROM pg_matviews
+                       WHERE matviewname = '#{connection.quote_string(table_name)}'
+                       LIMIT 1
+                     SQL
+                   else
+                     connection.exec_query(<<~SQL.squish, 'PostgreSQL View Definition')
+                       SELECT view_definition FROM information_schema.views
+                       WHERE table_name = '#{connection.quote_string(table_name)}'
+                       LIMIT 1
+                     SQL
+                   end
+
+          result.rows.first&.first&.strip
+        rescue ActiveRecord::StatementInvalid, PG::Error
+          nil
+        end
+
+        def view_refresh_strategy
+          view_type == 'materialized' ? 'manual' : nil
+        end
+
+        def view_last_refreshed
+          return nil unless view_type == 'materialized'
+
+          # Get the last refresh time from pg_stat_user_tables
+          result = connection.exec_query(<<~SQL.squish, 'PostgreSQL Materialized View Last Refresh')
+            SELECT COALESCE(last_vacuum, last_autovacuum) as last_refreshed
+            FROM pg_stat_user_tables
+            WHERE relname = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          result.rows.first&.first
+        rescue ActiveRecord::StatementInvalid, PG::Error
+          nil
+        end
       end
     end
   end