looksist 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fb62a2a0b2778134b40201016d38980393ee389
-  data.tar.gz: 6621c86b40473717e6e077c004506d0f79482d88
+  metadata.gz: d37e2dc990cb95ab09f7a065a226c2265808e1d7
+  data.tar.gz: 6e6886eca193e7b311b5c94ead38e098257d1821
 SHA512:
-  metadata.gz: 2bca80bd21a7a699b332930bdc5396f52e60a23b8e61acee6df1b0f42e92685a64b0a7c1658710a4f9aa610b83db50ed7ebc9fb8b50fa1d4ace9a2a257d4414f
-  data.tar.gz: 35937a98b7ff7e8e2edf52aa49424b04c8ec95eb0186b7c4e0b0bf3b8b2adce85374f69365ac3b5c261b907964eaa8ca84a24f9d937c728ff438c8fafc2ae080
+  metadata.gz: 82919b4456e2340f65119e66f7411051c9b5cccad412e2a150e2f03982542e1214ad4ad7f6c412567e7d447dfb722041c211bbaa6d25e8298ee899e195b285eb
+  data.tar.gz: 06003bbbc83e7499be00083848a16f97fc0d8db1e25c7376c16b0209807a172e712b444181e5c9cb0f8f9d24fcc968057df9fd64051f28448d5cfb728f82c2b8

data/lib/looksist/core.rb

@@ -42,7 +42,7 @@ module Looksist
 
 
     def as_json(opts)
-      Looksist.driver.json_opts(self, opts)
+      Looksist.driver.json_opts(self, self.class.lookup_attributes, opts)
     end
 
   end
@@ -50,8 +50,8 @@ module Looksist
   module Serializers
     class Her
       class << self
-        def json_opts(obj, _)
-          lookup_attributes = obj.class.lookup_attributes || {}
+        def json_opts(obj, lookup_attributes, _)
+          lookup_attributes  ||= {}
           other_attributes = lookup_attributes.keys.each_with_object({}) do |a, acc|
             using = lookup_attributes[a]
             acc[a] = obj.send(a) if obj.respond_to?(using)

data/lib/looksist/redis_service.rb

@@ -36,10 +36,10 @@ module Looksist
       keys = ids.collect { |id| redis_key(entity, id) }
       missed_keys = cache_op(proc_from { keys.uniq }) { (keys - @cache.keys).uniq }
       unless missed_keys.empty?
-        values = @client.mget *missed_keys
-        cache_op { @cache.merge!(Hash[*missed_keys.zip(values).flatten]) }
+        response = Hash[*missed_keys.zip(@client.mget *missed_keys).flatten]
+        cache_op { @cache.merge!(response) }
       end
-      (cache_op(proc_from { values }) { @cache.mslice(keys) })
+      (cache_op(proc_from { keys.collect {|k| response[k] } }) { @cache.mslice(keys) })
     end
 
     def cache_op(computed = nil)

data/lib/looksist/version.rb

@@ -1,3 +1,3 @@
 module Lookist
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

data/spec/looksist/hashed_spec.rb

@@ -1,334 +1,374 @@
 require 'spec_helper'
 
 describe Looksist::Hashed do
-  before(:each) do
-    @mock = {}
-    Looksist.configure do |looksist|
-      looksist.lookup_store = @mock
-      looksist.cache_buffer_size = 10
+  context('with_l2_cache') do
+    before(:each) do
+      @mock = {}
+      Looksist.configure do |looksist|
+        looksist.lookup_store = @mock
+        looksist.cache_buffer_size = 10
+      end
     end
-  end
 
-  context 'inject ' do
-    it 'should be capable to deep lookup and inject' do
-      class Menu
-        include Looksist
+    context 'inject ' do
+      it 'should be capable to deep lookup and inject' do
+        class Menu
+          include Looksist
+
+          def metrics
+            {
+                table: {
+                    menu: [
+                        {
+                            item_id: 1
+                        },
+                        {
+                            item_id: 2
+                        }
+                    ]
+                }
+            }
+          end
 
-        def metrics
-          {
-              table: {
-                  menu: [
-                      {
-                          item_id: 1
-                      },
-                      {
-                          item_id: 2
-                      }
-                  ]
-              }
-          }
+          inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name
+        expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2)).and_return(%w(Idly Pongal))
+
+        expect(Menu.new.metrics).to eq({
+                                           table: {
+                                               menu: [{
+                                                          item_id: 1,
+                                                          item_name: 'Idly'
+                                                      },
+                                                      {
+                                                          item_id: 2,
+                                                          item_name: 'Pongal'
+                                                      }]
+                                           }
+                                       })
       end
 
-      expect(@mock).to receive(:mget).once.with(*%w(items/1 items/2)).and_return(%w(Idly Pongal))
-
-      expect(Menu.new.metrics).to eq({
-                                         table: {
-                                             menu: [{
-                                                        item_id: 1,
-                                                        item_name: 'Idly'
-                                                    },
-                                                    {
-                                                        item_id: 2,
-                                                        item_name: 'Pongal'
-                                                    }]
-                                         }
-                                     })
-    end
+      it 'should be capable to deep lookup and inject from custom bucket' do
+        class CustomizedMenu
+          include Looksist
+
+          def metrics
+            {
+                table: {
+                    menu: [
+                        {
+                            item_id: 1
+                        },
+                        {
+                            item_id: 2
+                        }
+                    ]
+                }
+            }
+          end
 
-    it 'should be capable to deep lookup and inject from custom bucket' do
-      class CustomizedMenu
-        include Looksist
+          inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name, bucket_name: 'menu_items'
+        end
 
-        def metrics
-          {
-              table: {
-                  menu: [
-                      {
-                          item_id: 1
-                      },
-                      {
-                          item_id: 2
-                      }
-                  ]
-              }
-          }
+        expect(@mock).to receive(:mget).once.with(*%w(menu_items/1 menu_items/2)).and_return(%w(Idly Pongal))
+
+        expect(CustomizedMenu.new.metrics).to eq({
+                                                     table: {
+                                                         menu: [{
+                                                                    item_id: 1,
+                                                                    item_name: 'Idly'
+                                                                },
+                                                                {
+                                                                    item_id: 2,
+                                                                    item_name: 'Pongal'
+                                                                }]
+                                                     }
+                                                 })
+      end
+
+      xit 'should be capable to deep lookup and inject - another example' do
+        class NewMenu
+          include Looksist
+
+          def metrics
+            {
+                table: {
+                    menu: [
+                        {
+                            item_id: 4,
+                            item_name: 'Idly'
+                        },
+                        {
+                            item_id: 5
+                        }
+                    ]
+                }
+            }
+          end
+
+          inject after: :metrics, at: '$.table.menu[?(@.item_id=5)]', using: :item_id, populate: :item_name
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name, bucket_name: 'menu_items'
+        expect(@mock).to receive(:get).with('items/5').and_return(OpenStruct.new(value: 'Pongal'))
+
+        expect(NewMenu.new.metrics).to eq(
+                                           {
+                                               table: {
+                                                   menu: [
+                                                       {
+                                                           item_id: 4,
+                                                           item_name: 'Idly'
+                                                       },
+                                                       {
+                                                           item_id: 5,
+                                                           item_name: 'Pongal'
+                                                       }
+                                                   ]
+                                               }
+                                           }
+                                       )
       end
 
-      expect(@mock).to receive(:mget).once.with(*%w(menu_items/1 menu_items/2)).and_return(%w(Idly Pongal))
-
-      expect(CustomizedMenu.new.metrics).to eq({
-                                         table: {
-                                             menu: [{
-                                                        item_id: 1,
-                                                        item_name: 'Idly'
-                                                    },
-                                                    {
-                                                        item_id: 2,
-                                                        item_name: 'Pongal'
-                                                    }]
-                                         }
-                                     })
-    end
+      it 'should be capable to deep lookup and inject on columnar hashes' do
+        class DeepHash
+          include Looksist
 
-    xit 'should be capable to deep lookup and inject - another example' do
-      class NewMenu
-        include Looksist
+          def metrics
+            {
+                table: {
+                    inner_table: {
+                        employee_id: [10, 20]
+                    }
+                }
+            }
+          end
 
-        def metrics
-          {
-              table: {
-                  menu: [
-                      {
-                          item_id: 4,
-                          item_name: 'Idly'
-                      },
-                      {
-                          item_id: 5
-                      }
-                  ]
-              }
-          }
+          inject after: :metrics, at: '$.table.inner_table', using: :employee_id, populate: :employee_name
         end
 
-        inject after: :metrics, at: '$.table.menu[?(@.item_id=5)]', using: :item_id, populate: :item_name
+        expect(@mock).to receive(:mget).with(*%w(employees/10 employees/20)).and_return(['emp 1', 'emp 2'])
+
+        expect(DeepHash.new.metrics).to eq({table: {
+            inner_table: {
+                employee_id: [10, 20],
+                employee_name: ['emp 1', 'emp 2']
+            }
+        }})
       end
 
-      expect(@mock).to receive(:get).with('items/5').and_return(OpenStruct.new(value: 'Pongal'))
-
-      expect(NewMenu.new.metrics).to eq(
-                                         {
-                                             table: {
-                                                 menu: [
-                                                     {
-                                                         item_id: 4,
-                                                         item_name: 'Idly'
-                                                     },
-                                                     {
-                                                         item_id: 5,
-                                                         item_name: 'Pongal'
-                                                     }
-                                                 ]
-                                             }
-                                         }
-                                     )
-    end
+      it 'should inject single attribute to an existing hash' do
+        class HashService1
+          include Looksist
 
-    it 'should be capable to deep lookup and inject on columnar hashes' do
-      class DeepHash
-        include Looksist
+          def metrics
+            {
+                table: {
+                    employee_id: [1, 2]
+                }
+            }
+          end
 
-        def metrics
-          {
-              table: {
-                  inner_table: {
-                      employee_id: [10, 20]
-                  }
-              }
-          }
+          inject after: :metrics, at: :table, using: :employee_id, populate: :employee_name
         end
 
-        inject after: :metrics, at: '$.table.inner_table', using: :employee_id, populate: :employee_name
-      end
+        expect(@mock).to receive(:mget).with(*%w(employees/1 employees/2)).and_return(['emp 1', 'emp 2'])
 
-      expect(@mock).to receive(:mget).with(*%w(employees/10 employees/20)).and_return(['emp 1', 'emp 2'])
+        expect(HashService1.new.metrics).to eq({table: {
+            employee_id: [1, 2],
+            employee_name: ['emp 1', 'emp 2']
+        }})
+      end
 
-      expect(DeepHash.new.metrics).to eq({table: {
-          inner_table: {
-              employee_id: [10, 20],
-              employee_name: ['emp 1', 'emp 2']
-          }
-      }})
-    end
+      it 'should inject multiple attribute to an existing hash' do
+        class HashService
+          include Looksist
 
-    it 'should inject single attribute to an existing hash' do
-      class HashService1
-        include Looksist
+          def metrics
+            {
+                table: {
+                    employee_id: [5, 6],
+                    employer_id: [3, 4]
+                }
+            }
+          end
 
-        def metrics
-          {
-              table: {
-                  employee_id: [1, 2]
-              }
-          }
+          inject after: :metrics, at: :table, using: :employee_id, populate: :employee_name
+          inject after: :metrics, at: :table, using: :employer_id, populate: :employer_name
         end
 
-        inject after: :metrics, at: :table, using: :employee_id, populate: :employee_name
-      end
+        expect(@mock).to receive(:mget).with(*%w(employees/5 employees/6)).and_return(['emp 5', 'emp 6'])
 
-      expect(@mock).to receive(:mget).with(*%w(employees/1 employees/2)).and_return(['emp 1', 'emp 2'])
+        expect(@mock).to receive(:mget).with(*%w(employers/3 employers/4)).and_return(['empr 3', 'empr 4'])
 
-      expect(HashService1.new.metrics).to eq({table: {
-          employee_id: [1, 2],
-          employee_name: ['emp 1', 'emp 2']
-      }})
+        expect(HashService.new.metrics).to eq({table: {
+            employee_id: [5, 6],
+            employer_id: [3, 4],
+            employee_name: ['emp 5', 'emp 6'],
+            employer_name: ['empr 3', 'empr 4']
+        }})
+      end
     end
 
-    it 'should inject multiple attribute to an existing hash' do
-      class HashService
+    it 'should inject multiple attribute to an existing deep hash' do
+      class EmployeeHash
         include Looksist
 
         def metrics
           {
               table: {
-                  employee_id: [5, 6],
-                  employer_id: [3, 4]
+                  database: {
+                      employee_id: [15, 16],
+                      employer_id: [13, 14]
+                  }
               }
           }
         end
 
-        inject after: :metrics, at: :table, using: :employee_id, populate: :employee_name
-        inject after: :metrics, at: :table, using: :employer_id, populate: :employer_name
+        inject after: :metrics, at: '$.table.database', using: :employee_id, populate: :employee_name
+        inject after: :metrics, at: '$.table.database', using: :employer_id, populate: :employer_name
       end
 
-      expect(@mock).to receive(:mget).with(*%w(employees/5 employees/6)).and_return(['emp 5', 'emp 6'])
+      expect(@mock).to receive(:mget).with(*%w(employees/15 employees/16)).and_return(['emp 15', 'emp 16'])
 
-      expect(@mock).to receive(:mget).with(*%w(employers/3 employers/4)).and_return(['empr 3', 'empr 4'])
+      expect(@mock).to receive(:mget).with(*%w(employers/13 employers/14)).and_return(['empr 13', 'empr 14'])
 
-      expect(HashService.new.metrics).to eq({table: {
-          employee_id: [5, 6],
-          employer_id: [3, 4],
-          employee_name: ['emp 5', 'emp 6'],
-          employer_name: ['empr 3', 'empr 4']
+      expect(EmployeeHash.new.metrics).to eq({table: {
+          database: {
+              employee_id: [15, 16],
+              employer_id: [13, 14],
+              employee_name: ['emp 15', 'emp 16'],
+              employer_name: ['empr 13', 'empr 14']
+          }
       }})
     end
-  end
-
-  it 'should inject multiple attribute to an existing deep hash' do
-    class EmployeeHash
-      include Looksist
-
-      def metrics
-        {
-            table: {
-                database: {
-                    employee_id: [15, 16],
-                    employer_id: [13, 14]
-                }
-            }
-        }
-      end
 
-      inject after: :metrics, at: '$.table.database', using: :employee_id, populate: :employee_name
-      inject after: :metrics, at: '$.table.database', using: :employer_id, populate: :employer_name
-    end
+    context 'handle no data' do
+      it 'should not inject when data is not available' do
+        class EmptyResponse
+          include Looksist
 
-    expect(@mock).to receive(:mget).with(*%w(employees/15 employees/16)).and_return(['emp 15', 'emp 16'])
+          def empty
+            {:high_stock => {}, :low_shelf_life => {}, :in_elimination => {}, :inactive_with_stock => {}}
+          end
 
-    expect(@mock).to receive(:mget).with(*%w(employers/13 employers/14)).and_return(['empr 13', 'empr 14'])
+          inject after: :empty, at: :high_stock,
+                 using: :sub_category_id, populate: :sub_category
 
-    expect(EmployeeHash.new.metrics).to eq({table: {
-        database: {
-            employee_id: [15, 16],
-            employer_id: [13, 14],
-            employee_name: ['emp 15', 'emp 16'],
-            employer_name: ['empr 13', 'empr 14']
-        }
-    }})
-  end
+          inject after: :empty, at: '$.low_shelf_life',
+                 using: :sub_category_id, populate: :sub_category
 
-  context 'handle no data' do
-    it 'should not inject when data is not available' do
-      class EmptyResponse
-        include Looksist
+          inject after: :empty, at: '$.in_elimination',
+                 using: :sub_category_id, populate: :sub_category
 
-        def empty
-          {:high_stock => {}, :low_shelf_life => {}, :in_elimination => {}, :inactive_with_stock => {}}
+          inject after: :empty, at: '$.inactive_with_stock',
+                 using: :sub_category_id, populate: :sub_category
         end
+        expected_response = {:high_stock => {}, :low_shelf_life => {}, :in_elimination => {}, :inactive_with_stock => {}}
+        expect(EmptyResponse.new.empty).to eq(expected_response)
+      end
 
-        inject after: :empty, at: :high_stock,
-               using: :sub_category_id, populate: :sub_category
+      it 'should be capable to deep lookup and inject' do
+        class EmptyMenu
+          include Looksist
 
-        inject after: :empty, at: '$.low_shelf_life',
-               using: :sub_category_id, populate: :sub_category
+          def metrics
+            {
+                table: {
+                    menu: []
+                }
+            }
+          end
 
-        inject after: :empty, at: '$.in_elimination',
-               using: :sub_category_id, populate: :sub_category
+          inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name
+        end
 
-        inject after: :empty, at: '$.inactive_with_stock',
-               using: :sub_category_id, populate: :sub_category
+        expect(EmptyMenu.new.metrics).to eq({
+                                                table: {
+                                                    menu: []
+                                                }
+                                            })
       end
-      expected_response = {:high_stock => {}, :low_shelf_life => {}, :in_elimination => {}, :inactive_with_stock => {}}
-      expect(EmptyResponse.new.empty).to eq(expected_response)
     end
 
-    it 'should be capable to deep lookup and inject' do
-      class EmptyMenu
-        include Looksist
 
-        def metrics
-          {
-              table: {
-                  menu: []
-              }
-          }
+    context 'multiple methods and injections' do
+      it 'should inject multiple attribute to an existing hash' do
+        class HashServiceSuper
+          include Looksist
+
+          def shrinkage
+            {
+                table: {
+                    shrink_id: [1, 2]
+                }
+            }
+          end
+
+          def stock
+            {
+                table: {
+                    dc_id: [7, 8]
+                }
+            }
+          end
+
+          inject after: :shrinkage, at: :table, using: :shrink_id, populate: :shrink_name
+          inject after: :stock, at: :table, using: :dc_id, populate: :dc_name
         end
 
-        inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name
-      end
+        expect(@mock).to receive(:mget).with(*%w(shrinks/1 shrinks/2)).and_return(['shrink 1', 'shrink 2'])
 
-      expect(EmptyMenu.new.metrics).to eq({
-                                              table: {
-                                                  menu: []
-                                              }
-                                          })
+        expect(@mock).to receive(:mget).with(*%w(dcs/7 dcs/8)).and_return(['dc 7', 'dc 8'])
+
+        hash_service_super = HashServiceSuper.new
+        expect(hash_service_super.shrinkage).to eq({table: {
+            shrink_id: [1, 2],
+            shrink_name: ['shrink 1', 'shrink 2']
+        }})
+
+        expect(hash_service_super.stock).to eq({table: {
+            dc_id: [7, 8],
+            dc_name: ['dc 7', 'dc 8']
+        }})
+      end
     end
   end
 
+  context('no l2 cache') do
+    before(:each) do
+      @mock = {}
+      Looksist.configure do |looksist|
+        looksist.lookup_store = @mock
+        looksist.cache_buffer_size = 10
+        looksist.l2_cache = :no_cache
+      end
+    end
 
-  context 'multiple methods and injections' do
-    it 'should inject multiple attribute to an existing hash' do
-      class HashServiceSuper
+    it 'should be capable to deep lookup and inject on columnar hashes' do
+      class NoL2DeepHash
         include Looksist
 
-        def shrinkage
-          {
-              table: {
-                  shrink_id: [1, 2]
-              }
-          }
-        end
-
-        def stock
+        def metrics
           {
               table: {
-                  dc_id: [7, 8]
+                  inner_table: {
+                      employee_id: [10, 10]
+                  }
               }
           }
         end
 
-        inject after: :shrinkage, at: :table, using: :shrink_id, populate: :shrink_name
-        inject after: :stock, at: :table, using: :dc_id, populate: :dc_name
+        inject after: :metrics, at: '$.table.inner_table', using: :employee_id, populate: :employee_name
       end
 
-      expect(@mock).to receive(:mget).with(*%w(shrinks/1 shrinks/2)).and_return(['shrink 1', 'shrink 2'])
+      expect(@mock).to receive(:mget).with(*%w(employees/10)).and_return(['emp 1'])
 
-      expect(@mock).to receive(:mget).with(*%w(dcs/7 dcs/8)).and_return(['dc 7', 'dc 8'])
-
-      hash_service_super = HashServiceSuper.new
-      expect(hash_service_super.shrinkage).to eq({table: {
-          shrink_id: [1, 2],
-          shrink_name: ['shrink 1', 'shrink 2']
-      }})
-
-      expect(hash_service_super.stock).to eq({table: {
-          dc_id: [7, 8],
-          dc_name: ['dc 7', 'dc 8']
+      expect(NoL2DeepHash.new.metrics).to eq({table: {
+          inner_table: {
+              employee_id: [10, 10],
+              employee_name: ['emp 1', 'emp 1']
+          }
       }})
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: looksist
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - RC