caches 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: 7a1b49f6dedacf8fe673dd362a21bea4b7c58e70
-  data.tar.gz: 3d4610b424dba43177a5578335b10d6c8aa05d3a
-!binary "U0hBNTEy":
-  metadata.gz: b379b47737f67aa92c477341b9408ef39e5eb59fed51af6393c11a6e1f66d8901c898fab63101ee01b0055155946e9504a360c3af3d0dc71b7d8f26360d144b0
-  data.tar.gz: 1efbb38364ee01c8fef3b5380c3ae34b1afad063575f673efab18bea28e1ec1f08a226b0fd14089efed1b75e656d2628d60cdffdf5d561f724ce319062d25451
+SHA1:
+  metadata.gz: 5b755f8f05416c7bd3e24c8ba950f77ac2daea8c
+  data.tar.gz: a698c0d6cfeaf897adef53e6f13b028e2531ce1d
+SHA512:
+  metadata.gz: 639943fc289cfe0bb9e78c52671ca55f6908b2ec282da95222b60303a15138f3274b18ce8627de05a22f0d233d31430dc5196df3d8b475917dfe8b23a7b56cc4
+  data.tar.gz: 890232456a3682cb1883332c317cc0cfb68868801ef468f17faa7f0e4d130dec53590e61820e42176506210fa4e6e5397c38349c47834d35c662efdd396d5d76

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+## Unreleased
+
+### Added
+
+Nothing
+
+### Changed
+Nothing
+
+### Removed
+Nothing
+
+## 0.0.3 - 2014-08-22
+
+Currently have Caches::TTL and Caches::LRU

data/README.md

@@ -8,21 +8,29 @@
 
 ### Caches::TTL
 
-TTL (Time To Live) remembers values for as many seconds as you tell it. The default is 3600 seconds (1 hour).
+TTL (Time To Live) remembers values for as many seconds as you tell it. The default is 3600 seconds (1 hour). Sub-seconds are supported; the tests will fail if the value is too low for your machine.
 
 ```ruby
 require 'caches/ttl'
 
-h = Caches::TTL.new(ttl: 5)
+h = Caches::TTL.new(ttl: 0.01)
 h[:a] = 'aardvark'
 h[:a] #=> 'aardvark'
-sleep(6)
+sleep(0.02)
 h[:a] #=> nil
 ```
 
-If you pass `refresh: true`, reading a value will reset its timer; otherwise, only writing will.
+#### Initialization Options
+
+- With `refresh: true`, reading a value will reset its timer; otherwise, only writing will.
+- With `max_keys: 5`, on insertion, it will evict the oldest item if necessary to keep from exceeding 5 keys.
+
+#### Methods
+
+`keys` and `values` work the same as for a hash. They **do not** check whether each key is current.
+
+`memoize` method fetches a key if it exists and isn't expired; otherwise, it calculates the value using the block and saves it.
 
-The `memoize` method fetches a key if it exists and isn't expired; otherwise, it calculates the value using the block and saves it.
 
 ```ruby
 h = Caches::TTL.new(ttl: 5)
@@ -67,10 +75,6 @@ Or install it yourself as:
 
     $ gem install caches
 
-## Coming Soon
-
-Other classes with different cache expiration strategies.
-
 ## Contributing
 
 1. Fork it

data/lib/caches/linked_list.rb

@@ -83,6 +83,12 @@ module Caches
       self if present?
     end
 
+    def delete(node)
+      excise(node).tap {
+        self.length = length - 1
+      }
+    end
+
     private
     attr_accessor :head, :tail
     attr_writer   :length

data/lib/caches/ttl.rb

@@ -1,3 +1,4 @@
+require 'time'
 require_relative 'accessible'
 
 module Caches
@@ -6,33 +7,67 @@ module Caches
     attr_accessor :ttl, :refresh
 
     def initialize(options = {})
-      self.ttl     = options.fetch(:ttl) { 3600 }
-      self.refresh = !!(options.fetch(:refresh, false))
-      self.data    = {}
+      self.ttl      = options.fetch(:ttl) { 3600 }
+      self.refresh  = !!(options.fetch(:refresh, false))
+      self.data     = {}
+      self.nodes    = LinkedList.new
+      self.max_keys = options[:max_keys]
     end
 
     def [](key)
       return nil unless data.has_key?(key)
-      if (current_time - data[key][:time]) < ttl
+      if current?(key) 
         data[key][:time] = current_time if refresh
         data[key][:value]
       else
+        node = data[key][:node]
+        nodes.delete(node)
         data.delete(key)
         nil
       end
     end
 
     def []=(key, val)
-      data[key] = {time: current_time, value: val}
+      if data.has_key?(key)
+        node = data[key][:node]
+        nodes.move_to_head(node)
+      else
+        if full?
+          evicted_node = nodes.pop
+          data.delete(evicted_node.value)
+        end
+        node = nodes.prepend(key)
+      end
+      data[key] = {time: current_time, value: val, node: node}
     end
 
     def size
-      data.keys.length
+      keys.length
+    end
+
+    def keys
+      data.keys
+    end
+
+    def values
+      data.values.map { |h| h.fetch(:value) }
     end
 
     private
 
-    attr_accessor :data
+    def current?(key)
+      (current_time - data[key][:time]) < ttl
+    end
+
+    def expired?(key)
+      !current?(key)
+    end
+
+    def full?
+      max_keys && size >= max_keys
+    end
+
+    attr_accessor :data, :nodes, :max_keys
 
     def current_time
       Time.now

data/lib/caches/version.rb

@@ -1,3 +1,3 @@
 module Caches
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/{hash_cache → caches}/linked_list_spec.rb

@@ -11,6 +11,13 @@ describe Caches::LinkedList do
     expect(list.to_a).to eq(['lemur'])
   end
 
+  it "knows its length" do
+    expect(list.length).to eq(1)
+    list.append('wombat')
+    list.prepend('vole')
+    expect(list.length).to eq(3)
+  end
+
   describe '#append' do
 
     it "adds an item to the end" do
@@ -49,11 +56,28 @@ describe Caches::LinkedList do
 
   end
 
-  it "knows its length" do
-    expect(list.length).to eq(1)
-    list.append('wombat')
-    list.prepend('vole')
-    expect(list.length).to eq(3)
+  describe "#delete" do
+
+    before :each do
+      @wombat_node = list.append('wombat')
+      list.append('vole')
+      expect(list.to_a).to eq(%w[lemur wombat vole])
+      expect(list.length).to eq(3)
+      @deleted_node = list.delete(@wombat_node)
+    end
+
+    it "removes an item" do
+      expect(list.to_a).to eq(%w[lemur vole])
+    end
+
+    it "returns the removed item" do
+      expect(@deleted_node).to eq(@wombat_node)
+    end
+
+    it "decrements the length" do
+      expect(list.length).to eq(2)
+    end
+
   end
 
   describe "#move_to_head" do

data/spec/{hash_cache → caches}/ttl_spec.rb

@@ -4,63 +4,87 @@ require_relative '../../lib/caches/ttl'
 
 describe Caches::TTL do
 
-  let(:options) { {} }
+  let(:ttl)         { 0.01 }
+  let(:most_of_ttl) { ttl * 0.8 }
+  let(:options)     { { ttl: ttl} }
   let(:cache)   {
     described_class.new(options).tap {|c|
+      c[:a] = 'Aravis'
+      c[:b] = 'Bern'
       c[:c] = 'Caspian'
-      c.stub(:current_time).and_return(start_time)
     }
   }
 
-  let(:start_time) { Time.now }
-  let(:before_ttl) { start_time + 1800 }
-  let(:after_ttl)  { start_time + 3601 }
-
   it "can report its size" do
-    expect(cache.size).to eq(1)
+    expect(cache.size).to eq(3)
   end
 
   it "remembers cached values before the TTL expires" do
     expect(cache[:c]).to eq('Caspian')
-    cache.stub(:current_time).and_return(before_ttl)
-    expect(cache[:c]).to eq('Caspian')
+    expect(cache.size).to eq(3)
+    # testing private method
+    expect(cache.send(:nodes).length).to eq(3)
   end
 
-  it "forgets cached values after the TTL expires" do
+  it "forgets cached values when a read is attempted after the TTL expires" do
     expect(cache[:c]).to eq('Caspian')
-    cache.stub(:current_time).and_return(after_ttl)
+    sleep(ttl)
     expect(cache[:c]).to be_nil
+    expect(cache.size).to eq(2)
+    # testing private method
+    expect(cache.send(:nodes).length).to eq(2)
+    expect(cache[:a]).to be_nil
+    expect(cache.size).to eq(1)
+    # testing private method
+    expect(cache.send(:nodes).length).to eq(1)
+  end
+
+  describe "listing keys and values" do
+
+    it "can list them" do
+      expect(cache.keys).to eq(%i[a b c])
+      expect(cache.values).to eq(%w[Aravis Bern Caspian])
+    end
+
+    it "does not check whether they are current" do
+      sleep(ttl)
+      expect(cache.keys).to eq(%i[a b c])
+      expect(cache.values).to eq(%w[Aravis Bern Caspian])
+    end
+
   end
 
   it "continues returning nil for cached values after the TTL expires" do
     expect(cache[:c]).to eq('Caspian')
-    cache.stub(:current_time).and_return(after_ttl)
+    sleep(ttl)
     expect(cache[:c]).to be_nil
     expect(cache[:c]).to be_nil
   end
 
   it "resets TTL when an item is updated" do
-    cache.stub(:current_time).and_return(before_ttl)
+    expect(cache[:c]).to eq('Caspian')
+    sleep(most_of_ttl)
     cache[:c] = 'Cornelius'
-    cache.stub(:current_time).and_return(after_ttl)
+    sleep(most_of_ttl)
     expect(cache[:c]).to eq('Cornelius')
   end
 
   it "doesn't reset TTL when an item is accessed" do
-    cache.stub(:current_time).and_return(before_ttl)
     expect(cache[:c]).to eq('Caspian')
-    cache.stub(:current_time).and_return(after_ttl)
+    sleep(most_of_ttl)
+    expect(cache[:c]).to eq('Caspian')
+    sleep(most_of_ttl)
     expect(cache[:c]).to be_nil
   end
 
   context "when asked to refresh TTL on access" do
 
-    let(:options) { {refresh: true} }
+    let(:options) { {ttl: ttl, refresh: true} }
 
     it "keeps values that were accessed before the TTL expired" do
-      cache.stub(:current_time).and_return(before_ttl)
+      sleep(most_of_ttl)
       expect(cache[:c]).to eq('Caspian')
-      cache.stub(:current_time).and_return(after_ttl)
+      sleep(most_of_ttl)
       expect(cache[:c]).to eq('Caspian')
     end
 
@@ -85,7 +109,6 @@ describe Caches::TTL do
         end
 
         it "does not calculate the value" do
-          cache.stub(:current_time).and_return(before_ttl)
           expect(greeting).not_to receive(:upcase)
           cache.memoize(:c) { greeting.upcase }
         end
@@ -95,13 +118,15 @@ describe Caches::TTL do
       context "after the TTL is up" do
 
         it "recalculates the value" do
-          cache.stub(:current_time).and_return(after_ttl)
+          expect(cache[:c]).to eq('Caspian')
+          sleep(ttl)
           expect(greeting).to receive(:upcase)
           cache.memoize(:c) { greeting.upcase }
         end
 
         it "returns the calculated value" do
-          cache.stub(:current_time).and_return(after_ttl)
+          expect(cache[:c]).to eq('Caspian')
+          sleep(ttl)
           expect(cache.memoize(:c) { |key| key.to_s.upcase }).to eq('C')
         end
 
@@ -122,14 +147,14 @@ describe Caches::TTL do
 
       it "does not calculate the value again within the TTL" do
         cache.memoize(:nonexistent) { greeting.upcase }
-        cache.stub(:current_time).and_return(before_ttl)
+        sleep(most_of_ttl)
         expect(greeting).not_to receive(:upcase)
         cache.memoize(:nonexistent) { greeting.upcase }
       end
 
       it "does calculate the value again after the TTL is up" do
         cache.memoize(:nonexistent) { greeting.upcase }
-        cache.stub(:current_time).and_return(after_ttl)
+        sleep(ttl)
         expect(greeting).to receive(:upcase)
         cache.memoize(:nonexistent) { greeting.upcase }
       end
@@ -138,4 +163,51 @@ describe Caches::TTL do
 
   end
 
+  describe "supporting a maximum size" do
+
+    let(:options) { {ttl: ttl, max_keys: 3} }
+
+    let!(:cache)   {
+      described_class.new(options).tap {|c|
+        c[:a] = 'Aravis'
+        c[:b] = 'Bern'
+      }
+    }
+
+    context "when it's not full" do
+
+      it "doesn't evict on insertion" do
+        expect(cache.size).to eq(2)
+        cache[:c] = 'Caspian'
+        expect(cache.size).to eq(3)
+      end
+
+    end
+
+    context "when it's full" do
+
+      before :each do
+        cache[:c] = 'Caspian'
+        expect(cache.size).to eq(3)
+      end
+
+      it "evicts the oldest key on insertion" do
+        cache[:d] = 'Drinian'
+        expect(cache.size).to eq(3)
+      end
+
+      it "doesn't evict on update" do
+        cache[:c] = 'Corin'
+        expect(cache.size).to eq(3)
+      end
+
+      it "doesn't evict on read" do
+        cache[:c]
+        expect(cache.size).to eq(3)
+      end
+
+    end
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: caches
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nathan Long
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,14 +28,14 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -61,6 +61,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -74,10 +75,10 @@ files:
 - lib/caches/lru.rb
 - lib/caches/ttl.rb
 - lib/caches/version.rb
+- spec/caches/linked_list_spec.rb
+- spec/caches/lru_spec.rb
+- spec/caches/ttl_spec.rb
 - spec/fetch_examples.rb
-- spec/hash_cache/linked_list_spec.rb
-- spec/hash_cache/lru_spec.rb
-- spec/hash_cache/ttl_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/nathanl/caches
 licenses:
@@ -89,12 +90,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -104,8 +105,8 @@ signing_key:
 specification_version: 4
 summary: Caches with hash-like access
 test_files:
+- spec/caches/linked_list_spec.rb
+- spec/caches/lru_spec.rb
+- spec/caches/ttl_spec.rb
 - spec/fetch_examples.rb
-- spec/hash_cache/linked_list_spec.rb
-- spec/hash_cache/lru_spec.rb
-- spec/hash_cache/ttl_spec.rb
 - spec/spec_helper.rb