looksist 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9e223a56fa500fbab484ad09eb23888d21ba0e4
-  data.tar.gz: c9e15de4a77e2f64a0458bb4f9a05fd89127c22f
+  metadata.gz: 5d8ea751e7e460f9cefd33a35bde5d1ec4e1b3be
+  data.tar.gz: 19a868515f44ac3daa6861b22f29a6ea7c67366a
 SHA512:
-  metadata.gz: e29215c24a0879bd9c971539d52d4c34d109de530d9f53d6488fd10a333af560b79e32c01defa2c7775b33c73380f35fe24bb225c6eb553ee6b028866a59b27a
-  data.tar.gz: c6bbf9e15bea1037dc15f4223503992392144e023a98c80db915c20af9d8ad0263c9c260ad94f936b877d4891d5d7254bdd860e1ec04c4cfaf88ceab9ff5db7b
+  metadata.gz: d44bdc278b7e5f4d6fec53b2ba1954f10ce50f2580d594125ad0a3477133c7ecc055ede69cecc2da78a45d46b520d44552baa09d565889dd3d2b834f1ae36ab8
+  data.tar.gz: 6e0062819715018e8dd6dceeace7e94d7d3511d9d233d8fa1c09402043a625e6f2da46669ca52fb3566870e8c80481a6ab1fc12ac340f566bcacf95f20d04bf6

data/features/hash_services/array_of_hash.rb

@@ -12,5 +12,5 @@ class ArrayOfHash
     ]
   end
 
-  inject after: :menu, at: '$', using: :item_id, populate: :item_name
+  inject after: :menu, using: :item_id, populate: :item_name
 end

data/lib/looksist/hashed.rb

@@ -61,11 +61,7 @@ module Looksist
         if opts[:populate].is_a? Array
           opts[:populate].each do |elt|
             value_hash = values.each_with_object([]) do |i, acc|
-              if i.nil?
-                acc << nil
-              else
-                acc << JSON.parse(i).deep_symbolize_keys[elt]
-              end
+              acc << JSON.parse(i || '{}').deep_symbolize_keys[elt]
             end
             alias_method = find_alias(opts[:as], elt)
             hash_offset[alias_method] = value_hash
@@ -89,7 +85,7 @@ module Looksist
 
           end.to_hash.deep_symbolize_keys
         else
-          inject_attributes_for(hash, opts)
+          inject_attributes_for_array(hash, opts)
         end
       end
 
@@ -100,6 +96,19 @@ module Looksist
         opts[:populate].is_a?(Array) ? composite_attribute_lookup(array_of_hashes, opts, values) : single_attribute_lookup(array_of_hashes, opts, values)
       end
 
+      def inject_attributes_for_array(array_of_hashes, opts)
+        entity_name = __entity__(opts[:bucket_name] || opts[:using])
+        modified_array = if opts[:at].nil?
+                array_of_hashes.map(&:values)
+              else
+                json_path = JsonPath.new("#{opts[:at]}..#{opts[:using]}")
+                json_path.on(array_of_hashes.to_json)
+              end
+        keys = modified_array.flatten.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_for_array(array_of_hashes, opts, values)
+      end
+
       def single_attribute_lookup(array_of_hashes, opts, values)
         array_of_hashes.each do |elt|
           alias_method = find_alias(opts[:as], opts[:populate])
@@ -107,6 +116,25 @@ module Looksist
         end
       end
 
+      def single_attribute_lookup_for_array(array_of_hashes, opts, values)
+        array_of_hashes.collect do |elt|
+          alias_method = find_alias(opts[:as], opts[:populate])
+          if opts[:at].present?
+            JsonPath.for(elt.with_indifferent_access).gsub!(opts[:at]) do |node|
+              if node.is_a? Array
+                node.each { |x| x[alias_method] = values[x.with_indifferent_access[opts[:using]]] }
+              else
+                node[alias_method] = values[node.with_indifferent_access[opts[:using]]]
+              end
+              node
+            end.to_hash.deep_symbolize_keys
+          else
+            elt[alias_method] = values[elt[opts[:using]]]
+            elt
+          end
+        end
+      end
+
       def composite_attribute_lookup(array_of_hashes, opts, values)
         array_of_hashes.each do |elt|
           opts[:populate].each do |_key|

data/lib/looksist/version.rb

@@ -1,3 +1,3 @@
 module Lookist
-  VERSION = '0.3.4'
+  VERSION = '0.3.5'
 end

data/spec/looksist/hashed_spec.rb

@@ -372,7 +372,7 @@ describe Looksist::Hashed do
       }})
     end
 
- it 'should work for first level of substitution' do
+    it 'should work for first level of substitution' do
       class FirstLevelHash
         include Looksist
 
@@ -386,9 +386,9 @@ describe Looksist::Hashed do
       expect(@mock).to receive(:get).with('employees/10').and_return('emp 1')
 
       expect(FirstLevelHash.new.metrics).to eq({
-              employee_id: 10,
-              employee_name: 'emp 1'
-          })
+                                                   employee_id: 10,
+                                                   employee_name: 'emp 1'
+                                               })
     end
 
     it 'should work for array of hashes' do
@@ -406,7 +406,7 @@ describe Looksist::Hashed do
           ]
         end
 
-        inject after: :metrics, at: '$', using: :item_id, populate: :item_name, as: {item_name: 'dish_name'}
+        inject after: :metrics, using: :item_id, populate: :item_name, as: {item_name: 'dish_name'}
       end
 
       expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2)).and_return(%w(Idly Pongal))
@@ -447,8 +447,8 @@ describe Looksist::Hashed do
       expect(@mock).to receive(:mget).once.with(*%w(heros/1 heros/2)).and_return(jsons)
 
       expect(HashWithMultipleAttributes.new.metrics).to eq(
-                                                            [{:hero_id => 1, :hero_name => "Rajini", :hero_mnemonic => "SuperStart"},
-                                                             {:hero_id => 2, :hero_name => "Kamal", :hero_mnemonic => "Ulaganayagan"}]
+                                                            [{:hero_id => 1, :hero_name => 'Rajini', :hero_mnemonic => 'SuperStart'},
+                                                             {:hero_id => 2, :hero_name => 'Kamal', :hero_mnemonic => 'Ulaganayagan'}]
                                                         )
     end
 
@@ -464,11 +464,11 @@ describe Looksist::Hashed do
           ]
         end
 
-        inject after: :help_me, at: '$', using: :a, bucket_name: 'ids', populate: :name
+        inject after: :help_me, using: :a, bucket_name: 'ids', populate: :name
       end
 
       expect(@mock).to receive(:mget).once.with('ids/1').and_return(['RajiniKanth'])
-      expect(SelfHelp.help_me).to eq([{:a => 1, :name => "RajiniKanth"}])
+      expect(SelfHelp.help_me).to eq([{:a => 1, :name => 'RajiniKanth'}])
     end
 
     it 'should work for first level hashes in class methods' do
@@ -477,9 +477,9 @@ describe Looksist::Hashed do
 
         class << self
           def my_method
-              {
-                  a: 1
-              }
+            {
+                a: 1
+            }
           end
         end
 
@@ -487,7 +487,7 @@ describe Looksist::Hashed do
       end
 
       expect(@mock).to receive(:get).once.with('ids/1').and_return('RajiniKanth')
-      expect(FirstLevelClass.my_method).to eq({:a => 1, :name => "RajiniKanth"})
+      expect(FirstLevelClass.my_method).to eq({:a => 1, :name => 'RajiniKanth'})
     end
 
     it 'should be capable to deep lookup and inject multiple attributes' do
@@ -497,14 +497,14 @@ describe Looksist::Hashed do
         def self.metrics
           {
               table: {
-              menu:{
-                item_id: [1,2]
+                  menu: {
+                      item_id: [1, 2]
+                  }
               }
-            }
           }
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name:'item_name', mnemonic:'item_mnemonic'}
+        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name: 'item_name', mnemonic: 'item_mnemonic'}
       end
 
       js1 = {name: 'Rice Cake', mnemonic: 'Idly'}.to_json
@@ -513,7 +513,7 @@ describe Looksist::Hashed do
 
       expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2)).and_return(jsons)
 
-      expect(DeepLookUpMultiple.metrics).to eq({:table => {:menu=>{:item_id=>[1, 2], :item_name=>["Rice Cake", "Rice pudding"], :item_mnemonic=>["Idly", "Pongal"]}}})
+      expect(DeepLookUpMultiple.metrics).to eq({:table => {:menu => {:item_id => [1, 2], :item_name => ['Rice Cake', 'Rice pudding'], :item_mnemonic => ['Idly', 'Pongal']}}})
     end
 
     it 'should be capable to deep lookup and inject multiple attributes ignoring nil values' do
@@ -523,14 +523,14 @@ describe Looksist::Hashed do
         def self.metrics
           {
               table: {
-              menu:{
-                item_id: [1,2]
+                  menu: {
+                      item_id: [1, 2]
+                  }
               }
-            }
           }
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name:'item_name', mnemonic:'item_mnemonic'}
+        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name: 'item_name', mnemonic: 'item_mnemonic'}
       end
 
       js1 = {name: 'Rice Cake', mnemonic: 'Idly'}.to_json
@@ -538,7 +538,7 @@ describe Looksist::Hashed do
 
       expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2)).and_return(jsons)
 
-      expect(DeepLookUpMultipleIngnorNil.metrics).to eq({:table => {:menu=>{:item_id=>[1, 2], :item_name=>["Rice Cake", nil], :item_mnemonic=>["Idly", nil]}}})
+      expect(DeepLookUpMultipleIngnorNil.metrics).to eq({:table => {:menu => {:item_id => [1, 2], :item_name => ['Rice Cake', nil], :item_mnemonic => ['Idly', nil]}}})
     end
 
     it 'should be capable to deep lookup and inject multiple attributes in same order' do
@@ -548,25 +548,69 @@ describe Looksist::Hashed do
         def self.metrics
           {
               table: {
-              menu:{
-                item_id: [1,2,2,1,1,2,3,3,2,1]
+                  menu: {
+                      item_id: [1, 2, 2, 1, 1, 2, 3, 3, 2, 1]
+                  }
+              }
+          }
+        end
+
+        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name: 'item_name', mnemonic: 'item_mnemonic'}
+      end
+
+      class ColumnarWithEmpty
+        include Looksist
+
+        def self.metrics
+          {
+              table: {
+                  menu: {
+                      item_id: []
+                  }
               }
-            }
           }
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name:'item_name', mnemonic:'item_mnemonic'}
+        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: [:name, :mnemonic], as: {name: 'item_name', mnemonic: 'item_mnemonic'}
       end
 
       js1 = {name: 'Rice Cake', mnemonic: 'Idly'}.to_json
       js2 = {name: 'Pan Cake', mnemonic: 'Dosa'}.to_json
-      jsons = [js1,  js2, nil]
+      jsons = [js1, js2, nil]
 
       expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2 items/3)).and_return(jsons)
 
-      expect(ColumnarWithNil.metrics).to eq({:table => {:menu=>{:item_id=>[1,2,2,1,1,2,3,3,2,1], :item_name=>["Rice Cake", "Pan Cake", "Pan Cake", "Rice Cake", "Rice Cake", "Pan Cake", nil, nil, "Pan Cake", "Rice Cake"],
-                                                                            :item_mnemonic=>["Idly", "Dosa","Dosa","Idly","Idly","Dosa", nil,nil, "Dosa", "Idly"  ]}}})
+      expect(ColumnarWithNil.metrics).to eq({:table => {:menu => {
+          :item_id => [1, 2, 2, 1, 1, 2, 3, 3, 2, 1],
+          :item_name => ['Rice Cake', 'Pan Cake', 'Pan Cake', 'Rice Cake', 'Rice Cake', 'Pan Cake', nil, nil, 'Pan Cake', 'Rice Cake'],
+          :item_mnemonic => ['Idly', 'Dosa', 'Dosa', 'Idly', 'Idly', 'Dosa', nil, nil, 'Dosa', 'Idly']}}})
+
+      expect(ColumnarWithEmpty.metrics).to eq({
+                                                  table: {
+                                                      menu: {
+                                                          item_id: [],
+                                                          item_name: [],
+                                                          item_mnemonic: []
+                                                      }
+                                                  }
+                                              })
     end
 
+    it'should work for nested injection for array of hash' do
+      class DeepLookUpAtArrayOfHash
+        include Looksist
+        def self.articles
+          [{
+              articles:[{article_id: 1}, {article_id: 2}]
+           }]
+        end
+        inject after: :articles, at:'$..articles', using: :article_id, populate: :name
+      end
+
+      expect(@mock).to receive(:mget).once.with(*%w(articles/1 articles/2)).and_return(['a','b'])
+
+      expect(DeepLookUpAtArrayOfHash.articles).to eq([{articles:[{article_id: 1, name:'a'}, {article_id:2, name:'b'}]}])
+
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: looksist
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - RC
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-31 00:00:00.000000000 Z
+date: 2014-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler