jro_apps/redmine Commit - r2368:5b7a5c39a7da

Added request and controller objects to the hooks by default....

Eric Davis -

r2368:5b7a5c39a7da

parent child

Context file:

r2368:5b7a5c39a7da

Collapse all files

lib/redmine/hook.rb +52 -8

             # Redmine - project management software
             # Copyright (C) 2006-2008  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
+                include ActionController::UrlWriter
                 @@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={})
-                    response = ''
+                    returning [] do |response|
-                    hook_listeners(hook).each do |listener|
+                      hls = hook_listeners(hook)
-                      response << listener.send(hook, context).to_s
+                      if hls.any?
+                        request = context[:request]
+                        if request
+                          default_url_options[:host] ||= request.env["SERVER_NAME"]
+                          # Only set port if it's requested and isn't port 80.  Otherwise a url
+                          # like:  +http://example.com:/url+ may be generated
+                          if request.env["SERVER_PORT"] && request.env["SERVER_PORT"] != 80
+                            default_url_options[:port] ||= request.env["SERVER_PORT"]
+                          end
+                          default_url_options[:protocol] ||= request.protocol
+                        end
+                        hls.each {|listener| response << listener.send(hook, context)}
+                      end
                     end
-                    response
                   end
                 end
                 # Base class for hook listeners.
                 class Listener
                   include Singleton
                   include GLoc
                   # 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::PrototypeHelper
                   include ActionView::Helpers::NumberHelper
                   include ActionView::Helpers::UrlHelper
                   include ActionView::Helpers::AssetTagHelper
                   include ActionView::Helpers::TextHelper
                   include ActionController::UrlWriter
                   include ApplicationHelper
+                  # 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))
+                    end
+                  end
                 end
-                # Helper module included in ApplicationHelper so that hooks can be called
+                # Helper module included in ApplicationHelper and ActionControllerso that
-                # in views like this:
+                # hooks can be called in views like this:
+                #
                 #   <%= call_hook(:some_hook) %>
                 #   <%= call_hook(:another_hook, :foo => 'bar' %>
                 #
-                # Current project is automatically added to the call context.
+                # 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
+                #
                 module Helper
                   def call_hook(hook, context={})
-                    Redmine::Hook.call_hook(hook, {:project => @project}.merge(context))
+                    if is_a?(ActionController::Base)
+                      ctx = {:controller => self, :project => @project, :request => request}
+                      Redmine::Hook.call_hook(hook, ctx.merge(context))
+                    else
+                      ctx = {:controller => controller, :project => @project, :request => request}
+                      Redmine::Hook.call_hook(hook, ctx.merge(context)).join(' ')
+                    end
                   end
                 end
               end
             end
             ApplicationHelper.send(:include, Redmine::Hook::Helper)
             ActionController::Base.send(:include, Redmine::Hook::Helper)

test/unit/lib/redmine/hook_test.rb +79 -4

             # redMine - project management software
             # Copyright (C) 2006-2008  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.dirname(__FILE__) + '/../../../test_helper'
             class Redmine::Hook::ManagerTest < Test::Unit::TestCase
               # Some hooks that are manually registered in these tests
-              class TestHook < Redmine::Hook::Listener; end
+              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
               Redmine::Hook.clear_listeners
               def setup
                 @hook_module = Redmine::Hook
               end
               def teardown
                 @hook_module.clear_listeners
+                @hook_module.default_url_options = { }
               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_module.call_hook(:view_layouts_base_html_head)
+                assert_equal ['Test hook 1 listener.'], @hook_module.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_with_context
                 @hook_module.add_listener(TestHook3)
-                assert_equal 'Context keys: bar, foo.', @hook_module.call_hook(:view_layouts_base_html_head, :foo => 1, :bar => 'a')
+                assert_equal ['Context keys: bar, foo.'], @hook_module.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_module.call_hook(:view_layouts_base_html_head)
+                assert_equal ['Test hook 1 listener.', 'Test hook 2 listener.'], @hook_module.call_hook(:view_layouts_base_html_head)
+              end
+              # Context: Redmine::Hook::call_hook
+              def test_call_hook_default_url_options_set
+                request = ActionController::TestRequest.new
+                request.env = { "SERVER_NAME" => 'example.com'}
+                @hook_module.add_listener(TestLinkToHook)
+                assert_equal ['<a href="http://example.com/issues">Issues</a>'],
+                  @hook_module.call_hook(:view_layouts_base_html_head, :request => request)
+              end
+              def test_call_hook_default_url_options_set_with_no_standard_request_port
+                request = ActionController::TestRequest.new
+                request.env = { "SERVER_NAME" => 'example.com', "SERVER_PORT" => 3000}
+                @hook_module.add_listener(TestLinkToHook)
+                assert_equal ['<a href="http://example.com:3000/issues">Issues</a>'],
+                  @hook_module.call_hook(:view_layouts_base_html_head, :request => request)
+              end
+              def test_call_hook_default_url_options_set_with_ssl
+                request = ActionController::TestRequest.new
+                request.env = { "SERVER_NAME" => 'example.com', "HTTPS" => 'on'}
+                @hook_module.add_listener(TestLinkToHook)
+                assert_equal ['<a href="https://example.com/issues">Issues</a>'],
+                  @hook_module.call_hook(:view_layouts_base_html_head, :request => request)
+              end
+              def test_call_hook_default_url_options_set_with_forwarded_ssl
+                request = ActionController::TestRequest.new
+                request.env = { "SERVER_NAME" => 'example.com', "HTTP_X_FORWARDED_PROTO" => "https"}
+                @hook_module.add_listener(TestLinkToHook)
+                assert_equal ['<a href="https://example.com/issues">Issues</a>'],
+                  @hook_module.call_hook(:view_layouts_base_html_head, :request => request)
+              end
+              # Context: Redmine::Hook::Helper.call_hook
+              def test_call_hook_with_project_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_controller_with_controller_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_controller_with_request_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_view_with_project_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_view_with_controller_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_view_with_request_added_to_context
+                # TODO: Implement test
+              end
+              def test_call_hook_from_view_should_join_responses_with_a_space
+                # TODO: Implement test
               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