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(:order => 'lft')
+                 @projects = scope.all
                  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(
-                                                   :include => [:author, {:last_reply => :author}],
-                                                   :limit  =>  @topic_pages.items_per_page,
-                                                   :offset =>  @topic_pages.current.offset)
+                     @topics =  @board.topics.
+                       reorder("#{Message.table_name}.sticky DESC").
+                       includes(:author, {:last_reply => :author}).
+                       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',
-                                                            :include => [:author, :board],
-                                                            :limit => Setting.feeds_limit.to_i
+                     @messages = @board.messages.
+                       reorder('created_on DESC').
+                       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,
-                                     :order => sort_clause,
-                                     :limit  =>  @limit,
-                                     :offset =>  @offset
+                 @users =  scope.order(sort_clause).limit(@limit).offset(@offset).all
                  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,
-                                                         :select => "id, author_id, comments, updated_on, version",
-                                                         :order => 'version DESC',
-                                                         :limit  =>  @version_pages.items_per_page + 1,
-                                                         :offset =>  @version_pages.current.offset
+                 @versions = @page.content.versions.
+                   select("id, author_id, comments, updated_on, version").
+                   reorder('version DESC').
+                   limit(@version_pages.items_per_page + 1).
+                   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 +19 -12

              # 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,
-                                  :conditions => statement,
-                                  :order => order_option,
-                                  :joins => joins_for_order_statement(order_option),
-                                  :limit  => options[:limit],
-                                  :offset => options[:offset]
+                 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]}],
-                                    :conditions => statement,
-                                    :order => options[:order],
-                                    :limit => options[:limit],
-                                    :offset => options[:offset]
+                 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',
-                             :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
+                           order('version desc').
+                             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',
-                             :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
+                           order('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
  No newline at end of file

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