jro_apps/redmine Commit - r10687:5b21efd4a432

Replaces find(:all) calls....

Jean-Philippe Lang -

r10687:5b21efd4a432

parent child

Context file:

r10687:5b21efd4a432

Collapse all files

app/controllers/custom_fields_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 CustomFieldsController < ApplicationController
               layout 'admin'
               before_filter :require_admin
               before_filter :build_new_custom_field, :only => [:new, :create]
               before_filter :find_custom_field, :only => [:edit, :update, :destroy]
               def index
-                @custom_fields_by_type = CustomField.find(:all).group_by {|f| f.class.name }
+                @custom_fields_by_type = CustomField.all.group_by {|f| f.class.name }
                 @tab = params[:tab] || 'IssueCustomField'
               end
               def new
               end
               def create
                 if request.post? and @custom_field.save
                   flash[:notice] = l(:notice_successful_create)
                   call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)
                   redirect_to :action => 'index', :tab => @custom_field.class.name
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 if request.put? and @custom_field.update_attributes(params[:custom_field])
                   flash[:notice] = l(:notice_successful_update)
                   call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)
                   redirect_to :action => 'index', :tab => @custom_field.class.name
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @custom_field.destroy
                 redirect_to :action => 'index', :tab => @custom_field.class.name
               rescue
                 flash[:error] = l(:error_can_not_delete_custom_field)
                 redirect_to :action => 'index'
               end
               private
               def build_new_custom_field
                 @custom_field = CustomField.new_subclass_instance(params[:type], params[:custom_field])
                 if @custom_field.nil?
                   render_404
                 end
               end
               def find_custom_field
                 @custom_field = CustomField.find(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]
                 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.find(:all, :order => "created_on DESC")
+                @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/messages_controller.rb +6 -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 MessagesController < ApplicationController
               menu_item :boards
               default_search_scope :messages
               before_filter :find_board, :only => [:new, :preview]
               before_filter :find_message, :except => [:new, :preview]
               before_filter :authorize, :except => [:preview, :edit, :destroy]
               helper :boards
               helper :watchers
               helper :attachments
               include AttachmentsHelper
               REPLIES_PER_PAGE = 25 unless const_defined?(:REPLIES_PER_PAGE)
               # Show a topic and its replies
               def show
                 page = params[:page]
                 # Find the page of the requested reply
                 if params[:r] && page.nil?
                   offset = @topic.children.count(:conditions => ["#{Message.table_name}.id < ?", params[:r].to_i])
                   page = 1 + offset / REPLIES_PER_PAGE
                 end
                 @reply_count = @topic.children.count
                 @reply_pages = Paginator.new self, @reply_count, REPLIES_PER_PAGE, page
-                @replies =  @topic.children.find(:all, :include => [:author, :attachments, {:board => :project}],
+                @replies =  @topic.children.
-                                                       :order => "#{Message.table_name}.created_on ASC",
+                  includes(:author, :attachments, {:board => :project}).
-                                                       :limit => @reply_pages.items_per_page,
+                  reorder("#{Message.table_name}.created_on ASC").
-                                                       :offset => @reply_pages.current.offset)
+                  limit(@reply_pages.items_per_page).
+                  offset(@reply_pages.current.offset).
+                  all
                 @reply = Message.new(:subject => "RE: #{@message.subject}")
                 render :action => "show", :layout => false if request.xhr?
               end
               # Create a new topic
               def new
                 @message = Message.new
                 @message.author = User.current
                 @message.board = @board
                 @message.safe_attributes = params[:message]
                 if request.post?
                   @message.save_attachments(params[:attachments])
                   if @message.save
                     call_hook(:controller_messages_new_after_save, { :params => params, :message => @message})
                     render_attachment_warning_if_needed(@message)
                     redirect_to board_message_path(@board, @message)
                   end
                 end
               end
               # Reply to a topic
               def reply
                 @reply = Message.new
                 @reply.author = User.current
                 @reply.board = @board
                 @reply.safe_attributes = params[:reply]
                 @topic.children << @reply
                 if !@reply.new_record?
                   call_hook(:controller_messages_reply_after_save, { :params => params, :message => @reply})
                   attachments = Attachment.attach_files(@reply, params[:attachments])
                   render_attachment_warning_if_needed(@reply)
                 end
                 redirect_to board_message_path(@board, @topic, :r => @reply)
               end
               # Edit a message
               def edit
                 (render_403; return false) unless @message.editable_by?(User.current)
                 @message.safe_attributes = params[:message]
                 if request.post? && @message.save
                   attachments = Attachment.attach_files(@message, params[:attachments])
                   render_attachment_warning_if_needed(@message)
                   flash[:notice] = l(:notice_successful_update)
                   @message.reload
                   redirect_to board_message_path(@message.board, @message.root, :r => (@message.parent_id && @message.id))
                 end
               end
               # Delete a messages
               def destroy
                 (render_403; return false) unless @message.destroyable_by?(User.current)
                 r = @message.to_param
                 @message.destroy
                 if @message.parent
                   redirect_to board_message_path(@board, @message.parent, :r => r)
                 else
                   redirect_to project_board_path(@project, @board)
                 end
               end
               def quote
                 @subject = @message.subject
                 @subject = "RE: #{@subject}" unless @subject.starts_with?('RE:')
                 @content = "#{ll(Setting.default_language, :text_user_wrote, @message.author)}\n> "
                 @content << @message.content.to_s.strip.gsub(%r{<pre>((.|\s)*?)</pre>}m, '[...]').gsub(/(\r?\n|\r\n?)/, "\n> ") + "\n\n"
               end
               def preview
                 message = @board.messages.find_by_id(params[:id])
                 @attachements = message.attachments if message
                 @text = (params[:message] || params[:reply])[:content]
                 @previewed = message
                 render :partial => 'common/preview'
               end
             private
               def find_message
                 find_board
                 @message = @board.messages.find(params[:id], :include => :parent)
                 @topic = @message.root
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_board
                 @board = Board.find(params[:board_id], :include => :project)
                 @project = @board.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/projects_controller.rb +3 -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 ProjectsController < ApplicationController
               menu_item :overview
               menu_item :roadmap, :only => :roadmap
               menu_item :settings, :only => :settings
               before_filter :find_project, :except => [ :index, :list, :new, :create, :copy ]
               before_filter :authorize, :except => [ :index, :list, :new, :create, :copy, :archive, :unarchive, :destroy]
               before_filter :authorize_global, :only => [:new, :create]
               before_filter :require_admin, :only => [ :copy, :archive, :unarchive, :destroy ]
               accept_rss_auth :index
               accept_api_auth :index, :show, :create, :update, :destroy
               after_filter :only => [:create, :edit, :update, :archive, :unarchive, :destroy] do |controller|
                 if controller.request.post?
                   controller.send :expire_action, :controller => 'welcome', :action => 'robots'
                 end
               end
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issues
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               include ProjectsHelper
               # Lists visible projects
               def index
                 respond_to do |format|
                   format.html {
                     scope = Project
                     unless params[:closed]
                       scope = scope.active
                     end
                     @projects = scope.visible.order('lft').all
                   }
                   format.api  {
                     @offset, @limit = api_offset_and_limit
                     @project_count = Project.visible.count
-                    @projects = Project.visible.all(:offset => @offset, :limit => @limit, :order => 'lft')
+                    @projects = Project.visible.offset(@offset).limit(@limit).order('lft').all
                   }
                   format.atom {
-                    projects = Project.visible.find(:all, :order => 'created_on DESC',
+                    projects = Project.visible.order('created_on DESC').limit(Setting.feeds_limit.to_i).all
-                                                          :limit => Setting.feeds_limit.to_i)
                     render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                   }
                 end
               end
               def new
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.sorted.all
                 @project = Project.new
                 @project.safe_attributes = params[:project]
               end
               def create
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.sorted.all
                 @project = Project.new
                 @project.safe_attributes = params[:project]
                 if validate_parent_id && @project.save
                   @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                   # Add current user as a project member if he is not admin
                   unless User.current.admin?
                     r = Role.givable.find_by_id(Setting.new_project_user_role_id.to_i) || Role.givable.first
                     m = Member.new(:user => User.current, :roles => [r])
                     @project.members << m
                   end
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to(params[:continue] ?
                         {:controller => 'projects', :action => 'new', :project => {:parent_id => @project.parent_id}.reject {|k,v| v.nil?}} :
                         {:controller => 'projects', :action => 'settings', :id => @project}
                       )
                     }
                     format.api  { render :action => 'show', :status => :created, :location => url_for(:controller => 'projects', :action => 'show', :id => @project.id) }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@project) }
                   end
                 end
               end
               def copy
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.sorted.all
                 @source_project = Project.find(params[:id])
                 if request.get?
                   @project = Project.copy_from(@source_project)
                   @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
                 else
                   Mailer.with_deliveries(params[:notifications] == '1') do
                     @project = Project.new
                     @project.safe_attributes = params[:project]
                     if validate_parent_id && @project.copy(@source_project, :only => params[:only])
                       @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to :controller => 'projects', :action => 'settings', :id => @project
                     elsif !@project.new_record?
                       # Project was created
                       # But some objects were not copied due to validation failures
                       # (eg. issues from disabled trackers)
                       # TODO: inform about that
                       redirect_to :controller => 'projects', :action => 'settings', :id => @project
                     end
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 # source_project not found
                 render_404
               end
               # Show @project
               def show
                 if params[:jump]
                   # try to redirect to the requested menu item
                   redirect_to_project_menu_item(@project, params[:jump]) && return
                 end
                 @users_by_role = @project.users_by_role
                 @subprojects = @project.children.visible.all
-                @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")
+                @news = @project.news.limit(5).includes(:author, :project).reorder("#{News.table_name}.created_on DESC").all
                 @trackers = @project.rolled_up_trackers
                 cond = @project.project_condition(Setting.display_subprojects_issues?)
                 @open_issues_by_tracker = Issue.visible.open.where(cond).count(:group => :tracker)
                 @total_issues_by_tracker = Issue.visible.where(cond).count(:group => :tracker)
                 if User.current.allowed_to?(:view_time_entries, @project)
                   @total_hours = TimeEntry.visible.sum(:hours, :include => :project, :conditions => cond).to_f
                 end
                 @key = User.current.rss_key
                 respond_to do |format|
                   format.html
                   format.api
                 end
               end
               def settings
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @issue_category ||= IssueCategory.new
                 @member ||= @project.members.new
                 @trackers = Tracker.sorted.all
                 @wiki ||= @project.wiki
               end
               def edit
               end
               def update
                 @project.safe_attributes = params[:project]
                 if validate_parent_id && @project.save
                   @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to :action => 'settings', :id => @project
                     }
                     format.api  { render_api_ok }
                   end
                 else
                   respond_to do |format|
                     format.html {
                       settings
                       render :action => 'settings'
                     }
                     format.api  { render_validation_errors(@project) }
                   end
                 end
               end
               def modules
                 @project.enabled_module_names = params[:enabled_module_names]
                 flash[:notice] = l(:notice_successful_update)
                 redirect_to :action => 'settings', :id => @project, :tab => 'modules'
               end
               def archive
                 if request.post?
                   unless @project.archive
                     flash[:error] = l(:error_can_not_archive_project)
                   end
                 end
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               def unarchive
                 @project.unarchive if request.post? && !@project.active?
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               def close
                 @project.close
                 redirect_to project_path(@project)
               end
               def reopen
                 @project.reopen
                 redirect_to project_path(@project)
               end
               # Delete @project
               def destroy
                 @project_to_destroy = @project
                 if api_request? || params[:confirm]
                   @project_to_destroy.destroy
                   respond_to do |format|
                     format.html { redirect_to :controller => 'admin', :action => 'projects' }
                     format.api  { render_api_ok }
                   end
                 end
                 # hide project in layout
                 @project = nil
               end
               private
               # Validates parent_id param according to user's permissions
               # TODO: move it to Project model in a validation that depends on User.current
               def validate_parent_id
                 return true if User.current.admin?
                 parent_id = params[:project] && params[:project][:parent_id]
                 if parent_id || @project.new_record?
                   parent = parent_id.blank? ? nil : Project.find_by_id(parent_id.to_i)
                   unless @project.allowed_parents.include?(parent)
                     @project.errors.add :parent_id, :invalid
                     return false
                   end
                 end
                 true
               end
             end

app/controllers/reports_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 ReportsController < ApplicationController
               menu_item :issues
               before_filter :find_project, :authorize, :find_issue_statuses
               def issue_report
                 @trackers = @project.trackers
                 @versions = @project.shared_versions.sort
                 @priorities = IssuePriority.all.reverse
                 @categories = @project.issue_categories
                 @assignees = (Setting.issue_group_assignment? ? @project.principals : @project.users).sort
                 @authors = @project.users.sort
                 @subprojects = @project.descendants.visible
                 @issues_by_tracker = Issue.by_tracker(@project)
                 @issues_by_version = Issue.by_version(@project)
                 @issues_by_priority = Issue.by_priority(@project)
                 @issues_by_category = Issue.by_category(@project)
                 @issues_by_assigned_to = Issue.by_assigned_to(@project)
                 @issues_by_author = Issue.by_author(@project)
                 @issues_by_subproject = Issue.by_subproject(@project) || []
                 render :template => "reports/issue_report"
               end
               def issue_report_details
                 case params[:detail]
                 when "tracker"
                   @field = "tracker_id"
                   @rows = @project.trackers
                   @data = Issue.by_tracker(@project)
                   @report_title = l(:field_tracker)
                 when "version"
                   @field = "fixed_version_id"
                   @rows = @project.shared_versions.sort
                   @data = Issue.by_version(@project)
                   @report_title = l(:field_version)
                 when "priority"
                   @field = "priority_id"
                   @rows = IssuePriority.all.reverse
                   @data = Issue.by_priority(@project)
                   @report_title = l(:field_priority)
                 when "category"
                   @field = "category_id"
                   @rows = @project.issue_categories
                   @data = Issue.by_category(@project)
                   @report_title = l(:field_category)
                 when "assigned_to"
                   @field = "assigned_to_id"
                   @rows = (Setting.issue_group_assignment? ? @project.principals : @project.users).sort
                   @data = Issue.by_assigned_to(@project)
                   @report_title = l(:field_assigned_to)
                 when "author"
                   @field = "author_id"
                   @rows = @project.users.sort
                   @data = Issue.by_author(@project)
                   @report_title = l(:field_author)
                 when "subproject"
                   @field = "project_id"
                   @rows = @project.descendants.visible
                   @data = Issue.by_subproject(@project) || []
                   @report_title = l(:field_subproject)
                 end
                 respond_to do |format|
                   if @field
                     format.html {}
                   else
                     format.html { redirect_to :action => 'issue_report', :id => @project }
                   end
                 end
               end
               private
               def find_issue_statuses
-                @statuses = IssueStatus.find(:all, :order => 'position')
+                @statuses = IssueStatus.sorted.all
               end
             end

app/controllers/repositories_controller.rb +5 -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.
             require 'SVG/Graph/Bar'
             require 'SVG/Graph/BarHorizontal'
             require 'digest/sha1'
             require 'redmine/scm/adapters/abstract_adapter'
             class ChangesetNotFound < Exception; end
             class InvalidRevisionParam < Exception; end
             class RepositoriesController < ApplicationController
               menu_item :repository
               menu_item :settings, :only => [:new, :create, :edit, :update, :destroy, :committers]
               default_search_scope :changesets
               before_filter :find_project_by_project_id, :only => [:new, :create]
               before_filter :find_repository, :only => [:edit, :update, :destroy, :committers]
               before_filter :find_project_repository, :except => [:new, :create, :edit, :update, :destroy, :committers]
               before_filter :find_changeset, :only => [:revision, :add_related_issue, :remove_related_issue]
               before_filter :authorize
               accept_rss_auth :revisions
               rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed
               def new
                 scm = params[:repository_scm] || (Redmine::Scm::Base.all & Setting.enabled_scm).first
                 @repository = Repository.factory(scm)
                 @repository.is_default = @project.repository.nil?
                 @repository.project = @project
               end
               def create
                 attrs = pickup_extra_info
                 @repository = Repository.factory(params[:repository_scm])
                 @repository.safe_attributes = params[:repository]
                 if attrs[:attrs_extra].keys.any?
                   @repository.merge_extra_info(attrs[:attrs_extra])
                 end
                 @repository.project = @project
                 if request.post? && @repository.save
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 attrs = pickup_extra_info
                 @repository.safe_attributes = attrs[:attrs]
                 if attrs[:attrs_extra].keys.any?
                   @repository.merge_extra_info(attrs[:attrs_extra])
                 end
                 @repository.project = @project
                 if request.put? && @repository.save
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 else
                   render :action => 'edit'
                 end
               end
               def pickup_extra_info
                 p       = {}
                 p_extra = {}
                 params[:repository].each do |k, v|
                   if k =~ /^extra_/
                     p_extra[k] = v
                   else
                     p[k] = v
                   end
                 end
                 {:attrs => p, :attrs_extra => p_extra}
               end
               private :pickup_extra_info
               def committers
                 @committers = @repository.committers
                 @users = @project.users
                 additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)
                 @users += User.find_all_by_id(additional_user_ids) unless additional_user_ids.empty?
                 @users.compact!
                 @users.sort!
                 if request.post? && params[:committers].is_a?(Hash)
                   # Build a hash with repository usernames as keys and corresponding user ids as values
                   @repository.committer_ids = params[:committers].values.inject({}) {|h, c| h[c.first] = c.last; h}
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 end
               end
               def destroy
                 @repository.destroy if request.delete?
                 redirect_to settings_project_path(@project, :tab => 'repositories')
               end
               def show
                 @repository.fetch_changesets if Setting.autofetch_changesets? && @path.empty?
                 @entries = @repository.entries(@path, @rev)
                 @changeset = @repository.find_changeset_by_name(@rev)
                 if request.xhr?
                   @entries ? render(:partial => 'dir_list_content') : render(:nothing => true)
                 else
                   (show_error_not_found; return) unless @entries
                   @changesets = @repository.latest_changesets(@path, @rev)
                   @properties = @repository.properties(@path, @rev)
                   @repositories = @project.repositories
                   render :action => 'show'
                 end
               end
               alias_method :browse, :show
               def changes
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 @changesets = @repository.latest_changesets(@path, @rev, Setting.repository_log_display_limit.to_i)
                 @properties = @repository.properties(@path, @rev)
                 @changeset = @repository.find_changeset_by_name(@rev)
               end
               def revisions
                 @changeset_count = @repository.changesets.count
                 @changeset_pages = Paginator.new self, @changeset_count,
                                                  per_page_option,
                                                  params['page']
-                @changesets = @repository.changesets.find(:all,
+                @changesets = @repository.changesets.
-                                   :limit  =>  @changeset_pages.items_per_page,
+                  limit(@changeset_pages.items_per_page).
-                                   :offset =>  @changeset_pages.current.offset,
+                  offset(@changeset_pages.current.offset).
-                                   :include => [:user, :repository, :parents])
+                  includes(:user, :repository, :parents).
+                  all
                 respond_to do |format|
                   format.html { render :layout => false if request.xhr? }
                   format.atom { render_feed(@changesets, :title => "#{@project.name}: #{l(:label_revision_plural)}") }
                 end
               end
               def raw
                 entry_and_raw(true)
               end
               def entry
                 entry_and_raw(false)
               end
               def entry_and_raw(is_raw)
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 # If the entry is a dir, show the browser
                 (show; return) if @entry.is_dir?
                 @content = @repository.cat(@path, @rev)
                 (show_error_not_found; return) unless @content
                 if is_raw ||
                      (@content.size && @content.size > Setting.file_max_size_displayed.to_i.kilobyte) ||
                      ! is_entry_text_data?(@content, @path)
                   # Force the download
                   send_opt = { :filename => filename_for_content_disposition(@path.split('/').last) }
                   send_type = Redmine::MimeType.of(@path)
                   send_opt[:type] = send_type.to_s if send_type
                   send_opt[:disposition] = (Redmine::MimeType.is_type?('image', @path) && !is_raw ? 'inline' : 'attachment')
                   send_data @content, send_opt
                 else
                   # Prevent empty lines when displaying a file with Windows style eol
                   # TODO: UTF-16
                   # Is this needs? AttachmentsController reads file simply.
                   @content.gsub!("\r\n", "\n")
                   @changeset = @repository.find_changeset_by_name(@rev)
                 end
               end
               private :entry_and_raw
               def is_entry_text_data?(ent, path)
                 # UTF-16 contains "\x00".
                 # It is very strict that file contains less than 30% of ascii symbols
                 # in non Western Europe.
                 return true if Redmine::MimeType.is_type?('text', path)
                 # Ruby 1.8.6 has a bug of integer divisions.
                 # http://apidock.com/ruby/v1_8_6_287/String/is_binary_data%3F
                 return false if ent.is_binary_data?
                 true
               end
               private :is_entry_text_data?
               def annotate
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 @annotate = @repository.scm.annotate(@path, @rev)
                 if @annotate.nil? || @annotate.empty?
                   (render_error l(:error_scm_annotate); return)
                 end
                 ann_buf_size = 0
                 @annotate.lines.each do |buf|
                   ann_buf_size += buf.size
                 end
                 if ann_buf_size > Setting.file_max_size_displayed.to_i.kilobyte
                   (render_error l(:error_scm_annotate_big_text_file); return)
                 end
                 @changeset = @repository.find_changeset_by_name(@rev)
               end
               def revision
                 respond_to do |format|
                   format.html
                   format.js {render :layout => false}
                 end
               end
               # Adds a related issue to a changeset
               # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues
               def add_related_issue
                 @issue = @changeset.find_referenced_issue_by_id(params[:issue_id])
                 if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))
                   @issue = nil
                 end
                 if @issue
                   @changeset.issues << @issue
                 end
               end
               # Removes a related issue from a changeset
               # DELETE /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues/:issue_id
               def remove_related_issue
                 @issue = Issue.visible.find_by_id(params[:issue_id])
                 if @issue
                   @changeset.issues.delete(@issue)
                 end
               end
               def diff
                 if params[:format] == 'diff'
                   @diff = @repository.diff(@path, @rev, @rev_to)
                   (show_error_not_found; return) unless @diff
                   filename = "changeset_r#{@rev}"
                   filename << "_r#{@rev_to}" if @rev_to
                   send_data @diff.join, :filename => "#{filename}.diff",
                                         :type => 'text/x-patch',
                                         :disposition => 'attachment'
                 else
                   @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                   @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                   # Save diff type as user preference
                   if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                     User.current.pref[:diff_type] = @diff_type
                     User.current.preference.save
                   end
                   @cache_key = "repositories/diff/#{@repository.id}/" +
                                   Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}-#{current_language}")
                   unless read_fragment(@cache_key)
                     @diff = @repository.diff(@path, @rev, @rev_to)
                     show_error_not_found unless @diff
                   end
                   @changeset = @repository.find_changeset_by_name(@rev)
                   @changeset_to = @rev_to ? @repository.find_changeset_by_name(@rev_to) : nil
                   @diff_format_revisions = @repository.diff_format_revisions(@changeset, @changeset_to)
                 end
               end
               def stats
               end
               def graph
                 data = nil
                 case params[:graph]
                 when "commits_per_month"
                   data = graph_commits_per_month(@repository)
                 when "commits_per_author"
                   data = graph_commits_per_author(@repository)
                 end
                 if data
                   headers["Content-Type"] = "image/svg+xml"
                   send_data(data, :type => "image/svg+xml", :disposition => "inline")
                 else
                   render_404
                 end
               end
               private
               def find_repository
                 @repository = Repository.find(params[:id])
                 @project = @repository.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i
               def find_project_repository
                 @project = Project.find(params[:id])
                 if params[:repository_id].present?
                   @repository = @project.repositories.find_by_identifier_param(params[:repository_id])
                 else
                   @repository = @project.repository
                 end
                 (render_404; return false) unless @repository
                 @path = params[:path].is_a?(Array) ? params[:path].join('/') : params[:path].to_s
                 @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip
                 @rev_to = params[:rev_to]
                 unless @rev.to_s.match(REV_PARAM_RE) && @rev_to.to_s.match(REV_PARAM_RE)
                   if @repository.branches.blank?
                     raise InvalidRevisionParam
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               rescue InvalidRevisionParam
                 show_error_not_found
               end
               def find_changeset
                 if @rev.present?
                   @changeset = @repository.find_changeset_by_name(@rev)
                 end
                 show_error_not_found unless @changeset
               end
               def show_error_not_found
                 render_error :message => l(:error_scm_not_found), :status => 404
               end
               # Handler for Redmine::Scm::Adapters::CommandFailed exception
               def show_error_command_failed(exception)
                 render_error l(:error_scm_command_failed, exception.message)
               end
               def graph_commits_per_month(repository)
                 @date_to = Date.today
                 @date_from = @date_to << 11
                 @date_from = Date.civil(@date_from.year, @date_from.month, 1)
                 commits_by_day = Changeset.count(
                                       :all, :group => :commit_date,
                                       :conditions => ["repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to])
                 commits_by_month = [0] * 12
                 commits_by_day.each {|c| commits_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                 changes_by_day = Change.count(
                                       :all, :group => :commit_date, :include => :changeset,
                                       :conditions => ["#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to])
                 changes_by_month = [0] * 12
                 changes_by_day.each {|c| changes_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                 fields = []
 .times {|m| fields << month_name(((Date.today.month - 1 - m) % 12) + 1)}
                 graph = SVG::Graph::Bar.new(
                   :height => 300,
                   :width => 800,
                   :fields => fields.reverse,
                   :stack => :side,
                   :scale_integers => true,
                   :step_x_labels => 2,
                   :show_data_values => false,
                   :graph_title => l(:label_commits_per_month),
                   :show_graph_title => true
                 )
                 graph.add_data(
                   :data => commits_by_month[0..11].reverse,
                   :title => l(:label_revision_plural)
                 )
                 graph.add_data(
                   :data => changes_by_month[0..11].reverse,
                   :title => l(:label_change_plural)
                 )
                 graph.burn
               end
               def graph_commits_per_author(repository)
                 commits_by_author = Changeset.count(:all, :group => :committer, :conditions => ["repository_id = ?", repository.id])
                 commits_by_author.to_a.sort! {|x, y| x.last <=> y.last}
                 changes_by_author = Change.count(:all, :group => :committer, :include => :changeset, :conditions => ["#{Changeset.table_name}.repository_id = ?", repository.id])
                 h = changes_by_author.inject({}) {|o, i| o[i.first] = i.last; o}
                 fields = commits_by_author.collect {|r| r.first}
                 commits_data = commits_by_author.collect {|r| r.last}
                 changes_data = commits_by_author.collect {|r| h[r.first] || 0}
                 fields = fields + [""]*(10 - fields.length) if fields.length<10
                 commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10
                 changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10
                 # Remove email adress in usernames
                 fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }
                 graph = SVG::Graph::BarHorizontal.new(
                   :height => 400,
                   :width => 800,
                   :fields => fields,
                   :stack => :side,
                   :scale_integers => true,
                   :show_data_values => false,
                   :rotate_y_labels => false,
                   :graph_title => l(:label_commits_per_author),
                   :show_graph_title => true
                 )
                 graph.add_data(
                   :data => commits_data,
                   :title => l(:label_revision_plural)
                 )
                 graph.add_data(
                   :data => changes_data,
                   :title => l(:label_change_plural)
                 )
                 graph.burn
               end
             end

app/controllers/trackers_controller.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.
             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'
-                @projects = Project.find(: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.find(:all)
+                @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 +4 -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
                 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.find(:all)
+                @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.find(:all)
+                  @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.find(:all)
+                @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.find(:all)
+                  @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/versions_controller.rb +5 -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 VersionsController < ApplicationController
               menu_item :roadmap
               model_object Version
               before_filter :find_model_object, :except => [:index, :new, :create, :close_completed]
               before_filter :find_project_from_association, :except => [:index, :new, :create, :close_completed]
               before_filter :find_project_by_project_id, :only => [:index, :new, :create, :close_completed]
               before_filter :authorize
               accept_api_auth :index, :show, :create, :update, :destroy
               helper :custom_fields
               helper :projects
               def index
                 respond_to do |format|
                   format.html {
-                    @trackers = @project.trackers.find(:all, :order => 'position')
+                    @trackers = @project.trackers.sorted.all
                     retrieve_selected_tracker_ids(@trackers, @trackers.select {|t| t.is_in_roadmap?})
                     @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
                     project_ids = @with_subprojects ? @project.self_and_descendants.collect(&:id) : [@project.id]
                     @versions = @project.shared_versions || []
                     @versions += @project.rolled_up_versions.visible if @with_subprojects
                     @versions = @versions.uniq.sort
                     unless params[:completed]
                       @completed_versions = @versions.select {|version| version.closed? || version.completed? }
                       @versions -= @completed_versions
                     end
                     @issues_by_version = {}
                     if @selected_tracker_ids.any? && @versions.any?
                       issues = Issue.visible.all(
                         :include => [:project, :status, :tracker, :priority, :fixed_version],
                         :conditions => {:tracker_id => @selected_tracker_ids, :project_id => project_ids, :fixed_version_id => @versions.map(&:id)},
                         :order => "#{Project.table_name}.lft, #{Tracker.table_name}.position, #{Issue.table_name}.id"
                       )
                       @issues_by_version = issues.group_by(&:fixed_version)
                     end
                     @versions.reject! {|version| !project_ids.include?(version.project_id) && @issues_by_version[version].blank?}
                   }
                   format.api {
                     @versions = @project.shared_versions.all
                   }
                 end
               end
               def show
                 respond_to do |format|
                   format.html {
-                    @issues = @version.fixed_issues.visible.find(:all,
+                    @issues = @version.fixed_issues.visible.
-                      :include => [:status, :tracker, :priority],
+                      includes(:status, :tracker, :priority).
-                      :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id")
+                      reorder("#{Tracker.table_name}.position, #{Issue.table_name}.id").
+                      all
                   }
                   format.api
                 end
               end
               def new
                 @version = @project.versions.build
                 @version.safe_attributes = params[:version]
                 respond_to do |format|
                   format.html
                   format.js
                 end
               end
               def create
                 @version = @project.versions.build
                 if params[:version]
                   attributes = params[:version].dup
                   attributes.delete('sharing') unless attributes.nil? || @version.allowed_sharings.include?(attributes['sharing'])
                   @version.safe_attributes = attributes
                 end
                 if request.post?
                   if @version.save
                     respond_to do |format|
                       format.html do
                         flash[:notice] = l(:notice_successful_create)
                         redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                       end
                       format.js
                       format.api do
                         render :action => 'show', :status => :created, :location => version_url(@version)
                       end
                     end
                   else
                     respond_to do |format|
                       format.html { render :action => 'new' }
                       format.js   { render :action => 'new' }
                       format.api  { render_validation_errors(@version) }
                     end
                   end
                 end
               end
               def edit
               end
               def update
                 if request.put? && params[:version]
                   attributes = params[:version].dup
                   attributes.delete('sharing') unless @version.allowed_sharings.include?(attributes['sharing'])
                   @version.safe_attributes = attributes
                   if @version.save
                     respond_to do |format|
                       format.html {
                         flash[:notice] = l(:notice_successful_update)
                         redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                       }
                       format.api  { render_api_ok }
                     end
                   else
                     respond_to do |format|
                       format.html { render :action => 'edit' }
                       format.api  { render_validation_errors(@version) }
                     end
                   end
                 end
               end
               def close_completed
                 if request.put?
                   @project.close_completed_versions
                 end
                 redirect_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
               end
               def destroy
                 if @version.fixed_issues.empty?
                   @version.destroy
                   respond_to do |format|
                     format.html { redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project }
                     format.api  { render_api_ok }
                   end
                 else
                   respond_to do |format|
                     format.html {
                       flash[:error] = l(:notice_unable_delete_version)
                       redirect_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                     }
                     format.api  { head :unprocessable_entity }
                   end
                 end
               end
               def status_by
                 respond_to do |format|
                   format.html { render :action => 'show' }
                   format.js
                 end
               end
               private
               def retrieve_selected_tracker_ids(selectable_trackers, default_trackers=nil)
                 if ids = params[:tracker_ids]
                   @selected_tracker_ids = (ids.is_a? Array) ? ids.collect { |id| id.to_i.to_s } : ids.split('/').collect { |id| id.to_i.to_s }
                 else
                   @selected_tracker_ids = (default_trackers || selectable_trackers).collect {|t| t.id.to_s }
                 end
               end
             end

app/controllers/watchers_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 WatchersController < ApplicationController
               before_filter :find_project
               before_filter :require_login, :check_project_privacy, :only => [:watch, :unwatch]
               before_filter :authorize, :only => [:new, :destroy]
               def watch
                 if @watched.respond_to?(:visible?) && !@watched.visible?(User.current)
                   render_403
                 else
                   set_watcher(User.current, true)
                 end
               end
               def unwatch
                 set_watcher(User.current, false)
               end
               def new
               end
               def create
                 if params[:watcher].is_a?(Hash) && request.post?
                   user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
                   user_ids.each do |user_id|
                     Watcher.create(:watchable => @watched, :user_id => user_id)
                   end
                 end
                 respond_to do |format|
                   format.html { redirect_to_referer_or {render :text => 'Watcher added.', :layout => true}}
                   format.js
                 end
               end
               def append
                 if params[:watcher].is_a?(Hash)
                   user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
                   @users = User.active.find_all_by_id(user_ids)
                 end
               end
               def destroy
                 @watched.set_watcher(User.find(params[:user_id]), false) if request.post?
                 respond_to do |format|
                   format.html { redirect_to :back }
                   format.js
                 end
               end
               def autocomplete_for_user
-                @users = User.active.like(params[:q]).find(:all, :limit => 100)
+                @users = User.active.like(params[:q]).limit(100).all
                 if @watched
                   @users -= @watched.watcher_users
                 end
                 render :layout => false
               end
             private
               def find_project
                 if params[:object_type] && params[:object_id]
                   klass = Object.const_get(params[:object_type].camelcase)
                   return false unless klass.respond_to?('watched_by')
                   @watched = klass.find(params[:object_id])
                   @project = @watched.project
                 elsif params[:project_id]
                   @project = Project.visible.find_by_param(params[:project_id])
                 end
               rescue
                 render_404
               end
               def set_watcher(user, watching)
                 @watched.set_watcher(user, watching)
                 respond_to do |format|
                   format.html { redirect_to_referer_or {render :text => (watching ? 'Watcher added.' : 'Watcher removed.'), :layout => true}}
                   format.js { render :partial => 'set_watcher', :locals => {:user => user, :watched => @watched} }
                 end
               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