stacks 0.1.0

data/lib/stacks/items/column_dependent_block.rb

@@ -0,0 +1,29 @@
+class Stacks::Items::ColumnDependentBlock
+
+  attr_accessor :model
+
+  def initialize(model, columns, identifier, proc)
+    @model = model
+    @columns = columns.sort!
+    @columns = @columns.map { |c| c.to_s }
+    @identifier = identifier
+    @proc = proc
+  end
+
+  def key
+    @key ||= [@identifier].concat(@columns).join(Stacks::key_separator)
+  end
+
+  def self.key_to_columns(key)
+    all_keys = key.split(Stacks::key_separator)
+
+    # The identifier takes the first slot
+    all_keys.shift
+    all_keys
+  end
+
+  def value
+    @proc.call
+  end
+
+end

data/lib/stacks/items/method_call.rb

@@ -0,0 +1,27 @@
+class Stacks::Items::MethodCall
+
+  def initialize(object, method, args)
+    @object = object
+    @method = method
+    @args = args
+  end
+
+  def key_str
+    return @key_str if @key_str
+
+    object_str = Marshal.dump(@object)
+    method_str = @method.to_s
+    arg_str = Marshal.dump(@args)
+
+    @key_str ||= [object_str, method_str, arg_str].join(Stacks::key_separator)
+  end
+
+  def key
+    @key = Digest::SHA2.hexdigest(key_str)
+  end
+
+  def value
+    @object.send(@method, *@args)
+  end
+
+end

data/lib/stacks/items/proc.rb

@@ -0,0 +1,16 @@
+class Stacks::Items::Proc
+
+  def initialize(identifier, proc)
+    @identifier = identifier
+    @proc = proc
+  end
+
+  def key
+    @key ||= @identifier
+  end
+
+  def value
+    @proc.call
+  end
+
+end

data/lib/stacks/items/timestamp.rb

@@ -0,0 +1,11 @@
+class Stacks::Items::Timestamp
+
+  def key
+    "cache_timestamp"
+  end
+
+  def value
+    Time.now
+  end
+
+end

data/lib/stacks/method_cache.rb

@@ -0,0 +1,18 @@
+module Stacks::MethodCache
+
+  extend Stacks::Cache
+
+  def self.backend
+    Stacks::Backends::KeyValueBackend.new
+  end
+
+  def self.get_item(object, method, args, ttl)
+    Stacks::Items::MethodCall.new(object, method, args)
+  end
+
+  def self.cached(object, method, args, ttl)
+    item = get_item(object, method, args, ttl)
+    get_value(item, backend, ttl)
+  end
+
+end

data/lib/stacks/model_extensions.rb

@@ -0,0 +1,57 @@
+class Stacks::ModelExtensions
+
+  def self.watched_models
+    @watched_models ||= Set.new
+  end
+
+  def self.bust_cache_for_column(model, column)
+    bust_cache_for_columns(model, [column])
+  end
+
+  def self.bust_cache_for_columns(model, columns)
+    Stacks.model_listening_caches.each do |cache|
+      cache.bust_cache(model, columns)
+    end
+  end
+
+  module Extension
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval { before_save(:stacks_check_columns) }
+    end
+
+    def stacks_check_columns
+      return unless Stacks::ModelExtensions.watched_models.include?(self.class)
+
+      changed.each do |column|
+        column = column.to_sym
+
+        if self.class.stacks_watched_columns.include?(column)
+          Stacks::ModelExtensions.bust_cache_for_column(self.class, column)
+        end
+      end
+    end
+
+    module ClassMethods
+
+      def stacks_watched_columns
+        @nbc_watched_columns ||= Set.new
+      end
+
+      def stacks_watch_column(column)
+        stacks_watched_columns << column
+        Stacks::ModelExtensions.watched_models << self
+      end
+
+      def bust_stacks
+        Stacks::ModelExtensions.bust_cache_for_columns(self, stacks_watched_columns)
+      end
+
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.class_eval { include Stacks::ModelExtensions::Extension }

data/lib/stacks/report_cache.rb

@@ -0,0 +1,78 @@
+class Stacks::ReportCache
+
+  extend Stacks::Cache
+
+  attr_accessor(:report_name, :ttl, :values, :cache_condition)
+
+  def self.reports
+    @reports ||= {}
+  end
+
+  def self.get_report(report_name)
+    raise "Invalid report name" unless @reports.keys.include?(report_name)
+    reports[report_name]
+  end
+
+  def initialize(report_name, ttl)
+    @report_name = report_name
+    @values = {}
+    @ttl = ttl
+  end
+
+  def set_cache_condition(&block)
+    @cache_condition = block
+  end
+
+  def value(value_name, &block)
+    @values[value_name] = Stacks::Items::Proc.new(value_name, block)
+  end
+
+  def get_item(item)
+    if cache_condition
+      Stacks.deactivate = true unless cache_condition.call
+    end
+
+    value = self.class.get_value(item, backend, @ttl)
+    Stacks.deactivate = false
+    value
+  end
+
+  def get_value(value_name)
+    get_item(@values[value_name])
+  end
+
+  def timestamp
+    get_item(Stacks::Items::Timestamp.new)
+  end
+
+  def fill_cache
+    if cache_condition
+      return unless cache_condition.call
+    end
+
+    @values.each { |value_name, item| backend.fill(item, @ttl) }
+    backend.fill(Stacks::Items::Timestamp.new, @ttl)
+  end
+
+  def self.report(report_name, ttl, &block)
+    report = new(report_name, ttl)
+    report.instance_eval(&block)
+    reports[report_name] = report
+    report
+  end
+
+  def register_instance_variables(instance)
+    values.each do |value_name, item|
+      instance.instance_variable_set("@#{value_name}".to_sym, get_value(value_name))
+    end
+  end
+
+  def backend
+    return @backend if @backend
+
+    backend = Stacks::Backends::NamespacedBackend.new
+    backend.namespace = @report_name
+    @backend ||= backend
+  end
+
+end

data/spec/backends/backend_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+class TestBackend
+
+  include Stacks::Backends::Backend
+
+  def backend_key
+    "test_backend_key"
+  end
+
+end
+
+describe Stacks::Backends::Backend do
+
+  before(:each) do
+    @backend = TestBackend.new
+    @item = double
+  end
+
+  describe ".prefix_keys" do
+
+    it "includes the redis and backend prefix" do
+      @backend.prefix_keys.should == ["stacks", "test_backend_key"]
+    end
+
+    context "set extra prefix" do
+
+      before(:each) do
+        Stacks.extra_prefix = lambda { "test_extra_prefix" }
+      end
+
+      after(:each) do
+        Stacks.extra_prefix = nil
+      end
+
+      it "now includes 3 keys, including the extra prefix" do
+        @backend.prefix_keys.should == ["stacks", "test_backend_key", "test_extra_prefix"]
+      end
+
+    end
+
+  end
+
+  describe "#prefix_key" do
+
+    it "joins the prefix keys with the separator" do
+      @backend.prefix_key.should == "stacks:test_backend_key"
+    end
+
+  end
+
+  describe "#suffix_key" do
+
+    it "returns the items key" do
+      @item.should_receive(:key).and_return("test_key")
+      @backend.suffix_key(@item).should == "test_key"
+    end
+
+  end
+
+  describe "#fill" do
+
+    it "should set and expire an item" do
+      ttl = 100
+      @backend.should_receive(:set).with(@item)
+      @backend.should_receive(:expire).with(@item, ttl)
+
+      @backend.fill(@item, ttl)
+    end
+
+  end
+
+  describe "#get_or_set" do
+
+    it "returns the item's value if it's a cache hit" do
+      @backend.stub(:get).and_return("test_value")
+      @backend.should_receive(:fill).exactly(0).times
+
+      @backend.get_or_set(@item, 100).should == "test_value"
+    end
+
+    it "fills the cache with item's value if it's not a cache hit" do
+      @backend.stub(:get).and_raise(Stacks::NoValueException)
+      @backend.should_receive(:fill).exactly(1).times.with(@item, 100).and_return("test_value")
+
+      @backend.get_or_set(@item, 100).should == "test_value"
+    end
+
+    it "does not call fill if an unmarshaled value is nil" do
+      @backend.stub(:get).and_return(nil)
+      @backend.should_receive(:fill).exactly(0).times
+
+      @backend.get_or_set(@item, 100).should == nil
+    end
+
+  end
+
+end

data/spec/backends/key_value_backend_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Stacks::Backends::KeyValueBackend do
+
+  before(:each) do
+    @backend = Stacks::Backends::KeyValueBackend.new
+    @key = "stacks:test_redis_key"
+    @item = double
+  end
+
+  describe "#backend_key" do
+
+    it "is set" do
+      @backend.backend_key.should == "kv"
+    end
+
+  end
+
+  describe "#hit?" do
+
+    before(:each) do
+      @backend.should_receive(:key).with(@item).and_return(@key)
+    end
+
+    it "returns true if the redis key is set" do
+      Stacks.redis.set(@key, Marshal.dump("test_value"))
+      @backend.get(@item).should == "test_value"
+    end
+
+    it "raises an exception if the redis key is not set" do
+      expect { @backend.get(@item).should be_nil }.to raise_error(Stacks::NoValueException)
+    end
+
+  end
+
+  describe "#get" do
+
+    it "unmarshals what's stored at the key in redis" do
+      Stacks.redis.set(@key, Marshal.dump("test_value"))
+      @backend.should_receive(:key).with(@item).and_return(@key)
+      @backend.get(@item).should == "test_value"
+    end
+
+  end
+
+  describe "#set" do
+
+    it "stores the item's value in redis" do
+      @item.stub(:value) { "test_value" }
+      @backend.should_receive(:key).with(@item).exactly(2).times.and_return(@key)
+      @backend.set(@item)
+
+      @backend.get(@item).should == "test_value"
+    end
+
+  end
+
+  describe "#del" do
+
+    it "deletes an item from redis" do
+      @item.stub(:value) { "test_value" }
+      @backend.should_receive(:key).with(@item).exactly(4).times.and_return(@key)
+      @backend.set(@item)
+
+      @backend.get(@item).should == "test_value"
+      @backend.del(@item)
+
+      expect { @backend.get(@item) }.to raise_error(Stacks::NoValueException)
+    end
+
+  end
+
+  describe "#expire" do
+
+    it "sets a redis expire for an item" do
+      @backend.should_receive(:key).with(@item).and_return(@key)
+      Stacks.redis.should_receive(:expire).with(@key, 100)
+      @backend.expire(@item, 100)
+    end
+
+  end
+
+end

data/spec/backends/namespaced_backend_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Stacks::Backends::NamespacedBackend do
+
+  before(:each) do
+    @backend = Stacks::Backends::NamespacedBackend.new
+    @backend.namespace = "test_namespace"
+    @item = double
+  end
+
+  describe "#prefix_keys" do
+
+    it "includes the namespace in the prefix keys" do
+      @backend.prefix_keys.include?("test_namespace")
+    end
+
+  end
+
+  describe "#prefix_key" do
+
+    it "includes the name space in the full key" do
+      @backend.prefix_key.include?("test_namespace")
+    end
+
+  end
+
+  context "with prefix and suffix keys" do
+
+    before(:each) do
+      @item.stub(:key) { "test_key" }
+      @item.stub(:value) { "test_value" }
+    end
+
+    describe "#get" do
+
+      it "returns the unmarshaled value of what's stored for the item" do
+        Stacks.redis.hset(@backend.prefix_key,
+                           @backend.suffix_key(@item),
+                           Marshal.dump(@item.value))
+        @backend.get(@item).should == "test_value"
+      end
+
+    end
+
+    describe "#set" do
+
+      it "stores the marshaled version of an item's value in the cache" do
+        @backend.set(@item)
+        @backend.get(@item).should == "test_value"
+      end
+
+    end
+
+    describe "#expire" do
+
+      it "sets a redis expiration for the prefix key" do
+        Stacks.redis.should_receive(:expire).with(@backend.prefix_key, 666)
+        @backend.expire(@item, 666)
+      end
+
+    end
+
+    describe "#clear_cache" do
+
+      it "deletes all keys under the namespace" do
+        backend1 = Stacks::Backends::NamespacedBackend.new
+        backend1.namespace = "test_namespace1"
+        backend2 = Stacks::Backends::NamespacedBackend.new
+        backend2.namespace = "test_namespace2"
+
+        backend1.set(@item)
+        backend2.set(@item)
+
+        backend1.get(@item).should == @item.value
+        backend2.get(@item).should == @item.value
+
+        backend1.clear_cache
+
+        expect { backend1.get(@item) }.to raise_error(Stacks::NoValueException)
+        backend2.get(@item).should == @item.value
+      end
+
+    end
+
+    describe "#keys" do
+
+      it "returns the various suffix keys used in the namespace" do
+        @backend.set(@item)
+        @backend.keys.should == [@item.key]
+      end
+
+    end
+
+    describe "#del" do
+
+      it "removes the item from the cache" do
+        expect { @backend.get(@item) }.to raise_error(Stacks::NoValueException)
+        @backend.set(@item)
+        @backend.get(@item).should == "test_value"
+        @backend.del(@item)
+        expect { @backend.get(@item) }.to raise_error(Stacks::NoValueException)
+      end
+
+    end
+
+  end
+
+end