jro_apps/redmine Commit - r8646:1dcdba7cdcb5

Merged r8210 from trunk (#9792)....

Jean-Philippe Lang -

r8646:1dcdba7cdcb5

parent child

Context file:

r8646:1dcdba7cdcb5

Expand all files

app/helpers/account_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 AccountHelper
             end

app/helpers/admin_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 AdminHelper
               def project_status_options_for_select(selected)
                 options_for_select([[l(:label_all), ''],
                                     [l(:status_active), 1]], selected)
               end
             end

app/helpers/attachments_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 AttachmentsHelper
               # Displays view/delete links to the attachments of the given object
               # Options:
               #   :author -- author names are not displayed if set to false
               def link_to_attachments(container, options = {})
                 options.assert_valid_keys(:author)
                 if container.attachments.any?
                   options = {:deletable => container.attachments_deletable?, :author => true}.merge(options)
                   render :partial => 'attachments/links', :locals => {:attachments => container.attachments, :options => options}
                 end
               end
               def render_api_attachment(attachment, api)
                 api.attachment do
                   api.id attachment.id
                   api.filename attachment.filename
                   api.filesize attachment.filesize
                   api.content_type attachment.content_type
                   api.description attachment.description
                   api.content_url url_for(:controller => 'attachments', :action => 'download', :id => attachment, :filename => attachment.filename, :only_path => false)
                   api.author(:id => attachment.author.id, :name => attachment.author.name) if attachment.author
                   api.created_on attachment.created_on
                 end
               end
             end

app/helpers/auth_sources_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 AuthSourcesHelper
             end

app/helpers/boards_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 BoardsHelper
             end

app/helpers/calendars_helper.rb +19 0

+            # encoding: utf-8
+            #
+            # Redmine - project management software
+            # Copyright (C) 2006-2011  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 CalendarsHelper
               def link_to_previous_month(year, month, options={})
                 target_year, target_month = if month == 1
                                               [year - 1, 12]
                                             else
                                               [year, month - 1]
                                             end
                 name = if target_month == 12
                          "#{month_name(target_month)} #{target_year}"
                        else
                          "#{month_name(target_month)}"
                        end
                 # \xc2\xab(utf-8) = &#171;
                 link_to_month(("\xc2\xab " + name), target_year, target_month, options)
               end
               def link_to_next_month(year, month, options={})
                 target_year, target_month = if month == 12
                                               [year + 1, 1]
                                             else
                                               [year, month + 1]
                                             end
                 name = if target_month == 1
                          "#{month_name(target_month)} #{target_year}"
                        else
                          "#{month_name(target_month)}"
                        end
                 # \xc2\xbb(utf-8) = &#187;
                 link_to_month((name + " \xc2\xbb"), target_year, target_month, options)
               end
               def link_to_month(link_name, year, month, options={})
                 link_to_content_update(h(link_name), params.merge(:year => year, :month => month))
               end
             end

app/helpers/custom_fields_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 CustomFieldsHelper
               def custom_fields_tabs
                 tabs = [{:name => 'IssueCustomField', :partial => 'custom_fields/index', :label => :label_issue_plural},
                         {:name => 'TimeEntryCustomField', :partial => 'custom_fields/index', :label => :label_spent_time},
                         {:name => 'ProjectCustomField', :partial => 'custom_fields/index', :label => :label_project_plural},
                         {:name => 'VersionCustomField', :partial => 'custom_fields/index', :label => :label_version_plural},
                         {:name => 'UserCustomField', :partial => 'custom_fields/index', :label => :label_user_plural},
                         {:name => 'GroupCustomField', :partial => 'custom_fields/index', :label => :label_group_plural},
                         {:name => 'TimeEntryActivityCustomField', :partial => 'custom_fields/index', :label => TimeEntryActivity::OptionName},
                         {:name => 'IssuePriorityCustomField', :partial => 'custom_fields/index', :label => IssuePriority::OptionName},
                         {:name => 'DocumentCategoryCustomField', :partial => 'custom_fields/index', :label => DocumentCategory::OptionName}
                         ]
               end
               # Return custom field html tag corresponding to its format
               def custom_field_tag(name, custom_value)
                 custom_field = custom_value.custom_field
                 field_name = "#{name}[custom_field_values][#{custom_field.id}]"
                 field_id = "#{name}_custom_field_values_#{custom_field.id}"
                 field_format = Redmine::CustomFieldFormat.find_by_name(custom_field.field_format)
                 case field_format.try(:edit_as)
                 when "date"
                   text_field_tag(field_name, custom_value.value, :id => field_id, :size => 10) +
                   calendar_for(field_id)
                 when "text"
                   text_area_tag(field_name, custom_value.value, :id => field_id, :rows => 3, :style => 'width:90%')
                 when "bool"
                   hidden_field_tag(field_name, '0') + check_box_tag(field_name, '1', custom_value.true?, :id => field_id)
                 when "list"
                   blank_option = custom_field.is_required? ?
                                    (custom_field.default_value.blank? ? "<option value=\"\">--- #{l(:actionview_instancetag_blank_option)} ---</option>" : '') :
                                    '<option></option>'
                   select_tag(field_name, blank_option + options_for_select(custom_field.possible_values_options(custom_value.customized), custom_value.value), :id => field_id)
                 else
                   text_field_tag(field_name, custom_value.value, :id => field_id)
                 end
               end
               # Return custom field label tag
               def custom_field_label_tag(name, custom_value)
                 content_tag "label", h(custom_value.custom_field.name) +
             	(custom_value.custom_field.is_required? ? " <span class=\"required\">*</span>".html_safe : ""),
             	:for => "#{name}_custom_field_values_#{custom_value.custom_field.id}",
             	:class => (custom_value.errors.empty? ? nil : "error" )
               end
               # Return custom field tag with its label tag
               def custom_field_tag_with_label(name, custom_value)
                 custom_field_label_tag(name, custom_value) + custom_field_tag(name, custom_value)
               end
               def custom_field_tag_for_bulk_edit(name, custom_field, projects=nil)
                 field_name = "#{name}[custom_field_values][#{custom_field.id}]"
                 field_id = "#{name}_custom_field_values_#{custom_field.id}"
                 field_format = Redmine::CustomFieldFormat.find_by_name(custom_field.field_format)
                 case field_format.try(:edit_as)
                   when "date"
                     text_field_tag(field_name, '', :id => field_id, :size => 10) +
                     calendar_for(field_id)
                   when "text"
                     text_area_tag(field_name, '', :id => field_id, :rows => 3, :style => 'width:90%')
                   when "bool"
                     select_tag(field_name, options_for_select([[l(:label_no_change_option), ''],
                                                                [l(:general_text_yes), '1'],
                                                                [l(:general_text_no), '0']]), :id => field_id)
                   when "list"
                     select_tag(field_name, options_for_select([[l(:label_no_change_option), '']] + custom_field.possible_values_options(projects)), :id => field_id)
                   else
                     text_field_tag(field_name, '', :id => field_id)
                 end
               end
               # Return a string used to display a custom value
               def show_value(custom_value)
                 return "" unless custom_value
                 format_value(custom_value.value, custom_value.custom_field.field_format)
               end
               # Return a string used to display a custom value
               def format_value(value, field_format)
                 Redmine::CustomFieldFormat.format_value(value, field_format) # Proxy
               end
               # Return an array of custom field formats which can be used in select_tag
               def custom_field_formats_for_select(custom_field)
                 Redmine::CustomFieldFormat.as_select(custom_field.class.customized_class.name)
               end
               # Renders the custom_values in api views
               def render_api_custom_values(custom_values, api)
                 api.array :custom_fields do
                   custom_values.each do |custom_value|
                     api.custom_field :id => custom_value.custom_field_id, :name => custom_value.custom_field.name do
                       api.value custom_value.value
                     end
                   end
                 end unless custom_values.empty?
               end
             end

app/helpers/documents_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 DocumentsHelper
             end

app/helpers/enumerations_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 EnumerationsHelper
             end

app/helpers/gantt_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 GanttHelper
               def gantt_zoom_link(gantt, in_or_out)
                 case in_or_out
                 when :in
                   if gantt.zoom < 4
                     link_to_content_update l(:text_zoom_in),
                       params.merge(gantt.params.merge(:zoom => (gantt.zoom+1))),
                       :class => 'icon icon-zoom-in'
                   else
                     content_tag('span', l(:text_zoom_in), :class => 'icon icon-zoom-in').html_safe
                   end
                 when :out
                   if gantt.zoom > 1
                     link_to_content_update l(:text_zoom_out),
                       params.merge(gantt.params.merge(:zoom => (gantt.zoom-1))),
                       :class => 'icon icon-zoom-out'
                   else
                     content_tag('span', l(:text_zoom_out), :class => 'icon icon-zoom-out').html_safe
                   end
                 end
               end
             end

app/helpers/groups_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 GroupsHelper
               # Options for the new membership projects combo-box
               def options_for_membership_project_select(user, projects)
                 options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")
                 options << project_tree_options_for_select(projects) do |p|
                   {:disabled => (user.projects.include?(p))}
                 end
                 options
               end
               def group_settings_tabs
                 tabs = [{:name => 'general', :partial => 'groups/general', :label => :label_general},
                         {:name => 'users', :partial => 'groups/users', :label => :label_user_plural},
                         {:name => 'memberships', :partial => 'groups/memberships', :label => :label_project_plural}
                         ]
               end
             end

app/helpers/issue_categories_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 IssueCategoriesHelper
             end

app/helpers/issue_moves_helper.rb +2 0

+            # encoding: utf-8
+            #
             module IssueMovesHelper
             end

app/helpers/issue_relations_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 IssueRelationsHelper
               def collection_for_relation_type_select
                 values = IssueRelation::TYPES
                 values.keys.sort{|x,y| values[x][:order] <=> values[y][:order]}.collect{|k| [l(values[k][:name]), k]}
               end
             end

app/helpers/issue_statuses_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 IssueStatusesHelper
             end

app/helpers/issues_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 IssuesHelper
               include ApplicationHelper
               def issue_list(issues, &block)
                 ancestors = []
                 issues.each do |issue|
                   while (ancestors.any? && !issue.is_descendant_of?(ancestors.last))
                     ancestors.pop
                   end
                   yield issue, ancestors.size
                   ancestors << issue unless issue.leaf?
                 end
               end
               # Renders a HTML/CSS tooltip
               #
               # To use, a trigger div is needed.  This is a div with the class of "tooltip"
               # that contains this method wrapped in a span with the class of "tip"
               #
               #    <div class="tooltip"><%= link_to_issue(issue) %>
               #      <span class="tip"><%= render_issue_tooltip(issue) %></span>
               #    </div>
               #
               def render_issue_tooltip(issue)
                 @cached_label_status ||= l(:field_status)
                 @cached_label_start_date ||= l(:field_start_date)
                 @cached_label_due_date ||= l(:field_due_date)
                 @cached_label_assigned_to ||= l(:field_assigned_to)
                 @cached_label_priority ||= l(:field_priority)
                 @cached_label_project ||= l(:field_project)
                 (link_to_issue(issue) + "<br /><br />" +
                   "<strong>#{@cached_label_project}</strong>: #{link_to_project(issue.project)}<br />" +
                   "<strong>#{@cached_label_status}</strong>: #{h(issue.status.name)}<br />" +
                   "<strong>#{@cached_label_start_date}</strong>: #{format_date(issue.start_date)}<br />" +
                   "<strong>#{@cached_label_due_date}</strong>: #{format_date(issue.due_date)}<br />" +
                   "<strong>#{@cached_label_assigned_to}</strong>: #{h(issue.assigned_to)}<br />" +
                   "<strong>#{@cached_label_priority}</strong>: #{h(issue.priority.name)}").html_safe
               end
               def issue_heading(issue)
                 h("#{issue.tracker} ##{issue.id}")
               end
               def render_issue_subject_with_tree(issue)
                 s = ''
                 ancestors = issue.root? ? [] : issue.ancestors.visible.all
                 ancestors.each do |ancestor|
                   s << '<div>' + content_tag('p', link_to_issue(ancestor))
                 end
                 s << '<div>'
                 subject = h(issue.subject)
                 if issue.is_private?
                   subject = content_tag('span', l(:field_is_private), :class => 'private') + ' ' + subject
                 end
                 s << content_tag('h3', subject)
                 s << '</div>' * (ancestors.size + 1)
                 s.html_safe
               end
               def render_descendants_tree(issue)
                 s = '<form><table class="list issues">'
                 issue_list(issue.descendants.visible.sort_by(&:lft)) do |child, level|
                   s << content_tag('tr',
                          content_tag('td', check_box_tag("ids[]", child.id, false, :id => nil), :class => 'checkbox') +
                          content_tag('td', link_to_issue(child, :truncate => 60), :class => 'subject') +
                          content_tag('td', h(child.status)) +
                          content_tag('td', link_to_user(child.assigned_to)) +
                          content_tag('td', progress_bar(child.done_ratio, :width => '80px')),
                          :class => "issue issue-#{child.id} hascontextmenu #{level > 0 ? "idnt idnt-#{level}" : nil}")
                 end
                 s << '</form></table>'
                 s.html_safe
               end
               def render_custom_fields_rows(issue)
                 return if issue.custom_field_values.empty?
                 ordered_values = []
                 half = (issue.custom_field_values.size / 2.0).ceil
                 half.times do |i|
                   ordered_values << issue.custom_field_values[i]
                   ordered_values << issue.custom_field_values[i + half]
                 end
                 s = "<tr>\n"
                 n = 0
                 ordered_values.compact.each do |value|
                   s << "</tr>\n<tr>\n" if n > 0 && (n % 2) == 0
                   s << "\t<th>#{ h(value.custom_field.name) }:</th><td>#{ simple_format_without_paragraph(h(show_value(value))) }</td>\n"
                   n += 1
                 end
                 s << "</tr>\n"
                 s.html_safe
               end
               def issues_destroy_confirmation_message(issues)
                 issues = [issues] unless issues.is_a?(Array)
                 message = l(:text_issues_destroy_confirmation)
                 descendant_count = issues.inject(0) {|memo, i| memo += (i.right - i.left - 1)/2}
                 if descendant_count > 0
                   issues.each do |issue|
                     next if issue.root?
                     issues.each do |other_issue|
                       descendant_count -= 1 if issue.is_descendant_of?(other_issue)
                     end
                   end
                   if descendant_count > 0
                     message << "\n" + l(:text_issues_destroy_descendants_confirmation, :count => descendant_count)
                   end
                 end
                 message
               end
               def sidebar_queries
                 unless @sidebar_queries
                   # User can see public queries and his own queries
                   visible = ARCondition.new(["is_public = ? OR user_id = ?", true, (User.current.logged? ? User.current.id : 0)])
                   # Project specific queries and global queries
                   visible << (@project.nil? ? ["project_id IS NULL"] : ["project_id IS NULL OR project_id = ?", @project.id])
                   @sidebar_queries = Query.find(:all,
                                                 :select => 'id, name, is_public',
                                                 :order => "name ASC",
                                                 :conditions => visible.conditions)
                 end
                 @sidebar_queries
               end
               def query_links(title, queries)
                 # links to #index on issues/show
                 url_params = controller_name == 'issues' ? {:controller => 'issues', :action => 'index', :project_id => @project} : params
                 content_tag('h3', h(title)) +
                   queries.collect {|query|
                       link_to(h(query.name), url_params.merge(:query_id => query))
                     }.join('<br />')
               end
               def render_sidebar_queries
                 out = ''
                 queries = sidebar_queries.select {|q| !q.is_public?}
                 out << query_links(l(:label_my_queries), queries) if queries.any?
                 queries = sidebar_queries.select {|q| q.is_public?}
                 out << query_links(l(:label_query_plural), queries) if queries.any?
                 out
               end
               def show_detail(detail, no_html=false)
                 case detail.property
                 when 'attr'
                   field = detail.prop_key.to_s.gsub(/\_id$/, "")
                   label = l(("field_" + field).to_sym)
                   case
                   when ['due_date', 'start_date'].include?(detail.prop_key)
                     value = format_date(detail.value.to_date) if detail.value
                     old_value = format_date(detail.old_value.to_date) if detail.old_value
                   when ['project_id', 'status_id', 'tracker_id', 'assigned_to_id', 'priority_id', 'category_id', 'fixed_version_id'].include?(detail.prop_key)
                     value = find_name_by_reflection(field, detail.value)
                     old_value = find_name_by_reflection(field, detail.old_value)
                   when detail.prop_key == 'estimated_hours'
                     value = "%0.02f" % detail.value.to_f unless detail.value.blank?
                     old_value = "%0.02f" % detail.old_value.to_f unless detail.old_value.blank?
                   when detail.prop_key == 'parent_id'
                     label = l(:field_parent_issue)
                     value = "##{detail.value}" unless detail.value.blank?
                     old_value = "##{detail.old_value}" unless detail.old_value.blank?
                   when detail.prop_key == 'is_private'
                     value = l(detail.value == "0" ? :general_text_No : :general_text_Yes) unless detail.value.blank?
                     old_value = l(detail.old_value == "0" ? :general_text_No : :general_text_Yes) unless detail.old_value.blank?
                   end
                 when 'cf'
                   custom_field = CustomField.find_by_id(detail.prop_key)
                   if custom_field
                     label = custom_field.name
                     value = format_value(detail.value, custom_field.field_format) if detail.value
                     old_value = format_value(detail.old_value, custom_field.field_format) if detail.old_value
                   end
                 when 'attachment'
                   label = l(:label_attachment)
                 end
                 call_hook(:helper_issues_show_detail_after_setting, {:detail => detail, :label => label, :value => value, :old_value => old_value })
                 label ||= detail.prop_key
                 value ||= detail.value
                 old_value ||= detail.old_value
                 unless no_html
                   label = content_tag('strong', label)
                   old_value = content_tag("i", h(old_value)) if detail.old_value
                   old_value = content_tag("strike", old_value) if detail.old_value and detail.value.blank?
                   if detail.property == 'attachment' && !value.blank? && a = Attachment.find_by_id(detail.prop_key)
                     # Link to the attachment if it has not been removed
                     value = link_to_attachment(a)
                   else
                     value = content_tag("i", h(value)) if value
                   end
                 end
                 if detail.property == 'attr' && detail.prop_key == 'description'
                   s = l(:text_journal_changed_no_detail, :label => label)
                   unless no_html
                     diff_link = link_to 'diff',
                       {:controller => 'journals', :action => 'diff', :id => detail.journal_id, :detail_id => detail.id},
                       :title => l(:label_view_diff)
                     s << " (#{ diff_link })"
                   end
                   s
                 elsif !detail.value.blank?
                   case detail.property
                   when 'attr', 'cf'
                     if !detail.old_value.blank?
                       l(:text_journal_changed, :label => label, :old => old_value, :new => value)
                     else
                       l(:text_journal_set_to, :label => label, :value => value)
                     end
                   when 'attachment'
                     l(:text_journal_added, :label => label, :value => value)
                   end
                 else
                   l(:text_journal_deleted, :label => label, :old => old_value)
                 end
               end
               # Find the name of an associated record stored in the field attribute
               def find_name_by_reflection(field, id)
                 association = Issue.reflect_on_association(field.to_sym)
                 if association
                   record = association.class_name.constantize.find_by_id(id)
                   return record.name if record
                 end
               end
               # Renders issue children recursively
               def render_api_issue_children(issue, api)
                 return if issue.leaf?
                 api.array :children do
                   issue.children.each do |child|
                     api.issue(:id => child.id) do
                       api.tracker(:id => child.tracker_id, :name => child.tracker.name) unless child.tracker.nil?
                       api.subject child.subject
                       render_api_issue_children(child, api)
                     end
                   end
                 end
               end
               def issues_to_csv(issues, project, query, options={})
                 decimal_separator = l(:general_csv_decimal_separator)
                 encoding = l(:general_csv_encoding)
                 columns = (options[:columns] == 'all' ? query.available_columns : query.columns)
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # csv header fields
                   csv << [ "#" ] + columns.collect {|c| Redmine::CodesetUtil.from_utf8(c.caption.to_s, encoding) } +
                     (options[:description] ? [Redmine::CodesetUtil.from_utf8(l(:field_description), encoding)] : [])
                   # csv lines
                   issues.each do |issue|
                     col_values = columns.collect do |column|
                       s = if column.is_a?(QueryCustomFieldColumn)
                         cv = issue.custom_values.detect {|v| v.custom_field_id == column.custom_field.id}
                         show_value(cv)
                       else
                         value = issue.send(column.name)
                         if value.is_a?(Date)
                           format_date(value)
                         elsif value.is_a?(Time)
                           format_time(value)
                         elsif value.is_a?(Float)
                           value.to_s.gsub('.', decimal_separator)
                         else
                           value
                         end
                       end
                       s.to_s
                     end
                     csv << [ issue.id.to_s ] + col_values.collect {|c| Redmine::CodesetUtil.from_utf8(c.to_s, encoding) } +
                       (options[:description] ? [Redmine::CodesetUtil.from_utf8(issue.description, encoding)] : [])
                   end
                 end
                 export
               end
             end

app/helpers/journals_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 JournalsHelper
               def render_notes(issue, journal, options={})
                 content = ''
                 editable = User.current.logged? && (User.current.allowed_to?(:edit_issue_notes, issue.project) || (journal.user == User.current && User.current.allowed_to?(:edit_own_issue_notes, issue.project)))
                 links = []
                 if !journal.notes.blank?
                   links << link_to_remote(image_tag('comment.png'),
                                           { :url => {:controller => 'journals', :action => 'new', :id => issue, :journal_id => journal} },
                                           :title => l(:button_quote)) if options[:reply_links]
                   links << link_to_in_place_notes_editor(image_tag('edit.png'), "journal-#{journal.id}-notes",
                                                          { :controller => 'journals', :action => 'edit', :id => journal },
                                                             :title => l(:button_edit)) if editable
                 end
                 content << content_tag('div', links.join(' '), :class => 'contextual') unless links.empty?
                 content << textilizable(journal, :notes)
                 css_classes = "wiki"
                 css_classes << " editable" if editable
                 content_tag('div', content, :id => "journal-#{journal.id}-notes", :class => css_classes)
               end
               def link_to_in_place_notes_editor(text, field_id, url, options={})
                 onclick = "new Ajax.Request('#{url_for(url)}', {asynchronous:true, evalScripts:true, method:'get'}); return false;"
                 link_to text, '#', options.merge(:onclick => onclick)
               end
             end

app/helpers/mail_handler_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 MailHandlerHelper
             end

app/helpers/members_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 MembersHelper
             end

app/helpers/messages_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 MessagesHelper
             end

app/helpers/my_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 MyHelper
             end

app/helpers/news_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 NewsHelper
             end

app/helpers/projects_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ProjectsHelper
               def link_to_version(version, options = {})
                 return '' unless version && version.is_a?(Version)
                 link_to_if version.visible?, format_version_name(version), { :controller => 'versions', :action => 'show', :id => version }, options
               end
               def project_settings_tabs
                 tabs = [{:name => 'info', :action => :edit_project, :partial => 'projects/edit', :label => :label_information_plural},
                         {:name => 'modules', :action => :select_project_modules, :partial => 'projects/settings/modules', :label => :label_module_plural},
                         {:name => 'members', :action => :manage_members, :partial => 'projects/settings/members', :label => :label_member_plural},
                         {:name => 'versions', :action => :manage_versions, :partial => 'projects/settings/versions', :label => :label_version_plural},
                         {:name => 'categories', :action => :manage_categories, :partial => 'projects/settings/issue_categories', :label => :label_issue_category_plural},
                         {:name => 'wiki', :action => :manage_wiki, :partial => 'projects/settings/wiki', :label => :label_wiki},
                         {:name => 'repository', :action => :manage_repository, :partial => 'projects/settings/repository', :label => :label_repository},
                         {:name => 'boards', :action => :manage_boards, :partial => 'projects/settings/boards', :label => :label_board_plural},
                         {:name => 'activities', :action => :manage_project_activities, :partial => 'projects/settings/activities', :label => :enumeration_activities}
                         ]
                 tabs.select {|tab| User.current.allowed_to?(tab[:action], @project)}
               end
               def parent_project_select_tag(project)
                 selected = project.parent
                 # retrieve the requested parent project
                 parent_id = (params[:project] && params[:project][:parent_id]) || params[:parent_id]
                 if parent_id
                   selected = (parent_id.blank? ? nil : Project.find(parent_id))
                 end
                 options = ''
                 options << "<option value=''></option>" if project.allowed_parents.include?(nil)
                 options << project_tree_options_for_select(project.allowed_parents.compact, :selected => selected)
                 content_tag('select', options.html_safe, :name => 'project[parent_id]', :id => 'project_parent_id')
               end
               # Renders a tree of projects as a nested set of unordered lists
               # The given collection may be a subset of the whole project tree
               # (eg. some intermediate nodes are private and can not be seen)
               def render_project_hierarchy(projects)
                 s = ''
                 if projects.any?
                   ancestors = []
                   original_project = @project
                   projects.each do |project|
                     # set the project environment to please macros.
                     @project = project
                     if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                       s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
                     else
                       ancestors.pop
                       s << "</li>"
                       while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                         ancestors.pop
                         s << "</ul></li>\n"
                       end
                     end
                     classes = (ancestors.empty? ? 'root' : 'child')
                     s << "<li class='#{classes}'><div class='#{classes}'>" +
                            link_to_project(project, {}, :class => "project #{User.current.member_of?(project) ? 'my-project' : nil}")
                     s << "<div class='wiki description'>#{textilizable(project.short_description, :project => project)}</div>" unless project.description.blank?
                     s << "</div>\n"
                     ancestors << project
                   end
                   s << ("</li></ul>\n" * ancestors.size)
                   @project = original_project
                 end
                 s.html_safe
               end
               # Returns a set of options for a select field, grouped by project.
               def version_options_for_select(versions, selected=nil)
                 grouped = Hash.new {|h,k| h[k] = []}
                 versions.each do |version|
                   grouped[version.project.name] << [version.name, version.id]
                 end
                 # Add in the selected
                 if selected && !versions.include?(selected)
                   grouped[selected.project.name] << [selected.name, selected.id]
                 end
                 if grouped.keys.size > 1
                   grouped_options_for_select(grouped, selected && selected.id)
                 else
                   options_for_select((grouped.values.first || []), selected && selected.id)
                 end
               end
               def format_version_sharing(sharing)
                 sharing = 'none' unless Version::VERSION_SHARINGS.include?(sharing)
                 l("label_version_sharing_#{sharing}")
               end
             end

app/helpers/queries_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 QueriesHelper
               def operators_for_select(filter_type)
                 Query.operators_by_filter_type[filter_type].collect {|o| [l(Query.operators[o]), o]}
               end
               def column_header(column)
                 column.sortable ? sort_header_tag(column.name.to_s, :caption => column.caption,
                                                                     :default_order => column.default_order) :
                                   content_tag('th', h(column.caption))
               end
               def column_content(column, issue)
                 value = column.value(issue)
                 case value.class.name
                 when 'String'
                   if column.name == :subject
                     link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)
                   else
                     h(value)
                   end
                 when 'Time'
                   format_time(value)
                 when 'Date'
                   format_date(value)
                 when 'Fixnum', 'Float'
                   if column.name == :done_ratio
                     progress_bar(value, :width => '80px')
                   else
                     h(value.to_s)
                   end
                 when 'User'
                   link_to_user value
                 when 'Project'
                   link_to_project value
                 when 'Version'
                   link_to(h(value), :controller => 'versions', :action => 'show', :id => value)
                 when 'TrueClass'
                   l(:general_text_Yes)
                 when 'FalseClass'
                   l(:general_text_No)
                 when 'Issue'
                   link_to_issue(value, :subject => false)
                 else
                   h(value)
                 end
               end
               # Retrieve query from session or build a new query
               def retrieve_query
                 if !params[:query_id].blank?
                   cond = "project_id IS NULL"
                   cond << " OR project_id = #{@project.id}" if @project
                   @query = Query.find(params[:query_id], :conditions => cond)
                   raise ::Unauthorized unless @query.visible?
                   @query.project = @project
                   session[:query] = {:id => @query.id, :project_id => @query.project_id}
                   sort_clear
                 elsif api_request? || params[:set_filter] || session[:query].nil? || session[:query][:project_id] != (@project ? @project.id : nil)
                   # Give it a name, required to be valid
                   @query = Query.new(:name => "_")
                   @query.project = @project
                   build_query_from_params
                   session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}
                 else
                   # retrieve from session
                   @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]
                   @query ||= Query.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
                   @query.project = @project
                 end
               end
               def build_query_from_params
                 if params[:fields] || params[:f]
                   @query.filters = {}
                   @query.add_filters(params[:fields] || params[:f], params[:operators] || params[:op], params[:values] || params[:v])
                 else
                   @query.available_filters.keys.each do |field|
                     @query.add_short_filter(field, params[field]) if params[field]
                   end
                 end
                 @query.group_by = params[:group_by] || (params[:query] && params[:query][:group_by])
                 @query.column_names = params[:c] || (params[:query] && params[:query][:column_names])
               end
             end

app/helpers/reports_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ReportsHelper
               def aggregate(data, criteria)
                 a = 0
                 data.each { |row|
                   match = 1
                   criteria.each { |k, v|
                     match = 0 unless (row[k].to_s == v.to_s) || (k == 'closed' && row[k] == (v == 0 ? "f" : "t"))
                   } unless criteria.nil?
                   a = a + row["total"].to_i if match == 1
                 } unless data.nil?
                 a
               end
               def aggregate_link(data, criteria, *args)
                 a = aggregate data, criteria
                 a > 0 ? link_to(h(a), *args) : '-'
               end
             end

app/helpers/repositories_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 'iconv'
             require 'redmine/codeset_util'
             module RepositoriesHelper
               def format_revision(revision)
                 if revision.respond_to? :format_identifier
                   revision.format_identifier
                 else
                   revision.to_s
                 end
               end
               def truncate_at_line_break(text, length = 255)
                 if text
                   text.gsub(%r{^(.{#{length}}[^\n]*)\n.+$}m, '\\1...')
                 end
               end
               def render_properties(properties)
                 unless properties.nil? || properties.empty?
                   content = ''
                   properties.keys.sort.each do |property|
                     content << content_tag('li', "<b>#{h property}</b>: <span>#{h properties[property]}</span>".html_safe)
                   end
                   content_tag('ul', content.html_safe, :class => 'properties')
                 end
               end
               def render_changeset_changes
                 changes = @changeset.changes.find(:all, :limit => 1000, :order => 'path').collect do |change|
                   case change.action
                   when 'A'
                     # Detects moved/copied files
                     if !change.from_path.blank?
                       change.action =
                          @changeset.changes.detect {|c| c.action == 'D' && c.path == change.from_path} ? 'R' : 'C'
                     end
                     change
                   when 'D'
                     @changeset.changes.detect {|c| c.from_path == change.path} ? nil : change
                   else
                     change
                   end
                 end.compact
                 tree = { }
                 changes.each do |change|
                   p = tree
                   dirs = change.path.to_s.split('/').select {|d| !d.blank?}
                   path = ''
                   dirs.each do |dir|
                     path += '/' + dir
                     p[:s] ||= {}
                     p = p[:s]
                     p[path] ||= {}
                     p = p[path]
                   end
                   p[:c] = change
                 end
                 render_changes_tree(tree[:s])
               end
               def render_changes_tree(tree)
                 return '' if tree.nil?
                 output = ''
                 output << '<ul>'
                 tree.keys.sort.each do |file|
                   style = 'change'
                   text = File.basename(h(file))
                   if s = tree[file][:s]
                     style << ' folder'
                     path_param = to_path_param(@repository.relative_path(file))
                     text = link_to(h(text), :controller => 'repositories',
                                          :action => 'show',
                                          :id => @project,
                                          :path => path_param,
                                          :rev => @changeset.identifier)
                     output << "<li class='#{style}'>#{text}</li>"
                     output << render_changes_tree(s)
                   elsif c = tree[file][:c]
                     style << " change-#{c.action}"
                     path_param = to_path_param(@repository.relative_path(c.path))
                     text = link_to(h(text), :controller => 'repositories',
                                          :action => 'entry',
                                          :id => @project,
                                          :path => path_param,
                                          :rev => @changeset.identifier) unless c.action == 'D'
                     text << " - #{h(c.revision)}" unless c.revision.blank?
                     text << ' ('.html_safe + link_to(l(:label_diff), :controller => 'repositories',
                                                    :action => 'diff',
                                                    :id => @project,
                                                    :path => path_param,
                                                    :rev => @changeset.identifier) + ') '.html_safe if c.action == 'M'
                     text << ' '.html_safe + content_tag('span', h(c.from_path), :class => 'copied-from') unless c.from_path.blank?
                     output << "<li class='#{style}'>#{text}</li>"
                   end
                 end
                 output << '</ul>'
                 output.html_safe
               end
               def repository_field_tags(form, repository)
                 method = repository.class.name.demodulize.underscore + "_field_tags"
                 if repository.is_a?(Repository) &&
                     respond_to?(method) && method != 'repository_field_tags'
                   send(method, form, repository)
                 end
               end
               def scm_select_tag(repository)
                 scm_options = [["--- #{l(:actionview_instancetag_blank_option)} ---", '']]
                 Redmine::Scm::Base.all.each do |scm|
                 if Setting.enabled_scm.include?(scm) ||
                       (repository && repository.class.name.demodulize == scm)
                     scm_options << ["Repository::#{scm}".constantize.scm_name, scm]
                   end
                 end
                 select_tag('repository_scm',
                            options_for_select(scm_options, repository.class.name.demodulize),
                            :disabled => (repository && !repository.new_record?),
                            :onchange => remote_function(
                               :url => {
                                   :controller => 'repositories',
                                   :action     => 'edit',
                                   :id         => @project
                                },
                            :method => :get,
                            :with   => "Form.serialize(this.form)")
                          )
               end
               def with_leading_slash(path)
                 path.to_s.starts_with?('/') ? path : "/#{path}"
               end
               def without_leading_slash(path)
                 path.gsub(%r{^/+}, '')
               end
               def subversion_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :size => 60, :required => true,
                                    :disabled => (repository && !repository.root_url.blank?)) +
                                    '<br />'.html_safe +
                                    '(file:///, http://, https://, svn://, svn+[tunnelscheme]://)') +
                   content_tag('p', form.text_field(:login, :size => 30)) +
                   content_tag('p', form.password_field(
                                         :password, :size => 30, :name => 'ignore',
                                         :value => ((repository.new_record? || repository.password.blank?) ? '' : ('x'*15)),
                                         :onfocus => "this.value=''; this.name='repository[password]';",
                                         :onchange => "this.name='repository[password]';"))
               end
               def darcs_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_path_to_repository),
                                  :size => 60, :required => true,
                                  :disabled => (repository && !repository.new_record?))) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true))
               end
               def mercurial_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                    :url, :label => l(:field_path_to_repository),
                                    :size => 60, :required => true,
                                    :disabled => (repository && !repository.root_url.blank?)
                                      ) +
                                  '<br />'.html_safe + l(:text_mercurial_repository_note)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def git_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                    :url, :label => l(:field_path_to_repository),
                                    :size => 60, :required => true,
                                    :disabled => (repository && !repository.root_url.blank?)
                                      ) +
                                   '<br />'.html_safe +
                                   l(:text_git_repository_note)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note)) +
                 content_tag('p', form.check_box(
                                     :extra_report_last_commit,
                                     :label => l(:label_git_report_last_commit)
                                      ))
               end
               def cvs_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :root_url,
                                  :label => l(:field_cvsroot),
                                  :size => 60, :required => true,
                                  :disabled => !repository.new_record?)) +
                 content_tag('p', form.text_field(
                                  :url,
                                  :label => l(:field_cvs_module),
                                  :size => 30, :required => true,
                                  :disabled => !repository.new_record?)) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def bazaar_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_path_to_repository),
                                  :size => 60, :required => true,
                                  :disabled => (repository && !repository.new_record?))) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true))
               end
               def filesystem_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_root_directory),
                                  :size => 60, :required => true,
                                  :disabled => (repository && !repository.root_url.blank?))) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def index_commits(commits, heads, href_proc = nil)
                 return nil if commits.nil? or commits.first.parents.nil?
                 map  = {}
                 commit_hashes = []
                 refs_map = {}
                 href_proc ||= Proc.new {|x|x}
                 heads.each{|r| refs_map[r.scmid] ||= []; refs_map[r.scmid] << r}
                 commits.reverse.each_with_index do |c, i|
                   h = {}
                   h[:parents] = c.parents.collect do |p|
                     [p.scmid, 0, 0]
                   end
                   h[:rdmid] = i
                   h[:space] = 0
                   h[:refs]  = refs_map[c.scmid].join(" ") if refs_map.include? c.scmid
                   h[:scmid] = c.scmid
                   h[:href]  = href_proc.call(c.scmid)
                   commit_hashes << h
                   map[c.scmid] = h
                 end
                 heads.sort! do |a,b|
                   a.to_s <=> b.to_s
                 end
                 j = 0
                 heads.each do |h|
                   if map.include? h.scmid then
                     j = mark_chain(j += 1, map[h.scmid], map)
                   end
                 end
                 # when no head matched anything use first commit
                 if j == 0 then
                    mark_chain(j += 1, map.values.first, map)
                 end
                 map
               end
               def mark_chain(mark, commit, map)
                 stack = [[mark, commit]]
                 markmax = mark
                 until stack.empty?
                   current = stack.pop
                   m, commit = current
                   commit[:space] = m  if commit[:space] == 0
                   m1 = m - 1
                   commit[:parents].each_with_index do |p, i|
                     psha = p[0]
                     if map.include? psha  and  map[psha][:space] == 0 then
                       stack << [m1 += 1, map[psha]] if i == 0
                       stack = [[m1 += 1, map[psha]]] + stack if i > 0
                     end
                   end
                   markmax = m1 if markmax < m1
                 end
                 markmax
               end
             end

app/helpers/roles_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 RolesHelper
             end

app/helpers/search_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 SearchHelper
               def highlight_tokens(text, tokens)
                 return text unless text && tokens && !tokens.empty?
                 re_tokens = tokens.collect {|t| Regexp.escape(t)}
                 regexp = Regexp.new "(#{re_tokens.join('|')})", Regexp::IGNORECASE
                 result = ''
                 text.split(regexp).each_with_index do |words, i|
                   if result.length > 1200
                     # maximum length of the preview reached
                     result << '...'
                     break
                   end
                   words = words.mb_chars
                   if i.even?
                     result << h(words.length > 100 ? "#{words.slice(0..44)} ... #{words.slice(-45..-1)}" : words)
                   else
                     t = (tokens.index(words.downcase) || 0) % 4
                     result << content_tag('span', h(words), :class => "highlight token-#{t}")
                   end
                 end
                 result
               end
               def type_label(t)
                 l("label_#{t.singularize}_plural", :default => t.to_s.humanize)
               end
               def project_select_tag
                 options = [[l(:label_project_all), 'all']]
                 options << [l(:label_my_projects), 'my_projects'] unless User.current.memberships.empty?
                 options << [l(:label_and_its_subprojects, @project.name), 'subprojects'] unless @project.nil? || @project.descendants.active.empty?
                 options << [@project.name, ''] unless @project.nil?
                 label_tag("scope", l(:description_project_scope), :class => "hidden-for-sighted") +
                 select_tag('scope', options_for_select(options, params[:scope].to_s)) if options.size > 1
               end
               def render_results_by_type(results_by_type)
                 links = []
                 # Sorts types by results count
                 results_by_type.keys.sort {|a, b| results_by_type[b] <=> results_by_type[a]}.each do |t|
                   c = results_by_type[t]
                   next if c == 0
                   text = "#{type_label(t)} (#{c})"
                   links << link_to(h(text), :q => params[:q], :titles_only => params[:titles_only],
                                    :all_words => params[:all_words], :scope => params[:scope], t => 1)
                 end
                 ('<ul>' + links.map {|link| content_tag('li', link)}.join(' ') + '</ul>') unless links.empty?
               end
             end

app/helpers/settings_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 SettingsHelper
               def administration_settings_tabs
                 tabs = [{:name => 'general', :partial => 'settings/general', :label => :label_general},
                         {:name => 'display', :partial => 'settings/display', :label => :label_display},
                         {:name => 'authentication', :partial => 'settings/authentication', :label => :label_authentication},
                         {:name => 'projects', :partial => 'settings/projects', :label => :label_project_plural},
                         {:name => 'issues', :partial => 'settings/issues', :label => :label_issue_tracking},
                         {:name => 'notifications', :partial => 'settings/notifications', :label => :field_mail_notification},
                         {:name => 'mail_handler', :partial => 'settings/mail_handler', :label => :label_incoming_emails},
                         {:name => 'repositories', :partial => 'settings/repositories', :label => :label_repository_plural}
                         ]
               end
               def setting_select(setting, choices, options={})
                 if blank_text = options.delete(:blank)
                   choices = [[blank_text.is_a?(Symbol) ? l(blank_text) : blank_text, '']] + choices
                 end
                 setting_label(setting, options).html_safe +
                   select_tag("settings[#{setting}]",
                              options_for_select(choices, Setting.send(setting).to_s),
                              options).html_safe
               end
               def setting_multiselect(setting, choices, options={})
                 setting_values = Setting.send(setting)
                 setting_values = [] unless setting_values.is_a?(Array)
                 setting_label(setting, options).html_safe +
                   hidden_field_tag("settings[#{setting}][]", '').html_safe +
                   choices.collect do |choice|
                     text, value = (choice.is_a?(Array) ? choice : [choice, choice])
                     content_tag(
                       'label',
                       check_box_tag(
                          "settings[#{setting}][]",
                          value,
                          Setting.send(setting).include?(value)
                        ) + text.to_s,
                       :class => 'block'
                      )
                   end.join.html_safe
               end
               def setting_text_field(setting, options={})
                 setting_label(setting, options).html_safe +
                   text_field_tag("settings[#{setting}]", Setting.send(setting), options).html_safe
               end
               def setting_text_area(setting, options={})
                 setting_label(setting, options).html_safe +
                   text_area_tag("settings[#{setting}]", Setting.send(setting), options).html_safe
               end
               def setting_check_box(setting, options={})
                 setting_label(setting, options).html_safe +
                   hidden_field_tag("settings[#{setting}]", 0).html_safe +
                     check_box_tag("settings[#{setting}]", 1, Setting.send("#{setting}?"), options).html_safe
               end
               def setting_label(setting, options={})
                 label = options.delete(:label)
                 label != false ? content_tag("label", l(label || "setting_#{setting}")).html_safe : ''
               end
               # Renders a notification field for a Redmine::Notifiable option
               def notification_field(notifiable)
                 return content_tag(:label,
                                    check_box_tag('settings[notified_events][]',
                                                  notifiable.name,
                                                  Setting.notified_events.include?(notifiable.name)).html_safe +
                                      l_or_humanize(notifiable.name, :prefix => 'label_').html_safe,
                                    :class => notifiable.parent.present? ? "parent" : '').html_safe
               end
             end

app/helpers/sort_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Helpers to sort tables using clickable column headers.
             #
             # Author:  Stuart Rackham <srackham@methods.co.nz>, March 2005.
             #          Jean-Philippe Lang, 2009
             # License: This source code is released under the MIT license.
             #
             # - Consecutive clicks toggle the column's sort order.
             # - Sort state is maintained by a session hash entry.
             # - CSS classes identify sort column and state.
             # - Typically used in conjunction with the Pagination module.
             #
             # Example code snippets:
             #
             # Controller:
             #
             #   helper :sort
             #   include SortHelper
             #
             #   def list
             #     sort_init 'last_name'
             #     sort_update %w(first_name last_name)
             #     @items = Contact.find_all nil, sort_clause
             #   end
             #
             # Controller (using Pagination module):
             #
             #   helper :sort
             #   include SortHelper
             #
             #   def list
             #     sort_init 'last_name'
             #     sort_update %w(first_name last_name)
             #     @contact_pages, @items = paginate :contacts,
             #       :order_by => sort_clause,
             #       :per_page => 10
             #   end
             #
             # View (table header in list.rhtml):
             #
             #   <thead>
             #     <tr>
             #       <%= sort_header_tag('id', :title => 'Sort by contact ID') %>
             #       <%= sort_header_tag('last_name', :caption => 'Name') %>
             #       <%= sort_header_tag('phone') %>
             #       <%= sort_header_tag('address', :width => 200) %>
             #     </tr>
             #   </thead>
             #
             # - Introduces instance variables: @sort_default, @sort_criteria
             # - Introduces param :sort
             #
             module SortHelper
               class SortCriteria
                 def initialize
                   @criteria = []
                 end
                 def available_criteria=(criteria)
                   unless criteria.is_a?(Hash)
                     criteria = criteria.inject({}) {|h,k| h[k] = k; h}
                   end
                   @available_criteria = criteria
                 end
                 def from_param(param)
                   @criteria = param.to_s.split(',').collect {|s| s.split(':')[0..1]}
                   normalize!
                 end
                 def criteria=(arg)
                   @criteria = arg
                   normalize!
                 end
                 def to_param
                   @criteria.collect {|k,o| k + (o ? '' : ':desc')}.join(',')
                 end
                 def to_sql
                   sql = @criteria.collect do |k,o|
                     if s = @available_criteria[k]
                       (o ? s.to_a : s.to_a.collect {|c| append_desc(c)}).join(', ')
                     end
                   end.compact.join(', ')
                   sql.blank? ? nil : sql
                 end
                 def add!(key, asc)
                   @criteria.delete_if {|k,o| k == key}
                   @criteria = [[key, asc]] + @criteria
                   normalize!
                 end
                 def add(*args)
                   r = self.class.new.from_param(to_param)
                   r.add!(*args)
                   r
                 end
                 def first_key
                   @criteria.first && @criteria.first.first
                 end
                 def first_asc?
                   @criteria.first && @criteria.first.last
                 end
                 def empty?
                   @criteria.empty?
                 end
                 private
                 def normalize!
                   @criteria ||= []
                   @criteria = @criteria.collect {|s| s = s.to_a; [s.first, (s.last == false || s.last == 'desc') ? false : true]}
                   @criteria = @criteria.select {|k,o| @available_criteria.has_key?(k)} if @available_criteria
                   @criteria.slice!(3)
                   self
                 end
                 # Appends DESC to the sort criterion unless it has a fixed order
                 def append_desc(criterion)
                   if criterion =~ / (asc|desc)$/i
                     criterion
                   else
                     "#{criterion} DESC"
                   end
                 end
               end
               def sort_name
                 controller_name + '_' + action_name + '_sort'
               end
               # Initializes the default sort.
               # Examples:
               #
               #   sort_init 'name'
               #   sort_init 'id', 'desc'
               #   sort_init ['name', ['id', 'desc']]
               #   sort_init [['name', 'desc'], ['id', 'desc']]
               #
               def sort_init(*args)
                 case args.size
                 when 1
                   @sort_default = args.first.is_a?(Array) ? args.first : [[args.first]]
                 when 2
                   @sort_default = [[args.first, args.last]]
                 else
                   raise ArgumentError
                 end
               end
               # Updates the sort state. Call this in the controller prior to calling
               # sort_clause.
               # - criteria can be either an array or a hash of allowed keys
               #
               def sort_update(criteria)
                 @sort_criteria = SortCriteria.new
                 @sort_criteria.available_criteria = criteria
                 @sort_criteria.from_param(params[:sort] || session[sort_name])
                 @sort_criteria.criteria = @sort_default if @sort_criteria.empty?
                 session[sort_name] = @sort_criteria.to_param
               end
               # Clears the sort criteria session data
               #
               def sort_clear
                 session[sort_name] = nil
               end
               # Returns an SQL sort clause corresponding to the current sort state.
               # Use this to sort the controller's table items collection.
               #
               def sort_clause()
                 @sort_criteria.to_sql
               end
               # Returns a link which sorts by the named column.
               #
               # - column is the name of an attribute in the sorted record collection.
               # - the optional caption explicitly specifies the displayed link text.
               # - 2 CSS classes reflect the state of the link: sort and asc or desc
               #
               def sort_link(column, caption, default_order)
                 css, order = nil, default_order
                 if column.to_s == @sort_criteria.first_key
                   if @sort_criteria.first_asc?
                     css = 'sort asc'
                     order = 'desc'
                   else
                     css = 'sort desc'
                     order = 'asc'
                   end
                 end
                 caption = column.to_s.humanize unless caption
                 sort_options = { :sort => @sort_criteria.add(column.to_s, order).to_param }
                 url_options = params.merge(sort_options)
                  # Add project_id to url_options
                 url_options = url_options.merge(:project_id => params[:project_id]) if params.has_key?(:project_id)
                 link_to_content_update(h(caption), url_options, :class => css)
               end
               # Returns a table header <th> tag with a sort link for the named column
               # attribute.
               #
               # Options:
               #   :caption     The displayed link name (defaults to titleized column name).
               #   :title       The tag's 'title' attribute (defaults to 'Sort by :caption').
               #
               # Other options hash entries generate additional table header tag attributes.
               #
               # Example:
               #
               #   <%= sort_header_tag('id', :title => 'Sort by contact ID', :width => 40) %>
               #
               def sort_header_tag(column, options = {})
                 caption = options.delete(:caption) || column.to_s.humanize
                 default_order = options.delete(:default_order) || 'asc'
                 options[:title] = l(:label_sort_by, "\"#{caption}\"") unless options[:title]
                 content_tag('th', sort_link(column, caption, default_order), options)
               end
             end

app/helpers/timelog_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 TimelogHelper
               include ApplicationHelper
               def render_timelog_breadcrumb
                 links = []
                 links << link_to(l(:label_project_all), {:project_id => nil, :issue_id => nil})
                 links << link_to(h(@project), {:project_id => @project, :issue_id => nil}) if @project
                 if @issue
                   if @issue.visible?
                     links << link_to_issue(@issue, :subject => false)
                   else
                     links << "##{@issue.id}"
                   end
                 end
                 breadcrumb links
               end
               # Returns a collection of activities for a select field.  time_entry
               # is optional and will be used to check if the selected TimeEntryActivity
               # is active.
               def activity_collection_for_select_options(time_entry=nil, project=nil)
                 project ||= @project
                 if project.nil?
                   activities = TimeEntryActivity.shared.active
                 else
                   activities = project.activities
                 end
                 collection = []
                 if time_entry && time_entry.activity && !time_entry.activity.active?
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ]
                 else
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
                 end
                 activities.each { |a| collection << [a.name, a.id] }
                 collection
               end
               def select_hours(data, criteria, value)
               	if value.to_s.empty?
               		data.select {|row| row[criteria].blank? }
                 else
                 	data.select {|row| row[criteria].to_s == value.to_s}
                 end
               end
               def sum_hours(data)
                 sum = 0
                 data.each do |row|
                   sum += row['hours'].to_f
                 end
                 sum
               end
               def options_for_period_select(value)
                 options_for_select([[l(:label_all_time), 'all'],
                                     [l(:label_today), 'today'],
                                     [l(:label_yesterday), 'yesterday'],
                                     [l(:label_this_week), 'current_week'],
                                     [l(:label_last_week), 'last_week'],
                                     [l(:label_last_n_days, 7), '7_days'],
                                     [l(:label_this_month), 'current_month'],
                                     [l(:label_last_month), 'last_month'],
                                     [l(:label_last_n_days, 30), '30_days'],
                                     [l(:label_this_year), 'current_year']],
                                     value)
               end
               def entries_to_csv(entries)
                 decimal_separator = l(:general_csv_decimal_separator)
                 custom_fields = TimeEntryCustomField.find(:all)
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # csv header fields
                   headers = [l(:field_spent_on),
                              l(:field_user),
                              l(:field_activity),
                              l(:field_project),
                              l(:field_issue),
                              l(:field_tracker),
                              l(:field_subject),
                              l(:field_hours),
                              l(:field_comments)
                              ]
                   # Export custom fields
                   headers += custom_fields.collect(&:name)
                   csv << headers.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                  c.to_s,
                                                  l(:general_csv_encoding) )  }
                   # csv lines
                   entries.each do |entry|
                     fields = [format_date(entry.spent_on),
                               entry.user,
                               entry.activity,
                               entry.project,
                               (entry.issue ? entry.issue.id : nil),
                               (entry.issue ? entry.issue.tracker : nil),
                               (entry.issue ? entry.issue.subject : nil),
                               entry.hours.to_s.gsub('.', decimal_separator),
                               entry.comments
                               ]
                     fields += custom_fields.collect {|f| show_value(entry.custom_value_for(f)) }
                     csv << fields.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                  c.to_s,
                                                  l(:general_csv_encoding) )  }
                   end
                 end
                 export
               end
               def format_criteria_value(criteria, value)
                 if value.blank?
                   l(:label_none)
                 elsif k = @available_criterias[criteria][:klass]
                   obj = k.find_by_id(value.to_i)
                   if obj.is_a?(Issue)
                     obj.visible? ? "#{obj.tracker} ##{obj.id}: #{obj.subject}" : "##{obj.id}"
                   else
                     obj
                   end
                 else
                   format_value(value, @available_criterias[criteria][:format])
                 end
               end
               def report_to_csv(criterias, periods, hours)
                 decimal_separator = l(:general_csv_decimal_separator)
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # Column headers
                   headers = criterias.collect {|criteria| l(@available_criterias[criteria][:label]) }
                   headers += periods
                   headers << l(:label_total)
                   csv << headers.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                 c.to_s,
                                                 l(:general_csv_encoding) ) }
                   # Content
                   report_criteria_to_csv(csv, criterias, periods, hours)
                   # Total row
                   str_total = Redmine::CodesetUtil.from_utf8(l(:label_total), l(:general_csv_encoding))
                   row = [ str_total ] + [''] * (criterias.size - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? ("%.2f" % sum).gsub('.',decimal_separator) : '')
                   end
                   row << ("%.2f" % total).gsub('.',decimal_separator)
                   csv << row
                 end
                 export
               end
               def report_criteria_to_csv(csv, criterias, periods, hours, level=0)
                 decimal_separator = l(:general_csv_decimal_separator)
                 hours.collect {|h| h[criterias[level]].to_s}.uniq.each do |value|
                   hours_for_value = select_hours(hours, criterias[level], value)
                   next if hours_for_value.empty?
                   row = [''] * level
                   row << Redmine::CodesetUtil.from_utf8(
                                     format_criteria_value(criterias[level], value).to_s,
                                     l(:general_csv_encoding) )
                   row += [''] * (criterias.length - level - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours_for_value, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? ("%.2f" % sum).gsub('.',decimal_separator) : '')
                   end
                   row << ("%.2f" % total).gsub('.',decimal_separator)
                   csv << row
                   if criterias.length > level + 1
                     report_criteria_to_csv(csv, criterias, periods, hours_for_value, level + 1)
                   end
                 end
               end
             end

app/helpers/trackers_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 TrackersHelper
             end

app/helpers/users_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 UsersHelper
               def users_status_options_for_select(selected)
                 user_count_by_status = User.count(:group => 'status').to_hash
                 options_for_select([[l(:label_all), ''],
                                     ["#{l(:status_active)} (#{user_count_by_status[1].to_i})", 1],
                                     ["#{l(:status_registered)} (#{user_count_by_status[2].to_i})", 2],
                                     ["#{l(:status_locked)} (#{user_count_by_status[3].to_i})", 3]], selected)
               end
               # Options for the new membership projects combo-box
               def options_for_membership_project_select(user, projects)
                 options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")
                 options << project_tree_options_for_select(projects) do |p|
                   {:disabled => (user.projects.include?(p))}
                 end
                 options
               end
               def user_mail_notification_options(user)
                 user.valid_notification_options.collect {|o| [l(o.last), o.first]}
               end
               def change_status_link(user)
                 url = {:controller => 'users', :action => 'update', :id => user, :page => params[:page], :status => params[:status], :tab => nil}
                 if user.locked?
                   link_to l(:button_unlock), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :put, :class => 'icon icon-unlock'
                 elsif user.registered?
                   link_to l(:button_activate), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :put, :class => 'icon icon-unlock'
                 elsif user != User.current
                   link_to l(:button_lock), url.merge(:user => {:status => User::STATUS_LOCKED}), :method => :put, :class => 'icon icon-lock'
                 end
               end
               def user_settings_tabs
                 tabs = [{:name => 'general', :partial => 'users/general', :label => :label_general},
                         {:name => 'memberships', :partial => 'users/memberships', :label => :label_project_plural}
                         ]
                 if Group.all.any?
                   tabs.insert 1, {:name => 'groups', :partial => 'users/groups', :label => :label_group_plural}
                 end
                 tabs
               end
             end

app/helpers/versions_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 VersionsHelper
               STATUS_BY_CRITERIAS = %w(category tracker status priority author assigned_to)
               def render_issue_status_by(version, criteria)
                 criteria = 'category' unless STATUS_BY_CRITERIAS.include?(criteria)
                 h = Hash.new {|k,v| k[v] = [0, 0]}
                 begin
                   # Total issue count
                   Issue.count(:group => criteria,
                               :conditions => ["#{Issue.table_name}.fixed_version_id = ?", version.id]).each {|c,s| h[c][0] = s}
                   # Open issues count
                   Issue.count(:group => criteria,
                               :include => :status,
                               :conditions => ["#{Issue.table_name}.fixed_version_id = ? AND #{IssueStatus.table_name}.is_closed = ?", version.id, false]).each {|c,s| h[c][1] = s}
                 rescue ActiveRecord::RecordNotFound
                 # When grouping by an association, Rails throws this exception if there's no result (bug)
                 end
                 counts = h.keys.compact.sort.collect {|k| {:group => k, :total => h[k][0], :open => h[k][1], :closed => (h[k][0] - h[k][1])}}
                 max = counts.collect {|c| c[:total]}.max
                 render :partial => 'issue_counts', :locals => {:version => version, :criteria => criteria, :counts => counts, :max => max}
               end
               def status_by_options_for_select(value)
                 options_for_select(STATUS_BY_CRITERIAS.collect {|criteria| [l("field_#{criteria}".to_sym), criteria]}, value)
               end
             end

app/helpers/watchers_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 WatchersHelper
               def watcher_tag(object, user, options={})
                 content_tag("span", watcher_link(object, user), :class => watcher_css(object))
               end
               def watcher_link(object, user)
                 return '' unless user && user.logged? && object.respond_to?('watched_by?')
                 watched = object.watched_by?(user)
                 url = {:controller => 'watchers',
                        :action => (watched ? 'unwatch' : 'watch'),
                        :object_type => object.class.to_s.underscore,
                        :object_id => object.id}
                 link_to_remote((watched ? l(:button_unwatch) : l(:button_watch)),
                                {:url => url},
                                :href => url_for(url),
                                :class => (watched ? 'icon icon-fav' : 'icon icon-fav-off'))
               end
               # Returns the css class used to identify watch links for a given +object+
               def watcher_css(object)
                 "#{object.class.to_s.underscore}-#{object.id}-watcher"
               end
               # Returns a comma separated list of users watching the given object
               def watchers_list(object)
                 remove_allowed = User.current.allowed_to?("delete_#{object.class.name.underscore}_watchers".to_sym, object.project)
                 lis = object.watcher_users.collect do |user|
                   s = avatar(user, :size => "16").to_s + link_to_user(user, :class => 'user').to_s
                   if remove_allowed
                     url = {:controller => 'watchers',
                            :action => 'destroy',
                            :object_type => object.class.to_s.underscore,
                            :object_id => object.id,
                            :user_id => user}
                     s += ' ' + link_to_remote(image_tag('delete.png'),
                                               {:url => url},
                                               :href => url_for(url),
                                               :style => "vertical-align: middle",
                                               :class => "delete")
                   end
                   "<li>#{ s }</li>"
                 end
                 lis.empty? ? "" : "<ul>#{ lis.join("\n") }</ul>"
               end
             end

app/helpers/welcome_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 WelcomeHelper
             end

app/helpers/wiki_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 WikiHelper
               def wiki_page_options_for_select(pages, selected = nil, parent = nil, level = 0)
                 pages = pages.group_by(&:parent) unless pages.is_a?(Hash)
                 s = ''
                 if pages.has_key?(parent)
                   pages[parent].each do |page|
                     attrs = "value='#{page.id}'"
                     attrs << " selected='selected'" if selected == page
                     indent = (level > 0) ? ('&nbsp;' * level * 2 + '&#187; ') : nil
                     s << "<option #{attrs}>#{indent}#{h page.pretty_title}</option>\n" +
                            wiki_page_options_for_select(pages, selected, page, level + 1)
                   end
                 end
                 s
               end
               def wiki_page_breadcrumb(page)
                 breadcrumb(page.ancestors.reverse.collect {|parent|
                   link_to(h(parent.pretty_title), {:controller => 'wiki', :action => 'show', :id => parent.title, :project_id => parent.project})
                 })
               end
             end

app/helpers/workflows_helper.rb +2 0

+            # encoding: utf-8
+            #
             # Redmine - project management software
             # Copyright (C) 2006-2011  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 WorkflowsHelper
             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