refreshing_cache 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4cff5afd7bfdb705da3ed12b2ac36492efe2be9e
+  data.tar.gz: ae5b1fab4134d77fc795d47d8b2447d83b90b2e9
+SHA512:
+  metadata.gz: 00472cf7709777ef9e16e85b680c142e61642123d83aeb7c4abbdbd264772d0ecfc135dcd0d3c767eb20f214f11aadec5aa176bdf17b57508ae6133bc1ed1efd
+  data.tar.gz: ac01f7da301cdaaaf60b9141419527c2c7d03c9f43e89c3bd8ffb8c016e62888690e321330271105d425b2c4b1f2524ccd62603e4483caf4a0218c70c955228b

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in refreshing_cache.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Schneider
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# RefreshingCache
+
+*Motivation:* We have a background job that unpredictably sets a database row
+that the application needs to be aware of on a regular, but delayed basis.  We
+can't afford to check for an update every request, and the processing the app
+needs to do when it does change is substantial, so we don't want to toss the
+cache unnecessarily.
+
+*What this is:* A hash wrapper that lets you set a timeout, a checking proc, and
+a refresh proc.
+
+* When a value isn't present, the refersh proc runs to populate the cache
+* When the timeout gets hit, the check_proc runs to see if a refresh is
+  actually required (just because it timed out doesn't mean the cache needs to be
+  tossed)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'refreshing_cache'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install refreshing_cache
+
+## Usage
+
+```ruby
+cache = RefreshingCache.new(timeout: 60,
+                            check_proc: ->(key, last_refreshed) { Post.find_by_key(key).updated_at > last_refreshed },
+                            value_proc: ->(key, last_refreshed) { Post.find_by_key(key).expensive_render } )
+
+cache["post1"] # => Cache miss - calls expensive_render to generate a value
+
+cache["post1"] # => Hasn't hit 60 seconds yet, no db hit
+
+sleep 60
+cache["post1"] # => 60 second timer is up, hits db to check if the post has been updated. It hasn't. Serves cached value
+
+update_post!
+cache["post1"] # => Hasn't hit 60 seconds since last check, so no db hit. Our cache is unfortunately stale.
+
+sleep 60
+cache["post1"] # => Hits the db, finds the post has changed, and calls the expensive_render call and serves that result.
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/cschneid/refreshing_cache/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'refreshing_cache'
+  ARGV.clear
+  IRB.start
+end

data/lib/refreshing_cache.rb

@@ -0,0 +1,43 @@
+require 'delegate'
+
+class RefreshingCache < DelegateClass(Hash)
+  VERSION = "1.0.0"
+
+  def initialize(timeout: timeout, check_proc: check_proc, value_proc: value_proc)
+    @timeout = timeout
+
+    @check_proc = check_proc
+    @refresh_proc = value_proc
+
+    # Stores key => timeout info
+    @timeouts = {}
+
+    # Actual underlying data we're caching
+    @hash = {}
+    super(@hash)
+  end
+
+  def [](key)
+    self[key] = refresh!(key) if regenerate_value?(key)
+    super
+  end
+
+  def refresh!(key)
+    val = refresh_proc.call(key, timeouts[key])
+    timeouts[key] = Time.now
+    val
+  end
+
+  protected
+  attr_reader :check_proc, :refresh_proc, :timeout, :timeouts
+
+  def regenerate_value?(key)
+    # No timeout info? We need to generate values.
+    return true unless timeouts.has_key?(key)
+
+    # If we've timed out, force a check
+    return false if timeouts[key] + timeout > Time.now
+
+    check_proc.call(key, timeouts[key])
+  end
+end

data/refreshing_cache.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'refreshing_cache'
+
+Gem::Specification.new do |spec|
+  spec.name          = "refreshing_cache"
+  spec.version       = RefreshingCache::VERSION
+  spec.authors       = ["Chris Schneider"]
+  spec.email         = ["chris@christopher-schneider.com"]
+  spec.summary       = %q{A hash-like object that attempts to refresh the keys based on some rules}
+  spec.description   = %q{A hash-like object that attempts to refresh the keys based on some rules.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec"
+end

data/spec/refreshing_cache_spec.rb

@@ -0,0 +1,76 @@
+$: << File.dirname(__FILE__) + "../"
+require 'refreshing_cache'
+
+# Sorry for the sleeps, it's the easiest way to test this without overmocking.
+describe RefreshingCache do
+  before do
+    @check_proc_return_value = true
+    @check_proc_call_count = 0
+    @value_proc_call_count = 0
+  end
+
+  let!(:timeout) { 0.3 }
+  let!(:check_proc) { ->(key, time) { @check_proc_call_count += 1; @check_proc_return_value } }
+  let!(:value_proc) { ->(key, time) { @value_proc_call_count += 1; "calculated_value_for_#{key}_#{@value_proc_call_count}" } }
+
+  subject(:cache) { RefreshingCache.new(timeout: timeout, check_proc: check_proc, value_proc: value_proc) }
+
+  describe "#[]" do
+    it "doesn't call check_proc if there is no cached value" do
+      cache["test"]
+      expect(@check_proc_call_count).to eq(0)
+    end
+
+    it "returns the value returned by the value_proc" do
+      expect(cache["test"]).to eq("calculated_value_for_test_1")
+    end
+
+    describe "with a cached value" do
+      before { cache["test"] }
+
+      # TODO: A more clever way to do this, probably by reaching in and tweaking the timeouts hash
+      def expire!(key)
+        sleep(0.5)
+      end
+
+      it "doesn't call the check_proc if the cached value is within the timeout" do
+        cache["test"]
+        expect(@check_proc_call_count).to eq(0)
+      end
+
+      it "doesn't call the value_proc if the cached value is within the timeout" do
+        cache["test"]
+        expect(@value_proc_call_count).to eq(1)
+      end
+
+      it "calls the check_proc if the timeout has expired" do
+        expire!("test")
+        cache["test"]
+        expect(@check_proc_call_count).to eq(1)
+      end
+
+      it "returns the value in the cache" do
+        expect(cache["test"]).to eq("calculated_value_for_test_1")
+      end
+
+      context "when the check proc returns true" do
+        before { @check_proc_return_value = true }
+
+        it "after expiration, it calls the value_proc" do
+          expire!("test")
+          cache["test"]
+          expect(@value_proc_call_count).to eq(2)
+        end
+
+        it "returns the new value_proc result" do
+          expire!("test")
+          expect(cache["test"]).to eq("calculated_value_for_test_2")
+        end
+      end
+
+      context "When the check proc returns false" do
+        before { @check_proc_return_value = false }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: refreshing_cache
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Chris Schneider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  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
+  name: rspec
+  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'
+description: A hash-like object that attempts to refresh the keys based on some rules.
+email:
+- chris@christopher-schneider.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/refreshing_cache.rb
+- refreshing_cache.gemspec
+- spec/refreshing_cache_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A hash-like object that attempts to refresh the keys based on some rules
+test_files:
+- spec/refreshing_cache_spec.rb