rails_visualizer 0.1.0

data/lib/rails_visualizer/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class Configuration
+    attr_accessor :excluded_models, :excluded_controllers, :excluded_jobs, :excluded_mailers,
+                  :excluded_route_paths, :output_path, :open_browser, :theme, :parallel, :filename
+
+    def initialize
+      @excluded_models      = []
+      @excluded_controllers = []
+      @excluded_jobs        = []
+      @excluded_mailers     = []
+      @excluded_route_paths = []
+      @output_path          = 'tmp/rails_visualizer'
+      @open_browser         = true
+      @theme                = :light
+      @parallel             = true
+      @filename             = 'index.html'
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/rails_visualizer/controllers_inspector.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class ControllersInspector
+    include RailsVisualizer::PathHelper
+
+    FRAMEWORK_NAMESPACES = %w[
+      ActionController::
+      ActionDispatch::
+      ActiveStorage::
+      ActionMailbox::
+      ActionText::
+      Rails::
+      Turbo::
+      Devise::
+    ].freeze
+
+    ACTION_FILTER_CLASS = 'AbstractController::Callbacks::ActionFilter'
+    ROUTABLE_ACTION_PATTERN = /\A[a-z_][a-zA-Z0-9_]*!?\z/
+
+    def initialize(excluded: [])
+      @excluded_set          = excluded.to_set
+      @callbacks_by_class    = {}
+      @callback_origin_cache = {}
+    end
+
+    def call
+      return [] unless defined?(ActionController::Base)
+
+      base = ActionController::Base.descendants
+      api  = defined?(ActionController::API) ? ActionController::API.descendants : []
+
+      (base + api)
+        .uniq
+        .reject { |c| c.name.nil? || framework_class?(c.name) || @excluded_set.include?(c.name) }
+        .map { |c| serialize_controller(c) }
+        .sort_by { |c| c[:name] }
+    rescue StandardError
+      []
+    end
+
+    private
+
+    def serialize_controller(controller)
+      chain    = callbacks_for(controller)
+      sc_chain = callbacks_for(controller.superclass)
+
+      # Partition the chain once — avoids iterating it 4+ times.
+      by_kind, cb_names = partition_chain(chain)
+      sc_by_kind        = partition_chain(sc_chain).first
+
+      {
+        name: controller.name,
+        superclass: controller.superclass.name,
+        namespace: extract_namespace(controller.name),
+        file_path: source_path_for(controller),
+        controller_path: controller.controller_path,
+        actions: user_actions(controller),
+        public_helpers: public_helpers(controller, cb_names),
+        before_actions: build_kind(controller, :before, by_kind, sc_by_kind),
+        after_actions: build_kind(controller, :after, by_kind, sc_by_kind),
+        around_actions: build_kind(controller, :around, by_kind, sc_by_kind)
+      }
+    end
+
+    # Cached globally by class — many sibling controllers share the same superclass.
+    def callbacks_for(klass)
+      @callbacks_by_class[klass] ||= klass.send(:_process_action_callbacks).to_a
+    rescue StandardError
+      @callbacks_by_class[klass] = []
+    end
+
+    # Single pass: partitions symbol callbacks into { kind => [cb, ...] }
+    # and collects all callback names into a Set (for helper exclusion).
+    def partition_chain(chain)
+      by_kind  = Hash.new { |h, k| h[k] = [] }
+      cb_names = Set.new
+      chain.each do |cb|
+        next unless cb.filter.is_a?(Symbol)
+
+        cb_names.add(cb.filter.to_s)
+        by_kind[cb.kind] << cb
+      end
+      [by_kind, cb_names]
+    end
+
+    def build_kind(controller, kind, by_kind, sc_by_kind)
+      sc_names = sc_by_kind[kind].to_set { |cb| cb.filter.to_s }
+
+      raw = by_kind[kind].filter_map do |cb|
+        name = cb.filter.to_s
+        inherited = sc_names.include?(name) ? callback_origin(controller, name, kind) : nil
+        serialize_callback(cb, inherited)
+      end
+      raw.uniq { |c| c[:name] }
+    rescue StandardError
+      []
+    end
+
+    # Methods physically written in the controller's own source file.
+    # Checks both owner (excludes plain module includes) and source_location
+    # (excludes methods injected via concern `included do` blocks).
+    def own_public_methods(controller)
+      ctrl_file = controller_source_file(controller)
+      controller.public_instance_methods(false).filter_map do |m|
+        um = controller.instance_method(m)
+        next unless um.owner == controller
+        next if ctrl_file && um.source_location&.first != ctrl_file
+
+        m.to_s
+      end
+    rescue StandardError
+      []
+    end
+
+    def controller_source_file(controller)
+      Module.const_source_location(controller.name)&.first
+    rescue StandardError
+      nil
+    end
+
+    def user_actions(controller)
+      own_public_methods(controller)
+        .grep(ROUTABLE_ACTION_PATTERN)
+        .sort
+        .map { |name| { name: name, defined_in: nil } }
+    end
+
+    def public_helpers(controller, cb_names)
+      own_public_methods(controller)
+        .reject { |m| ROUTABLE_ACTION_PATTERN.match?(m) || cb_names.include?(m) }
+        .sort
+        .map { |m| { name: m, defined_in: nil } }
+    end
+
+    def extract_namespace(name)
+      parts = name.split('::')
+      parts.size > 1 ? parts[0..-2].join('::') : nil
+    end
+
+    def callback_origin(controller, filter_name, kind)
+      key = [controller.superclass, filter_name, kind]
+      @callback_origin_cache.fetch(key) do
+        @callback_origin_cache[key] = compute_callback_origin(controller, filter_name, kind)
+      end
+    end
+
+    def compute_callback_origin(controller, filter_name, kind)
+      origin = nil
+      klass  = controller.superclass
+      while user_controller_ancestor?(klass)
+        cbs = callbacks_for(klass)
+        origin = klass.name if cbs.any? { |cb| cb.kind == kind && cb.filter.to_s == filter_name }
+        klass = klass.superclass
+      end
+      origin
+    rescue StandardError
+      nil
+    end
+
+    # True for any user-defined ancestor that can hold action callbacks.
+    # Handles both ActionController::Base and ActionController::API hierarchies.
+    def user_controller_ancestor?(klass)
+      return false unless klass.is_a?(Class)
+
+      (klass < ActionController::Base) ||
+        (defined?(ActionController::API) && klass < ActionController::API)
+    end
+
+    def serialize_callback(callback, inherited_from = nil)
+      if_items     = Array(callback.instance_variable_get(:@if))
+      unless_items = Array(callback.instance_variable_get(:@unless))
+
+      {
+        name: callback.filter.to_s,
+        only: action_filter_actions(if_items),
+        except: action_filter_actions(unless_items),
+        if_conditions: if_items.grep(Symbol).map(&:to_s),
+        unless_conditions: unless_items.grep(Symbol).map(&:to_s),
+        has_custom_condition: (if_items + unless_items).any?(Proc),
+        inherited_from: inherited_from
+      }
+    end
+
+    def action_filter_actions(items)
+      items.each_with_object([]) do |item, result|
+        next unless item.class.name == ACTION_FILTER_CLASS # rubocop:disable Style/ClassEqualityComparison
+
+        raw = item.instance_variable_get(:@actions)
+        result.concat(Array(raw).map(&:to_s).sort)
+      end
+    rescue StandardError
+      []
+    end
+
+    def framework_class?(name)
+      FRAMEWORK_NAMESPACES.any? { |ns| name.start_with?(ns) }
+    end
+  end
+end

data/lib/rails_visualizer/gems_inspector.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class GemsInspector
+    # Groups Bundler adds implicitly when no :group is specified — not user-defined.
+    IMPLICIT_GROUPS = %w[default].freeze
+
+    def call
+      return [] unless defined?(Bundler)
+
+      specs_map = build_specs_map
+      Bundler.definition.dependencies
+             .map { |dep| serialize_gem(dep, specs_map[dep.name]) }
+             .sort_by { |g| g[:name] }
+    rescue StandardError
+      []
+    end
+
+    private
+
+    def build_specs_map
+      Bundler.load.specs.each_with_object({}) do |spec, map|
+        map[spec.name] ||= spec
+      end
+    rescue StandardError
+      {}
+    end
+
+    def serialize_gem(dep, spec)
+      {
+        name: dep.name,
+        version: spec&.version.to_s.presence,
+        requirement: dep.requirement.to_s,
+        groups: normalize_groups(dep.groups),
+        source_tags: source_tags(dep, spec) + require_tags(dep),
+        summary: clean_summary(spec&.summary),
+        homepage: spec&.homepage.to_s.presence
+      }
+    end
+
+    # Returns explicit environment groups only. Gems with no explicit group
+    # (Bundler's implicit :default) return [] — the UI treats them as "Common".
+    def normalize_groups(groups)
+      groups.map(&:to_s).reject { |g| IMPLICIT_GROUPS.include?(g) }
+    end
+
+    def clean_summary(summary)
+      str = summary.to_s.strip
+      str.empty? ? nil : str
+    end
+
+    # Builds an array of human-readable parameter chips for non-rubygems sources,
+    # e.g. ["github: procore-oss/migration-lock-timeout", "branch: main", "path: engines/erp"].
+    def source_tags(dep, spec)
+      src = dep.source || spec&.source
+      return [] unless src
+
+      if src.is_a?(Bundler::Source::Git)
+        git_source_tags(src)
+      elsif src.is_a?(Bundler::Source::Path)
+        ["path: #{src.path}"]
+      else
+        []
+      end
+    rescue StandardError
+      []
+    end
+
+    def git_source_tags(src)
+      tags = [git_origin_tag(src.uri.to_s)]
+      tags << "branch: #{src.branch}" if src.branch
+      tags << "tag: #{src.tag}"       if src.tag
+      # Only surface a bare ref if no branch/tag was given (pinned SHA)
+      tags << "ref: #{src.ref[0..7]}" if src.ref && !src.branch && !src.tag
+      tags.compact
+    end
+
+    # Builds chips for the require: option.
+    #   require: false          → ["require: false"]
+    #   require: 'exifr/jpeg'   → ["require: exifr/jpeg"]
+    #   require: [a, b]         → ["require: a, b"]
+    #   (not specified)         → []
+    def require_tags(dep)
+      ar = dep.autorequire
+      return [] if ar.nil? # no require: key at all → default behaviour
+      return ['require: false'] if ar.empty?
+
+      paths = Array(ar).map(&:to_s).reject(&:empty?)
+      paths.empty? ? [] : ["require: #{paths.join(', ')}"]
+    rescue StandardError
+      []
+    end
+
+    # Converts a git URI to a readable "github: owner/repo" or "git: <uri>" tag.
+    def git_origin_tag(uri)
+      github = uri.match(%r{github\.com[/:](.+?)(?:\.git)?$})
+      return "github: #{github[1]}" if github
+
+      gitlab = uri.match(%r{gitlab\.com[/:](.+?)(?:\.git)?$})
+      return "gitlab: #{gitlab[1]}" if gitlab
+
+      "git: #{uri}"
+    end
+  end
+end

data/lib/rails_visualizer/introspector.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class Introspector
+    include RailsVisualizer::PathHelper
+
+    def initialize(configuration = RailsVisualizer.configuration)
+      @configuration = configuration
+    end
+
+    def call
+      eager_load!
+      futures = launch_parallel_inspectors
+      cache, ar_models, migrations = run_db_phase
+      thread_results = join_futures(futures)
+      models = run_model_inspection(cache, ar_models)
+
+      assemble(models, migrations, thread_results)
+    end
+
+    private
+
+    def launch_parallel_inspectors
+      config = @configuration
+      {
+        routes: Thread.new { RoutesInspector.new(excluded_paths: config.excluded_route_paths).call },
+        jobs: Thread.new { JobsInspector.new(excluded: config.excluded_jobs).call },
+        controllers: Thread.new { ControllersInspector.new(excluded: config.excluded_controllers).call },
+        mailers: Thread.new { MailersInspector.new(excluded: config.excluded_mailers).call },
+        gems: Thread.new { GemsInspector.new.call }
+      }
+    end
+
+    def run_db_phase
+      cache = Schema::Cache.new
+      ar_models = collect_models
+      table_names = ar_models.filter_map { |m| safe_table_name(m) }.uniq
+      cache.preload_for(table_names)
+      migrations = MigrationsInspector.new.call
+      [cache, ar_models, migrations]
+    end
+
+    def join_futures(futures)
+      futures.transform_values(&:value)
+    end
+
+    def run_model_inspection(cache, ar_models)
+      file_cache = {}
+      preload_source_files(ar_models, file_cache)
+      inspect_models_parallel(cache, ar_models, file_cache)
+    end
+
+    def assemble(models, migrations, thread_results)
+      result = { app_name: app_name, models: models, migrations: migrations }
+      thread_results.each { |k, v| result[k] = v }
+      result
+    end
+
+    # ------------------------------------------------------------------
+    # Source file + primary_key warmup (runs before fork)
+    # ------------------------------------------------------------------
+
+    def preload_source_files(ar_models, file_cache)
+      root = app_root
+      ar_models.each do |model|
+        path = source_path_for(model)
+        next unless path
+        next if file_cache.key?(path)
+
+        absolute = File.join(root, path)
+        file_cache[path] = File.exist?(absolute) ? File.read(absolute) : nil
+      rescue StandardError
+        file_cache[path] = nil if defined?(path) && path
+      end
+    end
+
+    # ------------------------------------------------------------------
+    # Fork-based parallel model inspection
+    # ------------------------------------------------------------------
+
+    def inspect_models_parallel(cache, ar_models, file_cache)
+      nworkers = determine_worker_count(ar_models.size)
+      return inspect_sequential(cache, ar_models, file_cache) if nworkers <= 1
+
+      fork_and_collect(cache, ar_models, file_cache, nworkers)
+    rescue NotImplementedError
+      inspect_sequential(cache, ar_models, file_cache)
+    end
+
+    def inspect_sequential(cache, ar_models, file_cache)
+      method_cache = {}
+      ar_models.map { |m| Schema::ModelInspector.new(m, cache, file_cache, method_cache).call }
+    end
+
+    def fork_and_collect(cache, ar_models, file_cache, nworkers)
+      slices = ar_models.each_slice((ar_models.size.to_f / nworkers).ceil).to_a
+      workers = slices.map.with_index do |slice, idx|
+        tmppath = File.join(Dir.tmpdir, "rails_visualizer_#{Process.pid}_#{idx}.dat")
+        pid = fork_worker(cache, slice, file_cache, tmppath)
+        [pid, tmppath]
+      end
+      collect_results(workers)
+    end
+
+    def fork_worker(cache, models, file_cache, tmppath)
+      Process.fork do
+        ActiveRecord::Base.connection_handler.clear_all_connections! rescue nil # rubocop:disable Style/RescueModifier
+        method_cache = {}
+        results = models.map do |m|
+          Schema::ModelInspector.new(m, cache, file_cache, method_cache).call
+        end
+        File.binwrite(tmppath, Marshal.dump(results))
+      rescue StandardError => e
+        warn "[RailsVisualizer] Fork worker error: #{e.message}"
+        File.binwrite(tmppath, Marshal.dump([]))
+      ensure
+        exit!(0) # rubocop:disable Rails/Exit
+      end
+    end
+
+    def collect_results(workers)
+      workers.flat_map do |pid, tmppath|
+        _, status = Process.waitpid2(pid)
+        next [] unless status.success? && File.exist?(tmppath)
+
+        Marshal.load(File.binread(tmppath)) # rubocop:disable Security/MarshalLoad
+      ensure
+        File.delete(tmppath) if tmppath && File.exist?(tmppath)
+      end
+    end
+
+    def determine_worker_count(model_count)
+      return 1 unless @configuration.parallel
+      return 1 unless Process.respond_to?(:fork)
+      return 1 if model_count < 50
+
+      require 'etc'
+      [Etc.nprocessors, 8, (model_count / 50.0).ceil].min
+    rescue StandardError
+      1
+    end
+
+    # ------------------------------------------------------------------
+    # Existing helpers
+    # ------------------------------------------------------------------
+
+    def eager_load!
+      return unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+      Rails.application.eager_load!
+    rescue StandardError => e
+      warn "[RailsVisualizer] Warning: eager_load! raised #{e.class}: #{e.message}"
+      nil
+    end
+
+    def app_name
+      Rails.application.class.module_parent_name
+    rescue StandardError
+      nil
+    end
+
+    def collect_models
+      ActiveRecord::Base.descendants.reject do |model|
+        model.abstract_class? ||
+          excluded?(model) ||
+          !model.name ||
+          anonymous?(model)
+      end
+    rescue NameError
+      []
+    end
+
+    def excluded?(model)
+      excluded_set.include?(model.name)
+    end
+
+    def excluded_set
+      @excluded_set ||= @configuration.excluded_models.to_set
+    end
+
+    def anonymous?(model)
+      model.name.start_with?('#<')
+    end
+
+    def safe_table_name(model)
+      model.table_name
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/rails_visualizer/jobs_inspector.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RailsVisualizer
+  class JobsInspector
+    include RailsVisualizer::PathHelper
+
+    # Namespaces whose jobs come from Rails or popular gems, not user code.
+    FRAMEWORK_NAMESPACES = %w[
+      ActiveJob::
+      ActionMailer::
+      ActiveStorage::
+      ActionMailbox::
+      Turbo::
+      ActiveRecord::
+    ].freeze
+
+    # Conventional application base-class names.
+    BASE_JOB_NAMES = %w[ApplicationJob].freeze
+
+    def initialize(excluded: [])
+      @excluded_set = excluded.to_set
+    end
+
+    def call
+      {
+        adapter: detect_adapter,
+        active_jobs: collect_active_jobs,
+        sidekiq_workers: collect_sidekiq_workers
+      }
+    end
+
+    private
+
+    def detect_adapter
+      ActiveJob::Base.queue_adapter_name.to_s
+    rescue StandardError
+      'unknown'
+    end
+
+    def collect_active_jobs
+      return [] unless defined?(ActiveJob::Base)
+
+      ActiveJob::Base
+        .descendants
+        .reject { |j| j.name.nil? || framework_class?(j.name) || base_job?(j.name) || @excluded_set.include?(j.name) }
+        .map { |j| serialize_active_job(j) }
+    rescue StandardError
+      []
+    end
+
+    def serialize_active_job(job)
+      {
+        name: job.name,
+        file_path: source_path_for(job),
+        queue: safe_queue_name(job),
+        priority: job.priority,
+        retry_on: extract_retry_config(job),
+        discard_on: extract_discard_config(job)
+      }
+    rescue StandardError
+      { name: job.name, file_path: nil, queue: 'default', priority: nil, retry_on: [], discard_on: [] }
+    end
+
+    # queue_name may be a Proc/lambda when set via a block (queue_as { ... }).
+    # Calling .to_s on a Proc produces an unreadable string; return 'dynamic'.
+    def safe_queue_name(job)
+      name = job.queue_name
+      name.is_a?(String) ? name : 'dynamic'
+    rescue StandardError
+      'default'
+    end
+
+    def extract_retry_config(job)
+      job.rescue_handlers
+         .map { |h| { error: h[0].to_s, handler: h[1].class.name } }
+    rescue StandardError
+      []
+    end
+
+    def extract_discard_config(job)
+      return [] unless job.respond_to?(:discard_on_handlers)
+
+      job.discard_on_handlers.map(&:to_s)
+    rescue StandardError
+      []
+    end
+
+    def collect_sidekiq_workers
+      return [] unless defined?(Sidekiq)
+
+      worker_module = defined?(Sidekiq::Job) ? Sidekiq::Job : Sidekiq::Worker
+
+      ObjectSpace.each_object(Class)
+                 .select { |c| c < worker_module && !c.name.nil? }
+                 .reject { |c| framework_class?(c.name) || base_job?(c.name) || @excluded_set.include?(c.name) }
+                 .map { |c| serialize_sidekiq_worker(c) }
+    rescue StandardError
+      []
+    end
+
+    def serialize_sidekiq_worker(worker)
+      opts = worker.respond_to?(:sidekiq_options) ? worker.sidekiq_options : {}
+      {
+        name: worker.name,
+        file_path: source_path_for(worker),
+        queue: opts['queue'] || 'default',
+        retry: opts['retry'],
+        unique: opts['unique']
+      }
+    end
+
+    def framework_class?(name)
+      FRAMEWORK_NAMESPACES.any? { |ns| name.start_with?(ns) }
+    end
+
+    def base_job?(name)
+      BASE_JOB_NAMES.include?(name)
+    end
+  end
+end