fragmentary 0.1.0

data/lib/fragmentary/fragments_helper.rb

@@ -0,0 +1,62 @@
+module Fragmentary
+
+  module FragmentsHelper
+
+    def cache_fragment(options)
+      no_cache = options.delete(:no_cache)
+      options.reverse_merge!(:user => current_user) if respond_to?(:current_user)
+      fragment = options.delete(:fragment) || Fragmentary::Fragment.base_class.root(options)
+      builder = CacheBuilder.new(fragment, template = self)
+      unless no_cache
+        cache fragment, :skip_digest => true do
+          yield(builder)
+        end
+      else
+        yield(builder)
+      end
+      self.output_buffer = WidgetParser.new(self).parse_buffer
+    end
+
+    def fragment_builder(options)
+      template = options.delete(:template)
+      options.reverse_merge!(:user => current_user) if respond_to?(:current_user)
+      CacheBuilder.new(Fragmentary::Fragment.base_class.existing(options), template)
+    end
+
+
+    class CacheBuilder
+      include ::ActionView::Helpers::CacheHelper
+      include ::ActionView::Helpers::TextHelper
+
+      attr_accessor :fragment, :template
+
+      def initialize(fragment, template)
+        @fragment = fragment
+        @template = template
+      end
+
+      def cache_child(options)
+        no_cache = options.delete(:no_cache)
+        insert_widgets = options.delete(:insert_widgets)
+        options.reverse_merge!(:user => template.current_user) if template.respond_to?(:current_user)
+        child = options.delete(:child) || fragment.child(options)
+        builder = CacheBuilder.new(child, template)
+        unless no_cache
+          template.cache child, :skip_digest => true do
+            yield(builder)
+          end
+        else
+          yield(builder)
+        end
+        template.output_buffer = WidgetParser.new(template).parse_buffer if insert_widgets
+      end
+
+      def method_missing(method, *args)
+        fragment.send(method, *args)
+      end
+
+    end
+
+  end
+
+end

data/lib/fragmentary/handler.rb

@@ -0,0 +1,31 @@
+module Fragmentary
+  class Handler
+    def self.all
+      @@all
+    end
+
+    def self.clear
+      @@all = []
+    end
+    self.clear
+
+    def self.create(**args)
+      @@all << (handler = self.new(args))
+      handler
+    end
+
+    def initialize(**args)
+      @args = args
+    end
+
+    def call
+      raise "Method 'call' not defined."
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def to_h
+    attributes.symbolize_keys
+  end
+end

data/lib/fragmentary/publisher.rb

@@ -0,0 +1,82 @@
+require 'wisper/active_record'
+
+module Fragmentary
+
+  module Publisher
+
+    def self.included(base)
+      base.instance_eval do
+        @class_registrations ||= Set.new
+        include Wisper.model
+        # ensures we override Wisper's definitions
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+
+      private
+
+      def registrations
+        local_registrations + class_registrations + global_registrations + temporary_registrations
+      end
+
+      def class_registrations
+        self.class.registrations
+      end
+
+      def after_create_broadcast
+        Rails.logger.info "\n***** #{start = Time.now} broadcasting :after_create from #{self.class.name} #{self.id}\n"
+        broadcast(:after_create, self)
+        Rails.logger.info "\n***** #{Time.now} broadcast :after_create from #{self.class.name} #{self.id} took #{(Time.now - start) * 1000} ms\n"
+      end
+
+      def after_update_broadcast
+        broadcast(:after_update, self)
+      end
+
+      def after_destroy_broadcast
+        broadcast(:after_destroy, self)
+      end
+
+      def after_commit_broadcast
+      end
+    end
+
+    module ClassMethods
+      def subscribe(listener, options = {})
+        @class_registrations << ::Wisper::ObjectRegistration.new(listener, options.merge(:scope => self))
+      end
+
+      def registrations
+        @class_registrations + (superclass.try(:registrations) || [])
+      end
+    end
+  end
+end
+
+
+module Wisper
+  class ObjectRegistration
+
+    # For the registration to broadcast a specified event we require:
+    #   - 'should_broadcast?'    - If the listener susbcribed with an ':on' option, ensure that the event
+    #                              is included in the 'on' list.
+    #   - 'listener.respond_to?' - The listener contains a handler for the event
+    #   - 'publisher_in_scope'   - If the listener subscribed with a ':scope' option, ensure that the
+    #                              publisher's class is included in the 'scope' list.
+    def broadcast(event, publisher, *args)
+      method_to_call = map_event_to_method(event)
+      if should_broadcast?(event) && listener.respond_to?(method_to_call) && publisher_in_scope?(publisher)
+        broadcaster.broadcast(listener, publisher, method_to_call, args)
+      end
+    end
+
+    private
+
+    def publisher_in_scope?(publisher)
+      allowed_classes.empty? || (allowed_classes.include? publisher.class.name)
+    end
+  end
+end

data/lib/fragmentary/request.rb

@@ -0,0 +1,30 @@
+module Fragmentary
+
+  class Request
+    attr_reader :method, :path, :options, :parameters
+
+    def initialize(method, path, parameters=nil, options=nil)
+      @method, @path, @parameters, @options = method, path, parameters, options
+    end
+
+    def ==(other)
+      method == other.method and path == other.path and parameters == other.parameters and options == other.options
+    end
+
+    def to_proc
+      method = @method; path = @path; parameters = @parameters; options = @options.try :dup
+      if @options.try(:[], :xhr)
+        Proc.new do
+          puts "      * Sending xhr request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
+          send(:xhr, method, path, parameters, options)
+        end
+      else
+        Proc.new do
+          puts "      * Sending request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
+          send(method, path, parameters, options)
+        end
+      end
+    end
+  end
+
+end

data/lib/fragmentary/request_queue.rb

@@ -0,0 +1,139 @@
+require 'fragmentary/user_session'
+
+module Fragmentary
+
+  class RequestQueue
+
+    @@all = []
+
+    def self.all
+      @@all
+    end
+
+    attr_reader :requests, :user_type, :sender
+
+    def initialize(user_type)
+      @user_type = user_type
+      @requests = []
+      @sender = Sender.new(self)
+      @@all << self
+    end
+
+    def <<(request)
+      unless @requests.find{|r| r == request}
+        @requests << request
+      end
+      self
+    end
+
+    def size
+      @requests.size
+    end
+
+    def session
+      @session ||= new_session
+    end
+
+    def new_session
+      case user_type
+      when 'signed_in'
+        UserSession.new('Bob')
+      when 'admin'
+        UserSession.new('Alice', :admin => true)
+      else
+        UserSession.new
+      end
+    end
+
+    def next_request
+      @requests.shift
+    end
+
+    def clear
+      @requests = []
+    end
+
+    def clear_session
+      @session = nil
+    end
+
+    def remove_path(path)
+      requests.delete_if{|r| r.path == path}
+    end
+
+    def send(**args)
+      sender.start(args)
+    end
+
+    def method_missing(method, *args)
+      sender.send(method, *args)
+    end
+
+    class Sender
+      class << self
+        def jobs
+          ::Delayed::Job.where("(handler LIKE ?) OR (handler LIKE ?)", "--- !ruby/object:#{name} %", "--- !ruby/object:#{name}\n%")
+        end
+      end
+
+      attr_reader :queue
+
+      def initialize(queue)
+        @queue = queue
+      end
+
+      def next_request
+        queue.next_request.to_proc
+      end
+
+      def send_next_request
+        if queue.size > 0
+          queue.session.instance_exec(&(next_request))
+        end
+      end
+
+      def send_all_requests
+        while queue.size > 0
+          send_next_request
+        end
+      end
+
+      # Send all requests, either directly or by schedule
+      def start(delay: nil, between: nil)
+        Rails.logger.info "\n***** Processing request queue for user_type '#{queue.user_type}'\n"
+        @delay = delay; @between = between
+        if @delay or @between
+          schedule_requests(@delay)
+          # sending requests by schedule makes a copy of the sender and queue objects for
+          # asynchronous execution, so we have to manually clear out the original queue.
+          queue.clear
+        else
+          send_all_requests
+        end
+      end
+
+      def perform
+        Rails.logger.info "\n***** Processing request queue for user_type '#{queue.user_type}'\n"
+        @between ? send_next_request : send_all_requests
+      end
+
+      def success
+        schedule_requests(@between) if queue.size > 0
+      end
+
+      private
+
+      def schedule_requests(delay=0.seconds)
+        if queue.size > 0
+          queue.clear_session
+          Delayed::Job.transaction do
+            self.class.jobs.destroy_all
+            Delayed::Job.enqueue self, :run_at => delay.from_now
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fragmentary/subscriber.rb

@@ -0,0 +1,36 @@
+require 'fragmentary/subscription'
+
+module Fragmentary
+
+  # Each fragment subclass has a unique Subscriber instance reponsible for handling subscriptions
+  # to publishers. Each subscriber maintains a hash of Subscriptions, one for each publisher it
+  # subscribes to. The 'subscribe_to' method instantiates each new Subscription in turn and executes
+  # its block against against the Subscriber in order to define handlers for each publisher event
+  # of interest. Any other method invoked within a handler is delegated to the client, i.e. the
+  # fragment subclass that the subscriber is reponsible for.
+  class Subscriber
+    attr_reader :client, :subscriptions
+
+    def initialize(client)
+      @client = client
+      @subscriptions = Hash.new do |h, key|
+        if Object.const_defined?(key) and (publisher = key.constantize) < ActiveRecord::Base
+          h[key] = Subscription.new(publisher, self)
+        else
+          nil
+        end
+      end
+    end
+
+    def subscribe_to(publisher, block)
+      if subscriptions[publisher.name]
+        instance_exec(&block)
+      end
+    end
+
+    def method_missing(method, *args)
+      @client.send(method, *args)
+    end
+  end
+
+end

data/lib/fragmentary/subscription.rb

@@ -0,0 +1,85 @@
+module Fragmentary
+
+  class Subscription
+
+    class Proxy
+
+      # Allow only one proxy per publisher; the proxy is responsible for subscribing
+      # to the publisher on behalf of individual subscriptions and calling handlers
+      # on each of them whenever the publisher broadcasts.
+      @@all = Hash.new do |h, key|
+        h[key] = Proxy.new(:publisher => key.constantize)
+      end
+
+      attr_reader :publisher
+
+      def self.fetch(key)
+        @@all[key]
+      end
+
+      def register(subscription)
+        subscriptions << subscription if subscription.is_a? Subscription
+      end
+
+      ['create', 'update', 'destroy'].each do |event|
+        class_eval <<-HEREDOC
+          def after_#{event}(record)
+            subscriptions.each do |subscription|
+              subscription.after_#{event}(record)
+            end
+          end
+        HEREDOC
+      end
+
+      private
+      def initialize(publisher:)
+        @publisher = publisher
+        @publisher.subscribe(self)
+      end
+
+      def subscriptions
+        @subscriptions ||= Set.new
+      end
+
+    end
+
+    include ActiveSupport::Callbacks
+    define_callbacks :after_destroy
+
+    attr_reader :subscriber
+    attr_accessor :record
+
+    def initialize(publisher, subscriber)
+      @subscriber = subscriber
+      Proxy.fetch(publisher.name).register(self)
+    end
+
+    def after_create(record)
+      call_method(:"create_#{record.class.model_name.param_key}_successful", record)
+    end
+
+    def after_update(record)
+      call_method(:"update_#{record.class.model_name.param_key}_successful", record)
+    end
+
+    def after_destroy(record)
+      # An ActiveSupport::Callbacks :after_destroy callback is set on the eigenclass of each individual
+      # subscription in Fragment.set_record_type in order to clean up fragments whose AR records are destroyed.
+      run_callbacks :after_destroy do
+        @record = record
+        call_method(:"destroy_#{record.class.model_name.param_key}_successful", record)
+      end
+    end
+
+    private
+    def call_method(method, record)
+      Rails.logger.info "***** Calling #{method.inspect} on #{subscriber.client.name} with record #{record.class.name} #{record.id}"
+      start = Time.now
+      subscriber.public_send(method, record) if subscriber.respond_to? method
+      finish = Time.now
+      Rails.logger.info "***** #{method.inspect} duration: #{(finish - start) * 1000}ms\n\n"
+    end
+
+  end
+
+end