class-metrix 0.1.2

data/examples/real_world/microservices_audit.rb

@@ -0,0 +1,312 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../../lib/class_metrix"
+
+puts "=== Real-World Example: Microservices Configuration Audit ==="
+puts
+
+# Realistic microservice configuration classes
+class UserService
+  # Service metadata
+  SERVICE_NAME = "user-service"
+  VERSION = "2.1.0"
+  PORT = 8001
+  ENVIRONMENT = "production"
+
+  # Feature flags
+  ENABLE_CACHING = true
+  ENABLE_METRICS = true
+  ENABLE_TRACING = false
+  RATE_LIMITING_ENABLED = true
+
+  # Configuration methods
+  def self.database_config
+    {
+      host: "user-db.internal",
+      port: 5432,
+      database: "users_production",
+      pool_size: 20,
+      timeout: 30,
+      ssl: true,
+      backup_enabled: true
+    }
+  end
+
+  def self.redis_config
+    {
+      host: "user-redis.internal",
+      port: 6379,
+      database: 0,
+      timeout: 5,
+      max_connections: 50
+    }
+  end
+
+  def self.rate_limit_config
+    {
+      requests_per_minute: 1000,
+      burst_size: 100,
+      enabled: true
+    }
+  end
+
+  def self.health_status
+    "healthy"
+  end
+
+  def self.memory_usage_mb
+    512
+  end
+
+  def self.active_connections
+    45
+  end
+end
+
+class OrderService
+  # Service metadata
+  SERVICE_NAME = "order-service"
+  VERSION = "1.8.5"
+  PORT = 8002
+  ENVIRONMENT = "production"
+
+  # Feature flags
+  ENABLE_CACHING = true
+  ENABLE_METRICS = true
+  ENABLE_TRACING = true
+  RATE_LIMITING_ENABLED = true
+
+  # Configuration methods
+  def self.database_config
+    {
+      host: "order-db.internal",
+      port: 5432,
+      database: "orders_production",
+      pool_size: 30,
+      timeout: 45,
+      ssl: true,
+      backup_enabled: true,
+      read_replicas: 2
+    }
+  end
+
+  def self.redis_config
+    {
+      host: "order-redis.internal",
+      port: 6379,
+      database: 1,
+      timeout: 3,
+      max_connections: 100,
+      cluster_enabled: true
+    }
+  end
+
+  def self.rate_limit_config
+    {
+      requests_per_minute: 500,
+      burst_size: 50,
+      enabled: true,
+      premium_multiplier: 2.0
+    }
+  end
+
+  def self.health_status
+    "healthy"
+  end
+
+  def self.memory_usage_mb
+    768
+  end
+
+  def self.active_connections
+    127
+  end
+
+  def self.queue_size
+    42
+  end
+end
+
+class PaymentService
+  # Service metadata
+  SERVICE_NAME = "payment-service"
+  VERSION = "3.0.1"
+  PORT = 8003
+  ENVIRONMENT = "production"
+
+  # Feature flags
+  ENABLE_CACHING = false # Disabled for security
+  ENABLE_METRICS = true
+  ENABLE_TRACING = true
+  RATE_LIMITING_ENABLED = true
+
+  # Configuration methods
+  def self.database_config
+    {
+      host: "payment-db.internal",
+      port: 5432,
+      database: "payments_production",
+      pool_size: 15,
+      timeout: 60,
+      ssl: true,
+      backup_enabled: true,
+      encryption: "AES-256"
+    }
+  end
+
+  def self.redis_config
+    {
+      host: "payment-redis.internal",
+      port: 6379,
+      database: 2,
+      timeout: 2,
+      max_connections: 25,
+      ssl: true
+    }
+  end
+
+  def self.rate_limit_config
+    {
+      requests_per_minute: 100,
+      burst_size: 10,
+      enabled: true,
+      strict_mode: true
+    }
+  end
+
+  def self.health_status
+    "healthy"
+  end
+
+  def self.memory_usage_mb
+    256
+  end
+
+  def self.active_connections
+    12
+  end
+
+  def self.encryption_status
+    "AES-256-GCM"
+  end
+end
+
+puts "=== Microservices Defined ==="
+puts "UserService, OrderService, PaymentService"
+puts "Each service has metadata, feature flags, and configuration methods"
+puts
+
+# 1. Service Overview
+puts "🏢 1. SERVICE OVERVIEW"
+puts "=" * 70
+result = ClassMetrix.extract(:constants)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/SERVICE_NAME|VERSION|PORT|ENVIRONMENT/)
+                    .to_markdown
+
+puts result
+puts
+
+# 2. Feature Flags Comparison
+puts "🚩 2. FEATURE FLAGS COMPARISON"
+puts "=" * 70
+result = ClassMetrix.extract(:constants)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/ENABLE_|RATE_LIMITING/)
+                    .to_markdown
+
+puts result
+puts
+
+# 3. Database Configuration Analysis
+puts "🗄️ 3. DATABASE CONFIGURATION ANALYSIS"
+puts "=" * 70
+result = ClassMetrix.extract(:class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/database_config/)
+                    .expand_hashes
+                    .to_markdown
+
+puts result
+puts
+
+# 4. Redis Configuration Comparison
+puts "🔴 4. REDIS CONFIGURATION COMPARISON"
+puts "=" * 70
+result = ClassMetrix.extract(:class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/redis_config/)
+                    .expand_hashes
+                    .to_markdown
+
+puts result
+puts
+
+# 5. Rate Limiting Configuration
+puts "⚡ 5. RATE LIMITING CONFIGURATION"
+puts "=" * 70
+result = ClassMetrix.extract(:class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/rate_limit_config/)
+                    .expand_hashes
+                    .to_markdown
+
+puts result
+puts
+
+# 6. Service Health & Performance
+puts "📊 6. SERVICE HEALTH & PERFORMANCE METRICS"
+puts "=" * 70
+result = ClassMetrix.extract(:class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/health_status|memory_usage|active_connections/)
+                    .to_markdown
+
+puts result
+puts
+
+# 7. Security Features
+puts "🔒 7. SECURITY FEATURES ANALYSIS"
+puts "=" * 70
+result = ClassMetrix.extract(:constants, :class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .filter(/CACHING|ssl|encryption/)
+                    .to_markdown
+
+puts result
+puts
+
+# 8. Complete Configuration Audit
+puts "📋 8. COMPLETE CONFIGURATION AUDIT"
+puts "=" * 70
+result = ClassMetrix.extract(:constants, :class_methods)
+                    .from([UserService, OrderService, PaymentService])
+                    .handle_errors
+                    .expand_hashes
+                    .to_markdown
+
+puts "Full audit contains #{result.lines.count} lines"
+puts "Saving to microservices_audit_report.md..."
+
+# Save comprehensive report
+ClassMetrix.extract(:constants, :class_methods)
+           .from([UserService, OrderService, PaymentService])
+           .handle_errors
+           .expand_hashes
+           .to_markdown("microservices_audit_report.md")
+
+puts "✅ Complete audit saved to: microservices_audit_report.md"
+puts
+
+puts "🎯 Real-World Use Cases Demonstrated:"
+puts "• Service metadata comparison across microservices"
+puts "• Feature flag consistency analysis"
+puts "• Database configuration standardization check"
+puts "• Cache configuration comparison"
+puts "• Rate limiting policy analysis"
+puts "• Performance metrics monitoring"
+puts "• Security configuration audit"
+puts "• Complete infrastructure overview"
+puts "• Configuration drift detection"
+puts "• Compliance reporting"

data/lib/class_metrix/extractor.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "extractors/constants_extractor"
+require_relative "extractors/methods_extractor"
+require_relative "extractors/multi_type_extractor"
+require_relative "formatters/markdown_formatter"
+require_relative "formatters/csv_formatter"
+require_relative "utils/class_resolver"
+
+module ClassMetrix
+  class Extractor
+    def initialize(*types)
+      @types = types.flatten
+      @classes = []
+      @filters = []
+      @expand_hashes = false
+      @handle_errors = false
+      @modules = []
+    end
+
+    def from(classes)
+      @classes = ClassResolver.normalize_classes(classes)
+      self
+    end
+
+    def filter(pattern)
+      @filters << pattern
+      self
+    end
+
+    def expand_hashes
+      @expand_hashes = true
+      self
+    end
+
+    def handle_errors
+      @handle_errors = true
+      self
+    end
+
+    def modules(module_list)
+      @modules = module_list
+      self
+    end
+
+    def to_markdown(filename = nil, **options)
+      data = extract_all_data
+
+      # Merge default options with passed options
+      format_options = {
+        extraction_types: @types,
+        show_missing_summary: false,
+        show_footer: true,
+        footer_style: :default,
+        show_timestamp: false,
+        show_metadata: true,
+        show_classes: true,
+        show_extraction_info: true,
+        table_style: :standard,
+        summary_style: :grouped
+      }.merge(options)
+
+      formatted = MarkdownFormatter.new(data, @expand_hashes, format_options).format
+
+      File.write(filename, formatted) if filename
+      formatted
+    end
+
+    def to_csv(filename = nil, **options)
+      data = extract_all_data
+
+      # Merge default options with passed options
+      format_options = {
+        extraction_types: @types,
+        show_metadata: true,
+        separator: ",",
+        quote_char: '"',
+        flatten_hashes: true,
+        null_value: "",
+        comment_char: "#"
+      }.merge(options)
+
+      formatted = CsvFormatter.new(data, @expand_hashes, format_options).format
+
+      File.write(filename, formatted) if filename
+      formatted
+    end
+
+    private
+
+    def extract_all_data
+      # Handle single or multiple extraction types
+      if @types.size == 1
+        extract_single_type(@types.first)
+      else
+        extract_multiple_types
+      end
+    end
+
+    def extract_single_type(type)
+      extractor = get_extractor(type)
+      extractor.extract
+    end
+
+    def extract_multiple_types
+      # Combine multiple extraction types into one table
+      MultiTypeExtractor.new(@classes, @types, @filters, @modules, @handle_errors).extract
+    end
+
+    def get_extractor(type)
+      case type
+      when :constants
+        ConstantsExtractor.new(@classes, @filters, @handle_errors)
+      when :class_methods
+        MethodsExtractor.new(@classes, @filters, @handle_errors)
+      else
+        raise ArgumentError, "Unknown extraction type: #{type}"
+      end
+    end
+  end
+end

data/lib/class_metrix/extractors/constants_extractor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../processors/value_processor"
+
+module ClassMetrix
+  class ConstantsExtractor
+    def initialize(classes, filters, handle_errors)
+      @classes = classes
+      @filters = filters
+      @handle_errors = handle_errors
+    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)
+
+      # Build headers: ["Constant", "Class1", "Class2", ...]
+      headers = ["Constant"] + @classes.map(&:name)
+
+      # Build rows: each row represents one constant across all classes
+      rows = 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))
+      end
+
+      all_constants.to_a.sort
+    end
+
+    def apply_filters(constant_names)
+      return constant_names if @filters.empty?
+
+      @filters.each do |filter|
+        constant_names = constant_names.select do |name|
+          case filter
+          when Regexp
+            name.match?(filter)
+          when String
+            name.include?(filter)
+          else
+            false
+          end
+        end
+      end
+
+      constant_names
+    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)
+      else
+        @handle_errors ? ValueProcessor.missing_constant : nil
+      end
+    rescue NameError => e
+      @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
+    rescue StandardError => e
+      @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
+    end
+  end
+end

data/lib/class_metrix/extractors/methods_extractor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../processors/value_processor"
+
+module ClassMetrix
+  class MethodsExtractor
+    def initialize(classes, filters, handle_errors)
+      @classes = classes
+      @filters = filters
+      @handle_errors = handle_errors
+    end
+
+    def extract
+      return { headers: [], rows: [] } if @classes.empty?
+
+      # Get all class method names across all classes
+      method_names = get_all_class_method_names
+
+      # Apply filters
+      method_names = apply_filters(method_names)
+
+      # Build headers: ["Method", "Class1", "Class2", ...]
+      headers = ["Method"] + @classes.map(&:name)
+
+      # Build rows: each row represents one method across all classes
+      rows = method_names.map do |method_name|
+        row = [method_name]
+
+        @classes.each do |klass|
+          value = call_class_method(klass, method_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_class_method_names
+      all_methods = Set.new
+
+      @classes.each do |klass|
+        # Get class methods (singleton methods)
+        class_methods = klass.singleton_methods(false)
+        all_methods.merge(class_methods.map(&:to_s))
+      end
+
+      all_methods.to_a.sort
+    end
+
+    def apply_filters(method_names)
+      return method_names if @filters.empty?
+
+      @filters.each do |filter|
+        method_names = method_names.select do |name|
+          case filter
+          when Regexp
+            name.match?(filter)
+          when String
+            name.include?(filter)
+          else
+            false
+          end
+        end
+      end
+
+      method_names
+    end
+
+    def call_class_method(klass, method_name)
+      # Check if the method exists and is callable
+      if klass.respond_to?(method_name, true)
+        klass.public_send(method_name)
+      else
+        @handle_errors ? ValueProcessor.missing_method : nil
+      end
+    rescue NoMethodError => e
+      @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
+    rescue StandardError => e
+      @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
+    end
+  end
+end

data/lib/class_metrix/extractors/multi_type_extractor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "constants_extractor"
+require_relative "methods_extractor"
+
+module ClassMetrix
+  class MultiTypeExtractor
+    def initialize(classes, types, filters, modules, handle_errors)
+      @classes = classes
+      @types = types
+      @filters = filters
+      @modules = modules
+      @handle_errors = handle_errors
+    end
+
+    def extract
+      return { headers: [], rows: [] } if @classes.empty? || @types.empty?
+
+      # Build headers: ["Type", "Behavior", "Class1", "Class2", ...]
+      headers = %w[Type Behavior] + @classes.map(&:name)
+
+      all_rows = []
+
+      @types.each do |type|
+        type_data = extract_single_type(type)
+
+        # Add rows with type prefix
+        type_data[:rows].each do |row|
+          behavior_name = row[0]
+          values = row[1..]
+
+          new_row = [type_label(type), behavior_name] + values
+          all_rows << new_row
+        end
+      end
+
+      { headers: headers, rows: all_rows }
+    end
+
+    private
+
+    def extract_single_type(type)
+      case type
+      when :constants
+        ConstantsExtractor.new(@classes, @filters, @handle_errors).extract
+      when :class_methods
+        MethodsExtractor.new(@classes, @filters, @handle_errors).extract
+      else
+        { headers: [], rows: [] }
+      end
+    end
+
+    def type_label(type)
+      case type
+      when :constants
+        "Constant"
+      when :class_methods
+        "Class Method"
+      when :module_methods
+        "Module Method"
+      else
+        type.to_s.split("_").map(&:capitalize).join(" ")
+      end
+    end
+  end
+end