rails_visualizer 0.1.0

data/lib/rails_visualizer/mailers_inspector.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class MailersInspector
+    include RailsVisualizer::PathHelper
+
+    FRAMEWORK_NAMESPACES = %w[
+      ActionMailer::
+      Devise::
+    ].freeze
+
+    def initialize(excluded: [])
+      @excluded_set = excluded.to_set
+    end
+
+    def call
+      return [] unless defined?(ActionMailer::Base)
+
+      mailers = ActionMailer::Base
+                .descendants
+                .reject { |m| m.name.nil? || framework_class?(m.name) || @excluded_set.include?(m.name) }
+
+      superclass_names = mailers.to_set { |m| m.superclass.name }
+
+      mailers
+        .map { |m| serialize_mailer(m, superclass_names) }
+        .sort_by { |m| m[:name] }
+    rescue StandardError
+      []
+    end
+
+    private
+
+    def serialize_mailer(mailer, superclass_names)
+      own = own_action_methods(mailer)
+      {
+        name: mailer.name,
+        superclass: mailer.superclass.name,
+        abstract: own.empty? && superclass_names.include?(mailer.name),
+        file_path: source_path_for(mailer),
+        actions: own,
+        inherited_actions: inherited_action_methods(mailer, own),
+        default_from: extract_default_param(mailer, :from),
+        default_reply_to: extract_default_param(mailer, :reply_to),
+        layout: extract_layout(mailer),
+        callbacks: extract_callbacks(mailer)
+      }
+    end
+
+    def own_action_methods(mailer)
+      action_methods = mailer.action_methods.to_set
+      mailer.public_instance_methods(false)
+            .map(&:to_s)
+            .select { |m| action_methods.include?(m) }
+            .sort
+    rescue StandardError
+      []
+    end
+
+    # Returns inherited email methods grouped by the ancestor class that defines them.
+    # Walks up to (but not including) ActionMailer::Base; stops at framework boundaries.
+    def inherited_action_methods(mailer, own_methods)
+      action_set   = mailer.action_methods.to_set
+      already_seen = own_methods.to_set
+      result       = []
+
+      user_ancestors(mailer).each { |a| accumulate_ancestor_group(a, action_set, already_seen, result) }
+
+      result
+    rescue StandardError
+      []
+    end
+
+    def accumulate_ancestor_group(ancestor, action_set, already_seen, result)
+      ancestor_methods = ancestor.public_instance_methods(false).map(&:to_s)
+      relevant = ancestor_methods.select { |m| action_set.include?(m) && already_seen.exclude?(m) }
+      return if relevant.empty?
+
+      result << { defined_in: ancestor.name || ancestor.to_s, methods: relevant.sort }
+      already_seen.merge(relevant)
+    end
+
+    # Ancestors between the mailer itself and ActionMailer::Base, excluding framework modules.
+    def user_ancestors(mailer)
+      mailer.ancestors
+            .drop_while { |a| a == mailer }
+            .take_while { |a| a != ActionMailer::Base && !framework_ancestor?(a) }
+    end
+
+    def extract_default_param(mailer, key)
+      params = mailer.default_params
+      params[key] || params[key.to_s]
+    rescue StandardError
+      nil
+    end
+
+    def extract_layout(mailer)
+      layout = mailer._layout
+      layout.is_a?(String) ? layout.presence : nil
+    rescue StandardError
+      nil
+    end
+
+    def extract_callbacks(mailer)
+      chain  = mailer.send(:_process_action_callbacks).to_a
+      result = { before: [], after: [], around: [] }
+      chain.select { |cb| cb.filter.is_a?(Symbol) }.each do |cb|
+        result[cb.kind] << cb.filter.to_s
+      end
+      result
+    rescue StandardError
+      { before: [], after: [], around: [] }
+    end
+
+    def framework_ancestor?(ancestor)
+      return true unless ancestor.respond_to?(:name)
+
+      name = ancestor.name
+      name.nil? || FRAMEWORK_NAMESPACES.any? { |ns| name.start_with?(ns) }
+    end
+
+    def framework_class?(name)
+      FRAMEWORK_NAMESPACES.any? { |ns| name.start_with?(ns) }
+    end
+  end
+end

data/lib/rails_visualizer/migrations_inspector.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class MigrationsInspector
+    include RailsVisualizer::PathHelper
+
+    def call
+      run_versions = fetch_run_versions
+      migrations   = build_migrations(run_versions)
+      summarize(migrations, run_versions)
+    rescue StandardError
+      { migrations: [], current_version: nil, total_count: 0, pending_count: 0, applied_count: 0 }
+    end
+
+    private
+
+    def build_migrations(run_versions)
+      migration_files.map { |file| build_entry(file, run_versions) }
+    end
+
+    def build_entry(file, run_versions)
+      version  = File.basename(file)[/^\d+/]
+      raw_name = File.basename(file, '.rb').sub(/^\d+_/, '')
+      {
+        version: version,
+        name: raw_name,
+        human_name: humanize(raw_name),
+        status: run_versions.include?(version) ? 'up' : 'down',
+        file_path: relative_to_root(file.to_s),
+        ran_at: nil
+      }
+    end
+
+    def summarize(migrations, run_versions)
+      {
+        migrations: migrations,
+        current_version: run_versions.max,
+        total_count: migrations.size,
+        pending_count: migrations.count { |m| m[:status] == 'down' },
+        applied_count: migrations.count { |m| m[:status] == 'up' }
+      }
+    end
+
+    # Direct SQL is the most reliable way to read schema_migrations across
+    # all Rails versions (7.0, 7.1, 8.x) without hitting API breakages in
+    # the ActiveRecord::SchemaMigration class hierarchy.
+    def fetch_run_versions
+      conn = ActiveRecord::Base.connection
+      return Set.new unless conn.table_exists?('schema_migrations')
+
+      Set.new(conn.select_values('SELECT version FROM schema_migrations').map(&:to_s))
+    rescue StandardError
+      Set.new
+    end
+
+    def migration_files
+      return [] unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+      Rails.root.glob('db/migrate/*.rb').sort
+    rescue StandardError
+      []
+    end
+
+    def humanize(name)
+      name.tr('_', ' ').split.map(&:capitalize).join(' ')
+    end
+  end
+end

data/lib/rails_visualizer/path_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  # Shared helper for resolving the actual source file of a Ruby constant.
+  # Uses Module.const_source_location (Ruby 2.7+) and returns a path
+  # relative to Rails.root so it is portable across machines.
+  module PathHelper
+    private
+
+    def source_path_for(klass)
+      absolute = Module.const_source_location(klass.name)&.first
+      return nil if absolute.blank?
+
+      relative_to_root(absolute)
+    rescue StandardError
+      nil
+    end
+
+    def relative_to_root(absolute)
+      prefix = "#{app_root}/"
+      absolute.start_with?(prefix) ? absolute.delete_prefix(prefix) : absolute
+    end
+
+    # Memoised per-instance so Rails.root is evaluated once, not on every call.
+    def app_root
+      @app_root ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.to_s : Dir.pwd)
+    end
+  end
+end

data/lib/rails_visualizer/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.join(__dir__, '..', 'tasks', 'rails_visualizer.rake')
+    end
+  end
+end

data/lib/rails_visualizer/renderer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class Renderer
+    PLACEHOLDER = '<script id="rails-visualizer-data"></script>'
+    ASSET_PATH  = File.join(__dir__, 'assets', 'dist')
+
+    def initialize(json_data)
+      @json_data = json_data
+    end
+
+    def call
+      template = read_template
+      template.sub(PLACEHOLDER) { data_script }
+    end
+
+    private
+
+    def read_template
+      File.read(template_path)
+    end
+
+    def template_path
+      File.join(ASSET_PATH, 'index.html')
+    end
+
+    def data_script
+      %(<script id="rails-visualizer-data">window.__RAILS_VISUALIZER_DATA__ = #{@json_data};</script>)
+    end
+  end
+end

data/lib/rails_visualizer/routes_inspector.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class RoutesInspector
+    # Controllers served by Rails framework / engines — not user-defined code.
+    INTERNAL_PREFIXES = %w[
+      rails/
+      active_storage
+      action_mailbox
+      action_text
+      turbo/
+      cable/
+    ].freeze
+
+    def initialize(excluded_paths: [])
+      @excluded_paths = excluded_paths
+    end
+
+    def call
+      Rails.application.routes.routes
+           .select { |r| r.defaults[:controller].present? && r.verb.present? }
+           .reject { |r| excluded_path?(r.path.spec.to_s) }
+           .map { |r| serialize_route(r) }
+    rescue StandardError
+      []
+    end
+
+    private
+
+    def serialize_route(route) # rubocop:disable Metrics/AbcSize
+      controller  = route.defaults[:controller].to_s
+      action      = route.defaults[:action].to_s
+      path        = route.path.spec.to_s
+      is_internal = internal?(controller)
+      ctrl_file   = controller_file_map[controller]
+
+      {
+        verb: route.verb.to_s,
+        path: path,
+        controller: controller,
+        action: action,
+        name: route.name,
+        namespace: extract_namespace(controller),
+        internal: is_internal,
+        orphaned: !is_internal && controller.present? && ctrl_file.nil?,
+        controller_file_path: ctrl_file,
+        constraints: serialize_constraints(route.constraints)
+      }
+    end
+
+    # Builds a hash of controller_path => absolute_file_path by scanning every
+    # configured app/controllers directory across the main app and all engines/
+    # railties. Filesystem-based — works regardless of class-loading state and
+    # correctly handles monorepo component directories.
+    def controller_file_map
+      @controller_file_map ||= begin
+        dirs = controller_dirs
+        dirs.each_with_object({}) do |dir, map|
+          Dir.glob(File.join(dir, '**', '*_controller.rb')).each do |file|
+            # Derive the Rails controller path from the file path, e.g.:
+            #   ".../app/controllers/project_area/commitments_controller.rb"
+            #   → "project_area/commitments"
+            rel = file.delete_prefix("#{dir}/").delete_suffix('_controller.rb')
+            map[rel] ||= file # first match wins; avoids overwriting earlier finds
+          end
+        end
+      end
+    end
+
+    # Collects all directories that Rails treats as controller source dirs,
+    # covering the main app, all mounted engines/railties, and any paths
+    # manually added to autoload_paths / eager_load_paths.
+    def controller_dirs
+      dirs = Set.new
+      add_app_controller_dirs(dirs)
+      add_railtie_controller_dirs(dirs)
+      add_autoload_controller_dirs(dirs)
+      dirs
+    rescue StandardError
+      Set.new
+    end
+
+    def add_app_controller_dirs(dirs)
+      Array(Rails.application.paths['app/controllers']&.existent).each { |d| dirs.add(d.to_s) }
+    end
+
+    def add_railtie_controller_dirs(dirs)
+      Rails.application.railties.each do |railtie|
+        next unless railtie.respond_to?(:paths)
+
+        Array(railtie.paths['app/controllers']&.existent).each { |d| dirs.add(d.to_s) }
+      end
+    end
+
+    def add_autoload_controller_dirs(dirs)
+      # Scan ALL autoload/eager_load roots, not just those ending in /controllers.
+      # Some apps add subdirectories of app/controllers (e.g. non_tab_controllers/)
+      # directly to autoload_paths so their contents load without a namespace prefix.
+      # Scanning all roots with the *_controller.rb glob has no false-positive risk.
+      all_paths = Rails.application.config.autoload_paths + Rails.application.config.eager_load_paths
+      all_paths.each { |p| dirs.add(p.to_s) }
+    end
+
+    def extract_namespace(controller)
+      parts = controller.split('/')
+      parts.size > 1 ? parts[0..-2].join('/') : nil
+    end
+
+    def excluded_path?(path)
+      @excluded_paths.any? { |prefix| path.start_with?(prefix) }
+    end
+
+    def internal?(controller)
+      INTERNAL_PREFIXES.any? { |prefix| controller.start_with?(prefix) }
+    end
+
+    def serialize_constraints(constraints)
+      constraints.except(:controller, :action)
+                 .transform_values(&:to_s)
+    rescue StandardError
+      {}
+    end
+  end
+end

data/lib/rails_visualizer/schema/cache.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  module Schema
+    # Bulk-loads all column and index metadata with minimal DB round-trips.
+    # PostgreSQL: 2 parallel queries (one for columns, one for indexes).
+    # Other adapters: per-table fallback (still cached per table).
+    class Cache
+      Col = Struct.new(:name, :type, :null, :default, keyword_init: true)
+      Idx = Struct.new(:name, :unique, :columns, keyword_init: true)
+
+      PG_TYPE_MAP = {
+        'int2' => 'integer', 'int4' => 'integer', 'int8' => 'integer',
+        'float4' => 'float', 'float8' => 'float',
+        'numeric' => 'decimal', 'money' => 'decimal',
+        'bool' => 'boolean',
+        'varchar' => 'string', 'bpchar' => 'string', 'text' => 'text',
+        'bytea' => 'binary',
+        'date' => 'date',
+        'timestamp' => 'datetime', 'timestamptz' => 'datetime',
+        'time' => 'time', 'timetz' => 'time',
+        'json' => 'json', 'jsonb' => 'jsonb',
+        'uuid' => 'uuid',
+        'inet' => 'inet', 'cidr' => 'cidr',
+        'macaddr' => 'string',
+        'xml' => 'xml',
+        'hstore' => 'hstore',
+        'ltree' => 'ltree',
+        'interval' => 'interval',
+        '_int4' => 'integer', '_int8' => 'integer',
+        '_float8' => 'float',
+        '_varchar' => 'string', '_text' => 'string'
+      }.freeze
+
+      def initialize
+        @columns      = {}
+        @indexes      = {}
+        @index_maps   = {}
+        @primary_keys = {}
+      end
+
+      def table_exists?(table_name)
+        tables.include?(table_name.to_s)
+      end
+
+      def columns_for(table_name)
+        @columns.fetch(table_name.to_s, [])
+      end
+
+      def indexes_for(table_name)
+        @indexes.fetch(table_name.to_s, [])
+      end
+
+      def index_map_for(table_name)
+        tn = table_name.to_s
+        @index_maps[tn] ||= build_index_map(tn)
+      end
+
+      def primary_key_for(table_name)
+        @primary_keys.fetch(table_name.to_s, 'id')
+      end
+
+      def preload_for(table_names)
+        needed = table_names.select { |t| table_exists?(t) }
+        return if needed.empty?
+
+        if postgresql?
+          parallel_bulk_load_pg(needed)
+        else
+          fallback_preload(needed)
+        end
+      end
+
+      private
+
+      def build_index_map(table_name)
+        indexes_for(table_name).each_with_object({}) do |index, hash|
+          next unless index.columns.is_a?(Array)
+
+          index.columns.each do |col|
+            (hash[col] ||= []) << { name: index.name, unique: index.unique, columns: index.columns }
+          end
+        end
+      end
+
+      def tables
+        @tables ||= Set.new(connection.tables)
+      rescue StandardError
+        Set.new
+      end
+
+      def postgresql?
+        connection.adapter_name =~ /postg/i
+      end
+
+      # Run column and index bulk queries in parallel threads.
+      # SQL I/O releases the GIL so both queries hit the DB concurrently.
+      def parallel_bulk_load_pg(needed)
+        t1 = Thread.new do
+          bulk_load_columns_pg(needed)
+        ensure
+          ActiveRecord::Base.connection_pool.release_connection
+        end
+        t2 = Thread.new do
+          bulk_load_indexes_pg(needed)
+        ensure
+          ActiveRecord::Base.connection_pool.release_connection
+        end
+        t1.join
+        t2.join
+      rescue StandardError
+        fallback_preload(needed)
+      end
+
+      def bulk_load_columns_pg(needed)
+        needed_set = needed.to_set
+        rows       = fetch_pg_columns(needed)
+        rows.each do |row|
+          tname = row['table_name']
+          next unless needed_set.include?(tname)
+
+          (@columns[tname] ||= []) << Col.new(
+            name: row['column_name'],
+            type: pg_type(row['udt_name']),
+            null: row['is_nullable'] == 'YES',
+            default: row['column_default']
+          )
+        end
+      rescue StandardError
+        fallback_preload_columns(needed - @columns.keys)
+      end
+
+      def fetch_pg_columns(needed)
+        quoted = needed.map { |t| connection.quote(t) }.join(', ')
+        connection.select_all(<<~SQL) # rubocop:disable Rails/SquishedSQLHeredocs
+          SELECT table_name, column_name, ordinal_position,
+                 column_default, is_nullable, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = ANY(current_schemas(false))
+            AND table_name IN (#{quoted})
+          ORDER BY table_name, ordinal_position
+        SQL
+      end
+
+      def bulk_load_indexes_pg(needed)
+        needed_set = needed.to_set
+        rows       = fetch_pg_indexes(needed)
+        rows.each { |row| process_index_row(row, needed_set) }
+      rescue StandardError
+        fallback_preload_indexes(needed - @indexes.keys)
+      end
+
+      def fetch_pg_indexes(needed)
+        quoted = needed.map { |t| connection.quote(t) }.join(', ')
+        connection.select_all(<<~SQL) # rubocop:disable Rails/SquishedSQLHeredocs
+          SELECT t.relname  AS table_name,
+                 i.relname  AS index_name,
+                 ix.indisunique AS is_unique,
+                 ix.indisprimary AS is_primary,
+                 array_agg(a.attname ORDER BY x.n) AS columns
+          FROM pg_index ix
+          JOIN pg_class t  ON t.oid = ix.indrelid
+          JOIN pg_class i  ON i.oid = ix.indexrelid
+          JOIN pg_namespace ns ON ns.oid = t.relnamespace
+          CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS x(attnum, n)
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
+          WHERE ns.nspname = ANY(current_schemas(false))
+            AND t.relname IN (#{quoted})
+          GROUP BY t.relname, i.relname, ix.indisunique, ix.indisprimary
+        SQL
+      end
+
+      def process_index_row(row, needed_set)
+        tname = row['table_name']
+        return unless needed_set.include?(tname)
+
+        cols = parse_pg_array(row['columns'])
+
+        if row['is_primary']
+          @primary_keys[tname] = cols.first
+        else
+          (@indexes[tname] ||= []) << Idx.new(name: row['index_name'], unique: row['is_unique'], columns: cols)
+        end
+      end
+
+      def fallback_preload(table_names)
+        conn = connection
+        table_names.each do |t|
+          @columns[t] ||= conn.columns(t)
+          @indexes[t] ||= conn.indexes(t)
+          @primary_keys[t] ||= conn.primary_key(t) || 'id'
+        rescue StandardError
+          @columns[t] ||= []
+          @indexes[t] ||= []
+          @primary_keys[t] ||= 'id'
+        end
+      end
+
+      def fallback_preload_columns(table_names)
+        conn = connection
+        table_names.each do |t|
+          @columns[t] ||= conn.columns(t)
+        rescue StandardError
+          @columns[t] ||= []
+        end
+      end
+
+      def fallback_preload_indexes(table_names)
+        conn = connection
+        table_names.each do |t|
+          @indexes[t] ||= conn.indexes(t)
+        rescue StandardError
+          @indexes[t] ||= []
+        end
+      end
+
+      def pg_type(udt_name)
+        PG_TYPE_MAP.fetch(udt_name, 'string')
+      end
+
+      def parse_pg_array(value)
+        case value
+        when Array then value.map(&:to_s)
+        when String then value.delete('{}').split(',')
+        else []
+        end
+      end
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+    end
+  end
+end

data/lib/rails_visualizer/schema/index_inspector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  module Schema
+    class IndexInspector
+      def initialize(model)
+        @model = model
+      end
+
+      # Returns a hash of column_name => [index_info, ...] for the model's table.
+      def call
+        return {} unless safe_table_exists?
+
+        safe_indexes.each_with_object({}) do |index, hash|
+          next unless index.columns.is_a?(Array)
+
+          index.columns.each do |column|
+            hash[column] ||= []
+            hash[column] << {
+              name: index.name,
+              unique: index.unique,
+              columns: index.columns
+            }
+          end
+        end
+      end
+
+      private
+
+      def safe_table_exists?
+        @model.connection.table_exists?(@model.table_name)
+      rescue StandardError
+        false
+      end
+
+      def safe_indexes
+        @model.connection.indexes(@model.table_name)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end