Module: Looksist::Hashed::ClassMethods

Defined in:
lib/looksist/hashed.rb

Instance Method Summary collapse

Instance Method Details

#__entity__(entity) ⇒ Object 



102
103
104
 
# File 'lib/looksist/hashed.rb', line 102

def __entity__(entity)
  entity.to_s.gsub('_id', '')
end

#class_inject(opts) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/looksist/hashed.rb', line 33

def class_inject(opts)
  raise 'Incorrect usage' unless [:after, :using, :populate].all? { |e| opts.keys.include? e }

  after = opts[:after]
  @rules ||= {}
  (@rules[after] ||= []) << opts

  unless @rules[after].length > 1
    define_singleton_method("#{after}_with_inject") do |*args|
      hash = send("#{after}_without_inject".to_sym, *args)
      @rules[after].each do |opts|
        if opts[:at].is_a? String
          hash = update_using_json_path(hash, opts)
        else
          inject_attributes_at(hash[opts[:at]], opts)
        end
      end
      hash
    end
    self.singleton_class.send(:alias_method_chain, after, :inject)
  end
end

#composite_attribute_lookup(array_of_hashes, opts, values) ⇒ Object 



92
93
94
95
96
97
98
99
100
 
# File 'lib/looksist/hashed.rb', line 92

def composite_attribute_lookup(array_of_hashes, opts, values)
  array_of_hashes.each do |elt|
    opts[:populate].each do |_key|
      parsed_key = JSON.parse(values[elt[opts[:using]]]).deep_symbolize_keys
      alias_method = find_alias(opts[:as], _key)
      elt[alias_method] = parsed_key[_key]
    end
  end
end

#inject(opts) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/looksist/hashed.rb', line 10

def inject(opts)
  raise 'Incorrect usage' unless [:after, :using, :populate].all? { |e| opts.keys.include? e }

  after = opts[:after]
  @rules ||= {}
  (@rules[after] ||= []) << opts

  unless @rules[after].length > 1
    define_method("#{after}_with_inject") do |*args|
      hash = send("#{after}_without_inject".to_sym, *args)
      self.class.instance_variable_get(:@rules)[after].each do |opts|
        if opts[:at].is_a? String
          hash = self.class.update_using_json_path(hash, opts)
        else
          self.class.inject_attributes_at(hash[opts[:at]], opts)
        end
      end
      hash
    end
    alias_method_chain after, :inject
  end
end

#inject_attributes_at(hash_offset, opts) ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/looksist/hashed.rb', line 56

def inject_attributes_at(hash_offset, opts)
  return hash_offset if hash_offset.nil? or hash_offset.empty?
  keys = hash_offset[opts[:using]]
  entity_name = __entity__(opts[:bucket_name] || opts[:using])
  values = Looksist.redis_service.send("#{entity_name}_for", keys)
  alias_method = find_alias(opts, opts[:populate])
  hash_offset[alias_method] = values
  hash_offset
end

#inject_attributes_for(array_of_hashes, opts) ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/looksist/hashed.rb', line 78

def inject_attributes_for(array_of_hashes, opts)
  entity_name = __entity__(opts[:bucket_name] || opts[:using])
  keys = (array_of_hashes.collect { |i| i[opts[:using]] }).compact.uniq
  values = Hash[keys.zip(Looksist.redis_service.send("#{entity_name}_for", keys))]
  opts[:populate].is_a?(Array) ? composite_attribute_lookup(array_of_hashes, opts, values) : single_attribute_lookup(array_of_hashes, opts, values)
end

#single_attribute_lookup(array_of_hashes, opts, values) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/looksist/hashed.rb', line 85

def single_attribute_lookup(array_of_hashes, opts, values)
  array_of_hashes.each do |elt|
    alias_method = find_alias(opts[:as], opts[:populate])
    elt[alias_method] = values[elt[opts[:using]]]
  end
end

#update_using_json_path(hash, opts) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/looksist/hashed.rb', line 66

def update_using_json_path(hash, opts)
  if hash.is_a?(Hash)

    JsonPath.for(hash.with_indifferent_access).gsub!(opts[:at]) do |i|
      i.is_a?(Array) ? inject_attributes_for(i, opts) : inject_attributes_at(i, opts) unless (i.nil? or i.empty?)
      i
    end.to_hash.deep_symbolize_keys
  else
    inject_attributes_for(hash, opts)
  end
end