blunt-cache 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36219a4ebbe5e011cfccc581cee7d60585f2cf96
-  data.tar.gz: b86c47768e3bc83ec119cc432aa08130998dccf5
+  metadata.gz: 05f69782e6693f701b6163492ba7691080be6bdf
+  data.tar.gz: a543120a64bc44e0f1de54bf0d4bd5e2e9357e72
 SHA512:
-  metadata.gz: 74d110765ae9801c3d12368a40d9bceb9e7eae4e0bbc23b61412c22d03776d7650a092e12f431551142c65854bbb77d1047016b2febf90e95c0e122b2fcabcf1
-  data.tar.gz: 73025278992ede01a738c9b3185bd8615461c83077abee865149f97fd60718d4462c348b36207cefbf6ade24ef653d85bb114f762a89059e384a2538bcddb030
+  metadata.gz: 14490f56139a5d252ae1ef9e8617b69ff2b234dc80255d08a959c3568350b9cace55251fdf5ed96a449d0a4cf202f8746dad1dabad6ff6c2d255ffd513b2df67
+  data.tar.gz: 137f43be21cf0513e56c318d82cce66912842cea0215c157cd4b3d417606294b7d7954ebc4ff059fee7f066449954546310c292b329cf1c65f58cfc34de1d026

data/README.md

@@ -1,31 +1,45 @@
 # BluntCache
 Simple in-memory cache service for Ruby.
 
+[![Build Status](https://travis-ci.org/appelsin/blunt_cache.svg?branch=master)](https://travis-ci.org/appelsin/blunt_cache)
+[![Code Climate](https://codeclimate.com/github/appelsin/blunt_cache/badges/gpa.svg)](https://codeclimate.com/github/appelsin/blunt_cache)
+
 ## Usage
 
-    # set/get by key
-    BluntCache.set "key", data
-    data = BluntCache.get "key"
-
-    # executes block if not set or expired
-    data = BluntCache.fetch "key" do
-      do_something
-    end
-
-    # time to live can be provided (dafault is 60 sec)
-    BluntCache.set "key", expire: 120 data
-    BluntCache.fetch "key", expire: 120 do
-      do_something
-    end
-
-    # inherit it for namespacing and extending
-    class MyCache < BluntCache
-      @expire_default = 30
-    end
-
-    MyCache.set "1", "2"
-    BluntCache.set "1", "3"
-    MyCache.get "1" #2
+```ruby
+# set/get by key
+BluntCache.set "key", data
+data = BluntCache.get "key"
+
+# executes block if not set or expired
+data = BluntCache.fetch "key" do
+  do_something
+end
+
+# time to live can be provided (default is 60 sec)
+BluntCache.set "key", expire: 120 data
+BluntCache.fetch "key", expire: 120 do
+  do_something
+end
+
+# checks if key exists
+BluntCache.key? "nil_key" # false
+BluntCache.set "nil_key", nil
+BluntCache.key? "nil_key" # true
+
+# doesn't re-executes nil fetches
+data = BluntCache.fetch("heavy_key") { sleep 1; nil } # some heavy block returning nil
+data = BluntCache.fetch("heavy_key") { sleep 1; nil } # doesn't re-executes if not expired
+
+# inherit it for namespacing and extending
+class MyCache < BluntCache
+  @expire_default = 30
+end
+
+MyCache.set "1", "2"
+BluntCache.set "1", "3"
+MyCache.get "1" #2
+```
 
 ## Why? When to use?
 

data/lib/blunt-cache.rb

@@ -4,7 +4,7 @@ class BluntCache
 
   # Store +data+ in cache by +key+ for +:expire+ seconds (default is 60 sec)
   #   def self.set(key, data, expire: nil)
-  def self.set(key, data, options = {}, *args)
+  def self.set(key, data, options = {})
     expire = options[:expire]
     self.timestamp[key] = Time.now + (expire || self.expire_default)
     self.data[key] = data
@@ -16,14 +16,21 @@ class BluntCache
     self.timestamp[key].is_a?(Time) && Time.now < self.timestamp[key] ? self.data[key] : nil
   end
 
+  # Checks if key present in store.
+  # Returns true if key exists (even if value is false or nil) and false if key doesn't exist or expired.
+  def self.key?(key)
+    self.data.key?(key) && self.timestamp[key].is_a?(Time) && Time.now < self.timestamp[key]
+  end
+
   # Get +key+ from cache. Executes +block+, stores it's result and returns it if not set or expired.
   #   def self.fetch(key, expire: nil, &block)
   def self.fetch(key, options = {}, &block)
     expire = options[:expire]
-    result = self.get key
-    if result.nil?
-      self.set key, block.call, :expire => expire
+    if self.key?(key)
+      self.data[key]
     else
+      result = block.call
+      self.set key, result, :expire => expire
       result
     end
   end
@@ -34,8 +41,6 @@ class BluntCache
     @timestamp = {}
   end
 
-protected
-
   def self.data
     @data||= {}
   end

data/lib/blunt-cache/version.rb

@@ -1,3 +1,3 @@
 class BluntCache
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/blunt_cache_spec.rb

@@ -11,54 +11,123 @@ describe BluntCache do
 
   [BluntCache, MyCache, ShortCache].each do |c|
     context '#{c.name}' do
-      it 'stores data' do
-        expect { c.set("1", "1_val") }.not_to raise_error
-        result = nil
-        expect { result = c.get("1") }.not_to raise_error
-        expect(result).to eq "1_val"
-        expect { c.set("1", "1_val_2") }.not_to raise_error
-        expect { result = c.get("1") }.not_to raise_error
-        expect(result).to eq "1_val_2"
+      context 'set' do
+        it { expect(c.set("1", "1_val")).to eq "1_val" }
       end
 
-      it 'returns nil on no data' do
-        result = "value"
-        expect { result = c.get("2") }.not_to raise_error
-        expect(result).to eq nil
+      context 'get' do
+        before(:all) { c.set("1", "1_val") }
+
+        it { expect(c.get("1")).to eq "1_val" }
+
+        it 'returns previous set value' do
+          c.set("1", "1_val_2")
+          expect(result = c.get("1")).to eq "1_val_2"
+        end
+
+        it 'returns nil if not set' do
+          expect(c.get("2")).to eq nil
+        end
       end
 
-      it 'returns value before expiration and nil after expiration' do
-        expect { c.set("3", "3_val", :expire => 0.1) }.not_to raise_error
-        result = nil
-        expect { result = c.get("3") }.not_to raise_error
-        expect(result).to eq "3_val"
-        sleep(0.09)
-        expect { result = c.get("3") }.not_to raise_error
-        expect(result).to eq "3_val"
-        sleep(0.02)
-        expect { result = c.get("3") }.not_to raise_error
-        expect(result).to eq nil
+      context 'get with expiration' do
+        before(:each) { c.set("3", "3_val", :expire => 0.1) }
+
+        it { expect(c.get("3")).to eq "3_val" }
+
+        it 'returns value after short sleep' do
+          sleep(0.09)
+          expect(c.get("3")).to eq "3_val"
+        end
+
+        it 'returns nil after long sleep' do
+          sleep(0.11)
+          expect(c.get("3")).to eq nil
+        end
       end
 
-      it 'evals block in fetch if cache not set' do
-        expect(c.get("4")).to eq nil
-        result = nil
-        expect { result = c.fetch("4") do "4_val" end }.not_to raise_error
-        expect(result).to eq "4_val"
-        expect(c.get("4")).to eq "4_val"
-        expect { result = c.fetch("4") do "4_val_2" end }.not_to raise_error
-        expect(result).to eq "4_val"
+      context 'key?' do
+        before(:all) { c.set("k1", "k1_val") }
+
+        it { expect(c.key?("k1")).to eq true }
+        it 'returns false if not set' do
+          expect(c.key?("k2")).to eq false
+        end
+      end
+
+      context 'key? with expiration' do
+        before(:each) { c.set("k3", "k3_val", :expire => 0.1) }
+
+        it { expect(c.key?("k3")).to eq true }
+
+        it 'returns true after short sleep' do
+          sleep(0.09)
+          expect(c.key?("k3")).to eq true
+        end
+
+        it 'returns false after long sleep' do
+          sleep(0.11)
+          expect(c.key?("k3")).to eq false
+        end
+      end
+
+      context 'fetch' do
+        it 'executes block for a first time' do
+          executed = :not_executed
+          expect(c.fetch("4-0") { executed = :executed }).to eq :executed
+          expect(executed).to eq :executed
+        end
+
+        it 'sets value from block' do
+          expect(c.get("4")).to eq nil #pre-check
+          expect(c.fetch("4") { "4_val" }).to eq "4_val"
+        end
+
+        it 'doesn\'t execute block for a second time' do
+          expect(c.fetch("4-1") { :executed_first }).to eq :executed_first
+          executed = :not_executed
+          expect(c.fetch("4-1") { executed = :executed_second }).to eq :executed_first
+          expect(executed).to eq :not_executed
+        end
+      end
+
+      context 'fetch with experation' do
+        it 'recieves :expire' do
+          expect( c.fetch("6", :expire => 0.1) { "6_val" } ).to eq "6_val"
+        end
+
+        it 'doesn\'t execute block for a second time' do
+          expect(c.fetch("6-1", :expire => 0.1) { :executed_first }).to eq :executed_first
+          executed = :not_executed
+          expect(c.fetch("6-1", :expire => 0.1) { executed = :executed_second }).to eq :executed_first
+          expect(executed).to eq :not_executed
+        end
+
+        it 'doesn\'t execute block for a second time after short sleep' do
+          expect(c.fetch("6-2", :expire => 0.1) { :executed_first }).to eq :executed_first
+          executed = :not_executed
+          sleep(0.09)
+          expect(c.fetch("6-2", :expire => 0.1) { executed = :executed_second }).to eq :executed_first
+          expect(executed).to eq :not_executed
+        end
+
+        it 'executes block for a second time after long sleep' do
+          expect(c.fetch("6-3", :expire => 0.1) { :executed_first }).to eq :executed_first
+          executed = :not_executed
+          sleep(0.11)
+          expect(c.fetch("6-3", :expire => 0.1) { executed = :executed_second }).to eq :executed_second
+          expect(executed).to eq :executed_second
+        end
       end
 
-      it 'returns value before expiration and re-executes block after expiration (fetch)' do
-        result = nil
-        expect { result = c.fetch "6", :expire => 0.1 do "6_val" end }.not_to raise_error
-        expect(result).to eq "6_val"
-        expect { result = c.fetch "6" do "6_val_2" end }.not_to raise_error
-        expect(result).to eq "6_val"
-        sleep(0.11)
-        expect { result = c.fetch "6" do "6_val_3" end }.not_to raise_error
-        expect(result).to eq "6_val_3"
+      context 'fetch with nil' do
+        it 'doesn\'t re-executes for nil value' do
+          execution_counter = 0
+          expect(c.fetch("nill") { execution_counter+= 1; nil }).to eq nil
+          expect(execution_counter).to eq 1
+          expect(c.fetch("nill") { execution_counter+= 1; nil }).to eq nil
+          expect(execution_counter).to eq 1
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blunt-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Roman Exempliarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,10 +90,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Simple in-memory cache service for Ruby.
 test_files:
 - spec/blunt_cache_spec.rb
 - spec/spec_helper.rb
+has_rdoc: