cachet 0.0.0

data/README

@@ -0,0 +1,50 @@
+Just initialize the cache, by configuring your store.
+Just add the configuration to your config initializers
+
+require 'cachet'
+
+Cachet.setup do |config|
+  config.logger =  Rails.logger
+  config.storage   = Cachet::FileStore.new("/pal_storage/path")
+
+  # The followings are the configurations that you can do on file store
+  # The given values are the default ones, if you are OK with them you don't need
+  # to configure at all.
+  # You can set whether you want directory optimization or not
+  # file_store.optimize = TRUE
+  # The depth of directories you want
+  # file_store.dir_levels = 3
+  # Number of directories within a directory, it is better if you use a prime number
+  # but something other than 31, that is the one we use for hashing :)
+  # file_store.dir_count = 19
+end
+
+And from this point forward , if you want return values of your methods to be cached;
+
+#include cacheable module , which will add two class macros to mark a method as cacheable and also as cache invalidator.
+You should pass blocks to these marcos which will return cache keys. Use exact signature of the method that you are referring in the block that returns the key.
+
+
+class Sample
+  include Cachet::Cacheable
+
+  def first (param1, param2)
+    puts "First is running"
+    return "First"
+  end
+
+
+  def second (param1, param2)
+    puts "Second is running and invalidating for #{param1}"
+    return "First"
+  end
+
+  cacheable :first, :car do |param1, param2|
+    param1
+  end
+
+  cache_invalidator :second, :car do |param1, param2|
+    param1
+  end
+
+end

data/lib/cachet.rb

@@ -0,0 +1,35 @@
+require 'rails'
+
+module Cachet
+  mattr_accessor :logger
+  mattr_accessor :storage
+
+  class << self
+    def setup
+      yield self
+    end
+
+    def cache (entity, key)
+      cached_item = storage.read(entity, key)
+      if not cached_item
+        cached_item = yield
+        storage.write(entity, key, cached_item)
+        Cachet.logger.info "#{entity} with key:#{key} could not found in cache. Evaluated and written to cache"
+      else
+        Cachet.logger.info "#{entity} with key:#{key} found in cache."
+      end
+      cached_item
+    end
+
+    def invalidate (entity, key)
+      storage.purge(entity, key)
+      Cachet.logger.info "#{entity} with key:#{key} invalidated."
+    end
+  end
+
+end
+
+require 'cachet/file_store'
+require 'cachet/cacheable'
+
+

data/lib/cachet/cacheable.rb

@@ -0,0 +1,31 @@
+module Cachet
+  module Cacheable
+    def self.included(base)
+      Cachet.logger.debug "Including Cacheable in #{base}"
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def cacheable (cached_method, entity)
+        define_method("#{cached_method}_with_cache") { |*args|
+          cache_key = block_given? ? yield(*args) : cached_method.to_s
+          Cachet.cache(entity, cache_key) do
+            method("#{cached_method}_without_cache".to_sym).call(*args)
+          end
+        }
+        alias_method_chain "#{cached_method}".to_sym, :cache
+        Cachet.logger.debug "Aliasing method : #{cached_method} to cache the result as #{entity} entities"
+      end
+
+      def cache_invalidator (cached_method, entity)
+        define_method("#{cached_method}_with_cache_invalidation") { |*args|
+          cache_key = block_given? ? yield(*args) : cached_method.to_s
+          method("#{cached_method}_without_cache_invalidation".to_sym).call(*args)
+          Cachet.invalidate(entity, cache_key)
+        }
+        alias_method_chain "#{cached_method}".to_sym, :cache_invalidation
+        Cachet.logger.debug "Aliasing method : #{cached_method} to invalidate the #{entity} entities"
+      end
+    end
+  end
+end

data/lib/cachet/file_store.rb

@@ -0,0 +1,59 @@
+require 'digest/md5'
+
+module Cachet
+  class FileStore
+    attr_reader :root
+    attr_accessor :optimize
+    attr_accessor :dir_level
+    attr_accessor :dir_count
+
+    def initialize(root)
+      @root = root
+      FileUtils.mkdir_p root, :mode=>0755
+      @optimize = TRUE
+      @dir_level = 3
+      @dir_count = 19
+    end
+
+    def read(entity, key)
+      file_name = storage_path(entity, key)
+      File.open(file_name, 'rb') { |f| Marshal.load f.read } if  File.exist?(file_name)
+    end
+
+    def write(entity, key, data_to_be_stored)
+      file_name = storage_path(entity, key)
+      temp_file_name = file_name + '.' + Thread.current.object_id.to_s
+      FileUtils.mkdir_p File.dirname(file_name), :mode => 755
+      File.open(temp_file_name, 'wb') { |f| f.write(Marshal.dump(data_to_be_stored)) }
+      if File.exist?(file_name)
+        File.unlink temp_file_name
+      else
+        FileUtils.mv temp_file_name, file_name
+      end
+      Cachet.logger.info "A new #{entity} entity stored in the cache with key:#{key} to path #{file_name}."
+    end
+
+    def purge(entity, key)
+      file_name = storage_path(entity, key)
+      begin
+        File.unlink file_name if  File.exist?(file_name)
+      rescue
+        Cachet.logger.warn "An element of #{entity} in the cache with key:#{key} to path #{file_name}entity has could not be deleted."
+      end
+      Cachet.logger.info "An element of #{entity} in the cache with key:#{key} to path #{file_name}entity has been removed from the cache."
+    end
+
+    def storage_path(entity, key)
+      file_name = Digest::MD5.hexdigest(key)
+      if optimize
+        dirs = (1..dir_level).inject({:hash=>key.sum, :dirs=>[]}) do |result, level|
+          result[:dirs] << (result[:hash] % dir_count).abs.to_s
+          result[:hash] += (result[:hash] * 31)
+          result
+        end
+        file_name = File.join dirs[:dirs], file_name
+      end
+      File.join root, entity.to_s, file_name
+    end
+  end
+end

data/test/test_file_store.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class FileStoreTest < Test::Unit::TestCase
+
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+    @test_store = Cachet::FileStore.new("~/testroot/")
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_storage_path_creation
+    assert_equal "~/testroot/test/2/7/15/25f9e794323b453885f5181f1b624d0b", @test_store.storage_path(:test, "123456789"), "Check storage path, hashing seems to be not working."
+  end
+
+  def test_idempotent_storage_paths
+    assert_equal @test_store.storage_path(:test, "123456789"), @test_store.storage_path(:test, "123456789"), "Should always create same path for same entry."
+  end
+
+  def test_storage_options
+    @test_store.dir_level = 10
+    assert_equal "~/testroot/test/2/7/15/5/8/9/3/1/13/17/25f9e794323b453885f5181f1b624d0b", @test_store.storage_path(:test, "123456789"), "Should nest resourced under 10 recursive directories."
+    @test_store.dir_count = 100
+    assert_equal "~/testroot/test/77/64/48/36/52/64/48/36/52/64/25f9e794323b453885f5181f1b624d0b", @test_store.storage_path(:test, "123456789"), "Should allow 100 hundred directories under any directory."
+    @test_store.optimize = FALSE
+    assert_equal "~/testroot/test/25f9e794323b453885f5181f1b624d0b", @test_store.storage_path(:test, "123456789"), "Should not optimize paths since optimize is disabled."
+  end
+
+  def test_purging_entries
+    file_name = @test_store.storage_path(:test, 'test_item_1')
+    FileUtils.mkdir_p File.dirname(file_name), :mode => 755
+    File.open(file_name, 'wb') { |f| f.write("Data") }
+    assert_equal(true, File.exist?(file_name))
+    @test_store.purge(:test, 'test_item_1')
+    assert_equal(false, File.exist?(file_name))
+  end
+
+  def test_purging_nonexisting_entries
+    file_name = @test_store.storage_path(:test, 'test_item_2')
+    assert_equal(false, File.exist?(file_name))
+    assert_nothing_thrown("FileStore should be slince while purging nonexisting entities") {
+      @test_store.purge(:test, 'test_item_2')
+    }
+    assert_equal(false, File.exist?(file_name))
+  end
+
+  def test_reading_existing_entries
+    @test_store.write(:test, 'test_item_3', "Some test data")
+    assert_equal("Some test data", @test_store.read(:test, 'test_item_3'))
+  end
+
+  def test_reading_nonexisting_entries
+    @test_store.purge(:test, 'test_item_4')
+    assert_nil @test_store.read(:test, 'test_item_4')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require 'fakefs/safe'
+require 'cachet'
+
+Cachet.setup do |config|
+  config.logger =  Logger.new(STDOUT)
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: cachet
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Meltem Atesalp
+- Umut Utkan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-07 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Provides a way to cache and invalidate return values of your time consuming methods.
+email: meltem.atesalp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cachet.rb
+- lib/cachet/cacheable.rb
+- lib/cachet/file_store.rb
+- README
+- test/test_file_store.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/meltem/cachet
+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: Caches method responses to have a better performance!
+test_files: 
+- test/test_file_store.rb
+- test/test_helper.rb