class-metrix 0.1.2 → 1.0.1

data/lib/class_metrix/formatters/shared/table_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "value_processor"
+require_relative "../../utils/debug_logger"
 
 module ClassMetrix
   module Formatters
@@ -13,6 +14,13 @@ module ClassMetrix
           @expand_hashes = expand_hashes
           @options = options
           @value_processor = ValueProcessor
+          @debug_mode = options.fetch(:debug_mode, false)
+          @debug_level = options.fetch(:debug_level, :basic)
+          @logger = Utils::DebugLogger.new("TableBuilder", @debug_mode, @debug_level)
+
+          @logger.log("TableBuilder initialized with expand_hashes: #{expand_hashes}")
+          @logger.log("Data headers: #{@data[:headers]}", :detailed)
+          @logger.log("Number of rows: #{@data[:rows]&.length || 0}")
         end
 
         def build_simple_table
@@ -25,24 +33,26 @@ module ClassMetrix
         def build_expanded_table
           return build_simple_table unless @expand_hashes
 
+          @logger.log("Building expanded table with hash expansion")
           headers = @data[:headers]
-          expanded_rows = process_rows_for_expansion(headers)
+          rows = process_rows_for_expansion(headers)
 
           {
             headers: headers,
-            rows: expanded_rows
+            rows: rows
           }
         end
 
         def build_flattened_table
           return build_simple_table unless @expand_hashes
 
+          @logger.log("Building flattened table with hash expansion")
           headers = @data[:headers]
-          rows = @data[:rows]
+          all_hash_keys = collect_all_hash_keys(@data[:rows], headers)
+          @logger.log("Collected hash keys: #{all_hash_keys}")
 
-          all_hash_keys = collect_all_hash_keys(rows, headers)
           flattened_headers = create_flattened_headers(headers, all_hash_keys)
-          flattened_rows = create_flattened_rows(rows, headers, all_hash_keys)
+          flattened_rows = create_flattened_rows(@data[:rows], headers, all_hash_keys)
 
           {
             headers: flattened_headers,
@@ -53,21 +63,36 @@ module ClassMetrix
         private
 
         def process_rows_for_expansion(headers)
-          expanded_rows = []
+          expanded_rows = [] # : Array[Array[String]]
+          expandable_count = 0
 
-          @data[:rows].each do |row|
+          @data[:rows].each_with_index do |row, index|
             if row_has_expandable_hash?(row)
+              expandable_count += 1
+              @logger.log("Row #{index} has expandable hashes", :detailed)
               expanded_rows.concat(expand_row(row, headers))
             else
+              @logger.log("Row #{index} has no expandable hashes", :verbose)
               expanded_rows << process_row(row)
             end
           end
 
+          @logger.log("Processed #{@data[:rows].length} rows, #{expandable_count} had expandable hashes")
           expanded_rows
         end
 
         def row_has_expandable_hash?(row)
-          row[value_start_index..].any? { |cell| cell.is_a?(Hash) }
+          values = row[value_start_index..]
+
+          # Use summary logging instead of per-value logging
+          @logger.log_hash_detection_summary(values)
+
+          # Only consider real Hash objects as expandable
+          return false if values.nil?
+
+          result = values.any? { |cell| cell.is_a?(Hash) && cell.instance_of?(Hash) }
+          @logger.log_decision("Row expandable", "#{result ? "Has" : "No"} real Hash objects", :detailed)
+          result
         end
 
         def create_flattened_rows(rows, headers, all_hash_keys)
@@ -107,7 +132,9 @@ module ClassMetrix
 
         def expand_row(row, _headers)
           behavior_name = row[behavior_column_index]
-          values = row[value_start_index..]
+          values = row[value_start_index..] || []
+
+          @logger.log("Expanding row for behavior '#{behavior_name}'")
 
           all_hash_keys = collect_hash_keys_from_values(values)
           return [process_row(row)] if all_hash_keys.empty?
@@ -117,19 +144,44 @@ module ClassMetrix
 
         def collect_hash_keys_from_values(values)
           all_hash_keys = Set.new
-          values.each do |value|
-            all_hash_keys.merge(value.keys.map(&:to_s)) if value.is_a?(Hash)
+          hash_count = 0
+
+          values.each_with_index do |value, index|
+            # Be more strict about what we consider a "hash"
+            if value.is_a?(Hash) && value.instance_of?(Hash) && value.respond_to?(:keys)
+              hash_count += 1
+              keys = @logger.safe_keys(value)
+              @logger.log("Value #{index} is a real Hash with keys: #{keys}", :detailed)
+              all_hash_keys.merge(keys.map(&:to_s))
+            elsif value.is_a?(Hash)
+              @logger.log_anomaly("Hash-like object at index #{index} (#{@logger.safe_class(value)}) skipped")
+            end
           end
+
+          @logger.log("Collected hash keys from #{hash_count} real hashes: #{all_hash_keys.to_a}")
           all_hash_keys
         end
 
         def build_expanded_row_set(row, behavior_name, values, all_hash_keys)
-          expanded_rows = []
-          expanded_rows << build_main_row(row, behavior_name, values)
-          expanded_rows.concat(build_sub_rows(all_hash_keys, values))
+          expanded_rows = [] # : Array[Array[String]]
+
+          # Add main row if configured to show
+          expanded_rows << build_main_row(row, behavior_name, values) if should_show_main_row?
+
+          # Add sub rows if configured to show
+          expanded_rows.concat(build_sub_rows(all_hash_keys, values)) if should_show_key_rows?
+
           expanded_rows
         end
 
+        def should_show_main_row?
+          !@options.fetch(:hide_main_row, false)
+        end
+
+        def should_show_key_rows?
+          !@options.fetch(:hide_key_rows, true) # Default: hide key rows
+        end
+
         def build_main_row(row, behavior_name, values)
           processed_values = values.map { |value| process_value(value) }
 
@@ -172,8 +224,8 @@ module ClassMetrix
         end
 
         def extract_hash_value_for_key(hash, key)
-          if @value_processor.has_hash_key?(hash, key)
-            hash_value = @value_processor.safe_hash_lookup(hash, key)
+          if @value_processor.has_hash_key?(hash, key, debug_mode: @debug_mode)
+            hash_value = @value_processor.safe_hash_lookup(hash, key, debug_mode: @debug_mode)
             process_value(hash_value)
           else
             get_null_value
@@ -182,25 +234,38 @@ module ClassMetrix
 
         def collect_all_hash_keys(rows, _headers)
           value_start_idx = value_start_index
-          all_keys = {} # behavior_name => Set of keys
+          all_keys = {} # : Hash[String, Set[String]] # behavior_name => Set of keys
+          total_hash_count = 0
 
-          rows.each do |row|
-            collect_hash_keys_for_row(row, value_start_idx, all_keys)
+          rows.each_with_index do |row, index|
+            hash_count = collect_hash_keys_for_row(row, value_start_idx, all_keys)
+            total_hash_count += hash_count
+            @logger.log("Row #{index}: #{hash_count} hashes found", :detailed)
           end
 
+          @logger.log("Final hash key collection: #{total_hash_count} total hashes, #{all_keys.keys.length} behaviors with hashes")
           all_keys
         end
 
         def collect_hash_keys_for_row(row, value_start_idx, all_keys)
           behavior_name = row[behavior_column_index]
-          values = row[value_start_idx..]
-
-          values.each do |value|
-            next unless value.is_a?(Hash)
-
-            all_keys[behavior_name] ||= Set.new
-            all_keys[behavior_name].merge(value.keys.map(&:to_s))
+          values = row[value_start_idx..] || []
+          hash_count = 0
+
+          values.each_with_index do |value, index|
+            # Be more strict about what we consider a "hash"
+            if value.is_a?(Hash) && value.instance_of?(Hash) && value.respond_to?(:keys)
+              hash_count += 1
+              keys = @logger.safe_keys(value)
+              @logger.log("Behavior '#{behavior_name}' value #{index}: Hash with keys #{keys}", :verbose)
+              all_keys[behavior_name] ||= Set.new
+              all_keys[behavior_name].merge(keys.map(&:to_s))
+            elsif value.is_a?(Hash)
+              @logger.log_anomaly("Hash-like object in '#{behavior_name}' at index #{index} (#{@logger.safe_class(value)}) skipped")
+            end
           end
+
+          hash_count
         end
 
         def create_flattened_headers(headers, all_hash_keys)
@@ -236,7 +301,7 @@ module ClassMetrix
         def add_flattened_hash_values(flattened, row, behavior_name, all_hash_keys)
           return unless all_hash_keys[behavior_name]
 
-          values = row[value_start_index..]
+          values = row[value_start_index..] || []
 
           all_hash_keys[behavior_name].to_a.sort.each do |key|
             add_flattened_values_for_key(flattened, values, key)

data/lib/class_metrix/formatters/shared/value_processor.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
+require_relative "../../utils/debug_logger"
+
 module ClassMetrix
   module Formatters
     module Shared
       class ValueProcessor
-        def self.process_for_markdown(value)
+        def self.process_for_markdown(value, debug_mode: false, debug_level: :basic)
+          logger = Utils::DebugLogger.new("ValueProcessor", debug_mode, debug_level)
+          logger.log_value_details(value)
+
           case value
           when Hash
-            value.inspect
+            logger.log("Processing Hash with keys: #{logger.safe_keys(value)}", :detailed)
+            logger.safe_inspect(value)
           when Array
+            logger.log("Processing Array with #{logger.safe_length(value)} elements", :detailed)
             value.join(", ")
           when true
             "✅"
@@ -17,21 +24,32 @@ module ClassMetrix
           when nil
             "❌"
           when String
+            logger.log("Processing String: #{logger.safe_truncate(value, 50)}", :verbose)
             value
           else
-            value.to_s
+            logger.log("Processing other type (#{logger.safe_class(value)}): #{logger.safe_truncate(logger.safe_inspect(value), 100)}",
+                       :detailed)
+            logger.safe_to_s(value)
           end
         end
 
-        def self.process_for_csv(value, options = {})
-          null_value = options.fetch(:null_value, "")
+        def self.process_for_csv(value, options = {}, debug_mode: false, debug_level: :basic)
+          debug_mode = options.fetch(:debug_mode, false) if options.is_a?(Hash)
+          debug_level = options.fetch(:debug_level, :basic) if options.is_a?(Hash)
+          null_value = options.fetch(:null_value, "") if options.is_a?(Hash)
+
+          logger = Utils::DebugLogger.new("ValueProcessor", debug_mode, debug_level)
+          logger.log_value_details(value)
+
+          process_csv_value_by_type(value, logger, null_value)
+        end
 
+        def self.process_csv_value_by_type(value, logger, null_value)
           case value
           when Hash
-            # For non-flattened CSV, represent hash as JSON-like string
-            value.inspect
+            process_hash_for_csv(value, logger)
           when Array
-            value.join("; ") # Use semicolon to avoid CSV comma conflicts
+            process_array_for_csv(value, logger)
           when true
             "TRUE"
           when false
@@ -39,21 +57,59 @@ module ClassMetrix
           when nil
             null_value
           when String
-            # Clean up emoji for CSV compatibility
-            clean_value = value.gsub(/🚫|⚠️|✅|❌/, "").strip
-            clean_value.empty? ? null_value : clean_value
+            process_string_for_csv(value, null_value)
           else
-            value.to_s
+            process_other_for_csv(value, logger)
           end
         end
 
-        def self.safe_hash_lookup(hash, key)
+        def self.process_hash_for_csv(value, logger)
+          logger.log("Processing Hash for CSV with keys: #{logger.safe_keys(value)}", :detailed)
+          logger.safe_inspect(value)
+        end
+
+        def self.process_array_for_csv(value, logger)
+          logger.log("Processing Array for CSV with #{logger.safe_length(value)} elements", :detailed)
+          value.join("; ") # Use semicolon to avoid CSV comma conflicts
+        end
+
+        def self.process_string_for_csv(value, null_value)
+          clean_value = value.gsub(/🚫|⚠️|✅|❌/, "").strip
+          clean_value.empty? ? null_value : clean_value
+        end
+
+        def self.process_other_for_csv(value, logger)
+          logger.log(
+            "Processing other type for CSV (#{logger.safe_class(value)}): #{logger.safe_truncate(logger.safe_inspect(value),
+                                                                                                 100)}", :detailed
+          )
+          logger.safe_to_s(value)
+        end
+
+        def self.safe_hash_lookup(hash, key, debug_mode: false, debug_level: :basic)
+          logger = Utils::DebugLogger.new("ValueProcessor", debug_mode, debug_level)
+          logger.log("Hash lookup for key '#{key}' in hash with keys: #{logger.safe_keys(hash)}", :verbose)
+
           # Properly handle false values in hash lookup
-          hash.key?(key.to_sym) ? hash[key.to_sym] : hash[key.to_s]
+          begin
+            hash.key?(key.to_sym) ? hash[key.to_sym] : hash[key.to_s]
+          rescue StandardError => e
+            logger.log("Error during hash lookup: #{e.class.name}: #{e.message}")
+            nil
+          end
         end
 
-        def self.has_hash_key?(hash, key)
-          hash.key?(key.to_sym) || hash.key?(key.to_s)
+        def self.has_hash_key?(hash, key, debug_mode: false, debug_level: :basic)
+          logger = Utils::DebugLogger.new("ValueProcessor", debug_mode, debug_level)
+
+          begin
+            result = hash.key?(key.to_sym) || hash.key?(key.to_s)
+            logger.log("Checking if hash has key '#{key}': #{result} (hash keys: #{logger.safe_keys(hash)})", :verbose)
+            result
+          rescue StandardError => e
+            logger.log("Error checking hash key: #{e.class.name}: #{e.message}")
+            false
+          end
         end
 
         # Error message generators

data/lib/class_metrix/utils/debug_logger.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Utils
+    # Debug logging utility for ClassMetrix
+    # Provides safe, consistent debug output across all components
+    class DebugLogger
+      # Debug levels: :basic, :detailed, :verbose
+      LEVELS = { basic: 1, detailed: 2, verbose: 3 }.freeze
+
+      def initialize(component_name, debug_mode = false, level = :basic)
+        @component_name = component_name
+        @debug_mode = debug_mode
+        @level = LEVELS[level] || LEVELS[:basic]
+      end
+
+      def log(message, level = :basic)
+        return unless @debug_mode && LEVELS[level] <= @level
+
+        puts "[DEBUG #{@component_name}] #{message}"
+      end
+
+      def log_safe_operation(operation_name, level = :detailed, &block)
+        log("Starting #{operation_name}", level)
+        result = block.call
+        log("Completed #{operation_name} successfully", level)
+        result
+      rescue StandardError => e
+        log("Error in #{operation_name}: #{e.class.name}: #{e.message}")
+        raise
+      end
+
+      # Summary logging for groups of similar operations
+      def log_summary(operation, items, &block)
+        return unless @debug_mode
+
+        if @level >= LEVELS[:detailed]
+          log("#{operation} (#{items.length} items)")
+          items.each_with_index { |item, i| block.call(item, i) } if block_given?
+        else
+          log("#{operation} (#{items.length} items)")
+        end
+      end
+
+      def log_decision(decision, reason, level = :basic)
+        log("Decision: #{decision} - #{reason}", level)
+      end
+
+      def log_anomaly(description)
+        log("⚠️ Anomaly: #{description}")
+      end
+
+      # Safe inspection methods to handle problematic objects
+      def safe_inspect(value)
+        value.inspect
+      rescue StandardError => e
+        "[inspect failed: #{e.class.name}]"
+      end
+
+      def safe_class(value)
+        value.class
+      rescue StandardError => e
+        "[class failed: #{e.class.name}]"
+      end
+
+      def safe_keys(value)
+        value.keys
+      rescue StandardError => e
+        "[keys failed: #{e.class.name}]"
+      end
+
+      def safe_length(value)
+        value.length
+      rescue StandardError
+        "[length failed]"
+      end
+
+      def safe_truncate(str, max_length)
+        return str unless str.respond_to?(:length) && str.respond_to?(:[])
+
+        str.length > max_length ? "#{str[0...max_length]}..." : str
+      rescue StandardError => e
+        "[truncate failed: #{e.class.name}]"
+      end
+
+      def safe_to_s(value)
+        value.to_s
+      rescue StandardError => e
+        begin
+          value.class.name
+        rescue StandardError => e2
+          "[to_s failed: #{e.class.name}, class failed: #{e2.class.name}]"
+        end
+      end
+
+      def log_value_details(value, index = nil, level = :verbose)
+        return unless @debug_mode && @level >= LEVELS[level]
+
+        prefix = index ? "Value #{index}" : "Value"
+        log("#{prefix}: #{safe_inspect(value)} (#{safe_class(value)})", level)
+      end
+
+      def log_hash_detection(value, index = nil, level = :detailed)
+        return unless @debug_mode && @level >= LEVELS[level]
+
+        prefix = index ? "Value #{index}" : "Value"
+        is_hash = value.is_a?(Hash)
+        is_real_hash = value.is_a?(Hash) && value.instance_of?(Hash)
+
+        return unless is_hash
+
+        log("#{prefix} hash detection:")
+        log("  is_a?(Hash): #{is_hash}, class == Hash: #{is_real_hash}")
+        log("  respond_to?(:keys): #{value.respond_to?(:keys)}")
+
+        if is_hash && is_real_hash
+          log("  keys: #{safe_keys(value)}")
+        elsif is_hash
+          log_anomaly("Hash-like object (#{safe_class(value)}) but not real Hash - will be skipped")
+        end
+      end
+
+      # Smart hash detection summary
+      def log_hash_detection_summary(values)
+        return unless @debug_mode
+
+        hash_count = 0
+        real_hash_count = 0
+        anomaly_count = 0
+
+        values.each do |value|
+          next unless value.is_a?(Hash)
+
+          hash_count += 1
+          if value.instance_of?(Hash)
+            real_hash_count += 1
+          else
+            anomaly_count += 1
+          end
+        end
+
+        return unless hash_count.positive?
+
+        log("Hash detection summary: #{real_hash_count} real hashes, #{anomaly_count} hash-like objects")
+        log_anomaly("Found #{anomaly_count} hash-like proxy objects") if anomaly_count.positive?
+      end
+
+      def enabled?
+        @debug_mode
+      end
+
+      attr_reader :level
+
+      def set_level(level)
+        @level = LEVELS[level] || LEVELS[:basic]
+      end
+    end
+  end
+end

data/lib/class_metrix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClassMetrix
-  VERSION = "0.1.2"
+  VERSION = "1.0.1"
 end

data/sig/class_metrix.rbs

@@ -0,0 +1,8 @@
+# Main ClassMetrix module
+module ClassMetrix
+  class Error < StandardError
+  end
+
+  # Main entry point for the gem
+  def self.extract: (*Symbol types) -> ClassMetrix::Extractor
+end

data/sig/extractor.rbs

@@ -0,0 +1,54 @@
+# Core extractor class that provides the fluent interface
+module ClassMetrix
+  class Extractor
+    @types: Array[Symbol]
+    @classes: Array[Class]
+    @filters: Array[Regexp | String]
+    @expand_hashes: bool
+    @handle_errors: bool
+    @modules: Array[Module]
+    @include_inherited: bool
+    @include_modules: bool
+    @show_source: bool
+    @hide_main_row: bool
+    @hide_key_rows: bool
+    @debug_mode: bool
+    @debug_level: Symbol
+    @logger: ClassMetrix::Utils::DebugLogger?
+
+    def initialize: (*Symbol types) -> void
+
+    # Core configuration methods
+    def from: (Array[Class] classes) -> self
+    def filter: (Regexp | String pattern) -> self
+    def expand_hashes: () -> self
+    def debug: (?Symbol level) -> self
+    def handle_errors: () -> self
+    def modules: (Array[Module] module_list) -> self
+
+    # Inheritance and module inclusion options
+    def include_inherited: () -> self
+    def include_modules: () -> self
+    def show_source: () -> self
+    def include_all: () -> self
+
+    # Hash expansion display options
+    def show_only_main: () -> self
+    def show_only_keys: () -> self
+    def show_expanded_details: () -> self
+    def hide_main_row: () -> self
+    def hide_key_rows: () -> self
+
+    # Output methods
+    def to_markdown: (?String filename) -> String
+    def to_csv: (?String filename) -> String
+
+    private
+
+    def extract_all_data: () -> Hash[Symbol, untyped]
+    def extract_single_type: (Symbol type) -> Hash[Symbol, untyped]
+    def extract_multiple_types: () -> Hash[Symbol, untyped]
+    def get_extractor: (Symbol type) -> (ClassMetrix::ConstantsExtractor | ClassMetrix::MethodsExtractor)
+    def extraction_options: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/extractors.rbs

@@ -0,0 +1,84 @@
+# Specialized extractor classes
+module ClassMetrix
+  class ConstantsExtractor
+    @classes: Array[Class]
+    @filters: Array[Regexp | String]
+    @handle_errors: bool
+    @options: Hash[Symbol, untyped]
+    @debug_level: Symbol
+    @logger: ClassMetrix::Utils::DebugLogger
+
+    def initialize: (Array[Class] classes, Array[Regexp | String] filters, bool handle_errors, ?Hash[Symbol, untyped] options) -> void
+    def extract: () -> Hash[Symbol, untyped]
+
+    private
+
+    def default_options: () -> Hash[Symbol, untyped]
+    def build_headers: () -> Array[String]
+    def build_rows: (Array[String] constant_names) -> Array[Array[untyped]]
+    def get_all_constant_names: () -> Array[String]
+    def inheritance_or_modules_enabled?: () -> bool
+    def get_comprehensive_constants: (Class klass) -> Array[Symbol]
+    def get_inherited_constants: (Class klass) -> Set[Symbol]
+    def get_module_constants: (Class klass) -> Set[Symbol]
+    def get_all_included_modules: (Class klass) -> Array[Module]
+    def core_class?: (untyped klass) -> bool
+    def apply_filters: (Array[String] constant_names) -> Array[String]
+    def extract_constant_value: (Class klass, String const_name) -> untyped
+    def find_constant_source: (Class klass, String const_name) -> Hash[Symbol, untyped]?
+    def find_inherited_constant: (Class klass, String const_name) -> Hash[Symbol, untyped]?
+    def find_module_constant: (Class klass, String const_name) -> Hash[Symbol, untyped]?
+    def build_constant_info: (untyped value, String source, Symbol type) -> Hash[Symbol, untyped]
+    def debug_log: (String message) -> void
+  end
+
+  class MethodsExtractor
+    @classes: Array[Class]
+    @filters: Array[Regexp | String]
+    @handle_errors: bool
+    @options: Hash[Symbol, untyped]
+
+    def initialize: (Array[Class] classes, Array[Regexp | String] filters, bool handle_errors, ?Hash[Symbol, untyped] options) -> void
+    def extract: () -> Hash[Symbol, untyped]
+
+    private
+
+    def default_options: () -> Hash[Symbol, untyped]
+    def build_headers: () -> Array[String]
+    def build_rows: (Array[String] method_names) -> Array[Array[untyped]]
+    def get_all_class_method_names: () -> Array[String]
+    def inheritance_or_modules_enabled?: () -> bool
+    def get_comprehensive_methods: (Class klass) -> Array[Symbol]
+    def get_inherited_methods: (Class klass) -> Set[Symbol]
+    def get_module_methods: (Class klass) -> Set[Symbol]
+    def excluded_module_method?: (String method_name) -> bool
+    def get_all_singleton_modules: (Class klass) -> Array[Module]
+    def core_class?: (untyped klass) -> bool
+    def core_module?: (untyped mod) -> bool
+    def apply_filters: (Array[String] method_names) -> Array[String]
+    def call_class_method: (Class klass, String method_name) -> untyped
+    def call_method: (Hash[Symbol, untyped] method_info, Class klass, String method_name) -> untyped
+    def find_method_source: (Class klass, String method_name) -> Hash[Symbol, untyped]?
+    def find_inherited_method: (Class klass, Symbol method_sym, String method_name) -> Hash[Symbol, untyped]?
+    def find_module_method: (Class klass, Symbol method_sym, String method_name) -> Hash[Symbol, untyped]?
+    def determine_module_source: (Class klass, Module mod) -> String
+    def build_method_info: (String source, Symbol type, Proc? callable) -> Hash[Symbol, untyped]
+  end
+
+  class MultiTypeExtractor
+    @classes: Array[Class]
+    @types: Array[Symbol]
+    @filters: Array[Regexp | String]
+    @modules: Array[Module]
+    @handle_errors: bool
+    @options: Hash[Symbol, untyped]
+
+    def initialize: (Array[Class] classes, Array[Symbol] types, Array[Regexp | String] filters, ?Hash[Symbol, untyped] extraction_config) -> void
+    def extract: () -> Hash[Symbol, untyped]
+
+    private
+
+    def extract_single_type: (Symbol type) -> Hash[Symbol, untyped]
+    def type_label: (Symbol type) -> String
+  end
+end