render_sync 0.5.0

data/lib/render_sync/model_change_tracking.rb

@@ -0,0 +1,97 @@
+module RenderSync
+  module ModelChangeTracking
+    private
+    # Set up callback to store record and sync scope states prior
+    # the update action
+    def self.included(base)
+      base.class_eval do
+        before_update :store_state_before_update, if: -> { RenderSync::Model.enabled? }
+      end
+    end
+    
+    # Stores the current state of the record with its attributes
+    # and all sync relations in an instance variable BEFORE the update 
+    # command to later be able to check if the record has been 
+    # added/removed from sync scopes.
+    #
+    # Uses ActiveModel::Dirty to track attribute changes
+    # (triggered by AR Callback before_update)
+    #
+    def store_state_before_update
+      record = self.dup
+      changed_attributes.each do |key, value|
+        record.send("#{key}=", value)
+      end
+      record.send("#{self.class.primary_key}=", self.send(self.class.primary_key))
+      
+      @record_before_update = record
+      
+      @scopes_before_update = {}
+      sync_scope_definitions.each do |definition|
+        scope = RenderSync::Scope.new_from_model(definition, record)
+        @scopes_before_update[definition.name] = { 
+          scope: scope, 
+          contains_record: scope.contains?(record) 
+        }
+      end
+    end
+
+    # Checks if this record has left the old scope defined by the passed scope
+    # definition throughout the update process
+    #
+    def left_old_scope?(definition)
+      scope_before_update(definition).valid? \
+        && old_record_in_old_scope?(definition) \
+        && !new_record_in_old_scope?(definition)
+    end
+
+    # Checks if this record has entered the new (possibly changed) scope
+    # defined by the passed scope definition throughout the update process
+    #
+    def entered_new_scope?(definition)
+      scope_after_update(definition).valid? \
+        && new_record_in_new_scope?(definition) \
+        && !remained_in_old_scope?(definition)
+    end
+
+    # Return the instance (state) of this record from before the update
+    # (which was previously stored by #store_state_before_update)
+    #
+    def record_before_update
+      @record_before_update
+    end
+    
+    def record_after_update
+      self
+    end
+
+    def remained_in_old_scope?(definition)
+      old_record_in_old_scope?(definition) && new_record_in_old_scope?(definition)
+    end   
+    
+    def scope_before_update(definition)
+      @scopes_before_update[definition.name][:scope]
+    end
+    
+    def scope_after_update(definition)
+      RenderSync::Scope.new_from_model(definition, record_after_update)
+    end
+    
+    def old_record_in_old_scope?(definition)
+      @scopes_before_update[definition.name][:contains_record]
+    end
+    
+    def old_record_in_new_scope?(definition) 
+      scope_after_update(definition).contains?(record_before_update)
+    end
+    
+    def new_record_in_new_scope?(definition)
+      scope_after_update(definition).contains?(record_after_update)
+    end
+ 
+    def new_record_in_old_scope?(defintion)
+      scope_before_update(defintion).contains?(record_after_update)
+    end
+    
+  end
+end

data/lib/render_sync/model_syncing.rb

@@ -0,0 +1,65 @@
+module RenderSync
+  module ModelRenderSyncing
+    
+    private
+
+    def prepare_sync_create
+      add_sync_action(:new, self, default_scope: sync_default_scope)
+      
+      sync_scope_definitions.each do |definition|
+        scope = RenderSync::Scope.new_from_model(definition, self)
+        if scope.contains?(self)
+          add_sync_action :new, self, scope: scope, default_scope: sync_default_scope
+        end
+      end
+    end
+
+    def prepare_sync_update
+      add_sync_action :update, self
+
+      sync_scope_definitions.each do |definition|
+        prepare_sync_update_scope(definition)
+      end
+    end
+
+    def prepare_sync_destroy
+      add_sync_action :destroy, self, default_scope: sync_default_scope
+      
+      sync_scope_definitions.each do |definition|
+        scope = RenderSync::Scope.new_from_model(definition, self)
+        if scope.valid?
+          add_sync_action :destroy, self, 
+            scope: scope, 
+            default_scope: sync_default_scope
+        end
+      end
+    end
+
+    # Creates update actions for subscribers on the sync scope defined by
+    # the passed sync scope definition.
+    #
+    # It compares the state of the record in context of the sync scope before 
+    # and after the update. If the record has been added to a scope, it 
+    # publishes a new partial to the subscribers of that scope. It also sends 
+    # a destroy action to subscribers of the scope, if the record has been 
+    # removed from it.
+    #
+    def prepare_sync_update_scope(scope_definition)
+      # Add destroy action for the old scope (scope_before_update) 
+      # if this record has left it
+      if left_old_scope?(scope_definition)
+        add_sync_action :destroy, record_before_update, 
+          scope: scope_before_update(scope_definition), 
+          default_scope: sync_default_scope
+      end
+
+      # Add new action for the new scope (scope_after_update) if this record has entered it
+      if entered_new_scope?(scope_definition)
+        add_sync_action :new, record_after_update, 
+          scope: scope_after_update(scope_definition), 
+          default_scope: sync_default_scope
+      end
+    end
+    
+  end
+end

data/lib/render_sync/model_touching.rb

@@ -0,0 +1,35 @@
+module RenderSync
+  module ModelTouching
+
+    private
+
+    def prepare_sync_touches
+      sync_touches.each do |touch_association|
+        add_sync_action :update, touch_association
+      end
+    end
+    
+    # Return the associations to be touched after a record change
+    # Takes into account that an association itself may have changed during 
+    # an update call (e.g. project_id has changed). To accomplish this, it
+    # uses the stored record from before the update (@record_before_update) 
+    # and touches that as well as the current association
+    #
+    def sync_touches
+      sync_associations = []
+
+      self.class.sync_touches.each do |touch|
+        current = send(touch)
+        sync_associations.push(current.reload) if current.present?
+        
+        if @record_before_update.present?
+          previous = @record_before_update.send(touch)
+          sync_associations.push(previous.reload) if previous.present?
+        end
+      end
+
+      sync_associations.uniq.compact
+    end
+        
+  end
+end

data/lib/render_sync/partial.rb

@@ -0,0 +1,112 @@
+module RenderSync
+  class Partial
+    attr_accessor :name, :resource, :context
+
+    def self.all(model, context, scope = nil)
+      resource = Resource.new(model, scope)
+
+      Dir["#{RenderSync.views_root}/#{resource.plural_name}/_*.*"].map do |partial|
+        partial_name = File.basename(partial)
+        Partial.new(partial_name[1...partial_name.index('.')], resource.model, scope, context)
+      end
+    end
+
+    def self.find(model, partial_name, context)
+      resource = Resource.new(model)
+      plural_name = resource.plural_name
+      partial = Dir["app/views/sync/#{plural_name}/_#{partial_name}.*"].first
+      return unless partial
+      Partial.new(partial_name, resource.model, nil, context)
+    end
+
+    def initialize(name, resource, scope, context)
+      self.name = name
+      self.resource = Resource.new(resource, scope)
+      self.context = context
+    end
+
+    def render_to_string
+      context.render_to_string(partial: path, locals: locals, formats: [:html])
+    end
+
+    def render
+      context.render(partial: path, locals: locals, formats: [:html])
+    end
+
+    def sync(action)
+      message(action).publish
+    end
+
+    def message(action)
+      RenderSync.client.build_message channel_for_action(action),
+        html: (render_to_string unless action.to_s == "destroy")
+    end
+
+    def authorized?(auth_token)
+      self.auth_token == auth_token
+    end
+
+    def auth_token
+      @auth_token ||= Channel.new("#{polymorphic_path}-_#{name}").to_s
+    end
+
+    # For the refetch feature we need an auth_token that wasn't created
+    # with scopes, because the scope information is not available on the
+    # refetch-request. So we create a refetch_auth_token which is based
+    # only on model_name and id plus the name of this partial
+    #
+    def refetch_auth_token
+      @refetch_auth_token ||= Channel.new("#{model_path}-_#{name}").to_s
+    end
+
+    def channel_prefix
+      @channel_prefix ||= auth_token
+    end
+
+    def update_channel_prefix
+      @update_channel_prefix ||= refetch_auth_token
+    end
+
+    def channel_for_action(action)
+      case action
+      when :update
+        "#{update_channel_prefix}-#{action}"
+      else
+        "#{channel_prefix}-#{action}"
+      end
+    end
+
+    def selector_start
+      "#{channel_prefix}-start"
+    end
+
+    def selector_end
+      "#{channel_prefix}-end"
+    end
+
+    def creator_for_scope(scope)
+      PartialCreator.new(name, resource.model, scope, context)
+    end
+
+
+    private
+
+    def path
+      "sync/#{resource.plural_name}/#{name}"
+    end
+
+    def locals
+      locals_hash = {}
+      locals_hash[resource.base_name.to_sym] = resource.model
+      locals_hash
+    end
+
+    def model_path
+      resource.model_path
+    end
+
+    def polymorphic_path
+      resource.polymorphic_path
+    end
+  end
+end

data/lib/render_sync/partial_creator.rb

@@ -0,0 +1,47 @@
+module RenderSync
+  class PartialCreator
+    attr_accessor :name, :resource, :context, :partial
+
+    def initialize(name, resource, scopes, context)
+      self.name = name
+      self.resource = Resource.new(resource, scopes)
+      self.context = context
+      self.partial = Partial.new(name, self.resource.model, scopes, context)
+    end
+
+    def auth_token
+      @auth_token ||= Channel.new("#{polymorphic_path}-_#{name}").to_s
+    end
+
+    def channel
+      @channel ||= auth_token
+    end
+
+    def selector
+      "#{channel}"
+    end
+
+    def sync_new
+      message.publish
+    end
+
+    def message
+      RenderSync.client.build_message(channel,
+        html: partial.render_to_string,
+        resourceId: resource.id,
+        authToken: partial.auth_token,
+        channelUpdate: partial.channel_for_action(:update),
+        channelDestroy: partial.channel_for_action(:destroy),
+        selectorStart: partial.selector_start,
+        selectorEnd: partial.selector_end
+      )
+    end
+
+
+    private
+
+    def polymorphic_path
+      resource.polymorphic_new_path
+    end
+  end
+end

data/lib/render_sync/reactor.rb

@@ -0,0 +1,48 @@
+module RenderSync
+  class Reactor
+    include MonitorMixin
+
+    # Execute EventMachine bound code block, waiting for reactor to start if
+    # not yet started or reactor thread has gone away
+    def perform
+      return EM.next_tick{ yield } if running?
+      cleanly_shutdown_reactor
+      condition = new_cond
+      Thread.new do
+        EM.run do
+          EM.next_tick do
+            synchronize do
+              condition.signal
+            end
+          end
+        end
+      end
+      synchronize do
+        condition.wait_until { EM.reactor_running? }
+        EM.next_tick { yield }
+      end
+    end
+
+    def stop
+      EM.stop if running?
+    end
+
+    def running?
+      EM.reactor_running? && EM.reactor_thread.alive?
+    end
+
+    # If the reactor's thread died, EM still thinks it's running but it isn't.
+    # This will happen if we forked from a process that had the reator running.
+    # Tell EM it's dead. Stolen from the EM internals
+    #
+    # https://groups.google.com/forum/#!msg/ruby-amqp/zchM4QzbZRE/I43wIjbgIv4J
+    #
+    def cleanly_shutdown_reactor
+      if EM.reactor_running?
+        EM.stop_event_loop
+        EM.release_machine
+        EM.instance_variable_set '@reactor_running', false
+      end
+    end
+  end
+end

data/lib/render_sync/refetch_model.rb

@@ -0,0 +1,21 @@
+module RenderSync
+  class RefetchModel
+
+    def self.find_by_class_name_and_id(resource_name, id)      
+      class_name = resource_name.to_s.classify
+      class_name.safe_constantize.find(id) if supported_classes.include?(class_name)
+    rescue
+      nil
+    end
+
+    def self.supported_classes
+      Thread.current["sync_refetch_classes"] = nil if Rails.env.development?
+      
+      Thread.current["sync_refetch_classes"] ||= begin
+        Dir["app/views/sync/*/refetch"].collect{|path|
+          File.basename(path.gsub(/\/refetch$/, '')).classify
+        }.reject{|clazz| clazz.nil? }
+      end
+    end
+  end
+end

data/lib/render_sync/refetch_partial.rb

@@ -0,0 +1,43 @@
+module RenderSync
+  class RefetchPartial < Partial
+
+    def self.all(model, context, scope = nil)
+      resource = Resource.new(model)
+
+      Dir["#{RenderSync.views_root}/#{resource.plural_name}/refetch/_*.*"].map do |partial|
+        partial_name = File.basename(partial)
+        RefetchPartial.new(partial_name[1...partial_name.index('.')], resource.model, scope, context)
+      end
+    end
+
+    def self.find(model, partial_name, context)
+      resource = Resource.new(model)
+      plural_name = resource.plural_name
+      partial = Dir["#{RenderSync.views_root}/#{plural_name}/refetch/_#{partial_name}.*"].first
+      return unless partial
+      RefetchPartial.new(partial_name, resource.model, nil, context)
+    end
+
+    def self.find_by_authorized_resource(model, partial_name, context, auth_token)
+      partial = find(model, partial_name, context)
+      return unless partial && partial.authorized?(auth_token)
+
+      partial
+    end
+
+    def message(action)
+      RenderSync.client.build_message channel_for_action(action), refetch: true
+    end
+
+    def creator_for_scope(scope)
+      RefetchPartialCreator.new(name, resource.model, scope, context)
+    end
+
+
+    private
+
+    def path
+      "sync/#{resource.plural_name}/refetch/#{name}"
+    end
+  end
+end