class-metrix 0.1.2

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../shared/value_processor"
+
+module ClassMetrix
+  module Formatters
+    module Base
+      class BaseComponent
+        attr_reader :data, :options, :value_processor
+
+        def initialize(data, options = {})
+          @data = data
+          @options = options
+          @value_processor = Shared::ValueProcessor
+        end
+
+        def generate
+          raise NotImplementedError, "Subclasses must implement #generate method"
+        end
+
+        protected
+
+        def has_type_column?
+          @data[:headers].first == "Type"
+        end
+
+        def behavior_column_index
+          has_type_column? ? 1 : 0
+        end
+
+        def value_start_index
+          has_type_column? ? 2 : 1
+        end
+
+        def class_headers
+          if has_type_column?
+            @data[:headers][2..] # Skip "Type" and "Behavior"
+          else
+            @data[:headers][1..] # Skip first column (behavior name)
+          end
+        end
+
+        def extraction_types_description
+          return "" if @options[:extraction_types].empty?
+
+          @options[:extraction_types].map do |type|
+            case type
+            when :constants then "Constants"
+            when :class_methods then "Class Methods"
+            when :module_methods then "Module Methods"
+            else type.to_s.split("_").map(&:capitalize).join(" ")
+            end
+          end.join(", ")
+        end
+
+        def format_timestamp
+          Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../shared/value_processor"
+
+module ClassMetrix
+  module Formatters
+    module Base
+      class BaseFormatter
+        attr_reader :data, :expand_hashes, :options
+
+        def initialize(data, expand_hashes = false, options = {})
+          @data = data
+          @expand_hashes = expand_hashes
+          @options = default_options.merge(options)
+          @value_processor = Shared::ValueProcessor
+        end
+
+        def format
+          raise NotImplementedError, "Subclasses must implement #format method"
+        end
+
+        protected
+
+        def default_options
+          {
+            # Common options for all formatters
+            title: nil,
+            show_metadata: true,
+            extraction_types: []
+          }
+        end
+
+        def has_type_column?
+          @data[:headers].first == "Type"
+        end
+
+        def behavior_column_index
+          has_type_column? ? 1 : 0
+        end
+
+        def value_start_index
+          has_type_column? ? 2 : 1
+        end
+
+        def class_headers
+          if has_type_column?
+            @data[:headers][2..] # Skip "Type" and "Behavior"
+          else
+            @data[:headers][1..] # Skip first column (behavior name)
+          end
+        end
+
+        def collect_all_hash_keys(rows, _headers)
+          value_start_idx = value_start_index
+          all_keys = {} # behavior_name => Set of keys
+
+          rows.each do |row|
+            behavior_name = row[behavior_column_index]
+            values = row[value_start_idx..]
+
+            values.each do |value|
+              if value.is_a?(Hash)
+                all_keys[behavior_name] ||= Set.new
+                all_keys[behavior_name].merge(value.keys.map(&:to_s))
+              end
+            end
+          end
+
+          all_keys
+        end
+
+        def process_value(value, format = :markdown)
+          case format
+          when :markdown
+            @value_processor.process_for_markdown(value)
+          when :csv
+            @value_processor.process_for_csv(value, @options)
+          else
+            raise ArgumentError, "Unknown format: #{format}"
+          end
+        end
+
+        def safe_hash_lookup(hash, key)
+          @value_processor.safe_hash_lookup(hash, key)
+        end
+
+        def has_hash_key?(hash, key)
+          @value_processor.has_hash_key?(hash, key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class FooterComponent
+        def initialize(options = {})
+          @options = options
+          @show_footer = options.fetch(:show_footer, true)
+          @custom_footer = options[:custom_footer]
+          @show_timestamp = options.fetch(:show_timestamp, false)
+          @show_separator = options.fetch(:show_separator, true)
+          @footer_style = options.fetch(:footer_style, :default) # :default, :minimal, :detailed
+        end
+
+        def generate
+          return [] unless @show_footer
+
+          output = []
+
+          # Add separator line
+          output << "---" if @show_separator
+
+          case @footer_style
+          when :minimal
+            output << "*Generated by ClassMetrix*"
+          when :detailed
+            output.concat(generate_detailed_footer)
+          else
+            output.concat(generate_default_footer)
+          end
+
+          output
+        end
+
+        private
+
+        def generate_default_footer
+          output = []
+
+          output << (@custom_footer || "*Report generated by ClassMetrix gem*")
+
+          if @show_timestamp
+            output << ""
+            output << "*Generated at: #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}*"
+          end
+
+          output
+        end
+
+        def generate_detailed_footer
+          output = []
+
+          output << "## Report Information"
+          output << ""
+          output << "- **Generated by**: [ClassMetrix gem](https://github.com/your-username/class-metrix)"
+          output << "- **Generated at**: #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}"
+          output << "- **Ruby version**: #{RUBY_VERSION}"
+
+          output << "- **Note**: #{@custom_footer}" if @custom_footer
+
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../base/base_component"
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class GenericHeaderComponent < Base::BaseComponent
+        def initialize(data, options = {})
+          super
+          @format = options.fetch(:format, :markdown)
+          @title = options[:title]
+          @extraction_types = options[:extraction_types] || []
+          @show_metadata = options.fetch(:show_metadata, true)
+        end
+
+        def generate
+          return [] unless @show_metadata
+
+          case @format
+          when :markdown
+            generate_markdown_header
+          when :csv
+            generate_csv_header
+          else
+            raise ArgumentError, "Unknown format: #{@format}"
+          end
+        end
+
+        private
+
+        def generate_markdown_header
+          output = []
+
+          # Add title
+          if @title
+            output << "# #{@title}"
+            output << ""
+          end
+
+          # Add classes analyzed
+          output << "## Classes Analyzed"
+          output << ""
+          class_headers.each do |class_name|
+            output << "- **#{class_name}**"
+          end
+          output << ""
+
+          # Add extraction types
+          unless @extraction_types.empty?
+            output << "## Extraction Types"
+            output << ""
+            output << extraction_types_description
+            output << ""
+          end
+
+          output
+        end
+
+        def generate_csv_header
+          output = []
+          comment_char = @options.fetch(:comment_char, "#")
+
+          # Add title as comment
+          if @title
+            output << "#{comment_char} #{@title}"
+          else
+            extraction_label = @extraction_types.empty? ? "Class Analysis" : @extraction_types.map(&:to_s).map(&:capitalize).join(" and ")
+            output << "#{comment_char} #{extraction_label} Report"
+          end
+
+          # Add classes analyzed
+          output << "#{comment_char} Classes: #{class_headers.join(", ")}"
+
+          # Add extraction types
+          output << "#{comment_char} Extraction Types: #{extraction_types_description}" unless @extraction_types.empty?
+
+          # Add generation timestamp
+          output << "#{comment_char} Generated: #{format_timestamp}"
+          output << comment_char.to_s # Empty comment line for separation
+
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class HeaderComponent
+        def initialize(data, options = {})
+          @data = data
+          @options = options
+          @title = options[:title]
+          @extraction_types = options[:extraction_types] || []
+          @show_metadata = options.fetch(:show_metadata, true)
+          @show_classes = options.fetch(:show_classes, true)
+          @show_extraction_info = options.fetch(:show_extraction_info, true)
+        end
+
+        def generate
+          output = []
+
+          # Add title
+          output.concat(generate_title) if @title || @show_metadata
+
+          # Add classes being analyzed
+          output.concat(generate_classes_section) if @show_classes
+
+          # Add extraction types info
+          output.concat(generate_extraction_info) if @show_extraction_info && !@extraction_types.empty?
+
+          output
+        end
+
+        private
+
+        def generate_title
+          output = []
+
+          if @title
+            output << "# #{@title}"
+          else
+            extraction_label = @extraction_types.empty? ? "Class Analysis" : @extraction_types.map(&:to_s).map(&:capitalize).join(" and ")
+            output << "# #{extraction_label} Report"
+          end
+
+          output << ""
+          output
+        end
+
+        def generate_classes_section
+          output = []
+
+          has_type_column = @data[:headers].first == "Type"
+          class_headers = if has_type_column
+                            @data[:headers][2..] # Skip "Type" and "Behavior"
+                          else
+                            @data[:headers][1..] # Skip first column (behavior name)
+                          end
+
+          output << "## Classes Analyzed"
+          output << ""
+          class_headers.each do |class_name|
+            output << "- **#{class_name}**"
+          end
+          output << ""
+
+          output
+        end
+
+        def generate_extraction_info
+          output = []
+
+          output << "## Extraction Types"
+          output << ""
+          @extraction_types.each do |type|
+            output << case type
+                      when :constants
+                        "- **Constants**: Class constants and their values"
+                      when :class_methods
+                        "- **Class Methods**: Class method results and return values"
+                      when :module_methods
+                        "- **Module Methods**: Methods from included modules"
+                      else
+                        "- **#{type.to_s.split("_").map(&:capitalize).join(" ")}**"
+                      end
+          end
+          output << ""
+
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Components
+      class MissingBehaviorsComponent
+        def initialize(data, options = {})
+          @data = data
+          @options = options
+          @show_missing_summary = options.fetch(:show_missing_summary, false)
+          @summary_style = options.fetch(:summary_style, :grouped) # :grouped, :flat, :detailed
+          @missing_behaviors = {}
+        end
+
+        def generate
+          return [] unless @show_missing_summary
+
+          track_missing_behaviors
+          generate_missing_behaviors_summary
+        end
+
+        private
+
+        def track_missing_behaviors
+          has_type_column = @data[:headers].first == "Type"
+          class_headers = if has_type_column
+                            @data[:headers][2..]
+                          else
+                            @data[:headers][1..]
+                          end
+
+          # Initialize missing behaviors tracking with hash to store behavior name and error message
+          class_headers.each { |class_name| @missing_behaviors[class_name] = {} }
+
+          @data[:rows].each do |row|
+            behavior_name = has_type_column ? row[1] : row[0]
+            values = has_type_column ? row[2..] : row[1..]
+
+            values.each_with_index do |value, index|
+              class_name = class_headers[index]
+              next unless value.to_s.include?("🚫") || value.nil?
+
+              # Store the actual error message from the table
+              error_message = value.to_s.include?("🚫") ? value.to_s : "🚫 Not defined"
+              @missing_behaviors[class_name][behavior_name] = error_message
+            end
+          end
+        end
+
+        def generate_missing_behaviors_summary
+          # Only show summary if there are missing behaviors
+          total_missing = @missing_behaviors.values.map(&:size).sum
+          return [] if total_missing.zero?
+
+          case @summary_style
+          when :flat
+            generate_flat_summary
+          when :detailed
+            generate_detailed_summary
+          else
+            generate_grouped_summary
+          end
+        end
+
+        def generate_grouped_summary
+          output = []
+
+          output << "## Missing Behaviors Summary"
+          output << ""
+          output << "The following behaviors are not defined in some classes:"
+          output << ""
+
+          @missing_behaviors.each do |class_name, behaviors_hash|
+            next if behaviors_hash.empty?
+
+            output << "### #{class_name}"
+            behaviors_hash.each do |behavior_name, error_message|
+              output << "- `#{behavior_name}` - #{error_message}"
+            end
+            output << ""
+          end
+
+          output
+        end
+
+        def generate_flat_summary
+          output = []
+
+          output << "## Missing Behaviors"
+          output << ""
+
+          all_missing = []
+          @missing_behaviors.each do |class_name, behaviors_hash|
+            behaviors_hash.each do |behavior_name, error_message|
+              all_missing << "- **#{class_name}**: `#{behavior_name}` - #{error_message}"
+            end
+          end
+
+          output.concat(all_missing.sort)
+          output << ""
+
+          output
+        end
+
+        def generate_detailed_summary
+          output = []
+
+          total_missing = @missing_behaviors.values.map(&:size).sum
+          total_classes = @missing_behaviors.keys.size
+
+          output << "## Missing Behaviors Analysis"
+          output << ""
+          output << "**Summary**: #{total_missing} missing behaviors across #{total_classes} classes"
+          output << ""
+
+          # Group by error type
+          by_error_type = {}
+          @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:"
+              by_error_type[error_type] ||= []
+              by_error_type[error_type] << { class: class_name, behavior: behavior_name, message: error_message }
+            end
+          end
+
+          by_error_type.each do |error_type, items|
+            output << "### #{error_type} (#{items.size} items)"
+            output << ""
+            items.each do |item|
+              output << "- **#{item[:class]}**: `#{item[:behavior]}` - #{item[:message]}"
+            end
+            output << ""
+          end
+
+          output
+        end
+      end
+    end
+  end
+end