looksist 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3505080addc197736b40fd6384223c3f116d94bc
-  data.tar.gz: 9a3303eb8dd99a337dfb74e669ce9cfd970294ce
+  metadata.gz: 3fb62a2a0b2778134b40201016d38980393ee389
+  data.tar.gz: 6621c86b40473717e6e077c004506d0f79482d88
 SHA512:
-  metadata.gz: e1606ba5e94a4a323a6ce83b4c7804519bb169ba670bba6d7fc29da7488ac972d459815277b904c631b0932d62a54bab8f4bf34d8a5fbc6257daf3d822437446
-  data.tar.gz: f72d42711b96d872d972f397b94c6104724e32cb93d2b4cb7bfdf159522f1d11d8bcbbfa6aff5a65b9bc7dc73f26f53ef96c20d9e59f2d5bf17ac72760ffe7c8
+  metadata.gz: 2bca80bd21a7a699b332930bdc5396f52e60a23b8e61acee6df1b0f42e92685a64b0a7c1658710a4f9aa610b83db50ed7ebc9fb8b50fa1d4ace9a2a257d4414f
+  data.tar.gz: 35937a98b7ff7e8e2edf52aa49424b04c8ec95eb0186b7c4e0b0bf3b8b2adce85374f69365ac3b5c261b907964eaa8ca84a24f9d937c728ff438c8fafc2ae080

data/features/support/env.rb

@@ -29,5 +29,6 @@ I18n.enforce_available_locales = false
 
 Looksist.configure do |looksist|
   looksist.lookup_store = Redis.new(url: 'redis://localhost:6379', driver: :hiredis)
+  looksist.l2_cache = :no_cache
   looksist.driver = Looksist::Serializers::Her
-end
+end

data/lib/looksist.rb

@@ -15,13 +15,13 @@ module Looksist
   include Hashed
 
   class << self
-    attr_accessor :lookup_store, :driver, :cache_buffer_size, :redis_service
+    attr_accessor :lookup_store, :driver, :cache_buffer_size, :redis_service, :l2_cache
 
     def configure
       yield self
       self.redis_service = Looksist::RedisService.instance do |lookup|
         lookup.client = self.lookup_store
-        lookup.buffer_size = self.cache_buffer_size || 50000
+        lookup.buffer_size = (self.l2_cache == :no_cache) ? 0 : (self.cache_buffer_size || 50000)
       end
     end
 

data/lib/looksist/redis_service.rb

@@ -32,14 +32,22 @@ module Looksist
     private
 
     def find_all(entity, ids)
-      raise 'Buffer overflow! Increase buffer size' if ids.length > @buffer_size
+      raise 'Buffer overflow! Increase buffer size' if  ids.length > @buffer_size && @buffer_size != 0
       keys = ids.collect { |id| redis_key(entity, id) }
-      missed_keys = (keys - @cache.keys).uniq
+      missed_keys = cache_op(proc_from { keys.uniq }) { (keys - @cache.keys).uniq }
       unless missed_keys.empty?
         values = @client.mget *missed_keys
-        @cache.merge!(Hash[*missed_keys.zip(values).flatten])
+        cache_op { @cache.merge!(Hash[*missed_keys.zip(values).flatten]) }
+      end
+      (cache_op(proc_from { values }) { @cache.mslice(keys) })
+    end
+
+    def cache_op(computed = nil)
+      if @buffer_size == 0
+        return computed.call if computed
+      else
+        yield
       end
-      @cache.mslice(keys)
     end
 
     def find(entity, id)
@@ -50,11 +58,15 @@ module Looksist
     end
 
     def fetch(key, &block)
-      @cache[key] ||= block.call
+      (cache_op(proc_from { block.call }) { @cache[key] ||= block.call })
     end
 
     def redis_key(entity, id)
       "#{entity.pluralize}/#{id}"
     end
+
+    def proc_from
+      Proc.new
+    end
   end
 end

data/lib/looksist/version.rb

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

data/spec/looksist/hashed_spec.rb

@@ -10,7 +10,6 @@ describe Looksist::Hashed do
   end
 
   context 'inject ' do
-
     it 'should be capable to deep lookup and inject' do
       class Menu
         include Looksist

data/spec/looksist/looksist_spec.rb

@@ -2,232 +2,294 @@ require 'spec_helper'
 
 
 describe Looksist do
-  before(:each) do
-    @mock = {}
-    Looksist.configure do |looksist|
-      looksist.lookup_store = @mock
-      looksist.driver = Looksist::Serializers::Her
+  context 'no l2 cache' do
+    before(:each) do
+      @mock = {}
+      Looksist.configure do |looksist|
+        looksist.lookup_store = @mock
+        looksist.l2_cache = :no_cache
+        looksist.driver = Looksist::Serializers::Her
+      end
     end
-  end
-
-  context 'Serialization Support' do
-    it 'should decorate for her models' do
-      module Her
-        class Employee
-          include Her::Model
-          use_api TEST_API
-          include Looksist
-
-          lookup :name, using: :employee_id
-
-          def as_json(opts)
-            super(opts).merge(another_attr: 'Hello World')
+    context 'Serialization Support' do
+      it 'should decorate for her models' do
+        module Her
+          class NoCacheEmployee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
+
+            lookup :name, using: :employee_id
+
+            def as_json(opts)
+              super(opts).merge(another_attr: 'Hello World')
+            end
           end
         end
+
+        expect(@mock).to receive(:get).twice.with('employees/1').and_return('Employee Name')
+        e = Her::NoCacheEmployee.new({employee_id: 1})
+        expect(e.name).to eq('Employee Name')
+        expect(e.to_json).to eq({:employee_id => 1, :name => 'Employee Name', :another_attr => 'Hello World'}.to_json)
       end
-      expect(@mock).to receive(:get).once.with('employees/1').and_return('Employee Name')
-      e = Her::Employee.new({employee_id: 1})
-      expect(e.name).to eq('Employee Name')
-      expect(e.to_json).to eq({:employee_id => 1, :name => 'Employee Name', :another_attr => 'Hello World'}.to_json)
     end
-  end
-
-  context 'Store Lookup' do
-    it 'should consider bucket key when provided' do
-      module ExplicitBucket
-        class Employee
-          include Looksist
-          attr_accessor :id
-          lookup :name, using: :id, bucket_name: 'employees'
 
-          def initialize(id)
-            @id = id
+    context 'Alias Lookup' do
+      it 'should fetch attributes and use the alias for specific attributes in the api' do
+        module AliasSpecificLookup
+          class NoCacheEmployee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
+            attr_accessor :id
+            lookup [:name, :age], using: :id, as: {name: 'nome'}
+
+            def initialize(id)
+              @id = id
+            end
+
+            def as_json(opts)
+              super(opts).merge(id: @id)
+            end
           end
         end
+        expect(@mock).to receive(:get).exactly(4).times.with('ids/1').and_return({name: 'Rajini', age: 16}.to_json)
+        e = AliasSpecificLookup::NoCacheEmployee.new(1)
+        expect(e.nome).to eq('Rajini')
+        expect(e.age).to eq(16)
+        expect(e.to_json).to eq("{\"nome\":\"Rajini\",\"age\":16,\"id\":1}")
       end
-      expect(@mock).to receive(:get).once.with('employees/1').and_return('Employee Name')
-      e = ExplicitBucket::Employee.new(1)
-      expect(e.name).to eq('Employee Name')
     end
   end
+  context 'with l2 cache' do
+    before(:each) do
+      @mock = {}
+      Looksist.configure do |looksist|
+        looksist.lookup_store = @mock
+        looksist.l2_cache = :cached
+        looksist.driver = Looksist::Serializers::Her
+      end
+    end
 
-  context 'Tolerant lookup' do
-    it 'should not do a lookup when the key attribute is not defined' do
-      module TolerantLookUp
-        class Employee
-          include Her::Model
-          use_api TEST_API
-          include Looksist
+    context 'Serialization Support' do
+      it 'should decorate for her models' do
+        module Her
+          class Employee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
 
-          lookup :name, using: :employee_id
+            lookup :name, using: :employee_id
 
-          def as_json(opts)
-            super(opts)
+            def as_json(opts)
+              super(opts).merge(another_attr: 'Hello World')
+            end
           end
         end
+        expect(@mock).to receive(:get).once.with('employees/1').and_return('Employee Name')
+        e = Her::Employee.new({employee_id: 1})
+        expect(e.name).to eq('Employee Name')
+        expect(e.to_json).to eq({:employee_id => 1, :name => 'Employee Name', :another_attr => 'Hello World'}.to_json)
       end
-      expect(@mock).to receive(:get).never.with('employees_/1')
-      e = TolerantLookUp::Employee.new
-      expect(e.to_json).to eq('{}')
     end
-  end
-
-  context 'Alias support for lookup' do
-    it 'should fetch attributes and use the alias specified in the api' do
-      module AliasLookup
-        class Employee
-          include Her::Model
-          use_api TEST_API
-          include Looksist
-          attr_accessor :id
-          lookup :name, using: :id, bucket_name: 'employees', as: {name: 'nome'}
-
-          def initialize(id)
-            @id = id
-          end
 
-          def as_json(opts)
-            super(opts).merge(id: @id)
+    context 'Store Lookup' do
+      it 'should consider bucket key when provided' do
+        module ExplicitBucket
+          class Employee
+            include Looksist
+            attr_accessor :id
+            lookup :name, using: :id, bucket_name: 'employees'
+
+            def initialize(id)
+              @id = id
+            end
           end
         end
+        expect(@mock).to receive(:get).once.with('employees/1').and_return('Employee Name')
+        e = ExplicitBucket::Employee.new(1)
+        expect(e.name).to eq('Employee Name')
       end
-      expect(@mock).to receive(:get).once.with('employees/1').and_return('Rajini')
-      e = AliasLookup::Employee.new(1)
-      expect(e.nome).to eq('Rajini')
-      expect(e.to_json).to eq("{\"nome\":\"Rajini\",\"id\":1}")
     end
 
-    it 'should fetch attributes and use the alias for specific attributes in the api' do
-      module AliasSpecificLookup
-        class Employee
-          include Her::Model
-          use_api TEST_API
-          include Looksist
-          attr_accessor :id
-          lookup [:name, :age], using: :id, as: {name: 'nome'}
+    context 'Tolerant lookup' do
+      it 'should not do a lookup when the key attribute is not defined' do
+        module TolerantLookUp
+          class Employee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
 
-          def initialize(id)
-            @id = id
-          end
+            lookup :name, using: :employee_id
 
-          def as_json(opts)
-            super(opts).merge(id: @id)
+            def as_json(opts)
+              super(opts)
+            end
           end
         end
+        expect(@mock).to receive(:get).never.with('employees_/1')
+        e = TolerantLookUp::Employee.new
+        expect(e.to_json).to eq('{}')
       end
-      expect(@mock).to receive(:get).once.with('ids/1').and_return({name: 'Rajini', age: 16}.to_json)
-      e = AliasSpecificLookup::Employee.new(1)
-      expect(e.nome).to eq('Rajini')
-      expect(e.age).to eq(16)
-      expect(e.to_json).to eq("{\"nome\":\"Rajini\",\"age\":16,\"id\":1}")
     end
-  end
-
-  context 'Lazy Evaluation' do
-    module LazyEval
-      class HerEmployee
-        include Her::Model
-        use_api TEST_API
-        include Looksist
-
-        lookup :name, using: :employee_id
 
-        def as_json(opts)
-          super(opts).merge(another_attr: 'Hello World')
+    context 'Alias support for lookup' do
+      it 'should fetch attributes and use the alias specified in the api' do
+        module AliasLookup
+          class Employee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
+            attr_accessor :id
+            lookup :name, using: :id, bucket_name: 'employees', as: {name: 'nome'}
+
+            def initialize(id)
+              @id = id
+            end
+
+            def as_json(opts)
+              super(opts).merge(id: @id)
+            end
+          end
         end
+        expect(@mock).to receive(:get).once.with('employees/1').and_return('Rajini')
+        e = AliasLookup::Employee.new(1)
+        expect(e.nome).to eq('Rajini')
+        expect(e.to_json).to eq("{\"nome\":\"Rajini\",\"id\":1}")
       end
-      class Employee
-        include Looksist
-        attr_accessor :id
-        lookup :name, using: :id, bucket_name: 'employees'
 
-        def initialize(id)
-          @id = id
+      it 'should fetch attributes and use the alias for specific attributes in the api' do
+        module AliasSpecificLookup
+          class Employee
+            include Her::Model
+            use_api TEST_API
+            include Looksist
+            attr_accessor :id
+            lookup [:name, :age], using: :id, as: {name: 'nome'}
+
+            def initialize(id)
+              @id = id
+            end
+
+            def as_json(opts)
+              super(opts).merge(id: @id)
+            end
+          end
         end
+        expect(@mock).to receive(:get).once.with('ids/1').and_return({name: 'Rajini', age: 16}.to_json)
+        e = AliasSpecificLookup::Employee.new(1)
+        expect(e.nome).to eq('Rajini')
+        expect(e.age).to eq(16)
+        expect(e.to_json).to eq("{\"nome\":\"Rajini\",\"age\":16,\"id\":1}")
       end
     end
-    it 'should not eager evaluate' do
-      expect(@mock).to_not receive(:get)
-      LazyEval::Employee.new(1)
-      LazyEval::HerEmployee.new(employee_id: 1)
-    end
-  end
 
-  context 'lookup attributes' do
-    it 'should generate declarative attributes on the model with simple lookup value' do
-      module SimpleLookup
+    context 'Lazy Evaluation' do
+      module LazyEval
+        class HerEmployee
+          include Her::Model
+          use_api TEST_API
+          include Looksist
+
+          lookup :name, using: :employee_id
+
+          def as_json(opts)
+            super(opts).merge(another_attr: 'Hello World')
+          end
+        end
         class Employee
           include Looksist
-          attr_accessor :id, :employee_id
-          lookup :name, using:  :id
-          lookup :unavailable, using: :employee_id
+          attr_accessor :id
+          lookup :name, using: :id, bucket_name: 'employees'
 
           def initialize(id)
-            @id = @employee_id = id
+            @id = id
           end
         end
       end
-
-      expect(@mock).to receive(:get).once.with('ids/1').and_return('Employee Name')
-      expect(@mock).to receive(:get).once.with('employees/1').and_return(nil)
-      e = SimpleLookup::Employee.new(1)
-      expect(e.name).to eq('Employee Name')
-      expect(e.unavailable).to be(nil)
+      it 'should not eager evaluate' do
+        expect(@mock).to_not receive(:get)
+        LazyEval::Employee.new(1)
+        LazyEval::HerEmployee.new(employee_id: 1)
+      end
     end
 
-    it 'should generate declarative attributes on the model with object based lookup value' do
-      module CompositeLookup
-        class Employee
-          include Looksist
-          attr_accessor :id, :employee_id, :contact_id
+    context 'lookup attributes' do
+      it 'should generate declarative attributes on the model with simple lookup value' do
+        module SimpleLookup
+          class Employee
+            include Looksist
+            attr_accessor :id, :employee_id
+            lookup :name, using: :id
+            lookup :unavailable, using: :employee_id
+
+            def initialize(id)
+              @id = @employee_id = id
+            end
+          end
+        end
 
-          lookup [:name, :location], using: :id
-          lookup [:age, :sex], using: :employee_id
-          lookup [:pager, :cell], using: :contact_id
+        expect(@mock).to receive(:get).once.with('ids/1').and_return('Employee Name')
+        expect(@mock).to receive(:get).once.with('employees/1').and_return(nil)
+        e = SimpleLookup::Employee.new(1)
+        expect(e.name).to eq('Employee Name')
+        expect(e.unavailable).to be(nil)
+      end
 
-          def initialize(id)
-            @contact_id = @id = @employee_id = id
+      it 'should generate declarative attributes on the model with object based lookup value' do
+        module CompositeLookup
+          class Employee
+            include Looksist
+            attr_accessor :id, :employee_id, :contact_id
+
+            lookup [:name, :location], using: :id
+            lookup [:age, :sex], using: :employee_id
+            lookup [:pager, :cell], using: :contact_id
+
+            def initialize(id)
+              @contact_id = @id = @employee_id = id
+            end
           end
         end
-      end
 
-      expect(@mock).to receive(:get).once.with('ids/1').and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
-      expect(@mock).to receive(:get).once.with('contacts/1').and_return({pager: 'pager', cell: 'cell'}.to_json)
-      expect(@mock).to receive(:get).twice.with('employees/1').and_return(nil)
-      e = CompositeLookup::Employee.new(1)
+        expect(@mock).to receive(:get).once.with('ids/1').and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
+        expect(@mock).to receive(:get).once.with('contacts/1').and_return({pager: 'pager', cell: 'cell'}.to_json)
+        expect(@mock).to receive(:get).twice.with('employees/1').and_return(nil)
+        e = CompositeLookup::Employee.new(1)
 
-      expect(e.name).to eq('Employee Name')
-      expect(e.location).to eq('Chennai')
+        expect(e.name).to eq('Employee Name')
+        expect(e.location).to eq('Chennai')
 
-      expect(e.age).to eq(nil)
-      expect(e.sex).to eq(nil)
+        expect(e.age).to eq(nil)
+        expect(e.sex).to eq(nil)
 
-      expect(e.pager).to eq('pager')
-      expect(e.cell).to eq('cell')
+        expect(e.pager).to eq('pager')
+        expect(e.cell).to eq('cell')
+      end
     end
-  end
 
-  context 'share storage between instances' do
-    class Employee
-      include Looksist
-      attr_accessor :id
+    context 'share storage between instances' do
+      class Employee
+        include Looksist
+        attr_accessor :id
 
-      lookup [:name, :location], using: :id
+        lookup [:name, :location], using: :id
 
-      def initialize(id)
-        @id = id
+        def initialize(id)
+          @id = id
+        end
       end
-    end
-    it 'should share storage between instances to improve performance' do
-      employee_first_instance = Employee.new(1)
-      expect(@mock).to receive(:get).once.with('ids/1')
-                       .and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
-      employee_first_instance.name
+      it 'should share storage between instances to improve performance' do
+        employee_first_instance = Employee.new(1)
+        expect(@mock).to receive(:get).once.with('ids/1')
+                         .and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
+        employee_first_instance.name
 
-      employee_second_instance = Employee.new(1)
-      expect(@mock).not_to receive(:get).with('ids/1')
+        employee_second_instance = Employee.new(1)
+        expect(@mock).not_to receive(:get).with('ids/1')
 
-      employee_second_instance.name
+        employee_second_instance.name
+      end
     end
   end
 end

metadata

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