class-metrix 0.1.2 → 1.0.1

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

@@ -0,0 +1,57 @@
+# 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)
+            values = row[value_start_index..] || []
+            return false if values.nil?
+
+            values.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 = [] # : Array[String]
+            output << build_row(headers, column_widths)
+            output << build_separator(column_widths)
+
+            rows.each do |row|
+              output << build_row(row, column_widths)
+            end
+
+            output
+          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

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,41 @@ 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?
+          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/csv_formatter.rb

@@ -15,7 +15,7 @@ module ClassMetrix
     def format
       return "" if @data[:headers].empty? || @data[:rows].empty?
 
-      output_lines = []
+      output_lines = [] # : Array[String]
 
       # Add CSV header comments
       if @options.fetch(:show_metadata, true)
@@ -65,7 +65,7 @@ module ClassMetrix
 
       return [] if headers.empty?
 
-      output = []
+      output = [] # : Array[String]
       separator = @options.fetch(:separator, ",")
       quote_char = @options.fetch(:quote_char, '"')
 
@@ -75,7 +75,7 @@ module ClassMetrix
       csv_rows.each do |row|
         # Ensure all row values are strings and properly quoted
         formatted_row = row.map { |cell| format_csv_cell(cell) }
-        csv_line = CSV.generate_line(formatted_row, col_sep: separator, quote_char: quote_char).chomp
+        csv_line = CSV.generate(col_sep: separator, quote_char: quote_char) { |csv| csv << formatted_row }.chomp
         output << csv_line
       end
 

data/lib/class_metrix/formatters/markdown_formatter.rb

@@ -16,7 +16,7 @@ module ClassMetrix
     def format
       return "" if @data[:headers].empty? || @data[:rows].empty?
 
-      output = []
+      output = [] # : Array[String]
 
       # Add header sections (title, classes, extraction info)
       if @options.fetch(:show_metadata, true)
@@ -77,7 +77,7 @@ module ClassMetrix
 
       widths = calculate_column_widths(headers, rows)
 
-      output = []
+      output = [] # : Array[String]
       output << build_header_row(headers, widths)
       output << build_separator_row(widths)
       output.concat(build_data_rows(rows, headers, widths))
@@ -170,8 +170,7 @@ module ClassMetrix
       if max_width >= 15
         # Look for the first complete key-value pair (handle :symbol=>value format)
         match = text.match(/\{(:[^,}]+=>[^,}]+)/)
-        if match
-          first_pair = match[1]
+        if match && (first_pair = match[1])
           needed_length = first_pair.length + 6 # For "{", ", ...}"
           return "{#{first_pair}, ...}" if needed_length <= max_width
         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
@@ -19,7 +19,7 @@ module ClassMetrix
         # Create proper flat table structure for hash expansion
         def expand_row(row, _headers)
           behavior_name = row[behavior_column_index]
-          values = row[value_start_index..]
+          values = row[value_start_index..] || []
 
           all_hash_keys = collect_unique_hash_keys(values)
           return [process_row(row)] if all_hash_keys.empty?
@@ -36,9 +36,14 @@ module ClassMetrix
         end
 
         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))
+          expanded_rows = [] # : Array[Array[String]]
+
+          # 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