class-metrix 0.1.2 → 1.0.1

data/lib/class_metrix/extractors/methods_extractor.rb

@@ -4,54 +4,139 @@ require_relative "../processors/value_processor"
 
 module ClassMetrix
   class MethodsExtractor
-    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)
     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)
+      headers = build_headers
+      rows = build_rows(method_names)
 
-      # Build headers: ["Method", "Class1", "Class2", ...]
-      headers = ["Method"] + @classes.map(&:name)
+      { headers: headers, rows: rows }
+    end
 
-      # Build rows: each row represents one method across all classes
-      rows = method_names.map do |method_name|
-        row = [method_name]
+    private
+
+    def default_options
+      {
+        include_inherited: false,
+        include_modules: false,
+        show_source: false
+      }
+    end
+
+    def build_headers
+      if @options[:show_source]
+        ["Method (Source)"] + @classes.map(&:name)
+      else
+        ["Method"] + @classes.map(&:name)
+      end
+    end
 
+    def build_rows(method_names)
+      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))
+        methods = if inheritance_or_modules_enabled?
+                    get_comprehensive_methods(klass)
+                  else
+                    klass.singleton_methods(false)
+                  end
+        all_methods.merge(methods.map(&:to_s))
       end
 
       all_methods.to_a.sort
     end
 
+    def inheritance_or_modules_enabled?
+      @options[:include_inherited] || @options[:include_modules]
+    end
+
+    def get_comprehensive_methods(klass)
+      methods = Set.new
+      methods.merge(klass.singleton_methods(false))
+
+      methods.merge(get_inherited_methods(klass)) if @options[:include_inherited]
+
+      methods.merge(get_module_methods(klass)) if @options[:include_modules]
+
+      methods.to_a
+    end
+
+    def get_inherited_methods(klass)
+      methods = Set.new
+      parent = klass.superclass
+
+      while parent && !core_class?(parent)
+        methods.merge(parent.singleton_methods(false))
+        parent = parent.superclass
+      end
+
+      methods
+    end
+
+    def get_module_methods(klass)
+      methods = Set.new
+      all_singleton_modules = get_all_singleton_modules(klass)
+
+      all_singleton_modules.each do |mod|
+        next if core_module?(mod)
+
+        module_methods = mod.instance_methods(false).map(&:to_s)
+        # Filter out methods that shouldn't be called directly
+        module_methods = module_methods.reject { |method| excluded_module_method?(method) }
+        methods.merge(module_methods)
+      end
+
+      methods
+    end
+
+    def excluded_module_method?(method_name)
+      # Methods that require arguments or shouldn't be called directly
+      %w[included extended prepended].include?(method_name)
+    end
+
+    def get_all_singleton_modules(klass)
+      modules = [] # : Array[Module]
+      modules.concat(klass.singleton_class.included_modules)
+
+      if @options[:include_inherited]
+        parent = klass.superclass
+        while parent && !core_class?(parent)
+          modules.concat(parent.singleton_class.included_modules)
+          parent = parent.superclass
+        end
+      end
+
+      modules
+    end
+
+    def core_class?(klass)
+      [Object, BasicObject].include?(klass)
+    end
+
+    def core_module?(mod)
+      [Kernel, Module, Class].include?(mod)
+    end
+
     def apply_filters(method_names)
       return method_names if @filters.empty?
 
@@ -72,9 +157,10 @@ module ClassMetrix
     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)
+      method_info = find_method_source(klass, method_name)
+
+      if method_info
+        call_method(method_info, klass, method_name)
       else
         @handle_errors ? ValueProcessor.missing_method : nil
       end
@@ -83,5 +169,84 @@ module ClassMetrix
     rescue StandardError => e
       @handle_errors ? ValueProcessor.handle_extraction_error(e) : (raise e)
     end
+
+    def call_method(method_info, klass, method_name)
+      if method_info[:callable]
+        method_info[:callable].call
+      else
+        klass.public_send(method_name)
+      end
+    end
+
+    def find_method_source(klass, method_name)
+      method_sym = method_name.to_sym
+
+      return nil unless klass.respond_to?(method_name, true)
+
+      # Check own methods first
+      return build_method_info(klass.name, :own, nil) if klass.singleton_methods(false).include?(method_sym)
+
+      # Check inherited methods
+      if @options[:include_inherited]
+        inherited_info = find_inherited_method(klass, method_sym, method_name)
+        return inherited_info if inherited_info
+      end
+
+      # Check module methods
+      if @options[:include_modules]
+        module_info = find_module_method(klass, method_sym, method_name)
+        return module_info if module_info
+      end
+
+      # Fallback for unknown source
+      build_method_info("inherited", :unknown, nil)
+    end
+
+    def find_inherited_method(klass, method_sym, method_name)
+      parent = klass.superclass
+      while parent && !core_class?(parent)
+        if parent.singleton_methods(false).include?(method_sym)
+          parent_class = parent
+          method_to_call = method_name
+          callable = -> { parent_class.public_send(method_to_call) }
+          return build_method_info(parent.name, :inherited, callable)
+        end
+        parent = parent.superclass
+      end
+      nil
+    end
+
+    def find_module_method(klass, method_sym, method_name)
+      all_singleton_modules = get_all_singleton_modules(klass)
+
+      all_singleton_modules.each do |mod|
+        next if core_module?(mod)
+
+        next unless mod.instance_methods(false).include?(method_sym)
+
+        method_to_call = method_name
+        callable = -> { klass.public_send(method_to_call) }
+        source = determine_module_source(klass, mod)
+        return build_method_info(source, :module, callable)
+      end
+
+      nil
+    end
+
+    def determine_module_source(klass, mod)
+      if @options[:include_inherited] && !klass.singleton_class.included_modules.include?(mod)
+        "#{mod.name} (via parent)"
+      else
+        mod.name
+      end
+    end
+
+    def build_method_info(source, type, callable)
+      {
+        source: source,
+        type: type,
+        callable: callable
+      }
+    end
   end
 end

data/lib/class_metrix/extractors/multi_type_extractor.rb

@@ -5,12 +5,13 @@ require_relative "methods_extractor"
 
 module ClassMetrix
   class MultiTypeExtractor
-    def initialize(classes, types, filters, modules, handle_errors)
+    def initialize(classes, types, filters, extraction_config = {})
       @classes = classes
       @types = types
       @filters = filters
-      @modules = modules
-      @handle_errors = handle_errors
+      @modules = extraction_config[:modules] || []
+      @handle_errors = extraction_config[:handle_errors] || false
+      @options = extraction_config[:options] || {}
     end
 
     def extract
@@ -19,7 +20,7 @@ module ClassMetrix
       # Build headers: ["Type", "Behavior", "Class1", "Class2", ...]
       headers = %w[Type Behavior] + @classes.map(&:name)
 
-      all_rows = []
+      all_rows = [] # : Array[Array[untyped]]
 
       @types.each do |type|
         type_data = extract_single_type(type)
@@ -27,7 +28,7 @@ module ClassMetrix
         # Add rows with type prefix
         type_data[:rows].each do |row|
           behavior_name = row[0]
-          values = row[1..]
+          values = row[1..] || []
 
           new_row = [type_label(type), behavior_name] + values
           all_rows << new_row
@@ -42,9 +43,9 @@ module ClassMetrix
     def extract_single_type(type)
       case type
       when :constants
-        ConstantsExtractor.new(@classes, @filters, @handle_errors).extract
+        ConstantsExtractor.new(@classes, @filters, @handle_errors, @options).extract
       when :class_methods
-        MethodsExtractor.new(@classes, @filters, @handle_errors).extract
+        MethodsExtractor.new(@classes, @filters, @handle_errors, @options).extract
       else
         { headers: [], rows: [] }
       end

data/lib/class_metrix/formatters/base/base_formatter.rb

@@ -26,7 +26,7 @@ module ClassMetrix
             # Common options for all formatters
             title: nil,
             show_metadata: true,
-            extraction_types: []
+            extraction_types: [] # : Array[Symbol]
           }
         end
 
@@ -52,11 +52,11 @@ 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
 
           rows.each do |row|
             behavior_name = row[behavior_column_index]
-            values = row[value_start_idx..]
+            values = row[value_start_idx..] || []
 
             values.each do |value|
               if value.is_a?(Hash)

data/lib/class_metrix/formatters/components/footer_component.rb

@@ -16,7 +16,7 @@ module ClassMetrix
         def generate
           return [] unless @show_footer
 
-          output = []
+          output = [] # : Array[String]
 
           # Add separator line
           output << "---" if @show_separator
@@ -36,7 +36,7 @@ module ClassMetrix
         private
 
         def generate_default_footer
-          output = []
+          output = [] # : Array[String]
 
           output << (@custom_footer || "*Report generated by ClassMetrix gem*")
 
@@ -49,11 +49,11 @@ module ClassMetrix
         end
 
         def generate_detailed_footer
-          output = []
+          output = [] # : Array[String]
 
           output << "## Report Information"
           output << ""
-          output << "- **Generated by**: [ClassMetrix gem](https://github.com/your-username/class-metrix)"
+          output << "- **Generated by**: [ClassMetrix gem](https://github.com/patrick204nqh/class-metrix)"
           output << "- **Generated at**: #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}"
           output << "- **Ruby version**: #{RUBY_VERSION}"
 

data/lib/class_metrix/formatters/components/generic_header_component.rb

@@ -30,7 +30,7 @@ module ClassMetrix
         private
 
         def generate_markdown_header
-          output = []
+          output = [] # : Array[String]
 
           # Add title
           if @title
@@ -58,7 +58,7 @@ module ClassMetrix
         end
 
         def generate_csv_header
-          output = []
+          output = [] # : Array[String]
           comment_char = @options.fetch(:comment_char, "#")
 
           # Add title as comment

data/lib/class_metrix/formatters/components/header_component.rb

@@ -15,7 +15,7 @@ module ClassMetrix
         end
 
         def generate
-          output = []
+          output = [] # : Array[String]
 
           # Add title
           output.concat(generate_title) if @title || @show_metadata
@@ -32,7 +32,7 @@ module ClassMetrix
         private
 
         def generate_title
-          output = []
+          output = [] # : Array[String]
 
           if @title
             output << "# #{@title}"
@@ -46,7 +46,7 @@ module ClassMetrix
         end
 
         def generate_classes_section
-          output = []
+          output = [] # : Array[String]
 
           has_type_column = @data[:headers].first == "Type"
           class_headers = if has_type_column
@@ -66,7 +66,7 @@ module ClassMetrix
         end
 
         def generate_extraction_info
-          output = []
+          output = [] # : Array[String]
 
           output << "## Extraction Types"
           output << ""

data/lib/class_metrix/formatters/components/missing_behaviors_component.rb

@@ -9,7 +9,7 @@ module ClassMetrix
           @options = options
           @show_missing_summary = options.fetch(:show_missing_summary, false)
           @summary_style = options.fetch(:summary_style, :grouped) # :grouped, :flat, :detailed
-          @missing_behaviors = {}
+          @missing_behaviors = {} # : Hash[String, Hash[String, String]]
         end
 
         def generate
@@ -30,7 +30,7 @@ module ClassMetrix
                           end
 
           # Initialize missing behaviors tracking with hash to store behavior name and error message
-          class_headers.each { |class_name| @missing_behaviors[class_name] = {} }
+          class_headers.each { |class_name| @missing_behaviors[class_name] = {} } # : Hash[String, Hash[String, String]]
 
           @data[:rows].each do |row|
             behavior_name = has_type_column ? row[1] : row[0]
@@ -63,7 +63,7 @@ module ClassMetrix
         end
 
         def generate_grouped_summary
-          output = []
+          output = [] # : Array[String]
 
           output << "## Missing Behaviors Summary"
           output << ""
@@ -84,12 +84,12 @@ module ClassMetrix
         end
 
         def generate_flat_summary
-          output = []
+          output = [] # : Array[String]
 
           output << "## Missing Behaviors"
           output << ""
 
-          all_missing = []
+          all_missing = [] # : Array[String]
           @missing_behaviors.each do |class_name, behaviors_hash|
             behaviors_hash.each do |behavior_name, error_message|
               all_missing << "- **#{class_name}**: `#{behavior_name}` - #{error_message}"
@@ -103,7 +103,7 @@ module ClassMetrix
         end
 
         def generate_detailed_summary
-          output = []
+          output = [] # : Array[String]
 
           total_missing = @missing_behaviors.values.map(&:size).sum
           total_classes = @missing_behaviors.keys.size
@@ -114,7 +114,7 @@ module ClassMetrix
           output << ""
 
           # Group by error type
-          by_error_type = {}
+          by_error_type = {} # : Hash[String, Array[Hash[Symbol, String]]]
           @missing_behaviors.each do |class_name, behaviors_hash|
             behaviors_hash.each do |behavior_name, error_message|
               error_type = error_message.split.first(2).join(" ") # e.g., "🚫 Not", "⚠️ Error:"

data/lib/class_metrix/formatters/components/table_component/column_width_calculator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class TableComponent
+        class ColumnWidthCalculator
+          def initialize(table_style: :standard, min_column_width: 3, max_column_width: 50)
+            @table_style = table_style
+            @min_column_width = min_column_width
+            @max_column_width = max_column_width
+          end
+
+          def calculate_widths(headers, rows)
+            col_count = headers.length
+            widths = initialize_column_widths(col_count, headers)
+
+            update_widths_from_rows(widths, rows, col_count)
+            apply_minimum_widths(widths)
+          end
+
+          private
+
+          def initialize_column_widths(col_count, headers)
+            widths = Array.new(col_count, 0)
+            headers.each_with_index do |header, i|
+              widths[i] = [widths[i], header.to_s.length].max
+            end
+            widths
+          end
+
+          def update_widths_from_rows(widths, rows, col_count)
+            rows.each do |row|
+              row.each_with_index do |cell, i|
+                next if i >= col_count
+
+                cell_width = calculate_cell_width(cell)
+                widths[i] = [widths[i], cell_width].max
+              end
+            end
+          end
+
+          def calculate_cell_width(cell)
+            cell_width = cell.to_s.length
+            # Apply max width limit for readability
+            @table_style == :compact ? [@max_column_width, cell_width].min : cell_width
+          end
+
+          def apply_minimum_widths(widths)
+            widths.map { |w| [w, @min_column_width].max }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/class_metrix/formatters/components/table_component/row_processor.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../../../processors/value_processor"
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class TableComponent
+        class RowProcessor
+          def initialize(data_extractor, options = {})
+            @data_extractor = data_extractor
+            @hide_main_row = options.fetch(:hide_main_row, false)
+            @hide_key_rows = options.fetch(:hide_key_rows, true) # Default: show only main rows
+          end
+
+          def process_simple_rows(rows)
+            rows.map do |row|
+              processed_row = [row[0]] # Keep the behavior name as-is
+              rest_values = row[1..] || []
+              rest_values.each do |value|
+                processed_row << ValueProcessor.process(value)
+              end
+              processed_row
+            end
+          end
+
+          def process_expanded_rows(rows)
+            expanded_rows = [] # : Array[Array[String]]
+
+            rows.each do |row|
+              if @data_extractor.row_has_expandable_hash?(row)
+                expanded_rows.concat(expand_row(row))
+              else
+                expanded_rows << process_non_hash_row(row)
+              end
+            end
+
+            expanded_rows
+          end
+
+          private
+
+          def process_non_hash_row(row)
+            if @data_extractor.has_type_column?
+              rest_values = row[2..] || []
+              [row[0], row[1]] + rest_values.map { |value| ValueProcessor.process(value) }
+            else
+              rest_values = row[1..] || []
+              [row[0]] + rest_values.map { |value| ValueProcessor.process(value) }
+            end
+          end
+
+          def expand_row(row)
+            row_data = @data_extractor.extract_row_data(row)
+            all_hash_keys = @data_extractor.collect_hash_keys(row_data[:values])
+
+            return [row] if all_hash_keys.empty?
+
+            build_expanded_rows(row_data, all_hash_keys, row)
+          end
+
+          def build_expanded_rows(row_data, all_hash_keys, original_row)
+            expanded_rows = [] # : Array[Array[String]]
+
+            # Add main row if configured to show
+            expanded_rows << build_main_expanded_row(row_data) if should_show_main_row?
+
+            # Add key rows if configured to show
+            expanded_rows.concat(build_key_rows(all_hash_keys, row_data, original_row)) if should_show_key_rows?
+
+            expanded_rows
+          end
+
+          def should_show_main_row?
+            !@hide_main_row
+          end
+
+          def should_show_key_rows?
+            !@hide_key_rows
+          end
+
+          def build_key_rows(all_hash_keys, row_data, original_row)
+            all_hash_keys.to_a.sort.map do |key|
+              build_key_row(key, row_data, original_row)
+            end
+          end
+
+          def build_main_expanded_row(row_data)
+            processed_values = row_data[:values].map { |value| ValueProcessor.process(value) }
+
+            if @data_extractor.has_type_column?
+              [row_data[:type_value], row_data[:behavior_name]] + processed_values
+            else
+              [row_data[:behavior_name]] + processed_values
+            end
+          end
+
+          def build_key_row(key, row_data, original_row)
+            path_name = ".#{key}"
+            key_values = process_key_values(key, row_data[:values], original_row)
+
+            if @data_extractor.has_type_column?
+              ["-", path_name] + key_values
+            else
+              [path_name] + key_values
+            end
+          end
+
+          def process_key_values(key, values, original_row)
+            values.map.with_index do |value, index|
+              if value.is_a?(Hash)
+                extract_hash_value(value, key)
+              else
+                handle_non_hash_value(original_row, index)
+              end
+            end
+          end
+
+          def extract_hash_value(hash, key)
+            has_key = hash.key?(key.to_sym) || hash.key?(key.to_s)
+            if has_key
+              hash_value = hash[key.to_sym] || hash[key.to_s]
+              ValueProcessor.process(hash_value)
+            else
+              "—" # Missing hash key
+            end
+          end
+
+          def handle_non_hash_value(original_row, index)
+            original_value = original_row[@data_extractor.has_type_column? ? (index + 2) : (index + 1)]
+            if original_value.to_s.include?("🚫")
+              "🚫 Not defined"
+            else
+              "—" # Non-hash values don't have this key
+            end
+          end
+        end
+      end
+    end
+  end
+end