jro_apps/redmine Commit - r14954:42b5c332b2c2

Lists can be reordered with drag and drop (#12909)....

Jean-Philippe Lang -

r14954:42b5c332b2c2

parent child

Context file:

r14954:42b5c332b2c2

Collapse all files

app/controllers/custom_fields_controller.rb +11 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              class CustomFieldsController < ApplicationController
                layout 'admin'
                before_filter :require_admin
                before_filter :build_new_custom_field, :only => [:new, :create]
                before_filter :find_custom_field, :only => [:edit, :update, :destroy]
                accept_api_auth :index
                def index
                  respond_to do |format|
                    format.html {
                      @custom_fields_by_type = CustomField.all.group_by {|f| f.class.name }
                    }
                    format.api {
                      @custom_fields = CustomField.all
                    }
                  end
                end
                def new
                  @custom_field.field_format = 'string' if @custom_field.field_format.blank?
                  @custom_field.default_value = nil
                end
                def create
                  if @custom_field.save
                    flash[:notice] = l(:notice_successful_create)
                    call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)
                    redirect_to edit_custom_field_path(@custom_field)
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  if @custom_field.update_attributes(params[:custom_field])
-                   flash[:notice] = l(:notice_successful_update)
                    call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)
-                   redirect_back_or_default edit_custom_field_path(@custom_field)
+                   respond_to do |format|
+                     format.html {
+                       flash[:notice] = l(:notice_successful_update)
+                       redirect_back_or_default edit_custom_field_path(@custom_field)
+                     }
+                     format.js { render :nothing => true }
+                   end
                  else
-                   render :action => 'edit'
+                   respond_to do |format|
+                     format.html { render :action => 'edit' }
+                     format.js { render :nothing => true, :status => 422 }
+                   end
                  end
                end
                def destroy
                  begin
                    @custom_field.destroy
                  rescue
                    flash[:error] = l(:error_can_not_delete_custom_field)
                  end
                  redirect_to custom_fields_path(:tab => @custom_field.class.name)
                end
                private
                def build_new_custom_field
                  @custom_field = CustomField.new_subclass_instance(params[:type], params[:custom_field])
                  if @custom_field.nil?
                    render :action => 'select_type'
                  end
                end
                def find_custom_field
                  @custom_field = CustomField.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/enumerations_controller.rb +11 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              class EnumerationsController < ApplicationController
                layout 'admin'
                before_filter :require_admin, :except => :index
                before_filter :require_admin_or_api_request, :only => :index
                before_filter :build_new_enumeration, :only => [:new, :create]
                before_filter :find_enumeration, :only => [:edit, :update, :destroy]
                accept_api_auth :index
                helper :custom_fields
                def index
                  respond_to do |format|
                    format.html
                    format.api {
                      @klass = Enumeration.get_subclass(params[:type])
                      if @klass
                        @enumerations = @klass.shared.sorted.to_a
                      else
                        render_404
                      end
                    }
                  end
                end
                def new
                end
                def create
                  if request.post? && @enumeration.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to enumerations_path
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  if @enumeration.update_attributes(params[:enumeration])
-                   flash[:notice] = l(:notice_successful_update)
-                   redirect_to enumerations_path
+                   respond_to do |format|
+                     format.html {
+                       flash[:notice] = l(:notice_successful_update)
+                       redirect_to enumerations_path
+                     }
+                     format.js { render :nothing => true }
+                   end
                  else
-                   render :action => 'edit'
+                   respond_to do |format|
+                     format.html { render :action => 'edit' }
+                     format.js { render :nothing => true, :status => 422 }
+                   end
                  end
                end
                def destroy
                  if !@enumeration.in_use?
                    # No associated objects
                    @enumeration.destroy
                    redirect_to enumerations_path
                    return
                  elsif params[:reassign_to_id].present? && (reassign_to = @enumeration.class.find_by_id(params[:reassign_to_id].to_i))
                    @enumeration.destroy(reassign_to)
                    redirect_to enumerations_path
                    return
                  end
                  @enumerations = @enumeration.class.system.to_a - [@enumeration]
                end
                private
                def build_new_enumeration
                  class_name = params[:enumeration] && params[:enumeration][:type] || params[:type]
                  @enumeration = Enumeration.new_subclass_instance(class_name, params[:enumeration])
                  if @enumeration.nil?
                    render_404
                  end
                end
                def find_enumeration
                  @enumeration = Enumeration.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/issue_statuses_controller.rb +11 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              class IssueStatusesController < ApplicationController
                layout 'admin'
                before_filter :require_admin, :except => :index
                before_filter :require_admin_or_api_request, :only => :index
                accept_api_auth :index
                def index
                  @issue_statuses = IssueStatus.sorted.to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.api
                  end
                end
                def new
                  @issue_status = IssueStatus.new
                end
                def create
                  @issue_status = IssueStatus.new(params[:issue_status])
                  if @issue_status.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to issue_statuses_path
                  else
                    render :action => 'new'
                  end
                end
                def edit
                  @issue_status = IssueStatus.find(params[:id])
                end
                def update
                  @issue_status = IssueStatus.find(params[:id])
                  if @issue_status.update_attributes(params[:issue_status])
-                   flash[:notice] = l(:notice_successful_update)
-                   redirect_to issue_statuses_path(:page => params[:page])
+                   respond_to do |format|
+                     format.html {
+                       flash[:notice] = l(:notice_successful_update)
+                       redirect_to issue_statuses_path(:page => params[:page])
+                     }
+                     format.js { render :nothing => true }
+                   end
                  else
-                   render :action => 'edit'
+                   respond_to do |format|
+                     format.html { render :action => 'edit' }
+                     format.js { render :nothing => true, :status => 422 }
+                   end
                  end
                end
                def destroy
                  IssueStatus.find(params[:id]).destroy
                  redirect_to issue_statuses_path
                rescue
                  flash[:error] = l(:error_unable_delete_issue_status)
                  redirect_to issue_statuses_path
                end
                def update_issue_done_ratio
                  if request.post? && IssueStatus.update_issue_done_ratios
                    flash[:notice] = l(:notice_issue_done_ratios_updated)
                  else
                    flash[:error] =  l(:error_issue_done_ratios_not_updated)
                  end
                  redirect_to issue_statuses_path
                end
              end

app/controllers/roles_controller.rb +11 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              class RolesController < ApplicationController
                layout 'admin'
                before_filter :require_admin, :except => [:index, :show]
                before_filter :require_admin_or_api_request, :only => [:index, :show]
                before_filter :find_role, :only => [:show, :edit, :update, :destroy]
                accept_api_auth :index, :show
                require_sudo_mode :create, :update, :destroy
                def index
                  respond_to do |format|
                    format.html {
                      @roles = Role.sorted.to_a
                      render :layout => false if request.xhr?
                    }
                    format.api {
                      @roles = Role.givable.to_a
                    }
                  end
                end
                def show
                  respond_to do |format|
                    format.api
                  end
                end
                def new
                  # Prefills the form with 'Non member' role permissions by default
                  @role = Role.new(params[:role] || {:permissions => Role.non_member.permissions})
                  if params[:copy].present? && @copy_from = Role.find_by_id(params[:copy])
                    @role.copy_from(@copy_from)
                  end
                  @roles = Role.sorted.to_a
                end
                def create
                  @role = Role.new(params[:role])
                  if request.post? && @role.save
                    # workflow copy
                    if !params[:copy_workflow_from].blank? && (copy_from = Role.find_by_id(params[:copy_workflow_from]))
                      @role.workflow_rules.copy(copy_from)
                    end
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to roles_path
                  else
                    @roles = Role.sorted.to_a
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  if @role.update_attributes(params[:role])
-                   flash[:notice] = l(:notice_successful_update)
-                   redirect_to roles_path(:page => params[:page])
+                   respond_to do |format|
+                     format.html {
+                       flash[:notice] = l(:notice_successful_update)
+                       redirect_to roles_path(:page => params[:page])
+                     }
+                     format.js { render :nothing => true }
+                   end
                  else
-                   render :action => 'edit'
+                   respond_to do |format|
+                     format.html { render :action => 'edit' }
+                     format.js { render :nothing => true, :status => 422 }
+                   end
                  end
                end
                def destroy
                  @role.destroy
                  redirect_to roles_path
                rescue
                  flash[:error] =  l(:error_can_not_remove_role)
                  redirect_to roles_path
                end
                def permissions
                  @roles = Role.sorted.to_a
                  @permissions = Redmine::AccessControl.permissions.select { |p| !p.public? }
                  if request.post?
                    @roles.each do |role|
                      role.permissions = params[:permissions][role.id.to_s]
                      role.save
                    end
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to roles_path
                  end
                end
                private
                def find_role
                  @role = Role.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/trackers_controller.rb +15 -5

              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              class TrackersController < ApplicationController
                layout 'admin'
                before_filter :require_admin, :except => :index
                before_filter :require_admin_or_api_request, :only => :index
                accept_api_auth :index
                def index
                  @trackers = Tracker.sorted.to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.api
                  end
                end
                def new
                  @tracker ||= Tracker.new(params[:tracker])
                  @trackers = Tracker.sorted.to_a
                  @projects = Project.all
                end
                def create
                  @tracker = Tracker.new(params[:tracker])
                  if @tracker.save
                    # workflow copy
                    if !params[:copy_workflow_from].blank? && (copy_from = Tracker.find_by_id(params[:copy_workflow_from]))
                      @tracker.workflow_rules.copy(copy_from)
                    end
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to trackers_path
                    return
                  end
                  new
                  render :action => 'new'
                end
                def edit
                  @tracker ||= Tracker.find(params[:id])
                  @projects = Project.all
                end
                def update
                  @tracker = Tracker.find(params[:id])
                  if @tracker.update_attributes(params[:tracker])
-                   flash[:notice] = l(:notice_successful_update)
-                   redirect_to trackers_path(:page => params[:page])
-                   return
+                   respond_to do |format|
+                     format.html {
+                       flash[:notice] = l(:notice_successful_update)
+                       redirect_to trackers_path(:page => params[:page])
+                     }
+                     format.js { render :nothing => true }
+                   end
+                 else
+                   respond_to do |format|
+                     format.html {
+                       edit
+                       render :action => 'edit'
+                     }
+                     format.js { render :nothing => true, :status => 422 }
+                   end
                  end
-                 edit
-                 render :action => 'edit'
                end
                def destroy
                  @tracker = Tracker.find(params[:id])
                  unless @tracker.issues.empty?
                    flash[:error] = l(:error_can_not_delete_tracker)
                  else
                    @tracker.destroy
                  end
                  redirect_to trackers_path
                end
                def fields
                  if request.post? && params[:trackers]
                    params[:trackers].each do |tracker_id, tracker_params|
                      tracker = Tracker.find_by_id(tracker_id)
                      if tracker
                        tracker.core_fields = tracker_params[:core_fields]
                        tracker.custom_field_ids = tracker_params[:custom_field_ids]
                        tracker.save
                      end
                    end
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to fields_trackers_path
                    return
                  end
                  @trackers = Tracker.sorted.to_a
                  @custom_fields = IssueCustomField.all.sort
                end
              end

app/helpers/application_helper.rb +10 0

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2016  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 'forwardable'
              require 'cgi'
              module ApplicationHelper
                include Redmine::WikiFormatting::Macros::Definitions
                include Redmine::I18n
                include GravatarHelper::PublicMethods
                include Redmine::Pagination::Helper
                include Redmine::SudoMode::Helper
                include Redmine::Themes::Helper
                include Redmine::Hook::Helper
                extend Forwardable
                def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
                # Return true if user is authorized for controller/action, otherwise false
                def authorize_for(controller, action)
                  User.current.allowed_to?({:controller => controller, :action => action}, @project)
                end
                # Display a link if user is authorized
                #
                # @param [String] name Anchor text (passed to link_to)
                # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
                # @param [optional, Hash] html_options Options passed to link_to
                # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
                def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                  link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
                end
                # Displays a link to user's account page if active
                def link_to_user(user, options={})
                  if user.is_a?(User)
                    name = h(user.name(options[:format]))
                    if user.active? || (User.current.admin? && user.logged?)
                      link_to name, user_path(user), :class => user.css_classes
                    else
                      name
                    end
                  else
                    h(user.to_s)
                  end
                end
                # Displays a link to +issue+ with its subject.
                # Examples:
                #
                #   link_to_issue(issue)                        # => Defect #6: This is the subject
                #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
                #   link_to_issue(issue, :subject => false)     # => Defect #6
                #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
                #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6
                #
                def link_to_issue(issue, options={})
                  title = nil
                  subject = nil
                  text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"
                  if options[:subject] == false
                    title = issue.subject.truncate(60)
                  else
                    subject = issue.subject
                    if truncate_length = options[:truncate]
                      subject = subject.truncate(truncate_length)
                    end
                  end
                  only_path = options[:only_path].nil? ? true : options[:only_path]
                  s = link_to(text, issue_url(issue, :only_path => only_path),
                              :class => issue.css_classes, :title => title)
                  s << h(": #{subject}") if subject
                  s = h("#{issue.project} - ") + s if options[:project]
                  s
                end
                # Generates a link to an attachment.
                # Options:
                # * :text - Link text (default to attachment filename)
                # * :download - Force download (default: false)
                def link_to_attachment(attachment, options={})
                  text = options.delete(:text) || attachment.filename
                  route_method = options.delete(:download) ? :download_named_attachment_url : :named_attachment_url
                  html_options = options.slice!(:only_path)
                  options[:only_path] = true unless options.key?(:only_path)
                  url = send(route_method, attachment, attachment.filename, options)
                  link_to text, url, html_options
                end
                # Generates a link to a SCM revision
                # Options:
                # * :text - Link text (default to the formatted revision)
                def link_to_revision(revision, repository, options={})
                  if repository.is_a?(Project)
                    repository = repository.repository
                  end
                  text = options.delete(:text) || format_revision(revision)
                  rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                  link_to(
                      h(text),
                      {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                      :title => l(:label_revision_id, format_revision(revision)),
                      :accesskey => options[:accesskey]
                    )
                end
                # Generates a link to a message
                def link_to_message(message, options={}, html_options = nil)
                  link_to(
                    message.subject.truncate(60),
                    board_message_url(message.board_id, message.parent_id || message.id, {
                      :r => (message.parent_id && message.id),
                      :anchor => (message.parent_id ? "message-#{message.id}" : nil),
                      :only_path => true
                    }.merge(options)),
                    html_options
                  )
                end
                # Generates a link to a project if active
                # Examples:
                #
                #   link_to_project(project)                          # => link to the specified project overview
                #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
                #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
                #
                def link_to_project(project, options={}, html_options = nil)
                  if project.archived?
                    h(project.name)
                  else
                    link_to project.name,
                      project_url(project, {:only_path => true}.merge(options)),
                      html_options
                  end
                end
                # Generates a link to a project settings if active
                def link_to_project_settings(project, options={}, html_options=nil)
                  if project.active?
                    link_to project.name, settings_project_path(project, options), html_options
                  elsif project.archived?
                    h(project.name)
                  else
                    link_to project.name, project_path(project, options), html_options
                  end
                end
                # Generates a link to a version
                def link_to_version(version, options = {})
                  return '' unless version && version.is_a?(Version)
                  options = {:title => format_date(version.effective_date)}.merge(options)
                  link_to_if version.visible?, format_version_name(version), version_path(version), options
                end
                # Helper that formats object for html or text rendering
                def format_object(object, html=true, &block)
                  if block_given?
                    object = yield object
                  end
                  case object.class.name
                  when 'Array'
                    object.map {|o| format_object(o, html)}.join(', ').html_safe
                  when 'Time'
                    format_time(object)
                  when 'Date'
                    format_date(object)
                  when 'Fixnum'
                    object.to_s
                  when 'Float'
                    sprintf "%.2f", object
                  when 'User'
                    html ? link_to_user(object) : object.to_s
                  when 'Project'
                    html ? link_to_project(object) : object.to_s
                  when 'Version'
                    html ? link_to_version(object) : object.to_s
                  when 'TrueClass'
                    l(:general_text_Yes)
                  when 'FalseClass'
                    l(:general_text_No)
                  when 'Issue'
                    object.visible? && html ? link_to_issue(object) : "##{object.id}"
                  when 'CustomValue', 'CustomFieldValue'
                    if object.custom_field
                      f = object.custom_field.format.formatted_custom_value(self, object, html)
                      if f.nil? || f.is_a?(String)
                        f
                      else
                        format_object(f, html, &block)
                      end
                    else
                      object.value.to_s
                    end
                  else
                    html ? h(object) : object.to_s
                  end
                end
                def wiki_page_path(page, options={})
                  url_for({:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title}.merge(options))
                end
                def thumbnail_tag(attachment)
                  link_to image_tag(thumbnail_path(attachment)),
                    named_attachment_path(attachment, attachment.filename),
                    :title => attachment.filename
                end
                def toggle_link(name, id, options={})
                  onclick = "$('##{id}').toggle(); "
                  onclick << (options[:focus] ? "$('##{options[:focus]}').focus(); " : "this.blur(); ")
                  onclick << "return false;"
                  link_to(name, "#", :onclick => onclick)
                end
                def format_activity_title(text)
                  h(truncate_single_line_raw(text, 100))
                end
                def format_activity_day(date)
                  date == User.current.today ? l(:label_today).titleize : format_date(date)
                end
                def format_activity_description(text)
                  h(text.to_s.truncate(120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                     ).gsub(/[\r\n]+/, "<br />").html_safe
                end
                def format_version_name(version)
                  if version.project == @project
                    h(version)
                  else
                    h("#{version.project} - #{version}")
                  end
                end
                def due_date_distance_in_words(date)
                  if date
                    l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                  end
                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_nested_lists(projects, &block)
                  s = ''
                  if projects.any?
                    ancestors = []
                    original_project = @project
                    projects.sort_by(&:lft).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}'>"
                      s << h(block_given? ? capture(project, &block) : project.name)
                      s << "</div>\n"
                      ancestors << project
                    end
                    s << ("</li></ul>\n" * ancestors.size)
                    @project = original_project
                  end
                  s.html_safe
                end
                def render_page_hierarchy(pages, node=nil, options={})
                  content = ''
                  if pages[node]
                    content << "<ul class=\"pages-hierarchy\">\n"
                    pages[node].each do |page|
                      content << "<li>"
                      content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title, :version => nil},
                                         :title => (options[:timestamp] && page.updated_on ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                      content << "\n" + render_page_hierarchy(pages, page.id, options) if pages[page.id]
                      content << "</li>\n"
                    end
                    content << "</ul>\n"
                  end
                  content.html_safe
                end
                # Renders flash messages
                def render_flash_messages
                  s = ''
                  flash.each do |k,v|
                    s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")
                  end
                  s.html_safe
                end
                # Renders tabs and their content
                def render_tabs(tabs, selected=params[:tab])
                  if tabs.any?
                    unless tabs.detect {|tab| tab[:name] == selected}
                      selected = nil
                    end
                    selected ||= tabs.first[:name]
                    render :partial => 'common/tabs', :locals => {:tabs => tabs, :selected_tab => selected}
                  else
                    content_tag 'p', l(:label_no_data), :class => "nodata"
                  end
                end
                # Renders the project quick-jump box
                def render_project_jump_box
                  return unless User.current.logged?
                  projects = User.current.projects.active.select(:id, :name, :identifier, :lft, :rgt).to_a
                  if projects.any?
                    options =
                      ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                       '<option value="" disabled="disabled">---</option>').html_safe
                    options << project_tree_options_for_select(projects, :selected => @project) do |p|
                      { :value => project_path(:id => p, :jump => current_menu_item) }
                    end
                    content_tag( :span, nil, :class => 'jump-box-arrow') +
                    select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                  end
                end
                def project_tree_options_for_select(projects, options = {})
                  s = ''.html_safe
                  if blank_text = options[:include_blank]
                    if blank_text == true
                      blank_text = '&nbsp;'.html_safe
                    end
                    s << content_tag('option', blank_text, :value => '')
                  end
                  project_tree(projects) do |project, level|
                    name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                    tag_options = {:value => project.id}
                    if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                      tag_options[:selected] = 'selected'
                    else
                      tag_options[:selected] = nil
                    end
                    tag_options.merge!(yield(project)) if block_given?
                    s << content_tag('option', name_prefix + h(project), tag_options)
                  end
                  s.html_safe
                end
                # Yields the given block for each project with its level in the tree
                #
                # Wrapper for Project#project_tree
                def project_tree(projects, &block)
                  Project.project_tree(projects, &block)
                end
                def principals_check_box_tags(name, principals)
                  s = ''
                  principals.each do |principal|
                    s << "<label>#{ check_box_tag name, principal.id, false, :id => nil } #{h principal}</label>\n"
                  end
                  s.html_safe
                end
                # Returns a string for users/groups option tags
                def principals_options_for_select(collection, selected=nil)
                  s = ''
                  if collection.include?(User.current)
                    s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)
                  end
                  groups = ''
                  collection.sort.each do |element|
                    selected_attribute = ' selected="selected"' if option_value_selected?(element, selected) || element.id.to_s == selected
                    (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                  end
                  unless groups.empty?
                    s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                  end
                  s.html_safe
                end
                def option_tag(name, text, value, selected=nil, options={})
                  content_tag 'option', value, options.merge(:value => value, :selected => (value == selected))
                end
                def truncate_single_line_raw(string, length)
                  string.to_s.truncate(length).gsub(%r{[\r\n]+}m, ' ')
                end
                # Truncates at line break after 250 characters or options[:length]
                def truncate_lines(string, options={})
                  length = options[:length] || 250
                  if string.to_s =~ /\A(.{#{length}}.*?)$/m
                    "#{$1}..."
                  else
                    string
                  end
                end
                def anchor(text)
                  text.to_s.gsub(' ', '_')
                end
                def html_hours(text)
                  text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
                end
                def authoring(created, author, options={})
                  l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
                end
                def time_tag(time)
                  text = distance_of_time_in_words(Time.now, time)
                  if @project
                    link_to(text, project_activity_path(@project, :from => User.current.time_to_date(time)), :title => format_time(time))
                  else
                    content_tag('abbr', text, :title => format_time(time))
                  end
                end
                def syntax_highlight_lines(name, content)
                  lines = []
                  syntax_highlight(name, content).each_line { |line| lines << line }
                  lines
                end
                def syntax_highlight(name, content)
                  Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
                end
                def to_path_param(path)
                  str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                  str.blank? ? nil : str
                end
                def reorder_links(name, url, method = :post)
                  link_to(l(:label_sort_highest),
                          url.merge({"#{name}[move_to]" => 'highest'}), :method => method,
                          :title => l(:label_sort_highest), :class => 'icon-only icon-move-top') +
                  link_to(l(:label_sort_higher),
                          url.merge({"#{name}[move_to]" => 'higher'}), :method => method,
                          :title => l(:label_sort_higher), :class => 'icon-only icon-move-up') +
                  link_to(l(:label_sort_lower),
                          url.merge({"#{name}[move_to]" => 'lower'}), :method => method,
                          :title => l(:label_sort_lower), :class => 'icon-only icon-move-down') +
                  link_to(l(:label_sort_lowest),
                          url.merge({"#{name}[move_to]" => 'lowest'}), :method => method,
                          :title => l(:label_sort_lowest), :class => 'icon-only icon-move-bottom')
                end
+               def reorder_handle(object, options={})
+                 data = {
+                   :reorder_url => options[:url] || url_for(object),
+                   :reorder_param => options[:param] || object.class.name.underscore
+                 }
+                 content_tag('span', '',
+                   :class => "sort-handle ui-icon ui-icon-arrowthick-2-n-s",
+                   :data => data)
+               end
                def breadcrumb(*args)
                  elements = args.flatten
                  elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
                end
                def other_formats_links(&block)
                  concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                  yield Redmine::Views::OtherFormatsBuilder.new(self)
                  concat('</p>'.html_safe)
                end
                def page_header_title
                  if @project.nil? || @project.new_record?
                    h(Setting.app_title)
                  else
                    b = []
                    ancestors = (@project.root? ? [] : @project.ancestors.visible.to_a)
                    if ancestors.any?
                      root = ancestors.shift
                      b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                      if ancestors.size > 2
                        b << "\xe2\x80\xa6"
                        ancestors = ancestors[-2, 2]
                      end
                      b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                    end
                    b << content_tag(:span, h(@project), class: 'current-project')
                    if b.size > 1
                      separator = content_tag(:span, ' &raquo; '.html_safe, class: 'separator')
                      path = safe_join(b[0..-2], separator) + separator
                      b = [content_tag(:span, path.html_safe, class: 'breadcrumbs'), b[-1]]
                    end
                    safe_join b
                  end
                end
                # Returns a h2 tag and sets the html title with the given arguments
                def title(*args)
                  strings = args.map do |arg|
                    if arg.is_a?(Array) && arg.size >= 2
                      link_to(*arg)
                    else
                      h(arg.to_s)
                    end
                  end
                  html_title args.reverse.map {|s| (s.is_a?(Array) ? s.first : s).to_s}
                  content_tag('h2', strings.join(' &#187; ').html_safe)
                end
                # Sets the html title
                # Returns the html title when called without arguments
                # Current project name and app_title and automatically appended
                # Exemples:
                #   html_title 'Foo', 'Bar'
                #   html_title # => 'Foo - Bar - My Project - Redmine'
                def html_title(*args)
                  if args.empty?
                    title = @html_title || []
                    title << @project.name if @project
                    title << Setting.app_title unless Setting.app_title == title.last
                    title.reject(&:blank?).join(' - ')
                  else
                    @html_title ||= []
                    @html_title += args
                  end
                end
                # Returns the theme, controller name, and action as css classes for the
                # HTML body.
                def body_css_classes
                  css = []
                  if theme = Redmine::Themes.theme(Setting.ui_theme)
                    css << 'theme-' + theme.name
                  end
                  css << 'project-' + @project.identifier if @project && @project.identifier.present?
                  css << 'controller-' + controller_name
                  css << 'action-' + action_name
                  css.join(' ')
                end
                def accesskey(s)
                  @used_accesskeys ||= []
                  key = Redmine::AccessKeys.key_for(s)
                  return nil if @used_accesskeys.include?(key)
                  @used_accesskeys << key
                  key
                end
                # Formats text according to system settings.
                # 2 ways to call this method:
                # * with a String: textilizable(text, options)
                # * with an object and one of its attribute: textilizable(issue, :description, options)
                def textilizable(*args)
                  options = args.last.is_a?(Hash) ? args.pop : {}
                  case args.size
                  when 1
                    obj = options[:object]
                    text = args.shift
                  when 2
                    obj = args.shift
                    attr = args.shift
                    text = obj.send(attr).to_s
                  else
                    raise ArgumentError, 'invalid arguments to textilizable'
                  end
                  return '' if text.blank?
                  project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                  @only_path = only_path = options.delete(:only_path) == false ? false : true
                  text = text.dup
                  macros = catch_macros(text)
                  text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr)
                  @parsed_headings = []
                  @heading_anchors = {}
                  @current_section = 0 if options[:edit_section_links]
                  parse_sections(text, project, obj, attr, only_path, options)
                  text = parse_non_pre_blocks(text, obj, macros) do |text|
                    [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links].each do |method_name|
                      send method_name, text, project, obj, attr, only_path, options
                    end
                  end
                  parse_headings(text, project, obj, attr, only_path, options)
                  if @parsed_headings.any?
                    replace_toc(text, @parsed_headings)
                  end
                  text.html_safe
                end
                def parse_non_pre_blocks(text, obj, macros)
                  s = StringScanner.new(text)
                  tags = []
                  parsed = ''
                  while !s.eos?
                    s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                    text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                    if tags.empty?
                      yield text
                      inject_macros(text, obj, macros) if macros.any?
                    else
                      inject_macros(text, obj, macros, false) if macros.any?
                    end
                    parsed << text
                    if tag
                      if closing
                        if tags.last && tags.last.casecmp(tag) == 0
                          tags.pop
                        end
                      else
                        tags << tag.downcase
                      end
                      parsed << full_tag
                    end
                  end
                  # Close any non closing tags
                  while tag = tags.pop
                    parsed << "</#{tag}>"
                  end
                  parsed
                end
                def parse_inline_attachments(text, project, obj, attr, only_path, options)
                  return if options[:inline_attachments] == false
                  # when using an image link, try to use an attachment, if possible
                  attachments = options[:attachments] || []
                  attachments += obj.attachments if obj.respond_to?(:attachments)
                  if attachments.present?
                    text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                      filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                      # search for the picture in attachments
                      if found = Attachment.latest_attach(attachments, CGI.unescape(filename))
                        image_url = download_named_attachment_url(found, found.filename, :only_path => only_path)
                        desc = found.description.to_s.gsub('"', '')
                        if !desc.blank? && alttext.blank?
                          alt = " title=\"#{desc}\" alt=\"#{desc}\""
                        end
                        "src=\"#{image_url}\"#{alt}"
                      else
                        m
                      end
                    end
                  end
                end
                # Wiki links
                #
                # Examples:
                #   [[mypage]]
                #   [[mypage|mytext]]
                # wiki links can refer other project wikis, using project name or identifier:
                #   [[project:]] -> wiki starting page
                #   [[project:|mytext]]
                #   [[project:mypage]]
                #   [[project:mypage|mytext]]
                def parse_wiki_links(text, project, obj, attr, only_path, options)
                  text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                    link_project = project
                    esc, all, page, title = $1, $2, $3, $5
                    if esc.nil?
                      if page =~ /^([^\:]+)\:(.*)$/
                        identifier, page = $1, $2
                        link_project = Project.find_by_identifier(identifier) || Project.find_by_name(identifier)
                        title ||= identifier if page.blank?
                      end
                      if link_project && link_project.wiki
                        # extract anchor
                        anchor = nil
                        if page =~ /^(.+?)\#(.+)$/
                          page, anchor = $1, $2
                        end
                        anchor = sanitize_anchor_name(anchor) if anchor.present?
                        # check if page exists
                        wiki_page = link_project.wiki.find_page(page)
                        url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                          "##{anchor}"
                        else
                          case options[:wiki_links]
                          when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                          when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                          else
                            wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                            parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                            url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                             :id => wiki_page_id, :version => nil, :anchor => anchor, :parent => parent)
                          end
                        end
                        link_to(title.present? ? title.html_safe : h(page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                      else
                        # project or wiki doesn't exist
                        all
                      end
                    else
                      all
                    end
                  end
                end
                # Redmine links
                #
                # Examples:
                #   Issues:
                #     #52 -> Link to issue #52
                #   Changesets:
                #     r52 -> Link to revision 52
                #     commit:a85130f -> Link to scmid starting with a85130f
                #   Documents:
                #     document#17 -> Link to document with id 17
                #     document:Greetings -> Link to the document with title "Greetings"
                #     document:"Some document" -> Link to the document with title "Some document"
                #   Versions:
                #     version#3 -> Link to version with id 3
                #     version:1.0.0 -> Link to version named "1.0.0"
                #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
                #   Attachments:
                #     attachment:file.zip -> Link to the attachment of the current object named file.zip
                #   Source files:
                #     source:some/file -> Link to the file located at /some/file in the project's repository
                #     source:some/file@52 -> Link to the file's revision 52
                #     source:some/file#L120 -> Link to line 120 of the file
                #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
                #     export:some/file -> Force the download of the file
                #   Forum messages:
                #     message#1218 -> Link to message with id 1218
                #  Projects:
                #     project:someproject -> Link to project named "someproject"
                #     project#3 -> Link to project with id 3
                #
                #   Links can refer other objects from other projects, using project identifier:
                #     identifier:r52
                #     identifier:document:"Some document"
                #     identifier:version:1.0.0
                #     identifier:source:some/file
                def parse_redmine_links(text, default_project, obj, attr, only_path, options)
                  text.gsub!(%r{<a( [^>]+?)?>(.*?)</a>|([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-_]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                    tag_content, leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $2, $3, $4, $5, $6, $7, $12, $13, $10 || $14 || $20, $16 || $21, $17, $19
                    if tag_content
                      $&
                    else
                      link = nil
                      project = default_project
                      if project_identifier
                        project = Project.visible.find_by_identifier(project_identifier)
                      end
                      if esc.nil?
                        if prefix.nil? && sep == 'r'
                          if project
                            repository = nil
                            if repo_identifier
                              repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                            else
                              repository = project.repository
                            end
                            # project.changesets.visible raises an SQL error because of a double join on repositories
                            if repository &&
                                 (changeset = Changeset.visible.
                                                  find_by_repository_id_and_revision(repository.id, identifier))
                              link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"),
                                             {:only_path => only_path, :controller => 'repositories',
                                              :action => 'revision', :id => project,
                                              :repository_id => repository.identifier_param,
                                              :rev => changeset.revision},
                                             :class => 'changeset',
                                             :title => truncate_single_line_raw(changeset.comments, 100))
                            end
                          end
                        elsif sep == '#'
                          oid = identifier.to_i
                          case prefix
                          when nil
                            if oid.to_s == identifier &&
                              issue = Issue.visible.find_by_id(oid)
                              anchor = comment_id ? "note-#{comment_id}" : nil
                              link = link_to("##{oid}#{comment_suffix}",
                                             issue_url(issue, :only_path => only_path, :anchor => anchor),
                                             :class => issue.css_classes,
                                             :title => "#{issue.tracker.name}: #{issue.subject.truncate(100)} (#{issue.status.name})")
                            end
                          when 'document'
                            if document = Document.visible.find_by_id(oid)
                              link = link_to(document.title, document_url(document, :only_path => only_path), :class => 'document')
                            end
                          when 'version'
                            if version = Version.visible.find_by_id(oid)
                              link = link_to(version.name, version_url(version, :only_path => only_path), :class => 'version')
                            end
                          when 'message'
                            if message = Message.visible.find_by_id(oid)
                              link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                            end
                          when 'forum'
                            if board = Board.visible.find_by_id(oid)
                              link = link_to(board.name, project_board_url(board.project, board, :only_path => only_path), :class => 'board')
                            end
                          when 'news'
                            if news = News.visible.find_by_id(oid)
                              link = link_to(news.title, news_url(news, :only_path => only_path), :class => 'news')
                            end
                          when 'project'
                            if p = Project.visible.find_by_id(oid)
                              link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                            end
                          end
                        elsif sep == ':'
                          # removes the double quotes if any
                          name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                          name = CGI.unescapeHTML(name)
                          case prefix
                          when 'document'
                            if project && document = project.documents.visible.find_by_title(name)
                              link = link_to(document.title, document_url(document, :only_path => only_path), :class => 'document')
                            end
                          when 'version'
                            if project && version = project.versions.visible.find_by_name(name)
                              link = link_to(version.name, version_url(version, :only_path => only_path), :class => 'version')
                            end
                          when 'forum'
                            if project && board = project.boards.visible.find_by_name(name)
                              link = link_to(board.name, project_board_url(board.project, board, :only_path => only_path), :class => 'board')
                            end
                          when 'news'
                            if project && news = project.news.visible.find_by_title(name)
                              link = link_to(news.title, news_url(news, :only_path => only_path), :class => 'news')
                            end
                          when 'commit', 'source', 'export'
                            if project
                              repository = nil
                              if name =~ %r{^(([a-z0-9\-_]+)\|)(.+)$}
                                repo_prefix, repo_identifier, name = $1, $2, $3
                                repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                              else
                                repository = project.repository
                              end
                              if prefix == 'commit'
                                if repository && (changeset = Changeset.visible.where("repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%").first)
                                  link = link_to h("#{project_prefix}#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.identifier},
                                                               :class => 'changeset',
                                                               :title => truncate_single_line_raw(changeset.comments, 100)
                                end
                              else
                                if repository && User.current.allowed_to?(:browse_repository, project)
                                  name =~ %r{^[/\\]*(.*?)(@([^/\\@]+?))?(#(L\d+))?$}
                                  path, rev, anchor = $1, $3, $5
                                  link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => (prefix == 'export' ? 'raw' : 'entry'), :id => project, :repository_id => repository.identifier_param,
                                                                          :path => to_path_param(path),
                                                                          :rev => rev,
                                                                          :anchor => anchor},
                                                                         :class => (prefix == 'export' ? 'source download' : 'source')
                                end
                              end
                              repo_prefix = nil
                            end
                          when 'attachment'
                            attachments = options[:attachments] || []
                            attachments += obj.attachments if obj.respond_to?(:attachments)
                            if attachments && attachment = Attachment.latest_attach(attachments, name)
                              link = link_to_attachment(attachment, :only_path => only_path, :download => true, :class => 'attachment')
                            end
                          when 'project'
                            if p = Project.visible.where("identifier = :s OR LOWER(name) = :s", :s => name.downcase).first
                              link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                            end
                          end
                        end
                      end
                      (leading + (link || "#{project_prefix}#{prefix}#{repo_prefix}#{sep}#{identifier}#{comment_suffix}"))
                    end
                  end
                end
                HEADING_RE = /(<h(\d)( [^>]+)?>(.+?)<\/h(\d)>)/i unless const_defined?(:HEADING_RE)
                def parse_sections(text, project, obj, attr, only_path, options)
                  return unless options[:edit_section_links]
                  text.gsub!(HEADING_RE) do
                    heading, level = $1, $2
                    @current_section += 1
                    if @current_section > 1
                      content_tag('div',
                        link_to(l(:button_edit_section), options[:edit_section_links].merge(:section => @current_section),
                                :class => 'icon-only icon-edit'),
                        :class => "contextual heading-#{level}",
                        :title => l(:button_edit_section),
                        :id => "section-#{@current_section}") + heading.html_safe
                    else
                      heading
                    end
                  end
                end
                # Headings and TOC
                # Adds ids and links to headings unless options[:headings] is set to false
                def parse_headings(text, project, obj, attr, only_path, options)
                  return if options[:headings] == false
                  text.gsub!(HEADING_RE) do
                    level, attrs, content = $2.to_i, $3, $4
                    item = strip_tags(content).strip
                    anchor = sanitize_anchor_name(item)
                    # used for single-file wiki export
                    anchor = "#{obj.page.title}_#{anchor}" if options[:wiki_links] == :anchor && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version))
                    @heading_anchors[anchor] ||= 0
                    idx = (@heading_anchors[anchor] += 1)
                    if idx > 1
                      anchor = "#{anchor}-#{idx}"
                    end
                    @parsed_headings << [level, anchor, item]
                    "<a name=\"#{anchor}\"></a>\n<h#{level} #{attrs}>#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                  end
                end
                MACROS_RE = /(
                              (!)?                        # escaping
                              (
                              \{\{                        # opening tag
                              ([\w]+)                     # macro name
                              (\(([^\n\r]*?)\))?          # optional arguments
                              ([\n\r].*?[\n\r])?          # optional block of text
                              \}\}                        # closing tag
                              )
                             )/mx unless const_defined?(:MACROS_RE)
                MACRO_SUB_RE = /(
                                \{\{
                                macro\((\d+)\)
                                \}\}
                                )/x unless const_defined?(:MACRO_SUB_RE)
                # Extracts macros from text
                def catch_macros(text)
                  macros = {}
                  text.gsub!(MACROS_RE) do
                    all, macro = $1, $4.downcase
                    if macro_exists?(macro) || all =~ MACRO_SUB_RE
                      index = macros.size
                      macros[index] = all
                      "{{macro(#{index})}}"
                    else
                      all
                    end
                  end
                  macros
                end
                # Executes and replaces macros in text
                def inject_macros(text, obj, macros, execute=true)
                  text.gsub!(MACRO_SUB_RE) do
                    all, index = $1, $2.to_i
                    orig = macros.delete(index)
                    if execute && orig && orig =~ MACROS_RE
                      esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                      if esc.nil?
                        h(exec_macro(macro, obj, args, block) || all)
                      else
                        h(all)
                      end
                    elsif orig
                      h(orig)
                    else
                      h(all)
                    end
                  end
                end
                TOC_RE = /<p>\{\{((<|&lt;)|(>|&gt;))?toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
                # Renders the TOC with given headings
                def replace_toc(text, headings)
                  text.gsub!(TOC_RE) do
                    left_align, right_align = $2, $3
                    # Keep only the 4 first levels
                    headings = headings.select{|level, anchor, item| level <= 4}
                    if headings.empty?
                      ''
                    else
                      div_class = 'toc'
                      div_class << ' right' if right_align
                      div_class << ' left' if left_align
                      out = "<ul class=\"#{div_class}\"><li>"
                      root = headings.map(&:first).min
                      current = root
                      started = false
                      headings.each do |level, anchor, item|
                        if level > current
                          out << '<ul><li>' * (level - current)
                        elsif level < current
                          out << "</li></ul>\n" * (current - level) + "</li><li>"
                        elsif started
                          out << '</li><li>'
                        end
                        out << "<a href=\"##{anchor}\">#{item}</a>"
                        current = level
                        started = true
                      end
                      out << '</li></ul>' * (current - root)
                      out << '</li></ul>'
                    end
                  end
                end
                # Same as Rails' simple_format helper without using paragraphs
                def simple_format_without_paragraph(text)
                  text.to_s.
                    gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                    gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                    gsub(/([^\n]\n)(?=[^\n])/, '\1<br />'). # 1 newline   -> br
                    html_safe
                end
                def lang_options_for_select(blank=true)
                  (blank ? [["(auto)", ""]] : []) + languages_options
                end
                def labelled_form_for(*args, &proc)
                  args << {} unless args.last.is_a?(Hash)
                  options = args.last
                  if args.first.is_a?(Symbol)
                    options.merge!(:as => args.shift)
                  end
                  options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                  form_for(*args, &proc)
                end
                def labelled_fields_for(*args, &proc)
                  args << {} unless args.last.is_a?(Hash)
                  options = args.last
                  options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                  fields_for(*args, &proc)
                end
                def error_messages_for(*objects)
                  html = ""
                  objects = objects.map {|o| o.is_a?(String) ? instance_variable_get("@#{o}") : o}.compact
                  errors = objects.map {|o| o.errors.full_messages}.flatten
                  if errors.any?
                    html << "<div id='errorExplanation'><ul>\n"
                    errors.each do |error|
                      html << "<li>#{h error}</li>\n"
                    end
                    html << "</ul></div>\n"
                  end
                  html.html_safe
                end
                def delete_link(url, options={})
                  options = {
                    :method => :delete,
                    :data => {:confirm => l(:text_are_you_sure)},
                    :class => 'icon icon-del'
                  }.merge(options)
                  link_to l(:button_delete), url, options
                end
                def preview_link(url, form, target='preview', options={})
                  content_tag 'a', l(:label_preview), {
                      :href => "#",
                      :onclick => %|submitPreview("#{escape_javascript url_for(url)}", "#{escape_javascript form}", "#{escape_javascript target}"); return false;|,
                      :accesskey => accesskey(:preview)
                    }.merge(options)
                end
                def link_to_function(name, function, html_options={})
                  content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
                end
                # Helper to render JSON in views
                def raw_json(arg)
                  arg.to_json.to_s.gsub('/', '\/').html_safe
                end
                def back_url
                  url = params[:back_url]
                  if url.nil? && referer = request.env['HTTP_REFERER']
                    url = CGI.unescape(referer.to_s)
                  end
                  url
                end
                def back_url_hidden_field_tag
                  url = back_url
                  hidden_field_tag('back_url', url, :id => nil) unless url.blank?
                end
                def check_all_links(form_name)
                  link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                  " | ".html_safe +
                  link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
                end
                def toggle_checkboxes_link(selector)
                  link_to_function '',
                    "toggleCheckboxesBySelector('#{selector}')",
                    :title => "#{l(:button_check_all)} / #{l(:button_uncheck_all)}",
                    :class => 'toggle-checkboxes'
                end
                def progress_bar(pcts, options={})
                  pcts = [pcts, pcts] unless pcts.is_a?(Array)
                  pcts = pcts.collect(&:round)
                  pcts[1] = pcts[1] - pcts[0]
                  pcts << (100 - pcts[1] - pcts[0])
                  titles = options[:titles].to_a
                  titles[0] = "#{pcts[0]}%" if titles[0].blank?
                  legend = options[:legend] || ''
                  content_tag('table',
                    content_tag('tr',
                      (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0]}%;", :class => 'closed', :title => titles[0]) : ''.html_safe) +
                      (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done', :title => titles[1]) : ''.html_safe) +
                      (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo', :title => titles[2]) : ''.html_safe)
                    ), :class => "progress progress-#{pcts[0]}").html_safe +
                    content_tag('p', legend, :class => 'percent').html_safe
                end
                def checked_image(checked=true)
                  if checked
                    @checked_image_tag ||= content_tag(:span, nil, :class => 'icon-only icon-checked')
                  end
                end
                def context_menu(url)
                  unless @context_menu_included
                    content_for :header_tags do
                      javascript_include_tag('context_menu') +
                        stylesheet_link_tag('context_menu')
                    end
                    if l(:direction) == 'rtl'
                      content_for :header_tags do
                        stylesheet_link_tag('context_menu_rtl')
                      end
                    end
                    @context_menu_included = true
                  end
                  javascript_tag "contextMenuInit('#{ url_for(url) }')"
                end
                def calendar_for(field_id)
                  include_calendar_headers_tags
                  javascript_tag("$(function() { $('##{field_id}').addClass('date').datepicker(datepickerOptions); });")
                end
                def include_calendar_headers_tags
                  unless @calendar_headers_tags_included
                    tags = ''.html_safe
                    @calendar_headers_tags_included = true
                    content_for :header_tags do
                      start_of_week = Setting.start_of_week
                      start_of_week = l(:general_first_day_of_week, :default => '1') if start_of_week.blank?
                      # Redmine uses 1..7 (monday..sunday) in settings and locales
                      # JQuery uses 0..6 (sunday..saturday), 7 needs to be changed to 0
                      start_of_week = start_of_week.to_i % 7
                      tags << javascript_tag(
                                 "var datepickerOptions={dateFormat: 'yy-mm-dd', firstDay: #{start_of_week}, " +
                                   "showOn: 'button', buttonImageOnly: true, buttonImage: '" +
                                   path_to_image('/images/calendar.png') +
                                   "', showButtonPanel: true, showWeek: true, showOtherMonths: true, " +
                                   "selectOtherMonths: true, changeMonth: true, changeYear: true, " +
                                   "beforeShow: beforeShowDatePicker};")
                      jquery_locale = l('jquery.locale', :default => current_language.to_s)
                      unless jquery_locale == 'en'
                        tags << javascript_include_tag("i18n/datepicker-#{jquery_locale}.js")
                      end
                      tags
                    end
                  end
                end
                # Overrides Rails' stylesheet_link_tag with themes and plugins support.
                # Examples:
                #   stylesheet_link_tag('styles') # => picks styles.css from the current theme or defaults
                #   stylesheet_link_tag('styles', :plugin => 'foo) # => picks styles.css from plugin's assets
                #
                def stylesheet_link_tag(*sources)
                  options = sources.last.is_a?(Hash) ? sources.pop : {}
                  plugin = options.delete(:plugin)
                  sources = sources.map do |source|
                    if plugin
                      "/plugin_assets/#{plugin}/stylesheets/#{source}"
                    elsif current_theme && current_theme.stylesheets.include?(source)
                      current_theme.stylesheet_path(source)
                    else
                      source
                    end
                  end
                  super *sources, options
                end
                # Overrides Rails' image_tag with themes and plugins support.
                # Examples:
                #   image_tag('image.png') # => picks image.png from the current theme or defaults
                #   image_tag('image.png', :plugin => 'foo) # => picks image.png from plugin's assets
                #
                def image_tag(source, options={})
                  if plugin = options.delete(:plugin)
                    source = "/plugin_assets/#{plugin}/images/#{source}"
                  elsif current_theme && current_theme.images.include?(source)
                    source = current_theme.image_path(source)
                  end
                  super source, options
                end
                # Overrides Rails' javascript_include_tag with plugins support
                # Examples:
                #   javascript_include_tag('scripts') # => picks scripts.js from defaults
                #   javascript_include_tag('scripts', :plugin => 'foo) # => picks scripts.js from plugin's assets
                #
                def javascript_include_tag(*sources)
                  options = sources.last.is_a?(Hash) ? sources.pop : {}
                  if plugin = options.delete(:plugin)
                    sources = sources.map do |source|
                      if plugin
                        "/plugin_assets/#{plugin}/javascripts/#{source}"
                      else
                        source
                      end
                    end
                  end
                  super *sources, options
                end
                def sidebar_content?
                  content_for?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
                end
                def view_layouts_base_sidebar_hook_response
                  @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
                end
                def email_delivery_enabled?
                  !!ActionMailer::Base.perform_deliveries
                end
                # Returns the avatar image tag for the given +user+ if avatars are enabled
                # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
                def avatar(user, options = { })
                  if Setting.gravatar_enabled?
                    options.merge!(:default => Setting.gravatar_default)
                    email = nil
                    if user.respond_to?(:mail)
                      email = user.mail
                    elsif user.to_s =~ %r{<(.+?)>}
                      email = $1
                    end
                    return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                  else
                    ''
                  end
                end
                # Returns a link to edit user's avatar if avatars are enabled
                def avatar_edit_link(user, options={})
                  if Setting.gravatar_enabled?
                    url = "https://gravatar.com"
                    link_to avatar(user, {:title => l(:button_edit)}.merge(options)), url, :target => '_blank'
                  end
                end
                def sanitize_anchor_name(anchor)
                  anchor.gsub(%r{[^\s\-\p{Word}]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                end
                # Returns the javascript tags that are included in the html layout head
                def javascript_heads
                  tags = javascript_include_tag('jquery-1.11.1-ui-1.11.0-ujs-3.1.4', 'application', 'responsive')
                  unless User.current.pref.warn_on_leaving_unsaved == '0'
                    tags << "\n".html_safe + javascript_tag("$(window).load(function(){ warnLeavingUnsaved('#{escape_javascript l(:text_warn_on_leaving_unsaved)}'); });")
                  end
                  tags
                end
                def favicon
                  "<link rel='shortcut icon' href='#{favicon_path}' />".html_safe
                end
                # Returns the path to the favicon
                def favicon_path
                  icon = (current_theme && current_theme.favicon?) ? current_theme.favicon_path : '/favicon.ico'
                  image_path(icon)
                end
                # Returns the full URL to the favicon
                def favicon_url
                  # TODO: use #image_url introduced in Rails4
                  path = favicon_path
                  base = url_for(:controller => 'welcome', :action => 'index', :only_path => false)
                  base.sub(%r{/+$},'') + '/' + path.sub(%r{^/+},'')
                end
                def robot_exclusion_tag
                  '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
                end
                # Returns true if arg is expected in the API response
                def include_in_api_response?(arg)
                  unless @included_in_api_response
                    param = params[:include]
                    @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                    @included_in_api_response.collect!(&:strip)
                  end
                  @included_in_api_response.include?(arg.to_s)
                end
                # Returns options or nil if nometa param or X-Redmine-Nometa header
                # was set in the request
                def api_meta(options)
                  if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                    # compatibility mode for activeresource clients that raise
                    # an error when deserializing an array with attributes
                    nil
                  else
                    options
                  end
                end
                def generate_csv(&block)
                  decimal_separator = l(:general_csv_decimal_separator)
                  encoding = l(:general_csv_encoding)
                end
                private
                def wiki_helper
                  helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                  extend helper
                  return self
                end
                def link_to_content_update(text, url_params = {}, html_options = {})
                  link_to(text, url_params, html_options)
                end
              end

app/views/custom_fields/_index.html.erb +2 -3

-             <table class="list">
+             <table class="list custom_fields">
                <thead><tr>
                  <th><%=l(:field_name)%></th>
                  <th><%=l(:field_field_format)%></th>
                  <th><%=l(:field_is_required)%></th>
                  <% if tab[:name] == 'IssueCustomField' %>
                    <th><%=l(:field_is_for_all)%></th>
                    <th><%=l(:label_used_by)%></th>
                  <% end %>
-                 <th><%=l(:button_sort)%></th>
                  <th></th>
                </tr></thead>
                <tbody>
                <% (@custom_fields_by_type[tab[:name]] || []).sort.each do |custom_field| -%>
                  <% back_url = custom_fields_path(:tab => tab[:name]) %>
                  <tr class="<%= cycle("odd", "even") %>">
                    <td class="name"><%= link_to custom_field.name, edit_custom_field_path(custom_field) %></td>
                    <td><%= l(custom_field.format.label) %></td>
                    <td><%= checked_image custom_field.is_required? %></td>
                    <% if tab[:name] == 'IssueCustomField' %>
                    <td><%= checked_image custom_field.is_for_all? %></td>
                    <td><%= l(:label_x_projects, :count => custom_field.projects.count) if custom_field.is_a? IssueCustomField and !custom_field.is_for_all? %></td>
                    <% end %>
-                   <td class="reorder"><%= reorder_links('custom_field', {:action => 'update', :id => custom_field, :back_url => back_url}, :put) %></td>
                    <td class="buttons">
+                     <%= reorder_handle(custom_field, :url => custom_field_path(custom_field), :param => 'custom_field') %>
                      <%= delete_link custom_field_path(custom_field) %>
                    </td>
                  </tr>
                <% end; reset_cycle %>
                </tbody>
              </table>

app/views/custom_fields/index.html.erb +4 0

              <div class="contextual">
              <%= link_to l(:label_custom_field_new), new_custom_field_path, :class => 'icon icon-add' %>
              </div>
              <%= title l(:label_custom_field_plural) %>
              <% if @custom_fields_by_type.present? %>
                <%= render_custom_fields_tabs(@custom_fields_by_type.keys) %>
              <% else %>
                <p class="nodata"><%= l(:label_no_data) %></p>
              <% end %>
+             <%= javascript_tag do %>
+               $(function() { $("table.custom_fields tbody").positionedItems(); });
+             <% end %>
  No newline at end of file

app/views/enumerations/index.html.erb +9 -4

              <h2><%=l(:label_enumerations)%></h2>
              <% Enumeration.get_subclasses.each do |klass| %>
              <h3><%= l(klass::OptionName) %></h3>
              <% enumerations = klass.shared %>
              <% if enumerations.any? %>
-             <table class="list"><thead>
+             <table class="list enumerations"><thead>
              <tr>
                  <th><%= l(:field_name) %></th>
                  <th><%= l(:field_is_default) %></th>
                  <th><%= l(:field_active) %></th>
-                 <th><%=l(:button_sort)%></th>
                  <th></th>
              </tr></thead>
              <% enumerations.each do |enumeration| %>
              <tr class="<%= cycle('odd', 'even') %>">
                  <td class="name"><%= link_to enumeration, edit_enumeration_path(enumeration) %></td>
                  <td class="tick"><%= checked_image enumeration.is_default? %></td>
                  <td class="tick"><%= checked_image enumeration.active? %></td>
-                 <td class="reorder"><%= reorder_links('enumeration', {:action => 'update', :id => enumeration}, :put) %></td>
-                 <td class="buttons"><%= delete_link enumeration_path(enumeration) %></td>
+                 <td class="buttons">
+                   <%= reorder_handle(enumeration, :url => enumeration_path(enumeration), :param => 'enumeration') %>
+                   <%= delete_link enumeration_path(enumeration) %>
+                 </td>
              </tr>
              <% end %>
              </table>
              <% reset_cycle %>
              <% end %>
              <p><%= link_to l(:label_enumeration_new), new_enumeration_path(:type => klass.name) %></p>
              <% end %>
              <% html_title(l(:label_enumerations)) -%>
+             <%= javascript_tag do %>
+               $(function() { $("table.enumerations tbody").positionedItems(); });
+             <% end %>
  No newline at end of file

app/views/issue_statuses/index.html.erb +6 -3

              <div class="contextual">
              <%= link_to l(:label_issue_status_new), new_issue_status_path, :class => 'icon icon-add' %>
              <%= link_to(l(:label_update_issue_done_ratios), update_issue_done_ratio_issue_statuses_path, :class => 'icon icon-multiple', :method => 'post', :data => {:confirm => l(:text_are_you_sure)}) if Issue.use_status_for_done_ratio? %>
              </div>
              <h2><%=l(:label_issue_status_plural)%></h2>
-             <table class="list">
+             <table class="list issue_statuses">
                <thead><tr>
                <th><%=l(:field_status)%></th>
                <% if Issue.use_status_for_done_ratio? %>
                <th><%=l(:field_done_ratio)%></th>
                <% end %>
                <th><%=l(:field_is_closed)%></th>
-               <th><%=l(:button_sort)%></th>
                <th></th>
                </tr></thead>
                <tbody>
              <% for status in @issue_statuses %>
                <tr class="<%= cycle("odd", "even") %>">
                <td class="name"><%= link_to status.name, edit_issue_status_path(status) %></td>
                <% if Issue.use_status_for_done_ratio? %>
                <td><%= status.default_done_ratio %></td>
                <% end %>
                <td><%= checked_image status.is_closed? %></td>
-               <td class="reorder"><%= reorder_links('issue_status', {:action => 'update', :id => status, :page => params[:page]}, :put) %></td>
                <td class="buttons">
+                 <%= reorder_handle(status) %>
                  <%= delete_link issue_status_path(status) %>
                </td>
                </tr>
              <% end %>
                </tbody>
              </table>
              <% html_title(l(:label_issue_status_plural)) -%>
+             <%= javascript_tag do %>
+               $(function() { $("table.issue_statuses tbody").positionedItems(); });
+             <% end %>

app/views/roles/index.html.erb +7 -8

              <div class="contextual">
              <%= link_to l(:label_role_new), new_role_path, :class => 'icon icon-add' %>
              <%= link_to l(:label_permissions_report), permissions_roles_path, :class => 'icon icon-summary' %>
              </div>
              <h2><%=l(:label_role_plural)%></h2>
-             <table class="list">
+             <table class="list roles">
                <thead><tr>
                  <th><%=l(:label_role)%></th>
-                 <th><%=l(:button_sort)%></th>
                <th></th>
                </tr></thead>
                <tbody>
              <% for role in @roles %>
-               <tr class="<%= cycle("odd", "even") %>">
+               <tr class="<%= cycle("odd", "even") %> <%= role.builtin? ? "builtin" : "givable" %>">
                <td class="name"><%= content_tag(role.builtin? ? 'em' : 'span', link_to(role.name, edit_role_path(role))) %></td>
-               <td class="reorder">
-               <% unless role.builtin? %>
-                 <%= reorder_links('role', {:action => 'update', :id => role, :page => params[:page]}, :put) %>
-               <% end %>
-               </td>
                <td class="buttons">
+                 <%= reorder_handle(role) unless role.builtin? %>
                  <%= link_to l(:button_copy), new_role_path(:copy => role), :class => 'icon icon-copy' %>
                  <%= delete_link role_path(role) unless role.builtin? %>
                </td>
                </tr>
              <% end %>
                </tbody>
              </table>
              <% html_title(l(:label_role_plural)) -%>
+             <%= javascript_tag do %>
+               $(function() { $("table.roles tbody").positionedItems({items: ".givable"}); });
+             <% end %>
  No newline at end of file

app/views/trackers/index.html.erb +6 -5

              <div class="contextual">
              <%= link_to l(:label_tracker_new), new_tracker_path, :class => 'icon icon-add' %>
              <%= link_to l(:field_summary), fields_trackers_path, :class => 'icon icon-summary' %>
              </div>
              <h2><%=l(:label_tracker_plural)%></h2>
-             <table class="list">
+             <table class="list trackers">
                <thead><tr>
                <th><%=l(:label_tracker)%></th>
                <th></th>
-               <th><%=l(:button_sort)%></th>
                <th></th>
                </tr></thead>
                <tbody>
              <% for tracker in @trackers %>
                <tr class="<%= cycle("odd", "even") %>">
                <td class="name"><%= link_to tracker.name, edit_tracker_path(tracker) %></td>
                <td>
                  <% unless tracker.workflow_rules.count > 0 %>
                    <span class="icon icon-warning">
                      <%= l(:text_tracker_no_workflow) %> (<%= link_to l(:button_edit), workflows_edit_path(:tracker_id => tracker) %>)
                    </span>
                  <% end %>
                </td>
-               <td class="reorder">
-                 <%= reorder_links('tracker', {:action => 'update', :id => tracker, :page => params[:page]}, :put) %>
-               </td>
                <td class="buttons">
+                 <%= reorder_handle(tracker) %>
                  <%= delete_link tracker_path(tracker) %>
                </td>
                </tr>
              <% end %>
                </tbody>
              </table>
              <% html_title(l(:label_tracker_plural)) -%>
+             <%= javascript_tag do %>
+               $(function() { $("table.trackers tbody").positionedItems(); });
+             <% end %>

public/javascripts/application.js +39 0

              /* Redmine - project management software
                 Copyright (C) 2006-2016  Jean-Philippe Lang */
              function checkAll(id, checked) {
                $('#'+id).find('input[type=checkbox]:enabled').prop('checked', checked);
              }
              function toggleCheckboxesBySelector(selector) {
                var all_checked = true;
                $(selector).each(function(index) {
                  if (!$(this).is(':checked')) { all_checked = false; }
                });
                $(selector).prop('checked', !all_checked);
              }
              function showAndScrollTo(id, focus) {
                $('#'+id).show();
                if (focus !== null) {
                  $('#'+focus).focus();
                }
                $('html, body').animate({scrollTop: $('#'+id).offset().top}, 100);
              }
              function toggleRowGroup(el) {
                var tr = $(el).parents('tr').first();
                var n = tr.next();
                tr.toggleClass('open');
                while (n.length && !n.hasClass('group')) {
                  n.toggle();
                  n = n.next('tr');
                }
              }
              function collapseAllRowGroups(el) {
                var tbody = $(el).parents('tbody').first();
                tbody.children('tr').each(function(index) {
                  if ($(this).hasClass('group')) {
                    $(this).removeClass('open');
                  } else {
                    $(this).hide();
                  }
                });
              }
              function expandAllRowGroups(el) {
                var tbody = $(el).parents('tbody').first();
                tbody.children('tr').each(function(index) {
                  if ($(this).hasClass('group')) {
                    $(this).addClass('open');
                  } else {
                    $(this).show();
                  }
                });
              }
              function toggleAllRowGroups(el) {
                var tr = $(el).parents('tr').first();
                if (tr.hasClass('open')) {
                  collapseAllRowGroups(el);
                } else {
                  expandAllRowGroups(el);
                }
              }
              function toggleFieldset(el) {
                var fieldset = $(el).parents('fieldset').first();
                fieldset.toggleClass('collapsed');
                fieldset.children('div').toggle();
              }
              function hideFieldset(el) {
                var fieldset = $(el).parents('fieldset').first();
                fieldset.toggleClass('collapsed');
                fieldset.children('div').hide();
              }
              // columns selection
              function moveOptions(theSelFrom, theSelTo) {
                $(theSelFrom).find('option:selected').detach().prop("selected", false).appendTo($(theSelTo));
              }
              function moveOptionUp(theSel) {
                $(theSel).find('option:selected').each(function(){
                  $(this).prev(':not(:selected)').detach().insertAfter($(this));
                });
              }
              function moveOptionTop(theSel) {
                $(theSel).find('option:selected').detach().prependTo($(theSel));
              }
              function moveOptionDown(theSel) {
                $($(theSel).find('option:selected').get().reverse()).each(function(){
                  $(this).next(':not(:selected)').detach().insertBefore($(this));
                });
              }
              function moveOptionBottom(theSel) {
                $(theSel).find('option:selected').detach().appendTo($(theSel));
              }
              function initFilters() {
                $('#add_filter_select').change(function() {
                  addFilter($(this).val(), '', []);
                });
                $('#filters-table td.field input[type=checkbox]').each(function() {
                  toggleFilter($(this).val());
                });
                $('#filters-table').on('click', 'td.field input[type=checkbox]', function() {
                  toggleFilter($(this).val());
                });
                $('#filters-table').on('click', '.toggle-multiselect', function() {
                  toggleMultiSelect($(this).siblings('select'));
                });
                $('#filters-table').on('keypress', 'input[type=text]', function(e) {
                  if (e.keyCode == 13) $(this).closest('form').submit();
                });
              }
              function addFilter(field, operator, values) {
                var fieldId = field.replace('.', '_');
                var tr = $('#tr_'+fieldId);
                if (tr.length > 0) {
                  tr.show();
                } else {
                  buildFilterRow(field, operator, values);
                }
                $('#cb_'+fieldId).prop('checked', true);
                toggleFilter(field);
                $('#add_filter_select').val('').find('option').each(function() {
                  if ($(this).attr('value') == field) {
                    $(this).attr('disabled', true);
                  }
                });
              }
              function buildFilterRow(field, operator, values) {
                var fieldId = field.replace('.', '_');
                var filterTable = $("#filters-table");
                var filterOptions = availableFilters[field];
                if (!filterOptions) return;
                var operators = operatorByType[filterOptions['type']];
                var filterValues = filterOptions['values'];
                var i, select;
                var tr = $('<tr class="filter">').attr('id', 'tr_'+fieldId).html(
                  '<td class="field"><input checked="checked" id="cb_'+fieldId+'" name="f[]" value="'+field+'" type="checkbox"><label for="cb_'+fieldId+'"> '+filterOptions['name']+'</label></td>' +
                  '<td class="operator"><select id="operators_'+fieldId+'" name="op['+field+']"></td>' +
                  '<td class="values"></td>'
                );
                filterTable.append(tr);
                select = tr.find('td.operator select');
                for (i = 0; i < operators.length; i++) {
                  var option = $('<option>').val(operators[i]).text(operatorLabels[operators[i]]);
                  if (operators[i] == operator) { option.attr('selected', true); }
                  select.append(option);
                }
                select.change(function(){ toggleOperator(field); });
                switch (filterOptions['type']) {
                case "list":
                case "list_optional":
                case "list_status":
                case "list_subprojects":
                  tr.find('td.values').append(
                    '<span style="display:none;"><select class="value" id="values_'+fieldId+'_1" name="v['+field+'][]"></select>' +
                    ' <span class="toggle-multiselect">&nbsp;</span></span>'
                  );
                  select = tr.find('td.values select');
                  if (values.length > 1) { select.attr('multiple', true); }
                  for (i = 0; i < filterValues.length; i++) {
                    var filterValue = filterValues[i];
                    var option = $('<option>');
                    if ($.isArray(filterValue)) {
                      option.val(filterValue[1]).text(filterValue[0]);
                      if ($.inArray(filterValue[1], values) > -1) {option.attr('selected', true);}
                    } else {
                      option.val(filterValue).text(filterValue);
                      if ($.inArray(filterValue, values) > -1) {option.attr('selected', true);}
                    }
                    select.append(option);
                  }
                  break;
                case "date":
                case "date_past":
                  tr.find('td.values').append(
                    '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="10" class="value date_value" /></span>' +
                    ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="10" class="value date_value" /></span>' +
                    ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="3" class="value" /> '+labelDayPlural+'</span>'
                  );
                  $('#values_'+fieldId+'_1').val(values[0]).datepicker(datepickerOptions);
                  $('#values_'+fieldId+'_2').val(values[1]).datepicker(datepickerOptions);
                  $('#values_'+fieldId).val(values[0]);
                  break;
                case "string":
                case "text":
                  tr.find('td.values').append(
                    '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="30" class="value" /></span>'
                  );
                  $('#values_'+fieldId).val(values[0]);
                  break;
                case "relation":
                  tr.find('td.values').append(
                    '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="6" class="value" /></span>' +
                    '<span style="display:none;"><select class="value" name="v['+field+'][]" id="values_'+fieldId+'_1"></select></span>'
                  );
                  $('#values_'+fieldId).val(values[0]);
                  select = tr.find('td.values select');
                  for (i = 0; i < allProjects.length; i++) {
                    var filterValue = allProjects[i];
                    var option = $('<option>');
                    option.val(filterValue[1]).text(filterValue[0]);
                    if (values[0] == filterValue[1]) { option.attr('selected', true); }
                    select.append(option);
                  }
                  break;
                case "integer":
                case "float":
                case "tree":
                  tr.find('td.values').append(
                    '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="6" class="value" /></span>' +
                    ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="6" class="value" /></span>'
                  );
                  $('#values_'+fieldId+'_1').val(values[0]);
                  $('#values_'+fieldId+'_2').val(values[1]);
                  break;
                }
              }
              function toggleFilter(field) {
                var fieldId = field.replace('.', '_');
                if ($('#cb_' + fieldId).is(':checked')) {
                  $("#operators_" + fieldId).show().removeAttr('disabled');
                  toggleOperator(field);
                } else {
                  $("#operators_" + fieldId).hide().attr('disabled', true);
                  enableValues(field, []);
                }
              }
              function enableValues(field, indexes) {
                var fieldId = field.replace('.', '_');
                $('#tr_'+fieldId+' td.values .value').each(function(index) {
                  if ($.inArray(index, indexes) >= 0) {
                    $(this).removeAttr('disabled');
                    $(this).parents('span').first().show();
                  } else {
                    $(this).val('');
                    $(this).attr('disabled', true);
                    $(this).parents('span').first().hide();
                  }
                  if ($(this).hasClass('group')) {
                    $(this).addClass('open');
                  } else {
                    $(this).show();
                  }
                });
              }
              function toggleOperator(field) {
                var fieldId = field.replace('.', '_');
                var operator = $("#operators_" + fieldId);
                switch (operator.val()) {
                  case "!*":
                  case "*":
                  case "t":
                  case "ld":
                  case "w":
                  case "lw":
                  case "l2w":
                  case "m":
                  case "lm":
                  case "y":
                  case "o":
                  case "c":
                  case "*o":
                  case "!o":
                    enableValues(field, []);
                    break;
                  case "><":
                    enableValues(field, [0,1]);
                    break;
                  case "<t+":
                  case ">t+":
                  case "><t+":
                  case "t+":
                  case ">t-":
                  case "<t-":
                  case "><t-":
                  case "t-":
                    enableValues(field, [2]);
                    break;
                  case "=p":
                  case "=!p":
                  case "!p":
                    enableValues(field, [1]);
                    break;
                  default:
                    enableValues(field, [0]);
                    break;
                }
              }
              function toggleMultiSelect(el) {
                if (el.attr('multiple')) {
                  el.removeAttr('multiple');
                  el.attr('size', 1);
                } else {
                  el.attr('multiple', true);
                  if (el.children().length > 10)
                    el.attr('size', 10);
                  else
                    el.attr('size', 4);
                }
              }
              function showTab(name, url) {
                $('#tab-content-' + name).parent().find('.tab-content').hide();
                $('#tab-content-' + name).parent().find('div.tabs a').removeClass('selected');
                $('#tab-content-' + name).show();
                $('#tab-' + name).addClass('selected');
                //replaces current URL with the "href" attribute of the current link
                //(only triggered if supported by browser)
                if ("replaceState" in window.history) {
                  window.history.replaceState(null, document.title, url);
                }
                return false;
              }
              function moveTabRight(el) {
                var lis = $(el).parents('div.tabs').first().find('ul').children();
                var bw = $(el).parents('div.tabs-buttons').outerWidth(true);
                var tabsWidth = 0;
                var i = 0;
                lis.each(function() {
                  if ($(this).is(':visible')) {
                    tabsWidth += $(this).outerWidth(true);
                  }
                });
                if (tabsWidth < $(el).parents('div.tabs').first().width() - bw) { return; }
                $(el).siblings('.tab-left').removeClass('disabled');
                while (i<lis.length && !lis.eq(i).is(':visible')) { i++; }
                var w = lis.eq(i).width();
                lis.eq(i).hide();
                if (tabsWidth - w < $(el).parents('div.tabs').first().width() - bw) {
                  $(el).addClass('disabled');
                }
              }
              function moveTabLeft(el) {
                var lis = $(el).parents('div.tabs').first().find('ul').children();
                var i = 0;
                while (i < lis.length && !lis.eq(i).is(':visible')) { i++; }
                if (i > 0) {
                  lis.eq(i-1).show();
                  $(el).siblings('.tab-right').removeClass('disabled');
                }
                if (i <= 1) {
                  $(el).addClass('disabled');
                }
              }
              function displayTabsButtons() {
                var lis;
                var tabsWidth;
                var el;
                var numHidden;
                $('div.tabs').each(function() {
                  el = $(this);
                  lis = el.find('ul').children();
                  tabsWidth = 0;
                  numHidden = 0;
                  lis.each(function(){
                    if ($(this).is(':visible')) {
                      tabsWidth += $(this).outerWidth(true);
                    } else {
                      numHidden++;
                    }
                  });
                  var bw = $(el).parents('div.tabs-buttons').outerWidth(true);
                  if ((tabsWidth < el.width() - bw) && (lis.first().is(':visible'))) {
                    el.find('div.tabs-buttons').hide();
                  } else {
                    el.find('div.tabs-buttons').show().children('button.tab-left').toggleClass('disabled', numHidden == 0);
                  }
                });
              }
              function setPredecessorFieldsVisibility() {
                var relationType = $('#relation_relation_type');
                if (relationType.val() == "precedes" || relationType.val() == "follows") {
                  $('#predecessor_fields').show();
                } else {
                  $('#predecessor_fields').hide();
                }
              }
              function showModal(id, width, title) {
                var el = $('#'+id).first();
                if (el.length === 0 || el.is(':visible')) {return;}
                if (!title) title = el.find('h3.title').text();
                // moves existing modals behind the transparent background
                $(".modal").zIndex(99);
                el.dialog({
                  width: width,
                  modal: true,
                  resizable: false,
                  dialogClass: 'modal',
                  title: title
                }).on('dialogclose', function(){
                  $(".modal").zIndex(101);
                });
                el.find("input[type=text], input[type=submit]").first().focus();
              }
              function hideModal(el) {
                var modal;
                if (el) {
                  modal = $(el).parents('.ui-dialog-content');
                } else {
                  modal = $('#ajax-modal');
                }
                modal.dialog("close");
              }
              function submitPreview(url, form, target) {
                $.ajax({
                  url: url,
                  type: 'post',
                  data: $('#'+form).serialize(),
                  success: function(data){
                    $('#'+target).html(data);
                  }
                });
              }
              function collapseScmEntry(id) {
                $('.'+id).each(function() {
                  if ($(this).hasClass('open')) {
                    collapseScmEntry($(this).attr('id'));
                  }
                  $(this).hide();
                });
                $('#'+id).removeClass('open');
              }
              function expandScmEntry(id) {
                $('.'+id).each(function() {
                  $(this).show();
                  if ($(this).hasClass('loaded') && !$(this).hasClass('collapsed')) {
                    expandScmEntry($(this).attr('id'));
                  }
                });
                $('#'+id).addClass('open');
              }
              function scmEntryClick(id, url) {
                  var el = $('#'+id);
                  if (el.hasClass('open')) {
                      collapseScmEntry(id);
                      el.addClass('collapsed');
                      return false;
                  } else if (el.hasClass('loaded')) {
                      expandScmEntry(id);
                      el.removeClass('collapsed');
                      return false;
                  }
                  if (el.hasClass('loading')) {
                      return false;
                  }
                  el.addClass('loading');
                  $.ajax({
                    url: url,
                    success: function(data) {
                      el.after(data);
                      el.addClass('open').addClass('loaded').removeClass('loading');
                    }
                  });
                  return true;
              }
              function randomKey(size) {
                var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
                var key = '';
                for (var i = 0; i < size; i++) {
                  key += chars.charAt(Math.floor(Math.random() * chars.length));
                }
                return key;
              }
              function updateIssueFrom(url, el) {
                $('#all_attributes input, #all_attributes textarea, #all_attributes select').each(function(){
                  $(this).data('valuebeforeupdate', $(this).val());
                });
                if (el) {
                  $("#form_update_triggered_by").val($(el).attr('id'));
                }
                return $.ajax({
                  url: url,
                  type: 'post',
                  data: $('#issue-form').serialize()
                });
              }
              function replaceIssueFormWith(html){
                var replacement = $(html);
                $('#all_attributes input, #all_attributes textarea, #all_attributes select').each(function(){
                  var object_id = $(this).attr('id');
                  if (object_id && $(this).data('valuebeforeupdate')!=$(this).val()) {
                    replacement.find('#'+object_id).val($(this).val());
                  }
                });
                $('#all_attributes').empty();
                $('#all_attributes').prepend(replacement);
              }
              function updateBulkEditFrom(url) {
                $.ajax({
                  url: url,
                  type: 'post',
                  data: $('#bulk_edit_form').serialize()
                });
              }
              function observeAutocompleteField(fieldId, url, options) {
                $(document).ready(function() {
                  $('#'+fieldId).autocomplete($.extend({
                    source: url,
                    minLength: 2,
                    position: {collision: "flipfit"},
                    search: function(){$('#'+fieldId).addClass('ajax-loading');},
                    response: function(){$('#'+fieldId).removeClass('ajax-loading');}
                  }, options));
                  $('#'+fieldId).addClass('autocomplete');
                });
              }
              function observeSearchfield(fieldId, targetId, url) {
                $('#'+fieldId).each(function() {
                  var $this = $(this);
                  $this.addClass('autocomplete');
                  $this.attr('data-value-was', $this.val());
                  var check = function() {
                    var val = $this.val();
                    if ($this.attr('data-value-was') != val){
                      $this.attr('data-value-was', val);
                      $.ajax({
                        url: url,
                        type: 'get',
                        data: {q: $this.val()},
                        success: function(data){ if(targetId) $('#'+targetId).html(data); },
                        beforeSend: function(){ $this.addClass('ajax-loading'); },
                        complete: function(){ $this.removeClass('ajax-loading'); }
                      });
                    }
                  };
                  var reset = function() {
                    if (timer) {
                      clearInterval(timer);
                      timer = setInterval(check, 300);
                    }
                  };
                  var timer = setInterval(check, 300);
                  $this.bind('keyup click mousemove', reset);
                });
              }
              function beforeShowDatePicker(input, inst) {
                var default_date = null;
                switch ($(input).attr("id")) {
                  case "issue_start_date" :
                    if ($("#issue_due_date").size() > 0) {
                      default_date = $("#issue_due_date").val();
                    }
                    break;
                  case "issue_due_date" :
                    if ($("#issue_start_date").size() > 0) {
                      var start_date = $("#issue_start_date").val();
                      if (start_date != "") {
                        start_date = new Date(Date.parse(start_date));
                        if (start_date > new Date()) {
                          default_date = $("#issue_start_date").val();
                        }
                      }
                    }
                    break;
                }
                $(input).datepicker("option", "defaultDate", default_date);
              }
+             (function($){
+               $.fn.positionedItems = function(sortableOptions, options){
+                 var settings = $.extend({
+                   firstPosition: 1
+                 }, options );
+                 return this.sortable($.extend({
+                   handle: ".sort-handle",
+                   helper: function(event, ui){
+                     ui.children().each(function(){
+                       $(this).width($(this).width());
+                     });
+                     return ui;
+                   },
+                   update: function(event, ui) {
+                     var sortable = $(this);
+                     var url = ui.item.find(".sort-handle").data("reorder-url");
+                     var param = ui.item.find(".sort-handle").data("reorder-param");
+                     var data = {};
+                     data[param] = {position: ui.item.index() + settings['firstPosition']};
+                     $.ajax({
+                       url: url,
+                       type: 'put',
+                       dataType: 'script',
+                       data: data,
+                       success: function(data){
+                         sortable.children(":even").removeClass("even").addClass("odd");
+                         sortable.children(":odd").removeClass("odd").addClass("even");
+                       },
+                       error: function(jqXHR, textStatus, errorThrown){
+                         alert(jqXHR.status);
+                         sortable.sortable("cancel");
+                       }
+                     });
+                   },
+                 }, sortableOptions));
+               }
+             }( jQuery ));
              function initMyPageSortable(list, url) {
                $('#list-'+list).sortable({
                  connectWith: '.block-receiver',
                  tolerance: 'pointer',
                  update: function(){
                    $.ajax({
                      url: url,
                      type: 'post',
                      data: {'blocks': $.map($('#list-'+list).children(), function(el){return $(el).attr('id');})}
                    });
                  }
                });
                $("#list-top, #list-left, #list-right").disableSelection();
              }
              var warnLeavingUnsavedMessage;
              function warnLeavingUnsaved(message) {
                warnLeavingUnsavedMessage = message;
                $(document).on('submit', 'form', function(){
                  $('textarea').removeData('changed');
                });
                $(document).on('change', 'textarea', function(){
                  $(this).data('changed', 'changed');
                });
                window.onbeforeunload = function(){
                  var warn = false;
                  $('textarea').blur().each(function(){
                    if ($(this).data('changed')) {
                      warn = true;
                    }
                  });
                  if (warn) {return warnLeavingUnsavedMessage;}
                };
              }
              function setupAjaxIndicator() {
                $(document).bind('ajaxSend', function(event, xhr, settings) {
                  if ($('.ajax-loading').length === 0 && settings.contentType != 'application/octet-stream') {
                    $('#ajax-indicator').show();
                  }
                });
                $(document).bind('ajaxStop', function() {
                  $('#ajax-indicator').hide();
                });
              }
              function setupTabs() {
                if($('.tabs').length > 0) {
                  displayTabsButtons();
                  $(window).resize(displayTabsButtons);
                }
              }
              function hideOnLoad() {
                $('.hol').hide();
              }
              function addFormObserversForDoubleSubmit() {
                $('form[method=post]').each(function() {
                  if (!$(this).hasClass('multiple-submit')) {
                    $(this).submit(function(form_submission) {
                      if ($(form_submission.target).attr('data-submitted')) {
                        form_submission.preventDefault();
                      } else {
                        $(form_submission.target).attr('data-submitted', true);
                      }
                    });
                  }
                });
              }
              function defaultFocus(){
                if (($('#content :focus').length == 0) && (window.location.hash == '')) {
                  $('#content input[type=text], #content textarea').first().focus();
                }
              }
              function blockEventPropagation(event) {
                event.stopPropagation();
                event.preventDefault();
              }
              function toggleDisabledOnChange() {
                var checked = $(this).is(':checked');
                $($(this).data('disables')).attr('disabled', checked);
                $($(this).data('enables')).attr('disabled', !checked);
              }
              function toggleDisabledInit() {
                $('input[data-disables], input[data-enables]').each(toggleDisabledOnChange);
              }
              $(document).ready(function(){
                $('#content').on('change', 'input[data-disables], input[data-enables]', toggleDisabledOnChange);
                toggleDisabledInit();
              });
              function keepAnchorOnSignIn(form){
                var hash = decodeURIComponent(self.document.location.hash);
                if (hash) {
                  if (hash.indexOf("#") === -1) {
                    hash = "#" + hash;
                  }
                  form.action = form.action + hash;
                }
                return true;
              }
              $(document).ready(setupAjaxIndicator);
              $(document).ready(hideOnLoad);
              $(document).ready(addFormObserversForDoubleSubmit);
              $(document).ready(defaultFocus);
              $(document).ready(setupTabs);

test/functional/trackers_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class TrackersControllerTest < ActionController::TestCase
                fixtures :trackers, :projects, :projects_trackers, :users, :issues, :custom_fields, :issue_statuses
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'index'
                end
                def test_index_by_anonymous_should_redirect_to_login_form
                  @request.session[:user_id] = nil
                  get :index
                  assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Ftrackers'
                end
                def test_index_by_user_should_respond_with_406
                  @request.session[:user_id] = 2
                  get :index
                  assert_response 406
                end
                def test_new
                  get :new
                  assert_response :success
                  assert_template 'new'
                end
                def test_create
                  assert_difference 'Tracker.count' do
                    post :create, :tracker => { :name => 'New tracker', :default_status_id => 1, :project_ids => ['1', '', ''], :custom_field_ids => ['1', '6', ''] }
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.order('id DESC').first
                  assert_equal 'New tracker', tracker.name
                  assert_equal [1], tracker.project_ids.sort
                  assert_equal Tracker::CORE_FIELDS, tracker.core_fields
                  assert_equal [1, 6], tracker.custom_field_ids.sort
                  assert_equal 0, tracker.workflow_rules.count
                end
                def test_create_with_disabled_core_fields
                  assert_difference 'Tracker.count' do
                    post :create, :tracker => { :name => 'New tracker', :default_status_id => 1, :core_fields => ['assigned_to_id', 'fixed_version_id', ''] }
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.order('id DESC').first
                  assert_equal 'New tracker', tracker.name
                  assert_equal %w(assigned_to_id fixed_version_id), tracker.core_fields
                end
                def test_create_new_with_workflow_copy
                  assert_difference 'Tracker.count' do
                    post :create, :tracker => { :name => 'New tracker', :default_status_id => 1 }, :copy_workflow_from => 1
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.find_by_name('New tracker')
                  assert_equal 0, tracker.projects.count
                  assert_equal Tracker.find(1).workflow_rules.count, tracker.workflow_rules.count
                end
                def test_create_with_failure
                  assert_no_difference 'Tracker.count' do
                    post :create, :tracker => { :name => '', :project_ids => ['1', '', ''],
                                                :custom_field_ids => ['1', '6', ''] }
                  end
                  assert_response :success
                  assert_template 'new'
                  assert_select_error /name cannot be blank/i
                end
                def test_edit
                  Tracker.find(1).project_ids = [1, 3]
                  get :edit, :id => 1
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'input[name=?][value="1"][checked=checked]', 'tracker[project_ids][]'
                  assert_select 'input[name=?][value="2"]:not([checked])', 'tracker[project_ids][]'
                  assert_select 'input[name=?][value=""][type=hidden]', 'tracker[project_ids][]'
                end
                def test_edit_should_check_core_fields
                  tracker = Tracker.find(1)
                  tracker.core_fields = %w(assigned_to_id fixed_version_id)
                  tracker.save!
                  get :edit, :id => 1
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'input[name=?][value=assigned_to_id][checked=checked]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=fixed_version_id][checked=checked]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=category_id]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=category_id][checked=checked]', 'tracker[core_fields][]', 0
                  assert_select 'input[name=?][value=""][type=hidden]', 'tracker[core_fields][]'
                end
                def test_update
                  put :update, :id => 1, :tracker => { :name => 'Renamed',
                                                      :project_ids => ['1', '2', ''] }
                  assert_redirected_to :action => 'index'
                  assert_equal [1, 2], Tracker.find(1).project_ids.sort
                end
                def test_update_without_projects
                  put :update, :id => 1, :tracker => { :name => 'Renamed',
                                                      :project_ids => [''] }
                  assert_redirected_to :action => 'index'
                  assert Tracker.find(1).project_ids.empty?
                end
                def test_update_without_core_fields
                  put :update, :id => 1, :tracker => { :name => 'Renamed', :core_fields => [''] }
                  assert_redirected_to :action => 'index'
                  assert Tracker.find(1).core_fields.empty?
                end
                def test_update_with_failure
                  put :update, :id => 1, :tracker => { :name => '' }
                  assert_response :success
                  assert_template 'edit'
                  assert_select_error /name cannot be blank/i
                end
                def test_move_lower
                 tracker = Tracker.find_by_position(1)
-                put :update, :id => 1, :tracker => { :move_to => 'lower' }
+                put :update, :id => 1, :tracker => { :position => '2' }
                 assert_equal 2, tracker.reload.position
                end
                def test_destroy
                  tracker = Tracker.generate!(:name => 'Destroyable')
                  assert_difference 'Tracker.count', -1 do
                    delete :destroy, :id => tracker.id
                  end
                  assert_redirected_to :action => 'index'
                  assert_nil flash[:error]
                end
                def test_destroy_tracker_in_use
                  assert_no_difference 'Tracker.count' do
                    delete :destroy, :id => 1
                  end
                  assert_redirected_to :action => 'index'
                  assert_not_nil flash[:error]
                end
                def test_get_fields
                  get :fields
                  assert_response :success
                  assert_template 'fields'
                  assert_select 'form' do
                    assert_select 'input[type=checkbox][name=?][value=assigned_to_id]', 'trackers[1][core_fields][]'
                    assert_select 'input[type=checkbox][name=?][value="2"]', 'trackers[1][custom_field_ids][]'
                    assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][core_fields][]'
                    assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][custom_field_ids][]'
                  end
                end
                def test_post_fields
                  post :fields, :trackers => {
                    '1' => {'core_fields' => ['assigned_to_id', 'due_date', ''], 'custom_field_ids' => ['1', '2']},
                    '2' => {'core_fields' => [''], 'custom_field_ids' => ['']}
                  }
                  assert_redirected_to '/trackers/fields'
                  tracker = Tracker.find(1)
                  assert_equal %w(assigned_to_id due_date), tracker.core_fields
                  assert_equal [1, 2], tracker.custom_field_ids.sort
                  tracker = Tracker.find(2)
                  assert_equal [], tracker.core_fields
                  assert_equal [], tracker.custom_field_ids.sort
                end
              end

General Comments 0

Write
Preview

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

No TODOs yet

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

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