jro_apps/redmine Commit - r13578:d347fd4d39ff

link_to in Redmine::Hook::ViewListener omits relative url root (#19024)....

Jean-Philippe Lang -

r13578:d347fd4d39ff

parent child

Context file:

r13578:d347fd4d39ff

Collapse all files

lib/redmine/hook.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 listener instances.
                   def listeners
                     @@listeners ||= @@listener_classes.collect {|listener| listener.instance}
                   end
                   # Returns the listener 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 }
+                    {:only_path => true, :script_name => Redmine::Utils.relative_url_root}
                   end
                   # Helper method to directly render using the context,
                   # render_options must be valid #render options.
                   #
                   #   class MyHook < Redmine::Hook::ViewListener
                   #     render_on :view_issues_show_details_bottom, :partial => "show_more_data"
                   #   end
                   #
                   #   class MultipleHook < Redmine::Hook::ViewListener
                   #     render_on :view_issues_show_details_bottom,
                   #       {:partial => "show_more_data"},
                   #       {:partial => "show_even_more_data"}
                   #   end
                   #
                   def self.render_on(hook, *render_options)
                     define_method hook do |context|
                       render_options.map do |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
                   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, :hook_caller => self}
                       Redmine::Hook.call_hook(hook, default_context.merge(context))
                     else
                       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/unit/lib/redmine/hook_test.rb +9 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 :projects, :users, :members, :member_roles, :roles,
                        :groups_users,
                        :email_addresses,
                        :trackers, :projects_trackers,
                        :enabled_modules,
                        :versions,
                        :issue_statuses, :issue_categories, :issue_relations,
                        :enumerations,
                        :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
                 @hook_module.clear_listeners
               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, 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
+              def test_view_hook_should_generate_links_with_relative_url_root
+                Redmine::Utils.relative_url_root = '/foo'
+                @hook_module.add_listener(TestLinkToHook)
+                assert_equal ['<a href="/foo/issues">Issues</a>'], hook_helper.call_hook(:view_layouts_base_html_head)
+              ensure
+                Redmine::Utils.relative_url_root = ''
+              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.deliver_issue_add(issue)
                 mail = ActionMailer::Base.deliveries.last
                 @hook_module.add_listener(TestLinkToHook)
                 hook_helper.call_hook(:view_layouts_base_html_head)
                 ActionMailer::Base.deliveries.clear
                 Mailer.deliver_issue_add(issue)
                 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