render_sync 0.5.0

data/lib/generators/render_sync/install_generator.rb

@@ -0,0 +1,14 @@
+module RenderSync
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def self.source_root
+        File.dirname(__FILE__) + "/templates"
+      end
+
+      def copy_files
+        template "sync.yml", "config/sync.yml"
+        copy_file "sync.ru", "sync.ru"
+      end
+    end
+  end
+end

data/lib/generators/render_sync/templates/sync.ru

@@ -0,0 +1,14 @@
+# Run with: rackup sync.ru -E production
+require "bundler/setup"
+require "yaml"
+require "faye"
+require "render_sync"
+
+Faye::WebSocket.load_adapter 'thin'
+
+RenderSync.load_config(
+  File.expand_path("../config/sync.yml", __FILE__),
+  ENV["RAILS_ENV"] || "development"
+)
+
+run RenderSync.pubsub_app

data/lib/generators/render_sync/templates/sync.yml

@@ -0,0 +1,34 @@
+# Faye
+development:
+  server: "http://localhost:9292/faye"
+  adapter_javascript_url: "http://localhost:9292/faye/faye.js"
+  auth_token: DEVELOPMENT_SECRET_TOKEN
+  adapter: "Faye"
+  async: true
+
+# Pusher
+# development:
+#   adapter_javascript_url: "http://js.pusher.com/2.0/pusher.min.js"
+#   app_id: "YOUR_PUSHER_APP_ID"
+#   api_key: "YOUR_PUSHER_API_KEY"
+#   auth_token: "YOUR_PUSHER_SECRET"
+#   adapter: "Pusher"
+#   async: true
+
+# Disabled
+# development:
+#   adapter: false
+
+test:
+  server: "http://localhost:9292/faye"
+  adapter_javascript_url: "http://localhost:9292/faye/faye.js"
+  adapter: "Faye"
+  auth_token: "secret"
+  async: false
+
+production:
+  server: "http://example.com/faye"
+  adapter_javascript_url: "http://localhost:9292/faye/faye.js"
+  adapter: "Faye"
+  auth_token: "<%= defined?(SecureRandom) ? SecureRandom.hex(32) : ActiveSupport::SecureRandom.hex(32) %>"
+  async: true

data/lib/render_sync.rb

@@ -0,0 +1,174 @@
+require 'eventmachine'
+require 'monitor'
+require 'digest/sha1'
+require 'erb'
+require 'net/http'
+require 'net/https'
+require 'logger'
+require 'render_sync/renderer'
+require 'render_sync/actions'
+require 'render_sync/action'
+require 'render_sync/controller_helpers'
+require 'render_sync/view_helpers'
+require 'render_sync/model_change_tracking'
+require 'render_sync/model_actions'
+require 'render_sync/model_syncing'
+require 'render_sync/model_touching'
+require 'render_sync/model'
+require 'render_sync/scope'
+require 'render_sync/scope_definition'
+require 'render_sync/refetch_model'
+require 'render_sync/faye_extension'
+require 'render_sync/partial_creator'
+require 'render_sync/refetch_partial_creator'
+require 'render_sync/partial'
+require 'render_sync/refetch_partial'
+require 'render_sync/channel'
+require 'render_sync/resource'
+require 'render_sync/clients/faye'
+require 'render_sync/clients/pusher'
+require 'render_sync/clients/dummy'
+require 'render_sync/reactor'
+if defined? Rails
+  require 'render_sync/erb_tracker'
+  require 'render_sync/engine'
+end
+
+module RenderSync
+
+  class << self
+    attr_accessor :config, :client, :logger
+
+    def config
+      @config || {}
+    end
+
+    def config_json
+      @config_json ||= begin
+        {
+          server: server,
+          api_key: api_key,
+          pusher_ws_host: pusher_ws_host,
+          pusher_ws_port: pusher_ws_port,
+          pusher_wss_port: pusher_wss_port,
+          pusher_encrypted: pusher_encrypted,
+          adapter: adapter
+        }.reject { |k, v| v.nil? }.to_json
+      end
+    end
+
+    # Resets the configuration to the default (empty hash)
+    def reset_config
+      @config = {}
+      @config_json = nil
+    end
+
+    # Loads the configuration from a given YAML file and environment (such as production)
+    def load_config(filename, environment)
+      reset_config
+      yaml = YAML.load(ERB.new(File.read(filename)).result)[environment.to_s]
+      raise ArgumentError, "The #{environment} environment does not exist in #{filename}" if yaml.nil?
+      yaml.each{|key, value| config[key.to_sym] = value }
+      setup_logger
+
+      if adapter
+        setup_client
+      else
+        setup_dummy_client
+      end
+    end
+
+    def setup_client
+      raise ArgumentError, "auth_token missing" if config[:auth_token].nil?
+      @client = RenderSync::Clients.const_get(adapter).new
+      @client.setup
+    end
+
+    def setup_dummy_client
+      config[:auth_token] = 'dummy_auth_token'
+      @client = RenderSync::Clients::Dummy.new
+    end
+
+    def setup_logger
+      @logger = (defined?(Rails) && Rails.logger) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def async?
+      config[:async]
+    end
+
+    def server
+      config[:server]
+    end
+
+    def adapter_javascript_url
+      config[:adapter_javascript_url]
+    end
+
+    def auth_token
+      config[:auth_token]
+    end
+
+    def adapter
+      config[:adapter]
+    end
+
+    def app_id
+      config[:app_id]
+    end
+
+    def api_key
+      config[:api_key]
+    end
+
+    def pusher_api_scheme
+      config[:pusher_api_scheme]
+    end
+
+    def pusher_api_host
+      config[:pusher_api_host]
+    end
+
+    def pusher_api_port
+      config[:pusher_api_port]
+    end
+
+    def pusher_ws_host
+      config[:pusher_ws_host]
+    end
+
+    def pusher_ws_port
+      config[:pusher_ws_port]
+    end
+
+    def pusher_wss_port
+      config[:pusher_wss_port]
+    end
+
+    def pusher_encrypted
+      if config[:pusher_encrypted].nil?
+        true
+      else
+        config[:pusher_encrypted]
+      end
+    end
+
+    def reactor
+      @reactor ||= Reactor.new
+    end
+
+    # Returns the Faye Rack application.
+    # Any options given are passed to the Faye::RackAdapter.
+    def pubsub_app(options = {})
+      Faye::RackAdapter.new({
+        mount: config[:mount] || "/faye",
+        timeout: config[:timeout] || 45,
+        extensions: [FayeExtension.new]
+      }.merge(options))
+    end
+
+    def views_root
+      Rails.root.join('app', 'views', 'sync')
+    end
+  end
+end

data/lib/render_sync/action.rb

@@ -0,0 +1,39 @@
+module RenderSync
+  class Action
+    include Actions
+    
+    attr_accessor :record, :name, :scope
+    
+    def initialize(record, name, *args)
+      options = args.extract_options!
+      @record = record
+      @name = name
+      @scope = get_scope_from_options(options)
+    end
+    
+    def perform
+      case name
+      when :new
+        sync_new record, scope: scope
+      when :update
+        sync_update record, scope: scope
+      when :destroy
+        sync_destroy record, scope: scope
+      end
+    end
+    
+    # Just for testing purposes (see test/sync/model_test.rb)
+    def test_path
+      Resource.new(record, scope).polymorphic_path.to_s
+    end
+    
+    private
+
+    # Merge default_scope and scope from options Hash
+    # compact array to remove nil elements
+    def get_scope_from_options(options)
+      [options[:default_scope], options[:scope]].compact
+    end
+    
+  end
+end

data/lib/render_sync/actions.rb

@@ -0,0 +1,114 @@
+module RenderSync
+  module Actions
+
+    # Render all sync'd partials for resource to string and publish update action
+    # to pubsub server with rendered resource messages
+    #
+    # resource - The ActiveModel resource
+    # options - The Hash of options
+    #   default_scope - The ActiveModel resource to scope the update channel to
+    #   scope - Either a String, a symbol, an instance of ActiveModel or
+    #           RenderSync::Scope or an Array containing a combination to scope
+    #           the update channel to. Will be concatenated to an optional
+    #           default_scope
+    #
+    def sync_update(resource, options = {})
+      sync resource, :update, options
+    end
+
+    # Render all sync'd partials for resource to string and publish destroy action
+    # to pubsub server with rendered resource messages
+    #
+    # resource - The ActiveModel resource
+    # options - The Hash of options
+    #   default_scope - The ActiveModel resource to scope the update channel to
+    #   scope - Either a String, a symbol, an instance of ActiveModel or
+    #           RenderSync::Scope or an Array containing a combination to scope
+    #           the destroy channel to. Will be concatenated to an optional
+    #           default_scope
+    #
+    def sync_destroy(resource, options = {})
+      sync resource, :destroy, options
+    end
+
+    # Render all sync'd partials for resource to string and publish action
+    # to pubsub server with rendered resource messages
+    #
+    # resource - The ActiveModel resource
+    # action - The Symbol action to publish. One of :update, :destroy
+    # options - The Hash of options
+    #   default_scope - The ActiveModel resource to scope the action channel to
+    #   scope - Either a String, a symbol, an instance of ActiveModel or
+    #           RenderSync::Scope or an Array containing a combination to scope
+    #           the channel to. Will be concatenated to an optional default_scope
+    #
+    def sync(resource, action, options = {})
+      scope = options[:scope]
+      partial_name = options[:partial]
+      resources = [resource].flatten
+      messages = resources.collect do |resource|
+        if partial_name
+          specified_partials(resource, sync_render_context, partial_name).collect do |partial|
+            partial.message(action)
+          end
+        else
+          all_partials(resource, sync_render_context, scope).collect do |partial|
+            partial.message(action)
+          end
+        end
+      end
+
+      RenderSync.client.batch_publish(messages.flatten)
+    end
+
+    # Render all sync'd partials for resource to string and publish
+    # new action to pubsub server with rendered resource messages
+    #
+    # resource - The ActiveModel resource, or Array of ActiveModel resources
+    # action - The Symbol action to publish. One of :update, :destroy
+    # options - The Hash of options
+    #   default_scope - The ActiveModel resource to scope the new channel to
+    #   scope - Either a String, a symbol, an instance of ActiveModel or
+    #           RenderSync::Scope or an Array containing any combination to scope
+    #           the new channel to. Will be concatenated to an optional
+    #           default_scope
+    #
+    def sync_new(resource, options = {})
+      scope = options[:scope]
+      partial_name = options[:partial]
+      resources = [resource].flatten
+      messages = resources.collect do |resource|
+        if partial_name
+          specified_partials(resource, sync_render_context, partial_name).collect do |partial|
+            partial.creator_for_scope(scope).message
+          end
+        else
+          all_partials(resource, sync_render_context, scope).collect do |partial|
+            partial.creator_for_scope(scope).message
+          end
+        end
+      end
+
+      RenderSync.client.batch_publish(messages.flatten)
+    end
+
+    private
+
+    # The Context class handling partial rendering
+    def sync_render_context
+      @sync_render_context ||= Renderer.new
+    end
+
+    # Returns Array of Partials for all given resource and context, including
+    # both Partial and RefetchPartial instances
+    def all_partials(resource, context, scope = nil)
+      Partial.all(resource, context, scope) + RefetchPartial.all(resource, context, scope)
+    end
+
+    # Returns an Array containing both the Partial and RefetchPartial instances
+    # for a given resource, context and partial name
+    def specified_partials(resource, context, partial_name)
+      [Partial.find(resource, partial_name, context), RefetchPartial.find(resource, partial_name, context)].compact
+    end
+  end
+end

data/lib/render_sync/channel.rb

@@ -0,0 +1,23 @@
+module RenderSync
+
+  class Channel
+
+    attr_accessor :name
+
+    def initialize(name)
+      self.name = name
+    end
+
+    def signature
+      OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest.new('sha1'),
+        RenderSync.auth_token,
+        self.name
+      )
+    end
+
+    def to_s
+      RenderSync.client.normalize_channel(self.signature)
+    end
+  end
+end

data/lib/render_sync/clients/dummy.rb

@@ -0,0 +1,22 @@
+module RenderSync
+  module Clients
+    class Dummy
+      def method_missing(*args, &block)
+        nil
+      end
+
+      class Message
+        def self.method_missing(*args, &block)
+          nil
+        end
+
+        def initialize(*)
+        end
+
+        def method_missing(*args, &block)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/render_sync/clients/faye.rb

@@ -0,0 +1,104 @@
+module RenderSync
+  module Clients
+    class Faye
+
+      def setup
+        require 'faye'
+        # nothing to set up
+      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 Faye
+      def normalize_channel(channel)
+        "/#{channel}"
+      end
+
+
+      class Message
+
+        attr_accessor :channel, :data
+
+        def self.batch_publish(messages)
+          if RenderSync.async?
+            batch_publish_asynchronous(messages)
+          else
+            batch_publish_synchronous(messages)
+          end
+        end
+
+        def self.batch_publish_synchronous(messages)
+          Net::HTTP.post_form(
+            URI.parse(RenderSync.server), 
+            message: batch_messages_query_hash(messages).to_json
+          )
+        end
+
+        def self.batch_publish_asynchronous(messages)
+          RenderSync.reactor.perform do
+            EM::HttpRequest.new(RenderSync.server).post(body: {
+              message: batch_messages_query_hash(messages).to_json
+            })
+          end
+        end
+
+        def self.batch_messages_query_hash(messages)
+          {
+            channel: "/batch_publish",
+            data: messages.collect(&:to_hash),
+            ext: { auth_token: RenderSync.auth_token }
+          }
+        end
+
+        def initialize(channel, data)
+          self.channel = channel
+          self.data = data
+        end
+
+        def to_hash
+          {
+            channel: channel,
+            data: data,
+            ext: {
+              auth_token: RenderSync.auth_token
+            }
+          }
+        end
+
+        def to_json
+          to_hash.to_json
+        end
+
+        def publish
+          if RenderSync.async?
+            publish_asynchronous
+          else
+            publish_synchronous
+          end
+        end
+
+        def publish_synchronous
+          Net::HTTP.post_form URI.parse(RenderSync.server), message: to_json
+        end
+
+        def publish_asynchronous
+          RenderSync.reactor.perform do
+            EM::HttpRequest.new(RenderSync.server).post(body: {
+              message: self.to_json
+            })
+          end
+        end
+      end
+    end
+  end
+end