filecache 0.1.0

data/COPYING

@@ -0,0 +1,24 @@
+FileCache is distributed under the MIT license
+
+Copyright (c) 2008 Simon Whitaker <mailto:sw@netcetera.org>
+
+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

@@ -0,0 +1,27 @@
+= FileCache
+
+FileCache is a file-based caching library for Ruby
+
+= Synopsis
+
+ cache = FileCache.new
+ cache.set(:key, "value")
+ puts cache.get(:key)     # "value"
+ cache.delete(:key)
+ puts cache.get(:key)     # nil
+
+ # create a new cache called "my-cache", rooted in /home/simon/caches
+ # with an expiry time of 30 seconds, and a file hierarchy three 
+ # directories deep
+ cache = FileCache.new("my-cache", "/home/simon/caches", 30, 3)
+ cache.put("joe", "bloggs")
+ puts(cache.get("joe"))   # "bloggs"
+ sleep 30
+ puts(cache.get("joe"))   # nil
+ 
+
+= Copyright
+
+Copyright 2008 Simon Whitaker <mailto:sw@netcetera.org>
+
+See COPYING for license.

data/lib/filecache.rb

@@ -0,0 +1,107 @@
+require 'digest/md5'
+require 'fileutils'
+
+# A file-based caching library. It uses Marshal::dump and Marshal::load 
+# to serialize/deserialize cache values - so you should be OK to cache
+# object values.
+class FileCache
+  
+  MAX_DEPTH = 32
+  
+  # Create a new reference to a file cache system.
+  # domain:: A string that uniquely identifies this caching
+  #          system on the given host
+  # root_dir:: The root directory of the cache file hierarchy
+  #            The cache will be rooted at root_dir/domain/
+  # expiry:: The expiry time for cache entries, in seconds. Use
+  #          0 if you want cached values never to expire.
+  # depth:: The depth of the file tree storing the cache. Should
+  #         be large enough that no cache directory has more than
+  #         a couple of hundred objects in it
+  def initialize(domain = "default", root_dir = "/tmp", expiry = 0, depth = 2)
+    @domain  = domain
+    @root_dir = root_dir
+    @expiry  = expiry
+    @depth   = depth > MAX_DEPTH ? MAX_DEPTH : depth
+  end
+  
+  # Set a cache value for the given key. If the cache contains an existing value for
+  # the key it will be overwritten.
+  def set(key, value)
+    f = File.open(get_path(key), "w")
+    Marshal.dump(value, f)
+    f.close
+  end
+  
+  # Return the value for the specified key from the cache. Returns nil if
+  # the value isn't found.
+  def get(key)
+    path = get_path(key)
+
+    # expire
+    if @expiry > 0 && File.exists?(path) && Time.new - File.new(path).mtime >= @expiry
+      FileUtils.rm(path)
+    end
+    
+    if File.exists?(path)
+      f = File.open(path, "r")
+      result = Marshal.load(f)
+      f.close
+      return result
+    else
+      return nil
+    end
+  end
+  
+  # Delete the value for the given key from the cache
+  def delete(key)
+    FileUtils.rm(get_path(key))
+  end
+
+  # Delete ALL data from the cache, regardless of expiry time
+  def clear
+    if File.exists?(get_root)
+      FileUtils.rm_r(get_root)
+    end
+  end
+  
+  # Delete all expired data from the cache
+  def purge
+    @t_purge = Time.new
+    purge_dir(get_root) if @expiry > 0
+  end
+
+#-------- private methods ---------------------------------
+private  
+  def get_path(key)
+    md5 = Digest::MD5.hexdigest(key.to_s).to_s
+    
+    dir = File.join(get_root, md5.split(//)[0..@depth - 1])
+    FileUtils.mkdir_p(dir)
+    return File.join(dir, md5)
+  end
+  
+  def get_root
+    if @root == nil
+      @root = File.join(@root_dir, @domain)
+    end
+    return @root
+  end
+  
+  def purge_dir(dir)
+    Dir.foreach(dir) do |f|
+      next if f =~ /^\.\.?$/
+      path = File.join(dir, f)
+      if File.directory?(path) 
+        purge_dir(path)
+      elsif @t_purge - File.new(path).mtime >= @expiry
+        FileUtils.rm(path)
+      end
+    end
+    
+    # Delete empty directories
+    if Dir.entries(dir).delete_if{|e| e =~ /^\.\.?$/}.empty?
+      Dir.delete(dir)
+    end
+  end
+end

data/tests/test_filecache.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'filecache'
+require 'test/unit'
+
+class TestFileCache < Test::Unit::TestCase
+  KEY1 = "key1"
+  VALUE1 = "value1"
+  VALUE2 = "value2"
+  
+  def test_basic
+    f = FileCache.new("unit-test", "/tmp")
+    
+    f.set(KEY1, VALUE1)
+    assert_equal(f.get(KEY1), VALUE1, "set/get")
+    
+    f.delete(KEY1)
+    assert_nil(f.get(KEY1), "delete")
+
+    f.set(KEY1, VALUE1)
+    assert_equal(f.get(KEY1), VALUE1, "set on previously deleted key")
+    
+    f.set(KEY1, VALUE2)
+    assert_equal(f.get(KEY1), VALUE2, "set new value on previously set key")
+    
+    f.purge
+    assert_equal(f.get(KEY1), VALUE2, "purge has no effect on cache with expiry=0")
+    
+    f.clear
+    assert_nil(f.get(KEY1), "clear removes previously set value")
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: filecache
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Whitaker
+autorequire: filecache
+bindir: bin
+cert_chain: []
+
+date: 2008-07-07 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sw@netcetera.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- COPYING
+files: 
+- lib/filecache.rb
+- tests/test_filecache.rb
+- README
+- COPYING
+has_rdoc: true
+homepage: http://netcetera.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A file-based caching library
+test_files: 
+- tests/test_filecache.rb