Object.memoize

remvee (Remco van 't Veer) — Tue, 01 Apr 2008 14:06:28 GMT

The following is inspired by the article "Caching and Memoization" by James Edward Gray II.



# = Memoization for objects

# 

# This module will extend +Object+ with the +memoize+ method.  This method

# provides memoization for instance methods, which means return values will

# be cached and subsequent calls will return the cached value of the first

# call.

# 

# Caching is done based on instance, method and arguments to the method.  All

# data is kept in a single +Hash+ store which allows flushing all cached

# results at ones using the +flush_memos+ method.

# 

# == Example

#   class Person < Struct.new(:email)

#     def finger

#       `finger #{email}`

#     end

#     memoize :finger

#   end

#   

#   bob = Person.new('bob@test.net')

#   bob.finger                        # finger command executed

#   bob.finger                        # cached value returned

#   Memoizable.flush_memos

#   bob.finger                        # finger command executed

#

# == See also

# http://blog.grayproductions.net/articles/caching_and_memoization

#

# == Author

# R.W. van 't Veer, 2008-04-01, Amsterdam

module Memoizable

  # Store for cached values.

  CACHE = Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = {}}} # 3 level hash; CACHE[:foo][:bar][:yelp]

  

  # Memoize the given method(s).

  def memoize(*names)

    names.each do |name|

      unmemoized = "__unmemoized_#{name}"

      

      class_eval %Q{

        alias   :#{unmemoized} :#{name}

        private :#{unmemoized}

        def #{name}(*args)

          cache = CACHE[self][#{name.inspect}]

          cache.has_key?(args) ? cache[args] : (cache[args] = send(:#{unmemoized}, *args))

        end

      }

    end

  end

  

  # Flush cached return values.

  def flush_memos

    CACHE.clear

  end

  module_function :flush_memos

end



class Object # :nodoc:

  extend Memoizable

end



if $0 == __FILE__

  require 'test/unit'

  

  class MemoizeTest < Test::Unit::TestCase # :nodoc:

    def setup

      @obj = TestObject.new

    end

    

    def teardown

      Memoizable.flush_memos

    end

    

    def test_memoize_value_should_stick_until_cache_flushed

      @obj.value = 'a'

      assert_equal 'a', @obj.value

      

      @obj.value = 'b'

      assert_equal 'a', @obj.value

      

      Memoizable.flush_memos

      assert_equal 'b', @obj.value

    end

    

    def test_flush_should_clear_all_cached_objects

      @obj.value = 'yelp'

      @obj.value

      

      assert_not_equal 0, Memoizable::CACHE.size

      Memoizable.flush_memos

      assert_equal 0, Memoizable::CACHE.size

    end

    

    def test_memoize_should_keep_separate_cache_per_instance

      other = TestObject.new

      @obj.value, other.value = 'a', 'b'

      

      assert_equal 'a', @obj.value

      assert_equal 'b', other.value

    end

    

    def test_memoize_should_keep_separate_cache_per_method

      @obj.value, @obj.other = 'a', 'b'

      

      assert_equal 'a', @obj.value

      assert_equal 'b', @obj.other

    end

    

    def test_memoize_should_include_arguments_in_cache_key

      @obj.with_arguments = 'a'

      assert_equal 'a', @obj.with_arguments(:this)

      

      @obj.with_arguments = 'b'

      assert_equal 'a', @obj.with_arguments(:this)

      assert_equal 'b', @obj.with_arguments(:that)

    end

    

    class TestObject # :nodoc:

      attr_accessor :value, :other

      memoize :value, :other

      

      attr_writer :with_arguments

      def with_arguments(*args); @with_arguments; end

      memoize :with_arguments

      

      attr_writer :question

      def question?; @question; end

      memoize :question?

      

      attr_writer :exclamation

      def exclamation!; @exclamation; end

      memoize :exclamation!

    end

  end

end

Simple cacher module for Rails

remvee (Remco van 't Veer) — Tue, 01 Apr 2008 09:12:56 GMT

Illustration of a simple cacher module for Rails.



# lib/cacher.rb

module Cacher

  STORE = {}

  

  def cache(*args)

    STORE[args.inspect] ||= yield

  end



  def flush!

    STORE.clear

  end

  module_function :flush!

end



# app/models/person.rb

class Person < AR::Base

  include Cacher



  def finger

    cache(:finger, email) do

      `finger #{email}`

    end

  end

end



# app/controller/application.rb

class ApplicationController < AC::Base

  after_filter { Cacher.flush! }

end

response caching in camping

remvee (Remco van 't Veer) — Wed, 16 Jan 2008 13:27:23 GMT

A basic implementation of response caching in camping.



Camping.goes :MyCampingApp



module MyCampingApp

  module Controller

    class View < R '/'

      def get

        cache('root') do

          'Expensive operation!'

        end

      end

    end

  end

  

  def flush(id)

    f = File.dirname(__FILE__) + "/cache/#{id}"

    File.delete(f) if File.exists?(f)

  end

  

  def cache(id, timeout = 1.hour)

    f = File.dirname(__FILE__) + "/cache/#{id}"

    

    if File.exists?(f) && (Time.now - File.stat(f).mtime) < timeout

      File.read(f)

    else

      r = yield

      open(f, 'w'){|wr| wr.write(r)}

      r

    end

  end



  def self.create

    cache_dir = File.dirname(__FILE__) + "/cache"

    Dir.mkdir(cache_dir) unless File.directory?(cache_dir)

  end

end

DZone Snippets: caching code

Object.memoize

Simple cacher module for Rails

response caching in camping