Class: Alula::Util

Inherits:
Object
  • Object
show all
Defined in:
lib/alula/util.rb

Constant Summary collapse

CAMELIZE_MAPPING =

Some fields use odd casing (abbreviations mostly) that require a strict mapping for camelization to work properly

{
  'ce_arming_supervision_trouble_zones' => 'CEArmingSupervisionTroubleZones'
}.freeze

Class Method Summary collapse

Class Method Details

.camelize(under_scored_word) ⇒ Object 



28
29
30
31
32
 
# File 'lib/alula/util.rb', line 28

def camelize(under_scored_word)
  return CAMELIZE_MAPPING[under_scored_word.to_s] if CAMELIZE_MAPPING.key?(under_scored_word.to_s)
  words = under_scored_word.to_s.split(/-|_/)
  words.each_with_index.map{ |el, i| i == 0 ? el.downcase : el.capitalize }.join
end

.convert_hex_crc?(value) ⇒ Boolean

Check if BVN hex conversion needed

Returns:

  • (Boolean) 


24
25
26
 
# File 'lib/alula/util.rb', line 24

def convert_hex_crc?(value)
  [32, 33, 34, 35].include? value
end

.deep_merge(first, second) ⇒ Object

stackoverflow.com/questions/9381553/ruby-merge-nested-hash



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/alula/util.rb', line 43

def deep_merge(first, second)
  merger = proc do |key, v1, v2|
    if Hash === v1 && Hash === v2
      v1.merge(v2, &merger)
    elsif Array === v1 && Array === v2
      v1 | v2
    elsif [:undefined, nil, :nil].include?(v2)
      v1
    else
      v2
    end
  end

  first.merge(second.to_h, &merger)
end

.model_errors_from_response(response) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/alula/util.rb', line 59

def model_errors_from_response(response)
  errors = response.data['errors']
  return false unless errors

  error_object = errors.each_with_object({}) do |err, collector|
    #
    # This is duplicitive but it ensures that the model
    # itself will have _some_ kind of error detail if we need to print that out.
    collector[:model] ||= []
    collector[:model] << err['detail']

    # Error objects contain a bunch of info, but all the good stuff
    # is stored in a sub-object named meta
    # 
    # meta looks something like this
    # {
    #   fieldName: 'field error description',
    #   context: {
    #     // extra info about the request
    #   }
    # }
    # We need the fieldName to join errors to fields, and context gives extra
    # info that's good for debugging.
    err['meta']&.each_pair do |attribute, val|
      if attribute == 'context'
        collector[:context] ||= []
        collector[:context] << val
      else
        underscore_field = Alula::Util.underscore(attribute).to_sym
        collector[underscore_field] = val
      end
    end
  end

  #
  # De-duplicate context so we don't have the same info (requestId)
  # existing for every field that failed.
  error_object[:context] = error_object[:context].uniq.compact if error_object[:context]

  #
  # We have UI clients that depend on this being a string.
  # TODO: Update clients and let this be an array?
  error_object[:model] = error_object[:model].uniq.compact.join(', ')

  error_object
end

.split_on_word(string, separator_match = /-|_/, &block) ⇒ Object 



38
39
40
 
# File 'lib/alula/util.rb', line 38

def split_on_word(string, separator_match = /-|_/, &block)
  string.to_s.split(separator_match)
end

.underscore(camel_cased_word) ⇒ Object

Based on ActiveSupport’s underscore method activesupport/lib/active_support/inflector/methods.rb, line 90



13
14
15
16
17
18
19
20
21
 
# File 'lib/alula/util.rb', line 13

def underscore(camel_cased_word)
  return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
  word = camel_cased_word.to_s.gsub(/::/, '/')
  word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
  word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
  word.tr!("-", "_")
  word.downcase!
  word
end

.upper_camelcase(under_scored_word) ⇒ Object 



34
35
36
 
# File 'lib/alula/util.rb', line 34

def upper_camelcase(under_scored_word)
  under_scored_word.to_s.split(/-|_/).map(&:capitalize).join
end