Module: Trifle::Stats::Formatter::PathUtils

Defined in:
lib/trifle/stats/formatter/path_utils.rb

Class Method Summary collapse

Class Method Details

.collect_keys(values_list, acc) ⇒ Object 



54
55
56
57
58
59
60
61
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 54

def collect_keys(values_list, acc)
  values_list.each_with_object(Set.new) do |value, keys|
    result = fetch_path(value, acc)
    next unless result.is_a?(Hash)

    result.each_key { |key| keys << normalize_key(key) }
  end.to_a
end

.expand(values_list, segments, acc) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 40

def expand(values_list, segments, acc)
  return [acc] if segments.empty?

  segment, *rest = segments

  if segment == '*'
    collect_keys(values_list, acc).flat_map do |key|
      expand(values_list, rest, acc + [key])
    end
  else
    expand(values_list, rest, acc + [segment])
  end
end

.fetch_path(data, segments) ⇒ Object 



32
33
34
35
36
37
38
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 32

def fetch_path(data, segments)
  segments.reduce(data) do |current, segment|
    break nil unless current.is_a?(Hash)

    fetch_segment(current, segment)
  end
end

.fetch_segment(map, segment) ⇒ Object 



63
64
65
66
67
68
69
70
71
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 63

def fetch_segment(map, segment)
  return unless map.is_a?(Hash)

  key_candidates(segment).each do |key|
    return map[key] if key && map.key?(key)
  end

  nil
end

.integer_from_segment(segment) ⇒ Object 



83
84
85
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 83

def integer_from_segment(segment)
  Integer(segment, exception: false)
end

.key_candidates(segment) ⇒ Object 



73
74
75
76
77
78
79
80
81
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 73

def key_candidates(segment)
  candidates = [segment]
  candidates << segment.to_sym if segment.respond_to?(:to_sym)

  numeric = integer_from_segment(segment)
  candidates << numeric if numeric

  candidates
end

.map_target?(values_list, segments) ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
94
95
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 91

def map_target?(values_list, segments)
  values_list.any? do |value|
    fetch_path(value, segments).is_a?(Hash)
  end
end

.normalize_key(key) ⇒ Object 



87
88
89
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 87

def normalize_key(key)
  key.to_s
end

.resolve_concrete_paths(values_list, segments) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 21

def resolve_concrete_paths(values_list, segments)
  if segments.include?('*')
    resolve_paths(values_list, segments)
  elsif map_target?(values_list, segments)
    expanded = resolve_paths(values_list, segments + ['*'])
    expanded.empty? ? [segments] : expanded
  else
    [segments]
  end
end

.resolve_paths(values_list, segments) ⇒ Object 



17
18
19
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 17

def resolve_paths(values_list, segments)
  expand(values_list, segments, []).uniq
end

.split_path(path) ⇒ Object 



11
12
13
14
15
 
# File 'lib/trifle/stats/formatter/path_utils.rb', line 11

def split_path(path)
  return [] if path.nil? || path.empty?

  path.split('.').map(&:to_s)
end