ruby-blockcache 0.2

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010, Matthew Scharley
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Neither the name of the copyright holder, BlockCache nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,44 @@
+# BlockCache
+
+by Matthew Scharley  
+http://github.com/mscharley/ruby-blockcache
+
+## Overview
+
+> In computer science, a cache is a component that improves performance 
+> by transparently storing data such that future requests for that 
+> data can be served faster.
+>
+> -- [Cache at Wikipedia](http://en.wikipedia.org/wiki/Cache)
+
+Typical caches do this by allowing you to store data in them, along with
+a time limit to describe how long this data is valid for. You then need
+to check if the data is available, and if not, regenerate it and store
+it again, ready for next time.
+
+BlockCache eliminates all this. You define your cache, describe the
+elements it contains, and then you never have to worry about making
+sure you have fresh data again. Of course, if you need to ensure that
+you are getting clean, uncached data, you can do that too.
+
+## Example Usage
+
+    require 'blockcache'
+    
+    cache = BlockCache.new
+    cache.add('name', 10) do
+      puts "Hello, what is your name?"
+      STDIN.gets.strip
+    end
+    
+    for i in [1,2]
+      for j in [1,3]
+        puts "Hello " + cache['name'] + "!"
+      end
+      cache.refresh
+    end
+
+In the example above, you get asked for your name, then it says 
+hello to you three times. Note, each time is using the exact same
+code. The program then tells the cache that it wants fresh data,
+and repeats the process.

data/lib/blockcache.rb

@@ -0,0 +1,120 @@
+
+# This is a class used to cache data from the repository, so that it 
+# needn't be queried over and over. Use a timeout of a few seconds to
+# prevent repeated queries in the same operation, but preserve the 
+# ability to retrieve up to date data.
+#
+# You can call #refresh to reset all the timeouts manually if you
+# need to guarantee fresh data
+#
+# Example usage:
+#
+# def cache
+#   @cache ||= begin
+#     c = BlockCache.new
+#     c.add("test", 10) { "Hello world!" }
+#     # This block always returns the same thing, so never refresh it
+#     c.add("test2") { |name| "Hello #{name}" }
+#     c
+#   end
+# end
+#
+# cache["test2", "Matthew"] # "Hello Matthew"
+
+class BlockCache
+  
+  #attr_reader :values, :accessed
+  
+  def initialize(default=nil)
+    @default_value = default
+    @blocks = {}
+    @timeouts = {}
+    @accessed = {}
+    @values = {}
+  end
+  
+  def add(name, timeout, &block)
+    @blocks[name] = block
+    @timeouts[name] = timeout
+  end
+  
+  def [](name, *args)
+    return @default_value if not @blocks.keys.include?(name)
+    
+    atime = get_accessed(@accessed, [name, *args])
+    ctime = Time.now
+    
+    if ((not @timeouts[name].nil?) or (not value_exist?(@values, [name, *args]))) and ctime - atime > (@timeouts[name] || 0)
+      begin
+        set_value(@values, @blocks[name].call(*args), [name, *args])
+      rescue
+        # dump errors to the console, but otherwise, keep on trucking
+        puts $!.message
+        puts $!.backtrace
+        set_value(@values, @default_value, [name, *args])
+      end
+      
+      set_accessed(@accessed, ctime, [name, *args])
+    end
+    
+    get_value(@values, [name, *args])
+  end
+  
+  def refresh(times=@accessed)
+    times.each do |k, v|
+      if v.respond_to? '[]'
+        refresh v
+      else
+        times[k] = Time.at(0)
+      end
+    end
+  end
+  
+  private
+  
+  def value_exist?(values, path)
+    while path.length > 1
+      curr = path.shift
+      values = values[curr]
+      return false if not values.respond_to? '[]'
+    end
+    
+    return values.keys.include?(path[0])
+  end
+  
+  def get_value(values, path)
+    get_from_path(values, path, @default_value)
+  end
+  
+  def get_accessed(times, path)
+    get_from_path(times, path, Time.at(0))
+  end
+  
+  def get_from_path(hash, path, default)
+    while path.length > 1
+      curr = path.shift
+      hash = hash[curr]
+      return default if not hash.respond_to? '[]'
+    end
+    
+    return hash[path[0]] || default
+  end
+  
+  def set_value(values, value, path)
+    set_from_path(values, value, path)
+  end
+  
+  def set_accessed(times, time, path)
+    set_from_path(times, time, path)
+  end
+  
+  def set_from_path(hash, value, path)
+    while path.length > 1
+      curr = path.shift
+      hash[curr] ||= {}
+      hash = hash[curr]
+    end
+    
+    hash[path[0]] = value
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: ruby-blockcache
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Matt Scharley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-10 00:00:00.000000000 +01:00
+default_executable: 
+dependencies: []
+description: ''
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/blockcache.rb
+- README.md
+- LICENSE
+has_rdoc: true
+homepage: https://github.com/mscharley/ruby-blockcache
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Cache implemented in Ruby that knows how to update its own contents
+test_files: []