redrecord 0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1. First version

data/Manifest

@@ -0,0 +1,7 @@
+CHANGELOG
+README
+Rakefile
+lib/redrecord.rb
+test/test_all.rb
+test/test_helper.rb
+Manifest

data/README

@@ -0,0 +1,72 @@
+
+redrecord
+---------
+
+This gem pre-caches your ActiveRecord model's calculated attributes (computed
+fields) in Redis.
+
+
+Example
+-------
+
+ class User < ActiveRecord::Base
+
+   cache do
+     def fullname
+       firstname + ' ' + lastname
+     end
+   end
+
+ end
+
+
+Methods defined inside the "cache" block are redefined to get the answer
+from redis first.  The cached attributes are saved whenever the record is
+saved, in an after_commit callback.
+
+
+Cache invalidation for associations
+-----------------------------------
+
+Redrecord can be used to cache attributes that use assocations:
+
+ class User < ActiveRecord::Base
+   has_many :preferences
+
+   cache do
+     def preferences_list
+       preferences.map(&:name).join(', ')
+     end
+   end
+
+ end
+
+ class Preference < ActiveRecord::Base
+   belongs_to :user
+
+   invalidate_cache_on :user
+
+ end
+
+
+In this example, whenever a preference is saved, the associated user record
+will be recalculated and saved in redis.  If it is an array (eg. has_many)
+then all of the associated records will be re-cached.
+
+Other instance methods of interest:
+
+ obj.remove_from_cache! # Remove redis cache for an object.
+ obj.add_to_cache!      # Recalculate fields and store in redis.
+ obj.cached_fields      # hash of the cached fields and their values
+ obj.attribs_with_cached_fields # cached_fields merged with AR attributes
+
+
+
+
+
+Contact the author
+------------------
+
+Andrew Snow <andrew@modulus.org>
+Andys^ on irc.freenode.net
+

data/Rakefile

@@ -0,0 +1,11 @@
+require 'echoe'
+
+Echoe.new("redrecord") do |p|
+  p.author = "Andrew Snow"
+  p.email = 'andrew@modulus.org'
+  p.summary = "Redis cacheing for ActiveRecord"
+  p.url = "http://github.com/andys/redrecord"
+  p.runtime_dependencies = ['redis']  
+  p.development_dependencies = ['active_model', 'active_support']
+end
+

data/lib/redrecord.rb

@@ -0,0 +1,136 @@
+
+class Redrecord
+
+  class << self
+    attr_accessor :redis
+    def update_queue
+      Thread.current[:redrecord_update_queue] ||= []
+    end
+    def is_marshalled?(str)
+      Marshal.dump(nil)[0,2] == str[0,2]
+    end
+  end
+
+  module Model
+
+    module ClassMethods
+
+      def redrecord_cached_fields
+        @redrecord_cached_fields ||= []
+      end
+
+      def redrecord_invalidation_fields
+        @redrecord_invalidation_fields ||= []
+      end
+      
+      def cache(*fields, &bl)
+        if block_given?
+          old_methods = instance_methods
+          class_eval(&bl)
+          fields.push(*(instance_methods - old_methods))
+        end
+        redrecord_cached_fields.push(*fields)
+        fields.each do |f|
+          define_method "#{f}_with_cache" do
+            cached_method(f)
+          end
+          alias_method_chain f, :cache
+        end
+      end
+      
+      def invalidate_cache_on(fieldname)
+        redrecord_invalidation_fields << fieldname.to_sym 
+      end
+      
+    end
+    
+    def self.included(mod)
+      mod.extend(ClassMethods)
+      mod.send(:after_save,     :redrecord_update_queue_save)
+      mod.send(:after_destroy,  :redrecord_update_queue_destroy)
+      mod.send(:after_commit,   :redrecord_update_queue_commit)
+      mod.send(:after_rollback, :redrecord_update_queue_rollback)
+    end
+    
+    def redrecord_update_queue_save
+      Redrecord.update_queue << [:save, self] unless self.class.redrecord_cached_fields.empty?
+      invalidations_for_redrecord_update_queue
+    end
+    
+    def invalidations_for_redrecord_update_queue
+      self.class.redrecord_invalidation_fields.each do |f|
+        if((field_value = send(f)).kind_of?(Array))
+          field_value.each {|item|  Redrecord.update_queue << [:save, item] } 
+        else
+          Redrecord.update_queue << [:save, field_value] if field_value
+        end
+      end
+    end
+
+    def redrecord_update_queue_destroy
+      Redrecord.update_queue << [:destroy, self] unless self.class.redrecord_cached_fields.empty?
+      invalidations_for_redrecord_update_queue
+    end
+    
+    def redrecord_update_queue_rollback
+      Redrecord.update_queue.clear
+    end
+    
+    def redrecord_update_queue_commit
+      Redrecord.update_queue.each do |command, record|
+        if command == :destroy
+          record.remove_from_cache!
+        elsif command == :save
+          record.add_to_cache!
+        end
+      end
+      Redrecord.update_queue.clear
+    end
+    
+    def redrecord_key
+      "#{self.class.table_name}:#{self.id}"
+    end
+    
+    def remove_from_cache!
+      Redrecord.redis.del redrecord_key
+    end
+    
+    def add_to_cache!
+      Redrecord.redis.hmset(redrecord_key,
+        *(self.class.redrecord_cached_fields.map {|f|
+          val = send("#{f}_without_cache")
+          [f.to_s, String===val && !Redrecord.is_marshalled?(val) ? val : Marshal.dump(val)]
+        }.flatten)
+      )
+    end
+
+    def cached_method(method_name)
+      redrecord_cached_attrib_hash[method_name.to_sym]
+    end
+
+    def redrecord_redis_cache
+      @redrecord_redis_cache ||= Redrecord.redis.hgetall(redrecord_key)
+    end
+
+    def redrecord_cached_attrib_hash
+      @redrecord_cached_attrib_hash ||= Hash.new do |h,k|
+        h[k.to_sym] = if(cached = (redrecord_redis_cache[k.to_s] unless new_record?))
+          Redrecord.is_marshalled?(cached) ? Marshal.load(cached) : cached
+        else
+          send("#{k}_without_cache")
+        end
+      end
+    end
+
+    def attribs_with_cached_fields
+      attributes.merge(cached_fields)
+    end
+
+    def cached_fields
+      self.class.redrecord_cached_fields.inject({}) {|hsh,field| hsh[field] = send(field) ; hsh }
+    end
+
+  end
+  
+end
+

data/redrecord.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "redrecord"
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Snow"]
+  s.date = "2012-01-23"
+  s.description = "Redis cacheing for ActiveRecord"
+  s.email = "andrew@modulus.org"
+  s.extra_rdoc_files = ["CHANGELOG", "README", "lib/redrecord.rb"]
+  s.files = ["CHANGELOG", "README", "Rakefile", "lib/redrecord.rb", "test/test_all.rb", "test/test_helper.rb", "Manifest", "redrecord.gemspec"]
+  s.homepage = "http://github.com/andys/redrecord"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Redrecord", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "redrecord"
+  s.rubygems_version = "1.8.10"
+  s.summary = "Redis cacheing for ActiveRecord"
+  s.test_files = ["test/test_all.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 0"])
+      s.add_development_dependency(%q<active_model>, [">= 0"])
+      s.add_development_dependency(%q<active_support>, [">= 0"])
+    else
+      s.add_dependency(%q<redis>, [">= 0"])
+      s.add_dependency(%q<active_model>, [">= 0"])
+      s.add_dependency(%q<active_support>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 0"])
+    s.add_dependency(%q<active_model>, [">= 0"])
+    s.add_dependency(%q<active_support>, [">= 0"])
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,107 @@
+require 'active_model'
+require 'active_support/core_ext/module/aliasing'
+require "#{File.dirname(__FILE__)}/../lib/redrecord"
+require 'test/unit'
+require 'ostruct'
+require 'redis'
+require "#{File.dirname(__FILE__)}/test_helper"
+
+class TestRedrecord < Test::Unit::TestCase
+  def setup
+    $redis.flushdb
+    @user = TestUser.new(1, 'John', 'Smith')
+    $saved = {}
+  end
+  
+  def test_cached_string_attribute_save
+    # start with a blank slate and save the record
+    assert_equal({}, $redis.hgetall('TestUser:1'))
+    assert_nil @user.recalculated
+    @user.save
+    
+    # It should now be saved in redis
+    assert @user.recalculated
+    assert_equal 'John Smith', $redis.hget('TestUser:1', 'full_name')
+    
+    # different object should get the value straight of redis
+    u2 = TestUser.new(1)
+    assert_equal 'John Smith', u2.full_name
+    assert_nil u2.recalculated
+  end
+
+
+  def test_cached_nil_attribute_save
+    @user.save
+    assert_equal Marshal.dump(nil), $redis.hget('TestUser:1', 'nil')
+    u2 = TestUser.new(1, 'John', 'Smith')
+    assert_nil u2.nil
+  end
+
+  def test_invalidation_on_save
+    @user.save
+    @user.first_name = 'Bob'
+    @user.save
+    
+    assert_equal 'Bob Smith', $redis.hget('TestUser:1', 'full_name')
+    
+    u2 = TestUser.new(1)
+    assert_equal 'Bob Smith', u2.full_name
+    assert_nil u2.recalculated
+  end
+  
+  def test_invalidation_on_delete
+    @user.save
+    assert_equal 'John Smith', $redis.hget('TestUser:1', 'full_name')
+    @user.destroy
+    assert_equal({}, $redis.hgetall('TestUser:1'))
+  end
+
+  def test_invalidation_on_rollback
+    @user.save_with_rollback
+    assert_equal({}, $redis.hgetall('TestUser:1'))
+  end
+  
+  def test_invalidation_on_association_create
+    # Create two groups which are attached to the user
+    TestGroup.new(1, 'users', @user).save
+    TestGroup.new(2, 'admins', @user).save
+    #@user.save
+    
+    # Now a fresh user record should get the answer out of cache
+    u2 = TestUser.new(1)
+    assert_equal ['admins', 'users'], u2.group_names
+    assert_nil u2.recalculated
+  end
+
+  def test_invalidation_on_association
+    # Create two groups which are attached to the user
+    TestGroup.new(1, 'users', @user).save
+    g = TestGroup.new(2, 'admins', @user).save
+    @user.save
+    
+    # Removing a group should also refresh the cache
+    g.destroy
+    assert_equal ['users'], TestUser.new(1).group_names
+  end
+  
+  def test_attribs
+    assert_equal({
+        :nil         => nil,
+        :group_names => [],
+        :full_name   => 'John Smith'},
+      @user.cached_fields)
+  end
+
+  def test_cached_fields
+    assert_equal({
+        :first_name  => 'John',
+        :last_name   => 'Smith',
+        :id          => 1,
+        :nil         => nil,
+        :group_names => [],
+        :full_name   => 'John Smith'},
+      @user.attribs_with_cached_fields)
+  end
+
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,68 @@
+$redis = Redis.new(:host => 'localhost', :port => 6379) # TODO: dangerous!
+Redrecord.redis = $redis
+
+class TestModel
+  extend ActiveModel::Callbacks
+
+  define_model_callbacks :save, :destroy, :commit, :rollback
+  
+  include Redrecord::Model
+  
+  def save
+    run_callbacks :commit do
+      run_callbacks :save do
+        $saved[redrecord_key] = self
+      end
+    end
+  end
+  def destroy
+    run_callbacks :commit do
+      run_callbacks :destroy do
+        $saved.delete(redrecord_key)
+      end
+    end
+  end
+  def save_with_rollback
+    run_callbacks :rollback do
+      run_callbacks :save do
+      end
+    end
+  end
+  def new_record?
+    !$saved[redrecord_key]
+  end
+  def self.table_name
+    self.to_s.split('::').last
+  end
+  def attributes
+    instance_variables.map {|var| var.to_s.gsub(/^@/,'').to_sym }.inject({}) {|hsh,var| hsh[var] = send(var) ; hsh}
+  end
+end
+
+class TestGroup < TestModel
+  attr_accessor :id, :name, :user
+  def initialize(id, name=nil, user=nil)
+    @id, @name, @user = id, name, user
+  end
+  invalidate_cache_on :user
+end
+
+class TestUser < TestModel
+  attr_accessor :first_name, :last_name, :id, :recalculated
+  def initialize(id, first_name=nil, last_name=nil)
+    @id, @first_name, @last_name = id, first_name, last_name
+  end
+  
+  cache do
+    def full_name
+      @recalculated = true
+      "#{first_name} #{last_name}"
+    end
+    def nil
+      nil
+    end
+    def group_names
+      $saved.values.select {|v| TestGroup===v && v.user.id == self.id }.map(&:name).sort
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: redrecord
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Snow
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &71893080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *71893080
+- !ruby/object:Gem::Dependency
+  name: active_model
+  requirement: &71892570 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71892570
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &71891930 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71891930
+description: Redis cacheing for ActiveRecord
+email: andrew@modulus.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG
+- README
+- lib/redrecord.rb
+files:
+- CHANGELOG
+- README
+- Rakefile
+- lib/redrecord.rb
+- test/test_all.rb
+- test/test_helper.rb
+- Manifest
+- redrecord.gemspec
+homepage: http://github.com/andys/redrecord
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --title
+- Redrecord
+- --main
+- README
+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: '1.2'
+requirements: []
+rubyforge_project: redrecord
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Redis cacheing for ActiveRecord
+test_files:
+- test/test_all.rb