Class: ClassMetrix::Formatters::Shared::ValueProcessor

Inherits:
Object
  • Object
show all
Defined in:
lib/class_metrix/formatters/shared/value_processor.rb

Class Method Summary collapse

Class Method Details

.handle_extraction_error(error) ⇒ Object 



124
125
126
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 124

def self.handle_extraction_error(error)
  "⚠️ Error: #{error.message}"
end

.has_hash_key?(hash, key, debug_mode: false, debug_level: :basic) ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 102

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

.missing_constant ⇒ Object

Error message generators



116
117
118
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 116

def self.missing_constant
  "🚫 Not defined"
end

.missing_hash_key ⇒ Object 



128
129
130
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 128

def self.missing_hash_key
  "—"
end

.missing_method ⇒ Object 



120
121
122
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 120

def self.missing_method
  "🚫 No method"
end

.process_array_for_csv(value, logger) ⇒ Object 



71
72
73
74
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 71

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

.process_csv_value_by_type(value, logger, null_value) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 47

def self.process_csv_value_by_type(value, logger, null_value)
  case value
  when Hash
    process_hash_for_csv(value, logger)
  when Array
    process_array_for_csv(value, logger)
  when true
    "TRUE"
  when false
    "FALSE"
  when nil
    null_value
  when String
    process_string_for_csv(value, null_value)
  else
    process_other_for_csv(value, logger)
  end
end

.process_for_csv(value, options = {}, debug_mode: false, debug_level: :basic) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 36

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

.process_for_markdown(value, debug_mode: false, debug_level: :basic) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 9

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
    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
    "✅"
  when false
    "❌"
  when nil
    "❌"
  when String
    logger.log("Processing String: #{logger.safe_truncate(value, 50)}", :verbose)
    value
  else
    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

.process_hash_for_csv(value, logger) ⇒ Object 



66
67
68
69
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 66

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

.process_other_for_csv(value, logger) ⇒ Object 



81
82
83
84
85
86
87
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 81

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

.process_string_for_csv(value, null_value) ⇒ Object 



76
77
78
79
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 76

def self.process_string_for_csv(value, null_value)
  clean_value = value.gsub(/🚫|⚠️|✅|❌/, "").strip
  clean_value.empty? ? null_value : clean_value
end

.safe_hash_lookup(hash, key, debug_mode: false, debug_level: :basic) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/class_metrix/formatters/shared/value_processor.rb', line 89

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
  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