basiccache 0.0.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59373a2671eea1a0d1797e282bd2a7d5e84f1fa9
+  data.tar.gz: e19a7bc60ee8be6d5658f6ec227bf466b489c252
+SHA512:
+  metadata.gz: 057250fb3fbe1be8bbc55ae2764bc7c748b41f696e33ef810d1a27d7d65fb9b2f0ae72aab245a324207e9d4d5304d84b006f1e82f54ead086441f8e4c711f4b1
+  data.tar.gz: 26672ff44bf1ff353e07396c7968eed5c95491b38a0463c12a5917e1db0bdfff6bd89775ac1edc20bb40c8df0330bf7f7c772f6ed4023adc1a7f72ba77036a1a

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Les Aker
+
+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,92 @@
+BasicCache
+========
+
+[![Gem Version](https://badge.fury.io/rb/basiccache.png)](http://badge.fury.io/rb/basiccache)
+
+Provides a minimal key/value caching layer
+
+## Usage
+
+First, initialize a caching object:
+
+```
+require 'basiccache'
+my_cache = BasicCache.new
+```
+
+From then on, when you want to cache the results of some processing, just call my_cache.cache(key) with the processing block:
+
+```
+require 'basiccache'
+require 'benchmark'
+
+my_cache = BasicCache.new
+
+3.times do
+    puts Benchmark.measure {
+        my_cache.cache('foo') do
+            (1..50_000).reduce { |acc, i| acc*i }
+        end
+    }
+end
+```
+
+Results:
+
+```
+# ruby example.rb
+  1.690000   0.000000   1.690000 (  1.698418)
+  0.000000   0.000000   0.000000 (  0.000011)
+  0.000000   0.000000   0.000000 (  0.000005)
+```
+
+To clear the cache, call .clear!:
+
+```
+my_cache = BasicCache.new
+
+# do stuff
+
+my_cache.clear!
+```
+
+The .clear! method can be passed a key name to clear just a specific key, as well.
+
+## Subclasses
+
+### TimeCache
+
+This cache behaves similarly, with the addition of a lifetime attribute.
+
+When creating a new cache object, provide a lifetime or use the default of 30 seconds:
+
+```
+default_cache = BasicCache::TimeCache.new
+puts "Default Lifetime: #{default_cache.lifetime}"
+
+custom_cache = BasicCache::TimeCache.new(3)
+puts "Default Lifetime: #{custom_cache.lifetime}"
+
+custom_cache.cache('test') { "fish" }
+puts "Does the cache include 'test'? #{custom_cache.include? 'test'}"
+sleep 5
+puts "Does the cache include 'test' now? #{custom_cache.include? 'test'}"
+```
+
+This returns the following:
+
+```
+Default Lifetime: 30
+Default Lifetime: 3
+Does the cache include 'test'? true
+Does the cache include 'test' now? false
+```
+
+## Installation
+
+    gem install basiccache
+
+## License
+
+BasicCache is released under the MIT License. See the bundled LICENSE file for details.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => [:test, :build, :install]
+

data/basiccache.gemspec

@@ -0,0 +1,16 @@
+require File.join(Dir.pwd, 'lib/basiccache.rb')
+
+Gem::Specification.new do |s|
+  s.name        = 'basiccache'
+  s.version     = BasicCache::VERSION
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.summary     = 'Provides a minimal key/value caching layer'
+  s.description = "Allows an application to dynamically cache values and retrieve them later"
+  s.authors     = ['Les Aker']
+  s.email       = 'me@lesaker.org'
+  s.files       = `git ls-files`.split
+  s.test_files  = `git ls-files test/`.split
+  s.homepage    = 'https://github.com/akerl/basiccache'
+  s.license     = 'MIT'
+end
+

data/lib/basiccache.rb

@@ -0,0 +1,115 @@
+##
+# This module provides a simple key/value cache for storing computation results
+
+module BasicCache
+  VERSION = '0.0.13'
+
+  class << self
+    ##
+    # Insert a helper .new() method for creating a new Cache object
+
+    def new(*args)
+      self::Cache.new(*args)
+    end
+  end
+
+  ##
+  # If we're using 2.0.0+, caller_locations is available and is much faster.
+  # If not, fall back to caller
+  # These methods return the name of the calling function 2 levels up
+  # This allows them to return the name of whatever called Cache.cache()
+
+  if Kernel.respond_to? 'caller_locations'
+    def self.get_caller
+      caller_locations(2, 1).first.label
+    end
+  else
+    def self.get_caller
+      caller[1][/`([^']*)'/, 1]
+    end
+  end
+
+  ##
+  # Cache object, maintains a key/value store
+
+  class Cache
+    attr_reader :store
+
+    ##
+    # Generate an empty store
+
+    def initialize
+      @store = {}
+    end
+
+    ##
+    # Empty out either the given key or the full store
+
+    def clear!(key = nil)
+      key.nil? ? @store.clear : @store.delete(key)
+    end
+
+    ##
+    # If the key is cached, return it.
+    # If not, run the code, cache the result, and return it
+
+    def cache(key = nil, &code)
+      key ||= BasicCache.get_caller
+      @store[key.to_sym] ||= code.call
+    end
+
+    ##
+    # Return the size of the cache
+
+    def size
+      @store.length
+    end
+
+    ##
+    # Check if a value is cached
+    # (just a wrapper, designed to be redefined by subclasses)
+
+    def include?(key = nil)
+      key ||= BasicCache.get_caller
+      @store.include? key.to_sym
+    end
+  end
+
+  ##
+  # Time-based cache object
+
+  class TimeCache < Cache
+    attr_reader :lifetime
+
+    ##
+    # Generate an empty store, with a default lifetime of 60 seconds
+
+    def initialize(lifetime = 30)
+      @lifetime = lifetime
+      @cache_item = Struct.new(:stamp, :value)
+      super()
+    end
+
+    ##
+    # If the key is cached but expired, clear it
+
+    def cache(key = nil, &code)
+      key ||= BasicCache.get_caller
+      key = key.to_sym
+      unless @store.include? key and Time.now - @store[key].stamp < @lifetime
+        @store[key] = @cache_item.new(Time.now, code.call)
+      end
+      @store[key].value
+    end
+
+    ##
+    # Check if a value is cached and not expired
+
+    def include?(key = nil)
+      key ||= BasicCache.get_caller
+      key = key.to_sym
+      @store.include? key and Time.now - @store[key].stamp < @lifetime
+    end
+  end
+end
+

data/test/test_cache.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'benchmark'
+require 'basiccache'
+
+class BasicCacheTest < Test::Unit::TestCase
+  def compute(n)
+    (1..n).reduce { |a, e| a * e }
+  end
+  
+  def test_creation
+    a = BasicCache.new
+    b = BasicCache::Cache.new
+    assert_instance_of BasicCache::Cache, a
+    assert_instance_of BasicCache::Cache, b
+    assert_equal a.store, {}
+    assert_equal b.store, {}
+  end
+
+  def test_caching
+    cache = BasicCache.new
+    cache.cache { compute(10) }
+    assert cache.store.include? :test_caching
+    assert_equal cache.store[:test_caching], 3628800
+    assert_equal cache.cache, 3628800
+  end
+
+  def test_clearing
+    cache = BasicCache.new
+    cache.cache { compute(10) }
+    assert_equal cache.store.length, 1
+    cache.clear!
+    assert_equal cache.store.length, 0
+  end
+
+  def test_speed_increase
+    cache = BasicCache.new
+    trials = 2.times.map { Benchmark.measure { cache.cache { compute(50_000) } }.real }
+    assert (trials[0] > trials[1]*1000)
+  end
+end
+

data/test/test_timecache.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'benchmark'
+require 'basiccache'
+
+class TimeCacheTest < Test::Unit::TestCase
+  def compute(n)
+    (1..n).reduce { |a, e| a * e }
+  end
+  
+  def test_creation
+    a = BasicCache::TimeCache.new
+    assert_instance_of BasicCache::TimeCache, a
+    assert_equal a.store, {}
+    assert_equal a.lifetime, 30
+    b = BasicCache::TimeCache.new(10)
+    assert_equal b.lifetime, 10
+  end
+
+  def test_caching
+    cache = BasicCache::TimeCache.new
+    cache.cache { compute(10) }
+    assert cache.store.include? :test_caching
+    assert_equal cache.store[:test_caching].value, 3628800
+    assert_equal cache.cache, 3628800
+  end
+
+  def test_clearing
+    cache = BasicCache::TimeCache.new
+    cache.cache { compute(10) }
+    assert_equal cache.store.length, 1
+    cache.clear!
+    assert_equal cache.store.length, 0
+  end
+
+  def test_speed_increase
+    cache = BasicCache::TimeCache.new
+    trials = 2.times.map { Benchmark.measure { cache.cache { compute(50_000) } }.real }
+    assert (trials[0] > trials[1]*1000)
+  end
+
+  def test_expiration
+    cache = BasicCache::TimeCache.new(3)
+    cache.cache(:test) { 100 }
+    assert cache.include? :test
+    sleep 5
+    assert cache.include?(:test) == false
+  end
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: basiccache
+version: !ruby/object:Gem::Version
+  version: 0.0.13
+platform: ruby
+authors:
+- Les Aker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-14 00:00:00.000000000 Z
+dependencies: []
+description: Allows an application to dynamically cache values and retrieve them later
+email: me@lesaker.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- basiccache.gemspec
+- lib/basiccache.rb
+- test/test_cache.rb
+- test/test_timecache.rb
+homepage: https://github.com/akerl/basiccache
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Provides a minimal key/value caching layer
+test_files:
+- test/test_cache.rb
+- test/test_timecache.rb