looksist 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 548c83e23d27f194d2d8f18a525def021867efe1
-  data.tar.gz: 6f26ee73643662a541bb3f2b7ac0359d964092e7
+  metadata.gz: 4692f5e6e9889da65c8102e96df4c6568bc055d6
+  data.tar.gz: c29a30d638075b5b1c8ea4640eb0150d6835eb83
 SHA512:
-  metadata.gz: 906eaab20e3069cb554ca7b5fbd82d082a8e9cb2ebc893aef1ef737bf21f57bd597e2ddd6e65acf5f015832c1acaa50bb4b495235420147a3e272755baaf8d96
-  data.tar.gz: e9ad61712df22cba869456e71a30612d6f0d03ea5375e6ba601884e9260cc396e27475c17458277701ab7e44c2b0c58e8a6e7301a17df2be331eba928f12a2ca
+  metadata.gz: 0a9842bcb7941d3647be3ae3ab274665ddf8442a831499fc73b49b35e4023277c2b4f72a04af91e8c7db3a754afa8c6d5c84a0221db7db180133d9d429987575
+  data.tar.gz: 7a51b99b6bdd7c1e526408618cd780f3f336cd6e47ae3eeeed37433116ef124513d77b49be4289cbf8cdb21b6009c5d3aef8259cb399dfa836e2ca6b3a6e178d

data/README.md

@@ -28,8 +28,10 @@ Or install it yourself as:
 * Add an initializer to configure looksist
 
 ``` ruby
-Looksist.lookup_store_client ||= Redis.new(:url => (ENV['REDIS_URL'], :driver => :hiredis)
-Looksist.driver = Looksist::Serializers::Her
+Looksist.configure do |looksist|
+      looksist.lookup_store = Redis.new(:url => (ENV['REDIS_URL'], :driver => :hiredis)
+      looksist.driver =  Looksist::Serializers::Her
+end
 ```
 You need to specify the driver to manage the attributes. In this case, we use [HER](https://github.com/remiprev/her). You can add support for ActiveResource or ActiveRecord as needed (also refer to specs for free form usage without a driver).
 
@@ -49,7 +51,7 @@ it 'should generate declarative attributes on the model with simple lookup value
         end
       end
 
-      expect(Looksist.lookup_store_client).to receive(:get).with('ids/1').and_return('Employee Name')
+      expect(Looksist.lookup_store).to receive(:get).with('ids/1').and_return('Employee Name')
       e = SimpleLookup::Employee.new(1)
       expect(e.name).to eq('Employee Name')
 end
@@ -71,16 +73,6 @@ lookup [:name, :location], using = :employee_id
 
 ### With Plain Hashes
 
-* Add an initializer to configure looksist
-
-```ruby
-redis_client ||= Redis.new(:url => (ENV['REDIS_URL'], :driver => :hiredis)
-
-Looksist::Hashed.redis_service = Looksist::RedisService.instance do |lookup|
-  lookup.client = redis_client
-end
-
-```
 
 #### Columnar Hashes
 
@@ -89,7 +81,7 @@ end
 ```ruby
 it 'should inject multiple attribute to an existing hash' do
       class HashService
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {
@@ -121,7 +113,7 @@ it 'should inject multiple attribute to an existing hash' do
 ```ruby
 it 'should inject multiple attribute to an existing deep hash' do
     class EmployeeHash
-      include Looksist::Hashed
+      include Looksist
 
       def metrics
         {
@@ -156,7 +148,7 @@ it 'should inject multiple attribute to an existing deep hash' do
 ```ruby
 it 'should be capable to deep lookup and inject' do
       class Menu
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {

data/lib/looksist.rb

@@ -1,81 +1,31 @@
 require 'looksist/version'
 require 'jsonpath'
 require 'json'
+require 'looksist/core'
 require 'looksist/redis_service'
 require 'looksist/hashed'
 require 'looksist/her_collection'
+require 'looksist/safe_lru_cache'
 
-module Looksist
-  extend ActiveSupport::Concern
-  class << self;
-    attr_accessor :lookup_store_client, :driver
-  end
-
-  module ClassMethods
-
-    def bucket_name(entity_id)
-      entity = entity_id.to_s.gsub('_id', '')
-      entity.pluralize
-    end
 
-    def memoized(key)
-      self.storage ||= OpenStruct.new
-      self.storage[key] = self.storage[key] || Looksist.lookup_store_client.get(key)
-    end
+module Looksist
 
-    def mmemoized(key, values)
-      key_and_bucket = id_and_buckets.find{|h| h[:id] == key}
-      return if key_and_bucket.nil?
-      redis_keys = values.collect{|v| redis_key(key_and_bucket[:bucket], v)}
-      left_keys_to_lookup = redis_keys.select{|k| self.storage[k].nil?}
-      Looksist.lookup_store_client.mapped_mget(left_keys_to_lookup).each do |key, value|
-        self.storage[key] = value
-      end
+  extend ActiveSupport::Concern
 
-    end
+  include Core
+  include Hashed
 
-    def redis_key bucket, value
-      [bucket, '/', value].join('')
-    end
+  class << self
+    attr_accessor :lookup_store, :driver, :cache_buffer_size, :redis_service
 
-    def lookup(what, using, bucket = bucket_name(using))
-      self.lookup_attributes ||= []
-      self.id_and_buckets ||= []
-      self.id_and_buckets << {id: using, bucket: bucket}
-      if what.is_a? Array
-        what.each do |method_name|
-          define_method(method_name) do
-            JSON.parse(self.class.memoized(self.class.redis_key(bucket, self.send(using).try(:to_s))) || '{}')[method_name.to_s]
-          end
-          self.lookup_attributes << method_name
-        end
-      else
-        define_method(what) do
-          self.class.memoized(self.class.redis_key(bucket, self.send(using).try(:to_s)))
-        end
-        self.lookup_attributes << what.to_sym
+    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
       end
     end
-  end
-
-
 
-  def as_json(opts)
-    Looksist.driver.json_opts(self, opts)
   end
 
-  included do |base|
-    base.class_attribute :lookup_attributes, :storage, :id_and_buckets
-  end
-
-  module Serializers
-    class Her
-      class << self
-        def json_opts(obj, opts)
-          obj.class.lookup_attributes ||= []
-          obj.attributes.merge(obj.class.lookup_attributes.each_with_object({}) { |a, acc| acc[a] = obj.send(a) })
-        end
-      end
-    end
-  end
 end

data/lib/looksist/core.rb

@@ -0,0 +1,72 @@
+module Looksist
+  module Core
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def bucket_name(entity_id)
+        entity = entity_id.to_s.gsub('_id', '')
+        entity.pluralize
+      end
+
+      def memoized(key)
+        self.storage ||= OpenStruct.new
+        self.storage[key] = self.storage[key] || Looksist.lookup_store.get(key)
+      end
+
+      def mmemoized(key, values)
+        key_and_bucket = id_and_buckets.find{|h| h[:id] == key}
+        return if key_and_bucket.nil?
+        redis_keys = values.collect{|v| redis_key(key_and_bucket[:bucket], v)}
+        left_keys_to_lookup = redis_keys.select{|k| self.storage[k].nil?}
+        Looksist.lookup_store.mapped_mget(left_keys_to_lookup).each do |key, value|
+          self.storage[key] = value
+        end
+
+      end
+
+      def redis_key bucket, value
+        [bucket, '/', value].join('')
+      end
+
+      def lookup(what, using, bucket = bucket_name(using))
+        self.lookup_attributes ||= []
+        self.id_and_buckets ||= []
+        self.id_and_buckets << {id: using, bucket: bucket}
+        if what.is_a? Array
+          what.each do |method_name|
+            define_method(method_name) do
+              JSON.parse(self.class.memoized(self.class.redis_key(bucket, self.send(using).try(:to_s))) || '{}')[method_name.to_s]
+            end
+            self.lookup_attributes << method_name
+          end
+        else
+          define_method(what) do
+            self.class.memoized(self.class.redis_key(bucket, self.send(using).try(:to_s)))
+          end
+          self.lookup_attributes << what.to_sym
+        end
+      end
+    end
+
+    def as_json(opts)
+      Looksist.driver.json_opts(self, opts)
+    end
+
+    included do |base|
+      base.class_attribute :lookup_attributes, :storage, :id_and_buckets
+    end
+
+  end
+
+  module Serializers
+    class Her
+      class << self
+        def json_opts(obj, opts)
+          obj.class.lookup_attributes ||= []
+          obj.attributes.merge(obj.class.lookup_attributes.each_with_object({}) { |a, acc| acc[a] = obj.send(a) })
+        end
+      end
+    end
+  end
+end

data/lib/looksist/hashed.rb

@@ -5,10 +5,6 @@ module Looksist
   module Hashed
     extend ActiveSupport::Concern
 
-    class << self;
-      attr_accessor :redis_service
-    end
-
     module ClassMethods
       def inject(opts)
         raise 'Incorrect usage' unless [:after, :using, :populate].all? { |e| opts.keys.include? e }
@@ -49,7 +45,7 @@ module Looksist
     def inject_attributes_at(hash_offset, opts)
       keys = hash_offset[opts[:using]]
       entity_name = entity(opts[:using])
-      values = Hashed.redis_service.send("#{entity_name}_for", keys)
+      values = Looksist.redis_service.send("#{entity_name}_for", keys)
       hash_offset[opts[:populate]] = values
       hash_offset
     end
@@ -58,7 +54,7 @@ module Looksist
       arry_of_hashes.each do |elt|
         key = elt[opts[:using]]
         entity_name = entity(opts[:using])
-        value = Hashed.redis_service.send("#{entity_name}_for", [key])
+        value = Looksist.redis_service.send("#{entity_name}_for", [key])
         elt[opts[:populate]] = value.first
       end
     end

data/lib/looksist/redis_service.rb

@@ -1,50 +1,54 @@
 module Looksist
   class RedisService
+
     attr_accessor :client, :buffer_size, :cache
 
-    def self.instance
-      @_instance_ ||= new
-      @_instance_.cache ||= {}
-      yield @_instance_ if block_given?
-      @_instance_.buffer_size ||= 50000
-      @_instance_
+    class << self
+      private :new
+
+      def instance
+        @this ||= new
+        @this.buffer_size = 50000
+        yield @this if block_given?
+        @this.cache = SafeLruCache.new(@this.buffer_size)
+        @this
+      end
     end
 
-    def method_missing(m, *args, &block)
-      if m.to_s.ends_with?("_for")
-        entity = m.to_s.gsub('_for', '')
-        args.first.is_a?(Array) ? find_all(entity, args.first) : find(entity, args.first)
+    def method_missing(name, *args, &block)
+      if name.to_s.ends_with?("_for")
+        entity = name.to_s.gsub('_for','')
+        first_arg = args.first
+        first_arg.is_a?(Array) ? find_all(entity, first_arg) : find(entity, first_arg)
       else
-        super(m, args)
+        super(name, args)
       end
     end
 
-    private
-
-    def find(entity, id)
-      key = redis_key(entity, id)
-      hit_or_miss(key) do
-        @client.get(key)
-      end
+    def flush_cache!
+      @cache.clear
     end
 
+    private
 
     def find_all(entity, ids)
-      @client.pipelined do
-        ids.uniq.each do |id|
-          find(entity, id)
-        end
-      end
-      ids.each_with_object([]) { |k, acc| acc << cache[redis_key(entity, k)].value }
+      raise 'Buffer overflow! Increase buffer size' if ids.length > @buffer_size
+      keys = ids.collect { |id| redis_key(entity, id) }
+      missed_keys = (keys - @cache.keys).uniq
+      values = @client.mget missed_keys
+      @cache.merge!(Hash[*missed_keys.zip(values).flatten])
+      @cache.mslice(keys)
     end
 
-    def hit_or_miss(key, &block)
-      @cache[key] ||= lru(&block)
+    def find(entity, id)
+      key = redis_key(entity, id)
+      fetch(key) do
+        @client.get(key)
+      end
     end
 
-    def lru
-      @cache.shift if @cache.length >= @buffer_size
-      yield
+    def fetch(key, &block)
+      @cache[key] ||=  block.call
     end
 
     def redis_key(entity, id)

data/lib/looksist/safe_lru_cache.rb

@@ -0,0 +1,54 @@
+require 'monitor'
+
+module Looksist
+  class SafeLruCache < Hash
+
+    include MonitorMixin
+
+    def initialize(max_size)
+      @max_size = max_size
+      super(nil)
+    end
+
+    def []=(key, val)
+      synchronize do
+        super(key, val)
+        pop
+        val
+      end
+    end
+
+    def merge!(hash)
+      synchronize do
+        super(hash)
+        (count - @max_size).times { pop }
+      end
+    end
+
+    def mslice(keys)
+      synchronize do
+        keys.collect { |k| self[k] }
+      end
+    end
+
+    private
+
+    def pop
+      # not using shift coz: http://bugs.ruby-lang.org/issues/8312
+      delete(first[0]) if count > @max_size
+    end
+
+    def self.synchronize(*methods)
+      methods.each do |method|
+        define_method method do |*args, &blk|
+          synchronize do
+            super(*args, &blk)
+          end
+        end
+      end
+    end
+
+    synchronize :[], :each, :to_a, :delete, :count, :has_key?
+
+  end
+end

data/lib/looksist/version.rb

@@ -1,3 +1,3 @@
 module Lookist
-  VERSION = '0.0.8'
+  VERSION = '0.1.0'
 end

data/spec/{hashed_spec.rb → looksist/hashed_spec.rb}

@@ -2,25 +2,18 @@ require 'spec_helper'
 
 describe Looksist::Hashed do
   before(:each) do
-    class MockRedis
-      def pipelined
-        yield
-      end
-    end
-
-    @mock = MockRedis.new
-
-    Looksist::Hashed.redis_service = Looksist::RedisService.instance do |lookup|
-      lookup.client = @mock
+    @mock = {}
+    Looksist.configure do |looksist|
+      looksist.lookup_store = @mock
+      looksist.cache_buffer_size = 10
     end
   end
 
-
   context 'inject ' do
 
     it 'should be capable to deep lookup and inject' do
       class Menu
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {
@@ -40,26 +33,26 @@ describe Looksist::Hashed do
         inject after: :metrics, at: '$.table.menu', using: :item_id, populate: :item_name
       end
 
-      expect(@mock).to receive(:get).with('items/1').and_return(OpenStruct.new(value: 'Idly'))
-      expect(@mock).to receive(:get).with('items/2').and_return(OpenStruct.new(value: 'Pongal'))
+      expect(@mock).to receive(:mget).with(['items/1']).and_return(['Idly'])
+      expect(@mock).to receive(:mget).with(['items/2']).and_return(['Pongal'])
 
       expect(Menu.new.metrics).to eq({
-                                       table: {
-                                         menu: [{
-                                               item_id: 1,
-                                               item_name: 'Idly'
-                                           },
-                                           {
-                                               item_id: 2,
-                                               item_name: 'Pongal'
-                                           }]
-                                       }
+                                         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::Hashed
+        include Looksist
 
         def metrics
           {
@@ -102,7 +95,7 @@ describe Looksist::Hashed do
 
     it 'should be capable to deep lookup and inject on columnar hashes' do
       class DeepHash
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {
@@ -117,8 +110,7 @@ describe Looksist::Hashed do
         inject after: :metrics, at: '$.table.inner_table', using: :employee_id, populate: :employee_name
       end
 
-      expect(@mock).to receive(:get).with('employees/10').and_return(OpenStruct.new(value: 'emp 1'))
-      expect(@mock).to receive(:get).with('employees/20').and_return(OpenStruct.new(value: 'emp 2'))
+      expect(@mock).to receive(:mget).with(['employees/10', 'employees/20']).and_return(['emp 1', 'emp 2'])
 
       expect(DeepHash.new.metrics).to eq({table: {
           inner_table: {
@@ -130,7 +122,7 @@ describe Looksist::Hashed do
 
     it 'should inject single attribute to an existing hash' do
       class HashService1
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {
@@ -143,8 +135,7 @@ describe Looksist::Hashed do
         inject after: :metrics, at: :table, using: :employee_id, populate: :employee_name
       end
 
-      expect(@mock).to receive(:get).with('employees/1').and_return(OpenStruct.new(value: 'emp 1'))
-      expect(@mock).to receive(:get).with('employees/2').and_return(OpenStruct.new(value: 'emp 2'))
+      expect(@mock).to receive(:mget).with(['employees/1', 'employees/2']).and_return(['emp 1', 'emp 2'])
 
       expect(HashService1.new.metrics).to eq({table: {
           employee_id: [1, 2],
@@ -154,7 +145,7 @@ describe Looksist::Hashed do
 
     it 'should inject multiple attribute to an existing hash' do
       class HashService
-        include Looksist::Hashed
+        include Looksist
 
         def metrics
           {
@@ -169,11 +160,9 @@ describe Looksist::Hashed do
         inject after: :metrics, at: :table, using: :employer_id, populate: :employer_name
       end
 
-      expect(@mock).to receive(:get).with('employees/5').and_return(OpenStruct.new(value: 'emp 5'))
-      expect(@mock).to receive(:get).with('employees/6').and_return(OpenStruct.new(value: 'emp 6'))
+      expect(@mock).to receive(:mget).with(['employees/5', 'employees/6']).and_return(['emp 5', 'emp 6'])
 
-      expect(@mock).to receive(:get).with('employers/3').and_return(OpenStruct.new(value: 'empr 3'))
-      expect(@mock).to receive(:get).with('employers/4').and_return(OpenStruct.new(value: 'empr 4'))
+      expect(@mock).to receive(:mget).with(['employers/3', 'employers/4']).and_return(['empr 3', 'empr 4'])
 
       expect(HashService.new.metrics).to eq({table: {
           employee_id: [5, 6],
@@ -186,7 +175,7 @@ describe Looksist::Hashed do
 
   it 'should inject multiple attribute to an existing deep hash' do
     class EmployeeHash
-      include Looksist::Hashed
+      include Looksist
 
       def metrics
         {
@@ -203,11 +192,9 @@ describe Looksist::Hashed do
       inject after: :metrics, at: '$.table.database', using: :employer_id, populate: :employer_name
     end
 
-    expect(@mock).to receive(:get).with('employees/15').and_return(OpenStruct.new(value: 'emp 15'))
-    expect(@mock).to receive(:get).with('employees/16').and_return(OpenStruct.new(value: 'emp 16'))
+    expect(@mock).to receive(:mget).with(['employees/15', 'employees/16']).and_return(['emp 15', 'emp 16'])
 
-    expect(@mock).to receive(:get).with('employers/13').and_return(OpenStruct.new(value: 'empr 13'))
-    expect(@mock).to receive(:get).with('employers/14').and_return(OpenStruct.new(value: 'empr 14'))
+    expect(@mock).to receive(:mget).with(['employers/13', 'employers/14']).and_return(['empr 13', 'empr 14'])
 
     expect(EmployeeHash.new.metrics).to eq({table: {
         database: {
@@ -223,7 +210,7 @@ describe Looksist::Hashed do
   context 'multiple methods and injections' do
     it 'should inject multiple attribute to an existing hash' do
       class HashServiceSuper
-        include Looksist::Hashed
+        include Looksist
 
         def shrinkage
           {
@@ -245,11 +232,9 @@ describe Looksist::Hashed do
         inject after: :stock, at: :table, using: :dc_id, populate: :dc_name
       end
 
-      expect(@mock).to receive(:get).with('shrinks/1').and_return(OpenStruct.new(value: 'shrink 1'))
-      expect(@mock).to receive(:get).with('shrinks/2').and_return(OpenStruct.new(value: 'shrink 2'))
+      expect(@mock).to receive(:mget).with(['shrinks/1', 'shrinks/2']).and_return(['shrink 1', 'shrink 2'])
 
-      expect(@mock).to receive(:get).with('dcs/7').and_return(OpenStruct.new(value: 'dc 7'))
-      expect(@mock).to receive(:get).with('dcs/8').and_return(OpenStruct.new(value: 'dc 8'))
+      expect(@mock).to receive(:mget).with(['dcs/7', 'dcs/8']).and_return(['dc 7', 'dc 8'])
 
       hash_service_super = HashServiceSuper.new
       expect(hash_service_super.shrinkage).to eq({table: {

data/spec/{looksist_spec.rb → looksist/looksist_spec.rb}

@@ -3,8 +3,10 @@ require 'spec_helper'
 
 describe Looksist do
   before :each do
-    Looksist.lookup_store_client = double('store_lookup_client')
-    Looksist.driver = Looksist::Serializers::Her
+    Looksist.configure do |looksist|
+      looksist.lookup_store = double('store_lookup_client')
+      looksist.driver =  Looksist::Serializers::Her
+    end
   end
 
   context 'Serialization Support' do
@@ -22,7 +24,7 @@ describe Looksist do
           end
         end
       end
-      expect(Looksist.lookup_store_client).to receive(:get).with('employees/1').and_return('Employee Name')
+      expect(Looksist.lookup_store).to receive(:get).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)
@@ -42,7 +44,7 @@ describe Looksist do
           end
         end
       end
-      expect(Looksist.lookup_store_client).to receive(:get).with('employees/1').and_return('Employee Name')
+      expect(Looksist.lookup_store).to receive(:get).with('employees/1').and_return('Employee Name')
       e = ExplicitBucket::Employee.new(1)
       expect(e.name).to eq('Employee Name')
     end
@@ -61,7 +63,7 @@ describe Looksist do
       end
     end
     it 'should not eager evaluate' do
-      expect(Looksist.lookup_store_client).to_not receive(:get)
+      expect(Looksist.lookup_store).to_not receive(:get)
       LazyEval::Employee.new(1)
     end
   end
@@ -81,8 +83,8 @@ describe Looksist do
         end
       end
 
-      expect(Looksist.lookup_store_client).to receive(:get).with('ids/1').and_return('Employee Name')
-      expect(Looksist.lookup_store_client).to receive(:get).with('employees/1').and_return(nil)
+      expect(Looksist.lookup_store).to receive(:get).with('ids/1').and_return('Employee Name')
+      expect(Looksist.lookup_store).to receive(:get).with('employees/1').and_return(nil)
       e = SimpleLookup::Employee.new(1)
       expect(e.name).to eq('Employee Name')
       expect(e.unavailable).to be(nil)
@@ -103,9 +105,9 @@ describe Looksist do
         end
       end
 
-      expect(Looksist.lookup_store_client).to receive(:get).with('ids/1')
+      expect(Looksist.lookup_store).to receive(:get).with('ids/1')
                                               .and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
-      expect(Looksist.lookup_store_client).to receive(:get).twice.with('employees/1')
+      expect(Looksist.lookup_store).to receive(:get).twice.with('employees/1')
                                               .and_return(nil)
       e = CompositeLookup::Employee.new(1)
 
@@ -130,12 +132,12 @@ describe Looksist do
     end
     it 'should share storage between instances to improve performance' do
       employee_first_instance = Employee.new(1)
-      expect(Looksist.lookup_store_client).to receive(:get).with('ids/1')
+      expect(Looksist.lookup_store).to receive(:get).with('ids/1')
                                               .and_return({name: 'Employee Name', location: 'Chennai'}.to_json)
       employee_first_instance.name
 
       employee_second_instance = Employee.new(1)
-      expect(Looksist.lookup_store_client).not_to receive(:get).with('ids/1')
+      expect(Looksist.lookup_store).not_to receive(:get).with('ids/1')
 
       employee_second_instance.name
     end
@@ -164,7 +166,7 @@ describe Looksist do
     AnotherDeveloperClass.storage['cities/2'] = 'Delhi'
 
     it 'make single request for multiple values' do
-      expect(Looksist.lookup_store_client).to receive(:mapped_mget).with(%w(cities/4 cities/5))
+      expect(Looksist.lookup_store).to receive(:mapped_mget).with(%w(cities/4 cities/5))
                         .and_return({'cities/4' => 'Bangalore', 'cities/5' => 'Kolkata'})
       AnotherDeveloperClass.mmemoized(:city_id, [1, 4, 5])
 

data/spec/looksist/redis_service_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Looksist::RedisService do
+
+  context 'single lookup' do
+    before(:each) do
+      @lookup = Looksist::RedisService.instance do |lookup|
+        lookup.client = {}
+        lookup.buffer_size = 1
+      end
+      @lookup.cache.clear
+    end
+
+    it 'should call redis when key not present in cache' do
+      expect(@lookup.client).to receive(:get).once.with('sub_categories/8001').and_return('CEREALI')
+      expect(@lookup.sub_category_for(8001)).to eq('CEREALI')
+      expect(@lookup.sub_category_for(8001)).to eq('CEREALI')
+    end
+
+    it 'should abandon older entries incase of buffer overflow' do
+      expect(@lookup.client).to receive(:get).once.with('sub_families/12').and_return('DON CORLEONE')
+      expect(@lookup.client).to receive(:get).once.with('sub_families/34').and_return('SOPRANOS')
+
+      expect(@lookup.sub_family_for(12)).to eq('DON CORLEONE')
+      expect(@lookup.sub_family_for(34)).to eq('SOPRANOS')
+      expect(@lookup.cache.keys).to match_array(['sub_families/34'])
+    end
+
+  end
+
+  context 'multi lookup' do
+
+    before(:each) do
+      @mock = {}
+      @lookup = Looksist::RedisService.instance do |lookup|
+        lookup.client = @mock
+        lookup.buffer_size = 5
+      end
+    end
+
+    it 'should mget redis when there are multiple keys' do
+      expect(@mock).to receive(:mget).with(['snacks/1', 'snacks/2', 'snacks/3']).once.and_return(['BAJJI', 'BONDA', 'VADA'])
+      expect(@lookup.snacks_for([1, 2, 3])).to match_array(%w(BAJJI BONDA VADA))
+    end
+
+    it 'should mget redis only for unique keys' do
+      expect(@mock).to receive(:mget).with(['snacks/1', 'snacks/2', 'snacks/3']).once.and_return(['BAJJI', 'BONDA', 'VADA'])
+      expect(@lookup.snacks_for([1, 2, 3, 1, 2])).to match_array(%w(BAJJI BONDA VADA BAJJI BONDA))
+    end
+  end
+
+  context 'value not present' do
+    before(:each) do
+      @mock = {}
+      @lookup = Looksist::RedisService.instance do |lookup|
+        lookup.client = @mock
+        lookup.buffer_size = 5
+      end
+    end
+
+    it 'should not bomb when there are no values present' do
+      expect(@mock).to receive(:mget).with(['snacks/1', 'snacks/2', 'snacks/3']).once.and_return(['BAJJI', nil, 'VADA'])
+      expect(@lookup.snacks_for([1, 2, 3])).to match_array(["BAJJI", nil, "VADA"])
+    end
+  end
+
+  context 'flush local cache' do
+    before(:each) do
+      @mock = {}
+      @lookup = Looksist::RedisService.instance do |lookup|
+        lookup.client = @mock
+        lookup.buffer_size = 5
+      end
+    end
+
+    it 'should clear the local cache' do
+      expect(@mock).to receive(:mget).with(['snacks/1', 'snacks/2', 'snacks/3']).once.and_return(['BAJJI', nil, 'VADA'])
+      @lookup.snacks_for([1, 2, 3])
+      expect(@lookup.cache.size).to eq(3)
+      @lookup.flush_cache!
+      expect(@lookup.cache).to be_empty
+    end
+  end
+end

data/spec/looksist/safe_lru_cache_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Looksist::SafeLruCache do
+
+  before :each do
+    @cache = Looksist::SafeLruCache.new(3)
+  end
+
+  context 'one entry' do
+
+    it 'should hold only entries limited by max size' do
+      @cache[:a] = 1
+      @cache[:b] = 2
+      @cache[:c] = 3
+      @cache[:d] = 4
+      expect(@cache.size).to eq(3)
+      expect(@cache.keys).to match_array([:b, :c, :d])
+    end
+
+  end
+
+  context 'multiple entries' do
+
+    it 'should flush other entries when new entries are added' do
+      @cache = Looksist::SafeLruCache.new(3)
+      @cache[:a] = 1
+      @cache[:b] = 2
+      @cache.merge!(c: 3, d: 4, e: 5)
+      expect(@cache.size).to eq(3)
+      expect(@cache.keys).to match_array([:c, :d, :e])
+    end
+
+    it 'race conditions when actual size equals max size' do
+      @cache[:a] = 1
+      @cache[:b] = 2
+      @cache.merge!(c: 3)
+      expect(@cache.size).to eq(3)
+      expect(@cache.keys).to match_array([:a, :b, :c])
+    end
+
+  end
+
+  context '#mslice' do
+    it 'should slice hash for repeating keys' do
+      @cache.merge!(a: 1, b: 2, c: 3)
+      expect(@cache.mslice([:a, :b, :c, :a, :b])).to match_array([1, 2, 3, 1, 2])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'ostruct'
 require 'looksist'
 require 'looksist/redis_service'
 require 'looksist/hashed'
+require 'looksist/safe_lru_cache'
 require 'pry'
 
 module Her
@@ -27,3 +28,6 @@ end
 
 TEST_API.setup url: 'http://dummy.com', &config
 
+RSpec.configure do |config|
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: looksist
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - RC
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-17 00:00:00.000000000 Z
+date: 2014-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,14 +169,17 @@ files:
 - README.md
 - Rakefile
 - lib/looksist.rb
+- lib/looksist/core.rb
 - lib/looksist/hashed.rb
 - lib/looksist/her_collection.rb
 - lib/looksist/redis_service.rb
+- lib/looksist/safe_lru_cache.rb
 - lib/looksist/version.rb
 - looksist.gemspec
-- spec/hashed_spec.rb
-- spec/looksist_spec.rb
-- spec/redis_service_spec.rb
+- spec/looksist/hashed_spec.rb
+- spec/looksist/looksist_spec.rb
+- spec/looksist/redis_service_spec.rb
+- spec/looksist/safe_lru_cache_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jpsimonroy/herdis
 licenses:
@@ -203,7 +206,8 @@ signing_key:
 specification_version: 4
 summary: Redis backed lookup for your models
 test_files:
-- spec/hashed_spec.rb
-- spec/looksist_spec.rb
-- spec/redis_service_spec.rb
+- spec/looksist/hashed_spec.rb
+- spec/looksist/looksist_spec.rb
+- spec/looksist/redis_service_spec.rb
+- spec/looksist/safe_lru_cache_spec.rb
 - spec/spec_helper.rb

data/spec/redis_service_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Looksist::RedisService do
-
-  class MockRedis
-    def pipelined
-      yield
-    end
-  end
-
-  context 'single lookup' do
-    before(:each) do
-      @lookup = Looksist::RedisService.instance do |lookup|
-        lookup.client = {}
-        lookup.buffer_size = 1
-      end
-      @lookup.cache.clear
-    end
-
-    it 'should call redis when key not present in cache' do
-      expect(@lookup.client).to receive(:get).with('sub_categories/8001').and_return('CEREALI')
-      expect(@lookup.sub_category_for(8001)).to eq('CEREALI')
-      expect(@lookup.sub_category_for(8001)).to eq('CEREALI')
-    end
-
-    it 'should abandon older entries incase of buffer overflow' do
-      expect(@lookup.client).to receive(:get).with('sub_families/12').and_return('DON CORLEONE')
-      expect(@lookup.client).to receive(:get).with('sub_families/34').and_return('SOPRANOS')
-
-      expect(@lookup.sub_family_for(12)).to eq('DON CORLEONE')
-      expect(@lookup.sub_family_for(34)).to eq('SOPRANOS')
-      expect(@lookup.cache.keys).to match_array(['sub_families/34'])
-    end
-
-  end
-
-  context 'multi lookup' do
-
-    before(:each) do
-      @mock = MockRedis.new
-      @lookup = Looksist::RedisService.instance do |lookup|
-        lookup.client = @mock
-        lookup.buffer_size = 5
-      end
-    end
-
-    it 'should pipeline calls to redis when there are multiple keys' do
-      expect(@mock).to receive(:get).with('snacks/1').and_return(OpenStruct.new(value:'BAJJI'))
-      expect(@mock).to receive(:get).with('snacks/2').and_return(OpenStruct.new(value:'BONDA'))
-      expect(@mock).to receive(:get).with('snacks/3').and_return(OpenStruct.new(value:'VADA'))
-
-      expect(@lookup.snacks_for([1,2,3,1])).to match_array(%w(BAJJI BONDA VADA BAJJI))
-    end
-  end
-end