primer 0.1.0

data/lib/primer/cache/redis.rb

@@ -0,0 +1,70 @@
+require 'redis'
+
+module Primer
+  class Cache
+    
+    class Redis < Cache
+      REDIS_CONFIG = {:thread_safe => true}
+      
+      def initialize(config = {})
+        config = REDIS_CONFIG.merge(config)
+        @redis = ::Redis.new(config)
+      end
+      
+      def clear
+        @redis.flushdb
+      end
+      
+      def put(cache_key, value)
+        validate_key(cache_key)
+        @redis.set(cache_key, YAML.dump(value))
+        publish_change(cache_key)
+        RealTime.publish(cache_key, value)
+      end
+      
+      def get(cache_key)
+        validate_key(cache_key)
+        string = @redis.get(cache_key)
+        string ? YAML.load(string) : nil
+      end
+      
+      def has_key?(cache_key)
+        @redis.exists(cache_key)
+      end
+      
+      def invalidate(cache_key)
+        @redis.del(cache_key)
+        
+        return unless has_key?('deps' + cache_key)
+        @redis.smembers('deps' + cache_key).each do |attribute|
+          @redis.srem(attribute, cache_key)
+        end
+        @redis.del('deps' + cache_key)
+      end
+      
+      def relate(cache_key, attributes)
+        attributes.each do |attribute|
+          serial = attribute.join('/')
+          @redis.sadd('deps' + cache_key, serial)
+          @redis.sadd(serial, cache_key)
+        end
+      end
+      
+      def keys_for_attribute(attribute)
+        serial = attribute.join('/')
+        has_key?(serial) ? @redis.smembers(serial) : []
+      end
+      
+      def timeout(cache_key, &block)
+        return if has_key?('timeouts' + cache_key)
+        @redis.set('timeouts' + cache_key, 'true')
+        add_timeout(cache_key, @throttle) do
+          block.call
+          @redis.del('timeouts' + cache_key)
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/primer/cache.rb

@@ -0,0 +1,84 @@
+module Primer
+  class Cache
+    
+    autoload :Memory, ROOT + '/primer/cache/memory'
+    autoload :Redis,  ROOT + '/primer/cache/redis'
+    
+    include Watcher
+    watch_calls_to :get
+    
+    include Faye::Timeouts
+    
+    attr_accessor :throttle
+    attr_writer :routes
+    
+    def primer_identifier
+      [Cache.name]
+    end
+    
+    def routes(&block)
+      @routes ||= RouteSet.new
+      @routes.instance_eval(&block) if block_given?
+      @routes
+    end
+    
+    def bind_to_bus
+      Primer.bus.subscribe(:changes) { |attribute| changed(attribute) }
+    end
+    
+    def compute(cache_key)
+      return get(cache_key) if has_key?(cache_key)
+      
+      unless block_given? or @routes
+        message = "Cannot call Cache#compute(#{cache_key}) with no block: no routes have been configured"
+        raise RouteNotFound.new(message)
+      end
+      
+      calls = []
+      result = Watcher.watching(calls) do
+        block_given? ? yield : @routes.evaluate(cache_key)
+      end
+      
+      attributes = calls.map do |(receiver, method_name, args, block, return_value)|
+        receiver.primer_identifier + [method_name.to_s] + args
+      end
+      
+      unless result.nil?
+        relate(cache_key, attributes)
+        put(cache_key, result)
+      end
+      
+      result
+    end
+    
+    def changed(attribute)
+      keys_for_attribute(attribute).each do |cache_key|
+        block = lambda do
+          invalidate(cache_key)
+          regenerate(cache_key)
+        end
+        @throttle ? timeout(cache_key, &block) : block.call
+      end
+    end
+    
+  private
+    
+    def publish_change(cache_key)
+      Primer.bus.publish(:changes, primer_identifier + ['get', cache_key])
+    end
+    
+    def regenerate(cache_key)
+      compute(cache_key) rescue nil
+    end
+    
+    def validate_key(cache_key)
+      raise InvalidKey.new(cache_key) unless Cache.valid_key?(cache_key)
+    end
+    
+    def self.valid_key?(cache_key)
+      Faye::Channel.valid?(cache_key)
+    end
+    
+  end
+end
+

data/lib/primer/enabler.rb

@@ -0,0 +1,18 @@
+module Primer
+  module Enabler
+    def enable!
+      @enabled = true
+      on_enable
+    end
+    
+    def disable!
+      @enabled = false
+      on_disable
+    end
+    
+    def enabled?
+      !!@enabled
+    end
+  end
+end
+

data/lib/primer/helpers.rb

@@ -0,0 +1,66 @@
+module Primer
+  module Helpers
+    
+    module ERB
+      def primer(cache_key, tag_name = :div, &block)
+        result = Primer.cache.compute(cache_key) do
+          block_given? ?
+              primer_capture_output(&block) :
+              Primer.cache.routes.evaluate(cache_key)
+        end
+        
+        if Primer.real_time and not block_given?
+          result = primer_real_time(result, tag_name, cache_key)
+        end
+        
+        return result unless block_given?
+        primer_detect_buffer.concat(result)
+        nil
+      end
+      
+    private
+      
+      def primer_capture_output(&block)
+        return primer_capture_output_from_rails(&block) if primer_rails?
+        return primer_capture_output_from_sinatra(&block) if primer_sinatra?
+      end
+      
+      def primer_real_time(fragment, tag_name, cache_key)
+        <<-HTML
+        <#{ tag_name } id="#{ RealTime.dom_id(cache_key) }">
+        #{ fragment }
+        </#{ tag_name }>
+        <script type="text/javascript">PRIMER_CHANNELS.push(#{ cache_key.inspect })</script>
+        HTML
+      end
+      
+      def primer_detect_buffer
+        [@output_buffer, @_out_buf].compact.first
+      end
+      
+      def primer_rails?
+        return false unless respond_to?(:capture)
+        return true if defined?(ActionView::OutputBuffer)
+        String === @output_buffer
+      end
+      
+      def primer_capture_output_from_rails(&block)
+        capture(&block)
+      end
+      
+      def primer_sinatra?
+        defined?(@_out_buf)
+      end
+      
+      def primer_capture_output_from_sinatra(&block)
+        original_buffer = @_out_buf
+        result = @_out_buf = ''
+        block.call
+        @_out_buf = original_buffer
+        result.to_s
+      end
+    end
+    
+  end
+end
+

data/lib/primer/real_time.rb

@@ -0,0 +1,80 @@
+module Primer
+  class RealTime < Faye::RackAdapter
+    
+    BAYEUX_CONFIG = {:mount => '/primer/bayeux', :timeout => 25}
+    SCRIPT_PATH   = '/primer.js'
+    TYPE_SCRIPT   = {'Content-Type' => 'text/javascript'}
+    SCRIPT_SOURCE = File.read(ROOT + '/javascript/primer.js')
+    
+    class ServerAuth
+      def incoming(message, callback)
+        channel = message['channel']
+        return callback.call(message) if Faye::Channel.meta?(channel)
+        
+        password = message['ext'] && message['ext']['password']
+        unless password == RealTime.password
+          message['error'] = Faye::Error.ext_mismatch
+        end
+        
+        message['ext'].delete('password') if password
+        callback.call(message)
+      end
+    end
+    
+    class ClientAuth
+      def outgoing(message, callback)
+        channel = message['channel']
+        return callback.call(message) if Faye::Channel.meta?(channel)
+        
+        message['ext'] ||= {}
+        message['ext']['password'] = RealTime.password
+        
+        callback.call(message)
+      end
+    end
+    
+    def initialize(app)
+      super(app, BAYEUX_CONFIG)
+      add_extension(ServerAuth.new)
+    end
+    
+    def call(env)
+      request = Rack::Request.new(env)
+      return super unless request.path_info == SCRIPT_PATH
+      [200, TYPE_SCRIPT, [SCRIPT_SOURCE]]
+    end
+    
+    class << self
+      attr_accessor :bayeux_server, :password
+      
+      def dom_id(cache_key)
+        "primer#{ ('-' + cache_key).gsub(/[^a-z0-9]+/i, '-') }"
+      end
+      
+      def publish(cache_key, value)
+        return unless Primer.real_time
+        client.publish(cache_key,
+          :dom_id  => dom_id(cache_key),
+          :content => value
+        )
+      end
+      
+    private
+      
+      def client
+        raise NotConfigured.new unless bayeux_server
+        
+        Faye.ensure_reactor_running!
+        return @client if @client
+        
+        endpoint = "#{ bayeux_server }#{ BAYEUX_CONFIG[:mount] }"
+        @client = Faye::Client.new(endpoint)
+        @client.add_extension(ClientAuth.new)
+        
+        @client
+      end
+    end
+    
+  end
+end
+

data/lib/primer/route_set.rb

@@ -0,0 +1,50 @@
+require 'sinatra'
+
+module Primer
+  class RouteSet
+    def initialize(&routes)
+      @app = Class.new(Router)
+      instance_eval(&routes) if block_given?
+    end
+    
+    def get(path, &block)
+      @app.get(path, &block)
+    end
+    
+    def evaluate(path)
+      @app.new(path).evaluate
+    end
+  end
+  
+  class Router < Sinatra::Base
+    class Request
+      attr_reader :path_info
+      def initialize(path)
+        @path_info = path
+      end
+    end
+    
+    # Circumvent the fact that Sinatra::Base.new creates a Rack stack
+    def self.new(*args)
+      Class.instance_method(:new).bind(self).call(*args)
+    end
+    
+    def initialize(path)
+      @request = Request.new(path)
+      @original_params = indifferent_hash
+    end
+    
+    def evaluate
+      routes = self.class.routes['GET']
+      catch(:halt) {
+        routes.each do |pattern, keys, conditions, block|
+          process_route(pattern, keys, conditions) do
+            throw(:halt, instance_eval(&block))
+          end
+        end
+        raise RouteNotFound.new("No route match found for key #{@request.path_info}")
+      }
+    end
+  end
+end
+

data/lib/primer/watcher/active_record_macros.rb

@@ -0,0 +1,70 @@
+module Primer
+  module Watcher
+    
+    module ActiveRecordMacros
+      def self.extended(klass)
+        klass.watch_calls_to(*klass.attributes_watchable_by_primer)
+        klass.__send__(:include, InstanceMethods)
+        klass.after_create(:notify_primer_after_create)
+        klass.after_update(:notify_primer_after_update)
+        klass.after_destroy(:notify_primer_after_destroy)
+      end
+      
+      def attributes_watchable_by_primer
+        attributes = columns + reflect_on_all_associations
+        attributes.map { |c| c.name.to_s }
+      end
+      
+      def primer_foreign_key_mappings
+        return @primer_foreign_key_mappings if defined?(@primer_foreign_key_mappings)
+        
+        foreign_keys = reflect_on_all_associations.
+                       select { |a| a.macro == :belongs_to }.
+                       map { |a| [a.primary_key_name.to_s, a.name] }
+        
+        @primer_foreign_key_mappings = Hash[foreign_keys]
+      end
+      
+      def patch_method_for_primer(method_name)
+        method = instance_method(method_name) rescue nil
+        return super if method
+        class_eval <<-RUBY
+          def #{method_name}
+            result = read_attribute(:#{method_name})
+            Primer::Watcher.log(self, :#{method_name}, [], nil, result)
+            result
+          end
+        RUBY
+      end
+      
+      def unpatch_method_for_primer(method_name)
+        alias_name = Macros.alias_name(method_name)
+        method = instance_method(alias_name) rescue nil
+        return super if method
+        class_eval <<-RUBY
+          undef_method :#{method_name}
+        RUBY
+      end
+      
+      module InstanceMethods
+        def primer_identifier
+          ['ActiveRecord', self.class.name, read_attribute(self.class.primary_key)]
+        end
+        
+        def notify_primer_after_create
+          Primer.bus.publish(:active_record, [:create, self.class.name, attributes])
+        end
+        
+        def notify_primer_after_update
+          Primer.bus.publish(:active_record, [:update, self.class.name, attributes, changes])
+        end
+        
+        def notify_primer_after_destroy
+          Primer.bus.publish(:active_record, [:destroy, self.class.name, attributes])
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/primer/watcher/macros.rb

@@ -0,0 +1,70 @@
+module Primer
+  module Watcher
+    
+    module Macros
+      attr_reader :primer_watched_calls
+      
+      def self.extended(klass)
+        if defined?(ActiveRecord) and klass < ActiveRecord::Base
+          klass.extend(ActiveRecordMacros)
+        end
+      end
+      
+      def self.alias_name(method_name)
+        method_name.to_s.gsub(/[^a-z0-9_]$/i, '') + '_before_primer_patch'
+      end
+      
+      def watch_calls_to(*methods)
+        Watcher.register(self)
+        @primer_watched_calls ||= []
+        @primer_watched_calls += methods
+      end
+      
+      def inherited(subclass)
+        super
+        calls = @primer_watched_calls || []
+        subclass.watch_calls_to(*calls)
+      end
+      
+      def patch_for_primer!
+        return if @primer_watched_calls.nil? or @primer_patched
+        @primer_patched = true
+        @primer_watched_calls.each do |method_name|
+          patch_method_for_primer(method_name)
+        end
+      end
+      
+      def patch_method_for_primer(method_name)
+        alias_name = Macros.alias_name(method_name)
+        return unless method = instance_method(method_name) rescue nil
+        class_eval <<-RUBY
+          alias :#{alias_name} :#{method_name}
+          def #{method_name}(*args, &block)
+            result = #{alias_name}(*args, &block)
+            Primer::Watcher.log(self, :#{method_name}, args, block, result)
+            result
+          end
+        RUBY
+      end
+      
+      def unpatch_for_primer!
+        return if @primer_watched_calls.nil? or not @primer_patched
+        @primer_patched = false
+        @primer_watched_calls.each do |method_name|
+          unpatch_method_for_primer(method_name)
+        end
+      end
+      
+      def unpatch_method_for_primer(method_name)
+        alias_name = Macros.alias_name(method_name)
+        return unless method = instance_method(alias_name) rescue nil
+        class_eval <<-RUBY
+          alias :#{method_name} :#{alias_name}
+          undef_method :#{alias_name}
+        RUBY
+      end
+    end
+    
+  end
+end
+

data/lib/primer/watcher.rb

@@ -0,0 +1,62 @@
+module Primer
+  module Watcher
+    
+    extend Enabler
+    autoload :Macros,             ROOT + '/primer/watcher/macros'
+    autoload :ActiveRecordMacros, ROOT + '/primer/watcher/active_record_macros'
+    
+    def self.included(klass)
+      klass.extend(Macros)
+    end
+    
+    def self.register(klass)
+      @classes ||= Set.new
+      @classes.add(klass)
+    end
+    
+    def self.reset!
+      Thread.current[:primer_call_log] = []
+      Thread.current[:primer_loggers]  = nil
+    end
+    
+    def self.call_log
+      Thread.current[:primer_call_log] ||= []
+    end
+    
+    def self.log(receiver, method_name, args, block, result)
+      call = [receiver, method_name, args, block, result]
+      loggers.each { |logger| logger << call }
+    end
+    
+    def self.loggers
+      Thread.current[:primer_loggers] ||= [call_log]
+    end
+    
+    def self.on_enable
+      @classes.each { |klass| klass.patch_for_primer! }
+    end
+    
+    def self.on_disable
+      @classes.each { |klass| klass.unpatch_for_primer! }
+    end
+    
+    def self.watching(calls = [])
+      @active_watching_blocks ||= 0
+      @active_watching_blocks += 1
+      was_enabled = enabled?
+      enable!
+      loggers << calls
+      result = yield
+      loggers.pop
+      @active_watching_blocks -= 1
+      disable! if @active_watching_blocks.zero? and not was_enabled
+      result
+    end
+    
+    def primer_identifier
+      ['Object', self.class.name, object_id]
+    end
+    
+  end
+end
+

data/lib/primer/worker/active_record_agent.rb

@@ -0,0 +1,120 @@
+module Primer
+  class Worker
+    
+    class ActiveRecordAgent
+      def self.bind_to_bus
+        Primer.bus.subscribe :active_record do |event, class_name, attributes, changes|
+          model = class_name.constantize.new(attributes)
+          model.instance_eval do
+            @attributes = attributes
+            @changed_attributes = changes if changes
+          end
+          __send__("on_#{event}", model)
+        end
+      end
+      
+      def self.macros
+        Watcher::ActiveRecordMacros
+      end
+      
+      def self.on_create(model)
+        notify_belongs_to_associations(model)
+      end
+      
+      def self.on_update(model)
+        notify_attributes(model, model.changes)
+      end
+      
+      def self.on_destroy(model)
+        notify_attributes(model, model.attributes)
+        notify_has_many_associations(model)
+      end
+      
+      def self.notify_attributes(model, fields)
+        foreign_keys = model.class.primer_foreign_key_mappings
+        
+        fields.each do |attribute, value|
+          Primer.bus.publish(:changes, model.primer_identifier + [attribute.to_s])
+          
+          next unless assoc = foreign_keys[attribute.to_s]
+          Primer.bus.publish(:changes, model.primer_identifier + [assoc.to_s])
+          notify_belongs_to_association(model, assoc, value)
+        end
+      end
+      
+      def self.notify_belongs_to_associations(model)
+        model.class.reflect_on_all_associations.each do |assoc|
+          next unless assoc.macro == :belongs_to
+          notify_belongs_to_association(model, assoc.name)
+        end
+      end
+      
+      def self.notify_belongs_to_association(model, assoc_name, change = nil)
+        assoc = model.class.reflect_on_association(assoc_name)
+        owner_class = assoc.class_name.constantize
+        
+        mirror = mirror_association(model.class, owner_class, :has_many)
+        
+        if owner = model.__send__(assoc_name)
+          Primer.bus.publish(:changes, owner.primer_identifier + [mirror.name.to_s])
+          notify_has_many_through_association(owner, mirror.name)
+        end
+        
+        return unless Array === change and change.first.any?
+        old_id = change.first.first
+        previous = owner_class.find(:first, :conditions => {owner_class.primary_key => old_id})
+        return unless previous
+        
+        Primer.bus.publish(:changes, previous.primer_identifier + [mirror.name.to_s])
+        notify_has_many_through_association(previous, mirror.name)
+      end
+      
+      def self.notify_has_many_associations(model)
+        model.class.reflect_on_all_associations.each do |assoc|
+          next unless assoc.macro == :has_many
+          next if assoc.options[:dependent] == :destroy
+          
+          model_id = model.__send__(model.class.primary_key)
+          klass    = assoc.class_name.constantize
+          related  = klass.find(:all, :conditions => {assoc.primary_key_name => model_id})
+          
+          related.each do |object|
+            mirror = mirror_association(model.class, object.class, :belongs_to)
+            next unless mirror
+            
+            Primer.bus.publish(:changes, object.primer_identifier + [mirror.name.to_s])
+          end
+        end
+      end
+      
+      def self.notify_has_many_through_association(model, through_name)
+        model.class.reflect_on_all_associations.each do |assoc|
+          next unless assoc.macro == :has_many
+          
+          if assoc.options[:through] == through_name
+            Primer.bus.publish(:changes, model.primer_identifier + [assoc.name.to_s])
+          end
+          
+          assoc.class_name.constantize.reflect_on_all_associations.each do |secondary|
+            next unless secondary.macro == :has_many and secondary.options[:through] and
+                        secondary.source_reflection.active_record == model.class and
+                        secondary.source_reflection.name == through_name
+            
+            model.__send__(assoc.name).each do |related|
+              Primer.bus.publish(:changes, related.primer_identifier + [secondary.name.to_s])
+            end
+          end
+        end
+      end
+      
+      def self.mirror_association(object_class, related_class, macro)
+        related_class.reflect_on_all_associations.find do |mirror_assoc|
+          mirror_assoc.macro == macro and
+          mirror_assoc.class_name == object_class.name
+        end
+      end
+    end
+    
+  end
+end
+