class-metrix 0.1.2 → 1.0.1

data/examples/inheritance_and_modules.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/class_metrix"
+
+puts "ClassMetrix: Inheritance & Module Analysis"
+puts "=" * 50
+
+# Example: Service Configuration Analysis
+# This demonstrates analyzing service classes that use inheritance and modules
+
+module Configurable
+  DEFAULT_TIMEOUT = 30
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def configuration
+      { timeout: DEFAULT_TIMEOUT, enabled: true }
+    end
+  end
+end
+
+module Cacheable
+  CACHE_TTL = 3600
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def cache_config
+      { ttl: CACHE_TTL, enabled: true }
+    end
+  end
+end
+
+class BaseService
+  SERVICE_VERSION = "1.0"
+  
+  def self.service_type
+    "base"
+  end
+  
+  def self.health_check
+    { status: "ok", version: SERVICE_VERSION }
+  end
+end
+
+class DatabaseService < BaseService
+  include Configurable
+  
+  SERVICE_NAME = "database"
+  CONNECTION_POOL_SIZE = 5
+  
+  def self.service_type
+    "database"
+  end
+  
+  def self.connection_config
+    { pool_size: CONNECTION_POOL_SIZE, timeout: 60 }
+  end
+end
+
+class CacheService < BaseService
+  include Configurable
+  include Cacheable
+  
+  SERVICE_NAME = "cache" 
+  MAX_MEMORY = "512MB"
+  
+  def self.service_type
+    "cache"
+  end
+  
+  def self.memory_config
+    { max_memory: MAX_MEMORY, eviction_policy: "lru" }
+  end
+end
+
+# Demo the functionality
+services = [DatabaseService, CacheService]
+
+puts "\n1. Basic Analysis (Own Constants Only)"
+puts "-" * 40
+result = ClassMetrix.extract(:constants)
+                   .from(services)
+                   .to_markdown
+puts result
+
+puts "\n2. With Inheritance (Own + Parent Constants)"
+puts "-" * 40
+result = ClassMetrix.extract(:constants)
+                   .from(services)
+                   .include_inherited
+                   .to_markdown
+puts result
+
+puts "\n3. With Modules (Own + Module Constants)"
+puts "-" * 40
+result = ClassMetrix.extract(:constants)
+                   .from(services)
+                   .include_modules
+                   .to_markdown
+puts result
+
+puts "\n4. Complete Analysis (Own + Inherited + Modules)"
+puts "-" * 40
+result = ClassMetrix.extract(:constants, :class_methods)
+                   .from(services)
+                   .include_all
+                   .handle_errors
+                   .to_markdown
+puts result
+
+puts "\n5. Filtered Configuration Analysis"
+puts "-" * 40
+result = ClassMetrix.extract(:constants, :class_methods)
+                   .from(services)
+                   .include_all
+                   .filter(/config|timeout|service/i)
+                   .expand_hashes
+                   .to_markdown
+puts result
+
+puts "\n6. Hash Expansion Modes"
+puts "-" * 40
+
+puts "\n6a. Default: Show Only Main Rows (Collapsed Hashes)"
+result = ClassMetrix.extract(:class_methods)
+                   .from([CacheService])
+                   .filter(/config/)
+                   .expand_hashes
+                   .to_markdown
+puts result
+
+puts "\n6b. Show Only Key Rows (Expanded Details)"
+result = ClassMetrix.extract(:class_methods)
+                   .from([CacheService])
+                   .filter(/config/)
+                   .expand_hashes
+                   .show_only_keys
+                   .to_markdown
+puts result
+
+puts "\n6c. Show Both Main and Key Rows"
+result = ClassMetrix.extract(:class_methods)
+                   .from([CacheService])
+                   .filter(/config/)
+                   .expand_hashes
+                   .show_expanded_details
+                   .to_markdown
+puts result 

data/lib/class_metrix/extractor.rb

@@ -6,6 +6,7 @@ require_relative "extractors/multi_type_extractor"
 require_relative "formatters/markdown_formatter"
 require_relative "formatters/csv_formatter"
 require_relative "utils/class_resolver"
+require_relative "utils/debug_logger"
 
 module ClassMetrix
   class Extractor
@@ -16,10 +17,19 @@ module ClassMetrix
       @expand_hashes = false
       @handle_errors = false
       @modules = []
+      @include_inherited = false
+      @include_modules = false
+      @show_source = false
+      @hide_main_row = false
+      @hide_key_rows = true # Default: show only main rows
+      @debug_mode = false
+      @debug_level = :basic
+      @logger = nil # Will be initialized when debug mode is enabled
     end
 
     def from(classes)
       @classes = ClassResolver.normalize_classes(classes)
+      @logger&.log("Normalized classes: #{@classes.map(&:name)}")
       self
     end
 
@@ -30,6 +40,15 @@ module ClassMetrix
 
     def expand_hashes
       @expand_hashes = true
+      @logger&.log("Hash expansion enabled")
+      self
+    end
+
+    def debug(level = :basic)
+      @debug_mode = true
+      @debug_level = level
+      @logger = Utils::DebugLogger.new("Extractor", @debug_mode, level)
+      @logger&.log("Debug mode enabled (level: #{level})")
       self
     end
 
@@ -43,10 +62,63 @@ module ClassMetrix
       self
     end
 
+    # Inheritance and module inclusion options
+    def include_inherited
+      @include_inherited = true
+      self
+    end
+
+    def include_modules
+      @include_modules = true
+      self
+    end
+
+    def show_source
+      @show_source = true
+      self
+    end
+
+    def include_all
+      @include_inherited = true
+      @include_modules = true
+      self
+    end
+
+    # Hash expansion display options
+    def show_only_main
+      @hide_main_row = false
+      @hide_key_rows = true
+      self
+    end
+
+    def show_only_keys
+      @hide_main_row = true
+      @hide_key_rows = false
+      self
+    end
+
+    def show_expanded_details
+      @hide_main_row = false
+      @hide_key_rows = false
+      self
+    end
+
+    # Lower-level options (for advanced usage)
+    def hide_main_row
+      @hide_main_row = true
+      self
+    end
+
+    def hide_key_rows
+      @hide_key_rows = true
+      self
+    end
+
     def to_markdown(filename = nil, **options)
+      @logger&.log("Starting markdown generation...")
       data = extract_all_data
+      @logger&.log("Extracted data structure with #{data[:rows]&.length || 0} rows")
 
-      # Merge default options with passed options
       format_options = {
         extraction_types: @types,
         show_missing_summary: false,
@@ -57,7 +129,11 @@ module ClassMetrix
         show_classes: true,
         show_extraction_info: true,
         table_style: :standard,
-        summary_style: :grouped
+        summary_style: :grouped,
+        hide_main_row: @hide_main_row,
+        hide_key_rows: @hide_key_rows,
+        debug_mode: @debug_mode,
+        debug_level: @debug_level
       }.merge(options)
 
       formatted = MarkdownFormatter.new(data, @expand_hashes, format_options).format
@@ -67,9 +143,9 @@ module ClassMetrix
     end
 
     def to_csv(filename = nil, **options)
+      @logger&.log("Starting CSV generation...")
       data = extract_all_data
 
-      # Merge default options with passed options
       format_options = {
         extraction_types: @types,
         show_metadata: true,
@@ -77,7 +153,11 @@ module ClassMetrix
         quote_char: '"',
         flatten_hashes: true,
         null_value: "",
-        comment_char: "#"
+        comment_char: "#",
+        hide_main_row: @hide_main_row,
+        hide_key_rows: @hide_key_rows,
+        debug_mode: @debug_mode,
+        debug_level: @debug_level
       }.merge(options)
 
       formatted = CsvFormatter.new(data, @expand_hashes, format_options).format
@@ -89,7 +169,7 @@ module ClassMetrix
     private
 
     def extract_all_data
-      # Handle single or multiple extraction types
+      @logger&.log("Extracting data for types: #{@types}")
       if @types.size == 1
         extract_single_type(@types.first)
       else
@@ -98,24 +178,39 @@ module ClassMetrix
     end
 
     def extract_single_type(type)
-      extractor = get_extractor(type)
-      extractor.extract
+      @logger&.log("Extracting single type: #{type}")
+      get_extractor(type).extract
     end
 
     def extract_multiple_types
-      # Combine multiple extraction types into one table
-      MultiTypeExtractor.new(@classes, @types, @filters, @modules, @handle_errors).extract
+      @logger&.log("Extracting multiple types: #{@types}")
+      extraction_config = {
+        modules: @modules,
+        handle_errors: @handle_errors,
+        options: extraction_options
+      }
+      MultiTypeExtractor.new(@classes, @types, @filters, extraction_config).extract
     end
 
     def get_extractor(type)
       case type
       when :constants
-        ConstantsExtractor.new(@classes, @filters, @handle_errors)
+        ConstantsExtractor.new(@classes, @filters, @handle_errors, extraction_options)
       when :class_methods
-        MethodsExtractor.new(@classes, @filters, @handle_errors)
+        MethodsExtractor.new(@classes, @filters, @handle_errors, extraction_options)
       else
         raise ArgumentError, "Unknown extraction type: #{type}"
       end
     end
+
+    def extraction_options
+      {
+        include_inherited: @include_inherited,
+        include_modules: @include_modules,
+        show_source: @show_source,
+        debug_mode: @debug_mode,
+        debug_level: @debug_level
+      }
+    end
   end
 end

data/lib/class_metrix/extractors/constants_extractor.rb

@@ -1,57 +1,131 @@
 # frozen_string_literal: true
 
 require_relative "../processors/value_processor"
+require_relative "../utils/debug_logger"
 
 module ClassMetrix
   class ConstantsExtractor
-    def initialize(classes, filters, handle_errors)
+    def initialize(classes, filters, handle_errors, options = {})
       @classes = classes
       @filters = filters
       @handle_errors = handle_errors
+      @options = default_options.merge(options)
+      @debug_level = @options[:debug_level] || :basic
+      @logger = Utils::DebugLogger.new("ConstantsExtractor", @options[:debug_mode], @debug_level)
     end
 
     def extract
       return { headers: [], rows: [] } if @classes.empty?
 
-      # Get all constant names across all classes
       constant_names = get_all_constant_names
-
-      # Apply filters
       constant_names = apply_filters(constant_names)
+      headers = build_headers
+      rows = build_rows(constant_names)
 
-      # Build headers: ["Constant", "Class1", "Class2", ...]
-      headers = ["Constant"] + @classes.map(&:name)
+      { headers: headers, rows: rows }
+    end
 
-      # Build rows: each row represents one constant across all classes
-      rows = constant_names.map do |const_name|
-        row = [const_name]
+    private
+
+    def default_options
+      {
+        include_inherited: false,
+        include_modules: false,
+        show_source: false
+      }
+    end
+
+    def build_headers
+      if @options[:show_source]
+        ["Constant (Source)"] + @classes.map(&:name)
+      else
+        ["Constant"] + @classes.map(&:name)
+      end
+    end
 
+    def build_rows(constant_names)
+      constant_names.map do |const_name|
+        row = [const_name]
         @classes.each do |klass|
           value = extract_constant_value(klass, const_name)
-          # Pass the raw value for hash expansion to work properly
           row << value
         end
-
         row
       end
-
-      { headers: headers, rows: rows }
     end
 
-    private
-
     def get_all_constant_names
       all_constants = Set.new
 
       @classes.each do |klass|
-        # Get constants defined directly in this class (not inherited)
-        class_constants = klass.constants(false)
-        all_constants.merge(class_constants.map(&:to_s))
+        constants = if inheritance_or_modules_enabled?
+                      get_comprehensive_constants(klass)
+                    else
+                      klass.constants(false)
+                    end
+        all_constants.merge(constants.map(&:to_s))
       end
 
       all_constants.to_a.sort
     end
 
+    def inheritance_or_modules_enabled?
+      @options[:include_inherited] || @options[:include_modules]
+    end
+
+    def get_comprehensive_constants(klass)
+      constants = Set.new
+      constants.merge(klass.constants(false))
+
+      constants.merge(get_inherited_constants(klass)) if @options[:include_inherited]
+
+      constants.merge(get_module_constants(klass)) if @options[:include_modules]
+
+      constants.to_a
+    end
+
+    def get_inherited_constants(klass)
+      constants = Set.new
+      parent = klass.superclass
+
+      while parent && !core_class?(parent)
+        constants.merge(parent.constants(false))
+        parent = parent.superclass
+      end
+
+      constants
+    end
+
+    def get_module_constants(klass)
+      constants = Set.new
+      all_modules = get_all_included_modules(klass)
+
+      all_modules.each do |mod|
+        constants.merge(mod.constants(false))
+      end
+
+      constants
+    end
+
+    def get_all_included_modules(klass)
+      modules = [] # : Array[Module]
+      modules.concat(klass.included_modules)
+
+      if @options[:include_inherited]
+        parent = klass.superclass
+        while parent && !core_class?(parent)
+          modules.concat(parent.included_modules)
+          parent = parent.superclass
+        end
+      end
+
+      modules
+    end
+
+    def core_class?(klass)
+      [Object, BasicObject].include?(klass)
+    end
+
     def apply_filters(constant_names)
       return constant_names if @filters.empty?
 
@@ -72,16 +146,76 @@ module ClassMetrix
     end
 
     def extract_constant_value(klass, const_name)
-      # Check if constant exists before trying to get it
-      if klass.const_defined?(const_name, false)
-        klass.const_get(const_name)
+      constant_info = find_constant_source(klass, const_name)
+
+      if constant_info
+        value = constant_info[:value]
+        debug_log("Extracted constant '#{const_name}' from #{klass.name}: #{@logger.safe_inspect(value)} (#{@logger.safe_class(value)})")
+        value
       else
+        debug_log("Constant '#{const_name}' not found in #{klass.name}")
         @handle_errors ? ValueProcessor.missing_constant : nil
       end
     rescue NameError => e
+      debug_log("NameError extracting constant '#{const_name}' from #{klass.name}: #{e.message}")
       @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
     rescue StandardError => e
+      debug_log("Error extracting constant '#{const_name}' from #{klass.name}: #{e.message}")
       @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
     end
+
+    def find_constant_source(klass, const_name)
+      # Check own constants first
+      return build_constant_info(klass.const_get(const_name), klass.name, :own) if klass.const_defined?(const_name, false)
+
+      # Check inherited constants
+      if @options[:include_inherited]
+        inherited_info = find_inherited_constant(klass, const_name)
+        return inherited_info if inherited_info
+      end
+
+      # Check module constants
+      if @options[:include_modules]
+        module_info = find_module_constant(klass, const_name)
+        return module_info if module_info
+      end
+
+      # Fallback check with inheritance
+      return build_constant_info(klass.const_get(const_name), "inherited", :unknown) if klass.const_defined?(const_name, true)
+
+      nil
+    end
+
+    def find_inherited_constant(klass, const_name)
+      parent = klass.superclass
+      while parent && !core_class?(parent)
+        return build_constant_info(parent.const_get(const_name), parent.name, :inherited) if parent.const_defined?(const_name, false)
+
+        parent = parent.superclass
+      end
+      nil
+    end
+
+    def find_module_constant(klass, const_name)
+      all_modules = get_all_included_modules(klass)
+
+      all_modules.each do |mod|
+        return build_constant_info(mod.const_get(const_name), mod.name, :module) if mod.const_defined?(const_name, false)
+      end
+
+      nil
+    end
+
+    def build_constant_info(value, source, type)
+      {
+        value: value,
+        source: source,
+        type: type
+      }
+    end
+
+    def debug_log(message)
+      @logger.log(message)
+    end
   end
 end