class-metrix 0.1.2 → 1.0.0

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

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../../processors/value_processor"
+require_relative "table_component/table_data_extractor"
+require_relative "table_component/row_processor"
+require_relative "table_component/column_width_calculator"
+require_relative "table_component/table_renderer"
 
 module ClassMetrix
   module Formatters
@@ -10,257 +13,40 @@ module ClassMetrix
           @data = data
           @options = options
           @expand_hashes = options.fetch(:expand_hashes, false)
-          @table_style = options.fetch(:table_style, :standard) # :standard, :compact, :wide
+          @table_style = options.fetch(:table_style, :standard)
           @min_column_width = options.fetch(:min_column_width, 3)
           @max_column_width = options.fetch(:max_column_width, 50)
+          @hide_main_row = options.fetch(:hide_main_row, false)
+          @hide_key_rows = options.fetch(:hide_key_rows, true) # Default: show only main rows
+
+          # Initialize helper objects
+          @data_extractor = TableDataExtractor.new(@data[:headers])
+          @row_processor = RowProcessor.new(@data_extractor,
+                                            hide_main_row: @hide_main_row,
+                                            hide_key_rows: @hide_key_rows)
+          @width_calculator = ColumnWidthCalculator.new(
+            table_style: @table_style,
+            min_column_width: @min_column_width,
+            max_column_width: @max_column_width
+          )
+          @renderer = TableRenderer.new(
+            table_style: @table_style,
+            max_column_width: @max_column_width
+          )
         end
 
         def generate
           return "" if @data[:headers].empty? || @data[:rows].empty?
 
-          if @expand_hashes
-            format_with_hash_expansion
-          else
-            format_simple_table
-          end
-        end
-
-        private
-
-        def format_simple_table
-          headers = @data[:headers]
-          rows = @data[:rows]
-
-          processed_rows = process_simple_rows(rows)
-          build_table(headers, processed_rows)
-        end
-
-        def format_with_hash_expansion
           headers = @data[:headers]
-          rows = @data[:rows]
-
-          expanded_rows = process_expanded_rows(rows, headers)
-          build_table(headers, expanded_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, headers)
-          expanded_rows = []
-
-          rows.each do |row|
-            if row_has_expandable_hash?(row, headers)
-              expanded_rows.concat(expand_row(row, headers))
-            else
-              expanded_rows << process_non_hash_row(row, headers)
-            end
-          end
-
-          expanded_rows
-        end
-
-        def row_has_expandable_hash?(row, headers)
-          has_type_column = headers.first == "Type"
-          value_start_index = has_type_column ? 2 : 1
-          row[value_start_index..].any? { |cell| cell.is_a?(Hash) }
-        end
-
-        def process_non_hash_row(row, headers)
-          has_type_column = headers.first == "Type"
-          if 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 build_table(headers, rows)
-          col_widths = calculate_column_widths(headers, rows)
-
-          output = []
-          output << build_row(headers, col_widths)
-          output << build_separator(col_widths)
-
-          rows.each do |row|
-            output << build_row(row, col_widths)
-          end
-
-          output.join("\n")
-        end
-
-        def expand_row(row, headers)
-          has_type_column = headers.first == "Type"
-          row_data = extract_row_data(row, has_type_column)
-
-          all_hash_keys = collect_hash_keys(row_data[:values])
-          return [row] if all_hash_keys.empty?
-
-          build_expanded_rows(row_data, all_hash_keys, has_type_column, row)
-        end
-
-        def extract_row_data(row, has_type_column)
-          if has_type_column
-            build_type_column_data(row)
-          else
-            build_standard_column_data(row)
-          end
-        end
-
-        def build_type_column_data(row)
-          {
-            type_value: row[0],
-            behavior_name: row[1],
-            values: row[2..]
-          }
-        end
-
-        def build_standard_column_data(row)
-          {
-            behavior_name: row[0],
-            values: row[1..]
-          }
-        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
-
-        def build_expanded_rows(row_data, all_hash_keys, has_type_column, original_row)
-          expanded_rows = []
-
-          # Add main row
-          expanded_rows << build_main_expanded_row(row_data, has_type_column)
-
-          # Add key rows
-          all_hash_keys.to_a.sort.each do |key|
-            expanded_rows << build_key_row(key, row_data, has_type_column, original_row)
-          end
-
-          expanded_rows
-        end
-
-        def build_main_expanded_row(row_data, has_type_column)
-          processed_values = row_data[:values].map { |value| ValueProcessor.process(value) }
-
-          if 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, has_type_column, original_row)
-          path_name = ".#{key}"
-          key_values = process_key_values(key, row_data[:values], has_type_column, original_row)
-
-          if has_type_column
-            ["-", path_name] + key_values
-          else
-            [path_name] + key_values
-          end
-        end
-
-        def process_key_values(key, values, has_type_column, 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, has_type_column)
-            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, has_type_column)
-          original_value = original_row[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
-
-        def calculate_column_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
-
-        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
-
-        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("|")}|"
+          rows = if @expand_hashes
+                   @row_processor.process_expanded_rows(@data[:rows])
+                 else
+                   @row_processor.process_simple_rows(@data[:rows])
+                 end
+
+          column_widths = @width_calculator.calculate_widths(headers, rows)
+          @renderer.render_table(headers, rows, column_widths)
         end
       end
     end

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

@@ -9,7 +9,7 @@ module ClassMetrix
         private
 
         def process_value(value)
-          @value_processor.process_for_markdown(value)
+          @value_processor.process_for_markdown(value, debug_mode: @options.fetch(:debug_mode, false))
         end
 
         def get_null_value
@@ -37,8 +37,13 @@ module ClassMetrix
 
         def build_expanded_row_structure(row, behavior_name, values, all_hash_keys)
           expanded_rows = []
-          expanded_rows << build_main_row(row, behavior_name, values)
-          expanded_rows.concat(build_hash_key_rows(row, behavior_name, values, all_hash_keys))
+
+          # Add main row if configured to show
+          expanded_rows << build_main_row(row, behavior_name, values) if should_show_main_row?
+
+          # Add key rows if configured to show
+          expanded_rows.concat(build_hash_key_rows(row, behavior_name, values, all_hash_keys)) if should_show_key_rows?
+
           expanded_rows
         end
 
@@ -84,8 +89,8 @@ module ClassMetrix
         end
 
         def extract_hash_key_value(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: @options.fetch(:debug_mode, false))
+            hash_value = @value_processor.safe_hash_lookup(hash, key, debug_mode: @options.fetch(:debug_mode, false))
             process_value(hash_value)
           else
             get_null_value

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,
@@ -54,20 +64,33 @@ module ClassMetrix
 
         def process_rows_for_expansion(headers)
           expanded_rows = []
+          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
+          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)
@@ -109,6 +132,8 @@ module ClassMetrix
           behavior_name = row[behavior_column_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 +142,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))
+
+          # 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 +222,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
@@ -183,24 +233,37 @@ module ClassMetrix
         def collect_all_hash_keys(rows, _headers)
           value_start_idx = value_start_index
           all_keys = {} # 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))
+          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)

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