class-metrix 0.1.2 → 1.0.0

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 = []
+      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
@@ -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/components/footer_component.rb

@@ -53,7 +53,7 @@ module ClassMetrix
 
           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/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,138 @@
+# 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
+              row[1..].each do |value|
+                processed_row << ValueProcessor.process(value)
+              end
+              processed_row
+            end
+          end
+
+          def process_expanded_rows(rows)
+            expanded_rows = []
+
+            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?
+              [row[0], row[1]] + row[2..].map { |value| ValueProcessor.process(value) }
+            else
+              [row[0]] + row[1..].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 = []
+
+            # 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

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class TableComponent
+        class TableDataExtractor
+          def initialize(headers)
+            @headers = headers
+          end
+
+          def has_type_column?
+            @headers.first == "Type"
+          end
+
+          def value_start_index
+            has_type_column? ? 2 : 1
+          end
+
+          def behavior_column_index
+            has_type_column? ? 1 : 0
+          end
+
+          def extract_row_data(row)
+            if has_type_column?
+              {
+                type_value: row[0],
+                behavior_name: row[1],
+                values: row[2..]
+              }
+            else
+              {
+                behavior_name: row[0],
+                values: row[1..]
+              }
+            end
+          end
+
+          def row_has_expandable_hash?(row)
+            row[value_start_index..].any? { |cell| cell.is_a?(Hash) }
+          end
+
+          def collect_hash_keys(values)
+            all_hash_keys = Set.new
+            values.each do |value|
+              all_hash_keys.merge(value.keys.map(&:to_s)) if value.is_a?(Hash)
+            end
+            all_hash_keys
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class TableComponent
+        class TableRenderer
+          def initialize(table_style: :standard, max_column_width: 50)
+            @table_style = table_style
+            @max_column_width = max_column_width
+          end
+
+          def render_table(headers, rows, column_widths)
+            output = []
+            output << build_row(headers, column_widths)
+            output << build_separator(column_widths)
+
+            rows.each do |row|
+              output << build_row(row, column_widths)
+            end
+
+            output.join("\n")
+          end
+
+          private
+
+          def build_row(cells, col_widths)
+            formatted_cells = format_cells(cells, col_widths)
+            "|#{formatted_cells.join("|")}|"
+          end
+
+          def format_cells(cells, col_widths)
+            cells.each_with_index.map do |cell, i|
+              width = col_widths[i] || 10
+              cell_str = format_cell_content(cell)
+              " #{cell_str.ljust(width)} "
+            end
+          end
+
+          def format_cell_content(cell)
+            cell_str = cell.to_s
+            return cell_str unless @table_style == :compact && cell_str.length > @max_column_width
+
+            "#{cell_str[0...(@max_column_width - 3)]}..."
+          end
+
+          def build_separator(col_widths)
+            separators = col_widths.map { |width| "-" * (width + 2) }
+            "|#{separators.join("|")}|"
+          end
+        end
+      end
+    end
+  end
+end