render_sync 0.5.0

data/lib/render_sync/refetch_partial_creator.rb

@@ -0,0 +1,21 @@
+module RenderSync
+  class RefetchPartialCreator < PartialCreator
+
+    def initialize(name, resource, scoped_resource, context)
+      super
+      self.partial = RefetchPartial.new(name, self.resource.model, nil, context)
+    end
+
+    def message
+      RenderSync.client.build_message(channel,
+        refetch: true,
+        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
+  end
+end

data/lib/render_sync/renderer.rb

@@ -0,0 +1,19 @@
+module RenderSync
+  class Renderer
+
+    attr_accessor :context
+
+    def initialize
+      self.context = ApplicationController.new.view_context
+      self.context.instance_eval do
+        def url_options
+          ActionMailer::Base.default_url_options
+        end
+      end
+    end
+
+    def render_to_string(options)
+      context.render(options)
+    end
+  end
+end

data/lib/render_sync/resource.rb

@@ -0,0 +1,115 @@
+require 'pathname'
+
+module RenderSync
+  class Resource
+    attr_accessor :model, :scopes
+
+    # Constructor
+    #
+    # model - The ActiveModel instace for this Resource
+    # scopes - The optional scopes to prefix polymorphic paths with.
+    #          Can be a Symbol/String, a parent model or an RenderSync::Scope
+    #          or an Array with any combination.
+    #
+    # Examples
+    #
+    #   class User < ActiveRecord::Base
+    #     sync :all
+    #     sync_scope :cool, -> { where(cool: true) }
+    #     sync_scope :in_group, ->(group) { where(group_id: group.id) }
+    #   end
+    # 
+    #   user = User.find(1)
+    #
+    #   resource = Resource.new(user)
+    #   resource.polymorphic_path => "/users/1"
+    #   resource.polymorphic_new_path => "/users/new"
+    #
+    #   resource = Resource.new(user, :admin)
+    #   resource.polymorphic_path => "/admin/users/1"
+    #   resource.polymorphic_new_path => "/admin/users/new"
+    #
+    #   resource = Resource.new(user, [:staff, :restricted])
+    #   resource.polymorphic_path => "/staff/restricted/users/1"
+    #   resource.polymorphic_new_path => "/staff/restricted/users/new"
+    #
+    #   resource = Resource.new(user, project)
+    #   resource.polymorphic_path => "/projects/2/users/1"
+    #   resource.polymorphic_new_path => "/projects/2/users/new"
+    #
+    #   resource = Resource.new(user, User.cool)
+    #   resource.polymorphic_path => "/cool/users/2"
+    #   resource.polymorphic_new_path => "/cool/users/new"
+    #
+    #   resource = Resource.new(user, User.in_group(group))
+    #   resource.polymorphic_path => "/in_group/group/3/users/2"
+    #   resource.polymorphic_new_path => "/in_group/group/3/users/new"
+    #
+    #   resource = Resource.new(user, [:admin, User.cool, User.in_group(group)])
+    #   resource.polymorphic_path => "admin/cool/in_group/group/3/users/2"
+    #   resource.polymorphic_new_path => "admin/cool/in_group/group/3/users/new"
+    #
+    #   resource = Resource.new(user, [:admin, project])
+    #   resource.polymorphic_path => "/admin/projects/2/users/1"
+    #   resource.polymorphic_new_path => "/admin/projects/2/users/new"
+    #
+    def initialize(model, scopes = nil)
+      self.model = model
+      self.scopes = scopes
+    end
+
+    def scopes=(new_scopes)
+      new_scopes = [new_scopes] unless new_scopes.nil? or new_scopes.is_a? Array
+      @scopes = new_scopes
+    end
+
+    def id
+      model.id
+    end
+
+    def name
+      model.class.model_name.to_s.underscore
+    end
+    
+    def base_name
+      name.split('/').last
+    end
+
+    def plural_name
+      name.pluralize
+    end
+
+    def scopes_path
+      path = Pathname.new('/')
+      unless scopes.nil?
+        paths = scopes.map do |scope|
+          if scope.is_a?(RenderSync::Scope)
+            scope.polymorphic_path.relative_path_from(path)
+          elsif scope.class.respond_to? :model_name
+            Resource.new(scope).polymorphic_path.relative_path_from(path)
+          else
+            scope.to_s
+          end
+        end
+        path = path.join(*paths)
+      end
+      path
+    end
+
+    # Returns an unscoped Pathname for the model (e.g. /users/1)
+    def model_path
+      Pathname.new('/').join(plural_name, id.to_s)
+    end
+
+    # Returns the scoped Pathname for the model (e.g. /users/1/todos/2)
+    def polymorphic_path
+      scopes_path.join(plural_name, id.to_s)
+    end
+
+    # Returns the scoped Pathname for a new model (e.g. /users/1/todos/new)
+    def polymorphic_new_path
+      scopes_path.join(plural_name, "new")
+    end
+  end
+
+end

data/lib/render_sync/scope.rb

@@ -0,0 +1,113 @@
+module RenderSync
+  class Scope
+    attr_accessor :scope_definition, :args, :valid
+    
+    def initialize(scope_definition, args)
+      @scope_definition = scope_definition
+      @args = args
+    end
+    
+    # Return a new sync scope by passing a scope definition (containing a lambda and parameter names)
+    # and a set of arguments to be handed over to the lambda
+    def self.new_from_args(scope_definition, args)
+      if args.length != scope_definition.parameters.length
+        raise ArgumentError, "wrong number of arguments (#{args.length} for #{scope_definition.parameters.length})"
+      end
+
+      # Classes currently supported as Arguments for the sync scope lambda
+      supported_arg_types = [Fixnum, Integer, ActiveRecord::Base]
+
+      # Check passed args for types. Raise ArgumentError if arg class is not supported
+      args.each_with_index do |arg, i|
+
+        unless supported_arg_types.find { |klass| break true if arg.is_a?(klass) }
+          param = scope_definition.parameters[i]
+          raise ArgumentError, "invalid argument '#{param}' (#{arg.class.name}). Currently only #{supported_arg_types.map(&:name).join(", ")} are supported"
+        end
+      end
+      
+      new(scope_definition, args)
+    end
+    
+    # Return a new sync scope by passing a scope definition (containing a lambda and parameter names)
+    # and an ActiveRecord model object. The args List will be filled with the model attributes
+    # corrensponding to the parameter names defined in the scope_definition
+    def self.new_from_model(scope_definition, model)
+      new(scope_definition, scope_definition.parameters.map { |p| model.send(p) })
+    end
+    
+    # Return the ActiveRecord Relation by calling the lamda with the given args.
+    #
+    def relation
+      scope_definition.lambda.call(*args)
+    end
+
+    # Check if the combination of stored AR relation and args is valid by calling exists? on it.
+    # This may raise an exception depending on the args, so we have to rescue the block
+    #
+    def valid?
+      @valid ||= begin 
+        relation.exists?
+        true # set valid to true, if relation.exists?(model) does not throw any exception
+      rescue
+        false
+      end
+    end
+    
+    def invalid?
+      !valid?
+    end
+
+    # Check if the given record falls under the narrowing by the stored ActiveRecord Relation.
+    # Depending on the arguments set in args this can lead to an exception (e.g. when a nil is passed)
+    # Also set the value of valid to avoid another DB query.
+    #
+    def contains?(record)
+      begin
+        val = relation.exists?(record.id)
+        @valid = true # set valid to true, if relation.exists?(model) does not throw any exception
+        val
+      rescue
+        @valid = false
+      end
+    end
+
+    # Generates an Array of path elements based on the given lambda args and their
+    # name which is saved in scope_definition.parameters
+    #
+    def args_path
+      scope_definition.parameters.each_with_index.map do |parameter, i| 
+        if args[i].is_a? ActiveRecord::Base
+          [parameter.to_s, args[i].send(args[i].class.primary_key).to_s]
+        else
+          [parameter.to_s, args[i].to_s] 
+        end
+      end.flatten
+    end
+
+    # Returns the Pathname for this scope
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     sync :all
+    #     belongs_to :group
+    #     sync_scope :in_group, ->(group) { where(group_id: group.id) }
+    #   end
+    #       
+    #   group = Group.first
+    #   User.in_group(group).polymorphic_path.to_s
+    #   # => "/in_group/group/1"
+    #  
+    def polymorphic_path
+      Pathname.new('/').join(*([scope_definition.name.to_s, args_path].flatten))
+    end
+    
+    # Delegate all undefined methods to the relation, so that
+    # the scope behaves like an ActiveRecord::Relation, e.g. call count
+    # on the relation (User.in_group(group).count)
+    #
+    def method_missing(method, *args, &block)
+      relation.send(method, *args, &block)
+    end
+
+  end
+end

data/lib/render_sync/scope_definition.rb

@@ -0,0 +1,30 @@
+module RenderSync
+  class ScopeDefinition
+    attr_accessor :klass, :name, :lambda, :parameters, :args
+    
+    def initialize(klass, name, lambda)
+      self.class.ensure_valid_params!(klass, lambda)
+      
+      @klass = klass
+      @name = name
+      @lambda = lambda
+      @parameters = lambda.parameters.map { |p| p[1] }
+    end
+    
+    # Checks the validity of the parameter names contained in the lambda definition.
+    # E.g. if the lambda looks like this:
+    #
+    # ->(user) { where(user_id: user.id) }
+    #
+    # The name of the passed argument (user) must be present as a column name or an
+    # instance method (e.g. an association) of the ActiveRecord object.
+    #
+    def self.ensure_valid_params!(klass, lambda)
+      unless (invalid = lambda.parameters.map { |p| p[1] } - klass.column_names.map(&:to_sym) - klass.instance_methods) == []
+        raise ArgumentError, "Invalid parameters #{invalid}. Parameter names of the sync_scope lambda definition may only contain ActiveRecord column names or instance methods of #{klass.name}."
+      end
+      true
+    end
+   
+  end
+end

data/lib/render_sync/view_helpers.rb

@@ -0,0 +1,106 @@
+module RenderSync
+
+  module ViewHelpers
+
+    # Surround partial render in script tags, watching for
+    # sync_update and sync_destroy channels from pubsub server
+    #
+    # options - The Hash of options
+    #   partial - The String partial filename without leading underscore
+    #   resource - The ActiveModel resource
+    #   collection - The Array of ActiveModel resources to use in place of
+    #                single resource
+    #
+    # Examples
+    #   <%= sync partial: 'todo', resource: todo %>
+    #   <%= sync partial: 'todo', collection: todos %>
+    #
+    def sync(options = {})
+      collection   = options[:collection] || [options.fetch(:resource)]
+      scope        = options[:channel] || options[:scope] || (collection.is_a?(RenderSync::Scope) ? collection : nil)
+      partial_name = options.fetch(:partial, scope)
+      refetch      = options.fetch(:refetch, false)
+
+      results = []
+      collection.each do |resource|
+        if refetch
+          partial = RefetchPartial.new(partial_name, resource, scope, self)
+        else
+          partial = Partial.new(partial_name, resource, scope, self)
+        end
+        results << "
+          <script type='text/javascript' data-sync-id='#{partial.selector_start}'>
+            RenderSync.onReady(function(){
+              var partial = new RenderSync.Partial({
+                name:           '#{partial.name}',
+                resourceName:   '#{partial.resource.name}',
+                resourceId:     '#{resource.id}',
+                authToken:      '#{partial.refetch_auth_token}',
+                channelUpdate:  '#{partial.channel_for_action(:update)}',
+                channelDestroy: '#{partial.channel_for_action(:destroy)}',
+                selectorStart:  '#{partial.selector_start}',
+                selectorEnd:    '#{partial.selector_end}',
+                refetch:        #{refetch}
+              });
+              partial.subscribe();
+            });
+          </script>
+        ".squish.html_safe
+        results << partial.render
+        results << "
+          <script type='text/javascript' data-sync-id='#{partial.selector_end}'>
+          </script>
+        ".squish.html_safe
+      end
+
+      safe_join(results)
+    end
+
+    # Setup listener for new resource from sync_new channel, appending
+    # partial in place
+    #
+    # options - The Hash of options
+    #   partial - The String partial filename without leading underscore
+    #   resource - The ActiveModel resource
+    #   scope - The ActiveModel resource to scope the new channel publishes to.
+    #           Used for restricting new resource publishes to 'owner' models.
+    #           ie, current_user, project, group, etc. When excluded, listens
+    #           for global resource creates.
+    #
+    #   direction - The String/Symbol direction to insert rendered partials.
+    #               One of :append, :prepend. Defaults to :append
+    #
+    # Examples
+    #   <%= sync_new partial: 'todo', resource: Todo.new, scope: @project %>
+    #   <%= sync_new partial: 'todo', resource: Todo.new, scope: @project, direction: :prepend %>
+    #
+    def sync_new(options = {})
+      partial_name = options.fetch(:partial)
+      scope        = options[:scope]
+      direction    = options.fetch :direction, 'append'
+      refetch      = options.fetch(:refetch, false)
+      resource     = scope.is_a?(RenderSync::Scope) ? scope.new : options.fetch(:resource)
+
+      if refetch
+        creator = RefetchPartialCreator.new(partial_name, resource, scope, self)
+      else
+        creator = PartialCreator.new(partial_name, resource, scope, self)
+      end
+      "
+        <script type='text/javascript' data-sync-id='#{creator.selector}'>
+          RenderSync.onReady(function(){
+            var creator = new RenderSync.PartialCreator({
+              name:         '#{partial_name}',
+              resourceName: '#{creator.resource.name}',
+              channel:      '#{creator.channel}',
+              selector:     '#{creator.selector}',
+              direction:    '#{direction}',
+              refetch:      #{refetch}
+            });
+            creator.subscribe();
+          });
+        </script>
+      ".html_safe
+    end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks