jro_apps/redmine Commit - r9609:fc13aef5bb5b

Merged r9785 from trunk....

Jean-Philippe Lang -

r9609:fc13aef5bb5b

parent child

Context file:

r9609:fc13aef5bb5b

Collapse all files

lib/redmine/hook.rb +10 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module Hook
                 @@listener_classes = []
                 @@listeners = nil
                 @@hook_listeners = {}
                 class << self
                   # Adds a listener class.
                   # Automatically called when a class inherits from Redmine::Hook::Listener.
                   def add_listener(klass)
                     raise "Hooks must include Singleton module." unless klass.included_modules.include?(Singleton)
                     @@listener_classes << klass
                     clear_listeners_instances
                   end
                   # Returns all the listerners instances.
                   def listeners
                     @@listeners ||= @@listener_classes.collect {|listener| listener.instance}
                   end
                   # Returns the listeners instances for the given hook.
                   def hook_listeners(hook)
                     @@hook_listeners[hook] ||= listeners.select {|listener| listener.respond_to?(hook)}
                   end
                   # Clears all the listeners.
                   def clear_listeners
                     @@listener_classes = []
                     clear_listeners_instances
                   end
                   # Clears all the listeners instances.
                   def clear_listeners_instances
                     @@listeners = nil
                     @@hook_listeners = {}
                   end
                   # Calls a hook.
                   # Returns the listeners response.
                   def call_hook(hook, context={})
                     [].tap do |response|
                       hls = hook_listeners(hook)
                       if hls.any?
                         hls.each {|listener| response << listener.send(hook, context)}
                       end
                     end
                   end
                 end
                 # Base class for hook listeners.
                 class Listener
                   include Singleton
                   include Redmine::I18n
                   # Registers the listener
                   def self.inherited(child)
                     Redmine::Hook.add_listener(child)
                     super
                   end
                 end
                 # Listener class used for views hooks.
                 # Listeners that inherit this class will include various helpers by default.
                 class ViewListener < Listener
                   include ERB::Util
                   include ActionView::Helpers::TagHelper
                   include ActionView::Helpers::FormHelper
                   include ActionView::Helpers::FormTagHelper
                   include ActionView::Helpers::FormOptionsHelper
                   include ActionView::Helpers::JavaScriptHelper
                   include ActionView::Helpers::NumberHelper
                   include ActionView::Helpers::UrlHelper
                   include ActionView::Helpers::AssetTagHelper
                   include ActionView::Helpers::TextHelper
                   include Rails.application.routes.url_helpers
                   include ApplicationHelper
                   # Default to creating links using only the path.  Subclasses can
                   # change this default as needed
                   def self.default_url_options
                     {:only_path => true }
                   end
                   # Helper method to directly render a partial using the context:
                   #
                   #   class MyHook < Redmine::Hook::ViewListener
                   #     render_on :view_issues_show_details_bottom, :partial => "show_more_data"
                   #   end
                   #
                   def self.render_on(hook, options={})
                     define_method hook do |context|
-                      context[:controller].send(:render_to_string, {:locals => context}.merge(options))
+                      if context[:hook_caller].respond_to?(:render)
+                        context[:hook_caller].send(:render, {:locals => context}.merge(options))
+                      elsif context[:controller].is_a?(ActionController::Base)
+                        context[:controller].send(:render_to_string, {:locals => context}.merge(options))
+                      else
+                        raise "Cannot render #{self.name} hook from #{context[:hook_caller].class.name}"
+                      end
                     end
                   end
                   def controller
                     nil
                   end
                   def config
                     ActionController::Base.config
                   end
                 end
                 # Helper module included in ApplicationHelper and ActionController so that
                 # hooks can be called in views like this:
                 #
                 #   <%= call_hook(:some_hook) %>
                 #   <%= call_hook(:another_hook, :foo => 'bar') %>
                 #
                 # Or in controllers like:
                 #   call_hook(:some_hook)
                 #   call_hook(:another_hook, :foo => 'bar')
                 #
                 # Hooks added to views will be concatenated into a string. Hooks added to
                 # controllers will return an array of results.
                 #
                 # Several objects are automatically added to the call context:
                 #
                 # * project => current project
                 # * request => Request instance
                 # * controller => current Controller instance
+                # * hook_caller => object that called the hook
                 #
                 module Helper
                   def call_hook(hook, context={})
                     if is_a?(ActionController::Base)
-                      default_context = {:controller => self, :project => @project, :request => request}
+                      default_context = {:controller => self, :project => @project, :request => request, :hook_caller => self}
                       Redmine::Hook.call_hook(hook, default_context.merge(context))
                     else
-                      default_context = { :project => @project }
+                      default_context = { :project => @project, :hook_caller => self }
                       default_context[:controller] = controller if respond_to?(:controller)
                       default_context[:request] = request if respond_to?(:request)
                       Redmine::Hook.call_hook(hook, default_context.merge(context)).join(' ').html_safe
                     end
                   end
                 end
               end
             end
             ApplicationHelper.send(:include, Redmine::Hook::Helper)
             ActionController::Base.send(:include, Redmine::Hook::Helper)

test/integration/lib/redmine/hook_test.rb +23 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../test_helper', __FILE__)
             class MenuManagerTest < ActionController::IntegrationTest
               fixtures :users, :roles, :projects, :members, :member_roles
               # Hooks that are manually registered later
               class ProjectBasedTemplate < Redmine::Hook::ViewListener
                 def view_layouts_base_html_head(context)
                   # Adds a project stylesheet
                   stylesheet_link_tag(context[:project].identifier) if context[:project]
                 end
               end
               class SidebarContent < Redmine::Hook::ViewListener
                 def view_layouts_base_sidebar(context)
                   content_tag('p', 'Sidebar hook')
                 end
               end
+              class ContentForInsideHook < Redmine::Hook::ViewListener
+                render_on :view_welcome_index_left, :inline => <<-VIEW
+            <% content_for :header_tags do %>
+              <%= javascript_include_tag 'test_plugin.js', :plugin => 'test_plugin' %>
+              <%= stylesheet_link_tag 'test_plugin.css', :plugin => 'test_plugin' %>
+            <% end %>
+            <p>ContentForInsideHook content</p>
+            VIEW
+              end
               def setup
                 Redmine::Hook.clear_listeners
               end
               def teardown
                 Redmine::Hook.clear_listeners
               end
               def test_html_head_hook_response
                 Redmine::Hook.add_listener(ProjectBasedTemplate)
                 get '/projects/ecookbook'
                 assert_tag :tag => 'link', :attributes => {:href => '/stylesheets/ecookbook.css'},
                                            :parent => {:tag => 'head'}
               end
               def test_empty_sidebar_should_be_hidden
                 get '/'
                 assert_select 'div#main.nosidebar'
               end
               def test_sidebar_with_hook_content_should_not_be_hidden
                 Redmine::Hook.add_listener(SidebarContent)
                 get '/'
                 assert_select 'div#sidebar p', :text => 'Sidebar hook'
                 assert_select 'div#main'
                 assert_select 'div#main.nosidebar', 0
               end
+              def test_hook_with_content_for_should_append_content
+                Redmine::Hook.add_listener(ContentForInsideHook)
+                get '/'
+                assert_response :success
+                assert_select 'p', :text => 'ContentForInsideHook content'
+                assert_select 'head' do
+                  assert_select 'script[src=/plugin_assets/test_plugin/javascripts/test_plugin.js]'
+                  assert_select 'link[href=/plugin_assets/test_plugin/stylesheets/test_plugin.css]'
+                end
+              end
             end

test/unit/lib/redmine/hook_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../test_helper', __FILE__)
             class Redmine::Hook::ManagerTest < ActionView::TestCase
               fixtures :issues
               # Some hooks that are manually registered in these tests
               class TestHook < Redmine::Hook::ViewListener; end
               class TestHook1 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 1 listener.'
                 end
               end
               class TestHook2 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 2 listener.'
                 end
               end
               class TestHook3 < TestHook
                 def view_layouts_base_html_head(context)
                   "Context keys: #{context.keys.collect(&:to_s).sort.join(', ')}."
                 end
               end
               class TestLinkToHook < TestHook
                 def view_layouts_base_html_head(context)
                   link_to('Issues', :controller => 'issues')
                 end
               end
               class TestHookHelperController < ActionController::Base
                 include Redmine::Hook::Helper
               end
               class TestHookHelperView < ActionView::Base
                 include Redmine::Hook::Helper
               end
               Redmine::Hook.clear_listeners
               def setup
                 @hook_module = Redmine::Hook
               end
               def teardown
                 @hook_module.clear_listeners
               end
               def test_clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 2, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_add_listener
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 assert_equal 1, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_call_hook
                 @hook_module.add_listener(TestHook1)
                 assert_equal ['Test hook 1 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_with_context
                 @hook_module.add_listener(TestHook3)
-                assert_equal ['Context keys: bar, controller, foo, project, request.'],
+                assert_equal ['Context keys: bar, controller, foo, hook_caller, project, request.'],
                              hook_helper.call_hook(:view_layouts_base_html_head, :foo => 1, :bar => 'a')
               end
               def test_call_hook_with_multiple_listeners
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal ['Test hook 1 listener.', 'Test hook 2 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook default_url
               def test_call_hook_default_url_options
                 @hook_module.add_listener(TestLinkToHook)
                 assert_equal ['<a href="/issues">Issues</a>'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook
               def test_call_hook_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_view_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_should_join_responses_with_a_space
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 'Test hook 1 listener. Test hook 2 listener.',
                              view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_should_not_change_the_default_url_for_email_notifications
                 issue = Issue.find(1)
                 ActionMailer::Base.deliveries.clear
                 Mailer.issue_add(issue).deliver
                 mail = ActionMailer::Base.deliveries.last
                 @hook_module.add_listener(TestLinkToHook)
                 hook_helper.call_hook(:view_layouts_base_html_head)
                 ActionMailer::Base.deliveries.clear
                 Mailer.issue_add(issue).deliver
                 mail2 = ActionMailer::Base.deliveries.last
                 assert_equal mail_body(mail), mail_body(mail2)
               end
               def hook_helper
                 @hook_helper ||= TestHookHelperController.new
               end
               def view_hook_helper
                 @view_hook_helper ||= TestHookHelperView.new(Rails.root.to_s + '/app/views')
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages