jro_apps/redmine Commit - r10704:ea296a109a86

Replaces find(:first/:all) calls....

Jean-Philippe Lang -

r10704:ea296a109a86

parent child

Context file:

r10704:ea296a109a86

Collapse all files

app/controllers/admin_controller.rb +2 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 AdminController < ApplicationController
               layout 'admin'
               menu_item :projects, :only => :projects
               menu_item :plugins, :only => :plugins
               menu_item :info, :only => :info
               before_filter :require_admin
               helper :sort
               include SortHelper
               def index
                 @no_configuration_data = Redmine::DefaultData::Loader::no_data?
               end
               def projects
                 @status = params[:status] || 1
-                scope = Project.status(@status)
+                scope = Project.status(@status).order('lft')
                 scope = scope.like(params[:name]) if params[:name].present?
+                @projects = scope.all
-                @projects = scope.all(:order => 'lft')
                 render :action => "projects", :layout => false if request.xhr?
               end
               def plugins
                 @plugins = Redmine::Plugin.all
               end
               # Loads the default configuration
               # (roles, trackers, statuses, workflow, enumerations)
               def default_configuration
                 if request.post?
                   begin
                     Redmine::DefaultData::Loader::load(params[:lang])
                     flash[:notice] = l(:notice_default_data_loaded)
                   rescue Exception => e
                     flash[:error] = l(:error_can_t_load_default_data, e.message)
                   end
                 end
                 redirect_to :action => 'index'
               end
               def test_email
                 raise_delivery_errors = ActionMailer::Base.raise_delivery_errors
                 # Force ActionMailer to raise delivery errors so we can catch it
                 ActionMailer::Base.raise_delivery_errors = true
                 begin
                   @test = Mailer.test_email(User.current).deliver
                   flash[:notice] = l(:notice_email_sent, User.current.mail)
                 rescue Exception => e
                   flash[:error] = l(:notice_email_error, e.message)
                 end
                 ActionMailer::Base.raise_delivery_errors = raise_delivery_errors
                 redirect_to :controller => 'settings', :action => 'edit', :tab => 'notifications'
               end
               def info
                 @db_adapter_name = ActiveRecord::Base.connection.adapter_name
                 @checklist = [
                   [:text_default_administrator_account_changed, User.default_admin_account_changed?],
                   [:text_file_repository_writable, File.writable?(Attachment.storage_path)],
                   [:text_plugin_assets_writable,   File.writable?(Redmine::Plugin.public_directory)],
                   [:text_rmagick_available,        Object.const_defined?(:Magick)]
                 ]
               end
             end

app/controllers/boards_controller.rb +12 -7

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 BoardsController < ApplicationController
               default_search_scope :messages
               before_filter :find_project_by_project_id, :find_board_if_available, :authorize
               accept_rss_auth :index, :show
               helper :sort
               include SortHelper
               helper :watchers
               def index
                 @boards = @project.boards.includes(:last_message => :author).all
                 # show the board if there is only one
                 if @boards.size == 1
                   @board = @boards.first
                   show
                 end
               end
               def show
                 respond_to do |format|
                   format.html {
                     sort_init 'updated_on', 'desc'
                     sort_update	'created_on' => "#{Message.table_name}.created_on",
                                 'replies' => "#{Message.table_name}.replies_count",
                                 'updated_on' => "#{Message.table_name}.updated_on"
                     @topic_count = @board.topics.count
                     @topic_pages = Paginator.new self, @topic_count, per_page_option, params['page']
-                    @topics =  @board.topics.reorder("#{Message.table_name}.sticky DESC").order(sort_clause).all(
+                    @topics =  @board.topics.
-                                                  :include => [:author, {:last_reply => :author}],
+                      reorder("#{Message.table_name}.sticky DESC").
-                                                  :limit  =>  @topic_pages.items_per_page,
+                      includes(:author, {:last_reply => :author}).
-                                                  :offset =>  @topic_pages.current.offset)
+                      limit(@topic_pages.items_per_page).
+                      offset(@topic_pages.current.offset).
+                      order(sort_clause).
+                      all
                     @message = Message.new(:board => @board)
                     render :action => 'show', :layout => !request.xhr?
                   }
                   format.atom {
-                    @messages = @board.messages.find :all, :order => 'created_on DESC',
+                    @messages = @board.messages.
-                                                           :include => [:author, :board],
+                      reorder('created_on DESC').
-                                                           :limit => Setting.feeds_limit.to_i
+                      includes(:author, :board).
+                      limit(Setting.feeds_limit.to_i).
+                      all
                     render_feed(@messages, :title => "#{@project}: #{@board}")
                   }
                 end
               end
               def new
                 @board = @project.boards.build
                 @board.safe_attributes = params[:board]
               end
               def create
                 @board = @project.boards.build
                 @board.safe_attributes = params[:board]
                 if @board.save
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to_settings_in_projects
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 @board.safe_attributes = params[:board]
                 if @board.save
                   redirect_to_settings_in_projects
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @board.destroy
                 redirect_to_settings_in_projects
               end
             private
               def redirect_to_settings_in_projects
                 redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'
               end
               def find_board_if_available
                 @board = @project.boards.find(params[:id]) if params[:id]
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/documents_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 DocumentsController < ApplicationController
               default_search_scope :documents
               model_object Document
               before_filter :find_project_by_project_id, :only => [:index, :new, :create]
               before_filter :find_model_object, :except => [:index, :new, :create]
               before_filter :find_project_from_association, :except => [:index, :new, :create]
               before_filter :authorize
               helper :attachments
               def index
                 @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'
-                documents = @project.documents.find :all, :include => [:attachments, :category]
+                documents = @project.documents.includes(:attachments, :category).all
                 case @sort_by
                 when 'date'
                   @grouped = documents.group_by {|d| d.updated_on.to_date }
                 when 'title'
                   @grouped = documents.group_by {|d| d.title.first.upcase}
                 when 'author'
                   @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}
                 else
                   @grouped = documents.group_by(&:category)
                 end
                 @document = @project.documents.build
                 render :layout => false if request.xhr?
               end
               def show
                 @attachments = @document.attachments.all
               end
               def new
                 @document = @project.documents.build
                 @document.safe_attributes = params[:document]
               end
               def create
                 @document = @project.documents.build
                 @document.safe_attributes = params[:document]
                 @document.save_attachments(params[:attachments])
                 if @document.save
                   render_attachment_warning_if_needed(@document)
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'index', :project_id => @project
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 @document.safe_attributes = params[:document]
                 if request.put? and @document.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :id => @document
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @document.destroy if request.delete?
                 redirect_to :controller => 'documents', :action => 'index', :project_id => @project
               end
               def add_attachment
                 attachments = Attachment.attach_files(@document, params[:attachments])
                 render_attachment_warning_if_needed(@document)
                 if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')
                   Mailer.attachments_added(attachments[:files]).deliver
                 end
                 redirect_to :action => 'show', :id => @document
               end
             end

app/controllers/trackers_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class TrackersController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :index
               before_filter :require_admin_or_api_request, :only => :index
               accept_api_auth :index
               def index
                 respond_to do |format|
                   format.html {
                     @tracker_pages, @trackers = paginate :trackers, :per_page => 10, :order => 'position'
                     render :action => "index", :layout => false if request.xhr?
                   }
                   format.api {
                     @trackers = Tracker.sorted.all
                   }
                 end
               end
               def new
                 @tracker ||= Tracker.new(params[:tracker])
-                @trackers = Tracker.find :all, :order => 'position'
+                @trackers = Tracker.sorted.all
                 @projects = Project.all
               end
               def create
                 @tracker = Tracker.new(params[:tracker])
                 if request.post? and @tracker.save
                   # workflow copy
                   if !params[:copy_workflow_from].blank? && (copy_from = Tracker.find_by_id(params[:copy_workflow_from]))
                     @tracker.workflow_rules.copy(copy_from)
                   end
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'index'
                   return
                 end
                 new
                 render :action => 'new'
               end
               def edit
                 @tracker ||= Tracker.find(params[:id])
                 @projects = Project.all
               end
               def update
                 @tracker = Tracker.find(params[:id])
                 if request.put? and @tracker.update_attributes(params[:tracker])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'index'
                   return
                 end
                 edit
                 render :action => 'edit'
               end
               def destroy
                 @tracker = Tracker.find(params[:id])
                 unless @tracker.issues.empty?
                   flash[:error] = l(:error_can_not_delete_tracker)
                 else
                   @tracker.destroy
                 end
                 redirect_to :action => 'index'
               end
               def fields
                 if request.post? && params[:trackers]
                   params[:trackers].each do |tracker_id, tracker_params|
                     tracker = Tracker.find_by_id(tracker_id)
                     if tracker
                       tracker.core_fields = tracker_params[:core_fields]
                       tracker.custom_field_ids = tracker_params[:custom_field_ids]
                       tracker.save
                     end
                   end
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'fields'
                   return
                 end
                 @trackers = Tracker.sorted.all
                 @custom_fields = IssueCustomField.all.sort
               end
             end

app/controllers/users_controller.rb +1 -4

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 UsersController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :show
               before_filter :find_user, :only => [:show, :edit, :update, :destroy, :edit_membership, :destroy_membership]
               accept_api_auth :index, :show, :create, :update, :destroy
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               def index
                 sort_init 'login', 'asc'
                 sort_update %w(login firstname lastname mail admin created_on last_login_on)
                 case params[:format]
                 when 'xml', 'json'
                   @offset, @limit = api_offset_and_limit
                 else
                   @limit = per_page_option
                 end
                 @status = params[:status] || 1
                 scope = User.logged.status(@status)
                 scope = scope.like(params[:name]) if params[:name].present?
                 scope = scope.in_group(params[:group_id]) if params[:group_id].present?
                 @user_count = scope.count
                 @user_pages = Paginator.new self, @user_count, @limit, params['page']
                 @offset ||= @user_pages.current.offset
-                @users =  scope.find :all,
+                @users =  scope.order(sort_clause).limit(@limit).offset(@offset).all
-                                    :order => sort_clause,
-                                    :limit  =>  @limit,
-                                    :offset =>  @offset
                 respond_to do |format|
                   format.html {
                     @groups = Group.all.sort
                     render :layout => !request.xhr?
                   }
                   format.api
                 end
               end
               def show
                 # show projects based on current user visibility
                 @memberships = @user.memberships.all(:conditions => Project.visible_condition(User.current))
                 events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                 @events_by_day = events.group_by(&:event_date)
                 unless User.current.admin?
                   if !@user.active? || (@user != User.current  && @memberships.empty? && events.empty?)
                     render_404
                     return
                   end
                 end
                 respond_to do |format|
                   format.html { render :layout => 'base' }
                   format.api
                 end
               end
               def new
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @auth_sources = AuthSource.all
               end
               def create
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @user.safe_attributes = params[:user]
                 @user.admin = params[:user][:admin] || false
                 @user.login = params[:user][:login]
                 @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation] unless @user.auth_source_id
                 if @user.save
                   @user.pref.attributes = params[:pref]
                   @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
                   Mailer.account_information(@user, params[:user][:password]).deliver if params[:send_information]
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_user_successful_create, :id => view_context.link_to(@user.login, user_path(@user)))
                       redirect_to(params[:continue] ?
                         {:controller => 'users', :action => 'new'} :
                         {:controller => 'users', :action => 'edit', :id => @user}
                       )
                     }
                     format.api  { render :action => 'show', :status => :created, :location => user_url(@user) }
                   end
                 else
                   @auth_sources = AuthSource.all
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               end
               def edit
                 @auth_sources = AuthSource.all
                 @membership ||= Member.new
               end
               def update
                 @user.admin = params[:user][:admin] if params[:user][:admin]
                 @user.login = params[:user][:login] if params[:user][:login]
                 if params[:user][:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
                   @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation]
                 end
                 @user.safe_attributes = params[:user]
                 # Was the account actived ? (do it before User#save clears the change)
                 was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
                 # TODO: Similar to My#account
                 @user.pref.attributes = params[:pref]
                 @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                 if @user.save
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
                   if was_activated
                     Mailer.account_activated(@user).deliver
                   elsif @user.active? && params[:send_information] && !params[:user][:password].blank? && @user.auth_source_id.nil?
                     Mailer.account_information(@user, params[:user][:password]).deliver
                   end
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to_referer_or edit_user_path(@user)
                     }
                     format.api  { render_api_ok }
                   end
                 else
                   @auth_sources = AuthSource.all
                   @membership ||= Member.new
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => :edit }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               end
               def destroy
                 @user.destroy
                 respond_to do |format|
                   format.html { redirect_back_or_default(users_url) }
                   format.api  { render_api_ok }
                 end
               end
               def edit_membership
                 @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
                 @membership.save
                 respond_to do |format|
                   format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                   format.js
                 end
               end
               def destroy_membership
                 @membership = Member.find(params[:membership_id])
                 if @membership.deletable?
                   @membership.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                   format.js
                 end
               end
               private
               def find_user
                 if params[:id] == 'current'
                   require_login || return
                   @user = User.current
                 else
                   @user = User.find(params[:id])
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/wiki_controller.rb +6 -5

             # Redmine - project management software
             # Copyright (C) 2006-2012  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'
             # 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
               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 @page.new_record?
                   if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
                 if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
                   deny_access
                   return
                 end
                 @content = @page.content_for_version(params[:version])
                 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?
                   @page.content = WikiContent.new(:page => @page)
                   if params[:parent].present?
                     @page.parent = @page.wiki.find_page(params[:parent].to_s)
                   end
                 end
                 @content = @page.content_for_version(params[:version])
                 @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
                 @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.content = WikiContent.new(:page => @page) if @page.new_record?
                 @page.safe_attributes = params[:wiki_page]
                 @content = @page.content
                 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(params[:section].to_i, @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
                   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 { redirect_to :action => 'show', :project_id => @project, :id => @page.title }
                     format.api {
                       if was_new_page
                         render :action => 'show', :status => :created, :location => url_for(:controller => 'wiki', :action => 'show', :project_id => @project, :id => @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])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :project_id => @project, :id => @page.title
                 end
               end
               def protect
                 @page.update_attribute :protected, params[:protected]
                 redirect_to :action => 'show', :project_id => @project, :id => @page.title
               end
               # show page history
               def history
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, per_page_option, params['page']
                 # don't load text
-                @versions = @page.content.versions.find :all,
+                @versions = @page.content.versions.
-                                                        :select => "id, author_id, comments, updated_on, version",
+                  select("id, author_id, comments, updated_on, version").
-                                                        :order => 'version DESC',
+                  reorder('version DESC').
-                                                        :limit  =>  @version_pages.items_per_page + 1,
+                  limit(@version_pages.items_per_page + 1).
-                                                        :offset =>  @version_pages.current.offset
+                  offset(@version_pages.current.offset).
+                  all
                 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 :action => 'index', :project_id => @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 :action => 'history', :id => @page.title, :project_id => @project
               end
               # Export wiki to a single pdf or html file
               def export
                 @pages = @wiki.pages.all(:order => 'title', :include => [:content, {:attachments => :author}])
                 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
                   @attachements = 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 params.update(:id => @page.title)
                 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 params.update(:id => @page.title)
                 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.order("#{WikiPage.table_name}.title").includes(:wiki => :project).includes(:parent).all
               end
             end

app/models/query.rb +10 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 QueryColumn
               attr_accessor :name, :sortable, :groupable, :default_order
               include Redmine::I18n
               def initialize(name, options={})
                 self.name = name
                 self.sortable = options[:sortable]
                 self.groupable = options[:groupable] || false
                 if groupable == true
                   self.groupable = name.to_s
                 end
                 self.default_order = options[:default_order]
                 @caption_key = options[:caption] || "field_#{name}"
               end
               def caption
                 l(@caption_key)
               end
               # Returns true if the column is sortable, otherwise false
               def sortable?
                 !@sortable.nil?
               end
               def sortable
                 @sortable.is_a?(Proc) ? @sortable.call : @sortable
               end
               def value(issue)
                 issue.send name
               end
               def css_classes
                 name
               end
             end
             class QueryCustomFieldColumn < QueryColumn
               def initialize(custom_field)
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 self.groupable = custom_field.group_statement || false
                 @cf = custom_field
               end
               def caption
                 @cf.name
               end
               def custom_field
                 @cf
               end
               def value(issue)
                 cv = issue.custom_values.select {|v| v.custom_field_id == @cf.id}.collect {|v| @cf.cast_value(v.value)}
                 cv.size > 1 ? cv.sort {|a,b| a.to_s <=> b.to_s} : cv.first
               end
               def css_classes
                 @css_classes ||= "#{name} #{@cf.field_format}"
               end
             end
             class Query < ActiveRecord::Base
               class StatementInvalid < ::ActiveRecord::StatementInvalid
               end
               belongs_to :project
               belongs_to :user
               serialize :filters
               serialize :column_names
               serialize :sort_criteria, Array
               attr_protected :project_id, :user_id
               validates_presence_of :name
               validates_length_of :name, :maximum => 255
               validate :validate_query_filters
               @@operators = { "="   => :label_equals,
                               "!"   => :label_not_equals,
                               "o"   => :label_open_issues,
                               "c"   => :label_closed_issues,
                               "!*"  => :label_none,
                               "*"   => :label_any,
                               ">="  => :label_greater_or_equal,
                               "<="  => :label_less_or_equal,
                               "><"  => :label_between,
                               "<t+" => :label_in_less_than,
                               ">t+" => :label_in_more_than,
                               "><t+"=> :label_in_the_next_days,
                               "t+"  => :label_in,
                               "t"   => :label_today,
                               "w"   => :label_this_week,
                               ">t-" => :label_less_than_ago,
                               "<t-" => :label_more_than_ago,
                               "><t-"=> :label_in_the_past_days,
                               "t-"  => :label_ago,
                               "~"   => :label_contains,
                               "!~"  => :label_not_contains,
                               "=p"  => :label_any_issues_in_project,
                               "=!p" => :label_any_issues_not_in_project,
                               "!p"  => :label_no_issues_in_project}
               cattr_reader :operators
               @@operators_by_filter_type = { :list => [ "=", "!" ],
                                              :list_status => [ "o", "=", "!", "c", "*" ],
                                              :list_optional => [ "=", "!", "!*", "*" ],
                                              :list_subprojects => [ "*", "!*", "=" ],
                                              :date => [ "=", ">=", "<=", "><", "<t+", ">t+", "><t+", "t+", "t", "w", ">t-", "<t-", "><t-", "t-", "!*", "*" ],
                                              :date_past => [ "=", ">=", "<=", "><", ">t-", "<t-", "><t-", "t-", "t", "w", "!*", "*" ],
                                              :string => [ "=", "~", "!", "!~", "!*", "*" ],
                                              :text => [  "~", "!~", "!*", "*" ],
                                              :integer => [ "=", ">=", "<=", "><", "!*", "*" ],
                                              :float => [ "=", ">=", "<=", "><", "!*", "*" ],
                                              :relation => ["=", "=p", "=!p", "!p", "!*", "*"]}
               cattr_reader :operators_by_filter_type
               @@available_columns = [
                 QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
                 QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),
                 QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),
                 QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),
                 QueryColumn.new(:priority, :sortable => "#{IssuePriority.table_name}.position", :default_order => 'desc', :groupable => true),
                 QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
                 QueryColumn.new(:author, :sortable => lambda {User.fields_for_order_statement("authors")}, :groupable => true),
                 QueryColumn.new(:assigned_to, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),
                 QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
                 QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),
                 QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),
                 QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
                 QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
                 QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
                 QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
                 QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
                 QueryColumn.new(:relations, :caption => :label_related_issues)
               ]
               cattr_reader :available_columns
               scope :visible, lambda {|*args|
                 user = args.shift || User.current
                 base = Project.allowed_to_condition(user, :view_issues, *args)
                 user_id = user.logged? ? user.id : 0
                 {
                   :conditions => ["(#{table_name}.project_id IS NULL OR (#{base})) AND (#{table_name}.is_public = ? OR #{table_name}.user_id = ?)", true, user_id],
                   :include => :project
                 }
               }
               def initialize(attributes=nil, *args)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
                 @is_for_all = project.nil?
               end
               def validate_query_filters
                 filters.each_key do |field|
                   if values_for(field)
                     case type_for(field)
                     when :integer
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+$/) }
                     when :float
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+(\.\d*)?$/) }
                     when :date, :date_past
                       case operator_for(field)
                       when "=", ">=", "<=", "><"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && (!v.match(/^\d{4}-\d{2}-\d{2}$/) || (Date.parse(v) rescue nil).nil?) }
                       when ">t-", "<t-", "t-", ">t+", "<t+", "t+", "><t+", "><t-"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }
                       end
                     end
                   end
                   add_filter_error(field, :blank) unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t", "w"].include? operator_for(field)
                 end if filters
               end
               def add_filter_error(field, message)
                 m = label_for(field) + " " + l(message, :scope => 'activerecord.errors.messages')
                 errors.add(:base, m)
               end
               # Returns true if the query is visible to +user+ or the current user.
               def visible?(user=User.current)
                 (project.nil? || user.allowed_to?(:view_issues, project)) && (self.is_public? || self.user_id == user.id)
               end
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
                 return true if user.admin? || (!is_public && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
                 is_public && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def trackers
                 @trackers ||= project.nil? ? Tracker.sorted.all : project.rolled_up_trackers
               end
               # Returns a hash of localized labels for all filter operators
               def self.operators_labels
                 operators.inject({}) {|h, operator| h[operator.first] = l(operator.last); h}
               end
               def available_filters
                 return @available_filters if @available_filters
                 @available_filters = {
                   "status_id" => {
                     :type => :list_status, :order => 0,
                     :values => IssueStatus.sorted.all.collect{|s| [s.name, s.id.to_s] }
                    },
                   "tracker_id" => {
                     :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] }
                    },
                   "priority_id" => {
                     :type => :list, :order => 3, :values => IssuePriority.all.collect{|s| [s.name, s.id.to_s] }
                    },
                   "subject" => { :type => :text, :order => 8 },
                   "created_on" => { :type => :date_past, :order => 9 },
                   "updated_on" => { :type => :date_past, :order => 10 },
                   "start_date" => { :type => :date, :order => 11 },
                   "due_date" => { :type => :date, :order => 12 },
                   "estimated_hours" => { :type => :float, :order => 13 },
                   "done_ratio" =>  { :type => :integer, :order => 14 }
                 }
                 IssueRelation::TYPES.each do |relation_type, options|
                   @available_filters[relation_type] = {
                     :type => :relation, :order => @available_filters.size + 100,
                     :label => options[:name]
                   }
                 end
                 principals = []
                 if project
                   principals += project.principals.sort
                   unless project.leaf?
                     subprojects = project.descendants.visible.all
                     if subprojects.any?
                       @available_filters["subproject_id"] = {
                         :type => :list_subprojects, :order => 13,
                         :values => subprojects.collect{|s| [s.name, s.id.to_s] }
                       }
                       principals += Principal.member_of(subprojects)
                     end
                   end
                 else
                   if all_projects.any?
                     # members of visible projects
                     principals += Principal.member_of(all_projects)
                     # project filter
                     project_values = []
                     if User.current.logged? && User.current.memberships.any?
                       project_values << ["<< #{l(:label_my_projects).downcase} >>", "mine"]
                     end
                     project_values += all_projects_values
                     @available_filters["project_id"] = {
                       :type => :list, :order => 1, :values => project_values
                     } unless project_values.empty?
                   end
                 end
                 principals.uniq!
                 principals.sort!
                 users = principals.select {|p| p.is_a?(User)}
                 assigned_to_values = []
                 assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
                 assigned_to_values += (Setting.issue_group_assignment? ?
                                           principals : users).collect{|s| [s.name, s.id.to_s] }
                 @available_filters["assigned_to_id"] = {
                   :type => :list_optional, :order => 4, :values => assigned_to_values
                 } unless assigned_to_values.empty?
                 author_values = []
                 author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
                 author_values += users.collect{|s| [s.name, s.id.to_s] }
                 @available_filters["author_id"] = {
                   :type => :list, :order => 5, :values => author_values
                 } unless author_values.empty?
                 group_values = Group.all.collect {|g| [g.name, g.id.to_s] }
                 @available_filters["member_of_group"] = {
                   :type => :list_optional, :order => 6, :values => group_values
                 } unless group_values.empty?
                 role_values = Role.givable.collect {|r| [r.name, r.id.to_s] }
                 @available_filters["assigned_to_role"] = {
                   :type => :list_optional, :order => 7, :values => role_values
                 } unless role_values.empty?
                 if User.current.logged?
                   @available_filters["watcher_id"] = {
                     :type => :list, :order => 15, :values => [["<< #{l(:label_me)} >>", "me"]]
                   }
                 end
                 if project
                   # project specific filters
                   categories = project.issue_categories.all
                   unless categories.empty?
                     @available_filters["category_id"] = {
                       :type => :list_optional, :order => 6,
                       :values => categories.collect{|s| [s.name, s.id.to_s] }
                     }
                   end
                   versions = project.shared_versions.all
                   unless versions.empty?
                     @available_filters["fixed_version_id"] = {
                       :type => :list_optional, :order => 7,
                       :values => versions.sort.collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s] }
                     }
                   end
                   add_custom_fields_filters(project.all_issue_custom_fields)
                 else
                   # global filters for cross project issue list
                   system_shared_versions = Version.visible.find_all_by_sharing('system')
                   unless system_shared_versions.empty?
                     @available_filters["fixed_version_id"] = {
                       :type => :list_optional, :order => 7,
                       :values => system_shared_versions.sort.collect{|s|
                                                    ["#{s.project.name} - #{s.name}", s.id.to_s]
                                                  }
                     }
                   end
                   add_custom_fields_filters(IssueCustomField.where(:is_filter => true, :is_for_all => true).all)
                 end
                 add_associations_custom_fields_filters :project, :author, :assigned_to, :fixed_version
                 if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
                   User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
                   @available_filters["is_private"] = {
                     :type => :list, :order => 16,
                     :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]]
                   }
                 end
                 Tracker.disabled_core_fields(trackers).each {|field|
                   @available_filters.delete field
                 }
                 @available_filters.each do |field, options|
                   options[:name] ||= l(options[:label] || "field_#{field}".gsub(/_id$/, ''))
                 end
                 @available_filters
               end
               # Returns a representation of the available filters for JSON serialization
               def available_filters_as_json
                 json = {}
                 available_filters.each do |field, options|
                   json[field] = options.slice(:type, :name, :values).stringify_keys
                 end
                 json
               end
               def all_projects
                 @all_projects ||= Project.visible.all
               end
               def all_projects_values
                 return @all_projects_values if @all_projects_values
                 values = []
                 Project.project_tree(all_projects) do |p, level|
                   prefix = (level > 0 ? ('--' * level + ' ') : '')
                   values << ["#{prefix}#{p.name}", p.id.to_s]
                 end
                 @all_projects_values = values
               end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values.nil? || values.is_a?(Array)
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   # check if operator is allowed for that filter
                   #if @@operators_by_filter_type[filter_options[:type]].include? operator
                   #  allowed_values = values & ([""] + (filter_options[:values] || []).collect {|val| val[1]})
                   #  filters[field] = {:operator => operator, :values => allowed_values } if (allowed_values.first and !allowed_values.first.empty?) or ["o", "c", "!*", "*", "t"].include? operator
                   #end
                   filters[field] = {:operator => operator, :values => (values || [''])}
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression && available_filters.has_key?(field)
                 field_type = available_filters[field][:type]
                 @@operators_by_filter_type[field_type].sort.reverse.detect do |operator|
                   next unless expression =~ /^#{Regexp.escape(operator)}(.*)$/
                   add_filter field, operator, $1.present? ? $1.split('|') : ['']
                 end || add_filter(field, '=', expression.split('|'))
               end
               # Add multiple filters using +add_filter+
               def add_filters(fields, operators, values)
                 if fields.is_a?(Array) && operators.is_a?(Hash) && (values.nil? || values.is_a?(Hash))
                   fields.each do |field|
                     add_filter(field, operators[field], values && values[field])
                   end
                 end
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def type_for(field)
                 available_filters[field][:type] if available_filters.has_key?(field)
               end
               def operator_for(field)
                 has_filter?(field) ? filters[field][:operator] : nil
               end
               def values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def value_for(field, index=0)
                 (values_for(field) || [])[index]
               end
               def label_for(field)
                 label = available_filters[field][:name] if available_filters.has_key?(field)
                 label ||= l("field_#{field.to_s.gsub(/_id$/, '')}", :default => field)
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = ::Query.available_columns.dup
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
                                         IssueCustomField.all
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
                 if User.current.allowed_to?(:view_time_entries, project, :global => true)
                   index = nil
                   @available_columns.each_with_index {|column, i| index = i if column.name == :estimated_hours}
                   index = (index ? index + 1 : -1)
                   # insert the column after estimated_hours or at the end
                   @available_columns.insert index, QueryColumn.new(:spent_hours,
                     :sortable => "(SELECT COALESCE(SUM(hours), 0) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id)",
                     :default_order => 'desc',
                     :caption => :label_spent_time
                   )
                 end
                 if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
                   User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
                   @available_columns << QueryColumn.new(:is_private, :sortable => "#{Issue.table_name}.is_private")
                 end
                 disabled_fields = Tracker.disabled_core_fields(trackers).map {|field| field.sub(/_id$/, '')}
                 @available_columns.reject! {|column|
                   disabled_fields.include?(column.name.to_s)
                 }
                 @available_columns
               end
               def self.available_columns=(v)
                 self.available_columns = (v)
               end
               def self.add_available_column(column)
                 self.available_columns << (column) if column.is_a?(QueryColumn)
               end
               # Returns an array of columns that can be used to group the results
               def groupable_columns
                 available_columns.select {|c| c.groupable}
               end
               # Returns a Hash of columns and the key for sorting
               def sortable_columns
                 {'id' => "#{Issue.table_name}.id"}.merge(available_columns.inject({}) {|h, column|
                                                            h[column.name.to_s] = column.sortable
                                                            h
                                                          })
               end
               def columns
                 # preserve the column_names order
                 (has_default_columns? ? default_columns_names : column_names).collect do |name|
                    available_columns.find { |col| col.name == name }
                 end.compact
               end
               def default_columns_names
                 @default_columns_names ||= begin
                   default_columns = Setting.issue_list_default_columns.map(&:to_sym)
                   project.present? ? default_columns : [:project] | default_columns
                 end
               end
               def column_names=(names)
                 if names
                   names = names.select {|n| n.is_a?(Symbol) || !n.blank? }
                   names = names.collect {|n| n.is_a?(Symbol) ? n : n.to_sym }
                   # Set column_names to nil if default columns
                   if names == default_columns_names
                     names = nil
                   end
                 end
                 write_attribute(:column_names, names)
               end
               def has_column?(column)
                 column_names && column_names.include?(column.is_a?(QueryColumn) ? column.name : column)
               end
               def has_default_columns?
                 column_names.nil? || column_names.empty?
               end
               def sort_criteria=(arg)
                 c = []
                 if arg.is_a?(Hash)
                   arg = arg.keys.sort.collect {|k| arg[k]}
                 end
                 c = arg.select {|k,o| !k.to_s.blank?}.slice(0,3).collect {|k,o| [k.to_s, (o == 'desc' || o == false) ? 'desc' : 'asc']}
                 write_attribute(:sort_criteria, c)
               end
               def sort_criteria
                 read_attribute(:sort_criteria) || []
               end
               def sort_criteria_key(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].first
               end
               def sort_criteria_order(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].last
               end
               def sort_criteria_order_for(key)
                 sort_criteria.detect {|k, order| key.to_s == k}.try(:last)
               end
               # Returns the SQL sort order that should be prepended for grouping
               def group_by_sort_order
                 if grouped? && (column = group_by_column)
                   order = sort_criteria_order_for(column.name) || column.default_order
                   column.sortable.is_a?(Array) ?
                     column.sortable.collect {|s| "#{s} #{order}"}.join(',') :
                     "#{column.sortable} #{order}"
                 end
               end
               # Returns true if the query is a grouped query
               def grouped?
                 !group_by_column.nil?
               end
               def group_by_column
                 groupable_columns.detect {|c| c.groupable && c.name.to_s == group_by}
               end
               def group_by_statement
                 group_by_column.try(:groupable)
               end
               def project_statement
                 project_clauses = []
                 if project && !project.descendants.active.empty?
                   ids = [project.id]
                   if has_filter?("subproject_id")
                     case operator_for("subproject_id")
                     when '='
                       # include the selected subprojects
                       ids += values_for("subproject_id").each(&:to_i)
                     when '!*'
                       # main project only
                     else
                       # all subprojects
                       ids += project.descendants.collect(&:id)
                     end
                   elsif Setting.display_subprojects_issues?
                     ids += project.descendants.collect(&:id)
                   end
                   project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')
                 elsif project
                   project_clauses << "#{Project.table_name}.id = %d" % project.id
                 end
                 project_clauses.any? ? project_clauses.join(' AND ') : nil
               end
               def statement
                 # filters clauses
                 filters_clauses = []
                 filters.each_key do |field|
                   next if field == "subproject_id"
                   v = values_for(field).clone
                   next unless v and !v.empty?
                   operator = operator_for(field)
                   # "me" value subsitution
                   if %w(assigned_to_id author_id watcher_id).include?(field)
                     if v.delete("me")
                       if User.current.logged?
                         v.push(User.current.id.to_s)
                         v += User.current.group_ids.map(&:to_s) if field == 'assigned_to_id'
                       else
                         v.push("0")
                       end
                     end
                   end
                   if field == 'project_id'
                     if v.delete('mine')
                       v += User.current.memberships.map(&:project_id).map(&:to_s)
                     end
                   end
                   if field =~ /cf_(\d+)$/
                     # custom field
                     filters_clauses << sql_for_custom_field(field, operator, v, $1)
                   elsif respond_to?("sql_for_#{field}_field")
                     # specific statement
                     filters_clauses << send("sql_for_#{field}_field", field, operator, v)
                   else
                     # regular field
                     filters_clauses << '(' + sql_for_field(field, operator, v, Issue.table_name, field) + ')'
                   end
                 end if filters and valid?
                 filters_clauses << project_statement
                 filters_clauses.reject!(&:blank?)
                 filters_clauses.any? ? filters_clauses.join(' AND ') : nil
               end
               # Returns the issue count
               def issue_count
                 Issue.visible.count(:include => [:status, :project], :conditions => statement)
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issue count by group or nil if query is not grouped
               def issue_count_by_group
                 r = nil
                 if grouped?
                   begin
                     # Rails3 will raise an (unexpected) RecordNotFound if there's only a nil group value
                     r = Issue.visible.count(:group => group_by_statement, :include => [:status, :project], :conditions => statement)
                   rescue ActiveRecord::RecordNotFound
                     r = {nil => issue_count}
                   end
                   c = group_by_column
                   if c.is_a?(QueryCustomFieldColumn)
                     r = r.keys.inject({}) {|h, k| h[c.custom_field.cast_value(k)] = r[k]; h}
                   end
                 end
                 r
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issues
               # Valid options are :order, :offset, :limit, :include, :conditions
               def issues(options={})
                 order_option = [group_by_sort_order, options[:order]].reject {|s| s.blank?}.join(',')
                 order_option = nil if order_option.blank?
-                issues = Issue.visible.scoped(:conditions => options[:conditions]).find :all, :include => ([:status, :project] + (options[:include] || [])).uniq,
+                issues = Issue.visible.where(options[:conditions]).all(
+                  :include => ([:status, :project] + (options[:include] || [])).uniq,
                   :conditions => statement,
                   :order => order_option,
                   :joins => joins_for_order_statement(order_option),
                   :limit  => options[:limit],
                   :offset => options[:offset]
+                )
                 if has_column?(:spent_hours)
                   Issue.load_visible_spent_hours(issues)
                 end
                 if has_column?(:relations)
                   Issue.load_visible_relations(issues)
                 end
                 issues
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issues ids
               def issue_ids(options={})
                 order_option = [group_by_sort_order, options[:order]].reject {|s| s.blank?}.join(',')
                 order_option = nil if order_option.blank?
                 Issue.visible.scoped(:conditions => options[:conditions]).scoped(:include => ([:status, :project] + (options[:include] || [])).uniq,
                                  :conditions => statement,
                                  :order => order_option,
                                  :joins => joins_for_order_statement(order_option),
                                  :limit  => options[:limit],
                                  :offset => options[:offset]).find_ids
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the journals
               # Valid options are :order, :offset, :limit
               def journals(options={})
-                Journal.visible.find :all, :include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
+                Journal.visible.all(
+                  :include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
                   :conditions => statement,
                   :order => options[:order],
                   :limit => options[:limit],
                   :offset => options[:offset]
+                )
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the versions
               # Valid options are :conditions
               def versions(options={})
-                Version.visible.scoped(:conditions => options[:conditions]).find :all, :include => :project, :conditions => project_statement
+                Version.visible.where(options[:conditions]).all(
+                  :include => :project,
+                  :conditions => project_statement
+                )
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               def sql_for_watcher_id_field(field, operator, value)
                 db_table = Watcher.table_name
                 "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND " +
                   sql_for_field(field, '=', value, db_table, 'user_id') + ')'
               end
               def sql_for_member_of_group_field(field, operator, value)
                 if operator == '*' # Any group
                   groups = Group.all
                   operator = '=' # Override the operator since we want to find by assigned_to
                 elsif operator == "!*"
                   groups = Group.all
                   operator = '!' # Override the operator since we want to find by assigned_to
                 else
                   groups = Group.find_all_by_id(value)
                 end
                 groups ||= []
                 members_of_groups = groups.inject([]) {|user_ids, group|
                   if group && group.user_ids.present?
                     user_ids << group.user_ids
                   end
                   user_ids.flatten.uniq.compact
                 }.sort.collect(&:to_s)
                 '(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'
               end
               def sql_for_assigned_to_role_field(field, operator, value)
                 case operator
                 when "*", "!*" # Member / Not member
                   sw = operator == "!*" ? 'NOT' : ''
                   nl = operator == "!*" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id))"
                 when "=", "!"
                   role_cond = value.any? ?
                     "#{MemberRole.table_name}.role_id IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")" :
                     "1=0"
                   sw = operator == "!" ? 'NOT' : ''
                   nl = operator == "!" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}, #{MemberRole.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id AND #{Member.table_name}.id = #{MemberRole.table_name}.member_id AND #{role_cond}))"
                 end
               end
               def sql_for_is_private_field(field, operator, value)
                 op = (operator == "=" ? 'IN' : 'NOT IN')
                 va = value.map {|v| v == '0' ? connection.quoted_false : connection.quoted_true}.uniq.join(',')
                 "#{Issue.table_name}.is_private #{op} (#{va})"
               end
               def sql_for_relations(field, operator, value, options={})
                 relation_options = IssueRelation::TYPES[field]
                 return relation_options unless relation_options
                 relation_type = field
                 join_column, target_join_column = "issue_from_id", "issue_to_id"
                 if relation_options[:reverse] || options[:reverse]
                   relation_type = relation_options[:reverse] || relation_type
                   join_column, target_join_column = target_join_column, join_column
                 end
                 sql = case operator
                   when "*", "!*"
                     op = (operator == "*" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}')"
                   when "=", "!"
                     op = (operator == "=" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = #{value.first.to_i})"
                   when "=p", "=!p", "!p"
                     op = (operator == "!p" ? 'NOT IN' : 'IN')
                     comp = (operator == "=!p" ? '<>' : '=')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name}, #{Issue.table_name} relissues WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = relissues.id AND relissues.project_id #{comp} #{value.first.to_i})"
                   end
                 if relation_options[:sym] == field && !options[:reverse]
                   sqls = [sql, sql_for_relations(field, operator, value, :reverse => true)]
                   sqls.join(["!", "!*", "!p"].include?(operator) ? " AND " : " OR ")
                 else
                   sql
                 end
               end
               IssueRelation::TYPES.keys.each do |relation_type|
                 alias_method "sql_for_#{relation_type}_field".to_sym, :sql_for_relations
               end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)
                 db_table = CustomValue.table_name
                 db_field = 'value'
                 filter = @available_filters[field]
                 return nil unless filter
                 if filter[:format] == 'user'
                   if value.delete('me')
                     value.push User.current.id.to_s
                   end
                 end
                 not_in = nil
                 if operator == '!'
                   # Makes ! operator work for custom fields with multiple values
                   operator = '='
                   not_in = 'NOT'
                 end
                 customized_key = "id"
                 customized_class = Issue
                 if field =~ /^(.+)\.cf_/
                   assoc = $1
                   customized_key = "#{assoc}_id"
                   customized_class = Issue.reflect_on_association(assoc.to_sym).klass.base_class rescue nil
                   raise "Unknown Issue association #{assoc}" unless customized_class
                 end
                 "#{Issue.table_name}.#{customized_key} #{not_in} IN (SELECT #{customized_class.table_name}.id FROM #{customized_class.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='#{customized_class}' AND #{db_table}.customized_id=#{customized_class.table_name}.id AND #{db_table}.custom_field_id=#{custom_field_id} WHERE " +
                   sql_for_field(field, operator, value, db_table, db_field, true) + ')'
               end
               # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+
               def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)
                 sql = ''
                 case operator
                 when "="
                   if value.any?
                     case type_for(field)
                     when :date, :date_past
                       sql = date_clause(db_table, db_field, (Date.parse(value.first) rescue nil), (Date.parse(value.first) rescue nil))
                     when :integer
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) = #{value.first.to_i})"
                       else
                         sql = "#{db_table}.#{db_field} = #{value.first.to_i}"
                       end
                     when :float
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5})"
                       else
                         sql = "#{db_table}.#{db_field} BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5}"
                       end
                     else
                       sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                     end
                   else
                     # IN an empty set
                     sql = "1=0"
                   end
                 when "!"
                   if value.any?
                     sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + "))"
                   else
                     # NOT IN an empty set
                     sql = "1=1"
                   end
                 when "!*"
                   sql = "#{db_table}.#{db_field} IS NULL"
                   sql << " OR #{db_table}.#{db_field} = ''" if is_custom_filter
                 when "*"
                   sql = "#{db_table}.#{db_field} IS NOT NULL"
                   sql << " AND #{db_table}.#{db_field} <> ''" if is_custom_filter
                 when ">="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, (Date.parse(value.first) rescue nil), nil)
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) >= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} >= #{value.first.to_f}"
                     end
                   end
                 when "<="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, nil, (Date.parse(value.first) rescue nil))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) <= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} <= #{value.first.to_f}"
                     end
                   end
                 when "><"
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, (Date.parse(value[0]) rescue nil), (Date.parse(value[1]) rescue nil))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) BETWEEN #{value[0].to_f} AND #{value[1].to_f})"
                     else
                       sql = "#{db_table}.#{db_field} BETWEEN #{value[0].to_f} AND #{value[1].to_f}"
                     end
                   end
                 when "o"
                   sql = "#{Issue.table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{connection.quoted_false})" if field == "status_id"
                 when "c"
                   sql = "#{Issue.table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{connection.quoted_true})" if field == "status_id"
                 when "><t-"
                   # between today - n days and today
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, 0)
                 when ">t-"
                   # >= today - n days
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, nil)
                 when "<t-"
                   # <= today - n days
                   sql = relative_date_clause(db_table, db_field, nil, - value.first.to_i)
                 when "t-"
                   # = n days in past
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
                 when "><t+"
                   # between today and today + n days
                   sql = relative_date_clause(db_table, db_field, 0, value.first.to_i)
                 when ">t+"
                   # >= today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, nil)
                 when "<t+"
                   # <= today + n days
                   sql = relative_date_clause(db_table, db_field, nil, value.first.to_i)
                 when "t+"
                   # = today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, value.first.to_i)
                 when "t"
                   # = today
                   sql = relative_date_clause(db_table, db_field, 0, 0)
                 when "w"
                   # = this week
                   first_day_of_week = l(:general_first_day_of_week).to_i
                   day_of_week = Date.today.cwday
                   days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
                   sql = relative_date_clause(db_table, db_field, - days_ago, - days_ago + 6)
                 when "~"
                   sql = "LOWER(#{db_table}.#{db_field}) LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 when "!~"
                   sql = "LOWER(#{db_table}.#{db_field}) NOT LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 else
                   raise "Unknown query operator #{operator}"
                 end
                 return sql
               end
               def add_custom_fields_filters(custom_fields, assoc=nil)
                 return unless custom_fields.present?
                 @available_filters ||= {}
                 custom_fields.select(&:is_filter?).each do |field|
                   case field.field_format
                   when "text"
                     options = { :type => :text, :order => 20 }
                   when "list"
                     options = { :type => :list_optional, :values => field.possible_values, :order => 20}
                   when "date"
                     options = { :type => :date, :order => 20 }
                   when "bool"
                     options = { :type => :list, :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]], :order => 20 }
                   when "int"
                     options = { :type => :integer, :order => 20 }
                   when "float"
                     options = { :type => :float, :order => 20 }
                   when "user", "version"
                     next unless project
                     values = field.possible_values_options(project)
                     if User.current.logged? && field.field_format == 'user'
                       values.unshift ["<< #{l(:label_me)} >>", "me"]
                     end
                     options = { :type => :list_optional, :values => values, :order => 20}
                   else
                     options = { :type => :string, :order => 20 }
                   end
                   filter_id = "cf_#{field.id}"
                   filter_name = field.name
                   if assoc.present?
                     filter_id = "#{assoc}.#{filter_id}"
                     filter_name = l("label_attribute_of_#{assoc}", :name => filter_name)
                   end
                   @available_filters[filter_id] = options.merge({
                            :name => filter_name,
                            :format => field.field_format,
                            :field => field
                          })
                 end
               end
               def add_associations_custom_fields_filters(*associations)
                 fields_by_class = CustomField.where(:is_filter => true).group_by(&:class)
                 associations.each do |assoc|
                   association_klass = Issue.reflect_on_association(assoc).klass
                   fields_by_class.each do |field_class, fields|
                     if field_class.customized_class <= association_klass
                       add_custom_fields_filters(fields, assoc)
                     end
                   end
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_clause(table, field, from, to)
                 s = []
                 if from
                   from_yesterday = from - 1
                   from_yesterday_time = Time.local(from_yesterday.year, from_yesterday.month, from_yesterday.day)
                   if self.class.default_timezone == :utc
                     from_yesterday_time = from_yesterday_time.utc
                   end
                   s << ("#{table}.#{field} > '%s'" % [connection.quoted_date(from_yesterday_time.end_of_day)])
                 end
                 if to
                   to_time = Time.local(to.year, to.month, to.day)
                   if self.class.default_timezone == :utc
                     to_time = to_time.utc
                   end
                   s << ("#{table}.#{field} <= '%s'" % [connection.quoted_date(to_time.end_of_day)])
                 end
                 s.join(' AND ')
               end
               # Returns a SQL clause for a date or datetime field using relative dates.
               def relative_date_clause(table, field, days_from, days_to)
                 date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))
               end
               # Additional joins required for the given sort options
               def joins_for_order_statement(order_options)
                 joins = []
                 if order_options
                   if order_options.include?('authors')
                     joins << "LEFT OUTER JOIN #{User.table_name} authors ON authors.id = #{Issue.table_name}.author_id"
                   end
                   order_options.scan(/cf_\d+/).uniq.each do |name|
                     column = available_columns.detect {|c| c.name.to_s == name}
                     join = column && column.custom_field.join_for_order_statement
                     if join
                       joins << join
                     end
                   end
                 end
                 joins.any? ? joins.join(' ') : nil
               end
             end

lib/plugins/acts_as_versioned/lib/acts_as_versioned.rb +8 -6

             # Copyright (c) 2005 Rick Olson
             #
             # Permission is hereby granted, free of charge, to any person obtaining
             # a copy of this software and associated documentation files (the
             # "Software"), to deal in the Software without restriction, including
             # without limitation the rights to use, copy, modify, merge, publish,
             # distribute, sublicense, and/or sell copies of the Software, and to
             # permit persons to whom the Software is furnished to do so, subject to
             # the following conditions:
             #
             # The above copyright notice and this permission notice shall be
             # included in all copies or substantial portions of the Software.
             #
             # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
             # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
             # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
             # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
             # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
             # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
             # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
             module ActiveRecord #:nodoc:
               module Acts #:nodoc:
                 # Specify this act if you want to save a copy of the row in a versioned table.  This assumes there is a
                 # versioned table ready and that your model has a version field.  This works with optimistic locking if the lock_version
                 # column is present as well.
                 #
                 # The class for the versioned model is derived the first time it is seen. Therefore, if you change your database schema you have to restart
                 # your container for the changes to be reflected. In development mode this usually means restarting WEBrick.
                 #
                 #   class Page < ActiveRecord::Base
                 #     # assumes pages_versions table
                 #     acts_as_versioned
                 #   end
                 #
                 # Example:
                 #
                 #   page = Page.create(:title => 'hello world!')
                 #   page.version       # => 1
                 #
                 #   page.title = 'hello world'
                 #   page.save
                 #   page.version       # => 2
                 #   page.versions.size # => 2
                 #
                 #   page.revert_to(1)  # using version number
                 #   page.title         # => 'hello world!'
                 #
                 #   page.revert_to(page.versions.last) # using versioned instance
                 #   page.title         # => 'hello world'
                 #
                 #   page.versions.earliest # efficient query to find the first version
                 #   page.versions.latest   # efficient query to find the most recently created version
                 #
                 #
                 # Simple Queries to page between versions
                 #
                 #   page.versions.before(version)
                 #   page.versions.after(version)
                 #
                 # Access the previous/next versions from the versioned model itself
                 #
                 #   version = page.versions.latest
                 #   version.previous # go back one version
                 #   version.next     # go forward one version
                 #
                 # See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
                 module Versioned
                   CALLBACKS = [:set_new_version, :save_version_on_create, :save_version?, :clear_altered_attributes]
                   def self.included(base) # :nodoc:
                     base.extend ClassMethods
                   end
                   module ClassMethods
                     # == Configuration options
                     #
                     # * <tt>class_name</tt> - versioned model class name (default: PageVersion in the above example)
                     # * <tt>table_name</tt> - versioned model table name (default: page_versions in the above example)
                     # * <tt>foreign_key</tt> - foreign key used to relate the versioned model to the original model (default: page_id in the above example)
                     # * <tt>inheritance_column</tt> - name of the column to save the model's inheritance_column value for STI.  (default: versioned_type)
                     # * <tt>version_column</tt> - name of the column in the model that keeps the version number (default: version)
                     # * <tt>sequence_name</tt> - name of the custom sequence to be used by the versioned model.
                     # * <tt>limit</tt> - number of revisions to keep, defaults to unlimited
                     # * <tt>if</tt> - symbol of method to check before saving a new version.  If this method returns false, a new version is not saved.
                     #   For finer control, pass either a Proc or modify Model#version_condition_met?
                     #
                     #     acts_as_versioned :if => Proc.new { |auction| !auction.expired? }
                     #
                     #   or...
                     #
                     #     class Auction
                     #       def version_condition_met? # totally bypasses the <tt>:if</tt> option
                     #         !expired?
                     #       end
                     #     end
                     #
                     # * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model.  This takes
                     #   either a symbol or array of symbols.  WARNING - This will attempt to overwrite any attribute setters you may have.
                     #   Use this instead if you want to write your own attribute setters (and ignore if_changed):
                     #
                     #     def name=(new_name)
                     #       write_changed_attribute :name, new_name
                     #     end
                     #
                     # * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models.  You can also just pass a block
                     #   to create an anonymous mixin:
                     #
                     #     class Auction
                     #       acts_as_versioned do
                     #         def started?
                     #           !started_at.nil?
                     #         end
                     #       end
                     #     end
                     #
                     #   or...
                     #
                     #     module AuctionExtension
                     #       def started?
                     #         !started_at.nil?
                     #       end
                     #     end
                     #     class Auction
                     #       acts_as_versioned :extend => AuctionExtension
                     #     end
                     #
                     #  Example code:
                     #
                     #    @auction = Auction.find(1)
                     #    @auction.started?
                     #    @auction.versions.first.started?
                     #
                     # == Database Schema
                     #
                     # The model that you're versioning needs to have a 'version' attribute. The model is versioned
                     # into a table called #{model}_versions where the model name is singlular. The _versions table should
                     # contain all the fields you want versioned, the same version column, and a #{model}_id foreign key field.
                     #
                     # A lock_version field is also accepted if your model uses Optimistic Locking.  If your table uses Single Table inheritance,
                     # then that field is reflected in the versioned model as 'versioned_type' by default.
                     #
                     # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table
                     # method, perfect for a migration.  It will also create the version column if the main model does not already have it.
                     #
                     #   class AddVersions < ActiveRecord::Migration
                     #     def self.up
                     #       # create_versioned_table takes the same options hash
                     #       # that create_table does
                     #       Post.create_versioned_table
                     #     end
                     #
                     #     def self.down
                     #       Post.drop_versioned_table
                     #     end
                     #   end
                     #
                     # == Changing What Fields Are Versioned
                     #
                     # By default, acts_as_versioned will version all but these fields:
                     #
                     #   [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
                     #
                     # You can add or change those by modifying #non_versioned_columns.  Note that this takes strings and not symbols.
                     #
                     #   class Post < ActiveRecord::Base
                     #     acts_as_versioned
                     #     self.non_versioned_columns << 'comments_count'
                     #   end
                     #
                     def acts_as_versioned(options = {}, &extension)
                       # don't allow multiple calls
                       return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
                       send :include, ActiveRecord::Acts::Versioned::ActMethods
                       cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column,
                         :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
                         :version_association_options
                       # legacy
                       alias_method :non_versioned_fields,  :non_versioned_columns
                       alias_method :non_versioned_fields=, :non_versioned_columns=
                       class << self
                         alias_method :non_versioned_fields,  :non_versioned_columns
                         alias_method :non_versioned_fields=, :non_versioned_columns=
                       end
                       send :attr_accessor, :altered_attributes
                       self.versioned_class_name         = options[:class_name]  || "Version"
                       self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
                       self.versioned_table_name         = options[:table_name]  || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_versions#{table_name_suffix}"
                       self.versioned_inheritance_column = options[:inheritance_column] || "versioned_#{inheritance_column}"
                       self.version_column               = options[:version_column]     || 'version'
                       self.version_sequence_name        = options[:sequence_name]
                       self.max_version_limit            = options[:limit].to_i
                       self.version_condition            = options[:if] || true
                       self.non_versioned_columns        = [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
                       self.version_association_options  = {
                                                             :class_name  => "#{self.to_s}::#{versioned_class_name}",
                                                             :foreign_key => versioned_foreign_key,
                                                             :dependent   => :delete_all
                                                           }.merge(options[:association_options] || {})
                       if block_given?
                         extension_module_name = "#{versioned_class_name}Extension"
                         silence_warnings do
                           self.const_set(extension_module_name, Module.new(&extension))
                         end
                         options[:extend] = self.const_get(extension_module_name)
                       end
                       class_eval do
                         has_many :versions, version_association_options do
                           # finds earliest version of this record
                           def earliest
                             @earliest ||= order('version').first
                           end
                           # find latest version of this record
                           def latest
                             @latest ||= order('version desc').first
                           end
                         end
                         before_save  :set_new_version
                         after_create :save_version_on_create
                         after_update :save_version
                         after_save   :clear_old_versions
                         after_save   :clear_altered_attributes
                         unless options[:if_changed].nil?
                           self.track_altered_attributes = true
                           options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
                           options[:if_changed].each do |attr_name|
                             define_method("#{attr_name}=") do |value|
                               write_changed_attribute attr_name, value
                             end
                           end
                         end
                         include options[:extend] if options[:extend].is_a?(Module)
                       end
                       # create the dynamic versioned model
                       const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
                         def self.reloadable? ; false ; end
                         # find first version before the given version
                         def self.before(version)
-                          find :first, :order => 'version desc',
+                          order('version desc').
-                            :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
+                            where("#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version).
+                            first
                         end
                         # find first version after the given version.
                         def self.after(version)
-                          find :first, :order => 'version',
+                          order('version').
-                            :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
+                            where("#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version).
+                            first
                         end
                         def previous
                           self.class.before(self)
                         end
                         def next
                           self.class.after(self)
                         end
                         def versions_count
                           page.version
                         end
                       end
                       versioned_class.cattr_accessor :original_class
                       versioned_class.original_class = self
                       versioned_class.table_name = versioned_table_name
                       versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym,
                         :class_name  => "::#{self.to_s}",
                         :foreign_key => versioned_foreign_key
                       versioned_class.send :include, options[:extend]         if options[:extend].is_a?(Module)
                       versioned_class.set_sequence_name version_sequence_name if version_sequence_name
                     end
                   end
                   module ActMethods
                     def self.included(base) # :nodoc:
                       base.extend ClassMethods
                     end
                     # Finds a specific version of this record
                     def find_version(version = nil)
                       self.class.find_version(id, version)
                     end
                     # Saves a version of the model if applicable
                     def save_version
                       save_version_on_create if save_version?
                     end
                     # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
                     def save_version_on_create
                       rev = self.class.versioned_class.new
                       self.clone_versioned_model(self, rev)
                       rev.version = send(self.class.version_column)
                       rev.send("#{self.class.versioned_foreign_key}=", self.id)
                       rev.save
                     end
                     # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
                     # Override this method to set your own criteria for clearing old versions.
                     def clear_old_versions
                       return if self.class.max_version_limit == 0
                       excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
                       if excess_baggage > 0
                         sql = "DELETE FROM #{self.class.versioned_table_name} WHERE version <= #{excess_baggage} AND #{self.class.versioned_foreign_key} = #{self.id}"
                         self.class.versioned_class.connection.execute sql
                       end
                     end
                     def versions_count
                       version
                     end
                     # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
                     def revert_to(version)
                       if version.is_a?(self.class.versioned_class)
                         return false unless version.send(self.class.versioned_foreign_key) == self.id and !version.new_record?
                       else
                         return false unless version = versions.find_by_version(version)
                       end
                       self.clone_versioned_model(version, self)
                       self.send("#{self.class.version_column}=", version.version)
                       true
                     end
                     # Reverts a model to a given version and saves the model.
                     # Takes either a version number or an instance of the versioned model
                     def revert_to!(version)
                       revert_to(version) ? save_without_revision : false
                     end
                     # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
                     def save_without_revision
                       save_without_revision!
                       true
                     rescue
                       false
                     end
                     def save_without_revision!
                       without_locking do
                         without_revision do
                           save!
                         end
                       end
                     end
                     # Returns an array of attribute keys that are versioned.  See non_versioned_columns
                     def versioned_attributes
                       self.attributes.keys.select { |k| !self.class.non_versioned_columns.include?(k) }
                     end
                     # If called with no parameters, gets whether the current model has changed and needs to be versioned.
                     # If called with a single parameter, gets whether the parameter has changed.
                     def changed?(attr_name = nil)
                       attr_name.nil? ?
                         (!self.class.track_altered_attributes || (altered_attributes && altered_attributes.length > 0)) :
                         (altered_attributes && altered_attributes.include?(attr_name.to_s))
                     end
                     # keep old dirty? method
                     alias_method :dirty?, :changed?
                     # Clones a model.  Used when saving a new version or reverting a model's version.
                     def clone_versioned_model(orig_model, new_model)
                       self.versioned_attributes.each do |key|
                         new_model.send("#{key}=", orig_model.send(key)) if orig_model.respond_to?(key)
                       end
             					if self.class.columns_hash.include?(self.class.inheritance_column)
                         if orig_model.is_a?(self.class.versioned_class)
                           new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
                         elsif new_model.is_a?(self.class.versioned_class)
                           new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
                         end
                       end
                     end
                     # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
                     def save_version?
                       version_condition_met? && changed?
                     end
                     # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
                     # custom version condition checking.
                     def version_condition_met?
                       case
                       when version_condition.is_a?(Symbol)
                         send(version_condition)
                       when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
                         version_condition.call(self)
                       else
                         version_condition
                       end
                     end
                     # Executes the block with the versioning callbacks disabled.
                     #
                     #   @foo.without_revision do
                     #     @foo.save
                     #   end
                     #
                     def without_revision(&block)
                       self.class.without_revision(&block)
                     end
                     # Turns off optimistic locking for the duration of the block
                     #
                     #   @foo.without_locking do
                     #     @foo.save
                     #   end
                     #
                     def without_locking(&block)
                       self.class.without_locking(&block)
                     end
                     def empty_callback() end #:nodoc:
                     protected
                       # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
                       def set_new_version
                         self.send("#{self.class.version_column}=", self.next_version) if new_record? || (!locking_enabled? && save_version?)
                       end
                       # Gets the next available version for the current record, or 1 for a new record
                       def next_version
                         return 1 if new_record?
                         (versions.calculate(:max, :version) || 0) + 1
                       end
                       # clears current changed attributes.  Called after save.
                       def clear_altered_attributes
                         self.altered_attributes = []
                       end
                       def write_changed_attribute(attr_name, attr_value)
                         # Convert to db type for comparison. Avoids failing Float<=>String comparisons.
                         attr_value_for_db = self.class.columns_hash[attr_name.to_s].type_cast(attr_value)
                         (self.altered_attributes ||= []) << attr_name.to_s unless self.changed?(attr_name) || self.send(attr_name) == attr_value_for_db
                         write_attribute(attr_name, attr_value_for_db)
                       end
                     module ClassMethods
                       # Finds a specific version of a specific row of this model
                       def find_version(id, version = nil)
                         return find(id) unless version
                         conditions = ["#{versioned_foreign_key} = ? AND version = ?", id, version]
                         options = { :conditions => conditions, :limit => 1 }
                         if result = find_versions(id, options).first
                           result
                         else
                           raise RecordNotFound, "Couldn't find #{name} with ID=#{id} and VERSION=#{version}"
                         end
                       end
                       # Finds versions of a specific model.  Takes an options hash like <tt>find</tt>
                       def find_versions(id, options = {})
-                        versioned_class.find :all, {
+                        versioned_class.all({
                           :conditions => ["#{versioned_foreign_key} = ?", id],
-                          :order      => 'version' }.merge(options)
+                          :order      => 'version' }.merge(options))
                       end
                       # Returns an array of columns that are versioned.  See non_versioned_columns
                       def versioned_columns
                         self.columns.select { |c| !non_versioned_columns.include?(c.name) }
                       end
                       # Returns an instance of the dynamic versioned model
                       def versioned_class
                         const_get versioned_class_name
                       end
                       # Rake migration task to create the versioned table using options passed to acts_as_versioned
                       def create_versioned_table(create_table_options = {})
                         # create version column in main table if it does not exist
                         if !self.content_columns.find { |c| %w(version lock_version).include? c.name }
                           self.connection.add_column table_name, :version, :integer
                         end
                         self.connection.create_table(versioned_table_name, create_table_options) do |t|
                           t.column versioned_foreign_key, :integer
                           t.column :version, :integer
                         end
                         updated_col = nil
                         self.versioned_columns.each do |col|
                           updated_col = col if !updated_col && %(updated_at updated_on).include?(col.name)
                           self.connection.add_column versioned_table_name, col.name, col.type,
                             :limit => col.limit,
                             :default => col.default,
                             :scale => col.scale,
                             :precision => col.precision
                         end
                         if type_col = self.columns_hash[inheritance_column]
                           self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type,
                             :limit => type_col.limit,
                             :default => type_col.default,
                             :scale => type_col.scale,
                             :precision => type_col.precision
                         end
                         if updated_col.nil?
                           self.connection.add_column versioned_table_name, :updated_at, :timestamp
                         end
                       end
                       # Rake migration task to drop the versioned table
                       def drop_versioned_table
                         self.connection.drop_table versioned_table_name
                       end
                       # Executes the block with the versioning callbacks disabled.
                       #
                       #   Foo.without_revision do
                       #     @foo.save
                       #   end
                       #
                       def without_revision(&block)
                         class_eval do
                           CALLBACKS.each do |attr_name|
                             alias_method "orig_#{attr_name}".to_sym, attr_name
                             alias_method attr_name, :empty_callback
                           end
                         end
                         block.call
                       ensure
                         class_eval do
                           CALLBACKS.each do |attr_name|
                             alias_method attr_name, "orig_#{attr_name}".to_sym
                           end
                         end
                       end
                       # Turns off optimistic locking for the duration of the block
                       #
                       #   Foo.without_locking do
                       #     @foo.save
                       #   end
                       #
                       def without_locking(&block)
                         current = ActiveRecord::Base.lock_optimistically
                         ActiveRecord::Base.lock_optimistically = false if current
                         result = block.call
                         ActiveRecord::Base.lock_optimistically = true if current
                         result
                       end
                     end
                   end
                 end
               end
             end
             ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned

lib/tasks/migrate_from_mantis.rake +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.
             desc 'Mantis migration script'
             require 'active_record'
             require 'iconv'
             require 'pp'
             namespace :redmine do
             task :migrate_from_mantis => :environment do
               module MantisMigrate
                   DEFAULT_STATUS = IssueStatus.default
                   assigned_status = IssueStatus.find_by_position(2)
                   resolved_status = IssueStatus.find_by_position(3)
                   feedback_status = IssueStatus.find_by_position(4)
-                  closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
+                  closed_status = IssueStatus.where(:is_closed => true).first
                   STATUS_MAPPING = {10 => DEFAULT_STATUS,  # new
 => feedback_status, # feedback
 => DEFAULT_STATUS,  # acknowledged
 => DEFAULT_STATUS,  # confirmed
 => assigned_status, # assigned
 => resolved_status, # resolved
 => closed_status    # closed
                                     }
                   priorities = IssuePriority.all
                   DEFAULT_PRIORITY = priorities[2]
                   PRIORITY_MAPPING = {10 => priorities[1], # none
 => priorities[1], # low
 => priorities[2], # normal
 => priorities[3], # high
 => priorities[4], # urgent
 => priorities[5]  # immediate
                                       }
                   TRACKER_BUG = Tracker.find_by_position(1)
                   TRACKER_FEATURE = Tracker.find_by_position(2)
                   roles = Role.where(:builtin => 0).order('position ASC').all
                   manager_role = roles[0]
                   developer_role = roles[1]
                   DEFAULT_ROLE = roles.last
                   ROLE_MAPPING = {10 => DEFAULT_ROLE,   # viewer
 => DEFAULT_ROLE,   # reporter
 => DEFAULT_ROLE,   # updater
 => developer_role, # developer
 => manager_role,   # manager
 => manager_role    # administrator
                                   }
                   CUSTOM_FIELD_TYPE_MAPPING = {0 => 'string', # String
 => 'int',    # Numeric
 => 'int',    # Float
 => 'list',   # Enumeration
 => 'string', # Email
 => 'bool',   # Checkbox
 => 'list',   # List
 => 'list',   # Multiselection list
 => 'date',   # Date
                                                }
                   RELATION_TYPE_MAPPING = {1 => IssueRelation::TYPE_RELATES,    # related to
 => IssueRelation::TYPE_RELATES,    # parent of
 => IssueRelation::TYPE_RELATES,    # child of
 => IssueRelation::TYPE_DUPLICATES, # duplicate of
 => IssueRelation::TYPE_DUPLICATES  # has duplicate
                                            }
                 class MantisUser < ActiveRecord::Base
                   self.table_name = :mantis_user_table
                   def firstname
                     @firstname = realname.blank? ? username : realname.split.first[0..29]
                     @firstname
                   end
                   def lastname
                     @lastname = realname.blank? ? '-' : realname.split[1..-1].join(' ')[0..29]
                     @lastname = '-' if @lastname.blank?
                     @lastname
                   end
                   def email
                     if read_attribute(:email).match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) &&
                          !User.find_by_mail(read_attribute(:email))
                       @email = read_attribute(:email)
                     else
                       @email = "#{username}@foo.bar"
                     end
                   end
                   def username
                     read_attribute(:username)[0..29].gsub(/[^a-zA-Z0-9_\-@\.]/, '-')
                   end
                 end
                 class MantisProject < ActiveRecord::Base
                   self.table_name = :mantis_project_table
                   has_many :versions, :class_name => "MantisVersion", :foreign_key => :project_id
                   has_many :categories, :class_name => "MantisCategory", :foreign_key => :project_id
                   has_many :news, :class_name => "MantisNews", :foreign_key => :project_id
                   has_many :members, :class_name => "MantisProjectUser", :foreign_key => :project_id
                   def identifier
                     read_attribute(:name).gsub(/[^a-z0-9\-]+/, '-').slice(0, Project::IDENTIFIER_MAX_LENGTH)
                   end
                 end
                 class MantisVersion < ActiveRecord::Base
                   self.table_name = :mantis_project_version_table
                   def version
                     read_attribute(:version)[0..29]
                   end
                   def description
                     read_attribute(:description)[0..254]
                   end
                 end
                 class MantisCategory < ActiveRecord::Base
                   self.table_name = :mantis_project_category_table
                 end
                 class MantisProjectUser < ActiveRecord::Base
                   self.table_name = :mantis_project_user_list_table
                 end
                 class MantisBug < ActiveRecord::Base
                   self.table_name = :mantis_bug_table
                   belongs_to :bug_text, :class_name => "MantisBugText", :foreign_key => :bug_text_id
                   has_many :bug_notes, :class_name => "MantisBugNote", :foreign_key => :bug_id
                   has_many :bug_files, :class_name => "MantisBugFile", :foreign_key => :bug_id
                   has_many :bug_monitors, :class_name => "MantisBugMonitor", :foreign_key => :bug_id
                 end
                 class MantisBugText < ActiveRecord::Base
                   self.table_name = :mantis_bug_text_table
                   # Adds Mantis steps_to_reproduce and additional_information fields
                   # to description if any
                   def full_description
                     full_description = description
                     full_description += "\n\n*Steps to reproduce:*\n\n#{steps_to_reproduce}" unless steps_to_reproduce.blank?
                     full_description += "\n\n*Additional information:*\n\n#{additional_information}" unless additional_information.blank?
                     full_description
                   end
                 end
                 class MantisBugNote < ActiveRecord::Base
                   self.table_name = :mantis_bugnote_table
                   belongs_to :bug, :class_name => "MantisBug", :foreign_key => :bug_id
                   belongs_to :bug_note_text, :class_name => "MantisBugNoteText", :foreign_key => :bugnote_text_id
                 end
                 class MantisBugNoteText < ActiveRecord::Base
                   self.table_name = :mantis_bugnote_text_table
                 end
                 class MantisBugFile < ActiveRecord::Base
                   self.table_name = :mantis_bug_file_table
                   def size
                     filesize
                   end
                   def original_filename
                     MantisMigrate.encode(filename)
                   end
                   def content_type
                     file_type
                   end
                   def read(*args)
                       if @read_finished
                           nil
                       else
                           @read_finished = true
                           content
                       end
                   end
                 end
                 class MantisBugRelationship < ActiveRecord::Base
                   self.table_name = :mantis_bug_relationship_table
                 end
                 class MantisBugMonitor < ActiveRecord::Base
                   self.table_name = :mantis_bug_monitor_table
                 end
                 class MantisNews < ActiveRecord::Base
                   self.table_name = :mantis_news_table
                 end
                 class MantisCustomField < ActiveRecord::Base
                   self.table_name = :mantis_custom_field_table
                   set_inheritance_column :none
                   has_many :values, :class_name => "MantisCustomFieldString", :foreign_key => :field_id
                   has_many :projects, :class_name => "MantisCustomFieldProject", :foreign_key => :field_id
                   def format
                     read_attribute :type
                   end
                   def name
                     read_attribute(:name)[0..29]
                   end
                 end
                 class MantisCustomFieldProject < ActiveRecord::Base
                   self.table_name = :mantis_custom_field_project_table
                 end
                 class MantisCustomFieldString < ActiveRecord::Base
                   self.table_name = :mantis_custom_field_string_table
                 end
                 def self.migrate
                   # Users
                   print "Migrating users"
                   User.delete_all "login <> 'admin'"
                   users_map = {}
                   users_migrated = 0
                   MantisUser.all.each do |user|
                     u = User.new :firstname => encode(user.firstname),
                                  :lastname => encode(user.lastname),
                                  :mail => user.email,
                                  :last_login_on => user.last_visit
                     u.login = user.username
                     u.password = 'mantis'
                     u.status = User::STATUS_LOCKED if user.enabled != 1
                     u.admin = true if user.access_level == 90
                     next unless u.save!
                     users_migrated += 1
                     users_map[user.id] = u.id
                     print '.'
                   end
                   puts
                   # Projects
                   print "Migrating projects"
                   Project.destroy_all
                   projects_map = {}
                   versions_map = {}
                   categories_map = {}
                   MantisProject.all.each do |project|
                     p = Project.new :name => encode(project.name),
                                     :description => encode(project.description)
                     p.identifier = project.identifier
                     next unless p.save
                     projects_map[project.id] = p.id
                     p.enabled_module_names = ['issue_tracking', 'news', 'wiki']
                     p.trackers << TRACKER_BUG unless p.trackers.include?(TRACKER_BUG)
                     p.trackers << TRACKER_FEATURE unless p.trackers.include?(TRACKER_FEATURE)
                     print '.'
                     # Project members
                     project.members.each do |member|
                       m = Member.new :user => User.find_by_id(users_map[member.user_id]),
                                        :roles => [ROLE_MAPPING[member.access_level] || DEFAULT_ROLE]
                       m.project = p
                       m.save
                     end
                     # Project versions
                     project.versions.each do |version|
                       v = Version.new :name => encode(version.version),
                                       :description => encode(version.description),
                                       :effective_date => (version.date_order ? version.date_order.to_date : nil)
                       v.project = p
                       v.save
                       versions_map[version.id] = v.id
                     end
                     # Project categories
                     project.categories.each do |category|
                       g = IssueCategory.new :name => category.category[0,30]
                       g.project = p
                       g.save
                       categories_map[category.category] = g.id
                     end
                   end
                   puts
                   # Bugs
                   print "Migrating bugs"
                   Issue.destroy_all
                   issues_map = {}
                   keep_bug_ids = (Issue.count == 0)
                   MantisBug.find_each(:batch_size => 200) do |bug|
                     next unless projects_map[bug.project_id] && users_map[bug.reporter_id]
                     i = Issue.new :project_id => projects_map[bug.project_id],
                                   :subject => encode(bug.summary),
                                   :description => encode(bug.bug_text.full_description),
                                   :priority => PRIORITY_MAPPING[bug.priority] || DEFAULT_PRIORITY,
                                   :created_on => bug.date_submitted,
                                   :updated_on => bug.last_updated
                     i.author = User.find_by_id(users_map[bug.reporter_id])
                     i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category[0,30]) unless bug.category.blank?
                     i.fixed_version = Version.find_by_project_id_and_name(i.project_id, bug.fixed_in_version) unless bug.fixed_in_version.blank?
                     i.status = STATUS_MAPPING[bug.status] || DEFAULT_STATUS
                     i.tracker = (bug.severity == 10 ? TRACKER_FEATURE : TRACKER_BUG)
                     i.id = bug.id if keep_bug_ids
                     next unless i.save
                     issues_map[bug.id] = i.id
                     print '.'
                     STDOUT.flush
                     # Assignee
                     # Redmine checks that the assignee is a project member
                     if (bug.handler_id && users_map[bug.handler_id])
                       i.assigned_to = User.find_by_id(users_map[bug.handler_id])
                       i.save(:validate => false)
                     end
                     # Bug notes
                     bug.bug_notes.each do |note|
                       next unless users_map[note.reporter_id]
                       n = Journal.new :notes => encode(note.bug_note_text.note),
                                       :created_on => note.date_submitted
                       n.user = User.find_by_id(users_map[note.reporter_id])
                       n.journalized = i
                       n.save
                     end
                     # Bug files
                     bug.bug_files.each do |file|
                       a = Attachment.new :created_on => file.date_added
                       a.file = file
-                      a.author = User.find :first
+                      a.author = User.first
                       a.container = i
                       a.save
                     end
                     # Bug monitors
                     bug.bug_monitors.each do |monitor|
                       next unless users_map[monitor.user_id]
                       i.add_watcher(User.find_by_id(users_map[monitor.user_id]))
                     end
                   end
                   # update issue id sequence if needed (postgresql)
                   Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')
                   puts
                   # Bug relationships
                   print "Migrating bug relations"
                   MantisBugRelationship.all.each do |relation|
                     next unless issues_map[relation.source_bug_id] && issues_map[relation.destination_bug_id]
                     r = IssueRelation.new :relation_type => RELATION_TYPE_MAPPING[relation.relationship_type]
                     r.issue_from = Issue.find_by_id(issues_map[relation.source_bug_id])
                     r.issue_to = Issue.find_by_id(issues_map[relation.destination_bug_id])
                     pp r unless r.save
                     print '.'
                     STDOUT.flush
                   end
                   puts
                   # News
                   print "Migrating news"
                   News.destroy_all
                   MantisNews.where('project_id > 0').all.each do |news|
                     next unless projects_map[news.project_id]
                     n = News.new :project_id => projects_map[news.project_id],
                                  :title => encode(news.headline[0..59]),
                                  :description => encode(news.body),
                                  :created_on => news.date_posted
                     n.author = User.find_by_id(users_map[news.poster_id])
                     n.save
                     print '.'
                     STDOUT.flush
                   end
                   puts
                   # Custom fields
                   print "Migrating custom fields"
                   IssueCustomField.destroy_all
                   MantisCustomField.all.each do |field|
                     f = IssueCustomField.new :name => field.name[0..29],
                                              :field_format => CUSTOM_FIELD_TYPE_MAPPING[field.format],
                                              :min_length => field.length_min,
                                              :max_length => field.length_max,
                                              :regexp => field.valid_regexp,
                                              :possible_values => field.possible_values.split('|'),
                                              :is_required => field.require_report?
                     next unless f.save
                     print '.'
                     STDOUT.flush
                     # Trackers association
                     f.trackers = Tracker.all
                     # Projects association
                     field.projects.each do |project|
                       f.projects << Project.find_by_id(projects_map[project.project_id]) if projects_map[project.project_id]
                     end
                     # Values
                     field.values.each do |value|
                       v = CustomValue.new :custom_field_id => f.id,
                                           :value => value.value
                       v.customized = Issue.find_by_id(issues_map[value.bug_id]) if issues_map[value.bug_id]
                       v.save
                     end unless f.new_record?
                   end
                   puts
                   puts
                   puts "Users:           #{users_migrated}/#{MantisUser.count}"
                   puts "Projects:        #{Project.count}/#{MantisProject.count}"
                   puts "Memberships:     #{Member.count}/#{MantisProjectUser.count}"
                   puts "Versions:        #{Version.count}/#{MantisVersion.count}"
                   puts "Categories:      #{IssueCategory.count}/#{MantisCategory.count}"
                   puts "Bugs:            #{Issue.count}/#{MantisBug.count}"
                   puts "Bug notes:       #{Journal.count}/#{MantisBugNote.count}"
                   puts "Bug files:       #{Attachment.count}/#{MantisBugFile.count}"
                   puts "Bug relations:   #{IssueRelation.count}/#{MantisBugRelationship.count}"
                   puts "Bug monitors:    #{Watcher.count}/#{MantisBugMonitor.count}"
                   puts "News:            #{News.count}/#{MantisNews.count}"
                   puts "Custom fields:   #{IssueCustomField.count}/#{MantisCustomField.count}"
                 end
                 def self.encoding(charset)
                   @ic = Iconv.new('UTF-8', charset)
                 rescue Iconv::InvalidEncoding
                   return false
                 end
                 def self.establish_connection(params)
                   constants.each do |const|
                     klass = const_get(const)
                     next unless klass.respond_to? 'establish_connection'
                     klass.establish_connection params
                   end
                 end
                 def self.encode(text)
                   @ic.iconv text
                 rescue
                   text
                 end
               end
               puts
               if Redmine::DefaultData::Loader.no_data?
                 puts "Redmine configuration need to be loaded before importing data."
                 puts "Please, run this first:"
                 puts
                 puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""
                 exit
               end
               puts "WARNING: Your Redmine data will be deleted during this process."
               print "Are you sure you want to continue ? [y/N] "
               STDOUT.flush
               break unless STDIN.gets.match(/^y$/i)
               # Default Mantis database settings
               db_params = {:adapter => 'mysql2',
                            :database => 'bugtracker',
                            :host => 'localhost',
                            :username => 'root',
                            :password => '' }
               puts
               puts "Please enter settings for your Mantis database"
               [:adapter, :host, :database, :username, :password].each do |param|
                 print "#{param} [#{db_params[param]}]: "
                 value = STDIN.gets.chomp!
                 db_params[param] = value unless value.blank?
               end
               while true
                 print "encoding [UTF-8]: "
                 STDOUT.flush
                 encoding = STDIN.gets.chomp!
                 encoding = 'UTF-8' if encoding.blank?
                 break if MantisMigrate.encoding encoding
                 puts "Invalid encoding!"
               end
               puts
               # Make sure bugs can refer bugs in other projects
               Setting.cross_project_issue_relations = 1 if Setting.respond_to? 'cross_project_issue_relations'
               # Turn off email notifications
               Setting.notified_events = []
               MantisMigrate.establish_connection db_params
               MantisMigrate.migrate
             end
             end

lib/tasks/migrate_from_trac.rake +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 'active_record'
             require 'iconv'
             require 'pp'
             namespace :redmine do
               desc 'Trac migration script'
               task :migrate_from_trac => :environment do
                 module TracMigrate
                     TICKET_MAP = []
                     DEFAULT_STATUS = IssueStatus.default
                     assigned_status = IssueStatus.find_by_position(2)
                     resolved_status = IssueStatus.find_by_position(3)
                     feedback_status = IssueStatus.find_by_position(4)
-                    closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
+                    closed_status = IssueStatus.where(:is_closed => true).first
                     STATUS_MAPPING = {'new' => DEFAULT_STATUS,
                                       'reopened' => feedback_status,
                                       'assigned' => assigned_status,
                                       'closed' => closed_status
                                       }
                     priorities = IssuePriority.all
                     DEFAULT_PRIORITY = priorities[0]
                     PRIORITY_MAPPING = {'lowest' => priorities[0],
                                         'low' => priorities[0],
                                         'normal' => priorities[1],
                                         'high' => priorities[2],
                                         'highest' => priorities[3],
                                         # ---
                                         'trivial' => priorities[0],
                                         'minor' => priorities[1],
                                         'major' => priorities[2],
                                         'critical' => priorities[3],
                                         'blocker' => priorities[4]
                                         }
                     TRACKER_BUG = Tracker.find_by_position(1)
                     TRACKER_FEATURE = Tracker.find_by_position(2)
                     DEFAULT_TRACKER = TRACKER_BUG
                     TRACKER_MAPPING = {'defect' => TRACKER_BUG,
                                        'enhancement' => TRACKER_FEATURE,
                                        'task' => TRACKER_FEATURE,
                                        'patch' =>TRACKER_FEATURE
                                        }
                     roles = Role.where(:builtin => 0).order('position ASC').all
                     manager_role = roles[0]
                     developer_role = roles[1]
                     DEFAULT_ROLE = roles.last
                     ROLE_MAPPING = {'admin' => manager_role,
                                     'developer' => developer_role
                                     }
                   class ::Time
                     class << self
                       alias :real_now :now
                       def now
                         real_now - @fake_diff.to_i
                       end
                       def fake(time)
                         @fake_diff = real_now - time
                         res = yield
                         @fake_diff = 0
                        res
                       end
                     end
                   end
                   class TracComponent < ActiveRecord::Base
                     self.table_name = :component
                   end
                   class TracMilestone < ActiveRecord::Base
                     self.table_name = :milestone
                     # If this attribute is set a milestone has a defined target timepoint
                     def due
                       if read_attribute(:due) && read_attribute(:due) > 0
                         Time.at(read_attribute(:due)).to_date
                       else
                         nil
                       end
                     end
                     # This is the real timepoint at which the milestone has finished.
                     def completed
                       if read_attribute(:completed) && read_attribute(:completed) > 0
                         Time.at(read_attribute(:completed)).to_date
                       else
                         nil
                       end
                     end
                     def description
                       # Attribute is named descr in Trac v0.8.x
                       has_attribute?(:descr) ? read_attribute(:descr) : read_attribute(:description)
                     end
                   end
                   class TracTicketCustom < ActiveRecord::Base
                     self.table_name = :ticket_custom
                   end
                   class TracAttachment < ActiveRecord::Base
                     self.table_name = :attachment
                     set_inheritance_column :none
                     def time; Time.at(read_attribute(:time)) end
                     def original_filename
                       filename
                     end
                     def content_type
                       ''
                     end
                     def exist?
                       File.file? trac_fullpath
                     end
                     def open
                       File.open("#{trac_fullpath}", 'rb') {|f|
                         @file = f
                         yield self
                       }
                     end
                     def read(*args)
                       @file.read(*args)
                     end
                     def description
                       read_attribute(:description).to_s.slice(0,255)
                     end
                   private
                     def trac_fullpath
                       attachment_type = read_attribute(:type)
                       trac_file = filename.gsub( /[^a-zA-Z0-9\-_\.!~*']/n ) {|x| sprintf('%%%02x', x[0]) }
                       "#{TracMigrate.trac_attachments_directory}/#{attachment_type}/#{id}/#{trac_file}"
                     end
                   end
                   class TracTicket < ActiveRecord::Base
                     self.table_name = :ticket
                     set_inheritance_column :none
                     # ticket changes: only migrate status changes and comments
                     has_many :ticket_changes, :class_name => "TracTicketChange", :foreign_key => :ticket
                     has_many :customs, :class_name => "TracTicketCustom", :foreign_key => :ticket
                     def attachments
                       TracMigrate::TracAttachment.all(:conditions => ["type = 'ticket' AND id = ?", self.id.to_s])
                     end
                     def ticket_type
                       read_attribute(:type)
                     end
                     def summary
                       read_attribute(:summary).blank? ? "(no subject)" : read_attribute(:summary)
                     end
                     def description
                       read_attribute(:description).blank? ? summary : read_attribute(:description)
                     end
                     def time; Time.at(read_attribute(:time)) end
                     def changetime; Time.at(read_attribute(:changetime)) end
                   end
                   class TracTicketChange < ActiveRecord::Base
                     self.table_name = :ticket_change
                     def self.columns
                       # Hides Trac field 'field' to prevent clash with AR field_changed? method (Rails 3.0)
                       super.select {|column| column.name.to_s != 'field'}
                     end
                     def time; Time.at(read_attribute(:time)) end
                   end
                   TRAC_WIKI_PAGES = %w(InterMapTxt InterTrac InterWiki RecentChanges SandBox TracAccessibility TracAdmin TracBackup TracBrowser TracCgi TracChangeset \
                                        TracEnvironment TracFastCgi TracGuide TracImport TracIni TracInstall TracInterfaceCustomization \
                                        TracLinks TracLogging TracModPython TracNotification TracPermissions TracPlugins TracQuery \
                                        TracReports TracRevisionLog TracRoadmap TracRss TracSearch TracStandalone TracSupport TracSyntaxColoring TracTickets \
                                        TracTicketsCustomFields TracTimeline TracUnicode TracUpgrade TracWiki WikiDeletePage WikiFormatting \
                                        WikiHtml WikiMacros WikiNewPage WikiPageNames WikiProcessors WikiRestructuredText WikiRestructuredTextLinks \
                                        CamelCase TitleIndex)
                   class TracWikiPage < ActiveRecord::Base
                     self.table_name = :wiki
                     set_primary_key :name
                     def self.columns
                       # Hides readonly Trac field to prevent clash with AR readonly? method (Rails 2.0)
                       super.select {|column| column.name.to_s != 'readonly'}
                     end
                     def attachments
                       TracMigrate::TracAttachment.all(:conditions => ["type = 'wiki' AND id = ?", self.id.to_s])
                     end
                     def time; Time.at(read_attribute(:time)) end
                   end
                   class TracPermission < ActiveRecord::Base
                     self.table_name = :permission
                   end
                   class TracSessionAttribute < ActiveRecord::Base
                     self.table_name = :session_attribute
                   end
                   def self.find_or_create_user(username, project_member = false)
                     return User.anonymous if username.blank?
                     u = User.find_by_login(username)
                     if !u
                       # Create a new user if not found
                       mail = username[0, User::MAIL_LENGTH_LIMIT]
                       if mail_attr = TracSessionAttribute.find_by_sid_and_name(username, 'email')
                         mail = mail_attr.value
                       end
                       mail = "#{mail}@foo.bar" unless mail.include?("@")
                       name = username
                       if name_attr = TracSessionAttribute.find_by_sid_and_name(username, 'name')
                         name = name_attr.value
                       end
                       name =~ (/(.*)(\s+\w+)?/)
                       fn = $1.strip
                       ln = ($2 || '-').strip
                       u = User.new :mail => mail.gsub(/[^-@a-z0-9\.]/i, '-'),
                                    :firstname => fn[0, limit_for(User, 'firstname')],
                                    :lastname => ln[0, limit_for(User, 'lastname')]
                       u.login = username[0, User::LOGIN_LENGTH_LIMIT].gsub(/[^a-z0-9_\-@\.]/i, '-')
                       u.password = 'trac'
                       u.admin = true if TracPermission.find_by_username_and_action(username, 'admin')
                       # finally, a default user is used if the new user is not valid
                       u = User.first unless u.save
                     end
                     # Make sure he is a member of the project
                     if project_member && !u.member_of?(@target_project)
                       role = DEFAULT_ROLE
                       if u.admin
                         role = ROLE_MAPPING['admin']
                       elsif TracPermission.find_by_username_and_action(username, 'developer')
                         role = ROLE_MAPPING['developer']
                       end
                       Member.create(:user => u, :project => @target_project, :roles => [role])
                       u.reload
                     end
                     u
                   end
                   # Basic wiki syntax conversion
                   def self.convert_wiki_text(text)
                     # Titles
                     text = text.gsub(/^(\=+)\s(.+)\s(\=+)/) {|s| "\nh#{$1.length}. #{$2}\n"}
                     # External Links
                     text = text.gsub(/\[(http[^\s]+)\s+([^\]]+)\]/) {|s| "\"#{$2}\":#{$1}"}
                     # Ticket links:
                     #      [ticket:234 Text],[ticket:234 This is a test]
                     text = text.gsub(/\[ticket\:([^\ ]+)\ (.+?)\]/, '"\2":/issues/show/\1')
                     #      ticket:1234
                     #      #1 is working cause Redmine uses the same syntax.
                     text = text.gsub(/ticket\:([^\ ]+)/, '#\1')
                     # Milestone links:
                     #      [milestone:"0.1.0 Mercury" Milestone 0.1.0 (Mercury)]
                     #      The text "Milestone 0.1.0 (Mercury)" is not converted,
                     #      cause Redmine's wiki does not support this.
                     text = text.gsub(/\[milestone\:\"([^\"]+)\"\ (.+?)\]/, 'version:"\1"')
                     #      [milestone:"0.1.0 Mercury"]
                     text = text.gsub(/\[milestone\:\"([^\"]+)\"\]/, 'version:"\1"')
                     text = text.gsub(/milestone\:\"([^\"]+)\"/, 'version:"\1"')
                     #      milestone:0.1.0
                     text = text.gsub(/\[milestone\:([^\ ]+)\]/, 'version:\1')
                     text = text.gsub(/milestone\:([^\ ]+)/, 'version:\1')
                     # Internal Links
                     text = text.gsub(/\[\[BR\]\]/, "\n") # This has to go before the rules below
                     text = text.gsub(/\[\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                     text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                     text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                     text = text.gsub(/\[wiki:([^\s\]]+)\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                     text = text.gsub(/\[wiki:([^\s\]]+)\s(.*)\]/) {|s| "[[#{$1.delete(',./?;|:')}|#{$2.delete(',./?;|:')}]]"}
               # Links to pages UsingJustWikiCaps
               text = text.gsub(/([^!]|^)(^| )([A-Z][a-z]+[A-Z][a-zA-Z]+)/, '\\1\\2[[\3]]')
               # Normalize things that were supposed to not be links
               # like !NotALink
               text = text.gsub(/(^| )!([A-Z][A-Za-z]+)/, '\1\2')
                     # Revisions links
                     text = text.gsub(/\[(\d+)\]/, 'r\1')
                     # Ticket number re-writing
                     text = text.gsub(/#(\d+)/) do |s|
                       if $1.length < 10
             #            TICKET_MAP[$1.to_i] ||= $1
                         "\##{TICKET_MAP[$1.to_i] || $1}"
                       else
                         s
                       end
                     end
                     # We would like to convert the Code highlighting too
                     # This will go into the next line.
                     shebang_line = false
                     # Reguar expression for start of code
                     pre_re = /\{\{\{/
                     # Code hightlighing...
                     shebang_re = /^\#\!([a-z]+)/
                     # Regular expression for end of code
                     pre_end_re = /\}\}\}/
                     # Go through the whole text..extract it line by line
                     text = text.gsub(/^(.*)$/) do |line|
                       m_pre = pre_re.match(line)
                       if m_pre
                         line = '<pre>'
                       else
                         m_sl = shebang_re.match(line)
                         if m_sl
                           shebang_line = true
                           line = '<code class="' + m_sl[1] + '">'
                         end
                         m_pre_end = pre_end_re.match(line)
                         if m_pre_end
                           line = '</pre>'
                           if shebang_line
                             line = '</code>' + line
                           end
                         end
                       end
                       line
                     end
                     # Highlighting
                     text = text.gsub(/'''''([^\s])/, '_*\1')
                     text = text.gsub(/([^\s])'''''/, '\1*_')
                     text = text.gsub(/'''/, '*')
                     text = text.gsub(/''/, '_')
                     text = text.gsub(/__/, '+')
                     text = text.gsub(/~~/, '-')
                     text = text.gsub(/`/, '@')
                     text = text.gsub(/,,/, '~')
                     # Lists
                     text = text.gsub(/^([ ]+)\* /) {|s| '*' * $1.length + " "}
                     text
                   end
                   def self.migrate
                     establish_connection
                     # Quick database test
                     TracComponent.count
                     migrated_components = 0
                     migrated_milestones = 0
                     migrated_tickets = 0
                     migrated_custom_values = 0
                     migrated_ticket_attachments = 0
                     migrated_wiki_edits = 0
                     migrated_wiki_attachments = 0
                     #Wiki system initializing...
                     @target_project.wiki.destroy if @target_project.wiki
                     @target_project.reload
                     wiki = Wiki.new(:project => @target_project, :start_page => 'WikiStart')
                     wiki_edit_count = 0
                     # Components
                     print "Migrating components"
                     issues_category_map = {}
                     TracComponent.all.each do |component|
                     print '.'
                     STDOUT.flush
                       c = IssueCategory.new :project => @target_project,
                                             :name => encode(component.name[0, limit_for(IssueCategory, 'name')])
                     next unless c.save
                     issues_category_map[component.name] = c
                     migrated_components += 1
                     end
                     puts
                     # Milestones
                     print "Migrating milestones"
                     version_map = {}
                     TracMilestone.all.each do |milestone|
                       print '.'
                       STDOUT.flush
                       # First we try to find the wiki page...
                       p = wiki.find_or_new_page(milestone.name.to_s)
                       p.content = WikiContent.new(:page => p) if p.new_record?
                       p.content.text = milestone.description.to_s
                       p.content.author = find_or_create_user('trac')
                       p.content.comments = 'Milestone'
                       p.save
                       v = Version.new :project => @target_project,
                                       :name => encode(milestone.name[0, limit_for(Version, 'name')]),
                                       :description => nil,
                                       :wiki_page_title => milestone.name.to_s,
                                       :effective_date => milestone.completed
                       next unless v.save
                       version_map[milestone.name] = v
                       migrated_milestones += 1
                     end
                     puts
                     # Custom fields
                     # TODO: read trac.ini instead
                     print "Migrating custom fields"
                     custom_field_map = {}
                     TracTicketCustom.find_by_sql("SELECT DISTINCT name FROM #{TracTicketCustom.table_name}").each do |field|
                       print '.'
                       STDOUT.flush
                       # Redmine custom field name
                       field_name = encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize
                       # Find if the custom already exists in Redmine
                       f = IssueCustomField.find_by_name(field_name)
                       # Or create a new one
                       f ||= IssueCustomField.create(:name => encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize,
                                                     :field_format => 'string')
                       next if f.new_record?
                       f.trackers = Tracker.all
                       f.projects << @target_project
                       custom_field_map[field.name] = f
                     end
                     puts
                     # Trac 'resolution' field as a Redmine custom field
                     r = IssueCustomField.where(:name => "Resolution").first
                     r = IssueCustomField.new(:name => 'Resolution',
                                              :field_format => 'list',
                                              :is_filter => true) if r.nil?
                     r.trackers = Tracker.all
                     r.projects << @target_project
                     r.possible_values = (r.possible_values + %w(fixed invalid wontfix duplicate worksforme)).flatten.compact.uniq
                     r.save!
                     custom_field_map['resolution'] = r
                     # Tickets
                     print "Migrating tickets"
                       TracTicket.find_each(:batch_size => 200) do |ticket|
                       print '.'
                       STDOUT.flush
                       i = Issue.new :project => @target_project,
                                       :subject => encode(ticket.summary[0, limit_for(Issue, 'subject')]),
                                       :description => convert_wiki_text(encode(ticket.description)),
                                       :priority => PRIORITY_MAPPING[ticket.priority] || DEFAULT_PRIORITY,
                                       :created_on => ticket.time
                       i.author = find_or_create_user(ticket.reporter)
                       i.category = issues_category_map[ticket.component] unless ticket.component.blank?
                       i.fixed_version = version_map[ticket.milestone] unless ticket.milestone.blank?
                       i.status = STATUS_MAPPING[ticket.status] || DEFAULT_STATUS
                       i.tracker = TRACKER_MAPPING[ticket.ticket_type] || DEFAULT_TRACKER
                       i.id = ticket.id unless Issue.exists?(ticket.id)
                       next unless Time.fake(ticket.changetime) { i.save }
                       TICKET_MAP[ticket.id] = i.id
                       migrated_tickets += 1
                       # Owner
                         unless ticket.owner.blank?
                           i.assigned_to = find_or_create_user(ticket.owner, true)
                           Time.fake(ticket.changetime) { i.save }
                         end
                       # Comments and status/resolution changes
                       ticket.ticket_changes.group_by(&:time).each do |time, changeset|
                           status_change = changeset.select {|change| change.field == 'status'}.first
                           resolution_change = changeset.select {|change| change.field == 'resolution'}.first
                           comment_change = changeset.select {|change| change.field == 'comment'}.first
                           n = Journal.new :notes => (comment_change ? convert_wiki_text(encode(comment_change.newvalue)) : ''),
                                           :created_on => time
                           n.user = find_or_create_user(changeset.first.author)
                           n.journalized = i
                           if status_change &&
                                STATUS_MAPPING[status_change.oldvalue] &&
                                STATUS_MAPPING[status_change.newvalue] &&
                                (STATUS_MAPPING[status_change.oldvalue] != STATUS_MAPPING[status_change.newvalue])
                             n.details << JournalDetail.new(:property => 'attr',
                                                            :prop_key => 'status_id',
                                                            :old_value => STATUS_MAPPING[status_change.oldvalue].id,
                                                            :value => STATUS_MAPPING[status_change.newvalue].id)
                           end
                           if resolution_change
                             n.details << JournalDetail.new(:property => 'cf',
                                                            :prop_key => custom_field_map['resolution'].id,
                                                            :old_value => resolution_change.oldvalue,
                                                            :value => resolution_change.newvalue)
                           end
                           n.save unless n.details.empty? && n.notes.blank?
                       end
                       # Attachments
                       ticket.attachments.each do |attachment|
                         next unless attachment.exist?
                           attachment.open {
                             a = Attachment.new :created_on => attachment.time
                             a.file = attachment
                             a.author = find_or_create_user(attachment.author)
                             a.container = i
                             a.description = attachment.description
                             migrated_ticket_attachments += 1 if a.save
                           }
                       end
                       # Custom fields
                       custom_values = ticket.customs.inject({}) do |h, custom|
                         if custom_field = custom_field_map[custom.name]
                           h[custom_field.id] = custom.value
                           migrated_custom_values += 1
                         end
                         h
                       end
                       if custom_field_map['resolution'] && !ticket.resolution.blank?
                         custom_values[custom_field_map['resolution'].id] = ticket.resolution
                       end
                       i.custom_field_values = custom_values
                       i.save_custom_field_values
                     end
                     # update issue id sequence if needed (postgresql)
                     Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')
                     puts
                     # Wiki
                     print "Migrating wiki"
                     if wiki.save
                       TracWikiPage.order('name, version').all.each do |page|
                         # Do not migrate Trac manual wiki pages
                         next if TRAC_WIKI_PAGES.include?(page.name)
                         wiki_edit_count += 1
                         print '.'
                         STDOUT.flush
                         p = wiki.find_or_new_page(page.name)
                         p.content = WikiContent.new(:page => p) if p.new_record?
                         p.content.text = page.text
                         p.content.author = find_or_create_user(page.author) unless page.author.blank? || page.author == 'trac'
                         p.content.comments = page.comment
                         Time.fake(page.time) { p.new_record? ? p.save : p.content.save }
                         next if p.content.new_record?
                         migrated_wiki_edits += 1
                         # Attachments
                         page.attachments.each do |attachment|
                           next unless attachment.exist?
                           next if p.attachments.find_by_filename(attachment.filename.gsub(/^.*(\\|\/)/, '').gsub(/[^\w\.\-]/,'_')) #add only once per page
                           attachment.open {
                             a = Attachment.new :created_on => attachment.time
                             a.file = attachment
                             a.author = find_or_create_user(attachment.author)
                             a.description = attachment.description
                             a.container = p
                             migrated_wiki_attachments += 1 if a.save
                           }
                         end
                       end
                       wiki.reload
                       wiki.pages.each do |page|
                         page.content.text = convert_wiki_text(page.content.text)
                         Time.fake(page.content.updated_on) { page.content.save }
                       end
                     end
                     puts
                     puts
                     puts "Components:      #{migrated_components}/#{TracComponent.count}"
                     puts "Milestones:      #{migrated_milestones}/#{TracMilestone.count}"
                     puts "Tickets:         #{migrated_tickets}/#{TracTicket.count}"
                     puts "Ticket files:    #{migrated_ticket_attachments}/" + TracAttachment.count(:conditions => {:type => 'ticket'}).to_s
                     puts "Custom values:   #{migrated_custom_values}/#{TracTicketCustom.count}"
                     puts "Wiki edits:      #{migrated_wiki_edits}/#{wiki_edit_count}"
                     puts "Wiki files:      #{migrated_wiki_attachments}/" + TracAttachment.count(:conditions => {:type => 'wiki'}).to_s
                   end
                   def self.limit_for(klass, attribute)
                     klass.columns_hash[attribute.to_s].limit
                   end
                   def self.encoding(charset)
                     @ic = Iconv.new('UTF-8', charset)
                   rescue Iconv::InvalidEncoding
                     puts "Invalid encoding!"
                     return false
                   end
                   def self.set_trac_directory(path)
                     @@trac_directory = path
                     raise "This directory doesn't exist!" unless File.directory?(path)
                     raise "#{trac_attachments_directory} doesn't exist!" unless File.directory?(trac_attachments_directory)
                     @@trac_directory
                   rescue Exception => e
                     puts e
                     return false
                   end
                   def self.trac_directory
                     @@trac_directory
                   end
                   def self.set_trac_adapter(adapter)
                     return false if adapter.blank?
                     raise "Unknown adapter: #{adapter}!" unless %w(sqlite3 mysql postgresql).include?(adapter)
                     # If adapter is sqlite or sqlite3, make sure that trac.db exists
                     raise "#{trac_db_path} doesn't exist!" if %w(sqlite3).include?(adapter) && !File.exist?(trac_db_path)
                     @@trac_adapter = adapter
                   rescue Exception => e
                     puts e
                     return false
                   end
                   def self.set_trac_db_host(host)
                     return nil if host.blank?
                     @@trac_db_host = host
                   end
                   def self.set_trac_db_port(port)
                     return nil if port.to_i == 0
                     @@trac_db_port = port.to_i
                   end
                   def self.set_trac_db_name(name)
                     return nil if name.blank?
                     @@trac_db_name = name
                   end
                   def self.set_trac_db_username(username)
                     @@trac_db_username = username
                   end
                   def self.set_trac_db_password(password)
                     @@trac_db_password = password
                   end
                   def self.set_trac_db_schema(schema)
                     @@trac_db_schema = schema
                   end
                   mattr_reader :trac_directory, :trac_adapter, :trac_db_host, :trac_db_port, :trac_db_name, :trac_db_schema, :trac_db_username, :trac_db_password
                   def self.trac_db_path; "#{trac_directory}/db/trac.db" end
                   def self.trac_attachments_directory; "#{trac_directory}/attachments" end
                   def self.target_project_identifier(identifier)
                     project = Project.find_by_identifier(identifier)
                     if !project
                       # create the target project
                       project = Project.new :name => identifier.humanize,
                                             :description => ''
                       project.identifier = identifier
                       puts "Unable to create a project with identifier '#{identifier}'!" unless project.save
                       # enable issues and wiki for the created project
                       project.enabled_module_names = ['issue_tracking', 'wiki']
                     else
                       puts
                       puts "This project already exists in your Redmine database."
                       print "Are you sure you want to append data to this project ? [Y/n] "
                       STDOUT.flush
                       exit if STDIN.gets.match(/^n$/i)
                     end
                     project.trackers << TRACKER_BUG unless project.trackers.include?(TRACKER_BUG)
                     project.trackers << TRACKER_FEATURE unless project.trackers.include?(TRACKER_FEATURE)
                     @target_project = project.new_record? ? nil : project
                     @target_project.reload
                   end
                   def self.connection_params
                     if trac_adapter == 'sqlite3'
                       {:adapter => 'sqlite3',
                        :database => trac_db_path}
                     else
                       {:adapter => trac_adapter,
                        :database => trac_db_name,
                        :host => trac_db_host,
                        :port => trac_db_port,
                        :username => trac_db_username,
                        :password => trac_db_password,
                        :schema_search_path => trac_db_schema
                       }
                     end
                   end
                   def self.establish_connection
                     constants.each do |const|
                       klass = const_get(const)
                       next unless klass.respond_to? 'establish_connection'
                       klass.establish_connection connection_params
                     end
                   end
                 private
                   def self.encode(text)
                     @ic.iconv text
                   rescue
                     text
                   end
                 end
                 puts
                 if Redmine::DefaultData::Loader.no_data?
                   puts "Redmine configuration need to be loaded before importing data."
                   puts "Please, run this first:"
                   puts
                   puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""
                   exit
                 end
                 puts "WARNING: a new project will be added to Redmine during this process."
                 print "Are you sure you want to continue ? [y/N] "
                 STDOUT.flush
                 break unless STDIN.gets.match(/^y$/i)
                 puts
                 def prompt(text, options = {}, &block)
                   default = options[:default] || ''
                   while true
                     print "#{text} [#{default}]: "
                     STDOUT.flush
                     value = STDIN.gets.chomp!
                     value = default if value.blank?
                     break if yield value
                   end
                 end
                 DEFAULT_PORTS = {'mysql' => 3306, 'postgresql' => 5432}
                 prompt('Trac directory') {|directory| TracMigrate.set_trac_directory directory.strip}
                 prompt('Trac database adapter (sqlite3, mysql2, postgresql)', :default => 'sqlite3') {|adapter| TracMigrate.set_trac_adapter adapter}
                 unless %w(sqlite3).include?(TracMigrate.trac_adapter)
                   prompt('Trac database host', :default => 'localhost') {|host| TracMigrate.set_trac_db_host host}
                   prompt('Trac database port', :default => DEFAULT_PORTS[TracMigrate.trac_adapter]) {|port| TracMigrate.set_trac_db_port port}
                   prompt('Trac database name') {|name| TracMigrate.set_trac_db_name name}
                   prompt('Trac database schema', :default => 'public') {|schema| TracMigrate.set_trac_db_schema schema}
                   prompt('Trac database username') {|username| TracMigrate.set_trac_db_username username}
                   prompt('Trac database password') {|password| TracMigrate.set_trac_db_password password}
                 end
                 prompt('Trac database encoding', :default => 'UTF-8') {|encoding| TracMigrate.encoding encoding}
                 prompt('Target project identifier') {|identifier| TracMigrate.target_project_identifier identifier}
                 puts
                 # Turn off email notifications
                 Setting.notified_events = []
                 TracMigrate.migrate
               end
             end

test/integration/account_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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__)
             begin
               require 'mocha'
             rescue
               # Won't run some tests
             end
             class AccountTest < ActionController::IntegrationTest
               fixtures :users, :roles
               # Replace this with your real tests.
               def test_login
                 get "my/page"
                 assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fmy%2Fpage"
                 log_user('jsmith', 'jsmith')
                 get "my/account"
                 assert_response :success
                 assert_template "my/account"
               end
               def test_autologin
                 user = User.find(1)
                 Setting.autologin = "7"
                 Token.delete_all
                 # User logs in with 'autologin' checked
                 post '/login', :username => user.login, :password => 'admin', :autologin => 1
                 assert_redirected_to '/my/page'
-                token = Token.find :first
+                token = Token.first
                 assert_not_nil token
                 assert_equal user, token.user
                 assert_equal 'autologin', token.action
                 assert_equal user.id, session[:user_id]
                 assert_equal token.value, cookies['autologin']
                 # Session is cleared
                 reset!
                 User.current = nil
                 # Clears user's last login timestamp
                 user.update_attribute :last_login_on, nil
                 assert_nil user.reload.last_login_on
                 # User comes back with his autologin cookie
                 cookies[:autologin] = token.value
                 get '/my/page'
                 assert_response :success
                 assert_template 'my/page'
                 assert_equal user.id, session[:user_id]
                 assert_not_nil user.reload.last_login_on
               end
               def test_lost_password
                 Token.delete_all
                 get "account/lost_password"
                 assert_response :success
                 assert_template "account/lost_password"
                 assert_select 'input[name=mail]'
                 post "account/lost_password", :mail => 'jSmith@somenet.foo'
                 assert_redirected_to "/login"
                 token = Token.first
                 assert_equal 'recovery', token.action
                 assert_equal 'jsmith@somenet.foo', token.user.mail
                 assert !token.expired?
                 get "account/lost_password", :token => token.value
                 assert_response :success
                 assert_template "account/password_recovery"
                 assert_select 'input[type=hidden][name=token][value=?]', token.value
                 assert_select 'input[name=new_password]'
                 assert_select 'input[name=new_password_confirmation]'
                 post "account/lost_password", :token => token.value, :new_password => 'newpass123', :new_password_confirmation => 'newpass123'
                 assert_redirected_to "/login"
                 assert_equal 'Password was successfully updated.', flash[:notice]
                 log_user('jsmith', 'newpass123')
                 assert_equal 0, Token.count
               end
               def test_register_with_automatic_activation
                 Setting.self_registration = '3'
                 get 'account/register'
                 assert_response :success
                 assert_template 'account/register'
                 post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                          :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/my/account'
                 follow_redirect!
                 assert_response :success
                 assert_template 'my/account'
                 user = User.find_by_login('newuser')
                 assert_not_nil user
                 assert user.active?
                 assert_not_nil user.last_login_on
               end
               def test_register_with_manual_activation
                 Setting.self_registration = '2'
                 post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                          :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
               end
               def test_register_with_email_activation
                 Setting.self_registration = '1'
                 Token.delete_all
                 post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                          :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
                 token = Token.first
                 assert_equal 'register', token.action
                 assert_equal 'newuser@foo.bar', token.user.mail
                 assert !token.expired?
                 get 'account/activate', :token => token.value
                 assert_redirected_to '/login'
                 log_user('newuser', 'newpass123')
               end
               def test_onthefly_registration
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns({:login => 'foo', :firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_redirected_to '/my/page'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
               def test_onthefly_registration_with_invalid_attributes
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns({:login => 'foo', :lastname => 'Smith', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_response :success
                 assert_template 'account/register'
                 assert_tag :input, :attributes => { :name => 'user[firstname]', :value => '' }
                 assert_tag :input, :attributes => { :name => 'user[lastname]', :value => 'Smith' }
                 assert_no_tag :input, :attributes => { :name => 'user[login]' }
                 assert_no_tag :input, :attributes => { :name => 'user[password]' }
                 post 'account/register', :user => {:firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com'}
                 assert_redirected_to '/my/account'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
             end

test/unit/issue_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 IssueTest < ActiveSupport::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles,
                        :groups_users,
                        :trackers, :projects_trackers,
                        :enabled_modules,
                        :versions,
                        :issue_statuses, :issue_categories, :issue_relations, :workflows,
                        :enumerations,
                        :issues, :journals, :journal_details,
                        :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                        :time_entries
               include Redmine::I18n
               def teardown
                 User.current = nil
               end
               def test_create
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                   :status_id => 1, :priority => IssuePriority.all.first,
                                   :subject => 'test_create',
                                   :description => 'IssueTest#test_create', :estimated_hours => '1:30')
                 assert issue.save
                 issue.reload
                 assert_equal 1.5, issue.estimated_hours
               end
               def test_create_minimal
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                   :status_id => 1, :priority => IssuePriority.all.first,
                                   :subject => 'test_create')
                 assert issue.save
                 assert issue.description.nil?
                 assert_nil issue.estimated_hours
               end
               def test_start_date_format_should_be_validated
                 set_language_if_valid 'en'
                 ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
                   issue = Issue.new(:start_date => invalid_date)
                   assert !issue.valid?
                   assert_include 'Start date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
                 end
               end
               def test_due_date_format_should_be_validated
                 set_language_if_valid 'en'
                 ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
                   issue = Issue.new(:due_date => invalid_date)
                   assert !issue.valid?
                   assert_include 'Due date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
                 end
               end
               def test_due_date_lesser_than_start_date_should_not_validate
                 set_language_if_valid 'en'
                 issue = Issue.new(:start_date => '2012-10-06', :due_date => '2012-10-02')
                 assert !issue.valid?
                 assert_include 'Due date must be greater than start date', issue.errors.full_messages
               end
               def test_create_with_required_custom_field
                 set_language_if_valid 'en'
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :subject => 'test_create',
                                   :description => 'IssueTest#test_create_with_required_custom_field')
                 assert issue.available_custom_fields.include?(field)
                 # No value for the custom field
                 assert !issue.save
                 assert_equal ["Database can't be blank"], issue.errors.full_messages
                 # Blank value
                 issue.custom_field_values = { field.id => '' }
                 assert !issue.save
                 assert_equal ["Database can't be blank"], issue.errors.full_messages
                 # Invalid value
                 issue.custom_field_values = { field.id => 'SQLServer' }
                 assert !issue.save
                 assert_equal ["Database is not included in the list"], issue.errors.full_messages
                 # Valid value
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 issue.reload
                 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
               end
               def test_create_with_group_assignment
                 with_settings :issue_group_assignment => '1' do
                   assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                    :subject => 'Group assignment',
                                    :assigned_to_id => 11).save
                   issue = Issue.first(:order => 'id DESC')
                   assert_kind_of Group, issue.assigned_to
                   assert_equal Group.find(11), issue.assigned_to
                 end
               end
               def test_create_with_parent_issue_id
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => 1)
                 assert_save issue
                 assert_equal 1, issue.parent_issue_id
                 assert_equal Issue.find(1), issue.parent
               end
               def test_create_with_sharp_parent_issue_id
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => "#1")
                 assert_save issue
                 assert_equal 1, issue.parent_issue_id
                 assert_equal Issue.find(1), issue.parent
               end
               def test_create_with_invalid_parent_issue_id
                 set_language_if_valid 'en'
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => '01ABC')
                 assert !issue.save
                 assert_equal '01ABC', issue.parent_issue_id
                 assert_include 'Parent task is invalid', issue.errors.full_messages
               end
               def test_create_with_invalid_sharp_parent_issue_id
                 set_language_if_valid 'en'
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => '#01ABC')
                 assert !issue.save
                 assert_equal '#01ABC', issue.parent_issue_id
                 assert_include 'Parent task is invalid', issue.errors.full_messages
               end
               def assert_visibility_match(user, issues)
                 assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
               end
               def test_visible_scope_for_anonymous
                 # Anonymous user should see issues of public projects only
                 issues = Issue.visible(User.anonymous).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.project.is_public?}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match User.anonymous, issues
               end
               def test_visible_scope_for_anonymous_without_view_issues_permissions
                 # Anonymous user should not see issues without permission
                 Role.anonymous.remove_permission!(:view_issues)
                 issues = Issue.visible(User.anonymous).all
                 assert issues.empty?
                 assert_visibility_match User.anonymous, issues
               end
               def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
                 assert Role.anonymous.update_attribute(:issues_visibility, 'default')
                 issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                 assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                 assert !issue.visible?(User.anonymous)
               end
               def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own
                 assert Role.anonymous.update_attribute(:issues_visibility, 'own')
                 issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                 assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                 assert !issue.visible?(User.anonymous)
               end
               def test_visible_scope_for_non_member
                 user = User.find(9)
                 assert user.projects.empty?
                 # Non member user should see issues of public projects only
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.project.is_public?}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_non_member_with_own_issues_visibility
                 Role.non_member.update_attribute :issues_visibility, 'own'
                 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
                 user = User.find(9)
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.author != user}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_non_member_without_view_issues_permissions
                 # Non member user should not see issues without permission
                 Role.non_member.remove_permission!(:view_issues)
                 user = User.find(9)
                 assert user.projects.empty?
                 issues = Issue.visible(user).all
                 assert issues.empty?
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_member
                 user = User.find(9)
                 # User should see issues of projects for which he has view_issues permissions only
                 Role.non_member.remove_permission!(:view_issues)
                 Member.create!(:principal => user, :project_id => 3, :role_ids => [2])
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.project_id != 3}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_member_with_groups_should_return_assigned_issues
                 user = User.find(8)
                 assert user.groups.any?
                 Member.create!(:principal => user.groups.first, :project_id => 1, :role_ids => [2])
                 Role.non_member.remove_permission!(:view_issues)
                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                   :status_id => 1, :priority => IssuePriority.all.first,
                   :subject => 'Assignment test',
                   :assigned_to => user.groups.first,
                   :is_private => true)
                 Role.find(2).update_attribute :issues_visibility, 'default'
                 issues = Issue.visible(User.find(8)).all
                 assert issues.any?
                 assert issues.include?(issue)
                 Role.find(2).update_attribute :issues_visibility, 'own'
                 issues = Issue.visible(User.find(8)).all
                 assert issues.any?
                 assert issues.include?(issue)
               end
               def test_visible_scope_for_admin
                 user = User.find(1)
                 user.members.each(&:destroy)
                 assert user.projects.empty?
                 issues = Issue.visible(user).all
                 assert issues.any?
                 # Admin should see issues on private projects that he does not belong to
                 assert issues.detect {|issue| !issue.project.is_public?}
                 # Admin should see private issues of other users
                 assert issues.detect {|issue| issue.is_private? && issue.author != user}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_with_project
                 project = Project.find(1)
                 issues = Issue.visible(User.find(2), :project => project).all
                 projects = issues.collect(&:project).uniq
                 assert_equal 1, projects.size
                 assert_equal project, projects.first
               end
               def test_visible_scope_with_project_and_subprojects
                 project = Project.find(1)
                 issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
                 projects = issues.collect(&:project).uniq
                 assert projects.size > 1
                 assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
               end
               def test_visible_and_nested_set_scopes
                 assert_equal 0, Issue.find(1).descendants.visible.all.size
               end
               def test_open_scope
                 issues = Issue.open.all
                 assert_nil issues.detect(&:closed?)
               end
               def test_open_scope_with_arg
                 issues = Issue.open(false).all
                 assert_equal issues, issues.select(&:closed?)
               end
               def test_errors_full_messages_should_include_custom_fields_errors
                 field = IssueCustomField.find_by_name('Database')
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :subject => 'test_create',
                                   :description => 'IssueTest#test_create_with_required_custom_field')
                 assert issue.available_custom_fields.include?(field)
                 # Invalid value
                 issue.custom_field_values = { field.id => 'SQLServer' }
                 assert !issue.valid?
                 assert_equal 1, issue.errors.full_messages.size
                 assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",
                              issue.errors.full_messages.first
               end
               def test_update_issue_with_required_custom_field
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 issue = Issue.find(1)
                 assert_nil issue.custom_value_for(field)
                 assert issue.available_custom_fields.include?(field)
                 # No change to custom values, issue can be saved
                 assert issue.save
                 # Blank value
                 issue.custom_field_values = { field.id => '' }
                 assert !issue.save
                 # Valid value
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 issue.reload
                 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
               end
               def test_should_not_update_attributes_if_custom_fields_validation_fails
                 issue = Issue.find(1)
                 field = IssueCustomField.find_by_name('Database')
                 assert issue.available_custom_fields.include?(field)
                 issue.custom_field_values = { field.id => 'Invalid' }
                 issue.subject = 'Should be not be saved'
                 assert !issue.save
                 issue.reload
                 assert_equal "Can't print recipes", issue.subject
               end
               def test_should_not_recreate_custom_values_objects_on_update
                 field = IssueCustomField.find_by_name('Database')
                 issue = Issue.find(1)
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 custom_value = issue.custom_value_for(field)
                 issue.reload
                 issue.custom_field_values = { field.id => 'MySQL' }
                 assert issue.save
                 issue.reload
                 assert_equal custom_value.id, issue.custom_value_for(field).id
               end
               def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields
                 issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                       :status_id => 1, :subject => 'Test',
                                       :custom_field_values => {'2' => 'Test'})
                 assert !Tracker.find(2).custom_field_ids.include?(2)
                 issue = Issue.find(issue.id)
                 issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}
                 issue = Issue.find(issue.id)
                 custom_value = issue.custom_value_for(2)
                 assert_not_nil custom_value
                 assert_equal 'Test', custom_value.value
               end
               def test_assigning_tracker_id_should_reload_custom_fields_values
                 issue = Issue.new(:project => Project.find(1))
                 assert issue.custom_field_values.empty?
                 issue.tracker_id = 1
                 assert issue.custom_field_values.any?
               end
               def test_assigning_attributes_should_assign_project_and_tracker_first
                 seq = sequence('seq')
                 issue = Issue.new
                 issue.expects(:project_id=).in_sequence(seq)
                 issue.expects(:tracker_id=).in_sequence(seq)
                 issue.expects(:subject=).in_sequence(seq)
                 issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}
               end
               def test_assigning_tracker_and_custom_fields_should_assign_custom_fields
                 attributes = ActiveSupport::OrderedHash.new
                 attributes['custom_field_values'] = { '1' => 'MySQL' }
                 attributes['tracker_id'] = '1'
                 issue = Issue.new(:project => Project.find(1))
                 issue.attributes = attributes
                 assert_equal 'MySQL', issue.custom_field_value(1)
               end
               def test_should_update_issue_with_disabled_tracker
                 p = Project.find(1)
                 issue = Issue.find(1)
                 p.trackers.delete(issue.tracker)
                 assert !p.trackers.include?(issue.tracker)
                 issue.reload
                 issue.subject = 'New subject'
                 assert issue.save
               end
               def test_should_not_set_a_disabled_tracker
                 p = Project.find(1)
                 p.trackers.delete(Tracker.find(2))
                 issue = Issue.find(1)
                 issue.tracker_id = 2
                 issue.subject = 'New subject'
                 assert !issue.save
                 assert_not_nil issue.errors[:tracker_id]
               end
               def test_category_based_assignment
                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                      :status_id => 1, :priority => IssuePriority.all.first,
                                      :subject => 'Assignment test',
                                      :description => 'Assignment test', :category_id => 1)
                 assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
               end
               def test_new_statuses_allowed_to
                 WorkflowTransition.delete_all
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 2,
                                            :author => false, :assignee => false)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 3,
                                            :author => true, :assignee => false)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1,
                                            :new_status_id => 4, :author => false,
                                            :assignee => true)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 5,
                                            :author => true, :assignee => true)
                 status = IssueStatus.find(1)
                 role = Role.find(1)
                 tracker = Tracker.find(1)
                 user = User.find(2)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author_id => 1)
                 assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author => user)
                 assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author_id => 1,
                                         :assigned_to => user)
                 assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author => user,
                                         :assigned_to => user)
                 assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
               end
               def test_new_statuses_allowed_to_should_return_all_transitions_for_admin
                 admin = User.find(1)
                 issue = Issue.find(1)
                 assert !admin.member_of?(issue.project)
                 expected_statuses = [issue.status] +
                                         WorkflowTransition.find_all_by_old_status_id(
                                             issue.status_id).map(&:new_status).uniq.sort
                 assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)
               end
               def test_new_statuses_allowed_to_should_return_default_and_current_status_when_copying
                 issue = Issue.find(1).copy
                 assert_equal [1], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
                 issue = Issue.find(2).copy
                 assert_equal [1, 2], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
               end
               def test_safe_attributes_names_should_not_include_disabled_field
                 tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))
                 issue = Issue.new(:tracker => tracker)
                 assert_include 'tracker_id', issue.safe_attribute_names
                 assert_include 'status_id', issue.safe_attribute_names
                 assert_include 'subject', issue.safe_attribute_names
                 assert_include 'description', issue.safe_attribute_names
                 assert_include 'custom_field_values', issue.safe_attribute_names
                 assert_include 'custom_fields', issue.safe_attribute_names
                 assert_include 'lock_version', issue.safe_attribute_names
                 tracker.core_fields.each do |field|
                   assert_include field, issue.safe_attribute_names
                 end
                 tracker.disabled_core_fields.each do |field|
                   assert_not_include field, issue.safe_attribute_names
                 end
               end
               def test_safe_attributes_should_ignore_disabled_fields
                 tracker = Tracker.find(1)
                 tracker.core_fields = %w(assigned_to_id due_date)
                 tracker.save!
                 issue = Issue.new(:tracker => tracker)
                 issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}
                 assert_nil issue.start_date
                 assert_equal Date.parse('2012-07-14'), issue.due_date
               end
               def test_safe_attributes_should_accept_target_tracker_enabled_fields
                 source = Tracker.find(1)
                 source.core_fields = []
                 source.save!
                 target = Tracker.find(2)
                 target.core_fields = %w(assigned_to_id due_date)
                 target.save!
                 issue = Issue.new(:tracker => source)
                 issue.safe_attributes = {'tracker_id' => 2, 'due_date' => '2012-07-14'}
                 assert_equal target, issue.tracker
                 assert_equal Date.parse('2012-07-14'), issue.due_date
               end
               def test_safe_attributes_should_not_include_readonly_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 assert_equal %w(due_date), issue.read_only_attribute_names(user)
                 assert_not_include 'due_date', issue.safe_attribute_names(user)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user
                 assert_equal Date.parse('2012-07-14'), issue.start_date
                 assert_nil issue.due_date
               end
               def test_safe_attributes_should_not_include_readonly_custom_fields
                 cf1 = IssueCustomField.create!(:name => 'Writable field',
                                                :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1])
                 cf2 = IssueCustomField.create!(:name => 'Readonly field',
                                                :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => cf2.id.to_s,
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)
                 assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)
                 issue.send :safe_attributes=, {'custom_field_values' => {
                                                    cf1.id.to_s => 'value1', cf2.id.to_s => 'value2'
                                                  }}, user
                 assert_equal 'value1', issue.custom_field_value(cf1)
                 assert_nil issue.custom_field_value(cf2)
                 issue.send :safe_attributes=, {'custom_fields' => [
                                                   {'id' => cf1.id.to_s, 'value' => 'valuea'},
                                                   {'id' => cf2.id.to_s, 'value' => 'valueb'}
                                                 ]}, user
                 assert_equal 'valuea', issue.custom_field_value(cf1)
                 assert_nil issue.custom_field_value(cf2)
               end
               def test_editable_custom_field_values_should_return_non_readonly_custom_values
                 cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1, 2])
                 cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1, 2])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,
                                            :field_name => cf2.id.to_s, :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 values = issue.editable_custom_field_values(user)
                 assert values.detect {|value| value.custom_field == cf1}
                 assert_nil values.detect {|value| value.custom_field == cf2}
                 issue.tracker_id = 2
                 values = issue.editable_custom_field_values(user)
                 assert values.detect {|value| value.custom_field == cf1}
                 assert values.detect {|value| value.custom_field == cf2}
               end
               def test_safe_attributes_should_accept_target_tracker_writable_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                'due_date' => '2012-07-14'}, user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_nil issue.due_date
                 issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                'due_date' => '2012-07-16',
                                                'tracker_id' => 2}, user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_equal Date.parse('2012-07-16'), issue.due_date
               end
               def test_safe_attributes_should_accept_target_status_writable_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                'due_date' => '2012-07-14'},
                                                user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_nil issue.due_date
                 issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                 'due_date' => '2012-07-16',
                                                 'status_id' => 2},
                                               user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_equal Date.parse('2012-07-16'), issue.due_date
               end
               def test_required_attributes_should_be_validated
                 cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string',
                                               :is_for_all => true, :tracker_ids => [1, 2])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'category_id',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => cf.id.to_s,
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => cf.id.to_s,
                                            :rule => 'required')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :status_id => 1, :subject => 'Required fields',
                                   :author => user)
                 assert_equal [cf.id.to_s, "category_id", "due_date"],
                              issue.required_attribute_names(user).sort
                 assert !issue.save, "Issue was saved"
                 assert_equal ["Category can't be blank", "Due date can't be blank", "Foo can't be blank"],
                               issue.errors.full_messages.sort
                 issue.tracker_id = 2
                 assert_equal [cf.id.to_s, "start_date"], issue.required_attribute_names(user).sort
                 assert !issue.save, "Issue was saved"
                 assert_equal ["Foo can't be blank", "Start date can't be blank"],
                              issue.errors.full_messages.sort
                 issue.start_date = Date.today
                 issue.custom_field_values = {cf.id.to_s => 'bar'}
                 assert issue.save
               end
               def test_required_attribute_names_for_multiple_roles_should_intersect_rules
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'required')
                 user = User.find(2)
                 member = Member.find(1)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 assert_equal %w(due_date start_date), issue.required_attribute_names(user).sort
                 member.role_ids = [1, 2]
                 member.save!
                 assert_equal [], issue.required_attribute_names(user.reload)
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 2, :field_name => 'due_date',
                                            :rule => 'required')
                 assert_equal %w(due_date), issue.required_attribute_names(user)
                 member.role_ids = [1, 2, 3]
                 member.save!
                 assert_equal [], issue.required_attribute_names(user.reload)
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 2, :field_name => 'due_date',
                                            :rule => 'readonly')
                 # required + readonly => required
                 assert_equal %w(due_date), issue.required_attribute_names(user)
               end
               def test_read_only_attribute_names_for_multiple_roles_should_intersect_rules
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 member = Member.find(1)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 assert_equal %w(due_date start_date), issue.read_only_attribute_names(user).sort
                 member.role_ids = [1, 2]
                 member.save!
                 assert_equal [], issue.read_only_attribute_names(user.reload)
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                           :role_id => 2, :field_name => 'due_date',
                                           :rule => 'readonly')
                 assert_equal %w(due_date), issue.read_only_attribute_names(user)
               end
               def test_copy
                 issue = Issue.new.copy_from(1)
                 assert issue.copy?
                 assert issue.save
                 issue.reload
                 orig = Issue.find(1)
                 assert_equal orig.subject, issue.subject
                 assert_equal orig.tracker, issue.tracker
                 assert_equal "125", issue.custom_value_for(2).value
               end
               def test_copy_should_copy_status
                 orig = Issue.find(8)
                 assert orig.status != IssueStatus.default
                 issue = Issue.new.copy_from(orig)
                 assert issue.save
                 issue.reload
                 assert_equal orig.status, issue.status
               end
               def test_copy_should_add_relation_with_copied_issue
                 copied = Issue.find(1)
                 issue = Issue.new.copy_from(copied)
                 assert issue.save
                 issue.reload
                 assert_equal 1, issue.relations.size
                 relation = issue.relations.first
                 assert_equal 'copied_to', relation.relation_type
                 assert_equal copied, relation.issue_from
                 assert_equal issue, relation.issue_to
               end
               def test_copy_should_copy_subtasks
                 issue = Issue.generate_with_descendants!
                 copy = issue.reload.copy
                 copy.author = User.find(7)
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                 end
                 copy.reload
                 assert_equal %w(Child1 Child2), copy.children.map(&:subject).sort
                 child_copy = copy.children.detect {|c| c.subject == 'Child1'}
                 assert_equal %w(Child11), child_copy.children.map(&:subject).sort
                 assert_equal copy.author, child_copy.author
               end
               def test_copy_should_copy_subtasks_to_target_project
                 issue = Issue.generate_with_descendants!
                 copy = issue.copy(:project_id => 3)
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                 end
                 assert_equal [3], copy.reload.descendants.map(&:project_id).uniq
               end
               def test_copy_should_not_copy_subtasks_twice_when_saving_twice
                 issue = Issue.generate_with_descendants!
                 copy = issue.reload.copy
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                   assert copy.save
                 end
               end
               def test_should_not_call_after_project_change_on_creation
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                   :subject => 'Test', :author_id => 1)
                 issue.expects(:after_project_change).never
                 issue.save!
               end
               def test_should_not_call_after_project_change_on_update
                 issue = Issue.find(1)
                 issue.project = Project.find(1)
                 issue.subject = 'No project change'
                 issue.expects(:after_project_change).never
                 issue.save!
               end
               def test_should_call_after_project_change_on_project_change
                 issue = Issue.find(1)
                 issue.project = Project.find(2)
                 issue.expects(:after_project_change).once
                 issue.save!
               end
               def test_adding_journal_should_update_timestamp
                 issue = Issue.find(1)
                 updated_on_was = issue.updated_on
                 issue.init_journal(User.first, "Adding notes")
                 assert_difference 'Journal.count' do
                   assert issue.save
                 end
                 issue.reload
                 assert_not_equal updated_on_was, issue.updated_on
               end
               def test_should_close_duplicates
                 # Create 3 issues
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue3 = Issue.generate!
                 # 2 is a dupe of 1
                 IssueRelation.create!(:issue_from => issue2, :issue_to => issue1,
                                       :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 2
                 IssueRelation.create!(:issue_from => issue3, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 1 (circular duplicates)
                 IssueRelation.create!(:issue_from => issue3, :issue_to => issue1,
                                       :relation_type => IssueRelation::TYPE_DUPLICATES)
                 assert issue1.reload.duplicates.include?(issue2)
                 # Closing issue 1
                 issue1.init_journal(User.first, "Closing issue1")
-                issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
+                issue1.status = IssueStatus.where(:is_closed => true).first
                 assert issue1.save
                 # 2 and 3 should be also closed
                 assert issue2.reload.closed?
                 assert issue3.reload.closed?
               end
               def test_should_not_close_duplicated_issue
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 # 2 is a dupe of 1
                 IssueRelation.create(:issue_from => issue2, :issue_to => issue1,
                                      :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # 2 is a dup of 1 but 1 is not a duplicate of 2
                 assert !issue2.reload.duplicates.include?(issue1)
                 # Closing issue 2
                 issue2.init_journal(User.first, "Closing issue2")
-                issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
+                issue2.status = IssueStatus.where(:is_closed => true).first
                 assert issue2.save
                 # 1 should not be also closed
                 assert !issue1.reload.closed?
               end
               def test_assignable_versions
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :fixed_version_id => 1,
                                   :subject => 'New issue')
                 assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
               end
               def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :fixed_version_id => 1,
                                   :subject => 'New issue')
                 assert !issue.save
                 assert_not_nil issue.errors[:fixed_version_id]
               end
               def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :fixed_version_id => 2,
                                   :subject => 'New issue')
                 assert !issue.save
                 assert_not_nil issue.errors[:fixed_version_id]
               end
               def test_should_be_able_to_assign_a_new_issue_to_an_open_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :fixed_version_id => 3,
                                   :subject => 'New issue')
                 assert issue.save
               end
               def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 assert_equal 'closed', issue.fixed_version.status
                 issue.subject = 'Subject changed'
                 assert issue.save
               end
               def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 issue.status_id = 1
                 assert !issue.save
                 assert_not_nil issue.errors[:base]
               end
               def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 issue.status_id = 1
                 issue.fixed_version_id = 3
                 assert issue.save
               end
               def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
                 issue = Issue.find(12)
                 assert_equal 'locked', issue.fixed_version.status
                 issue.status_id = 1
                 assert issue.save
               end
               def test_should_not_be_able_to_keep_unshared_version_when_changing_project
                 issue = Issue.find(2)
                 assert_equal 2, issue.fixed_version_id
                 issue.project_id = 3
                 assert_nil issue.fixed_version_id
                 issue.fixed_version_id = 2
                 assert !issue.save
                 assert_include 'Target version is not included in the list', issue.errors.full_messages
               end
               def test_should_keep_shared_version_when_changing_project
                 Version.find(2).update_attribute :sharing, 'tree'
                 issue = Issue.find(2)
                 assert_equal 2, issue.fixed_version_id
                 issue.project_id = 3
                 assert_equal 2, issue.fixed_version_id
                 assert issue.save
               end
               def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled
                 assert_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
               end
               def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled
                 Project.find(2).disable_module! :issue_tracking
                 assert_not_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
               end
               def test_move_to_another_project_with_same_category
                 issue = Issue.find(1)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Category changes
                 assert_equal 4, issue.category_id
                 # Make sure time entries were move to the target project
                 assert_equal 2, issue.time_entries.first.project_id
               end
               def test_move_to_another_project_without_same_category
                 issue = Issue.find(2)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Category cleared
                 assert_nil issue.category_id
               end
               def test_move_to_another_project_should_clear_fixed_version_when_not_shared
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 1)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Cleared fixed_version
                 assert_equal nil, issue.fixed_version
               end
               def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 4)
                 issue.project = Project.find(5)
                 assert issue.save
                 issue.reload
                 assert_equal 5, issue.project_id
                 # Keep fixed_version
                 assert_equal 4, issue.fixed_version_id
               end
               def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 1)
                 issue.project = Project.find(5)
                 assert issue.save
                 issue.reload
                 assert_equal 5, issue.project_id
                 # Cleared fixed_version
                 assert_equal nil, issue.fixed_version
               end
               def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 7)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Keep fixed_version
                 assert_equal 7, issue.fixed_version_id
               end
               def test_move_to_another_project_should_keep_parent_if_valid
                 issue = Issue.find(1)
                 issue.update_attribute(:parent_issue_id, 2)
                 issue.project = Project.find(3)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.parent_id
               end
               def test_move_to_another_project_should_clear_parent_if_not_valid
                 issue = Issue.find(1)
                 issue.update_attribute(:parent_issue_id, 2)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_nil issue.parent_id
               end
               def test_move_to_another_project_with_disabled_tracker
                 issue = Issue.find(1)
                 target = Project.find(2)
                 target.tracker_ids = [3]
                 target.save
                 issue.project = target
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 assert_equal 3, issue.tracker_id
               end
               def test_copy_to_the_same_project
                 issue = Issue.find(1)
                 copy = issue.copy
                 assert_difference 'Issue.count' do
                   copy.save!
                 end
                 assert_kind_of Issue, copy
                 assert_equal issue.project, copy.project
                 assert_equal "125", copy.custom_value_for(2).value
               end
               def test_copy_to_another_project_and_tracker
                 issue = Issue.find(1)
                 copy = issue.copy(:project_id => 3, :tracker_id => 2)
                 assert_difference 'Issue.count' do
                   copy.save!
                 end
                 copy.reload
                 assert_kind_of Issue, copy
                 assert_equal Project.find(3), copy.project
                 assert_equal Tracker.find(2), copy.tracker
                 # Custom field #2 is not associated with target tracker
                 assert_nil copy.custom_value_for(2)
               end
               context "#copy" do
                 setup do
                   @issue = Issue.find(1)
                 end
                 should "not create a journal" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
                   copy.save!
                   assert_equal 0, copy.reload.journals.size
                 end
                 should "allow assigned_to changes" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
                   assert_equal 3, copy.assigned_to_id
                 end
                 should "allow status changes" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
                   assert_equal 2, copy.status_id
                 end
                 should "allow start date changes" do
                   date = Date.today
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
                   assert_equal date, copy.start_date
                 end
                 should "allow due date changes" do
                   date = Date.today
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)
                   assert_equal date, copy.due_date
                 end
                 should "set current user as author" do
                   User.current = User.find(9)
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2)
                   assert_equal User.current, copy.author
                 end
                 should "create a journal with notes" do
                   date = Date.today
                   notes = "Notes added when copying"
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
                   copy.init_journal(User.current, notes)
                   copy.save!
                   assert_equal 1, copy.journals.size
                   journal = copy.journals.first
                   assert_equal 0, journal.details.size
                   assert_equal notes, journal.notes
                 end
               end
               def test_valid_parent_project
                 issue = Issue.find(1)
                 issue_in_same_project = Issue.find(2)
                 issue_in_child_project = Issue.find(5)
                 issue_in_grandchild_project = Issue.generate!(:project_id => 6, :tracker_id => 1)
                 issue_in_other_child_project = Issue.find(6)
                 issue_in_different_tree = Issue.find(4)
                 with_settings :cross_project_subtasks => '' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                 end
                 with_settings :cross_project_subtasks => 'system' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_different_tree)
                 end
                 with_settings :cross_project_subtasks => 'tree' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                 end
                 with_settings :cross_project_subtasks => 'descendants' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue)
                   assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                 end
               end
               def test_recipients_should_include_previous_assignee
                 user = User.find(3)
                 user.members.update_all ["mail_notification = ?", false]
                 user.update_attribute :mail_notification, 'only_assigned'
                 issue = Issue.find(2)
                 issue.assigned_to = nil
                 assert_include user.mail, issue.recipients
                 issue.save!
                 assert !issue.recipients.include?(user.mail)
               end
               def test_recipients_should_not_include_users_that_cannot_view_the_issue
                 issue = Issue.find(12)
                 assert issue.recipients.include?(issue.author.mail)
                 # copy the issue to a private project
                 copy  = issue.copy(:project_id => 5, :tracker_id => 2)
                 # author is not a member of project anymore
                 assert !copy.recipients.include?(copy.author.mail)
               end
               def test_recipients_should_include_the_assigned_group_members
                 group_member = User.generate!
                 group = Group.generate!
                 group.users << group_member
                 issue = Issue.find(12)
                 issue.assigned_to = group
                 assert issue.recipients.include?(group_member.mail)
               end
               def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue
                 user = User.find(3)
                 issue = Issue.find(9)
                 Watcher.create!(:user => user, :watchable => issue)
                 assert issue.watched_by?(user)
                 assert !issue.watcher_recipients.include?(user.mail)
               end
               def test_issue_destroy
                 Issue.find(1).destroy
                 assert_nil Issue.find_by_id(1)
                 assert_nil TimeEntry.find_by_issue_id(1)
               end
               def test_destroying_a_deleted_issue_should_not_raise_an_error
                 issue = Issue.find(1)
                 Issue.find(1).destroy
                 assert_nothing_raised do
                   assert_no_difference 'Issue.count' do
                     issue.destroy
                   end
                   assert issue.destroyed?
                 end
               end
               def test_destroying_a_stale_issue_should_not_raise_an_error
                 issue = Issue.find(1)
                 Issue.find(1).update_attribute :subject, "Updated"
                 assert_nothing_raised do
                   assert_difference 'Issue.count', -1 do
                     issue.destroy
                   end
                   assert issue.destroyed?
                 end
               end
               def test_blocked
                 blocked_issue = Issue.find(9)
                 blocking_issue = Issue.find(10)
                 assert blocked_issue.blocked?
                 assert !blocking_issue.blocked?
               end
               def test_blocked_issues_dont_allow_closed_statuses
                 blocked_issue = Issue.find(9)
                 allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
                 assert !allowed_statuses.empty?
                 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                 assert closed_statuses.empty?
               end
               def test_unblocked_issues_allow_closed_statuses
                 blocking_issue = Issue.find(10)
                 allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
                 assert !allowed_statuses.empty?
                 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                 assert !closed_statuses.empty?
               end
               def test_reschedule_an_issue_without_dates
                 with_settings :non_working_week_days => [] do
                   issue = Issue.new(:start_date => nil, :due_date => nil)
                   issue.reschedule_on '2012-10-09'.to_date
                   assert_equal '2012-10-09'.to_date, issue.start_date
                   assert_equal '2012-10-09'.to_date, issue.due_date
                 end
                 with_settings :non_working_week_days => %w(6 7) do
                   issue = Issue.new(:start_date => nil, :due_date => nil)
                   issue.reschedule_on '2012-10-09'.to_date
                   assert_equal '2012-10-09'.to_date, issue.start_date
                   assert_equal '2012-10-09'.to_date, issue.due_date
                   issue = Issue.new(:start_date => nil, :due_date => nil)
                   issue.reschedule_on '2012-10-13'.to_date
                   assert_equal '2012-10-15'.to_date, issue.start_date
                   assert_equal '2012-10-15'.to_date, issue.due_date
                 end
               end
               def test_reschedule_an_issue_with_start_date
                 with_settings :non_working_week_days => [] do
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                   issue.reschedule_on '2012-10-13'.to_date
                   assert_equal '2012-10-13'.to_date, issue.start_date
                   assert_equal '2012-10-13'.to_date, issue.due_date
                 end
                 with_settings :non_working_week_days => %w(6 7) do
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                   issue.reschedule_on '2012-10-11'.to_date
                   assert_equal '2012-10-11'.to_date, issue.start_date
                   assert_equal '2012-10-11'.to_date, issue.due_date
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                   issue.reschedule_on '2012-10-13'.to_date
                   assert_equal '2012-10-15'.to_date, issue.start_date
                   assert_equal '2012-10-15'.to_date, issue.due_date
                 end
               end
               def test_reschedule_an_issue_with_start_and_due_dates
                 with_settings :non_working_week_days => [] do
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-15')
                   issue.reschedule_on '2012-10-13'.to_date
                   assert_equal '2012-10-13'.to_date, issue.start_date
                   assert_equal '2012-10-19'.to_date, issue.due_date
                 end
                 with_settings :non_working_week_days => %w(6 7) do
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-19') # 8 working days
                   issue.reschedule_on '2012-10-11'.to_date
                   assert_equal '2012-10-11'.to_date, issue.start_date
                   assert_equal '2012-10-23'.to_date, issue.due_date
                   issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-19')
                   issue.reschedule_on '2012-10-13'.to_date
                   assert_equal '2012-10-15'.to_date, issue.start_date
                   assert_equal '2012-10-25'.to_date, issue.due_date
                 end
               end
               def test_rescheduling_an_issue_to_a_later_due_date_should_reschedule_following_issue
                 issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                 issue1.due_date = '2012-10-23'
                 issue1.save!
                 issue2.reload
                 assert_equal Date.parse('2012-10-24'), issue2.start_date
                 assert_equal Date.parse('2012-10-26'), issue2.due_date
               end
               def test_rescheduling_an_issue_to_an_earlier_due_date_should_reschedule_following_issue
                 issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                 issue1.start_date = '2012-09-17'
                 issue1.due_date = '2012-09-18'
                 issue1.save!
                 issue2.reload
                 assert_equal Date.parse('2012-09-19'), issue2.start_date
                 assert_equal Date.parse('2012-09-21'), issue2.due_date
               end
               def test_rescheduling_reschedule_following_issue_earlier_should_consider_other_preceding_issues
                 issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                 issue3 = Issue.generate!(:start_date => '2012-10-01', :due_date => '2012-10-02')
                 IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_PRECEDES)
                 IssueRelation.create!(:issue_from => issue3, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                 issue1.start_date = '2012-09-17'
                 issue1.due_date = '2012-09-18'
                 issue1.save!
                 issue2.reload
                 # Issue 2 must start after Issue 3
                 assert_equal Date.parse('2012-10-03'), issue2.start_date
                 assert_equal Date.parse('2012-10-05'), issue2.due_date
               end
               def test_rescheduling_a_stale_issue_should_not_raise_an_error
                 with_settings :non_working_week_days => [] do
                   stale = Issue.find(1)
                   issue = Issue.find(1)
                   issue.subject = "Updated"
                   issue.save!
                   date = 10.days.from_now.to_date
                   assert_nothing_raised do
                     stale.reschedule_on!(date)
                   end
                   assert_equal date, stale.reload.start_date
                 end
               end
               def test_overdue
                 assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
                 assert !Issue.new(:due_date => Date.today).overdue?
                 assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
                 assert !Issue.new(:due_date => nil).overdue?
                 assert !Issue.new(:due_date => 1.day.ago.to_date,
                                   :status => IssueStatus.where(:is_closed => true).first
                                   ).overdue?
               end
               context "#behind_schedule?" do
                 should "be false if the issue has no start_date" do
                   assert !Issue.new(:start_date => nil,
                                     :due_date => 1.day.from_now.to_date,
                                     :done_ratio => 0).behind_schedule?
                 end
                 should "be false if the issue has no end_date" do
                   assert !Issue.new(:start_date => 1.day.from_now.to_date,
                                     :due_date => nil,
                                     :done_ratio => 0).behind_schedule?
                 end
                 should "be false if the issue has more done than it's calendar time" do
                   assert !Issue.new(:start_date => 50.days.ago.to_date,
                                     :due_date => 50.days.from_now.to_date,
                                     :done_ratio => 90).behind_schedule?
                 end
                 should "be true if the issue hasn't been started at all" do
                   assert Issue.new(:start_date => 1.day.ago.to_date,
                                    :due_date => 1.day.from_now.to_date,
                                    :done_ratio => 0).behind_schedule?
                 end
                 should "be true if the issue has used more calendar time than it's done ratio" do
                   assert Issue.new(:start_date => 100.days.ago.to_date,
                                    :due_date => Date.today,
                                    :done_ratio => 90).behind_schedule?
                 end
               end
               context "#assignable_users" do
                 should "be Users" do
                   assert_kind_of User, Issue.find(1).assignable_users.first
                 end
                 should "include the issue author" do
                   non_project_member = User.generate!
                   issue = Issue.generate!(:author => non_project_member)
                   assert issue.assignable_users.include?(non_project_member)
                 end
                 should "include the current assignee" do
                   user = User.generate!
                   issue = Issue.generate!(:assigned_to => user)
                   user.lock!
                   assert Issue.find(issue.id).assignable_users.include?(user)
                 end
                 should "not show the issue author twice" do
                   assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
                   assert_equal 2, assignable_user_ids.length
                   assignable_user_ids.each do |user_id|
                     assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,
                                  "User #{user_id} appears more or less than once"
                   end
                 end
                 context "with issue_group_assignment" do
                   should "include groups" do
                     issue = Issue.new(:project => Project.find(2))
                     with_settings :issue_group_assignment => '1' do
                       assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                       assert issue.assignable_users.include?(Group.find(11))
                     end
                   end
                 end
                 context "without issue_group_assignment" do
                   should "not include groups" do
                     issue = Issue.new(:project => Project.find(2))
                     with_settings :issue_group_assignment => '0' do
                       assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                       assert !issue.assignable_users.include?(Group.find(11))
                     end
                   end
                 end
               end
               def test_create_should_send_email_notification
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 3, :status_id => 1,
                                   :priority => IssuePriority.all.first,
                                   :subject => 'test_create', :estimated_hours => '1:30')
                 assert issue.save
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_stale_issue_should_not_send_email_notification
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 stale = Issue.find(1)
                 issue.init_journal(User.find(1))
                 issue.subject = 'Subjet update'
                 assert issue.save
                 assert_equal 1, ActionMailer::Base.deliveries.size
                 ActionMailer::Base.deliveries.clear
                 stale.init_journal(User.find(1))
                 stale.subject = 'Another subjet update'
                 assert_raise ActiveRecord::StaleObjectError do
                   stale.save
                 end
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_journalized_description
                 IssueCustomField.delete_all
                 i = Issue.first
                 old_description = i.description
                 new_description = "This is the new description"
                 i.init_journal(User.find(2))
                 i.description = new_description
                 assert_difference 'Journal.count', 1 do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save!
                   end
                 end
                 detail = JournalDetail.first(:order => 'id DESC')
                 assert_equal i, detail.journal.journalized
                 assert_equal 'attr', detail.property
                 assert_equal 'description', detail.prop_key
                 assert_equal old_description, detail.old_value
                 assert_equal new_description, detail.value
               end
               def test_blank_descriptions_should_not_be_journalized
                 IssueCustomField.delete_all
                 Issue.update_all("description = NULL", "id=1")
                 i = Issue.find(1)
                 i.init_journal(User.find(2))
                 i.subject = "blank description"
                 i.description = "\r\n"
                 assert_difference 'Journal.count', 1 do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save!
                   end
                 end
               end
               def test_journalized_multi_custom_field
                 field = IssueCustomField.create!(:name => 'filter', :field_format => 'list',
                                                  :is_filter => true, :is_for_all => true,
                                                  :tracker_ids => [1],
                                                  :possible_values => ['value1', 'value2', 'value3'],
                                                  :multiple => true)
                 issue = Issue.create!(:project_id => 1, :tracker_id => 1,
                                       :subject => 'Test', :author_id => 1)
                 assert_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count' do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value1']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count' do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value1', 'value2']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count', 2 do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value3', 'value2']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count', 2 do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => nil}
                     issue.save!
                   end
                 end
               end
               def test_description_eol_should_be_normalized
                 i = Issue.new(:description => "CR \r LF \n CRLF \r\n")
                 assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description
               end
               def test_saving_twice_should_not_duplicate_journal_details
                 i = Issue.first
                 i.init_journal(User.find(2), 'Some notes')
                 # initial changes
                 i.subject = 'New subject'
                 i.done_ratio = i.done_ratio + 10
                 assert_difference 'Journal.count' do
                   assert i.save
                 end
                 # 1 more change
                 i.priority = IssuePriority.where("id <> ?", i.priority_id).first
                 assert_no_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save
                   end
                 end
                 # no more change
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'JournalDetail.count' do
                     i.save
                   end
                 end
               end
               def test_all_dependent_issues
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(3),
                                              :issue_to   => Issue.find(8),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               def test_all_dependent_issues_with_persistent_circular_dependency
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 r = IssueRelation.create!(:issue_from => Issue.find(3),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_PRECEDES)
                 IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                 assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               def test_all_dependent_issues_with_persistent_multiple_circular_dependencies
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 assert IssueRelation.create!(:issue_from => Issue.find(3),
                                              :issue_to   => Issue.find(8),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 r = IssueRelation.create!(:issue_from => Issue.find(8),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_RELATES)
                 IssueRelation.update_all("issue_to_id = 2", ["id = ?", r.id])
                 r = IssueRelation.create!(:issue_from => Issue.find(3),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_RELATES)
                 IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               context "#done_ratio" do
                 setup do
                   @issue = Issue.find(1)
                   @issue_status = IssueStatus.find(1)
                   @issue_status.update_attribute(:default_done_ratio, 50)
                   @issue2 = Issue.find(2)
                   @issue_status2 = IssueStatus.find(2)
                   @issue_status2.update_attribute(:default_done_ratio, 0)
                 end
                 teardown do
                   Setting.issue_done_ratio = 'issue_field'
                 end
                 context "with Setting.issue_done_ratio using the issue_field" do
                   setup do
                     Setting.issue_done_ratio = 'issue_field'
                   end
                   should "read the issue's field" do
                     assert_equal 0, @issue.done_ratio
                     assert_equal 30, @issue2.done_ratio
                   end
                 end
                 context "with Setting.issue_done_ratio using the issue_status" do
                   setup do
                     Setting.issue_done_ratio = 'issue_status'
                   end
                   should "read the Issue Status's default done ratio" do
                     assert_equal 50, @issue.done_ratio
                     assert_equal 0, @issue2.done_ratio
                   end
                 end
               end
               context "#update_done_ratio_from_issue_status" do
                 setup do
                   @issue = Issue.find(1)
                   @issue_status = IssueStatus.find(1)
                   @issue_status.update_attribute(:default_done_ratio, 50)
                   @issue2 = Issue.find(2)
                   @issue_status2 = IssueStatus.find(2)
                   @issue_status2.update_attribute(:default_done_ratio, 0)
                 end
                 context "with Setting.issue_done_ratio using the issue_field" do
                   setup do
                     Setting.issue_done_ratio = 'issue_field'
                   end
                   should "not change the issue" do
                     @issue.update_done_ratio_from_issue_status
                     @issue2.update_done_ratio_from_issue_status
                     assert_equal 0, @issue.read_attribute(:done_ratio)
                     assert_equal 30, @issue2.read_attribute(:done_ratio)
                   end
                 end
                 context "with Setting.issue_done_ratio using the issue_status" do
                   setup do
                     Setting.issue_done_ratio = 'issue_status'
                   end
                   should "change the issue's done ratio" do
                     @issue.update_done_ratio_from_issue_status
                     @issue2.update_done_ratio_from_issue_status
                     assert_equal 50, @issue.read_attribute(:done_ratio)
                     assert_equal 0, @issue2.read_attribute(:done_ratio)
                   end
                 end
               end
               test "#by_tracker" do
                 User.current = User.anonymous
                 groups = Issue.by_tracker(Project.find(1))
                 assert_equal 3, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_version" do
                 User.current = User.anonymous
                 groups = Issue.by_version(Project.find(1))
                 assert_equal 3, groups.size
                 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_priority" do
                 User.current = User.anonymous
                 groups = Issue.by_priority(Project.find(1))
                 assert_equal 4, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_category" do
                 User.current = User.anonymous
                 groups = Issue.by_category(Project.find(1))
                 assert_equal 2, groups.size
                 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_assigned_to" do
                 User.current = User.anonymous
                 groups = Issue.by_assigned_to(Project.find(1))
                 assert_equal 2, groups.size
                 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_author" do
                 User.current = User.anonymous
                 groups = Issue.by_author(Project.find(1))
                 assert_equal 4, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_subproject" do
                 User.current = User.anonymous
                 groups = Issue.by_subproject(Project.find(1))
                 # Private descendant not visible
                 assert_equal 1, groups.size
                 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               def test_recently_updated_scope
                 #should return the last updated issue
                 assert_equal Issue.reorder("updated_on DESC").first, Issue.recently_updated.limit(1).first
               end
               def test_on_active_projects_scope
                 assert Project.find(2).archive
                 before = Issue.on_active_project.length
                 # test inclusion to results
                 issue = Issue.generate!(:tracker => Project.find(2).trackers.first)
                 assert_equal before + 1, Issue.on_active_project.length
                 # Move to an archived project
                 issue.project = Project.find(2)
                 assert issue.save
                 assert_equal before, Issue.on_active_project.length
               end
               context "Issue#recipients" do
                 setup do
                   @project = Project.find(1)
                   @author = User.generate!
                   @assignee = User.generate!
                   @issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)
                 end
                 should "include project recipients" do
                   assert @project.recipients.present?
                   @project.recipients.each do |project_recipient|
                     assert @issue.recipients.include?(project_recipient)
                   end
                 end
                 should "include the author if the author is active" do
                   assert @issue.author, "No author set for Issue"
                   assert @issue.recipients.include?(@issue.author.mail)
                 end
                 should "include the assigned to user if the assigned to user is active" do
                   assert @issue.assigned_to, "No assigned_to set for Issue"
                   assert @issue.recipients.include?(@issue.assigned_to.mail)
                 end
                 should "not include users who opt out of all email" do
                   @author.update_attribute(:mail_notification, :none)
                   assert !@issue.recipients.include?(@issue.author.mail)
                 end
                 should "not include the issue author if they are only notified of assigned issues" do
                   @author.update_attribute(:mail_notification, :only_assigned)
                   assert !@issue.recipients.include?(@issue.author.mail)
                 end
                 should "not include the assigned user if they are only notified of owned issues" do
                   @assignee.update_attribute(:mail_notification, :only_owner)
                   assert !@issue.recipients.include?(@issue.assigned_to.mail)
                 end
               end
               def test_last_journal_id_with_journals_should_return_the_journal_id
                 assert_equal 2, Issue.find(1).last_journal_id
               end
               def test_last_journal_id_without_journals_should_return_nil
                 assert_nil Issue.find(3).last_journal_id
               end
               def test_journals_after_should_return_journals_with_greater_id
                 assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')
                 assert_equal [], Issue.find(1).journals_after('2')
               end
               def test_journals_after_with_blank_arg_should_return_all_journals
                 assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')
               end
               def test_css_classes_should_include_priority
                 issue = Issue.new(:priority => IssuePriority.find(8))
                 classes = issue.css_classes.split(' ')
                 assert_include 'priority-8', classes
                 assert_include 'priority-highest', classes
               end
               def test_save_attachments_with_hash_should_save_attachments_in_keys_order
                 set_tmp_attachments_directory
                 issue = Issue.generate!
                 issue.save_attachments({
                   'p0' => {'file' => mock_file_with_options(:original_filename => 'upload')},
                   '3' => {'file' => mock_file_with_options(:original_filename => 'bar')},
                   '1' => {'file' => mock_file_with_options(:original_filename => 'foo')}
                 })
                 issue.attach_saved_attachments
                 assert_equal 3, issue.reload.attachments.count
                 assert_equal %w(upload foo bar), issue.attachments.map(&:filename)
               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