jro_apps/redmine Commit - r10704:ea296a109a86

app/controllers/admin_controller.rb +2 -3

                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

app/controllers/boards_controller.rb +12 -7

                      @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

app/controllers/documents_controller.rb +1 -1

                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 }

app/controllers/trackers_controller.rb +1 -1

                def new
                  @tracker ||= Tracker.new(params[:tracker])
-                 @trackers = Tracker.find :all, :order => 'position'
+                 @trackers = Tracker.sorted.all
                  @projects = Project.all
                end

app/controllers/users_controller.rb +1 -4

                  @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 {

app/controllers/wiki_controller.rb +6 -5

                  @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

app/models/query.rb +19 -12

                  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)
                # 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

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

                          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
                        # 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

lib/tasks/migrate_from_mantis.rake +2 -2

                    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
                      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

lib/tasks/migrate_from_trac.rake +1 -1

                      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,

test/integration/account_test.rb +1 -1

                  # 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

test/unit/issue_test.rb +2 -2

                  # 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?
                  # 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?

	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