file_cache 0.0.1

data/README.rdoc

@@ -0,0 +1,28 @@
+= FileCache
+
+Simple caching utility that persists arbitrary data in files.
+
+== Install
+
+	$ gem install phoet-file_cache -s http://gems.github.com
+
+== How to use
+
+Just include the FileCache module and use the provided +file_cache+ method
+
+	include FileCache
+	[...]
+	file_cache :the_name_of_the_action_you_execute do
+		#some stuff that should be cached, an external API call f.e.
+	end
+
+The block you are providing is only executed if there is no cache-data provided or if the cache is expired.
+By default, the cache expires after half an hour, but you can override this behavior by passing in time you want the content to be cached as a second argument.
+
+	file_cache :the_name_of_the_action_you_execute, 60 do ...
+
+FileCache persists the return-value of the given block in a file in your local +tmpfolder+. 
+You may override this behavior by setting the +file_cache_dir+.
+
+	self.file_cache_dir='path_to_other_dir'
+

data/lib/file_cache.rb

@@ -0,0 +1,72 @@
+require 'tmpdir'
+
+# = FileCache
+#
+# FileCache is a simple utility to persist arbitrary data into a file.
+# Just wrap the action you want to cache into a FileCache call and it will be available for 30 minutes by default.
+#
+# FileCache uses the default tmp-directory of your OS, but you may override that setting via +file_cache_dir+
+#
+# == Example
+#
+#   require 'file_cache'
+#   include FileCache
+#
+#   file_cache :cache_token_name do
+#     #some_stuff_that_should_be_cached_executed_here
+#   end
+#
+module FileCache
+  
+  # configures the directory where file_cache persists the payload
+  attr_accessor :file_cache_dir
+  
+  # performs the caching with the name of +token+ for the given +payload+ block
+  #
+  # the +caching_time_in_minutes+ defaults to half an hour
+  def file_cache(token, caching_time_in_minutes=30, &payload)
+    file = file_cache_name(token)
+    if not_cached_or_to_old? file, caching_time_in_minutes
+      load_from_file_cache file
+    else
+      write_to_file_cache file, (yield payload)
+    end
+  end
+  
+  private
+  
+  # writes given +payload+ to given +file+
+  def write_to_file_cache(file, payload)
+    puts "direct access, storing in #{file}"
+    File.open( file, 'w' ) do |out|
+      Marshal.dump(payload, out)
+    end
+    payload
+  end
+  
+  # loads payload from given +file+
+  def load_from_file_cache(file)
+    puts "loading stuff from #{file}"
+    File.open(file, 'r') do |input|
+      Marshal.load(input.read)
+    end
+  end
+  
+  # checks if given +file+ already exists or if it expires the +caching_time_in_minutes+
+  def not_cached_or_to_old?(file, caching_time_in_minutes)
+    File.exists?(file) and (File.mtime(file) + caching_time_in_minutes * 60) > Time.new
+  end
+  
+  # gets the name of the file-cache for given +token+
+  def file_cache_name(token)
+    name = "#{token}".gsub(/[^\w]/, '_')
+    "#{file_cache_dir}/#{name}.mrs"
+  end
+  
+  # gets the dir where to put the file-caches
+  # defaults to _tmpdir_
+  def file_cache_dir
+    @file_cache_dir || Dir.tmpdir
+  end
+  
+end

data/test/test_file_cache.rb

@@ -0,0 +1,32 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','..','lib')
+
+require 'test/unit'
+require 'file_cache'
+
+class TestFileCache < Test::Unit::TestCase
+  
+  include FileCache
+
+  def test_file_cache_name_with_strange_tokens_only_characters_remain
+    self.file_cache_dir = 'tmp'
+    assert_equal('tmp/a_b_c.mrs', file_cache_name(:'a+b*c'), 'Expected token to be just charactes and underscores!')
+  end
+  
+  def test_file_checking_working
+    file = 'timestamp'
+    FileUtils.touch file
+    assert(not_cached_or_to_old?(file, 1), 'Expected File to be existing and not that old!')
+    assert(!not_cached_or_to_old?(file, 0), 'Expected File to be too old!')
+    assert(!not_cached_or_to_old?('other', 1), 'Expected File not to exist!')
+  end
+  
+  def test_cache_with_object_tmp_file_is_created
+    file = file_cache_name(:name)
+    File.delete file if File.exists? file
+    payload = [1,2,3]
+    result = file_cache :name do payload end
+    assert_equal(payload, result, 'Expected result to be same as paylaod!')
+    assert(File.exists?(file), 'Expected tmpfile to be created!')
+  end
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: file_cache
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Peter Schr\xC3\xB6der"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Caches arbitrary data in files.
+email: phoetmail@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/file_cache.rb
+has_rdoc: true
+homepage: http://github.com/phoet/file_cache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- -a
+- --inline-source
+- --charset=UTF-8
+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: none
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Caching is a need for nearly every application. Especially if you are integrating lots of external APIs. So just load the stuff and push it into a file - done!
+test_files: 
+- test/test_file_cache.rb