render_sync 0.5.0

data/lib/render_sync/clients/pusher.rb

@@ -0,0 +1,77 @@
+module RenderSync
+  module Clients
+    class Pusher
+
+      def setup
+        require 'pusher'
+        ::Pusher.app_id = RenderSync.app_id
+        ::Pusher.key    = RenderSync.api_key
+        ::Pusher.secret = RenderSync.auth_token
+
+        if RenderSync.pusher_api_scheme
+          ::Pusher.scheme = RenderSync.pusher_api_scheme
+        end
+
+        if RenderSync.pusher_api_host
+          ::Pusher.host = RenderSync.pusher_api_host
+        end
+
+        if RenderSync.pusher_api_port
+          ::Pusher.port = RenderSync.pusher_api_port
+        end
+      end
+
+      def batch_publish(*args)
+        Message.batch_publish(*args)
+      end
+
+      def build_message(*args)
+        Message.new(*args)
+      end
+
+      # Public: Normalize channel to adapter supported format
+      #
+      # channel - The string channel name
+      #
+      # Returns The normalized channel prefixed with supported format for Pusher
+      def normalize_channel(channel)
+        channel
+      end
+
+
+      class Message
+
+        attr_accessor :channel, :data
+
+        def self.batch_publish(messages)
+          messages.each do |message|
+            message.publish
+          end
+        end
+
+        def initialize(channel, data)
+          self.channel = channel
+          self.data = data
+        end
+
+        def publish
+          if RenderSync.async?
+            publish_asynchronous
+          else
+            publish_synchronous
+          end
+        end
+
+        def publish_synchronous
+          ::Pusher.trigger([channel], 'sync', data)
+        end
+
+        def publish_asynchronous
+          RenderSync.reactor.perform do
+            ::Pusher.trigger_async([channel], 'sync', data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/render_sync/controller_helpers.rb

@@ -0,0 +1,33 @@
+module RenderSync
+
+  module ControllerHelpers
+
+    include Actions
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def enable_sync(options = {})
+        around_filter :enable_sync, options
+      end
+    end
+
+
+    private
+
+    def enable_sync
+      RenderSync::Model.enable(sync_render_context) do
+        yield
+      end
+    end
+
+    # ControllerHelpers overrides Action#sync_render_context to use self as
+    # context to allow full access to request/response cycle
+    # over default abstract Renderer class
+    def sync_render_context
+      self
+    end
+  end
+end

data/lib/render_sync/engine.rb

@@ -0,0 +1,24 @@
+module RenderSync
+
+  class Engine < Rails::Engine
+    # Loads the sync.yml file if it exists.
+    initializer "sync.config", group: :all do
+      path = Rails.root.join("config/sync.yml")
+      RenderSync.load_config(path, Rails.env) if path.exist?
+    end
+
+    initializer "sync.activerecord" do
+      ActiveRecord::Base.send :extend, Model::ClassMethods
+    end
+
+    # Adds the ViewHelpers into ActionView::Base
+    initializer "sync.view_helpers" do
+      ActionView::Base.send :include, ViewHelpers
+    end
+
+    # Adds the ControllerHelpers into ActionConroller::Base
+    initializer "sync.controller_helpers" do
+      ActionController::Base.send :include, RenderSync::ControllerHelpers
+    end
+  end
+end

data/lib/render_sync/erb_tracker.rb

@@ -0,0 +1,49 @@
+module RenderSync
+  tracker_class = nil
+  begin
+    require 'action_view/dependency_tracker'
+    tracker_class = ActionView::DependencyTracker::ERBTracker
+  rescue LoadError
+    begin
+      require 'cache_digests/dependency_tracker'
+      tracker_class = CacheDigests::DependencyTracker::ERBTracker
+    rescue LoadError
+    end
+  end
+
+  if tracker_class
+    class ERBTracker < tracker_class
+      # Matches:
+      #   sync partial: "comment", collection: commentable.comments
+      #   sync partial: "comment", resource: comment
+      SYNC_DEPENDENCY = /
+        sync(?:_new)?\s*                         # sync or sync_new, followed by optional whitespace
+        \(?\s*                                   # start an optional parenthesis for the sync call
+        (?:partial:|:partial\s+=>)\s*            # naming the partial, used with collection
+        ["']([a-z][a-z_\/]+)["']\s*              # the template name itself -- 1st capture
+        ,\s*                                     # comma separating parameters
+        :?(?:resource|collection)(?::|\s+=>)\s*  # resource or collection identifier
+        @?(?:[a-z]+\.)*([a-z]+)                  # the resource or collection itself -- 2nd capture
+      /x
+
+      def self.call(name, template)
+        new(name, template).dependencies
+      end
+
+      def dependencies
+        (sync_dependencies + super).uniq
+      end
+
+      private
+
+      def source
+        template.source
+      end
+
+      def sync_dependencies
+        source.scan(SYNC_DEPENDENCY).
+          collect { |template, resource| "sync/#{resource.pluralize}/#{template}" }
+      end
+    end
+  end
+end

data/lib/render_sync/faye_extension.rb

@@ -0,0 +1,45 @@
+module RenderSync
+  class FayeExtension
+
+    def incoming(message, callback)
+      return handle_eror(message, callback) unless message_authenticated?(message)
+      if batch_publish?(message)
+        batch_incoming(message, callback)
+      else
+        single_incoming(message, callback)
+      end
+    end
+
+    def batch_incoming(message, callback)
+      message["data"].each do |message|
+        incoming(message, callback)
+      end
+    end
+
+    def single_incoming(message, callback)
+      callback.call(message)
+    end
+
+    def batch_publish?(message)
+      message['channel'] == "/batch_publish"
+    end
+
+    # IMPORTANT: clear out the auth token so it is not leaked to the client
+    def outgoing(message, callback)
+      if message['ext'] && message['ext']['auth_token']
+        message['ext'] = {} 
+      end
+      callback.call(message)
+    end
+
+    def handle_eror(message, callback)
+      message['error'] = 'Invalid authentication token'
+      callback.call(message)
+    end
+
+    def message_authenticated?(message)
+      !(message['channel'] !~ %r{^/meta/} && 
+        message['ext']['auth_token'] != RenderSync.auth_token)
+    end
+  end
+end

data/lib/render_sync/model.rb

@@ -0,0 +1,174 @@
+module RenderSync
+  module Model
+
+    def self.enabled?
+      Thread.current["model_sync_enabled"]
+    end
+
+    def self.context
+      Thread.current["model_sync_context"]
+    end
+
+    def self.enable!(context = nil)
+      Thread.current["model_sync_enabled"] = true
+      Thread.current["model_sync_context"] = context
+    end
+
+    def self.disable!
+      Thread.current["model_sync_enabled"] = false
+      Thread.current["model_sync_context"] = nil
+    end
+
+    def self.enable(context = nil)
+      enable!(context)
+      yield
+    ensure
+      disable!
+    end
+
+    module ClassMethods
+      attr_accessor :sync_default_scope, :sync_scope_definitions, :sync_touches
+
+      # Set up automatic syncing of partials when a record of this class is
+      # created, updated or deleted. Be sure to wrap your model actions inside
+      # a sync_enable block for sync to do its magic.
+      #
+      def sync(*actions)
+        include ModelActions unless include?(ModelActions)
+        include ModelChangeTracking unless include?(ModelChangeTracking)
+        include ModelRenderSyncing
+        
+        if actions.last.is_a? Hash
+          @sync_default_scope = actions.last.fetch :default_scope
+        end
+        
+        actions = [:create, :update, :destroy] if actions.include? :all
+        actions.flatten!
+
+        if actions.include? :create
+          after_create  :prepare_sync_create,  if: -> { RenderSync::Model.enabled? }
+        end
+        
+        if actions.include? :update
+          after_update  :prepare_sync_update,  if: -> { RenderSync::Model.enabled? }
+        end
+        
+        if actions.include? :destroy
+          after_destroy :prepare_sync_destroy, if: -> { RenderSync::Model.enabled? }
+        end
+
+      end
+
+      # Set up a sync scope for the model defining a set of records to be 
+      # updated via sync
+      #
+      # name - The name of the scope
+      # lambda - A lambda defining the scope.
+      #    Has to return an ActiveRecord::Relation.
+      #
+      # You can define the lambda with arguments (see examples). 
+      # Note that the naming of the parameters is very important. Only use 
+      # names of methods or ActiveRecord attributes defined on the model (e.g. 
+      # user_id). This way sync will be able to pass changed records to the 
+      # lambda and track changes to the scope.
+      #
+      # Example:
+      #
+      #   class Todo < ActiveRecord::Base
+      #     belongs_to :user
+      #     belongs_to :project
+      #     scope :incomplete, -> { where(complete: false) }
+      #
+      #     sync :all
+      #
+      #     sync_scope :complete, -> { where(complete: true) }
+      #     sync_scope :by_project, ->(project_id) { where(project_id: project_id) }
+      #     sync_scope :my_incomplete_todos, ->(user) { incomplete.where(user_id: user.id) }
+      #   end
+      #
+      # To subscribe to these scopes you would put these lines into your views:
+      #
+      #   <%= sync partial: "todo", collection: @todos, scope: Todo.complete %>
+      #
+      # If the collection you want to render is exactly defined be the given 
+      # scope the scope can be omitted:
+      #
+      #   <%= sync partial: "todo", collection: Todo.complete %>
+      #
+      # For rendering my_incomplete_todos:
+      #
+      #   <%= sync partial: "todo", collection: Todo.my_incomplete_todos(current_user) %>
+      #
+      # The render_new call has to look like this:
+      #
+      #   <%= sync_new partial: "todo", resource: Todo.new, scope: Todo.complete %>
+      # 
+      # Now when a record changes sync will use the names of the lambda 
+      # parameters (project_id and user), get the corresponding attributes from 
+      # the record (project_id column or user association) and pass it to the 
+      # lambda. This way sync can identify if a record has been added or 
+      # removed from a scope and will then publish the changes to subscribers
+      # on all scoped channels.
+      #
+      # Beware that chaining of sync scopes in the view is currently not 
+      # possible. So the following example would raise an exception:
+      #
+      #   <%= sync_new partial: "todo", Todo.new, scope: Todo.mine(current_user).incomplete %>
+      #
+      # To work around this just create an explicit sync_scope for your problem:
+      # 
+      #   sync_scope :my_incomplete_todos, ->(user) { incomplete.mine(current_user) }
+      #
+      # And in the view:
+      #
+      #   <%= sync_new partial: "todo", Todo.new, scope: Todo.my_incomplete_todos(current_user) %>
+      #
+      def sync_scope(name, lambda)
+        if self.respond_to?(name)
+          raise ArgumentError, "invalid scope name '#{name}'. Already defined on #{self.name}"
+        end
+        
+        @sync_scope_definitions[name] = RenderSync::ScopeDefinition.new(self, name, lambda)
+        
+        singleton_class.send(:define_method, name) do |*args|
+          RenderSync::Scope.new_from_args(@sync_scope_definitions[name], args)
+        end        
+      end
+      
+      # Register one or more associations to be sync'd when this record changes. 
+      #
+      # Example:
+      #
+      #   class Todo < ActiveRecord::Base
+      #     belongs_to :project
+      #     belongs_to :user
+      #
+      #     sync :all
+      #     sync_touch :project, :user
+      #   end
+      #
+      def sync_touch(*args)
+        # Only load Modules and set up callbacks if sync_touch wasn't 
+        # called before
+        if @sync_touches.blank?
+          include ModelActions unless include?(ModelActions)
+          include ModelChangeTracking unless include?(ModelChangeTracking)
+          include ModelTouching
+        
+          @sync_touches ||= []
+        
+          after_create   :prepare_sync_touches, if: -> { RenderSync::Model.enabled? }
+          after_update   :prepare_sync_touches, if: -> { RenderSync::Model.enabled? }
+          after_destroy  :prepare_sync_touches, if: -> { RenderSync::Model.enabled? }
+        end
+
+        options = args.extract_options!
+        args.each do |arg|
+          @sync_touches.push(arg)
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/render_sync/model_actions.rb

@@ -0,0 +1,60 @@
+module RenderSync
+  module ModelActions
+    # Set up instance variable holding the collected sync actions 
+    # to be published later on.
+    #
+    attr_accessor :sync_actions
+
+    # Set up ActiveRecord callbacks to prepare for collecting 
+    # publish sync actions and publishing them after commit
+    #
+    def self.included(base)
+      base.class_eval do
+        @sync_scope_definitions ||= {}
+        
+        before_create  :prepare_sync_actions, if: -> { RenderSync::Model.enabled? }
+        before_update  :prepare_sync_actions, if: -> { RenderSync::Model.enabled? }
+        before_destroy :prepare_sync_actions, if: -> { RenderSync::Model.enabled? }
+        
+        after_commit   :publish_sync_actions, if: -> { RenderSync::Model.enabled? }
+      end
+    end
+    
+    def sync_default_scope
+      return nil unless self.class.sync_default_scope
+      send self.class.sync_default_scope
+    end
+    
+    private
+
+    def sync_render_context
+      RenderSync::Model.context || super
+    end
+    
+    def prepare_sync_actions
+      self.sync_actions = []
+    end
+    
+    # Add a new aync action to the list of actions to be published later on
+    #
+    def add_sync_action(action_name, record, options = {})
+      sync_actions.push(Action.new(record, action_name, options))
+    end
+    
+    # Run the collected actions on after_commit callback
+    # Triggers the syncing of the partials
+    #
+    def publish_sync_actions
+      sync_actions.each(&:perform)
+    end
+    
+    def sync_scope_definitions
+      self.class.sync_scope_definitions.values
+    end
+    
+    def sync_render_context
+      RenderSync::Model.context || super
+    end
+    
+  end
+end