class-metrix 0.1.2

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative "value_processor"
+
+module ClassMetrix
+  module Formatters
+    module Shared
+      class TableBuilder
+        attr_reader :data, :expand_hashes, :options
+
+        def initialize(data, expand_hashes = false, options = {})
+          @data = data
+          @expand_hashes = expand_hashes
+          @options = options
+          @value_processor = ValueProcessor
+        end
+
+        def build_simple_table
+          {
+            headers: @data[:headers],
+            rows: @data[:rows].map { |row| process_row(row) }
+          }
+        end
+
+        def build_expanded_table
+          return build_simple_table unless @expand_hashes
+
+          headers = @data[:headers]
+          expanded_rows = process_rows_for_expansion(headers)
+
+          {
+            headers: headers,
+            rows: expanded_rows
+          }
+        end
+
+        def build_flattened_table
+          return build_simple_table unless @expand_hashes
+
+          headers = @data[:headers]
+          rows = @data[:rows]
+
+          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)
+
+          {
+            headers: flattened_headers,
+            rows: flattened_rows
+          }
+        end
+
+        private
+
+        def process_rows_for_expansion(headers)
+          expanded_rows = []
+
+          @data[:rows].each do |row|
+            if row_has_expandable_hash?(row)
+              expanded_rows.concat(expand_row(row, headers))
+            else
+              expanded_rows << process_row(row)
+            end
+          end
+
+          expanded_rows
+        end
+
+        def row_has_expandable_hash?(row)
+          row[value_start_index..].any? { |cell| cell.is_a?(Hash) }
+        end
+
+        def create_flattened_rows(rows, headers, all_hash_keys)
+          rows.map do |row|
+            flatten_row(row, headers, all_hash_keys)
+          end
+        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 process_row(row)
+          row.map { |value| process_value(value) }
+        end
+
+        def process_value(value)
+          # This will be overridden by subclasses
+          value
+        end
+
+        def expand_row(row, _headers)
+          behavior_name = row[behavior_column_index]
+          values = row[value_start_index..]
+
+          all_hash_keys = collect_hash_keys_from_values(values)
+          return [process_row(row)] if all_hash_keys.empty?
+
+          build_expanded_row_set(row, behavior_name, values, all_hash_keys)
+        end
+
+        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)
+          end
+          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))
+          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_sub_rows(all_hash_keys, values)
+          all_hash_keys.to_a.sort.map do |key|
+            build_single_sub_row(key, values)
+          end
+        end
+
+        def build_single_sub_row(key, values)
+          path_name = ".#{key}"
+          key_values = extract_key_values(values, key)
+
+          if has_type_column?
+            ["", path_name] + key_values # Empty type for sub-rows
+          else
+            [path_name] + key_values
+          end
+        end
+
+        def extract_key_values(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_value_for_key(value, key)
+          else
+            get_null_value
+          end
+        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)
+            process_value(hash_value)
+          else
+            get_null_value
+          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|
+            collect_hash_keys_for_row(row, value_start_idx, all_keys)
+          end
+
+          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))
+          end
+        end
+
+        def create_flattened_headers(headers, all_hash_keys)
+          flattened = headers.dup
+          class_hdrs = class_headers
+
+          add_hash_key_headers(flattened, all_hash_keys, class_hdrs)
+          flattened
+        end
+
+        def add_hash_key_headers(flattened, all_hash_keys, class_hdrs)
+          all_hash_keys.each do |behavior_name, keys|
+            add_behavior_key_headers(flattened, behavior_name, keys, class_hdrs)
+          end
+        end
+
+        def add_behavior_key_headers(flattened, behavior_name, keys, class_hdrs)
+          keys.to_a.sort.each do |key|
+            class_hdrs.each do |class_name|
+              flattened << "#{behavior_name}.#{key}.#{class_name}"
+            end
+          end
+        end
+
+        def flatten_row(row, _headers, all_hash_keys)
+          behavior_name = row[behavior_column_index]
+          flattened = process_row(row)
+
+          add_flattened_hash_values(flattened, row, behavior_name, all_hash_keys)
+          flattened
+        end
+
+        def add_flattened_hash_values(flattened, row, behavior_name, all_hash_keys)
+          return unless all_hash_keys[behavior_name]
+
+          values = row[value_start_index..]
+
+          all_hash_keys[behavior_name].to_a.sort.each do |key|
+            add_flattened_values_for_key(flattened, values, key)
+          end
+        end
+
+        def add_flattened_values_for_key(flattened, values, key)
+          values.each do |value|
+            flattened << extract_flattened_value(value, key)
+          end
+        end
+
+        def extract_flattened_value(value, key)
+          if value.is_a?(Hash)
+            extract_hash_value_for_key(value, key)
+          else
+            get_null_value
+          end
+        end
+
+        def get_null_value
+          # Override in subclasses
+          ""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  module Formatters
+    module Shared
+      class ValueProcessor
+        def self.process_for_markdown(value)
+          case value
+          when Hash
+            value.inspect
+          when Array
+            value.join(", ")
+          when true
+            "✅"
+          when false
+            "❌"
+          when nil
+            "❌"
+          when String
+            value
+          else
+            value.to_s
+          end
+        end
+
+        def self.process_for_csv(value, options = {})
+          null_value = options.fetch(:null_value, "")
+
+          case value
+          when Hash
+            # For non-flattened CSV, represent hash as JSON-like string
+            value.inspect
+          when Array
+            value.join("; ") # Use semicolon to avoid CSV comma conflicts
+          when true
+            "TRUE"
+          when false
+            "FALSE"
+          when nil
+            null_value
+          when String
+            # Clean up emoji for CSV compatibility
+            clean_value = value.gsub(/🚫|⚠️|✅|❌/, "").strip
+            clean_value.empty? ? null_value : clean_value
+          else
+            value.to_s
+          end
+        end
+
+        def self.safe_hash_lookup(hash, key)
+          # Properly handle false values in hash lookup
+          hash.key?(key.to_sym) ? hash[key.to_sym] : hash[key.to_s]
+        end
+
+        def self.has_hash_key?(hash, key)
+          hash.key?(key.to_sym) || hash.key?(key.to_s)
+        end
+
+        # Error message generators
+        def self.missing_constant
+          "🚫 Not defined"
+        end
+
+        def self.missing_method
+          "🚫 No method"
+        end
+
+        def self.handle_extraction_error(error)
+          "⚠️ Error: #{error.message}"
+        end
+
+        def self.missing_hash_key
+          "—"
+        end
+      end
+    end
+  end
+end

data/lib/class_metrix/processors/value_processor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../formatters/shared/value_processor"
+
+module ClassMetrix
+  # Legacy value processor - now delegates to the new shared processor
+  # Maintained for backward compatibility with existing code
+  class ValueProcessor
+    def self.process(value, expand_hashes: false)
+      if expand_hashes && value.is_a?(Hash)
+        expand_hash(value)
+      else
+        Formatters::Shared::ValueProcessor.process_for_markdown(value)
+      end
+    rescue StandardError => e
+      "⚠️ #{e.class.name}"
+    end
+
+    def self.format_hash(hash)
+      Formatters::Shared::ValueProcessor.process_for_markdown(hash)
+    end
+
+    def self.expand_hash(hash)
+      # Return an array of key-value pairs for expansion
+      hash.map { |k, v| { key: k.to_s, value: process(v, expand_hashes: false) } }
+    end
+
+    def self.handle_extraction_error(error)
+      Formatters::Shared::ValueProcessor.handle_extraction_error(error)
+    end
+
+    def self.missing_constant
+      Formatters::Shared::ValueProcessor.missing_constant
+    end
+
+    def self.missing_method
+      Formatters::Shared::ValueProcessor.missing_method
+    end
+  end
+end

data/lib/class_metrix/utils/class_resolver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  class ClassResolver
+    def self.normalize_classes(classes)
+      classes.map do |klass|
+        case klass
+        when String
+          Object.const_get(klass)
+        when Class
+          klass
+        else
+          raise ArgumentError, "Invalid class: #{klass.inspect}"
+        end
+      end
+    rescue NameError => e
+      raise ArgumentError, "Class not found: #{e.message}"
+    end
+  end
+end

data/lib/class_metrix/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ClassMetrix
+  VERSION = "0.1.2"
+end

data/lib/class_metrix.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "class_metrix/version"
+require_relative "class_metrix/extractor"
+
+module ClassMetrix
+  class Error < StandardError; end
+
+  def self.extract(*types)
+    Extractor.new(*types)
+  end
+end

data/sig/class/metrix.rbs

@@ -0,0 +1,6 @@
+module Class
+  module Metrix
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: class-metrix
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Huy Nguyen
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ClassMetrix allows you to easily extract and compare constants and class
+  methods across multiple Ruby classes, generating clean markdown tables for analysis
+  and documentation.
+email:
+- patrick204nqh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- RELEASE_GUIDE.md
+- Rakefile
+- examples/README.md
+- examples/advanced/error_handling.rb
+- examples/advanced/hash_expansion.rb
+- examples/basic/01_simple_constants.rb
+- examples/basic/02_simple_methods.rb
+- examples/basic/03_multi_type_extraction.rb
+- examples/components/configurable_reports.rb
+- examples/csv_output_demo.rb
+- examples/real_world/microservices_audit.rb
+- lib/class_metrix.rb
+- lib/class_metrix/extractor.rb
+- lib/class_metrix/extractors/constants_extractor.rb
+- lib/class_metrix/extractors/methods_extractor.rb
+- lib/class_metrix/extractors/multi_type_extractor.rb
+- lib/class_metrix/formatters/base/base_component.rb
+- lib/class_metrix/formatters/base/base_formatter.rb
+- lib/class_metrix/formatters/components/footer_component.rb
+- lib/class_metrix/formatters/components/generic_header_component.rb
+- lib/class_metrix/formatters/components/header_component.rb
+- lib/class_metrix/formatters/components/missing_behaviors_component.rb
+- lib/class_metrix/formatters/components/table_component.rb
+- lib/class_metrix/formatters/csv_formatter.rb
+- lib/class_metrix/formatters/markdown_formatter.rb
+- lib/class_metrix/formatters/shared/csv_table_builder.rb
+- lib/class_metrix/formatters/shared/markdown_table_builder.rb
+- lib/class_metrix/formatters/shared/table_builder.rb
+- lib/class_metrix/formatters/shared/value_processor.rb
+- lib/class_metrix/processors/value_processor.rb
+- lib/class_metrix/utils/class_resolver.rb
+- lib/class_metrix/version.rb
+- sig/class/metrix.rbs
+homepage: https://github.com/patrick204nqh/class-metrix
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/patrick204nqh/class-metrix
+  source_code_uri: https://github.com/patrick204nqh/class-metrix
+  changelog_uri: https://github.com/patrick204nqh/class-metrix/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Simple extraction and comparison of Ruby class behaviors with clean markdown
+  output
+test_files: []