jro_apps/redmine Commit - r14953:64afa24a7f72

Replaces acts_as_list with an implementation that handles #position= (#12909)....

Jean-Philippe Lang -

r14953:64afa24a7f72

parent child

Context file:

r14953:64afa24a7f72

Collapse all files

db/migrate/20160416072926_remove_position_defaults.rb created 644 +13 0

@@ -0,0 +1,13
	1	class RemovePositionDefaults < ActiveRecord::Migration
	2	def up
	3	[Board, CustomField, Enumeration, IssueStatus, Role, Tracker].each do \|klass\|
	4	change_column klass.table_name, :position, :integer, :default => nil
	5	end
	6	end
	7
	8	def down
	9	[Board, CustomField, Enumeration, IssueStatus, Role, Tracker].each do \|klass\|
	10	change_column klass.table_name, :position, :integer, :default => 1
	11	end
	12	end
	13	end

lib/redmine/acts/positioned.rb created 644 +134 0

@@ -0,0 +1,134
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2016 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	module Redmine
	19	module Acts
	20	module Positioned
	21	def self.included(base)
	22	base.extend ClassMethods
	23	end
	24
	25	# This extension provides the capabilities for reordering objects in a list.
	26	# The class needs to have a +position+ column defined as an integer on the
	27	# mapped database table.
	28	module ClassMethods
	29	# Configuration options are:
	30	#
	31	# * +scope+ - restricts what is to be considered a list. Must be a symbol
	32	# or an array of symbols
	33	def acts_as_positioned(options = {})
	34	class_attribute :positioned_options
	35	self.positioned_options = {:scope => Array(options[:scope])}
	36
	37	send :include, Redmine::Acts::Positioned::InstanceMethods
	38
	39	before_save :set_default_position
	40	after_save :update_position
	41	after_destroy :remove_position
	42	end
	43	end
	44
	45	module InstanceMethods
	46	def self.included(base)
	47	base.extend ClassMethods
	48	end
	49
	50	# Move to the given position
	51	# For compatibility with the previous way of sorting items
	52	def move_to=(pos)
	53	case pos.to_s
	54	when 'highest'
	55	self.position = 1
	56	when 'higher'
	57	self.position -= 1 if position > 1
	58	when 'lower'
	59	self.position += 1
	60	when 'lowest'
	61	self.position = nil
	62	set_default_position
	63	end
	64	end
	65
	66	private
	67
	68	def position_scope
	69	build_position_scope {\|c\| send(c)}
	70	end
	71
	72	def position_scope_was
	73	build_position_scope {\|c\| send("#{c}_was")}
	74	end
	75
	76	def build_position_scope
	77	condition_hash = self.class.positioned_options[:scope].inject({}) do \|h, column\|
	78	h[column] = yield(column)
	79	h
	80	end
	81	self.class.where(condition_hash)
	82	end
	83
	84	def set_default_position
	85	if position.nil?
	86	self.position = position_scope.maximum(:position).to_i + (new_record? ? 1 : 0)
	87	end
	88	end
	89
	90	def update_position
	91	if !new_record? && position_scope_changed?
	92	remove_position
	93	insert_position
	94	elsif position_changed?
	95	if position_was.nil?
	96	insert_position
	97	else
	98	shift_positions
	99	end
	100	end
	101	end
	102
	103	def insert_position
	104	position_scope.where("position >= ? AND id <> ?", position, id).update_all("position = position + 1")
	105	end
	106
	107	def remove_position
	108	position_scope_was.where("position >= ? AND id <> ?", position_was, id).update_all("position = position - 1")
	109	end
	110
	111	def position_scope_changed?
	112	(changed & self.class.positioned_options[:scope].map(&:to_s)).any?
	113	end
	114
	115	def shift_positions
	116	offset = position_was <=> position
	117	min, max = [position, position_was].sort
	118	r = position_scope.where("id <> ? AND position BETWEEN ? AND ?", id, min, max).update_all("position = position + #{offset}")
	119	if r != max - min
	120	reset_positions_in_list
	121	end
	122	end
	123
	124	def reset_positions_in_list
	125	position_scope.reorder(:position, :id).pluck(:id).each_with_index do \|record_id, p\|
	126	self.class.where(:id => record_id).update_all(:position => p+1)
	127	end
	128	end
	129	end
	130	end
	131	end
	132	end
	133
	134	ActiveRecord::Base.send :include, Redmine::Acts::Positioned

test/unit/lib/redmine/acts/positioned_with_scope_test.rb created 644 +53 0

@@ -0,0 +1,53
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2016 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.expand_path('../../../../../test_helper', __FILE__)
	19
	20	class Redmine::Acts::PositionedWithScopeTest < ActiveSupport::TestCase
	21	fixtures :projects, :boards
	22
	23	def test_create_should_default_to_last_position
	24	b = Board.generate!(:project_id => 1)
	25	assert_equal 3, b.reload.position
	26
	27	b = Board.generate!(:project_id => 3)
	28	assert_equal 1, b.reload.position
	29	end
	30
	31	def test_create_should_insert_at_given_position
	32	b = Board.generate!(:project_id => 1, :position => 2)
	33
	34	assert_equal 2, b.reload.position
	35	assert_equal [1, 3, 1, 2], Board.order(:id).pluck(:position)
	36	end
	37
	38	def test_destroy_should_remove_position
	39	b = Board.generate!(:project_id => 1, :position => 2)
	40	b.destroy
	41
	42	assert_equal [1, 2, 1], Board.order(:id).pluck(:position)
	43	end
	44
	45	def test_update_should_update_positions
	46	b = Board.generate!(:project_id => 1)
	47	assert_equal 3, b.position
	48
	49	b.position = 2
	50	b.save!
	51	assert_equal [1, 3, 1, 2], Board.order(:id).pluck(:position)
	52	end
	53	end

test/unit/lib/redmine/acts/positioned_without_scope_test.rb created 644 +55 0

@@ -0,0 +1,55
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2016 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.expand_path('../../../../../test_helper', __FILE__)
	19
	20	class Redmine::Acts::PositionedWithoutScopeTest < ActiveSupport::TestCase
	21	fixtures :trackers, :issue_statuses
	22
	23	def test_create_should_default_to_last_position
	24	t = Tracker.generate
	25	t.save!
	26
	27	assert_equal 4, t.reload.position
	28	end
	29
	30	def test_create_should_insert_at_given_position
	31	t = Tracker.generate
	32	t.position = 2
	33	t.save!
	34
	35	assert_equal 2, t.reload.position
	36	assert_equal [1, 3, 4, 2], Tracker.order(:id).pluck(:position)
	37	end
	38
	39	def test_destroy_should_remove_position
	40	t = Tracker.generate!
	41	Tracker.generate!
	42	t.destroy
	43
	44	assert_equal [1, 2, 3, 4], Tracker.order(:id).pluck(:position)
	45	end
	46
	47	def test_update_should_update_positions
	48	t = Tracker.generate!
	49	assert_equal 4, t.position
	50
	51	t.position = 2
	52	t.save!
	53	assert_equal [1, 3, 4, 2], Tracker.order(:id).pluck(:position)
	54	end
	55	end

app/models/board.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.
             class Board < ActiveRecord::Base
               include Redmine::SafeAttributes
               belongs_to :project
               has_many :messages, lambda {order("#{Message.table_name}.created_on DESC")}, :dependent => :destroy
               belongs_to :last_message, :class_name => 'Message'
               acts_as_tree :dependent => :nullify
-              acts_as_list :scope => '(project_id = #{project_id} AND parent_id #{parent_id ? "= #{parent_id}" : "IS NULL"})'
+              acts_as_positioned :scope => [:project_id, :parent_id]
               acts_as_watchable
               validates_presence_of :name, :description
               validates_length_of :name, :maximum => 30
               validates_length_of :description, :maximum => 255
               validate :validate_board
               attr_protected :id
               scope :visible, lambda {|*args|
                 joins(:project).
                 where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
               }
               safe_attributes 'name', 'description', 'parent_id', 'move_to'
               def visible?(user=User.current)
                 !user.nil? && user.allowed_to?(:view_messages, project)
               end
               def reload(*args)
                 @valid_parents = nil
                 super
               end
               def to_s
                 name
               end
               # Returns a scope for the board topics (messages without parent)
               def topics
                 messages.where(:parent_id => nil)
               end
               def valid_parents
                 @valid_parents ||= project.boards - self_and_descendants
               end
               def reset_counters!
                 self.class.reset_counters!(id)
               end
               # Updates topics_count, messages_count and last_message_id attributes for +board_id+
               def self.reset_counters!(board_id)
                 board_id = board_id.to_i
                 Board.where(:id => board_id).
                   update_all(["topics_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=:id AND parent_id IS NULL)," +
                            " messages_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=:id)," +
                            " last_message_id = (SELECT MAX(id) FROM #{Message.table_name} WHERE board_id=:id)", :id => board_id])
               end
               def self.board_tree(boards, parent_id=nil, level=0)
                 tree = []
                 boards.select {|board| board.parent_id == parent_id}.sort_by(&:position).each do |board|
                   tree << [board, level]
                   tree += board_tree(boards, board.id, level+1)
                 end
                 if block_given?
                   tree.each do |board, level|
                     yield board, level
                   end
                 end
                 tree
               end
               protected
               def validate_board
                 if parent_id && parent_id_changed?
                   errors.add(:parent_id, :invalid) unless valid_parents.include?(parent)
                 end
               end
             end

app/models/custom_field.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.
             class CustomField < ActiveRecord::Base
               include Redmine::SubclassFactory
               has_many :enumerations,
                        lambda { order(:position) },
                        :class_name => 'CustomFieldEnumeration',
                        :dependent => :delete_all
               has_many :custom_values, :dependent => :delete_all
               has_and_belongs_to_many :roles, :join_table => "#{table_name_prefix}custom_fields_roles#{table_name_suffix}", :foreign_key => "custom_field_id"
-              acts_as_list :scope => 'type = \'#{self.class}\''
+              acts_as_positioned
               serialize :possible_values
               store :format_store
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :field_format, :in => Proc.new { Redmine::FieldFormat.available_formats }
               validate :validate_custom_field
               attr_protected :id
               before_validation :set_searchable
               before_save do |field|
                 field.format.before_custom_field_save(field)
               end
               after_save :handle_multiplicity_change
               after_save do |field|
                 if field.visible_changed? && field.visible
                   field.roles.clear
                 end
               end
               scope :sorted, lambda { order(:position) }
               scope :visible, lambda {|*args|
                 user = args.shift || User.current
                 if user.admin?
                   # nop
                 elsif user.memberships.any?
                   where("#{table_name}.visible = ? OR #{table_name}.id IN (SELECT DISTINCT cfr.custom_field_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = ?)",
                     true, user.id)
                 else
                   where(:visible => true)
                 end
               }
               def visible_by?(project, user=User.current)
                 visible? || user.admin?
               end
               def format
                 @format ||= Redmine::FieldFormat.find(field_format)
               end
               def field_format=(arg)
                 # cannot change format of a saved custom field
                 if new_record?
                   @format = nil
                   super
                 end
               end
               def set_searchable
                 # make sure these fields are not searchable
                 self.searchable = false unless format.class.searchable_supported
                 # make sure only these fields can have multiple values
                 self.multiple = false unless format.class.multiple_supported
                 true
               end
               def validate_custom_field
                 format.validate_custom_field(self).each do |attribute, message|
                   errors.add attribute, message
                 end
                 if regexp.present?
                   begin
                     Regexp.new(regexp)
                   rescue
                     errors.add(:regexp, :invalid)
                   end
                 end
                 if default_value.present?
                   validate_field_value(default_value).each do |message|
                     errors.add :default_value, message
                   end
                 end
               end
               def possible_custom_value_options(custom_value)
                 format.possible_custom_value_options(custom_value)
               end
               def possible_values_options(object=nil)
                 if object.is_a?(Array)
                   object.map {|o| format.possible_values_options(self, o)}.reduce(:&) || []
                 else
                   format.possible_values_options(self, object) || []
                 end
               end
               def possible_values
                 values = read_attribute(:possible_values)
                 if values.is_a?(Array)
                   values.each do |value|
                     value.to_s.force_encoding('UTF-8')
                   end
                   values
                 else
                   []
                 end
               end
               # Makes possible_values accept a multiline string
               def possible_values=(arg)
                 if arg.is_a?(Array)
                   values = arg.compact.map {|a| a.to_s.strip}.reject(&:blank?)
                   write_attribute(:possible_values, values)
                 else
                   self.possible_values = arg.to_s.split(/[\n\r]+/)
                 end
               end
               def cast_value(value)
                 format.cast_value(self, value)
               end
               def value_from_keyword(keyword, customized)
                 format.value_from_keyword(self, keyword, customized)
               end
               # Returns the options hash used to build a query filter for the field
               def query_filter_options(query)
                 format.query_filter_options(self, query)
               end
               def totalable?
                 format.totalable_supported
               end
               # Returns a ORDER BY clause that can used to sort customized
               # objects by their value of the custom field.
               # Returns nil if the custom field can not be used for sorting.
               def order_statement
                 return nil if multiple?
                 format.order_statement(self)
               end
               # Returns a GROUP BY clause that can used to group by custom value
               # Returns nil if the custom field can not be used for grouping.
               def group_statement
                 return nil if multiple?
                 format.group_statement(self)
               end
               def join_for_order_statement
                 format.join_for_order_statement(self)
               end
               def visibility_by_project_condition(project_key=nil, user=User.current, id_column=nil)
                 if visible? || user.admin?
                   "1=1"
                 elsif user.anonymous?
                   "1=0"
                 else
                   project_key ||= "#{self.class.customized_class.table_name}.project_id"
                   id_column ||= id
                   "#{project_key} IN (SELECT DISTINCT m.project_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = #{user.id} AND cfr.custom_field_id = #{id_column})"
                 end
               end
               def self.visibility_condition
                 if user.admin?
                   "1=1"
                 elsif user.anonymous?
                   "#{table_name}.visible"
                 else
                   "#{project_key} IN (SELECT DISTINCT m.project_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = #{user.id} AND cfr.custom_field_id = #{id})"
                 end
               end
               def <=>(field)
                 position <=> field.position
               end
               # Returns the class that values represent
               def value_class
                 format.target_class if format.respond_to?(:target_class)
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 $1.constantize rescue nil
               end
               # to move in project_custom_field
               def self.for_all
                 where(:is_for_all => true).order('position').to_a
               end
               def type_name
                 nil
               end
               # Returns the error messages for the given value
               # or an empty array if value is a valid value for the custom field
               def validate_custom_value(custom_value)
                 value = custom_value.value
                 errs = []
                 if value.is_a?(Array)
                   if !multiple?
                     errs << ::I18n.t('activerecord.errors.messages.invalid')
                   end
                   if is_required? && value.detect(&:present?).nil?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                 else
                   if is_required? && value.blank?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                 end
                 errs += format.validate_custom_value(custom_value)
                 errs
               end
               # Returns the error messages for the default custom field value
               def validate_field_value(value)
                 validate_custom_value(CustomFieldValue.new(:custom_field => self, :value => value))
               end
               # Returns true if value is a valid value for the custom field
               def valid_field_value?(value)
                 validate_field_value(value).empty?
               end
               def format_in?(*args)
                 args.include?(field_format)
               end
               protected
               # Removes multiple values for the custom field after setting the multiple attribute to false
               # We kepp the value with the highest id for each customized object
               def handle_multiplicity_change
                 if !new_record? && multiple_was && !multiple
                   ids = custom_values.
                     where("EXISTS(SELECT 1 FROM #{CustomValue.table_name} cve WHERE cve.custom_field_id = #{CustomValue.table_name}.custom_field_id" +
                       " AND cve.customized_type = #{CustomValue.table_name}.customized_type AND cve.customized_id = #{CustomValue.table_name}.customized_id" +
                       " AND cve.id > #{CustomValue.table_name}.id)").
                     pluck(:id)
                   if ids.any?
                     custom_values.where(:id => ids).delete_all
                   end
                 end
               end
             end
             require_dependency 'redmine/field_format'

app/models/enumeration.rb +23 -18

             # 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 Enumeration < ActiveRecord::Base
               include Redmine::SubclassFactory
               default_scope lambda {order(:position)}
               belongs_to :project
-              acts_as_list :scope => 'type = \'#{type}\' AND #{parent_id ? "parent_id = #{parent_id}" : "parent_id IS NULL"}'
+              acts_as_positioned :scope => :parent_id
               acts_as_customizable
               acts_as_tree
               before_destroy :check_integrity
               before_save    :check_default
               attr_protected :type
               validates_presence_of :name
               validates_uniqueness_of :name, :scope => [:type, :project_id]
               validates_length_of :name, :maximum => 30
               scope :shared, lambda { where(:project_id => nil) }
               scope :sorted, lambda { order(:position) }
               scope :active, lambda { where(:active => true) }
               scope :system, lambda { where(:project_id => nil) }
               scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
               def self.default
                 # Creates a fake default scope so Enumeration.default will check
                 # it's type.  STI subclasses will automatically add their own
                 # types to the finder.
                 if self.descends_from_active_record?
                   where(:is_default => true, :type => 'Enumeration').first
                 else
                   # STI classes are
                   where(:is_default => true).first
                 end
               end
               # Overloaded on concrete classes
               def option_name
                 nil
               end
               def check_default
                 if is_default? && is_default_changed?
                   Enumeration.where({:type => type}).update_all({:is_default => false})
                 end
               end
               # Overloaded on concrete classes
               def objects_count
               end
               def in_use?
                 self.objects_count != 0
               end
               # Is this enumeration overriding a system level enumeration?
               def is_override?
                 !self.parent.nil?
               end
               alias :destroy_without_reassign :destroy
               # Destroy the enumeration
               # If a enumeration is specified, objects are reassigned
               def destroy(reassign_to = nil)
                 if reassign_to && reassign_to.is_a?(Enumeration)
                   self.transfer_relations(reassign_to)
                 end
                 destroy_without_reassign
               end
               def <=>(enumeration)
                 position <=> enumeration.position
               end
               def to_s; name end
               # Returns the Subclasses of Enumeration.  Each Subclass needs to be
               # required in development mode.
               #
               # Note: subclasses is protected in ActiveRecord
               def self.get_subclasses
                 subclasses
               end
               # Does the +new+ Hash override the previous Enumeration?
               def self.overriding_change?(new, previous)
                 if (same_active_state?(new['active'], previous.active)) && same_custom_values?(new,previous)
                   return false
                 else
                   return true
                 end
               end
               # Does the +new+ Hash have the same custom values as the previous Enumeration?
               def self.same_custom_values?(new, previous)
                 previous.custom_field_values.each do |custom_value|
                   if custom_value.value != new["custom_field_values"][custom_value.custom_field_id.to_s]
                     return false
                   end
                 end
                 return true
               end
               # Are the new and previous fields equal?
               def self.same_active_state?(new, previous)
                 new = (new == "1" ? true : false)
                 return new == previous
               end
-              # Overrides acts_as_list reset_positions_in_list so that enumeration overrides
+              private
-              # get the same position as the overriden enumeration
-              def reset_positions_in_list
-                acts_as_list_class.where(scope_condition).reorder("#{position_column} ASC, id ASC").each_with_index do |item, i|
-                  acts_as_list_class.where("id = :id OR parent_id = :id", :id => item.id).
-                    update_all({position_column => (i + 1)})
-                end
-              end
-            private
               def check_integrity
                 raise "Cannot delete enumeration" if self.in_use?
               end
-              # Overrides acts_as_list add_to_list_bottom so that enumeration overrides
+              # Overrides Redmine::Acts::Positioned#set_default_position so that enumeration overrides
               # get the same position as the overriden enumeration
-              def add_to_list_bottom
+              def set_default_position
-                if parent
+                if position.nil? && parent
-                  self[position_column] = parent.position
+                  self.position = parent.position
-                else
+                end
-                  super
+                super
+              end
+              # Overrides Redmine::Acts::Positioned#update_position so that overrides get the same
+              # position as the overriden enumeration
+              def update_position
+                super
+                if position_changed?
+                  self.class.where.not(:parent_id => nil).update_all(
+                    "position = coalesce((
+                      select position
+                      from (select id, position from enumerations) as parent
+                      where parent_id = parent.id), 1)"
+                  )
                 end
               end
-              # Overrides acts_as_list remove_from_list so that enumeration overrides
+              # Overrides Redmine::Acts::Positioned#remove_position so that enumeration overrides
               # get the same position as the overriden enumeration
-              def remove_from_list
+              def remove_position
                 if parent_id.blank?
                   super
                 end
               end
             end
             # Force load the subclasses in development mode
             require_dependency 'time_entry_activity'
             require_dependency 'document_category'
             require_dependency 'issue_priority'

app/models/issue_status.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.
             class IssueStatus < ActiveRecord::Base
               before_destroy :check_integrity
               has_many :workflows, :class_name => 'WorkflowTransition', :foreign_key => "old_status_id"
               has_many :workflow_transitions_as_new_status, :class_name => 'WorkflowTransition', :foreign_key => "new_status_id"
-              acts_as_list
+              acts_as_positioned
               after_update :handle_is_closed_change
               before_destroy :delete_workflow_rules
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :default_done_ratio, :in => 0..100, :allow_nil => true
               attr_protected :id
               scope :sorted, lambda { order(:position) }
               scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
               # Update all the +Issues+ setting their done_ratio to the value of their +IssueStatus+
               def self.update_issue_done_ratios
                 if Issue.use_status_for_done_ratio?
                   IssueStatus.where("default_done_ratio >= 0").each do |status|
                     Issue.where({:status_id => status.id}).update_all({:done_ratio => status.default_done_ratio})
                   end
                 end
                 return Issue.use_status_for_done_ratio?
               end
               # Returns an array of all statuses the given role can switch to
               def new_statuses_allowed_to(roles, tracker, author=false, assignee=false)
                 self.class.new_statuses_allowed(self, roles, tracker, author, assignee)
               end
               alias :find_new_statuses_allowed_to :new_statuses_allowed_to
               def self.new_statuses_allowed(status, roles, tracker, author=false, assignee=false)
                 if roles.present? && tracker
                   status_id = status.try(:id) || 0
                   scope = IssueStatus.
                     joins(:workflow_transitions_as_new_status).
                     where(:workflows => {:old_status_id => status_id, :role_id => roles.map(&:id), :tracker_id => tracker.id})
                   unless author && assignee
                     if author || assignee
                       scope = scope.where("author = ? OR assignee = ?", author, assignee)
                     else
                       scope = scope.where("author = ? AND assignee = ?", false, false)
                     end
                   end
                   scope.uniq.to_a.sort
                 else
                   []
                 end
               end
               def <=>(status)
                 position <=> status.position
               end
               def to_s; name end
               private
               # Updates issues closed_on attribute when an existing status is set as closed.
               def handle_is_closed_change
                 if is_closed_changed? && is_closed == true
                   # First we update issues that have a journal for when the current status was set,
                   # a subselect is used to update all issues with a single query
                   subselect = "SELECT MAX(j.created_on) FROM #{Journal.table_name} j" +
                     " JOIN #{JournalDetail.table_name} d ON d.journal_id = j.id" +
                     " WHERE j.journalized_type = 'Issue' AND j.journalized_id = #{Issue.table_name}.id" +
                     " AND d.property = 'attr' AND d.prop_key = 'status_id' AND d.value = :status_id"
                   Issue.where(:status_id => id, :closed_on => nil).
                     update_all(["closed_on = (#{subselect})", {:status_id => id.to_s}])
                   # Then we update issues that don't have a journal which means the
                   # current status was set on creation
                   Issue.where(:status_id => id, :closed_on => nil).update_all("closed_on = created_on")
                 end
               end
               def check_integrity
                 if Issue.where(:status_id => id).any?
                   raise "This status is used by some issues"
                 elsif Tracker.where(:default_status_id => id).any?
                   raise "This status is used as the default status by some trackers"
                 end
               end
               # Deletes associated workflows
               def delete_workflow_rules
                 WorkflowRule.delete_all(["old_status_id = :id OR new_status_id = :id", {:id => id}])
               end
             end

app/models/role.rb +3 -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 Role < ActiveRecord::Base
               # Custom coder for the permissions attribute that should be an
               # array of symbols. Rails 3 uses Psych which can be *unbelievably*
               # slow on some platforms (eg. mingw32).
               class PermissionsAttributeCoder
                 def self.load(str)
                   str.to_s.scan(/:([a-z0-9_]+)/).flatten.map(&:to_sym)
                 end
                 def self.dump(value)
                   YAML.dump(value)
                 end
               end
               # Built-in roles
               BUILTIN_NON_MEMBER = 1
               BUILTIN_ANONYMOUS  = 2
               ISSUES_VISIBILITY_OPTIONS = [
                 ['all', :label_issues_visibility_all],
                 ['default', :label_issues_visibility_public],
                 ['own', :label_issues_visibility_own]
               ]
               TIME_ENTRIES_VISIBILITY_OPTIONS = [
                 ['all', :label_time_entries_visibility_all],
                 ['own', :label_time_entries_visibility_own]
               ]
               USERS_VISIBILITY_OPTIONS = [
                 ['all', :label_users_visibility_all],
                 ['members_of_visible_projects', :label_users_visibility_members_of_visible_projects]
               ]
               scope :sorted, lambda { order(:builtin, :position) }
               scope :givable, lambda { order(:position).where(:builtin => 0) }
               scope :builtin, lambda { |*args|
                 compare = (args.first == true ? 'not' : '')
                 where("#{compare} builtin = 0")
               }
               before_destroy :check_deletable
               has_many :workflow_rules, :dependent => :delete_all do
                 def copy(source_role)
                   WorkflowRule.copy(nil, source_role, nil, proxy_association.owner)
                 end
               end
               has_and_belongs_to_many :custom_fields, :join_table => "#{table_name_prefix}custom_fields_roles#{table_name_suffix}", :foreign_key => "role_id"
               has_and_belongs_to_many :managed_roles, :class_name => 'Role',
                 :join_table => "#{table_name_prefix}roles_managed_roles#{table_name_suffix}",
                 :association_foreign_key => "managed_role_id"
               has_many :member_roles, :dependent => :destroy
               has_many :members, :through => :member_roles
-              acts_as_list
+              acts_as_positioned :scope => :builtin
               serialize :permissions, ::Role::PermissionsAttributeCoder
               attr_protected :builtin
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :issues_visibility,
                 :in => ISSUES_VISIBILITY_OPTIONS.collect(&:first),
                 :if => lambda {|role| role.respond_to?(:issues_visibility) && role.issues_visibility_changed?}
               validates_inclusion_of :users_visibility,
                 :in => USERS_VISIBILITY_OPTIONS.collect(&:first),
                 :if => lambda {|role| role.respond_to?(:users_visibility) && role.users_visibility_changed?}
               validates_inclusion_of :time_entries_visibility,
                 :in => TIME_ENTRIES_VISIBILITY_OPTIONS.collect(&:first),
                 :if => lambda {|role| role.respond_to?(:time_entries_visibility) && role.time_entries_visibility_changed?}
               # Copies attributes from another role, arg can be an id or a Role
               def copy_from(arg, options={})
                 return unless arg.present?
                 role = arg.is_a?(Role) ? arg : Role.find_by_id(arg.to_s)
                 self.attributes = role.attributes.dup.except("id", "name", "position", "builtin", "permissions")
                 self.permissions = role.permissions.dup
                 self
               end
               def permissions=(perms)
                 perms = perms.collect {|p| p.to_sym unless p.blank? }.compact.uniq if perms
                 write_attribute(:permissions, perms)
               end
               def add_permission!(*perms)
                 self.permissions = [] unless permissions.is_a?(Array)
                 permissions_will_change!
                 perms.each do |p|
                   p = p.to_sym
                   permissions << p unless permissions.include?(p)
                 end
                 save!
               end
               def remove_permission!(*perms)
                 return unless permissions.is_a?(Array)
                 permissions_will_change!
                 perms.each { |p| permissions.delete(p.to_sym) }
                 save!
               end
               # Returns true if the role has the given permission
               def has_permission?(perm)
                 !permissions.nil? && permissions.include?(perm.to_sym)
               end
               def consider_workflow?
                 has_permission?(:add_issues) || has_permission?(:edit_issues)
               end
               def <=>(role)
                 if role
                   if builtin == role.builtin
                     position <=> role.position
                   else
                     builtin <=> role.builtin
                   end
                 else
                   -1
                 end
               end
               def to_s
                 name
               end
               def name
                 case builtin
                 when 1; l(:label_role_non_member, :default => read_attribute(:name))
                 when 2; l(:label_role_anonymous,  :default => read_attribute(:name))
                 else; read_attribute(:name)
                 end
               end
               # Return true if the role is a builtin role
               def builtin?
                 self.builtin != 0
               end
               # Return true if the role is the anonymous role
               def anonymous?
                 builtin == 2
               end
               # Return true if the role is a project member role
               def member?
                 !self.builtin?
               end
               # Return true if role is allowed to do the specified action
               # action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               def allowed_to?(action)
                 if action.is_a? Hash
                   allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                 else
                   allowed_permissions.include? action
                 end
               end
               # Return all the permissions that can be given to the role
               def setable_permissions
                 setable_permissions = Redmine::AccessControl.permissions - Redmine::AccessControl.public_permissions
                 setable_permissions -= Redmine::AccessControl.members_only_permissions if self.builtin == BUILTIN_NON_MEMBER
                 setable_permissions -= Redmine::AccessControl.loggedin_only_permissions if self.builtin == BUILTIN_ANONYMOUS
                 setable_permissions
               end
               # Find all the roles that can be given to a project member
               def self.find_all_givable
                 Role.givable.to_a
               end
               # Return the builtin 'non member' role.  If the role doesn't exist,
               # it will be created on the fly.
               def self.non_member
                 find_or_create_system_role(BUILTIN_NON_MEMBER, 'Non member')
               end
               # Return the builtin 'anonymous' role.  If the role doesn't exist,
               # it will be created on the fly.
               def self.anonymous
                 find_or_create_system_role(BUILTIN_ANONYMOUS, 'Anonymous')
               end
             private
               def allowed_permissions
                 @allowed_permissions ||= permissions + Redmine::AccessControl.public_permissions.collect {|p| p.name}
               end
               def allowed_actions
                 @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
               end
               def check_deletable
                 raise "Cannot delete role" if members.any?
                 raise "Cannot delete builtin role" if builtin?
               end
               def self.find_or_create_system_role(builtin, name)
                 role = where(:builtin => builtin).first
                 if role.nil?
-                  role = create(:name => name, :position => 0) do |r|
+                  role = create(:name => name) do |r|
                     r.builtin = builtin
                   end
-                  raise "Unable to create the #{name} role." if role.new_record?
+                  raise "Unable to create the #{name} role (#{role.errors.full_messages.join(',')})." if role.new_record?
                 end
                 role
               end
             end

app/models/tracker.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.
             class Tracker < ActiveRecord::Base
               CORE_FIELDS_UNDISABLABLE = %w(project_id tracker_id subject description priority_id is_private).freeze
               # Fields that can be disabled
               # Other (future) fields should be appended, not inserted!
               CORE_FIELDS = %w(assigned_to_id category_id fixed_version_id parent_issue_id start_date due_date estimated_hours done_ratio).freeze
               CORE_FIELDS_ALL = (CORE_FIELDS_UNDISABLABLE + CORE_FIELDS).freeze
               before_destroy :check_integrity
               belongs_to :default_status, :class_name => 'IssueStatus'
               has_many :issues
               has_many :workflow_rules, :dependent => :delete_all do
                 def copy(source_tracker)
                   WorkflowRule.copy(source_tracker, nil, proxy_association.owner, nil)
                 end
               end
               has_and_belongs_to_many :projects
               has_and_belongs_to_many :custom_fields, :class_name => 'IssueCustomField', :join_table => "#{table_name_prefix}custom_fields_trackers#{table_name_suffix}", :association_foreign_key => 'custom_field_id'
-              acts_as_list
+              acts_as_positioned
               attr_protected :fields_bits
               validates_presence_of :default_status
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
               scope :sorted, lambda { order(:position) }
               scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
               def to_s; name end
               def <=>(tracker)
                 position <=> tracker.position
               end
               # Returns an array of IssueStatus that are used
               # in the tracker's workflows
               def issue_statuses
                 @issue_statuses ||= IssueStatus.where(:id => issue_status_ids).to_a.sort
               end
               def issue_status_ids
                 if new_record?
                   []
                 else
                   @issue_status_ids ||= WorkflowTransition.where(:tracker_id => id).uniq.pluck(:old_status_id, :new_status_id).flatten.uniq
                 end
               end
               def disabled_core_fields
                 i = -1
                 @disabled_core_fields ||= CORE_FIELDS.select { i += 1; (fields_bits || 0) & (2 ** i) != 0}
               end
               def core_fields
                 CORE_FIELDS - disabled_core_fields
               end
               def core_fields=(fields)
                 raise ArgumentError.new("Tracker.core_fields takes an array") unless fields.is_a?(Array)
                 bits = 0
                 CORE_FIELDS.each_with_index do |field, i|
                   unless fields.include?(field)
                     bits |= 2 ** i
                   end
                 end
                 self.fields_bits = bits
                 @disabled_core_fields = nil
                 core_fields
               end
               # Returns the fields that are disabled for all the given trackers
               def self.disabled_core_fields(trackers)
                 if trackers.present?
                   trackers.map(&:disabled_core_fields).reduce(:&)
                 else
                   []
                 end
               end
               # Returns the fields that are enabled for one tracker at least
               def self.core_fields(trackers)
                 if trackers.present?
                   trackers.uniq.map(&:core_fields).reduce(:|)
                 else
                   CORE_FIELDS.dup
                 end
               end
             private
               def check_integrity
                 raise Exception.new("Cannot delete tracker") if Issue.where(:tracker_id => self.id).any?
               end
             end

lib/redmine.rb +2 0

             # 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 'redmine/core_ext'
             begin
               require 'rmagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             begin
               require 'redcarpet' unless Object.const_defined?(:Redcarpet)
             rescue LoadError
               # Redcarpet is not available
             end
+            require 'redmine/acts/positioned'
             require 'redmine/scm/base'
             require 'redmine/access_control'
             require 'redmine/access_keys'
             require 'redmine/activity'
             require 'redmine/activity/fetcher'
             require 'redmine/ciphering'
             require 'redmine/codeset_util'
             require 'redmine/field_format'
             require 'redmine/menu_manager'
             require 'redmine/notifiable'
             require 'redmine/platform'
             require 'redmine/mime_type'
             require 'redmine/notifiable'
             require 'redmine/search'
             require 'redmine/syntax_highlighting'
             require 'redmine/thumbnail'
             require 'redmine/unified_diff'
             require 'redmine/utils'
             require 'redmine/version'
             require 'redmine/wiki_formatting'
             require 'redmine/default_data/loader'
             require 'redmine/helpers/calendar'
             require 'redmine/helpers/diff'
             require 'redmine/helpers/gantt'
             require 'redmine/helpers/time_report'
             require 'redmine/views/other_formats_builder'
             require 'redmine/views/labelled_form_builder'
             require 'redmine/views/builders'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/hook/listener'
             require 'redmine/hook/view_listener'
             require 'redmine/plugin'
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true, :read => true
               map.permission :search_project, {:search => :index}, :public => true, :read => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :close_project, {:projects => [:close, :reopen]}, :require => :member, :read => true
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :view_members, {:members => [:index, :show]}, :public => true, :read => true
               map.permission :manage_members, {:projects => :settings, :members => [:index, :show, :new, :create, :update, :destroy, :autocomplete]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]},
                                               :read => true
                 map.permission :add_issues, {:issues => [:new, :create], :attachments => :upload}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update], :journals => [:new], :attachments => :upload}
                 map.permission :copy_issues, {:issues => [:new, :create, :bulk_edit, :bulk_update], :attachments => :upload}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new], :attachments => :upload}
                 map.permission :edit_issue_notes, {:journals => [:edit, :update]}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => [:edit, :update]}, :require => :loggedin
                 map.permission :view_private_notes, {}, :read => true, :require => :member
                 map.permission :set_notes_private, {}, :require => :member
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}, :read => true
                 map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
                 map.permission :import_issues, {:imports => [:new, :create, :settings, :mapping, :run, :show]}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, {:timelog => [:index, :report, :show]}, :read => true
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy], :attachments => :upload}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true, :read => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :add_documents, {:documents => [:new, :create, :add_attachment], :attachments => :upload}, :require => :loggedin
                 map.permission :edit_documents, {:documents => [:edit, :update, :add_attachment], :attachments => :upload}, :require => :loggedin
                 map.permission :delete_documents, {:documents => [:destroy]}, :require => :loggedin
                 map.permission :view_documents, {:documents => [:index, :show, :download]}, :read => true
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create], :attachments => :upload}, :require => :loggedin
                 map.permission :view_files, {:files => :index, :versions => :download}, :read => true
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => [:destroy, :destroy_version]}, :require => :member
                 map.permission :view_wiki_pages, {:wiki => [:index, :show, :special, :date_index]}, :read => true
                 map.permission :export_wiki_pages, {:wiki => [:export]}, :read => true
                 map.permission :view_wiki_edits, {:wiki => [:history, :diff, :annotate]}, :read => true
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment], :attachments => :upload
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:new, :create, :edit, :update, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, {:repositories => [:show, :browse, :entry, :raw, :annotate, :changes, :diff, :stats, :graph]}, :read => true
                 map.permission :view_changesets, {:repositories => [:show, :revisions, :revision]}, :read => true
                 map.permission :commit_access, {}
                 map.permission :manage_related_issues, {:repositories => [:add_related_issue, :remove_related_issue]}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true, :read => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote], :attachments => :upload}
                 map.permission :edit_messages, {:messages => :edit, :attachments => :upload}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit, :attachments => :upload}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, {:calendars => [:show, :update]}, :read => true
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, {:gantts => [:show, :update]}, :read => true
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, :register_path, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => {:method => 'post'}, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new', :copy_from => nil }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) },
                           :if => Proc.new { |p| p.trackers.any? },
                           :permission => :add_issues
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'show', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show', :repository_id => nil, :path => nil, :rev => nil },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile
               format.register :markdown if Object.const_defined?(:Redcarpet)
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/fixtures/custom_fields.yml +1 0

             ---
             custom_fields_001:
               name: Database
               regexp: ""
               is_for_all: true
               is_filter: true
               type: IssueCustomField
               possible_values:
               - MySQL
               - PostgreSQL
               - Oracle
               id: 1
               is_required: false
               field_format: list
               default_value: ""
               editable: true
               position: 2
             custom_fields_002:
               name: Searchable field
               min_length: 1
               regexp: ""
               is_for_all: true
               is_filter: true
               type: IssueCustomField
               max_length: 100
               possible_values: ""
               id: 2
               is_required: false
               field_format: string
               searchable: true
               default_value: "Default string"
               editable: true
               position: 1
             custom_fields_003:
               name: Development status
               regexp: ""
               is_for_all: false
               is_filter: true
               type: ProjectCustomField
               possible_values:
               - Stable
               - Beta
               - Alpha
               - Planning
               id: 3
               is_required: false
               field_format: list
               default_value: ""
               editable: true
               position: 1
             custom_fields_004:
               name: Phone number
               regexp: ""
               is_for_all: false
               type: UserCustomField
               possible_values: ""
               id: 4
               is_required: false
               field_format: string
               default_value: ""
               editable: true
               position: 1
             custom_fields_005:
               name: Money
               regexp: ""
               is_for_all: false
               type: UserCustomField
               possible_values: ""
               id: 5
               is_required: false
               field_format: float
               default_value: ""
               editable: true
               position: 2
             custom_fields_006:
               name: Float field
               regexp: ""
               is_for_all: true
               type: IssueCustomField
               possible_values: ""
               id: 6
               is_required: false
               field_format: float
               default_value: ""
               editable: true
               position: 3
             custom_fields_007:
               name: Billable
               regexp: ""
               is_for_all: false
               is_filter: true
               type: TimeEntryActivityCustomField
               possible_values: ""
               id: 7
               is_required: false
               field_format: bool
               default_value: ""
               editable: true
               position: 1
             custom_fields_008:
               name: Custom date
               regexp: ""
               is_for_all: true
               is_filter: false
               type: IssueCustomField
               possible_values: ""
               id: 8
               is_required: false
               field_format: date
               default_value: ""
               editable: true
               position: 4
             custom_fields_009:
               name: Project 1 cf
               regexp: ""
               is_for_all: false
               is_filter: true
               type: IssueCustomField
               possible_values: ""
               id: 9
               is_required: false
               field_format: date
               default_value: ""
               editable: true
               position: 5
             custom_fields_010:
               name: Overtime
               regexp: ""
               is_for_all: false
               is_filter: false
               type: TimeEntryCustomField
               possible_values: ""
               id: 10
               is_required: false
               field_format: bool
               default_value: 0
               editable: true
               position: 1
             custom_fields_011:
               id: 11
               name: Binary
               type: CustomField
               possible_values:
               - !binary |
                 SGXDqWzDp2prc2Tigqw2NTTDuQ==
               - Other value
               field_format: list
+              position: 1

test/fixtures/enumerations.yml +2 0

             ---
             enumerations_001:
               name: Uncategorized
               id: 1
               type: DocumentCategory
               active: true
               position: 1
             enumerations_002:
               name: User documentation
               id: 2
               type: DocumentCategory
               active: true
               position: 2
             enumerations_003:
               name: Technical documentation
               id: 3
               type: DocumentCategory
               active: true
               position: 3
             enumerations_004:
               name: Low
               id: 4
               type: IssuePriority
               active: true
               position: 1
               position_name: lowest
             enumerations_005:
               name: Normal
               id: 5
               type: IssuePriority
               is_default: true
               active: true
               position: 2
               position_name: default
             enumerations_006:
               name: High
               id: 6
               type: IssuePriority
               active: true
               position: 3
               position_name: high3
             enumerations_007:
               name: Urgent
               id: 7
               type: IssuePriority
               active: true
               position: 4
               position_name: high2
             enumerations_008:
               name: Immediate
               id: 8
               type: IssuePriority
               active: true
               position: 5
               position_name: highest
             enumerations_009:
               name: Design
               id: 9
               type: TimeEntryActivity
               position: 1
               active: true
             enumerations_010:
               name: Development
               id: 10
               type: TimeEntryActivity
               position: 2
               is_default: true
               active: true
             enumerations_011:
               name: QA
               id: 11
               type: TimeEntryActivity
               position: 3
               active: true
             enumerations_012:
               name: Default Enumeration
               id: 12
               type: Enumeration
               is_default: true
               active: true
+              position: 1
             enumerations_013:
               name: Another Enumeration
               id: 13
               type: Enumeration
               active: true
+              position: 2
             enumerations_014:
               name: Inactive Activity
               id: 14
               type: TimeEntryActivity
               position: 4
               active: false
             enumerations_015:
               name: Inactive Priority
               id: 15
               type: IssuePriority
               position: 6
               active: false
             enumerations_016:
               name: Inactive Document Category
               id: 16
               type: DocumentCategory
               active: false
               position: 4

test/fixtures/roles.yml +2 -2

             ---
             roles_001:
               name: Manager
               id: 1
               builtin: 0
               issues_visibility: all
               users_visibility: all
               permissions: |
                 ---
                 - :add_project
                 - :edit_project
                 - :close_project
                 - :select_project_modules
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :view_issues
                 - :add_issues
                 - :edit_issues
                 - :copy_issues
                 - :manage_issue_relations
                 - :manage_subtasks
                 - :add_issue_notes
                 - :delete_issues
                 - :view_issue_watchers
                 - :add_issue_watchers
                 - :set_issues_private
                 - :set_notes_private
                 - :view_private_notes
                 - :delete_issue_watchers
                 - :manage_public_queries
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :edit_time_entries
                 - :delete_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :add_documents
                 - :edit_documents
                 - :delete_documents
                 - :view_wiki_pages
                 - :export_wiki_pages
                 - :view_wiki_edits
                 - :edit_wiki_pages
                 - :delete_wiki_pages_attachments
                 - :protect_wiki_pages
                 - :delete_wiki_pages
                 - :rename_wiki_pages
                 - :add_messages
                 - :edit_messages
                 - :delete_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :manage_repository
                 - :view_changesets
                 - :manage_related_issues
                 - :manage_project_activities
                 - :import_issues
               position: 1
             roles_002:
               name: Developer
               id: 2
               builtin: 0
               issues_visibility: default
               users_visibility: all
               permissions: |
                 ---
                 - :edit_project
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :view_issues
                 - :add_issues
                 - :edit_issues
                 - :copy_issues
                 - :manage_issue_relations
                 - :manage_subtasks
                 - :add_issue_notes
                 - :delete_issues
                 - :view_issue_watchers
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :edit_own_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :add_documents
                 - :edit_documents
                 - :delete_documents
                 - :view_wiki_pages
                 - :view_wiki_edits
                 - :edit_wiki_pages
                 - :protect_wiki_pages
                 - :delete_wiki_pages
                 - :add_messages
                 - :edit_own_messages
                 - :delete_own_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 2
             roles_003:
               name: Reporter
               id: 3
               builtin: 0
               issues_visibility: default
               users_visibility: all
               permissions: |
                 ---
                 - :edit_project
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :view_issues
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :view_issue_watchers
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :add_documents
                 - :edit_documents
                 - :delete_documents
                 - :view_wiki_pages
                 - :view_wiki_edits
                 - :edit_wiki_pages
                 - :delete_wiki_pages
                 - :add_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 3
             roles_004:
               name: Non member
               id: 4
               builtin: 1
               issues_visibility: default
               users_visibility: all
               permissions: |
                 ---
                 - :view_issues
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :comment_news
                 - :view_documents
                 - :view_wiki_pages
                 - :view_wiki_edits
                 - :edit_wiki_pages
                 - :add_messages
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
-              position: 4
+              position: 1
             roles_005:
               name: Anonymous
               id: 5
               builtin: 2
               issues_visibility: default
               users_visibility: all
               permissions: |
                 ---
                 - :view_issues
                 - :add_issue_notes
                 - :view_gantt
                 - :view_calendar
                 - :view_time_entries
                 - :view_documents
                 - :view_wiki_pages
                 - :view_wiki_edits
                 - :view_files
                 - :browse_repository
                 - :view_changesets
-              position: 5
+              position: 1

test/functional/roles_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 RolesControllerTest < ActionController::TestCase
               fixtures :roles, :users, :members, :member_roles, :workflows, :trackers
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:roles)
                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
                 assert_select 'a[href="/roles/1/edit"]', :text => 'Manager'
               end
               def test_new
                 get :new
                 assert_response :success
                 assert_template 'new'
               end
               def test_new_with_copy
                 copy_from = Role.find(2)
                 get :new, :copy => copy_from.id.to_s
                 assert_response :success
                 assert_template 'new'
                 role = assigns(:role)
                 assert_equal copy_from.permissions, role.permissions
                 assert_select 'form' do
                   # blank name
                   assert_select 'input[name=?][value=""]', 'role[name]'
                   # edit_project permission checked
                   assert_select 'input[type=checkbox][name=?][value=edit_project][checked=checked]', 'role[permissions][]'
                   # add_project permission not checked
                   assert_select 'input[type=checkbox][name=?][value=add_project]', 'role[permissions][]'
                   assert_select 'input[type=checkbox][name=?][value=add_project][checked=checked]', 'role[permissions][]', 0
                   # workflow copy selected
                   assert_select 'select[name=?]', 'copy_workflow_from' do
                     assert_select 'option[value="2"][selected=selected]'
                   end
                 end
               end
               def test_create_with_validaton_failure
                 post :create, :role => {:name => '',
                                      :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
                                      :assignable => '0'}
                 assert_response :success
                 assert_template 'new'
                 assert_select 'div#errorExplanation'
               end
               def test_create_without_workflow_copy
                 post :create, :role => {:name => 'RoleWithoutWorkflowCopy',
                                      :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
                                      :assignable => '0'}
                 assert_redirected_to '/roles'
                 role = Role.find_by_name('RoleWithoutWorkflowCopy')
                 assert_not_nil role
                 assert_equal [:add_issues, :edit_issues, :log_time], role.permissions
                 assert !role.assignable?
               end
               def test_create_with_workflow_copy
                 post :create, :role => {:name => 'RoleWithWorkflowCopy',
                                      :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
                                      :assignable => '0'},
                            :copy_workflow_from => '1'
                 assert_redirected_to '/roles'
                 role = Role.find_by_name('RoleWithWorkflowCopy')
                 assert_not_nil role
                 assert_equal Role.find(1).workflow_rules.size, role.workflow_rules.size
               end
               def test_edit
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_equal Role.find(1), assigns(:role)
                 assert_select 'select[name=?]', 'role[issues_visibility]'
               end
               def test_edit_anonymous
                 get :edit, :id => Role.anonymous.id
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'select[name=?]', 'role[issues_visibility]', 0
               end
               def test_edit_invalid_should_respond_with_404
                 get :edit, :id => 999
                 assert_response 404
               end
               def test_update
                 put :update, :id => 1,
                             :role => {:name => 'Manager',
                                       :permissions => ['edit_project', ''],
                                       :assignable => '0'}
                 assert_redirected_to '/roles'
                 role = Role.find(1)
                 assert_equal [:edit_project], role.permissions
               end
               def test_update_with_failure
                 put :update, :id => 1, :role => {:name => ''}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 r = Role.create!(:name => 'ToBeDestroyed', :permissions => [:view_wiki_pages])
                 delete :destroy, :id => r
                 assert_redirected_to '/roles'
                 assert_nil Role.find_by_id(r.id)
               end
               def test_destroy_role_in_use
                 delete :destroy, :id => 1
                 assert_redirected_to '/roles'
                 assert_equal 'This role is in use and cannot be deleted.', flash[:error]
                 assert_not_nil Role.find_by_id(1)
               end
               def test_get_permissions
                 get :permissions
                 assert_response :success
                 assert_template 'permissions'
                 assert_not_nil assigns(:roles)
                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
                 assert_select 'input[name=?][type=checkbox][value=add_issues][checked=checked]', 'permissions[3][]'
                 assert_select 'input[name=?][type=checkbox][value=delete_issues]:not([checked])', 'permissions[3][]'
               end
               def test_post_permissions
                 post :permissions, :permissions => { '0' => '', '1' => ['edit_issues'], '3' => ['add_issues', 'delete_issues']}
                 assert_redirected_to '/roles'
                 assert_equal [:edit_issues], Role.find(1).permissions
                 assert_equal [:add_issues, :delete_issues], Role.find(3).permissions
                 assert Role.find(2).permissions.empty?
               end
               def test_clear_all_permissions
                 post :permissions, :permissions => { '0' => '' }
                 assert_redirected_to '/roles'
                 assert Role.find(1).permissions.empty?
               end
               def test_move_highest
                 put :update, :id => 3, :role => {:move_to => 'highest'}
                 assert_redirected_to '/roles'
                 assert_equal 1, Role.find(3).position
               end
               def test_move_higher
                 position = Role.find(3).position
                 put :update, :id => 3, :role => {:move_to => 'higher'}
                 assert_redirected_to '/roles'
                 assert_equal position - 1, Role.find(3).position
               end
               def test_move_lower
                 position = Role.find(2).position
                 put :update, :id => 2, :role => {:move_to => 'lower'}
                 assert_redirected_to '/roles'
                 assert_equal position + 1, Role.find(2).position
               end
               def test_move_lowest
                 put :update, :id => 2, :role => {:move_to => 'lowest'}
                 assert_redirected_to '/roles'
-                assert_equal Role.count, Role.find(2).position
+                assert_equal Role.givable.count, Role.find(2).position
               end
             end

test/object_helpers.rb +6 -1

             module ObjectHelpers
               def User.generate!(attributes={})
                 @generated_user_login ||= 'user0'
                 @generated_user_login.succ!
                 user = User.new(attributes)
                 user.login = @generated_user_login.dup if user.login.blank?
                 user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
                 user.firstname = "Bob" if user.firstname.blank?
                 user.lastname = "Doe" if user.lastname.blank?
                 yield user if block_given?
                 user.save!
                 user
               end
               def User.add_to_project(user, project, roles=nil)
                 roles = Role.find(1) if roles.nil?
                 roles = [roles] if roles.is_a?(Role)
                 Member.create!(:principal => user, :project => project, :roles => roles)
               end
               def Group.generate!(attributes={})
                 @generated_group_name ||= 'Group 0'
                 @generated_group_name.succ!
                 group = Group.new(attributes)
                 group.name = @generated_group_name.dup if group.name.blank?
                 yield group if block_given?
                 group.save!
                 group
               end
               def Project.generate!(attributes={})
                 @generated_project_identifier ||= 'project-0000'
                 @generated_project_identifier.succ!
                 project = Project.new(attributes)
                 project.name = @generated_project_identifier.dup if project.name.blank?
                 project.identifier = @generated_project_identifier.dup if project.identifier.blank?
                 yield project if block_given?
                 project.save!
                 project
               end
               def Project.generate_with_parent!(*args)
                 attributes = args.last.is_a?(Hash) ? args.pop : {}
                 parent = args.size > 0 ? args.first : Project.generate!
                 project = Project.generate!(attributes) do |p|
                   p.parent = parent
                 end
                 parent.reload if parent
                 project
               end
               def IssueStatus.generate!(attributes={})
                 @generated_status_name ||= 'Status 0'
                 @generated_status_name.succ!
                 status = IssueStatus.new(attributes)
                 status.name = @generated_status_name.dup if status.name.blank?
                 yield status if block_given?
                 status.save!
                 status
               end
-              def Tracker.generate!(attributes={})
+              def Tracker.generate(attributes={})
                 @generated_tracker_name ||= 'Tracker 0'
                 @generated_tracker_name.succ!
                 tracker = Tracker.new(attributes)
                 tracker.name = @generated_tracker_name.dup if tracker.name.blank?
                 tracker.default_status ||= IssueStatus.order('position').first || IssueStatus.generate!
                 yield tracker if block_given?
+                tracker
+              end
+              def Tracker.generate!(attributes={}, &block)
+                tracker = Tracker.generate(attributes, &block)
                 tracker.save!
                 tracker
               end
               def Role.generate!(attributes={})
                 @generated_role_name ||= 'Role 0'
                 @generated_role_name.succ!
                 role = Role.new(attributes)
                 role.name = @generated_role_name.dup if role.name.blank?
                 yield role if block_given?
                 role.save!
                 role
               end
               # Generates an unsaved Issue
               def Issue.generate(attributes={})
                 issue = Issue.new(attributes)
                 issue.project ||= Project.find(1)
                 issue.tracker ||= issue.project.trackers.first
                 issue.subject = 'Generated' if issue.subject.blank?
                 issue.author ||= User.find(2)
                 yield issue if block_given?
                 issue
               end
               # Generates a saved Issue
               def Issue.generate!(attributes={}, &block)
                 issue = Issue.generate(attributes, &block)
                 issue.save!
                 issue
               end
               # Generates an issue with 2 children and a grandchild
               def Issue.generate_with_descendants!(attributes={})
                 issue = Issue.generate!(attributes)
                 child = Issue.generate!(:project => issue.project, :subject => 'Child1', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child2', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child11', :parent_issue_id => child.id)
                 issue.reload
               end
               def Issue.generate_with_child!(attributes={})
                 issue = Issue.generate!(attributes)
                 Issue.generate!(:parent_issue_id => issue.id)
                 issue.reload
               end
               def Journal.generate!(attributes={})
                 journal = Journal.new(attributes)
                 journal.user ||= User.first
                 journal.journalized ||= Issue.first
                 yield journal if block_given?
                 journal.save!
                 journal
               end
               def Version.generate!(attributes={})
                 @generated_version_name ||= 'Version 0'
                 @generated_version_name.succ!
                 version = Version.new(attributes)
                 version.name = @generated_version_name.dup if version.name.blank?
                 version.project ||= Project.find(1)
                 yield version if block_given?
                 version.save!
                 version
               end
               def TimeEntry.generate!(attributes={})
                 entry = TimeEntry.new(attributes)
                 entry.user ||= User.find(2)
                 entry.issue ||= Issue.find(1) unless entry.project
                 entry.project ||= entry.issue.project
                 entry.activity ||= TimeEntryActivity.first
                 entry.spent_on ||= Date.today
                 entry.hours ||= 1.0
                 entry.save!
                 entry
               end
               def AuthSource.generate!(attributes={})
                 @generated_auth_source_name ||= 'Auth 0'
                 @generated_auth_source_name.succ!
                 source = AuthSource.new(attributes)
                 source.name = @generated_auth_source_name.dup if source.name.blank?
                 yield source if block_given?
                 source.save!
                 source
               end
               def Board.generate!(attributes={})
                 @generated_board_name ||= 'Forum 0'
                 @generated_board_name.succ!
                 board = Board.new(attributes)
                 board.name = @generated_board_name.dup if board.name.blank?
                 board.description = @generated_board_name.dup if board.description.blank?
                 yield board if block_given?
                 board.save!
                 board
               end
               def Attachment.generate!(attributes={})
                 @generated_filename ||= 'testfile0'
                 @generated_filename.succ!
                 attributes = attributes.dup
                 attachment = Attachment.new(attributes)
                 attachment.container ||= Issue.find(1)
                 attachment.author ||= User.find(2)
                 attachment.filename = @generated_filename.dup if attachment.filename.blank?
                 attachment.save!
                 attachment
               end
               def CustomField.generate!(attributes={})
                 @generated_custom_field_name ||= 'Custom field 0'
                 @generated_custom_field_name.succ!
                 field = new(attributes)
                 field.name = @generated_custom_field_name.dup if field.name.blank?
                 field.field_format = 'string' if field.field_format.blank?
                 yield field if block_given?
                 field.save!
                 field
               end
               def IssueCustomField.generate!(attributes={})
                 super do |field|
                   field.is_for_all = true unless attributes.key?(:is_for_all)
                   field.tracker_ids = Tracker.all.ids unless attributes.key?(:tracker_ids) || attributes.key?(:trackers)
                 end
               end
               def Changeset.generate!(attributes={})
                 @generated_changeset_rev ||= '123456'
                 @generated_changeset_rev.succ!
                 changeset = new(attributes)
                 changeset.repository ||= Project.find(1).repository
                 changeset.revision ||= @generated_changeset_rev
                 changeset.committed_on ||= Time.now
                 yield changeset if block_given?
                 changeset.save!
                 changeset
               end
               def Query.generate!(attributes={})
                 query = new(attributes)
                 query.name = "Generated query" if query.name.blank?
                 query.user ||= User.find(1)
                 query.save!
                 query
               end
               def generate_import(fixture_name='import_issues.csv')
                 import = IssueImport.new
                 import.user_id = 2
                 import.file = uploaded_test_file(fixture_name, 'text/csv')
                 import.save!
                 import
               end
               def generate_import_with_mapping(fixture_name='import_issues.csv')
                 import = generate_import(fixture_name)
                 import.settings = {
                   'separator' => ";", 'wrapper' => '"', 'encoding' => "UTF-8",
                   'mapping' => {'project_id' => '1', 'tracker_id' => '2', 'subject' => '1'}
                 }
                 import.save!
                 import
               end
             end
             module TrackerObjectHelpers
               def generate_transitions!(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 if args.size == 1
                   args << args.first
                 end
                 if options[:clear]
                   WorkflowTransition.where(:tracker_id => id).delete_all
                 end
                 args.each_cons(2) do |old_status_id, new_status_id|
                   WorkflowTransition.create!(
                     :tracker => self,
                     :role_id => (options[:role_id] || 1),
                     :old_status_id => old_status_id,
                     :new_status_id => new_status_id
                   )
                 end
               end
             end
             Tracker.send :include, TrackerObjectHelpers
             module IssueObjectHelpers
               def close!
                 self.status = IssueStatus.where(:is_closed => true).first
                 save!
               end
               def generate_child!(attributes={})
                 Issue.generate!(attributes.merge(:parent_issue_id => self.id))
               end
             end
             Issue.send :include, IssueObjectHelpers

test/unit/enumeration_test.rb +1 0

             # 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 EnumerationTest < ActiveSupport::TestCase
               fixtures :enumerations, :issues, :custom_fields, :custom_values
               def test_objects_count
                 # low priority
                 assert_equal 6, Enumeration.find(4).objects_count
                 # urgent
                 assert_equal 0, Enumeration.find(7).objects_count
               end
               def test_in_use
                 # low priority
                 assert Enumeration.find(4).in_use?
                 # urgent
                 assert !Enumeration.find(7).in_use?
               end
               def test_default
                 e = Enumeration.default
                 assert e.is_a?(Enumeration)
                 assert e.is_default?
                 assert e.active?
                 assert_equal 'Default Enumeration', e.name
               end
               def test_default_non_active
                 e = Enumeration.find(12)
                 assert e.is_a?(Enumeration)
                 assert e.is_default?
                 assert e.active?
                 e.update_attributes(:active => false)
                 assert e.is_default?
                 assert !e.active?
               end
               def test_create
                 e = Enumeration.new(:name => 'Not default', :is_default => false)
                 e.type = 'Enumeration'
                 assert e.save
                 assert_equal 'Default Enumeration', Enumeration.default.name
               end
               def test_create_as_default
                 e = Enumeration.new(:name => 'Very urgent', :is_default => true)
                 e.type = 'Enumeration'
                 assert e.save
                 assert_equal e, Enumeration.default
               end
               def test_update_default
                 e = Enumeration.default
                 e.update_attributes(:name => 'Changed', :is_default => true)
                 assert_equal e, Enumeration.default
               end
               def test_update_default_to_non_default
                 e = Enumeration.default
                 e.update_attributes(:name => 'Changed', :is_default => false)
                 assert_nil Enumeration.default
               end
               def test_change_default
                 e = Enumeration.find_by_name('Default Enumeration')
                 e.update_attributes(:name => 'Changed Enumeration', :is_default => true)
                 assert_equal e, Enumeration.default
               end
               def test_destroy_with_reassign
                 Enumeration.find(4).destroy(Enumeration.find(6))
                 assert_nil Issue.where(:priority_id => 4).first
                 assert_equal 6, Enumeration.find(6).objects_count
               end
               def test_should_be_customizable
                 assert Enumeration.included_modules.include?(Redmine::Acts::Customizable::InstanceMethods)
               end
               def test_should_belong_to_a_project
                 association = Enumeration.reflect_on_association(:project)
                 assert association, "No Project association found"
                 assert_equal :belongs_to, association.macro
               end
               def test_should_act_as_tree
                 enumeration = Enumeration.find(4)
                 assert enumeration.respond_to?(:parent)
                 assert enumeration.respond_to?(:children)
               end
               def test_is_override
                 # Defaults to off
                 enumeration = Enumeration.find(4)
                 assert !enumeration.is_override?
                 # Setup as an override
                 enumeration.parent = Enumeration.find(5)
                 assert enumeration.is_override?
               end
               def test_get_subclasses
                 classes = Enumeration.get_subclasses
                 assert_include IssuePriority, classes
                 assert_include DocumentCategory, classes
                 assert_include TimeEntryActivity, classes
                 classes.each do |klass|
                   assert_equal Enumeration, klass.superclass
                 end
               end
               def test_list_should_be_scoped_for_each_type
                 Enumeration.delete_all
                 a = IssuePriority.create!(:name => 'A')
                 b = IssuePriority.create!(:name => 'B')
                 c = DocumentCategory.create!(:name => 'C')
                 assert_equal [1, 2, 1], [a, b, c].map(&:reload).map(&:position)
               end
               def test_override_should_be_created_with_same_position_as_parent
                 Enumeration.delete_all
                 a = IssuePriority.create!(:name => 'A')
                 b = IssuePriority.create!(:name => 'B')
                 override = IssuePriority.create!(:name => 'BB', :parent_id => b.id)
                 assert_equal [1, 2, 2], [a, b, override].map(&:reload).map(&:position)
               end
               def test_override_position_should_be_updated_with_parent_position
                 Enumeration.delete_all
                 a = IssuePriority.create!(:name => 'A')
                 b = IssuePriority.create!(:name => 'B')
                 override = IssuePriority.create!(:name => 'BB', :parent_id => b.id)
                 b.move_to = 'higher'
+                b.save!
                 assert_equal [2, 1, 1], [a, b, override].map(&:reload).map(&:position)
               end
               def test_destroying_override_should_not_update_positions
                 Enumeration.delete_all
                 a = IssuePriority.create!(:name => 'A')
                 b = IssuePriority.create!(:name => 'B')
                 c = IssuePriority.create!(:name => 'C')
                 override = IssuePriority.create!(:name => 'BB', :parent_id => b.id)
                 assert_equal [1, 2, 3, 2], [a, b, c, override].map(&:reload).map(&:position)
                 override.destroy
                 assert_equal [1, 2, 3], [a, b, c].map(&:reload).map(&:position)
               end
             end

test/unit/issue_priority_test.rb +1 -19

             # 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 IssuePriorityTest < ActiveSupport::TestCase
               fixtures :enumerations, :issues
               def test_named_scope
                 assert_equal Enumeration.find_by_name('Normal'), Enumeration.named('normal').first
               end
               def test_default_should_return_the_default_priority
                 assert_equal Enumeration.find_by_name('Normal'), IssuePriority.default
               end
               def test_default_should_return_nil_when_no_default_priority
                 IssuePriority.update_all :is_default => false
                 assert_nil IssuePriority.default
               end
               def test_should_be_an_enumeration
                 assert IssuePriority.ancestors.include?(Enumeration)
               end
               def test_objects_count
                 # low priority
                 assert_equal 6, IssuePriority.find(4).objects_count
                 # urgent
                 assert_equal 0, IssuePriority.find(7).objects_count
               end
               def test_option_name
                 assert_equal :enumeration_issue_priorities, IssuePriority.new.option_name
               end
               def test_should_be_created_at_last_position
                 IssuePriority.delete_all
                 priorities = [1, 2, 3].map {|i| IssuePriority.create!(:name => "P#{i}")}
                 assert_equal [1, 2, 3], priorities.map(&:position)
               end
-              def test_reset_positions_in_list_should_set_sequential_positions
-                IssuePriority.delete_all
-                priorities = [1, 2, 3].map {|i| IssuePriority.create!(:name => "P#{i}")}
-                priorities[0].update_attribute :position, 4
-                priorities[1].update_attribute :position, 2
-                priorities[2].update_attribute :position, 7
-                assert_equal [4, 2, 7], priorities.map(&:reload).map(&:position)
-                priorities[0].reset_positions_in_list
-                assert_equal [2, 1, 3], priorities.map(&:reload).map(&:position)
-              end
-              def test_moving_in_list_should_reset_positions
-                priority = IssuePriority.first
-                priority.expects(:reset_positions_in_list).once
-                priority.move_to = 'higher'
-              end
               def test_clear_position_names_should_set_position_names_to_nil
                 IssuePriority.clear_position_names
                 assert IssuePriority.all.all? {|priority| priority.position_name.nil?}
               end
               def test_compute_position_names_with_default_priority
                 IssuePriority.clear_position_names
                 IssuePriority.compute_position_names
                 assert_equal %w(lowest default high3 high2 highest), IssuePriority.active.to_a.sort.map(&:position_name)
               end
               def test_compute_position_names_without_default_priority_should_split_priorities
                 IssuePriority.clear_position_names
                 IssuePriority.update_all :is_default => false
                 IssuePriority.compute_position_names
                 assert_equal %w(lowest low2 default high2 highest), IssuePriority.active.to_a.sort.map(&:position_name)
               end
               def test_adding_a_priority_should_update_position_names
                 priority = IssuePriority.create!(:name => 'New')
                 assert_equal %w(lowest default high4 high3 high2 highest), IssuePriority.active.to_a.sort.map(&:position_name)
               end
               def test_moving_a_priority_should_update_position_names
                 prio = IssuePriority.first
                 prio.move_to = 'lowest'
+                prio.save!
                 prio.reload
                 assert_equal 'highest', prio.position_name
               end
               def test_deactivating_a_priority_should_update_position_names
                 prio = IssuePriority.active.order(:position).last
                 prio.active = false
                 prio.save
                 assert_equal 'highest', IssuePriority.active.order(:position).last.position_name
               end
               def test_destroying_a_priority_should_update_position_names
                 IssuePriority.find_by_position_name('highest').destroy
                 assert_equal %w(lowest default high2 highest), IssuePriority.active.to_a.sort.map(&:position_name)
               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