class-metrix 0.1.2

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "../../processors/value_processor"
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class TableComponent
+        def initialize(data, options = {})
+          @data = data
+          @options = options
+          @expand_hashes = options.fetch(:expand_hashes, false)
+          @table_style = options.fetch(:table_style, :standard) # :standard, :compact, :wide
+          @min_column_width = options.fetch(:min_column_width, 3)
+          @max_column_width = options.fetch(:max_column_width, 50)
+        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("|")}|"
+        end
+      end
+    end
+  end
+end

data/lib/class_metrix/formatters/csv_formatter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "csv"
+require_relative "base/base_formatter"
+require_relative "shared/csv_table_builder"
+require_relative "components/generic_header_component"
+
+module ClassMetrix
+  class CsvFormatter < Formatters::Base::BaseFormatter
+    def initialize(data, expand_hashes = false, options = {})
+      super
+      @table_builder = Formatters::Shared::CsvTableBuilder.new(data, expand_hashes, @options)
+    end
+
+    def format
+      return "" if @data[:headers].empty? || @data[:rows].empty?
+
+      output_lines = []
+
+      # Add CSV header comments
+      if @options.fetch(:show_metadata, true)
+        header_component = Formatters::Components::GenericHeaderComponent.new(@data, @options.merge(format: :csv))
+        header_lines = header_component.generate
+        output_lines.concat(header_lines)
+      end
+
+      # Generate table data based on hash handling mode
+      table_data = determine_table_data
+
+      # Convert to CSV format
+      csv_output = render_csv_table(table_data)
+      output_lines.concat(csv_output)
+
+      output_lines.join("\n")
+    end
+
+    protected
+
+    def default_options
+      super.merge({
+                    separator: ",",
+                    quote_char: '"',
+                    flatten_hashes: false,
+                    null_value: "",
+                    comment_char: "#",
+                    show_metadata: true
+                  })
+    end
+
+    private
+
+    def determine_table_data
+      if @options[:flatten_hashes]
+        @table_builder.build_flattened_table
+      elsif @expand_hashes
+        @table_builder.build_expanded_table
+      else
+        @table_builder.build_simple_table
+      end
+    end
+
+    def render_csv_table(table_data)
+      headers = table_data[:headers]
+      rows = table_data[:rows]
+
+      return [] if headers.empty?
+
+      output = []
+      separator = @options.fetch(:separator, ",")
+      quote_char = @options.fetch(:quote_char, '"')
+
+      # Generate CSV rows
+      csv_rows = [headers] + rows
+
+      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
+        output << csv_line
+      end
+
+      output
+    end
+
+    def format_csv_cell(value)
+      case value
+      when nil
+        @options.fetch(:null_value, "")
+      when String
+        # Clean up emoji and special characters for CSV compatibility
+        clean_value = value.gsub(/[🚫⚠️✅❌]/, "").strip
+        clean_value.empty? ? @options.fetch(:null_value, "") : clean_value
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/class_metrix/formatters/markdown_formatter.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative "base/base_formatter"
+require_relative "shared/markdown_table_builder"
+require_relative "components/generic_header_component"
+require_relative "components/missing_behaviors_component"
+require_relative "components/footer_component"
+
+module ClassMetrix
+  class MarkdownFormatter < Formatters::Base::BaseFormatter
+    def initialize(data, expand_hashes = false, options = {})
+      super
+      @table_builder = Formatters::Shared::MarkdownTableBuilder.new(data, expand_hashes, @options)
+    end
+
+    def format
+      return "" if @data[:headers].empty? || @data[:rows].empty?
+
+      output = []
+
+      # Add header sections (title, classes, extraction info)
+      if @options.fetch(:show_metadata, true)
+        header_component = Formatters::Components::GenericHeaderComponent.new(@data, @options.merge(format: :markdown))
+        header_output = header_component.generate
+        output.concat(header_output) unless header_output.empty?
+      end
+
+      # Add main table
+      table_data = @expand_hashes ? @table_builder.build_expanded_table : @table_builder.build_simple_table
+      table_output = render_markdown_table(table_data)
+      unless table_output.empty?
+        # Join table rows with single newlines, then add as one section
+        output << table_output.join("\n")
+      end
+
+      # Add missing behaviors summary
+      if @options.fetch(:show_missing_summary, false)
+        missing_component = Formatters::Components::MissingBehaviorsComponent.new(@data, @options)
+        missing_output = missing_component.generate
+        output.concat(missing_output) unless missing_output.empty?
+      end
+
+      # Add footer
+      if @options.fetch(:show_footer, true)
+        footer_component = Formatters::Components::FooterComponent.new(@options)
+        footer_output = footer_component.generate
+        output.concat(footer_output) unless footer_output.empty?
+      end
+
+      # Join with newlines, filtering out empty sections
+      output.reject { |section| section.nil? || section == "" }.join("\n\n")
+    end
+
+    protected
+
+    def default_options
+      super.merge({
+                    show_footer: true,
+                    footer_style: :default,
+                    show_timestamp: false,
+                    show_classes: true,
+                    show_extraction_info: true,
+                    table_style: :standard,
+                    summary_style: :grouped,
+                    min_column_width: 3,
+                    max_column_width: 20
+                  })
+    end
+
+    private
+
+    def render_markdown_table(table_data)
+      headers = table_data[:headers]
+      rows = table_data[:rows]
+
+      return [] if headers.empty? || rows.empty?
+
+      widths = calculate_column_widths(headers, rows)
+
+      output = []
+      output << build_header_row(headers, widths)
+      output << build_separator_row(widths)
+      output.concat(build_data_rows(rows, headers, widths))
+
+      output
+    end
+
+    def build_header_row(headers, widths)
+      "| " + headers.map.with_index { |header, i| header.ljust(widths[i]) }.join(" | ") + " |"
+    end
+
+    def build_separator_row(widths)
+      "|" + widths.map { |width| "-" * (width + 2) }.join("|") + "|"
+    end
+
+    def build_data_rows(rows, headers, widths)
+      rows.map do |row|
+        build_single_data_row(row, headers, widths)
+      end
+    end
+
+    def build_single_data_row(row, headers, widths)
+      padded_row = pad_row_to_header_length(row, headers.length)
+      formatted_cells = format_row_cells(padded_row, widths)
+      "| " + formatted_cells.join(" | ") + " |"
+    end
+
+    def pad_row_to_header_length(row, header_length)
+      padding_needed = [0, header_length - row.length].max
+      row + Array.new(padding_needed, "")
+    end
+
+    def format_row_cells(row, widths)
+      row.map.with_index do |cell, i|
+        cell_str = truncate_cell(cell.to_s, widths[i])
+        cell_str.ljust(widths[i])
+      end
+    end
+
+    def calculate_column_widths(headers, rows)
+      table_style = @options.fetch(:table_style, :standard)
+      min_width = @options.fetch(:min_column_width, 3)
+      max_width = @options.fetch(:max_column_width, 30)
+
+      # Calculate the maximum width needed for each column
+      widths = headers.map(&:length)
+
+      rows.each do |row|
+        row.each_with_index do |cell, i|
+          next if i >= widths.length
+
+          cell_length = cell.to_s.length
+
+          # Apply max width limit for readability (like the old component did)
+          cell_length = [max_width, cell_length].min if %i[compact standard].include?(table_style)
+
+          widths[i] = [widths[i], cell_length].max
+        end
+      end
+
+      # Apply minimum width and final constraints
+      case table_style
+      when :compact
+        widths.map { |w| [[w, min_width].max, max_width].min }
+      when :wide
+        widths.map { |w| [w, min_width].max } # No max limit for wide style
+      else # :standard
+        widths.map { |w| [[w, min_width].max, max_width].min } # Apply max limit for standard too
+      end
+    end
+
+    def truncate_cell(text, max_width)
+      return text if text.length <= max_width
+      return text if max_width < 4
+
+      # Smart truncation for hash-like structures
+      if text.start_with?("{") && text.include?("=>")
+        # For hash representations, create a valid truncated version
+        truncate_hash_representation(text, max_width)
+      else
+        # Standard truncation for other values
+        "#{text[0..max_width - 4]}..."
+      end
+    end
+
+    def truncate_hash_representation(text, max_width)
+      return text if max_width < 6 # Need space for "{...}"
+
+      # Try to fit at least the first key-value pair
+      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]
+          needed_length = first_pair.length + 6 # For "{", ", ...}"
+          return "{#{first_pair}, ...}" if needed_length <= max_width
+        end
+      end
+
+      # Fallback to simple hash indicator
+      "{...}"
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "table_builder"
+
+module ClassMetrix
+  module Formatters
+    module Shared
+      class CsvTableBuilder < TableBuilder
+        private
+
+        def process_value(value)
+          @value_processor.process_for_csv(value, @options)
+        end
+
+        def get_null_value
+          @options.fetch(:null_value, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "table_builder"
+
+module ClassMetrix
+  module Formatters
+    module Shared
+      class MarkdownTableBuilder < TableBuilder
+        private
+
+        def process_value(value)
+          @value_processor.process_for_markdown(value)
+        end
+
+        def get_null_value
+          @value_processor.missing_hash_key
+        end
+
+        # Create proper flat table structure for hash expansion
+        def expand_row(row, _headers)
+          behavior_name = row[behavior_column_index]
+          values = row[value_start_index..]
+
+          all_hash_keys = collect_unique_hash_keys(values)
+          return [process_row(row)] if all_hash_keys.empty?
+
+          build_expanded_row_structure(row, behavior_name, values, all_hash_keys)
+        end
+
+        def collect_unique_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_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
+        end
+
+        def build_main_row(row, behavior_name, values)
+          processed_values = values.map { |value| process_value(value) }
+
+          if has_type_column?
+            [row[0], behavior_name] + processed_values
+          else
+            [behavior_name] + processed_values
+          end
+        end
+
+        def build_hash_key_rows(row, behavior_name, values, all_hash_keys)
+          all_hash_keys.to_a.sort.map do |key|
+            build_single_key_row(row, behavior_name, values, key)
+          end
+        end
+
+        def build_single_key_row(row, behavior_name, values, key)
+          path_name = "#{behavior_name}.#{key}"
+          key_values = extract_key_values_for_row(values, key)
+
+          if has_type_column?
+            [row[0], path_name] + key_values # Keep original type
+          else
+            [path_name] + key_values
+          end
+        end
+
+        def extract_key_values_for_row(values, key)
+          values.map do |value|
+            extract_single_key_value(value, key)
+          end
+        end
+
+        def extract_single_key_value(value, key)
+          if value.is_a?(Hash)
+            extract_hash_key_value(value, key)
+          else
+            get_null_value
+          end
+        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)
+            process_value(hash_value)
+          else
+            get_null_value
+          end
+        end
+      end
+    end
+  end
+end