extremist_cache 0.0.3

data/History.txt

@@ -0,0 +1,11 @@
+=== 0.0.3 / 2009-01-19
+
+* Fix missing fragment cache helper error on fresh Rails
+
+=== 0.0.2 / 2009-01-19
+
+* Fix botched builds
+
+=== 0.0.1 / 2009-01-19
+
+* Gemification

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO.txt
+init.rb
+lib/extremist_cache.rb
+lib/marking_store.rb
+lib/touching_store.rb
+test/digest_benchmark.rb
+test/test_extremist_cache.rb

data/README.txt

@@ -0,0 +1,7 @@
+= extremist_cache
+
+* http://live.julik.nl/2008/07/cache-with-automatic-transmission
+
+== DESCRIPTION:
+
+Oh please spare me.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'hoe'
+require './lib/extremist_cache'
+
+Hoe::RUBY_FLAGS.gsub!(/^-w/, '') # zap!
+Hoe.new('extremist_cache', ExtremistCache::VERSION) do |p|
+  p.developer('Julik', 'me@julik.nl')
+  p.description = "Object-keyed caches for anything"
+  p.extra_deps << 'rails'
+end
+
+begin
+  require 'load_multi_rails_rake_tasks'
+rescue LoadError
+end

data/TODO.txt

@@ -0,0 +1 @@
+* There is no cache_erb_fragment in modern Rails

data/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/extremist_cache'
+ExtremistCache.bootstrap!

data/lib/extremist_cache.rb

@@ -0,0 +1,45 @@
+require 'openssl'
+module ExtremistCache
+  DIGEST = OpenSSL::Digest::MD4
+  VERSION = '0.0.3'
+  
+  # To be called from a plugin init.rb 
+  def self.bootstrap!
+    if !@boostrapped
+      ::ActionController::Base.send(:include, ExtremistCache)
+      ::ActionController::Base.send(:helper, ExtremistCache)
+    end
+  end
+  
+  # This one should be used from controllers and helpers
+  def cached_based_on(*whatever)
+    segmented_path = lazy_cache_key_for(*whatever)
+    (@controller || self).read_fragment(segmented_path) || (@controller || self).write_fragment(segmented_path, yield)
+  end
+  
+  # This one is for blocks that return objects, results of expensive computation
+  def value_cached_based_on(*whatever)
+    segmented_path = lazy_cache_key_for(whatever)
+    fragment = (@controller || self).read_fragment(segmented_path)
+    fragment ? Marshal.load(fragment) : returning(yield) {|f| (@controller || self).write_fragment(segmented_path, Marshal.dump(f)) }
+  end
+  
+  def erb_cache_based_on(*whatever, &block)
+    begin
+      name = {:__extremist => lazy_cache_key_for(whatever)}
+      @controller.fragment_for(output_buffer, name, nil, &block)
+    rescue NoMethodError
+      @controller.cache_erb_fragment(block, lazy_cache_key_for(*whatever))
+    end
+  end
+  
+  private
+    def lazy_cache_key_for(*anything)
+      calling_method = caller(2)[0..1]
+      # OpenSSL's MD5 is much faster than the Ruby one - like ten times
+      checksum =  DIGEST.hexdigest(Marshal.dump(calling_method + anything))
+      # Splitting an MD5 on 2 symbols will give us good rainbow spread across
+      # directories with 256 subdirectories max, in each given directory
+      segmented_path = "extremist-cache/" + checksum.scan(/(.{2})/).join('/')
+    end
+end

data/lib/marking_store.rb

@@ -0,0 +1,50 @@
+class MarkingStore < ::ActionController::Caching::Fragments::MemoryStore
+  EACH_NTH_REQUEST = 20
+  TTL = 20.days
+  class AccessMark
+    include Comparable
+    attr_reader :key, :atime
+    def initialize(key)
+      @key = key; update
+    end
+    
+    def update
+      @atime = Time.now.to_i
+    end
+    
+    def <=>(other)
+      @atime <=> other.atime
+    end
+  end
+
+  def initialize
+    @at_request = 0
+    @marks = []
+  end
+  
+  def write_fragment(key, value, options = nil)
+    @marks << AccessMark.new(key)
+    @cache[key] = value
+  end
+  
+  def read_fragment(key, value, options = nil)
+    @at_request += 1
+    return nil unless @cache[key]
+    
+    @marks.find{|m| m.key == key }.update
+    run_gc if (@at_request % EACH_NTH_REQUEST)
+    @accessed[key]
+  end
+  
+  private
+    def run_gc
+      threshold = (Time.now.to_i - TTL)
+      @marks.sort!
+      new_marks = []
+      ((@marks.length *-1)..0).each do | idx |
+        new_marks << @marks[idx]
+        break if @marks[idx].atime < threshold
+      end
+      @marks = new_marks
+    end
+end

data/lib/touching_store.rb

@@ -0,0 +1,13 @@
+# Will not only read the file but mark it's modification date. We can then expire
+# "everything that hasn't b been used for years" to save space
+class TouchingStore < ::ActionController::Caching::Fragments::FileStore
+  def read(name, options = nil)
+    begin
+      st = Time.now
+      File.utime(st, st, real_file_path(name))
+      File.open(real_file_path(name), 'rb') { |f| f.read } 
+    rescue
+      nil
+    end
+  end
+end

data/test/digest_benchmark.rb

@@ -0,0 +1,36 @@
+require 'openssl'
+require 'digest'
+    
+lets = ("a".."z").to_a
+
+require 'benchmark'
+
+module Noop
+  def self.hexdigest(of); of; end
+end
+
+[Noop, Digest::MD5, OpenSSL::Digest::MD5,  OpenSSL::Digest::MD4, OpenSSL::Digest::SHA1].each do | d |
+  
+  puts "\n\n #{d} with value digest"
+  Benchmark.bm do | x|
+    hundred_values = (0..100).map { (0..100).map { lets[rand(lets.length)]}.join }
+    
+    x.report do
+      300.times do
+        hundred_values.map {|let| d.hexdigest(Marshal.dump(let)) }
+      end
+    end
+  end
+
+  puts "\n\n #{d} with hash digest"
+  Benchmark.bm do | x|
+    hundred_values = (0..100).map { (0..100).map { lets[rand(lets.length)]}.join }
+    
+    x.report do
+      300.times do
+        hundred_values.map {|let| d.hexdigest(Marshal.dump(let).hash.to_s) }
+      end
+    end
+  end
+
+end

data/test/test_extremist_cache.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+
+require 'test/unit'
+require 'flexmock'
+require 'flexmock/test_unit'
+require 'stringio'
+
+require 'action_controller'
+require 'action_controller/caching'
+require 'action_controller/caching/fragments'
+require 'action_controller/test_process'
+require File.dirname(__FILE__)  + '/../init'
+
+$routes = ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+
+class HashingTest < Test::Unit::TestCase
+  class Handle
+    include ExtremistCache
+    def b(*a)
+      lazy_cache_key_for(*a)
+    end
+  end
+  
+  def setup
+    @h = Handle.new
+  end
+  
+  def test_hashing_yields_segmented_md5
+    [1, [1,2,3], {"x" => 'y'}, Object.new].each do | value |
+      assert_match /^extremist\-cache\/([a-z\d]{2})\/([a-z\d]{2})\/([a-z\d]{2})/, @h.b(value),
+        "Should be a segmented path"
+    end
+  end
+  
+  def test_hashing_yields_same_hash_for_different_hashes
+    assert_equal @h.b({:a => 'b', :c => 'd'}), @h.b({:c => 'd', :a => 'b'})
+  end
+  
+  def test_hashing_depends_on_values_and_caller
+    values = [
+      "abcdef",
+      [1, 2, 3],
+      (34..190),
+      {"foo" => :bar, :x => [1,5,10]},
+      Object.new,
+    ]
+    
+    via_method_a = values.inject([]) do | hashes, one |
+      hashes << from_one_method(one)
+    end
+
+    via_method_a_once_again = values.inject([]) do | hashes, one |
+      hashes << from_one_method(one)
+    end
+    
+    via_method_b = values.inject([]) do | hashes, one |
+      hashes << from_other_method(one)
+    end
+
+    assert_not_equal via_method_a, via_method_a_once_again, "Hashing depends on the caller"
+    assert_not_equal via_method_a, via_method_b, "Hashing depends on the caller"
+  end
+  
+  private
+    def from_one_method(*a)
+      @h.b(*a)
+    end
+
+    def from_other_method(*a)
+      @h.b(*a)
+    end
+end
+
+class BogusController < ActionController::Base
+  def action_that_calls_cache
+    retval = value_cached_based_on(params[:id]) { perform_expensive_computation(params[:id]) }
+    
+    signal_return_value(retval)
+    render :nothing => true
+  end
+  def rescue_action(e); raise e; end
+  def perform_expensive_computation(flag); return "wroom #{flag}"; end
+  def signal_return_value(retval); end
+  
+  def action_that_renders_with_cache
+    t = '<% erb_cache_based_on(params[:id]) do %> Foo<%= params[:id] %> <%= Time.now.usec %> <% end %>'
+    render :inline => t
+  end
+end
+
+class ValueReturnTest < Test::Unit::TestCase
+  def setup
+    @store = ActiveSupport::Cache.lookup_store :memory_store
+    ::ActionController::Base.cache_store = @store
+    
+    @controller = BogusController.new
+    @controller.logger = Logger.new(StringIO.new)
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    
+    super
+  end
+  
+  def test_cache_through
+    wrapped_key = '123'
+    
+    flexmock(@controller).should_receive(:lazy_cache_key_for).with([wrapped_key]).at_least.times(6).and_return("some_key")
+    
+    computation_result = "abcdef #{rand}"
+    flexmock(@controller).should_receive(:perform_expensive_computation).at_most.once.and_return(computation_result)
+    flexmock(@controller).should_receive(:signal_return_value).with(computation_result).at_least.times(6)
+
+    6.times do
+      assert_nothing_raised { get :action_that_calls_cache, :id => wrapped_key }
+    end
+  end
+  
+  def test_cache_through_helper
+    get :action_that_renders_with_cache, :id => "Poeing"
+    first_body = @response.body.dup
+    
+    10.times { get :action_that_renders_with_cache, :id => "Poeing" }
+    assert_equal first_body, @response.body
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: extremist_cache
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Julik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-22 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 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 9
+        - 4
+        version: 2.9.4
+  type: :development
+  version_requirements: *id002
+description: Object-keyed caches for anything
+email: 
+- me@julik.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- TODO.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO.txt
+- init.rb
+- lib/extremist_cache.rb
+- lib/marking_store.rb
+- lib/touching_store.rb
+- test/digest_benchmark.rb
+- test/test_extremist_cache.rb
+- .gemtest
+has_rdoc: true
+homepage: http://live.julik.nl/2008/07/cache-with-automatic-transmission
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: extremist_cache
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Oh please spare me.
+test_files: 
+- test/test_extremist_cache.rb