primer 0.1.0

data/lib/primer/worker.rb

@@ -0,0 +1,34 @@
+module Primer
+  class Worker
+    
+    class ConfigError < StandardError ; end
+    
+    autoload :ActiveRecordAgent, ROOT + '/primer/worker/active_record_agent'
+    
+    def run
+      raise ConfigError.new('No cache present') unless Primer.cache
+      raise ConfigError.new('No message bus present') unless Primer.bus
+      
+      puts "Cache: #{ Primer.cache }"
+      puts "Message bus: #{ Primer.bus }"
+      puts
+      
+      EM.run {
+        Primer.bus.subscribe :active_record do |args|
+          puts "[active_record] #{ args.inspect }"
+        end
+        Primer.bus.subscribe :changes do |args|
+          puts "[changes] #{ args.inspect }"
+        end
+        
+        ActiveRecordAgent.bind_to_bus
+        Primer.cache.bind_to_bus
+        
+        puts "Listening for messages..."
+        puts
+      }
+    end
+    
+  end
+end
+

data/lib/primer.rb

@@ -0,0 +1,31 @@
+require 'faye'
+require 'set'
+require 'yaml'
+
+module Primer
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  VERSION = '0.1.0'
+  
+  class InvalidKey    < StandardError ; end
+  class RouteNotFound < StandardError ; end
+  
+  autoload :Cache,    ROOT + '/primer/cache'
+  autoload :Bus,      ROOT + '/primer/bus'
+  autoload :RouteSet, ROOT + '/primer/route_set'
+  autoload :Enabler,  ROOT + '/primer/enabler'
+  autoload :Watcher,  ROOT + '/primer/watcher'
+  autoload :Helpers,  ROOT + '/primer/helpers'
+  autoload :RealTime, ROOT + '/primer/real_time'
+  autoload :Worker,   ROOT + '/primer/worker'
+  
+  class << self
+    attr_accessor :cache, :bus, :real_time
+  end
+  
+  self.bus = Bus::Memory.new
+  
+  def self.worker!
+    Worker.new.run
+  end
+end
+

data/spec/models/artist.rb

@@ -0,0 +1,10 @@
+class Artist < ActiveRecord::Base
+  has_many :performances
+  has_many :concerts, :through => :performances
+  
+  belongs_to :calendar
+  has_many :upcoming_gigs, :through => :calendar, :source => :gigs
+  
+  include Primer::Watcher
+end
+

data/spec/models/blog_post.rb

@@ -0,0 +1,5 @@
+class BlogPost < ActiveRecord::Base
+  belongs_to :person
+  include Primer::Watcher
+end
+

data/spec/models/calendar.rb

@@ -0,0 +1,7 @@
+class Calendar < ActiveRecord::Base
+  has_many :artists
+  has_many :gigs, :class_name => 'Concert'
+  
+  include Primer::Watcher
+end
+

data/spec/models/concert.rb

@@ -0,0 +1,6 @@
+class Concert < ActiveRecord::Base
+  belongs_to :calendar
+  has_many :performances, :dependent => :destroy
+  include Primer::Watcher
+end
+

data/spec/models/performance.rb

@@ -0,0 +1,6 @@
+class Performance < ActiveRecord::Base
+  belongs_to :artist
+  belongs_to :concert
+  include Primer::Watcher
+end
+

data/spec/models/person.rb

@@ -0,0 +1,14 @@
+class Person < ActiveRecord::Base
+  has_many :blog_posts
+  
+  include Primer::Watcher
+  
+  def all_attributes
+    [id, the_name]
+  end
+  
+  def the_name
+    name
+  end
+end
+

data/spec/models/watchable.rb

@@ -0,0 +1,17 @@
+class Watchable
+  include Primer::Watcher
+  watch_calls_to :name, :is_called?
+  
+  def initialize(name)
+    @name = name
+  end
+  
+  def name
+    @name
+  end
+  
+  def is_called?(name)
+    @name == name
+  end
+end
+

data/spec/primer/bus_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+shared_examples_for "primer event bus" do
+  before do
+    @message = nil
+    bus.subscribe(:changes) { |message| @message = message }
+  end
+  
+  it "transmits messages verbatim" do
+    bus.publish :changes, ["series", "of", "params"]
+    sleep 1.0
+    @message.should == ["series", "of", "params"]
+  end
+  
+  it "routes messages to the right channel" do
+    bus.publish :other, "something"
+    sleep 1.0
+    @message.should be_nil
+  end
+end
+
+describe Primer::Bus::Memory do
+  let(:bus) { Primer::Bus::Memory.new }
+  it_should_behave_like "primer event bus"
+end
+
+describe Primer::Bus::AMQP do
+  let(:bus) { Primer::Bus::AMQP.new(:queue => 'data_changes') }
+  it_should_behave_like "primer event bus"
+end
+

data/spec/primer/cache_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+  
+shared_examples_for "primer cache" do
+  before do
+    Primer.cache = cache
+    Primer.bus   = bus
+    
+    cache.bind_to_bus
+    Primer::Worker::ActiveRecordAgent.bind_to_bus
+    sync
+    
+    @person   = Person.create(:name => "Abe")
+    @impostor = Person.create(:name => "Aaron")
+    @post     = BlogPost.create(:person => @impostor, :title => "roflmillions")
+  end
+  
+  def sync
+    sleep sync_time
+  end
+  
+  describe "#compute with a block" do
+    def compute_value
+      cache.compute("/people/abe/name") { @person.name }
+    end
+    
+    it "returns the value of the block" do
+      compute_value.should == "Abe"
+    end
+    
+    it "calls the implementation to get the value" do
+      @person.should_receive(:name)
+      compute_value
+    end
+    
+    it "stores the result of the computation" do
+      cache.should_receive(:put).with("/people/abe/name", "Abe")
+      compute_value
+    end
+    
+    it "notes that the value is related to some ActiveRecord data" do
+      cache.should_receive(:relate).with("/people/abe/name", [["ActiveRecord", "Person", @person.id, "name"]])
+      compute_value
+    end
+    
+    describe "when the value is already known" do
+      before { compute_value }
+      
+      it "returns the value of the block" do
+        compute_value.should == "Abe"
+      end
+      
+      it "does not call the implementation" do
+        @person.should_not_receive(:name)
+        compute_value
+      end
+      
+      it "invalidates the cache when related data changes" do
+        cache.should_receive(:invalidate).with("/people/abe/name")
+        @person.update_attribute(:name, "Aaron")
+        sync
+      end
+      
+      it "does not invalidate the cache when a different object changes" do
+        cache.should_not_receive(:invalidate)
+        @impostor.update_attribute(:name, "Weeble")
+        sync
+      end
+      
+      it "does not invalidate the cache when unrelated data changes" do
+        cache.should_not_receive(:invalidate)
+        @person.update_attribute(:age, 28)
+        sync
+      end
+    end
+  end
+  
+  describe "#compute without a block" do
+    let(:compute_value)  { cache.compute("/name") }
+    let(:compute_count)  { cache.compute("/count") }
+    let(:compute_author) { cache.compute("/author") }
+    
+    before do
+      cache.routes = Primer::RouteSet.new do
+        get('/name')    { Person.first.name }
+        get('/bar/:id') { params[:id] }
+        get('/count')   { Person.first.blog_posts.count }
+        get('/author')  { BlogPost.first.person.name }
+      end
+    end
+    
+    it "uses the routes to find the right value" do
+      compute_value.should == "Abe"
+    end
+    
+    it "stores the result of the computation" do
+      cache.should_receive(:put).with("/name", "Abe")
+      compute_value
+    end
+    
+    it "notes that the value is related to some ActiveRecord data" do
+      cache.should_receive(:relate).with("/name", [["ActiveRecord", "Person", @person.id, "name"]])
+      compute_value
+    end
+    
+    it "handles routing patterns and params" do
+      cache.should_receive(:put).with("/bar/pattern_match", "pattern_match")
+      cache.should_receive(:relate).with("/bar/pattern_match", [])
+      cache.compute("/bar/pattern_match").should == "pattern_match"
+    end
+    
+    it "raise an error for paths that don't match anything" do
+      cache.should_not_receive(:put)
+      cache.should_not_receive(:relate)
+      lambda { cache.compute("/qux") }.should raise_error(Primer::RouteNotFound)
+    end
+    
+    describe "when the value is already known" do
+      before do
+        compute_value
+        compute_count
+        compute_author
+      end
+      
+      it "returns the value of the block" do
+        compute_value.should == "Abe"
+      end
+      
+      it "does not call the implementation" do
+        @person.should_not_receive(:name)
+        compute_value
+      end
+      
+      it "regenerates the cache when related data changes" do
+        @person.update_attribute(:name, "Aaron")
+        sync
+        cache.get("/name").should == "Aaron"
+      end
+      
+      it "regenerates the cache when an associated collection changes" do
+        BlogPost.create(:person => @person, :title => "ROFLscale")
+        sync
+        cache.get("/count").to_i.should == 1
+        @person.blog_posts.destroy_all
+        sync
+        cache.get("/count").to_i.should == 0
+      end
+      
+      it "regenerates the cache when an association is changed" do
+        @post.update_attribute(:person, @person)
+        sync
+        cache.get("/author").should == "Abe"
+      end
+      
+      it "regenerates the cache when an associated object changes" do
+        @impostor.update_attribute(:name, "Steve")
+        sync
+        cache.get("/author").should == "Steve"
+      end
+      
+      it "removes a cache key when data it uses is deleted" do
+        cache.compute("/aaron") { Person.find_by_name("Aaron").name }
+        sync
+        cache.get("/aaron").should == "Aaron"
+        @impostor.destroy
+        sync
+        cache.get("/aaron").should be_nil
+        cache.has_key?("/aaron").should be_false
+      end
+    end
+  end
+  
+  describe "nested cache values" do
+    before do
+      cache.routes = Primer::RouteSet.new do
+        get('/title')   { BlogPost.first.title }
+        get('/content') { BlogPost.first.person.name + Primer.cache.compute('/title') }
+      end
+    end
+    
+    it "returns the correct value for the outer computation" do
+      cache.compute("/content").should == "Aaronroflmillions"
+    end
+    
+    describe "when the inner cache value is known before computing the outer value" do
+      before do
+        cache.compute("/title")
+        cache.compute("/content")
+      end
+      
+      it "returns the correct value for the outer computation" do
+        cache.compute("/content").should == "Aaronroflmillions"
+      end
+      
+      it "updates the cache when the title changes" do
+        @post.update_attribute(:title, "It's toasted")
+        sync
+        cache.get("/title").should == "It's toasted"
+        cache.get("/content").should == "AaronIt's toasted"
+      end
+    end
+  end
+  
+  describe "throttling" do
+    before do
+      cache.routes = Primer::RouteSet.new do
+        get("/data") { [BlogPost.first.title, Person.first.name] }
+      end
+      cache.throttle = 0.5
+      cache.compute("/data")
+    end
+    
+    it "restricts how often the cache is recalculated" do
+      cache.should_receive(:regenerate).once
+      @post.update_attribute(:title, "The new title")
+      @person.update_attribute(:name, "The new name")
+      sleep 1.0
+    end
+    
+    it "regenerates after the given throttle time, not after the first trigger" do
+      @post.update_attribute(:title, "The new title")
+      cache.get("/data").should == ["roflmillions", "Abe"]
+      
+      @person.update_attribute(:name, "The new name")
+      cache.get("/data").should == ["roflmillions", "Abe"]
+      
+      sleep 1.0
+      cache.get("/data").should == ["The new title", "The new name"]
+    end
+  end
+  
+  describe "#get" do
+    it "can be caught by the Watcher" do
+      calls = []
+      Primer::Watcher.watching(calls) { cache.get("/a/key") }
+      calls.should == [[cache, :get, ["/a/key"], nil, nil]]
+    end
+  end
+  
+  describe "#put" do
+    before { cache.get("/key").should be_nil }
+    
+    it "writes a value to the cache" do
+      cache.put("/key", "value")
+      cache.get("/key").should == "value"
+    end
+    
+    it "raises an error if any invalid key is used" do
+      lambda { cache.put("invalid", "hmm") }.should raise_error(Primer::InvalidKey)
+    end
+    
+    it "can store arbitrary data" do
+      value = ["foo", 4, [5, :bar], {:qux => [6, 7]}]
+      cache.put("/key", value)
+      cache.get("/key").should == value
+    end
+  end
+  
+  describe "#invalidate" do
+    before { cache.put("/some/key", "value") }
+    
+    it "removes the key from the cache" do
+      cache.invalidate("/some/key")
+      cache.get("/some/key").should be_nil
+    end
+    
+    describe "when a cache value has been generated from a computation" do
+      before { cache.compute("/people/abe/name") { @person.name } }
+      
+      it "removes existing relations between the model and the cache" do
+        cache.invalidate("/people/abe/name")
+        cache.should_not_receive(:invalidate)
+        @person.update_attribute(:name, "Weeble")
+      end
+    end
+  end
+  
+  describe "#clear" do
+    before { cache.put("/some/key", "value") }
+    
+    it "empties the cache" do
+      cache.clear
+      cache.get("/some/key").should be_nil
+    end
+  end
+end
+
+describe Primer::Cache::Memory do
+  let(:cache) { Primer::Cache::Memory.new }
+  
+  describe "with an in-memory bus" do
+    let(:bus) { Primer::Bus::Memory.new }
+    let(:sync_time) { 0 }
+    it_should_behave_like "primer cache"
+  end
+  
+  describe "with an AMQP bus" do
+    let(:bus) { Primer::Bus::AMQP.new(:queue => "data_changes_#{Helper.next_id}") }
+    let(:sync_time) { 0.2 }
+    it_should_behave_like "primer cache"
+  end
+end
+
+describe Primer::Cache::Redis do
+  let(:cache) { Primer::Cache::Redis.new }
+  let(:bus) { Primer::Bus::Memory.new }
+  let(:sync_time) { 0 }
+  it_should_behave_like "primer cache"
+end
+

data/spec/primer/helpers/erb_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module RenderingHelper
+  include Primer::Helpers::ERB
+  attr_accessor :name
+end
+
+class Context
+  include RenderingHelper
+end
+
+shared_examples_for "erb helper" do
+  before { context.name = "Aaron" }
+  
+  before do
+    Primer.cache = Primer::Cache::Memory.new
+    Primer.cache.routes = Primer::RouteSet.new do
+      get('/user') { "Master" }
+    end
+  end
+  
+  describe "#primer" do
+    describe "with an empty cache" do
+      it "renders the contents of the block" do
+        output.should == "Welcome, Master\nHello, Aaron\nThanks\n"
+      end
+      
+      it "uses the model to get data" do
+        context.should_receive(:name).and_return("Abe")
+        output.should == "Welcome, Master\nHello, Abe\nThanks\n"
+      end
+      
+      it "writes the block result to the cache" do
+        Primer.cache.should_receive(:put).with("/user", "Master")
+        Primer.cache.should_receive(:put).with("/cache/key", "Hello, Aaron")
+        output
+      end
+    end
+    
+    describe "with a value in the cache" do
+      before { Primer.cache.put("/cache/key", "Text from the cache") }
+      
+      it "does not use the model to get data" do
+        context.should_not_receive(:name)
+        output
+      end
+      
+      it "renders the cached value into the template" do
+        output.should == "Welcome, Master\nText from the cache\nThanks\n"
+      end
+    end
+  end
+end
+
+describe "Rails3 ERB templates" do
+  class ApplicationController < ActionController::Base
+    def self._helpers
+      RenderingHelper
+    end
+  end
+  
+  before do
+    view_context = context
+    controller.stub(:view_context).and_return(view_context)
+  end
+  
+  let(:controller) { ApplicationController.new }
+  let(:context)    { controller.view_context   }
+
+  let :output do
+    controller.render(:file => "spec/templates/page.erb", :action => "show") rescue
+    body = controller.response_body
+    Array === body ? body.first : body
+  end
+  
+  it_should_behave_like "erb helper"
+end
+
+describe "Sinatra ERB templates" do
+  let(:context) { Context.new }
+  
+  let :output do
+    template = Tilt[:erb].new("spec/templates/page.erb", 0, :outvar => "@_out_buf")
+    template.render(context)
+  end
+  
+  it_should_behave_like "erb helper"
+end
+