Merge branch 'ffcrm' of git://github.com/crossroads/fat_free_crm into crossroads/ffcrm

Author: Mike Dvorkin

lib/fat_free_crm/callback.rb

@@ -19,19 +19,23 @@ module FatFreeCRM
   module Callback
     @@classes   = []  # Classes that inherit from FatFreeCRM::Callback::Base.
     @@responder = {}  # Class instances that respond to (i.e. implement) hook methods.
+                      # Also includes class instances that implement a
+                      # set of view hook operations (insert_after, replace, etc).
 
     # Adds a class inherited from from FatFreeCRM::Callback::Base.
     #--------------------------------------------------------------------------
     def self.add(klass)
       @@classes << klass
     end
 
+    #                     [Controller] and [Legacy View] Hooks
+    # -----------------------------------------------------------------------------
+
     # Finds class instance that responds to given method.
     #------------------------------------------------------------------------------
     def self.responder(method)
       @@responder[method] ||= @@classes.map { |klass| klass.instance }.select { |instance| instance.respond_to?(method) }
     end
-
     # Invokes the hook named :method and captures its output. The hook returns:
     # - empty array if no hook with this name was detected.
     # - array with single item returned by the hook.
@@ -43,14 +47,58 @@ def self.hook(method, caller, context = {})
       end
     end
 
+
+    #                             [View] Hooks
+    # -----------------------------------------------------------------------------
+
+    # Find class instances that contain operations for the given view hook.
+    #------------------------------------------------------------------------------
+    def self.view_responder(method)
+      @@responder[method] ||= @@classes.map { |klass| klass.instance }.select { |instance| instance.class.view_hooks[method] }
+    end
+    # Invokes the view hook Proc stored under :hook and captures its output.
+    # => Instead of defining methods on the class, view hooks are
+    #    stored as Procs in a hash. This allows the same hook to be manipulated in
+    #    multiple ways from within a single Callback subclass.
+    # The hook returns:
+    # - empty hash if no hook with this name was detected.
+    # - a hash of arrays containing Procs and positions to insert content.
+    #--------------------------------------------------------------------------
+    def self.view_hook(hook, caller, context = {})
+      view_responder(hook).inject(Hash.new([])) do |response, instance|
+        # Process each operation within each view hook, storing the data in a hash.
+        instance.class.view_hooks[hook].each do |op|
+          response[op[:position]] += [op[:proc].call(caller, context)]
+        end
+        response
+      end
+    end
+
     #--------------------------------------------------------------------------
     class Base
       include Singleton
-
       def self.inherited(child)
         FatFreeCRM::Callback.add(child)
+        # Positioning hash to determine where content is placed.
+        child.class_eval do
+          @view_hooks = Hash.new([])
+        end
         super
       end
+
+      class << self
+        attr_accessor :view_hooks
+
+        def add_view_hook(hook, proc, position)
+          @view_hooks[hook] += [{:proc => proc,
+                                 :position => position}]
+        end
+
+        def insert_before(hook, &block); add_view_hook(hook, block,        :before);  end
+        def insert_after(hook, &block);  add_view_hook(hook, block,        :after);   end
+        def replace(hook, &block);       add_view_hook(hook, block,        :replace); end
+        def remove(hook);                add_view_hook(hook, Proc.new{""}, :replace); end
+      end
 
     end # class Base
 
@@ -59,9 +107,32 @@ def self.inherited(child)
     # data otherwise.
     #--------------------------------------------------------------------------
     module Helper
-      def hook(method, caller, context = {})
-        data = FatFreeCRM::Callback.hook(method, caller, context)
-        caller.class.to_s.start_with?("ActionView") ? data.join : data
+      def hook(method, caller, context = {}, &block)
+        is_view_hook = caller.class.to_s.start_with?("ActionView")
+
+        # If a block was given, hooks are able to replace, append or prepend view content.
+        if block_given? and is_view_hook
+          hooks = FatFreeCRM::Callback.view_hook(method, caller, context)
+          # Add content to the view in the following order:
+          # -- before
+          # -- replace || original block
+          # -- after
+          view_data = []
+          hooks[:before].each{|data| view_data << data }
+          # Only render the original view block if there are no pending :replace operations
+          if hooks[:replace].empty?
+            view_data << capture(&block)
+          else
+            hooks[:replace].each{|data| view_data << data }
+          end
+          hooks[:after].each{|data| view_data << data }
+          view_data.join
+
+        else
+          # Hooks called without blocks are either controller or legacy view hooks
+          data = FatFreeCRM::Callback.hook(method, caller, context)
+          is_view_hook ? data.join : data
+        end
       end
     end # module Helper
 

spec/lib/fat_free_crm/callback_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module CallbackSpecHelper
+  class TestCallback < FatFreeCRM::Callback::Base
+    # --------------------------------------------
+    insert_before :test_before do |view, context|
+      "BEFORE-"
+    end
+    # --------------------------------------------
+    insert_after :test_after do |view, context|
+      "-AFTER"
+    end
+    # --------------------------------------------
+    replace :test_replace do |view, context|
+      "REPLACE"
+    end
+    # --------------------------------------------
+    remove :test_remove
+    # --------------------------------------------
+    insert_before :test_before_and_after do |view, context|
+      "BEFORE-"
+    end
+    insert_after :test_before_and_after do |view, context|
+      "-AFTER"
+    end
+    # --------------------------------------------
+    insert_before :test_before_and_after_with_replace do |view, context|
+      "BEFORE-"
+    end
+    insert_after :test_before_and_after_with_replace do |view, context|
+      "-AFTER"
+    end
+    replace :test_before_and_after_with_replace do |view, context|
+      "REPLACED"
+    end
+    # --------------------------------------------
+    def test_legacy(view, context={})
+      "LEGACY"
+    end
+  end
+
+  def test_hook(position)
+    Haml::Engine.new(%Q^
+= hook("test_#{position}".to_sym, ActionView::Base.new) do
+  BLOCK^).render.gsub("\n",'')
+  end
+  
+end
+
+include FatFreeCRM::Callback::Helper
+include ActionView::Helpers::CaptureHelper
+include CallbackSpecHelper
+
+describe FatFreeCRM::Callback do 
+  it "should insert content before the block" do
+    test_hook(:before).should == "BEFORE-BLOCK"
+  end
+  
+  it "should insert content after the block" do
+    test_hook(:after).should == "BLOCK-AFTER"
+  end
+  
+  it "should replace the content of the block" do
+    test_hook(:replace).should == "REPLACE"
+  end
+  
+  it "should remove the block" do
+    test_hook(:remove).should == ""
+  end
+
+  it "should be able to insert content before and after the block" do
+    test_hook(:before_and_after).should == "BEFORE-BLOCK-AFTER"
+  end
+
+  it "should be able to insert content before and after a replaced block" do
+    test_hook(:before_and_after_with_replace).should == "BEFORE-REPLACED-AFTER"
+  end
+  
+  it "should still work for legacy hooks" do
+    Haml::Engine.new("= hook(:test_legacy, ActionView::Base.new)").render.
+      gsub("\n",'').should == "LEGACY"
+  end
+end