jro_apps/redmine Commit - r13261:e0a034164f34

Move wiki page to other project (#5450)....

Jean-Philippe Lang -

r13261:e0a034164f34

parent child

Context file:

r13261:e0a034164f34

Collapse all files

db/migrate/20141122124142_add_wiki_redirects_redirects_to_wiki_id.rb created 644 +11 0

@@ -0,0 +1,11
	1	class AddWikiRedirectsRedirectsToWikiId < ActiveRecord::Migration
	2	def self.up
	3	add_column :wiki_redirects, :redirects_to_wiki_id, :integer
	4	WikiRedirect.update_all "redirects_to_wiki_id = wiki_id"
	5	change_column :wiki_redirects, :redirects_to_wiki_id, :integer, :null => false
	6	end
	7
	8	def self.down
	9	remove_column :wiki_redirects, :redirects_to_wiki_id
	10	end
	11	end

app/controllers/wiki_controller.rb +8 -3

             # Redmine - project management software
             # Copyright (C) 2006-2014  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.
             # The WikiController follows the Rails REST controller pattern but with
             # a few differences
             #
             # * index - shows a list of WikiPages grouped by page or date
             # * new - not used
             # * create - not used
             # * show - will also show the form for creating a new wiki page
             # * edit - used to edit an existing or new page
             # * update - used to save a wiki page update to the database, including new pages
             # * destroy - normal
             #
             # Other member and collection methods are also used
             #
             # TODO: still being worked on
             class WikiController < ApplicationController
               default_search_scope :wiki_pages
               before_filter :find_wiki, :authorize
               before_filter :find_existing_or_new_page, :only => [:show, :edit, :update]
               before_filter :find_existing_page, :only => [:rename, :protect, :history, :diff, :annotate, :add_attachment, :destroy, :destroy_version]
               accept_api_auth :index, :show, :update, :destroy
               before_filter :find_attachments, :only => [:preview]
               helper :attachments
               include AttachmentsHelper
               helper :watchers
               include Redmine::Export::PDF
               # List of pages, sorted alphabetically and by parent (hierarchy)
               def index
                 load_pages_for_index
                 respond_to do |format|
                   format.html {
                     @pages_by_parent_id = @pages.group_by(&:parent_id)
                   }
                   format.api
                 end
               end
               # List of page, by last update
               def date_index
                 load_pages_for_index
                 @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}
               end
               # display a page (in editing mode if it doesn't exist)
               def show
                 if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
                   deny_access
                   return
                 end
                 @content = @page.content_for_version(params[:version])
                 if @content.nil?
                   if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
                 if User.current.allowed_to?(:export_wiki_pages, @project)
                   if params[:format] == 'pdf'
                     send_data(wiki_page_to_pdf(@page, @project), :type => 'application/pdf', :filename => "#{@page.title}.pdf")
                     return
                   elsif params[:format] == 'html'
                     export = render_to_string :action => 'export', :layout => false
                     send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")
                     return
                   elsif params[:format] == 'txt'
                     send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")
                     return
                   end
                 end
                 @editable = editable?
                 @sections_editable = @editable && User.current.allowed_to?(:edit_wiki_pages, @page.project) &&
                   @content.current_version? &&
                   Redmine::WikiFormatting.supports_section_edit?
                 respond_to do |format|
                   format.html
                   format.api
                 end
               end
               # edit an existing page or a new one
               def edit
                 return render_403 unless editable?
                 if @page.new_record?
                   if params[:parent].present?
                     @page.parent = @page.wiki.find_page(params[:parent].to_s)
                   end
                 end
                 @content = @page.content_for_version(params[:version])
                 @content ||= WikiContent.new(:page => @page)
                 @content.text = initial_page_content(@page) if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 # To prevent StaleObjectError exception when reverting to a previous version
                 @content.version = @page.content.version if @page.content
                 @text = @content.text
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @text, @section_hash = Redmine::WikiFormatting.formatter.new(@text).get_section(@section)
                   render_404 if @text.blank?
                 end
               end
               # Creates a new page or updates an existing one
               def update
                 return render_403 unless editable?
                 was_new_page = @page.new_record?
                 @page.safe_attributes = params[:wiki_page]
                 @content = @page.content || WikiContent.new(:page => @page)
                 content_params = params[:content]
                 if content_params.nil? && params[:wiki_page].is_a?(Hash)
                   content_params = params[:wiki_page].slice(:text, :comments, :version)
                 end
                 content_params ||= {}
                 @content.comments = content_params[:comments]
                 @text = content_params[:text]
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @section_hash = params[:section_hash]
                   @content.text = Redmine::WikiFormatting.formatter.new(@content.text).update_section(@section, @text, @section_hash)
                 else
                   @content.version = content_params[:version] if content_params[:version]
                   @content.text = @text
                 end
                 @content.author = User.current
                 if @page.save_with_content(@content)
                   attachments = Attachment.attach_files(@page, params[:attachments])
                   render_attachment_warning_if_needed(@page)
                   call_hook(:controller_wiki_edit_after_save, { :params => params, :page => @page})
                   respond_to do |format|
                     format.html {
                       anchor = @section ? "section-#{@section}" : nil
                       redirect_to project_wiki_page_path(@project, @page.title, :anchor => anchor)
                     }
                     format.api {
                       if was_new_page
                         render :action => 'show', :status => :created, :location => project_wiki_page_path(@project, @page.title)
                       else
                         render_api_ok
                       end
                     }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api { render_validation_errors(@content) }
                   end
                 end
               rescue ActiveRecord::StaleObjectError, Redmine::WikiFormatting::StaleSectionError
                 # Optimistic locking exception
                 respond_to do |format|
                   format.html {
                     flash.now[:error] = l(:notice_locking_conflict)
                     render :action => 'edit'
                   }
                   format.api { render_api_head :conflict }
                 end
               rescue ActiveRecord::RecordNotSaved
                 respond_to do |format|
                   format.html { render :action => 'edit' }
                   format.api { render_validation_errors(@content) }
                 end
               end
               # rename a page
               def rename
                 return render_403 unless editable?
                 @page.redirect_existing_links = true
                 # used to display the *original* title if some AR validation errors occur
                 @original_title = @page.pretty_title
-                if request.post? && @page.update_attributes(params[:wiki_page])
+                @page.safe_attributes = params[:wiki_page]
+                if request.post? && @page.save
                   flash[:notice] = l(:notice_successful_update)
-                  redirect_to project_wiki_page_path(@project, @page.title)
+                  redirect_to project_wiki_page_path(@page.project, @page.title)
                 end
               end
               def protect
                 @page.update_attribute :protected, params[:protected]
                 redirect_to project_wiki_page_path(@project, @page.title)
               end
               # show page history
               def history
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new @version_count, per_page_option, params['page']
                 # don't load text
                 @versions = @page.content.versions.
                   select("id, author_id, comments, updated_on, version").
                   reorder('version DESC').
                   limit(@version_pages.per_page + 1).
                   offset(@version_pages.offset).
                   to_a
                 render :layout => false if request.xhr?
               end
               def diff
                 @diff = @page.diff(params[:version], params[:version_from])
                 render_404 unless @diff
               end
               def annotate
                 @annotate = @page.annotate(params[:version])
                 render_404 unless @annotate
               end
               # Removes a wiki page and its history
               # Children can be either set as root pages, removed or reassigned to another parent page
               def destroy
                 return render_403 unless editable?
                 @descendants_count = @page.descendants.size
                 if @descendants_count > 0
                   case params[:todo]
                   when 'nullify'
                     # Nothing to do
                   when 'destroy'
                     # Removes all its descendants
                     @page.descendants.each(&:destroy)
                   when 'reassign'
                     # Reassign children to another parent page
                     reassign_to = @wiki.pages.find_by_id(params[:reassign_to_id].to_i)
                     return unless reassign_to
                     @page.children.each do |child|
                       child.update_attribute(:parent, reassign_to)
                     end
                   else
                     @reassignable_to = @wiki.pages - @page.self_and_descendants
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @page.destroy
                 respond_to do |format|
                   format.html { redirect_to project_wiki_index_path(@project) }
                   format.api { render_api_ok }
                 end
               end
               def destroy_version
                 return render_403 unless editable?
                 @content = @page.content_for_version(params[:version])
                 @content.destroy
                 redirect_to_referer_or history_project_wiki_page_path(@project, @page.title)
               end
               # Export wiki to a single pdf or html file
               def export
                 @pages = @wiki.pages.
                                   order('title').
                                   includes([:content, {:attachments => :author}]).
                                   to_a
                 respond_to do |format|
                   format.html {
                     export = render_to_string :action => 'export_multiple', :layout => false
                     send_data(export, :type => 'text/html', :filename => "wiki.html")
                   }
                   format.pdf {
                     send_data(wiki_pages_to_pdf(@pages, @project),
                               :type => 'application/pdf',
                               :filename => "#{@project.identifier}.pdf")
                   }
                 end
               end
               def preview
                 page = @wiki.find_page(params[:id])
                 # page is nil when previewing a new page
                 return render_403 unless page.nil? || editable?(page)
                 if page
                   @attachments += page.attachments
                   @previewed = page.content
                 end
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 return render_403 unless editable?
                 attachments = Attachment.attach_files(@page, params[:attachments])
                 render_attachment_warning_if_needed(@page)
                 redirect_to :action => 'show', :id => @page.title, :project_id => @project
               end
             private
               def find_wiki
                 @project = Project.find(params[:project_id])
                 @wiki = @project.wiki
                 render_404 unless @wiki
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Finds the requested page or a new page if it doesn't exist
               def find_existing_or_new_page
                 @page = @wiki.find_or_new_page(params[:id])
                 if @wiki.page_found_with_redirect?
                   redirect_to_page @page
                 end
               end
               # Finds the requested page and returns a 404 error if it doesn't exist
               def find_existing_page
                 @page = @wiki.find_page(params[:id])
                 if @page.nil?
                   render_404
                   return
                 end
                 if @wiki.page_found_with_redirect?
                   redirect_to_page @page
                 end
               end
               def redirect_to_page(page)
-                redirect_to :action => action_name, :project_id => page.wiki.project, :id => page.title
+                if page.project && page.project.visible?
+                  redirect_to :action => action_name, :project_id => page.project, :id => page.title
+                else
+                  render_404
+                end
               end
               # Returns true if the current user is allowed to edit the page, otherwise false
               def editable?(page = @page)
                 page.editable_by?(User.current)
               end
               # Returns the default content of a new wiki page
               def initial_page_content(page)
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper unless self.instance_of?(helper)
                 helper.instance_method(:initial_page_content).bind(self).call(page)
               end
               def load_pages_for_index
                 @pages = @wiki.pages.with_updated_on.
                             reorder("#{WikiPage.table_name}.title").
                             includes(:wiki => :project).
                             includes(:parent).
                             to_a
               end
             end

app/helpers/wiki_helper.rb +10 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module WikiHelper
               def wiki_page_options_for_select(pages, selected = nil, parent = nil, level = 0)
                 pages = pages.group_by(&:parent) unless pages.is_a?(Hash)
                 s = ''.html_safe
                 if pages.has_key?(parent)
                   pages[parent].each do |page|
                     attrs = "value='#{page.id}'"
                     attrs << " selected='selected'" if selected == page
                     indent = (level > 0) ? ('&nbsp;' * level * 2 + '&#187; ') : ''
                     s << content_tag('option', (indent + h(page.pretty_title)).html_safe, :value => page.id.to_s, :selected => selected == page) +
                            wiki_page_options_for_select(pages, selected, page, level + 1)
                   end
                 end
                 s
               end
+              def wiki_page_wiki_options_for_select(page)
+                projects = Project.allowed_to(:rename_wiki_pages).joins(:wiki).preload(:wiki).to_a
+                projects << page.project unless projects.include?(page.project)
+                project_tree_options_for_select(projects, :selected => page.project) do |project|
+                  wiki_id = project.wiki.try(:id)
+                  {:value => wiki_id, :selected => wiki_id == page.wiki_id}
+                end
+              end
               def wiki_page_breadcrumb(page)
                 breadcrumb(page.ancestors.reverse.collect {|parent|
                   link_to(h(parent.pretty_title), {:controller => 'wiki', :action => 'show', :id => parent.title, :project_id => parent.project, :version => nil})
                 })
               end
             end

app/models/wiki.rb +11 -3

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 Wiki < ActiveRecord::Base
               include Redmine::SafeAttributes
               belongs_to :project
               has_many :pages, lambda {order('title')}, :class_name => 'WikiPage', :dependent => :destroy
-              has_many :redirects, :class_name => 'WikiRedirect', :dependent => :delete_all
+              has_many :redirects, :class_name => 'WikiRedirect'
               acts_as_watchable
               validates_presence_of :start_page
               validates_format_of :start_page, :with => /\A[^,\.\/\?\;\|\:]*\z/
               attr_protected :id
+              before_destroy :delete_redirects
               safe_attributes 'start_page'
               def visible?(user=User.current)
                 !user.nil? && user.allowed_to?(:view_wiki_pages, project)
               end
               # Returns the wiki page that acts as the sidebar content
               # or nil if no such page exists
               def sidebar
                 @sidebar ||= find_page('Sidebar', :with_redirect => false)
               end
               # find the page with the given title
               # if page doesn't exist, return a new page
               def find_or_new_page(title)
                 title = start_page if title.blank?
                 find_page(title) || WikiPage.new(:wiki => self, :title => Wiki.titleize(title))
               end
               # find the page with the given title
               def find_page(title, options = {})
                 @page_found_with_redirect = false
                 title = start_page if title.blank?
                 title = Wiki.titleize(title)
                 page = pages.where("LOWER(title) = LOWER(?)", title).first
-                if !page && !(options[:with_redirect] == false)
+                if page.nil? && options[:with_redirect] != false
                   # search for a redirect
                   redirect = redirects.where("LOWER(title) = LOWER(?)", title).first
                   if redirect
-                    page = find_page(redirect.redirects_to, :with_redirect => false)
+                    page = redirect.target_page
                     @page_found_with_redirect = true
                   end
                 end
                 page
               end
               # Returns true if the last page was found with a redirect
               def page_found_with_redirect?
                 @page_found_with_redirect
               end
+              # Deletes all redirects from/to the wiki
+              def delete_redirects
+                WikiRedirect.where(:wiki_id => id).delete_all
+                WikiRedirect.where(:redirects_to_wiki_id => id).delete_all
+              end
               # Finds a page by title
               # The given string can be of one of the forms: "title" or "project:title"
               # Examples:
               #   Wiki.find_page("bar", project => foo)
               #   Wiki.find_page("foo:bar")
               def self.find_page(title, options = {})
                 project = options[:project]
                 if title.to_s =~ %r{^([^\:]+)\:(.*)$}
                   project_identifier, title = $1, $2
                   project = Project.find_by_identifier(project_identifier) || Project.find_by_name(project_identifier)
                 end
                 if project && project.wiki
                   page = project.wiki.find_page(title)
                   if page && page.content
                     page
                   end
                 end
               end
               # turn a string into a valid page title
               def self.titleize(title)
                 # replace spaces with _ and remove unwanted caracters
                 title = title.gsub(/\s+/, '_').delete(',./?;|:') if title
                 # upcase the first letter
                 title = (title.slice(0..0).upcase + (title.slice(1..-1) || '')) if title
                 title
               end
             end

app/models/wiki_page.rb +58 -18

             # Redmine - project management software
             # Copyright (C) 2006-2014  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
               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 => preload(:wiki => :project).joins(: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 :remove_redirects
+              before_destroy :delete_redirects
-              before_save    :handle_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 {
                 select("#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on, #{WikiContent.table_name}.version").
                   joins("LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id")
               }
               # Wiki pages that are protected by default
               DEFAULT_PROTECTED_PAGES = %w(sidebar)
-              safe_attributes 'parent_id', 'parent_title',
+              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)
-                @previous_title = read_attribute(:title) if @previous_title.blank?
                 write_attribute(:title, value)
               end
-              def handle_redirects
+              def safe_attributes=(attrs, user=User.current)
-                self.title = Wiki.titleize(title)
+                return unless attrs.is_a?(Hash)
-                # Manage redirects if the title has changed
+                attrs = attrs.deep_dup
-                if !@previous_title.blank? && (@previous_title != title) && !new_record?
+                # 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
-                  wiki.redirects.where(:redirects_to => @previous_title).each do |r|
+                  WikiRedirect.where(:redirects_to => title_was, :redirects_to_wiki_id => wiki_id_was).each do |r|
                     r.redirects_to = title
-                    r.title == r.redirects_to ? r.destroy : r.save
+                    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
-                  wiki.redirects.where(:title => title).each(&:destroy)
+                  WikiRedirect.where(:wiki_id => wiki_id, :title => title).delete_all
                   # Create a redirect to the new title
-                  wiki.redirects << WikiRedirect.new(:title => @previous_title, :redirects_to => title) unless redirect_existing_links == "0"
+                  unless redirect_existing_links == "0"
-                  @previous_title = nil
+                    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
+                    end
+                  end
+                end
+              end
+              private :handle_children_move
-              def remove_redirects
+              # Deletes redirects to this page
-                # Remove redirects to this page
+              def delete_redirects
-                wiki.redirects.where(:redirects_to => title).each(&:destroy)
+                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.project
+                wiki.try(:project)
               end
               def text
                 content.text if content
               end
               def updated_on
                 unless @updated_on
                   if time = read_attribute(:updated_on)
                     # content updated_on was eager loaded with the page
                     begin
                       @updated_on = (self.class.default_timezone == :utc ? Time.parse(time.to_s).utc : Time.parse(time.to_s).localtime)
                     rescue
                     end
                   else
                     @updated_on = content && content.updated_on
                   end
                 end
                 @updated_on
               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
               def save_with_content(content)
                 ret = nil
                 transaction do
                   ret = save
                   if content.text_changed?
                     self.content = content
                     ret = ret && content.changed?
                   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))
-                errors.add(:parent_title, :not_same_project) if parent && (parent.wiki_id != wiki_id)
+                if parent_id_changed? && parent && (parent.wiki_id != wiki_id)
+                  errors.add(:parent_title, :not_same_project)
+                end
               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

app/models/wiki_redirect.rb +16 -1

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 WikiRedirect < ActiveRecord::Base
               belongs_to :wiki
-              validates_presence_of :title, :redirects_to
+              validates_presence_of :wiki_id, :title, :redirects_to
               validates_length_of :title, :redirects_to, :maximum => 255
               attr_protected :id
+              before_save :set_redirects_to_wiki_id
+              def target_page
+                wiki = Wiki.find_by_id(redirects_to_wiki_id)
+                if wiki
+                  wiki.find_page(redirects_to, :with_redirect => false)
+                end
+              end
+              private
+              def set_redirects_to_wiki_id
+                self.redirects_to_wiki_id ||= wiki_id
+              end
             end

app/views/wiki/rename.html.erb +5 0

             <%= wiki_page_breadcrumb(@page) %>
             <h2><%= h @original_title %></h2>
             <%= error_messages_for 'page' %>
             <%= labelled_form_for :wiki_page, @page,
                                  :url => { :action => 'rename' },
                                  :html => { :method => :post } do |f| %>
             <div class="box tabular">
             <p><%= f.text_field :title, :required => true, :size => 100  %></p>
             <p><%= f.check_box :redirect_existing_links %></p>
             <p><%= f.select :parent_id,
                             content_tag('option', '', :value => '') +
                               wiki_page_options_for_select(
                                 @wiki.pages.includes(:parent).to_a - @page.self_and_descendants,
                                 @page.parent),
                             :label => :field_parent_title %></p>
+            <% if @page.safe_attribute? 'wiki_id' %>
+            <p><%= f.select :wiki_id, wiki_page_wiki_options_for_select(@page), :label => :label_project %></p>
+            <% end %>
             </div>
             <%= submit_tag l(:button_rename) %>
             <% end %>

test/functional/wiki_controller_test.rb +33 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 WikiControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles,
                        :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                        :wiki_content_versions, :attachments,
                        :issues, :issue_statuses
               def setup
                 User.current = nil
               end
               def test_show_start_page
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_select 'h1', :text => /CookBook documentation/
                 # child_pages macro
                 assert_select 'ul.pages-hierarchy>li>a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image',
                   :text => 'Page with an inline image'
               end
               def test_export_link
                 Role.anonymous.add_permission! :export_wiki_pages
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation.txt'
               end
               def test_show_page_with_name
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'show'
                 assert_select 'h1', :text => /Another page/
                 # Included page with an inline image
                 assert_select 'p', :text => /This is an inline image/
                 assert_select 'img[src=?][alt=?]', '/attachments/download/3/logo.gif', 'This is a logo'
               end
               def test_show_old_version
                 with_settings :default_language => 'en' do
                   get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 end
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/1', :text => /Previous/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/diff', :text => /diff/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/3', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_old_version_with_attachments
                 page = WikiPage.find(4)
                 assert page.attachments.any?
                 content = page.content
                 content.text = "update"
                 content.save!
                 get :show, :project_id => 'ecookbook', :id => page.title, :version => '1'
                 assert_kind_of WikiContent::Version, assigns(:content)
                 assert_response :success
                 assert_template 'show'
               end
               def test_show_old_version_without_permission_should_be_denied
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fprojects%2Fecookbook%2Fwiki%2FCookBook_documentation%2F2'
               end
               def test_show_first_version
                 with_settings :default_language => 'en' do
                   get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'
                 end
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a', :text => /Previous/, :count => 0
                 assert_select 'a', :text => /diff/, :count => 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_redirected_page
                 WikiRedirect.create!(:wiki_id => 1, :title => 'Old_title', :redirects_to => 'Another_page')
                 get :show, :project_id => 'ecookbook', :id => 'Old_title'
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
               end
               def test_show_with_sidebar
                 page = Project.find(1).wiki.pages.new(:title => 'Sidebar')
                 page.content = WikiContent.new(:text => 'Side bar content for test_show_with_sidebar')
                 page.save!
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_select 'div#sidebar', :text => /Side bar content for test_show_with_sidebar/
               end
               def test_show_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=1', 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=3'
               end
               def test_show_current_version_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 3
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
               end
               def test_show_old_version_should_not_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2', 0
               end
               def test_show_unexistent_page_without_edit_right
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response 404
               end
               def test_show_unexistent_page_with_edit_right
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_show_specific_version_of_an_unexistent_page_without_edit_right
                 get :show, :project_id => 1, :id => 'Unexistent page', :version => 1
                 assert_response 404
               end
               def test_show_unexistent_page_with_parent_should_preselect_parent
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'select[name=?] option[value="2"][selected=selected]', 'wiki_page[parent_id]'
               end
               def test_show_should_not_show_history_without_permission
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_response 302
               end
               def test_show_page_without_content_should_display_the_edit_form
                 @request.session[:user_id] = 2
                 WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
                 get :show, :project_id => 1, :id => 'NoContent'
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'textarea[name=?]', 'content[text]'
               end
               def test_create_page
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0}
                   end
                 end
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'New_page'
                 page = Project.find(1).wiki.find_page('New page')
                 assert !page.new_record?
                 assert_not_nil page.content
                 assert_nil page.parent
                 assert_equal 'Created the page', page.content.comments
               end
               def test_create_page_with_attachments
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'Attachment.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0},
                                 :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                   end
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal 1, page.attachments.count
                 assert_equal 'testfile.txt', page.attachments.first.filename
               end
               def test_create_page_with_parent
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   put :update, :project_id => 1, :id => 'New page',
                     :content => {:text => "h1. New page\n\nThis is a new page", :version => 0},
                     :wiki_page => {:parent_id => 2}
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal WikiPage.find(2), page.parent
               end
               def test_edit_page
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'textarea[name=?]', 'content[text]',
                   :text => WikiPage.find_by_title('Another_page').content.text
               end
               def test_edit_section
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 2
                 assert_response :success
                 assert_template 'edit'
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 assert_select 'textarea[name=?]', 'content[text]', :text => section
                 assert_select 'input[name=section][type=hidden][value="2"]'
                 assert_select 'input[name=section_hash][type=hidden][value=?]', hash
               end
               def test_edit_invalid_section_should_respond_with_404
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 10
                 assert_response 404
               end
               def test_update_page
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
               end
               def test_update_page_with_parent
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'a' * 300,  # failure here, comment is too long
                           :text => 'edited',
                           :version => 1
                         }
                       end
                     end
                   end
                 assert_response :success
                 assert_template 'edit'
                 assert_select_error /Comment is too long/
                 assert_select 'textarea#content_text', :text => "edited"
                 assert_select 'input#content_version[value="1"]'
               end
               def test_update_page_with_parent_change_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => '',
                           :text => Wiki.find(1).find_page('Another_page').content.text,
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_attachments_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       assert_difference 'Attachment.count' do
                         put :update, :project_id => 1,
                           :id => 'Another_page',
                           :content => {
                             :comments => '',
                             :text => Wiki.find(1).find_page('Another_page').content.text,
                             :version => 1
                           },
                           :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                       end
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
               end
               def test_update_stale_page_should_not_raise_an_error
                 @request.session[:user_id] = 2
                 c = Wiki.find(1).find_page('Another_page').content
                 c.text = 'Previous text'
                 c.save!
                 assert_equal 2, c.version
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'My comments',
                           :text => 'Text should not be lost',
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.error', :text => /Data has been updated by another user/
                 assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                 assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
                 c.reload
                 assert_equal 'Previous text', c.text
                 assert_equal 2, c.version
               end
               def test_update_page_without_content_should_create_content
                 @request.session[:user_id] = 2
                 page = WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
                 assert_no_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
                     put :update, :project_id => 1, :id => 'NoContent', :content => {:text => 'Some content'}
                     assert_response 302
                   end
                 end
                 assert_equal 'Some content', page.reload.content.text
               end
               def test_update_section
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections#section-2'
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.reload.content.text
               end
               def test_update_section_should_allow_stale_page_update
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 2 # Current version is 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections#section-2'
                 page.reload
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.content.text
                 assert_equal 4, page.content.version
               end
               def test_update_section_should_not_allow_stale_section_update
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :comments => 'My comments',
                           :text => "Text should not be lost",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => Digest::MD5.hexdigest("wrong hash")
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.error', :text => /Data has been updated by another user/
                 assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                 assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
               end
               def test_preview
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'CookBook_documentation',
                                                :content => { :comments => '',
                                                              :text => 'this is a *previewed text*',
                                                              :version => 3 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_select 'strong', :text => /previewed text/
               end
               def test_preview_new_page
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'New page',
                                                :content => { :text => 'h1. New page',
                                                              :comments => '',
                                                              :version => 0 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_select 'h1', :text => /New page/
               end
               def test_history
                 @request.session[:user_id] = 2
                 get :history, :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 3, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]"
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => '2'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => 'Delete'
                 end
               end
               def test_history_with_one_version
                 @request.session[:user_id] = 2
                 get :history, :project_id => 'ecookbook', :id => 'Another_page'
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 1, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]", false
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => '1'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => 'Delete', :count => 0
                 end
               end
               def test_diff
                 content = WikiPage.find(1).content
                 assert_difference 'WikiContent::Version.count', 2 do
                   content.text = "Line removed\nThis is a sample text for testing diffs"
                   content.save!
                   content.text = "This is a sample text for testing diffs\nLine added"
                   content.save!
                 end
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => content.version, :version_from => (content.version - 1)
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => 'Line removed'
                 assert_select 'span.diff_in', :text => 'Line added'
               end
               def test_diff_with_invalid_version_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_diff_with_invalid_version_from_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99', :version_from => '98'
                 assert_response 404
               end
               def test_annotate
                 get :annotate, :project_id => 1, :id =>  'CookBook_documentation', :version => 2
                 assert_response :success
                 assert_template 'annotate'
                 # Line 1
                 assert_select 'table.annotate tr:nth-child(1)' do
                   assert_select 'th.line-num', :text => '1'
                   assert_select 'td.author', :text => /John Smith/
                   assert_select 'td', :text => /h1\. CookBook documentation/
                 end
                 # Line 5
                 assert_select 'table.annotate tr:nth-child(5)' do
                   assert_select 'th.line-num', :text => '5'
                   assert_select 'td.author', :text => /Redmine Admin/
                   assert_select 'td', :text => /Some updated \[\[documentation\]\] here/
                 end
               end
               def test_annotate_with_invalid_version_should_respond_with_404
                 get :annotate, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_get_rename
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'rename'
                 assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                   assert_select 'option[value=""]', :text => ''
                   assert_select 'option[selected=selected]', 0
                 end
               end
               def test_get_rename_child_page
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Child_1'
                 assert_response :success
                 assert_template 'rename'
                 assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                   assert_select 'option[value=""]', :text => ''
                   assert_select 'option[value="2"][selected=selected]', :text => /Another page/
                 end
               end
               def test_rename_with_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => 1 }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check redirects
                 assert_not_nil wiki.find_page('Another page')
                 assert_nil wiki.find_page('Another page', :with_redirect => false)
               end
               def test_rename_without_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => "0" }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check that there's no redirects
                 assert_nil wiki.find_page('Another page')
               end
               def test_rename_with_parent_assignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                   :wiki_page => { :title => 'Another page', :redirect_existing_links => "0", :parent_id => '4' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert_equal WikiPage.find(4), WikiPage.find_by_title('Another_page').parent
               end
               def test_rename_with_parent_unassignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Child_1',
                   :wiki_page => { :title => 'Child 1', :redirect_existing_links => "0", :parent_id => '' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Child_1'
                 assert_nil WikiPage.find_by_title('Child_1').parent
               end
+              def test_get_rename_should_show_target_projects_list
+                @request.session[:user_id] = 2
+                project = Project.find(5)
+                project.enable_module! :wiki
+                get :rename, :project_id => 1, :id => 'Another_page'
+                assert_response :success
+                assert_template 'rename'
+                assert_select 'select[name=?]', 'wiki_page[wiki_id]' do
+                  assert_select 'option', 2
+                  assert_select 'option[value=?][selected=selected]', '1', :text => /eCookbook/
+                  assert_select 'option[value=?]', project.wiki.id.to_s, :text => /#{project.name}/
+                end
+              end
+              def test_rename_with_move
+                @request.session[:user_id] = 2
+                project = Project.find(5)
+                project.enable_module! :wiki
+                post :rename, :project_id => 1, :id => 'Another_page',
+                  :wiki_page => {
+                    :wiki_id => project.wiki.id.to_s,
+                    :title => 'Another renamed page',
+                    :redirect_existing_links => 1
+                  }
+                assert_redirected_to '/projects/private-child/wiki/Another_renamed_page'
+                page = WikiPage.find(2)
+                assert_equal project.wiki.id, page.wiki_id
+              end
               def test_destroy_a_page_without_children_should_not_ask_confirmation
                 @request.session[:user_id] = 2
                 delete :destroy, :project_id => 1, :id => 'Child_2'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
               end
               def test_destroy_parent_should_ask_confirmation
                 @request.session[:user_id] = 2
                 assert_no_difference('WikiPage.count') do
                   delete :destroy, :project_id => 1, :id => 'Another_page'
                 end
                 assert_response :success
                 assert_template 'destroy'
                 assert_select 'form' do
                   assert_select 'input[name=todo][value=nullify]'
                   assert_select 'input[name=todo][value=destroy]'
                   assert_select 'input[name=todo][value=reassign]'
                 end
               end
               def test_destroy_parent_with_nullify_should_delete_parent_only
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'nullify'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
               end
               def test_destroy_parent_with_cascade_should_delete_descendants
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -4) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'destroy'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_nil WikiPage.find_by_id(5)
               end
               def test_destroy_parent_with_reassign
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'reassign', :reassign_to_id => 1
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_equal WikiPage.find(1), WikiPage.find_by_id(5).parent
               end
               def test_destroy_version
                 @request.session[:user_id] = 2
                 assert_difference 'WikiContent::Version.count', -1 do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiPage.count' do
                       delete :destroy_version, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 2
                       assert_redirected_to '/projects/ecookbook/wiki/CookBook_documentation/history'
                     end
                   end
                 end
               end
               def test_index
                 get :index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'index'
                 pages = assigns(:pages)
                 assert_not_nil pages
                 assert_equal Project.find(1).wiki.pages.size, pages.size
                 assert_equal pages.first.content.updated_on, pages.first.updated_on
                 assert_select 'ul.pages-hierarchy' do
                   assert_select 'li' do
                     assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => 'CookBook documentation'
                     assert_select 'ul li a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image', :text => 'Page with an inline image'
                   end
                   assert_select 'li a[href=?]', '/projects/ecookbook/wiki/Another_page', :text => 'Another page'
                 end
               end
               def test_index_should_include_atom_link
                 get :index, :project_id => 'ecookbook'
                 assert_select 'a[href=?]', '/projects/ecookbook/activity.atom?show_wiki_edits=1'
               end
               def test_export_to_html
                 @request.session[:user_id] = 2
                 get :export, :project_id => 'ecookbook'
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal "text/html", @response.content_type
                 assert_select "a[name=?]", "CookBook_documentation"
                 assert_select "a[name=?]", "Another_page"
                 assert_select "a[name=?]", "Page_with_an_inline_image"
               end
               def test_export_to_pdf
                 @request.session[:user_id] = 2
                 get :export, :project_id => 'ecookbook', :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="ecookbook.pdf"', @response.headers['Content-Disposition']
                 assert @response.body.starts_with?('%PDF')
               end
               def test_export_without_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :export_wiki_pages
                 get :export, :project_id => 'ecookbook'
                 assert_response 403
               end
               def test_date_index
                 get :date_index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'date_index'
                 assert_not_nil assigns(:pages)
                 assert_not_nil assigns(:pages_by_date)
                 assert_select 'a[href=?]', '/projects/ecookbook/activity.atom?show_wiki_edits=1'
               end
               def test_not_found
                 get :show, :project_id => 999
                 assert_response 404
               end
               def test_protect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'Another_page')
                 assert !page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '1'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert page.reload.protected?
               end
               def test_unprotect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'CookBook_documentation')
                 assert page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '0'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert !page.reload.protected?
               end
               def test_show_page_with_edit_link
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit'
               end
               def test_show_page_without_edit_link
                 @request.session[:user_id] = 4
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit', 0
               end
               def test_show_pdf
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.pdf"',
                               @response.headers['Content-Disposition']
               end
               def test_show_html
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'html'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_select 'h1', :text => /CookBook documentation/
               end
               def test_show_versioned_html
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'html', :version => 2
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_select 'h1', :text => /CookBook documentation/
               end
               def test_show_txt
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'txt'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_show_versioned_txt
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'txt', :version => 2
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_edit_unprotected_page
                 # Non members can edit unprotected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_edit_protected_page_by_nonmember
                 # Non members can't edit protected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response 403
               end
               def test_edit_protected_page_by_member
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_history_of_non_existing_page_should_return_404
                 get :history, :project_id => 1, :id => 'Unknown_page'
                 assert_response 404
               end
               def test_add_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count' do
                   post :add_attachment, :project_id => 1, :id => 'CookBook_documentation',
                        :attachments => {
                          '1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'),
                                  'description' => 'test file'}
                        }
                 end
                 attachment = Attachment.order('id DESC').first
                 assert_equal Wiki.find(1).find_page('CookBook_documentation'), attachment.container
               end
             end

test/unit/wiki_page_test.rb +20 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  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_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_updated_on_eager_load
                 page = WikiPage.with_updated_on.order('id').first
                 assert page.is_a?(WikiPage)
                 assert_not_nil page.read_attribute(:updated_on)
                 assert_equal Time.gm(2007, 3, 6, 23, 10, 51), page.content.updated_on
                 assert_equal page.content.updated_on, page.updated_on
                 assert_not_nil page.read_attribute(: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

test/unit/wiki_redirect_test.rb +30 -7

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 WikiRedirectTest < ActiveSupport::TestCase
               fixtures :projects, :wikis, :wiki_pages
               def setup
                 @wiki = Wiki.find(1)
                 @original = WikiPage.create(:wiki => @wiki, :title => 'Original title')
               end
-              def test_create_redirect
+              def test_create_redirect_on_rename
                 @original.title = 'New title'
-                assert @original.save
+                @original.save!
-                @original.reload
-                assert_equal 'New_title', @original.title
+                redirect = @wiki.redirects.find_by_title('Original_title')
-                assert @wiki.redirects.find_by_title('Original_title')
+                assert_not_nil redirect
-                assert @wiki.find_page('Original title')
+                assert_equal 1, redirect.redirects_to_wiki_id
-                assert @wiki.find_page('ORIGINAL title')
+                assert_equal 'New_title', redirect.redirects_to
+                assert_equal @original, redirect.target_page
+              end
+              def test_create_redirect_on_move
+                @original.wiki_id = 2
+                @original.save!
+                redirect = @wiki.redirects.find_by_title('Original_title')
+                assert_not_nil redirect
+                assert_equal 2, redirect.redirects_to_wiki_id
+                assert_equal 'Original_title', redirect.redirects_to
+                assert_equal @original, redirect.target_page
+              end
+              def test_create_redirect_on_rename_and_move
+                @original.title = 'New title'
+                @original.wiki_id = 2
+                @original.save!
+                redirect = @wiki.redirects.find_by_title('Original_title')
+                assert_not_nil redirect
+                assert_equal 2, redirect.redirects_to_wiki_id
+                assert_equal 'New_title', redirect.redirects_to
+                assert_equal @original, redirect.target_page
               end
               def test_update_redirect
                 # create a redirect that point to this page
                 assert WikiRedirect.create(:wiki => @wiki, :title => 'An_old_page', :redirects_to => 'Original_title')
                 @original.title = 'New title'
                 @original.save
                 # make sure the old page now points to the new page
                 assert_equal 'New_title', @wiki.find_page('An old page').title
               end
               def test_reverse_rename
                 # create a redirect that point to this page
                 assert WikiRedirect.create(:wiki => @wiki, :title => 'An_old_page', :redirects_to => 'Original_title')
                 @original.title = 'An old page'
                 @original.save
                 assert !@wiki.redirects.find_by_title_and_redirects_to('An_old_page', 'An_old_page')
                 assert @wiki.redirects.find_by_title_and_redirects_to('Original_title', 'An_old_page')
               end
               def test_rename_to_already_redirected
                 assert WikiRedirect.create(:wiki => @wiki, :title => 'An_old_page', :redirects_to => 'Other_page')
                 @original.title = 'An old page'
                 @original.save
                 # this redirect have to be removed since 'An old page' page now exists
                 assert !@wiki.redirects.find_by_title_and_redirects_to('An_old_page', 'Other_page')
               end
               def test_redirects_removed_when_deleting_page
                 assert WikiRedirect.create(:wiki => @wiki, :title => 'An_old_page', :redirects_to => 'Original_title')
                 @original.destroy
                 assert_nil @wiki.redirects.first
               end
             end

test/unit/wiki_test.rb +14 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2014  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 WikiTest < ActiveSupport::TestCase
               fixtures :projects, :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions
               def test_create
                 wiki = Wiki.new(:project => Project.find(3))
                 assert !wiki.save
                 assert_equal 1, wiki.errors.count
                 wiki.start_page = "Start page"
                 assert wiki.save
               end
               def test_update
                 @wiki = Wiki.find(1)
                 @wiki.start_page = "Another start page"
                 assert @wiki.save
                 @wiki.reload
                 assert_equal "Another start page", @wiki.start_page
               end
               def test_find_page_should_not_be_case_sensitive
                 wiki = Wiki.find(1)
                 page = WikiPage.find(2)
                 assert_equal page, wiki.find_page('Another_page')
                 assert_equal page, wiki.find_page('Another page')
                 assert_equal page, wiki.find_page('ANOTHER page')
               end
               def test_find_page_with_cyrillic_characters
                 wiki = Wiki.find(1)
                 page = WikiPage.find(10)
                 assert_equal page, wiki.find_page('Этика_менеджмента')
               end
               def test_find_page_with_backslashes
                 wiki = Wiki.find(1)
                 page = WikiPage.create!(:wiki => wiki, :title => '2009\\02\\09')
                 assert_equal page, wiki.find_page('2009\\02\\09')
               end
               def test_find_page_without_redirect
                 wiki = Wiki.find(1)
                 page = wiki.find_page('Another_page')
                 assert_not_nil page
                 assert_equal 'Another_page', page.title
                 assert_equal false, wiki.page_found_with_redirect?
               end
               def test_find_page_with_redirect
                 wiki = Wiki.find(1)
                 WikiRedirect.create!(:wiki => wiki, :title => 'Old_title', :redirects_to => 'Another_page')
                 page = wiki.find_page('Old_title')
                 assert_not_nil page
                 assert_equal 'Another_page', page.title
                 assert_equal true, wiki.page_found_with_redirect?
               end
               def test_titleize
                 ja_test = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding('UTF-8')
                 assert_equal 'Page_title_with_CAPITALES', Wiki.titleize('page title with CAPITALES')
                 assert_equal ja_test, Wiki.titleize(ja_test)
               end
               def test_sidebar_should_return_nil_if_undefined
                 @wiki = Wiki.find(1)
                 assert_nil @wiki.sidebar
               end
               def test_sidebar_should_return_a_wiki_page_if_defined
                 @wiki = Wiki.find(1)
                 page = @wiki.pages.new(:title => 'Sidebar')
                 page.content = WikiContent.new(:text => 'Side bar content for test_show_with_sidebar')
                 page.save!
                 assert_kind_of WikiPage, @wiki.sidebar
                 assert_equal 'Sidebar', @wiki.sidebar.title
               end
+              def test_destroy_should_remove_redirects_from_the_wiki
+                WikiRedirect.create!(:wiki_id => 1, :title => 'Foo', :redirects_to_wiki_id => 2, :redirects_to => 'Bar')
+                Wiki.find(1).destroy
+                assert_equal 0, WikiRedirect.where(:wiki_id => 1).count
+              end
+              def test_destroy_should_remove_redirects_to_the_wiki
+                WikiRedirect.create!(:wiki_id => 2, :title => 'Foo', :redirects_to_wiki_id => 1, :redirects_to => 'Bar')
+                Wiki.find(1).destroy
+                assert_equal 0, WikiRedirect.where(:redirects_to_wiki_id => 1).count
+              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