jro_apps/redmine Commit - r14748:f4bcb1286e21

Fixed that moving a wiki page with a child raises an error when target wiki contains a page with the same name as the child (#21900)....

Jean-Philippe Lang -

r14748:f4bcb1286e21

parent child

Context file:

r14748:f4bcb1286e21

Collapse all files

app/models/wiki_page.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 'diff'
             require 'enumerator'
             class WikiPage < ActiveRecord::Base
               include Redmine::SafeAttributes
               belongs_to :wiki
               has_one :content, :class_name => 'WikiContent', :foreign_key => 'page_id', :dependent => :destroy
               has_one :content_without_text, lambda {without_text.readonly}, :class_name => 'WikiContent', :foreign_key => 'page_id'
               acts_as_attachable :delete_permission => :delete_wiki_pages_attachments
               acts_as_tree :dependent => :nullify, :order => 'title'
               acts_as_watchable
               acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},
                             :description => :text,
                             :datetime => :created_on,
                             :url => Proc.new {|o| {:controller => 'wiki', :action => 'show', :project_id => o.wiki.project, :id => o.title}}
               acts_as_searchable :columns => ['title', "#{WikiContent.table_name}.text"],
                                  :scope => joins(:content, {:wiki => :project}),
                                  :preload => [:content, {:wiki => :project}],
                                  :permission => :view_wiki_pages,
                                  :project_key => "#{Wiki.table_name}.project_id"
               attr_accessor :redirect_existing_links
               validates_presence_of :title
               validates_format_of :title, :with => /\A[^,\.\/\?\;\|\s]*\z/
               validates_uniqueness_of :title, :scope => :wiki_id, :case_sensitive => false
               validates_associated :content
               attr_protected :id
               validate :validate_parent_title
               before_destroy :delete_redirects
               before_save :handle_rename_or_move
               after_save :handle_children_move
               # eager load information about last updates, without loading text
               scope :with_updated_on, lambda { preload(:content_without_text) }
               # Wiki pages that are protected by default
               DEFAULT_PROTECTED_PAGES = %w(sidebar)
               safe_attributes 'parent_id', 'parent_title', 'title', 'redirect_existing_links', 'wiki_id',
                 :if => lambda {|page, user| page.new_record? || user.allowed_to?(:rename_wiki_pages, page.project)}
               def initialize(attributes=nil, *args)
                 super
                 if new_record? && DEFAULT_PROTECTED_PAGES.include?(title.to_s.downcase)
                   self.protected = true
                 end
               end
               def visible?(user=User.current)
                 !user.nil? && user.allowed_to?(:view_wiki_pages, project)
               end
               def title=(value)
                 value = Wiki.titleize(value)
                 write_attribute(:title, value)
               end
               def safe_attributes=(attrs, user=User.current)
                 return unless attrs.is_a?(Hash)
                 attrs = attrs.deep_dup
                 # Project and Tracker must be set before since new_statuses_allowed_to depends on it.
                 if (w_id = attrs.delete('wiki_id')) && safe_attribute?('wiki_id')
                   if (w = Wiki.find_by_id(w_id)) && w.project && user.allowed_to?(:rename_wiki_pages, w.project)
                     self.wiki = w
                   end
                 end
                 super attrs, user
               end
               # Manages redirects if page is renamed or moved
               def handle_rename_or_move
                 if !new_record? && (title_changed? || wiki_id_changed?)
                   # Update redirects that point to the old title
                   WikiRedirect.where(:redirects_to => title_was, :redirects_to_wiki_id => wiki_id_was).each do |r|
                     r.redirects_to = title
                     r.redirects_to_wiki_id = wiki_id
                     (r.title == r.redirects_to && r.wiki_id == r.redirects_to_wiki_id) ? r.destroy : r.save
                   end
                   # Remove redirects for the new title
                   WikiRedirect.where(:wiki_id => wiki_id, :title => title).delete_all
                   # Create a redirect to the new title
                   unless redirect_existing_links == "0"
                     WikiRedirect.create(
                       :wiki_id => wiki_id_was, :title => title_was,
                       :redirects_to_wiki_id => wiki_id, :redirects_to => title
                     )
                   end
                 end
                 if !new_record? && wiki_id_changed? && parent.present?
                   unless parent.wiki_id == wiki_id
                     self.parent_id = nil
                   end
                 end
               end
               private :handle_rename_or_move
               # Moves child pages if page was moved
               def handle_children_move
                 if !new_record? && wiki_id_changed?
                   children.each do |child|
                     child.wiki_id = wiki_id
                     child.redirect_existing_links = redirect_existing_links
                     unless child.save
-                      WikiPage.where(:id => child.id).update_all :parent_nil => nil
+                      WikiPage.where(:id => child.id).update_all :parent_id => nil
                     end
                   end
                 end
               end
               private :handle_children_move
               # Deletes redirects to this page
               def delete_redirects
                 WikiRedirect.where(:redirects_to_wiki_id => wiki_id, :redirects_to => title).delete_all
               end
               def pretty_title
                 WikiPage.pretty_title(title)
               end
               def content_for_version(version=nil)
                 if content
                   result = content.versions.find_by_version(version.to_i) if version
                   result ||= content
                   result
                 end
               end
               def diff(version_to=nil, version_from=nil)
                 version_to = version_to ? version_to.to_i : self.content.version
                 content_to = content.versions.find_by_version(version_to)
                 content_from = version_from ? content.versions.find_by_version(version_from.to_i) : content_to.try(:previous)
                 return nil unless content_to && content_from
                 if content_from.version > content_to.version
                   content_to, content_from = content_from, content_to
                 end
                 (content_to && content_from) ? WikiDiff.new(content_to, content_from) : nil
               end
               def annotate(version=nil)
                 version = version ? version.to_i : self.content.version
                 c = content.versions.find_by_version(version)
                 c ? WikiAnnotate.new(c) : nil
               end
               def self.pretty_title(str)
                 (str && str.is_a?(String)) ? str.tr('_', ' ') : str
               end
               def project
                 wiki.try(:project)
               end
               def text
                 content.text if content
               end
               def updated_on
                 content_attribute(:updated_on)
               end
               def version
                 content_attribute(:version)
               end
               # Returns true if usr is allowed to edit the page, otherwise false
               def editable_by?(usr)
                 !protected? || usr.allowed_to?(:protect_wiki_pages, wiki.project)
               end
               def attachments_deletable?(usr=User.current)
                 editable_by?(usr) && super(usr)
               end
               def parent_title
                 @parent_title || (self.parent && self.parent.pretty_title)
               end
               def parent_title=(t)
                 @parent_title = t
                 parent_page = t.blank? ? nil : self.wiki.find_page(t)
                 self.parent = parent_page
               end
               # Saves the page and its content if text was changed
               # Return true if the page was saved
               def save_with_content(content)
                 ret = nil
                 transaction do
                   ret = save
                   if content.text_changed?
                     begin
                       self.content = content
                       ret = ret && content.changed?
                     rescue ActiveRecord::RecordNotSaved
                       ret = false
                     end
                   end
                   raise ActiveRecord::Rollback unless ret
                 end
                 ret
               end
               protected
               def validate_parent_title
                 errors.add(:parent_title, :invalid) if !@parent_title.blank? && parent.nil?
                 errors.add(:parent_title, :circular_dependency) if parent && (parent == self || parent.ancestors.include?(self))
                 if parent_id_changed? && parent && (parent.wiki_id != wiki_id)
                   errors.add(:parent_title, :not_same_project)
                 end
               end
               private
               def content_attribute(name)
                 (association(:content).loaded? ? content : content_without_text).try(name)
               end
             end
             class WikiDiff < Redmine::Helpers::Diff
               attr_reader :content_to, :content_from
               def initialize(content_to, content_from)
                 @content_to = content_to
                 @content_from = content_from
                 super(content_to.text, content_from.text)
               end
             end
             class WikiAnnotate
               attr_reader :lines, :content
               def initialize(content)
                 @content = content
                 current = content
                 current_lines = current.text.split(/\r?\n/)
                 @lines = current_lines.collect {|t| [nil, nil, t]}
                 positions = []
                 current_lines.size.times {|i| positions << i}
                 while (current.previous)
                   d = current.previous.text.split(/\r?\n/).diff(current.text.split(/\r?\n/)).diffs.flatten
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '+' && positions[line] && positions[line] != -1
                       if @lines[positions[line]][0].nil?
                         @lines[positions[line]][0] = current.version
                         @lines[positions[line]][1] = current.author
                       end
                     end
                   end
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '-'
                       positions.insert(line, -1)
                     else
                       positions[line] = nil
                     end
                   end
                   positions.compact!
                   # Stop if every line is annotated
                   break unless @lines.detect { |line| line[0].nil? }
                   current = current.previous
                 end
                 @lines.each { |line|
                   line[0] ||= current.version
                   # if the last known version is > 1 (eg. history was cleared), we don't know the author
                   line[1] ||= current.author if current.version == 1
                 }
               end
             end

test/unit/wiki_page_test.rb +18 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 WikiPageTest < ActiveSupport::TestCase
               fixtures :projects, :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions
               def setup
                 @wiki = Wiki.find(1)
                 @page = @wiki.pages.first
               end
               def test_create
                 page = WikiPage.new(:wiki => @wiki)
                 assert !page.save
                 assert_equal 1, page.errors.count
                 page.title = "Page"
                 assert page.save
                 page.reload
                 assert !page.protected?
                 @wiki.reload
                 assert @wiki.pages.include?(page)
               end
               def test_sidebar_should_be_protected_by_default
                 page = @wiki.find_or_new_page('sidebar')
                 assert page.new_record?
                 assert page.protected?
               end
               def test_find_or_new_page
                 page = @wiki.find_or_new_page("CookBook documentation")
                 assert_kind_of WikiPage, page
                 assert !page.new_record?
                 page = @wiki.find_or_new_page("Non existing page")
                 assert_kind_of WikiPage, page
                 assert page.new_record?
               end
               def test_parent_title
                 page = WikiPage.find_by_title('Another_page')
                 assert_nil page.parent_title
                 page = WikiPage.find_by_title('Page_with_an_inline_image')
                 assert_equal 'CookBook documentation', page.parent_title
               end
               def test_assign_parent
                 page = WikiPage.find_by_title('Another_page')
                 page.parent_title = 'CookBook documentation'
                 assert page.save
                 page.reload
                 assert_equal WikiPage.find_by_title('CookBook_documentation'), page.parent
               end
               def test_unassign_parent
                 page = WikiPage.find_by_title('Page_with_an_inline_image')
                 page.parent_title = ''
                 assert page.save
                 page.reload
                 assert_nil page.parent
               end
               def test_parent_validation
                 page = WikiPage.find_by_title('CookBook_documentation')
                 # A page that doesn't exist
                 page.parent_title = 'Unknown title'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.invalid'),
                                page.errors[:parent_title]
                 # A child page
                 page.parent_title = 'Page_with_an_inline_image'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                page.errors[:parent_title]
                 # The page itself
                 page.parent_title = 'CookBook_documentation'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                page.errors[:parent_title]
                 page.parent_title = 'Another_page'
                 assert page.save
               end
               def test_move_child_should_clear_parent
                 parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
                 child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent => parent)
                 child.wiki_id = 2
                 child.save!
                 assert_equal nil, child.reload.parent_id
               end
               def test_move_parent_should_move_child_page
                 parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
                 child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent => parent)
                 parent.reload
                 parent.wiki_id = 2
                 parent.save!
                 assert_equal 2, child.reload.wiki_id
                 assert_equal parent, child.parent
               end
+              def test_move_parent_with_child_with_duplicate_name_should_not_move_child
+                parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
+                child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent_id => parent.id)
+                parent.reload
+                # page with the same name as the child in the target wiki
+                WikiPage.create!(:wiki_id => 2, :title => 'Child')
+                parent.wiki_id = 2
+                parent.save!
+                parent.reload
+                assert_equal 2, parent.wiki_id
+                child.reload
+                assert_equal 1, child.wiki_id
+                assert_nil child.parent_id
+              end
               def test_destroy
                 page = WikiPage.find(1)
                 page.destroy
                 assert_nil WikiPage.find_by_id(1)
                 # make sure that page content and its history are deleted
                 assert_equal 0, WikiContent.where(:page_id => 1).count
                 assert_equal 0, WikiContent.versioned_class.where(:page_id => 1).count
               end
               def test_destroy_should_not_nullify_children
                 page = WikiPage.find(2)
                 child_ids = page.child_ids
                 assert child_ids.any?
                 page.destroy
                 assert_nil WikiPage.find_by_id(2)
                 children = WikiPage.where(:id => child_ids)
                 assert_equal child_ids.size, children.count
                 children.each do |child|
                   assert_nil child.parent_id
                 end
               end
               def test_with_updated_on_scope_should_preload_updated_on_and_version
                 page = WikiPage.with_updated_on.where(:id => 1).first
                 # make the assertions fail if attributes are not preloaded
                 WikiContent.update_all(:updated_on => '2001-01-01 10:00:00', :version => 1)
                 assert_equal Time.gm(2007, 3, 6, 23, 10, 51), page.updated_on
                 assert_equal 3, page.version
               end
               def test_descendants
                 page = WikiPage.create!(:wiki => @wiki, :title => 'Parent')
                 child1 = WikiPage.create!(:wiki => @wiki, :title => 'Child1', :parent => page)
                 child11 = WikiPage.create!(:wiki => @wiki, :title => 'Child11', :parent => child1)
                 child111 = WikiPage.create!(:wiki => @wiki, :title => 'Child111', :parent => child11)
                 child2 = WikiPage.create!(:wiki => @wiki, :title => 'Child2', :parent => page)
                 assert_equal %w(Child1 Child11 Child111 Child2), page.descendants.map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2), page.descendants(nil).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child2), page.descendants(2).map(&:title).sort
                 assert_equal %w(Child1 Child2), page.descendants(1).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants.map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants(nil).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child2 Parent), page.self_and_descendants(2).map(&:title).sort
                 assert_equal %w(Child1 Child2 Parent), page.self_and_descendants(1).map(&:title).sort
               end
               def test_diff_for_page_with_deleted_version_should_pick_the_previous_available_version
                 WikiContent::Version.find_by_page_id_and_version(1, 2).destroy
                 page = WikiPage.find(1)
                 diff = page.diff(3)
                 assert_not_nil diff
                 assert_equal 3, diff.content_to.version
                 assert_equal 1, diff.content_from.version
               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