jro_apps/redmine Commit - r14957:39ff11ba06a7

Removes #move_to= (#12909)....

Jean-Philippe Lang -

r14957:39ff11ba06a7

parent child

Context file:

r14957:39ff11ba06a7

Collapse all files

lib/redmine/acts/positioned.rb 0 -16

             # 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.
             module Redmine
               module Acts
                 module Positioned
                   def self.included(base)
                     base.extend ClassMethods
                   end
                   # This extension provides the capabilities for reordering objects in a list.
                   # The class needs to have a +position+ column defined as an integer on the
                   # mapped database table.
                   module ClassMethods
                     # Configuration options are:
                     #
                     # * +scope+ - restricts what is to be considered a list. Must be a symbol
                     # or an array of symbols
                     def acts_as_positioned(options = {})
                       class_attribute :positioned_options
                       self.positioned_options = {:scope => Array(options[:scope])}
                       send :include, Redmine::Acts::Positioned::InstanceMethods
                       before_save :set_default_position
                       after_save :update_position
                       after_destroy :remove_position
                     end
                   end
                   module InstanceMethods
                     def self.included(base)
                       base.extend ClassMethods
                     end
-                    # Move to the given position
-                    # For compatibility with the previous way of sorting items
-                    def move_to=(pos)
-                      case pos.to_s
-                      when 'highest'
-                        self.position = 1
-                      when 'higher'
-                        self.position -= 1 if position > 1
-                      when 'lower'
-                        self.position += 1
-                      when 'lowest'
-                        self.position = nil
-                        set_default_position
-                      end
-                    end
                     private
                     def position_scope
                       build_position_scope {|c| send(c)}
                     end
                     def position_scope_was
                       build_position_scope {|c| send("#{c}_was")}
                     end
                     def build_position_scope
                       condition_hash = self.class.positioned_options[:scope].inject({}) do |h, column|
                         h[column] = yield(column)
                         h
                       end
                       self.class.where(condition_hash)
                     end
                     def set_default_position
                       if position.nil?
                         self.position = position_scope.maximum(:position).to_i + (new_record? ? 1 : 0)
                       end
                     end
                     def update_position
                       if !new_record? && position_scope_changed?
                         remove_position
                         insert_position
                       elsif position_changed?
                         if position_was.nil?
                           insert_position
                         else
                           shift_positions
                         end
                       end
                     end
                     def insert_position
                       position_scope.where("position >= ? AND id <> ?", position, id).update_all("position = position + 1")
                     end
                     def remove_position
                       position_scope_was.where("position >= ? AND id <> ?", position_was, id).update_all("position = position - 1")
                     end
                     def position_scope_changed?
                       (changed & self.class.positioned_options[:scope].map(&:to_s)).any?
                     end
                     def shift_positions
                       offset = position_was <=> position
                       min, max = [position, position_was].sort
                       r = position_scope.where("id <> ? AND position BETWEEN ? AND ?", id, min, max).update_all("position = position + #{offset}")
                       if r != max - min
                         reset_positions_in_list
                       end
                     end
                     def reset_positions_in_list
                       position_scope.reorder(:position, :id).pluck(:id).each_with_index do |record_id, p|
                         self.class.where(:id => record_id).update_all(:position => p+1)
                       end
                     end
                   end
                 end
               end
             end
             ActiveRecord::Base.send :include, Redmine::Acts::Positioned

test/functional/roles_controller_test.rb +4 -4

             # 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'}
+                put :update, :id => 3, :role => {:position => 1}
                 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'}
+                put :update, :id => 3, :role => {:position => position - 1}
                 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'}
+                put :update, :id => 2, :role => {:position => position + 1}
                 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'}
+                put :update, :id => 2, :role => {:position => Role.givable.count}
                 assert_redirected_to '/roles'
                 assert_equal Role.givable.count, Role.find(2).position
               end
             end

test/unit/enumeration_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 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.position -= 1
                 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 -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 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_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.position = IssuePriority.count
                 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