Patch #44660 » 02_settings_tabs.patch
| app/helpers/groups_helper.rb | ||
|---|---|---|
|
tabs << {:name => 'general', :partial => 'groups/general', :label => :label_general}
|
||
|
tabs << {:name => 'users', :partial => 'groups/users', :label => :label_user_plural} if group.givable?
|
||
|
tabs << {:name => 'memberships', :partial => 'groups/memberships', :label => :label_project_plural}
|
||
|
tabs
|
||
|
Redmine::Tabs.add_to(:group, tabs, :group => group)
|
||
|
end
|
||
|
def render_principals_for_new_group_users(group, limit=100)
|
||
| app/helpers/issues_helper.rb | ||
|---|---|---|
|
"'#{issue_path(@issue, :tab => 'changesets')}')"
|
||
|
}
|
||
|
end
|
||
|
tabs
|
||
|
Redmine::Tabs.add_to(:issue_history, tabs, :issue => @issue)
|
||
|
end
|
||
|
def issue_history_default_tab
|
||
| app/helpers/projects_helper.rb | ||
|---|---|---|
|
{:name => 'activities', :action => :manage_project_activities,
|
||
|
:partial => 'projects/settings/activities', :label => :label_time_tracking}
|
||
|
]
|
||
|
# A plugin tab without a :permission needs the one of the project tab
|
||
|
tabs = Redmine::Tabs.add_to(:project_settings, tabs, :project => @project).each {|tab| tab[:action] ||= :edit_project}
|
||
|
tabs.
|
||
|
select {|tab| User.current.allowed_to?(tab[:action], @project)}.
|
||
|
select {|tab| tab[:module].nil? || @project.module_enabled?(tab[:module])}
|
||
| app/helpers/settings_helper.rb | ||
|---|---|---|
|
{:name => 'repositories', :partial => 'settings/repositories',
|
||
|
:label => :label_repository_plural}
|
||
|
]
|
||
|
Redmine::Tabs.add_to(:administration_settings, tabs)
|
||
|
end
|
||
|
def render_settings_error(errors)
|
||
| app/helpers/users_helper.rb | ||
|---|---|---|
|
if Group.givable.any?
|
||
|
tabs.insert 1, {:name => 'groups', :partial => 'users/groups', :label => :label_group_plural}
|
||
|
end
|
||
|
tabs
|
||
|
Redmine::Tabs.add_to(:user, tabs, :user => @user)
|
||
|
end
|
||
|
end
|
||
| lib/redmine/plugin.rb | ||
|---|---|---|
|
Redmine::MenuManager.map(menu).delete(item)
|
||
|
end
|
||
|
# Adds a tab to a tabbed settings page (see Redmine::Tabs for the pages and options).
|
||
|
# settings_tab :user, :a_tab, :partial => 'a_plugin/user_tab', :after => :general
|
||
|
def settings_tab(page, name, options={})
|
||
|
Redmine::Tabs.register(page, name, options)
|
||
|
end
|
||
|
# Adds a tab to the project settings. Without a :permission the tab needs
|
||
|
# :edit_project, as the project tab does.
|
||
|
# project_settings_tab :a_tab, :label => :label_a_tab, :partial => 'a_plugin/settings',
|
||
|
# :permission => :manage_a_plugin, :after => :members
|
||
|
def project_settings_tab(name, options={})
|
||
|
settings_tab(:project_settings, name, options)
|
||
|
end
|
||
|
# Adds a tab to the administration settings.
|
||
|
def administration_settings_tab(name, options={})
|
||
|
settings_tab(:administration_settings, name, options)
|
||
|
end
|
||
|
# Adds a tab to the user edit page.
|
||
|
def user_settings_tab(name, options={})
|
||
|
settings_tab(:user, name, options)
|
||
|
end
|
||
|
# Adds a tab to the group edit page.
|
||
|
def group_settings_tab(name, options={})
|
||
|
settings_tab(:group, name, options)
|
||
|
end
|
||
|
# Adds a tab to the history of an issue.
|
||
|
def issue_history_tab(name, options={})
|
||
|
settings_tab(:issue_history, name, options)
|
||
|
end
|
||
|
# Defines a permission called +name+ for the given +actions+.
|
||
|
#
|
||
|
# The +actions+ argument is a hash with controllers as keys and actions as values (a single value or an array):
|
||
| lib/redmine/tabs.rb | ||
|---|---|---|
|
# frozen_string_literal: true
|
||
|
# Redmine - project management software
|
||
|
# Copyright (C) 2006- 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
|
||
|
# Registry of the tabs that plugins add to the tabbed settings pages, so that a
|
||
|
# plugin does not have to override the helper that builds the list of tabs.
|
||
|
#
|
||
|
# Pages:
|
||
|
# * :project_settings - project settings (ProjectsHelper#project_settings_tabs)
|
||
|
# * :administration_settings - administration settings (SettingsHelper#administration_settings_tabs)
|
||
|
# * :user - user edit page (UsersHelper#user_settings_tabs)
|
||
|
# * :group - group edit page (GroupsHelper#group_settings_tabs)
|
||
|
# * :issue_history - the tabs of an issue's history (IssuesHelper#issue_history_tabs);
|
||
|
# a tab given :remote => true and an :onclick loads its content as core's tabs do
|
||
|
#
|
||
|
# Options:
|
||
|
# * :partial - the partial that renders the tab (required, except for a :remote tab)
|
||
|
# * :label - the label of the tab, a symbol for l() or a string (default: :label_<name>)
|
||
|
# * :permission - project settings only: the permission the user needs in the project
|
||
|
# * :module - project settings only: the project module that must be enabled
|
||
|
# * :if - a Proc that receives the context of the page (a Hash with :project, :user or
|
||
|
# :group) and returns false to hide the tab
|
||
|
# * :url - extra url params for the tab
|
||
|
# * :remote, :onclick - issue history only: a tab whose content is loaded on click
|
||
|
# * :after, :before - the name of the tab to place the tab after or before (appended
|
||
|
# to the list by default)
|
||
|
#
|
||
|
# Example, in a plugin's init.rb:
|
||
|
# Redmine::Plugin.register :a_plugin do
|
||
|
# project_settings_tab :a_tab, :label => :label_a_tab,
|
||
|
# :partial => 'a_plugin/settings', :permission => :manage_a_plugin, :after => :members
|
||
|
# end
|
||
|
module Tabs
|
||
|
PAGES = [:project_settings, :administration_settings, :user, :group, :issue_history].freeze
|
||
|
@registered = Hash.new {|h, k| h[k] = []}
|
||
|
class << self
|
||
|
def register(page, name, options={})
|
||
|
page = page.to_sym
|
||
|
raise ArgumentError, "Unknown tabs page '#{page}'" unless PAGES.include?(page)
|
||
|
if options[:partial].blank? && !options[:remote]
|
||
|
raise ArgumentError, "Missing :partial for tab '#{name}'"
|
||
|
end
|
||
|
if options[:if] && !options[:if].respond_to?(:call)
|
||
|
raise ArgumentError, "Invalid option :if for tab '#{name}'"
|
||
|
end
|
||
|
@registered[page].reject! {|tab| tab[:name] == name.to_s}
|
||
|
@registered[page] << options.merge(:name => name.to_s)
|
||
|
end
|
||
|
# Returns the tabs registered for +page+
|
||
|
def registered(page)
|
||
|
@registered[page.to_sym].dup
|
||
|
end
|
||
|
# Removes the registered tabs (all of them or those of +page+)
|
||
|
def clear(page=nil)
|
||
|
page ? @registered.delete(page.to_sym) : @registered.clear
|
||
|
end
|
||
|
# Returns +tabs+ (core's tabs, an Array of Hash) with the tabs registered for
|
||
|
# +page+ added at their place. +context+ is given to the :if option.
|
||
|
def add_to(page, tabs, context={})
|
||
|
tabs = tabs.dup
|
||
|
registered(page).each do |options|
|
||
|
next if options[:if] && !options[:if].call(context)
|
||
|
tab = {:name => options[:name], :label => options[:label] || :"label_#{options[:name]}"}
|
||
|
tab[:partial] = options[:partial] if options[:partial]
|
||
|
tab[:action] = options[:permission] if options[:permission]
|
||
|
tab[:module] = options[:module] if options[:module]
|
||
|
tab[:url] = options[:url] if options[:url]
|
||
|
tab[:remote] = options[:remote] if options.key?(:remote)
|
||
|
tab[:onclick] = options[:onclick] if options[:onclick]
|
||
|
insert(tabs, tab, options)
|
||
|
end
|
||
|
tabs
|
||
|
end
|
||
|
private
|
||
|
def insert(tabs, tab, options)
|
||
|
anchor = options[:after] || options[:before]
|
||
|
index = anchor && tabs.index {|t| t[:name].to_s == anchor.to_s}
|
||
|
if index.nil?
|
||
|
tabs << tab
|
||
|
elsif options[:after]
|
||
|
tabs.insert(index + 1, tab)
|
||
|
else
|
||
|
tabs.insert(index, tab)
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
| test/integration/lib/redmine/view_hooks_test.rb | ||
|---|---|---|
|
require_relative '../../../test_helper'
|
||
|
# The hooks that let plugins add to pages without overriding core views or
|
||
|
# helpers: each one is called on its page, and what a plugin adds through them
|
||
|
# leaves the page's HTML as valid as it was.
|
||
|
# The hooks and registries that let plugins add to pages without overriding
|
||
|
# core views or helpers: each one is called on its page, and what a plugin adds
|
||
|
# through them leaves the page's HTML as valid as it was.
|
||
|
class ViewHooksTest < Redmine::IntegrationTest
|
||
|
# The pages and the hooks each one must call
|
||
|
PAGES = {
|
||
| ... | ... | |
|
def teardown
|
||
|
Redmine::Hook.clear_listeners
|
||
|
Redmine::Tabs.clear
|
||
|
end
|
||
|
def html_errors
|
||
| ... | ... | |
|
assert_select 'h2>a+img.gravatar'
|
||
|
assert_select 'h2 + span.hook-view_layouts_base_title_after'
|
||
|
end
|
||
|
def test_registered_tabs_should_be_shown
|
||
|
# The label is a locale key, as for core's tabs
|
||
|
Redmine::Tabs.register :project_settings, :sample, :partial => 'common/preview', :label => :label_preview, :after => :members
|
||
|
Redmine::Tabs.register :user, :sample, :partial => 'common/preview', :label => :label_preview
|
||
|
Redmine::Tabs.register :group, :sample, :partial => 'common/preview', :label => :label_preview
|
||
|
Redmine::Tabs.register :administration_settings, :sample, :partial => 'common/preview', :label => :label_preview
|
||
|
Redmine::Tabs.register :issue_history, :sample, :remote => true, :label => :label_preview, :onclick => 'return false;'
|
||
|
['/projects/ecookbook/settings', '/users/2/edit', '/groups/10/edit', '/settings', '/issues/1'].each do |path|
|
||
|
get path
|
||
|
assert_response :success, path
|
||
|
assert_select 'div.tabs a#tab-sample', {:text => I18n.t(:label_preview)}, "The tab is not on #{path}"
|
||
|
end
|
||
|
end
|
||
|
def test_project_settings_tab_should_require_its_permission
|
||
|
Redmine::Tabs.register :project_settings, :sample, :partial => 'common/preview', :permission => :manage_sample
|
||
|
get '/projects/ecookbook/settings'
|
||
|
assert_select 'a#tab-sample', 0
|
||
|
end
|
||
|
end
|
||
| test/unit/lib/redmine/tabs_test.rb | ||
|---|---|---|
|
# frozen_string_literal: true
|
||
|
# Redmine - project management software
|
||
|
# Copyright (C) 2006- 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_relative '../../../test_helper'
|
||
|
class Redmine::TabsTest < ActiveSupport::TestCase
|
||
|
def setup
|
||
|
Redmine::Tabs.clear
|
||
|
end
|
||
|
def teardown
|
||
|
Redmine::Tabs.clear
|
||
|
end
|
||
|
def core_tabs
|
||
|
[{:name => 'general', :partial => 'x/general'}, {:name => 'members', :partial => 'x/members'}]
|
||
|
end
|
||
|
def test_add_to_should_append_a_registered_tab
|
||
|
Redmine::Tabs.register :project_settings, :foo, :partial => 'foo/settings'
|
||
|
tabs = Redmine::Tabs.add_to(:project_settings, core_tabs)
|
||
|
assert_equal %w(general members foo), tabs.pluck(:name)
|
||
|
assert_equal({:name => 'foo', :partial => 'foo/settings', :label => :label_foo}, tabs.last)
|
||
|
end
|
||
|
def test_add_to_should_not_change_the_given_tabs
|
||
|
Redmine::Tabs.register :project_settings, :foo, :partial => 'foo/settings'
|
||
|
tabs = core_tabs
|
||
|
Redmine::Tabs.add_to(:project_settings, tabs)
|
||
|
assert_equal 2, tabs.size
|
||
|
end
|
||
|
def test_add_to_should_place_a_tab_after_or_before_another
|
||
|
Redmine::Tabs.register :user, :after_general, :partial => 'a', :after => :general
|
||
|
Redmine::Tabs.register :user, :before_general, :partial => 'b', :before => 'general'
|
||
|
tabs = Redmine::Tabs.add_to(:user, core_tabs)
|
||
|
assert_equal %w(before_general general after_general members), tabs.pluck(:name)
|
||
|
end
|
||
|
def test_add_to_should_append_a_tab_placed_after_an_unknown_tab
|
||
|
Redmine::Tabs.register :group, :foo, :partial => 'foo', :after => :unknown
|
||
|
assert_equal %w(general members foo), Redmine::Tabs.add_to(:group, core_tabs).pluck(:name)
|
||
|
end
|
||
|
def test_add_to_should_map_permission_and_module_to_the_keys_core_filters_on
|
||
|
Redmine::Tabs.register :project_settings, :foo, :partial => 'foo',
|
||
|
:permission => :manage_foo, :module => :foo_module, :label => 'Foo'
|
||
|
tab = Redmine::Tabs.add_to(:project_settings, []).first
|
||
|
assert_equal :manage_foo, tab[:action]
|
||
|
assert_equal :foo_module, tab[:module]
|
||
|
assert_equal 'Foo', tab[:label]
|
||
|
end
|
||
|
def test_add_to_should_skip_a_tab_whose_condition_is_false
|
||
|
Redmine::Tabs.register :group, :foo, :partial => 'foo', :if => Proc.new {|context| context[:group].nil?}
|
||
|
assert_equal 1, Redmine::Tabs.add_to(:group, []).size
|
||
|
assert_equal 0, Redmine::Tabs.add_to(:group, [], :group => Group.new).size
|
||
|
end
|
||
|
def test_register_should_replace_a_tab_with_the_same_name
|
||
|
Redmine::Tabs.register :user, :foo, :partial => 'one'
|
||
|
Redmine::Tabs.register :user, :foo, :partial => 'two'
|
||
|
assert_equal ['two'], Redmine::Tabs.registered(:user).pluck(:partial)
|
||
|
end
|
||
|
def test_register_should_refuse_an_unknown_page_or_a_missing_partial
|
||
|
assert_raise(ArgumentError) {Redmine::Tabs.register :unknown_page, :foo, :partial => 'foo'}
|
||
|
assert_raise(ArgumentError) {Redmine::Tabs.register :user, :foo}
|
||
|
assert_raise(ArgumentError) {Redmine::Tabs.register :user, :foo, :partial => 'foo', :if => true}
|
||
|
end
|
||
|
def test_plugin_should_register_tabs
|
||
|
Redmine::Plugin.register :tabs_test_plugin do
|
||
|
directory Rails.root.join('test/fixtures/plugins/foo_plugin').to_s
|
||
|
project_settings_tab :foo, :partial => 'foo/project'
|
||
|
administration_settings_tab :foo, :partial => 'foo/admin'
|
||
|
user_settings_tab :foo, :partial => 'foo/user'
|
||
|
group_settings_tab :foo, :partial => 'foo/group'
|
||
|
end
|
||
|
assert_equal ['foo/project'], Redmine::Tabs.registered(:project_settings).pluck(:partial)
|
||
|
assert_equal ['foo/admin'], Redmine::Tabs.registered(:administration_settings).pluck(:partial)
|
||
|
assert_equal ['foo/user'], Redmine::Tabs.registered(:user).pluck(:partial)
|
||
|
assert_equal ['foo/group'], Redmine::Tabs.registered(:group).pluck(:partial)
|
||
|
ensure
|
||
|
Redmine::Plugin.unregister(:tabs_test_plugin)
|
||
|
end
|
||
|
end
|
||