jro_apps/redmine Commit - r10690:536747b74708

Replaces find(:all) calls....

Jean-Philippe Lang -

r10690:536747b74708

parent child

Context file:

r10690:536747b74708

Expand all files

app/models/custom_field.rb +1 -1

               # to move in project_custom_field
               def self.for_all
-                find(:all, :conditions => ["is_for_all=?", true], :order => 'position')
+                where(:is_for_all => true).order('position').all
               end
               def type_name

app/models/group.rb +5 -2

               def user_removed(user)
                 members.each do |member|
-                  MemberRole.find(:all, :include => :member,
+                  MemberRole.
-                                        :conditions => ["#{Member.table_name}.user_id = ? AND #{MemberRole.table_name}.inherited_from IN (?)", user.id, member.member_role_ids]).each(&:destroy)
+                    includes(:member).
+                    where("#{Member.table_name}.user_id = ? AND #{MemberRole.table_name}.inherited_from IN (?)", user.id, member.member_role_ids).
+                    all.
+                    each(&:destroy)
                 end
               end

app/models/mail_handler.rb +1 -1

                 if user.allowed_to?("add_#{obj.class.name.underscore}_watchers".to_sym, obj.project)
                   addresses = [email.to, email.cc].flatten.compact.uniq.collect {|a| a.strip.downcase}
                   unless addresses.empty?
-                    watchers = User.active.find(:all, :conditions => ['LOWER(mail) IN (?)', addresses])
+                    watchers = User.active.where('LOWER(mail) IN (?)', addresses).all
                     watchers.each {|w| obj.add_watcher(w)}
                   end
                 end

app/models/mailer.rb +1 -1

               #   Mailer.account_activation_request(user).deliver => sends an email to all active administrators
               def account_activation_request(user)
                 # Send the email to all active administrators
-                recipients = User.active.find(:all, :conditions => {:admin => true}).collect { |u| u.mail }.compact
+                recipients = User.active.where(:admin => true).all.collect { |u| u.mail }.compact
                 @user = user
                 @url = url_for(:controller => 'users', :action => 'index',
                                      :status => User::STATUS_REGISTERED,

app/models/member_role.rb +1 -1

               end
               def remove_role_from_group_users
-                MemberRole.find(:all, :conditions => { :inherited_from => id }).group_by(&:member).each do |member, member_roles|
+                MemberRole.where(:inherited_from => id).all.group_by(&:member).each do |member, member_roles|
                   member_roles.each(&:destroy)
                   if member && member.user
                     Watcher.prune(:user => member.user, :project => member.project)

app/models/project.rb +7 -9

               # returns latest created projects
               # non public projects will be returned only if user is a member of those
               def self.latest(user=nil, count=5)
-                visible(user).find(:all, :limit => count, :order => "created_on DESC")
+                visible(user).limit(count).order("created_on DESC").all
               end
               # Returns true if the project is visible to +user+ or to the current user.
               # by the current user
               def allowed_parents
                 return @allowed_parents if @allowed_parents
-                @allowed_parents = Project.find(:all, :conditions => Project.allowed_to_condition(User.current, :add_subprojects))
+                @allowed_parents = Project.where(Project.allowed_to_condition(User.current, :add_subprojects)).all
                 @allowed_parents = @allowed_parents - self_and_descendants
                 if User.current.allowed_to?(:add_project, nil, :global => true) || (!new_record? && parent.nil?)
                   @allowed_parents << nil
               # Closes open and locked project versions that are completed
               def close_completed_versions
                 Version.transaction do
-                  versions.find(:all, :conditions => {:status => %w(open locked)}).each do |version|
+                  versions.where(:status => %w(open locked)).all.each do |version|
                     if version.completed?
                       version.update_attribute(:status, 'closed')
                     end
               # Returns a hash of project users grouped by role
               def users_by_role
-                members.find(:all, :include => [:user, :roles]).inject({}) do |h, m|
+                members.includes(:user, :roles).all.inject({}) do |h, m|
                   m.roles.each do |r|
                     h[r] ||= []
                     h[r] << m.user
                 # Get issues sorted by root_id, lft so that parent issues
                 # get copied before their children
-                project.issues.find(:all, :order => 'root_id, lft').each do |issue|
+                project.issues.reorder('root_id, lft').all.each do |issue|
                   new_issue = Issue.new
                   new_issue.copy_from(issue, :subtasks => false, :link => false)
                   new_issue.project = self
               def system_activities_and_project_overrides(include_inactive=false)
                 if include_inactive
                   return TimeEntryActivity.shared.
-                    find(:all,
+                    where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
-                         :conditions => ["id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)]) +
                     self.time_entry_activities
                 else
                   return TimeEntryActivity.shared.active.
-                    find(:all,
+                    where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
-                         :conditions => ["id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)]) +
                     self.time_entry_activities.active
                 end
               end

app/models/query.rb +4 -9

               end
               def trackers
-                @trackers ||= project.nil? ? Tracker.find(:all, :order => 'position') : project.rolled_up_trackers
+                @trackers ||= project.nil? ? Tracker.sorted.all : project.rolled_up_trackers
               end
               # Returns a hash of localized labels for all filter operators
                 @available_filters = {
                   "status_id" => {
                     :type => :list_status, :order => 0,
-                    :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] }
+                    :values => IssueStatus.sorted.all.collect{|s| [s.name, s.id.to_s] }
                    },
                   "tracker_id" => {
                     :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] }
                                                  }
                     }
                   end
-                  add_custom_fields_filters(
+                  add_custom_fields_filters(IssueCustomField.where(:is_filter => true, :is_for_all => true).all)
-                               IssueCustomField.find(:all,
-                                                     :conditions => {
-                                                        :is_filter => true,
-                                                        :is_for_all => true
-                                                     }))
                 end
                 add_associations_custom_fields_filters :project, :author, :assigned_to, :fixed_version
                 if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
                 @available_columns = ::Query.available_columns.dup
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
-                                        IssueCustomField.find(:all)
+                                        IssueCustomField.all
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
                 if User.current.allowed_to?(:view_time_entries, project, :global => true)

app/models/repository.rb +1 -1

               # scan changeset comments to find related and fixed issues for all repositories
               def self.scan_changesets_for_issue_ids
-                find(:all).each(&:scan_changesets_for_issue_ids)
+                all.each(&:scan_changesets_for_issue_ids)
               end
               def self.scm_name

app/models/repository/mercurial.rb +6 -5

               # Sqlite3 and PostgreSQL pass.
               # Is this MySQL bug?
               def latest_changesets(path, rev, limit=10)
-                changesets.find(:all,
+                changesets.
-                                :include    => :user,
+                  includes(:user).
-                                :conditions => latest_changesets_cond(path, rev, limit),
+                  where(latest_changesets_cond(path, rev, limit)).
-                                :limit      => limit,
+                  limit(limit).
-                                :order      => "#{Changeset.table_name}.id DESC")
+                  order("#{Changeset.table_name}.id DESC").
+                  all
               end
               def latest_changesets_cond(path, rev, limit)

app/models/watcher.rb +2 -2

                   prune_single_user(options[:user], options)
                 else
                   pruned = 0
-                  User.find(:all, :conditions => "id IN (SELECT DISTINCT user_id FROM #{table_name})").each do |user|
+                  User.where("id IN (SELECT DISTINCT user_id FROM #{table_name})").all.each do |user|
                     pruned += prune_single_user(user, options)
                   end
                   pruned
               def self.prune_single_user(user, options={})
                 return unless user.is_a?(User)
                 pruned = 0
-                find(:all, :conditions => {:user_id => user.id}).each do |watcher|
+                where(:user_id => user.id).all.each do |watcher|
                   next if watcher.watchable.nil?
                   if options.has_key?(:project)

app/views/groups/_memberships.html.erb +1 -1

             <% roles = Role.find_all_givable %>
-            <% projects = Project.active.find(:all, :order => 'lft') %>
+            <% projects = Project.active.all %>
             <div class="splitcontentleft">
             <% if @group.memberships.any? %>

app/views/projects/settings/_members.html.erb +1 -1

             <%= error_messages_for 'member' %>
             <% roles = Role.find_all_givable
-               members = @project.member_principals.find(:all, :include => [:roles, :principal]).sort %>
+               members = @project.member_principals.includes(:roles, :principal).all.sort %>
             <div class="splitcontentleft">
             <% if members.any? %>

app/views/settings/_repositories.html.erb +1 -1

             <p><%= setting_text_field :commit_fix_keywords, :size => 30 %>
             &nbsp;<%= l(:label_applied_status) %>: <%= setting_select :commit_fix_status_id,
                                                                       [["", 0]] +
-                                                                          IssueStatus.find(:all).collect{
+                                                                          IssueStatus.sorted.all.collect{
                                                                              |status| [status.name, status.id.to_s]
                                                                           },
                                                                       :label => false %>

app/views/users/_memberships.html.erb +1 -1

             <% roles = Role.find_all_givable %>
-            <% projects = Project.active.find(:all, :order => 'lft') %>
+            <% projects = Project.active.all %>
             <div class="splitcontentleft">
             <% if @user.memberships.any? %>

lib/plugins/acts_as_customizable/lib/acts_as_customizable.rb +1 -2

                     end
                     def available_custom_fields
-                      CustomField.find(:all, :conditions => "type = '#{self.class.name}CustomField'",
+                      CustomField.where("type = '#{self.class.name}CustomField'").sorted.all
-                                             :order => 'position')
                     end
                     # Sets the values of the object's custom fields

lib/redmine/default_data/loader.rb +5 -5

                         rejected  = IssueStatus.create!(:name => l(:default_issue_status_rejected), :is_closed => true, :is_default => false, :position => 6)
                         # Workflow
-                        Tracker.find(:all).each { |t|
+                        Tracker.all.each { |t|
-                          IssueStatus.find(:all).each { |os|
+                          IssueStatus.all.each { |os|
-                            IssueStatus.find(:all).each { |ns|
+                            IssueStatus.all.each { |ns|
                               WorkflowTransition.create!(:tracker_id => t.id, :role_id => manager.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns
                             }
                           }
                         }
-                        Tracker.find(:all).each { |t|
+                        Tracker.all.each { |t|
                           [new, in_progress, resolved, feedback].each { |os|
                             [in_progress, resolved, feedback, closed].each { |ns|
                               WorkflowTransition.create!(:tracker_id => t.id, :role_id => developer.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns
                           }
                         }
-                        Tracker.find(:all).each { |t|
+                        Tracker.all.each { |t|
                           [new, in_progress, resolved, feedback].each { |os|
                             [closed].each { |ns|
                               WorkflowTransition.create!(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

lib/redmine/helpers/time_report.rb +2 -2

                     end if @project
                     # Add list and boolean time entry custom fields
-                    TimeEntryCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
+                    TimeEntryCustomField.all.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                       @available_criteria["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'TimeEntry' AND c.customized_id = #{TimeEntry.table_name}.id ORDER BY c.value LIMIT 1)",
                                                              :format => cf.field_format,
                                                              :label => cf.name}
                     end
                     # Add list and boolean time entry activity custom fields
-                    TimeEntryActivityCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
+                    TimeEntryActivityCustomField.all.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                       @available_criteria["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Enumeration' AND c.customized_id = #{TimeEntry.table_name}.activity_id ORDER BY c.value LIMIT 1)",
                                                              :format => cf.field_format,
                                                              :label => cf.name}

lib/tasks/migrate_from_mantis.rake +7 -7

                   TRACKER_BUG = Tracker.find_by_position(1)
                   TRACKER_FEATURE = Tracker.find_by_position(2)
-                  roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
+                  roles = Role.where(:builtin => 0).order('position ASC').all
                   manager_role = roles[0]
                   developer_role = roles[1]
                   DEFAULT_ROLE = roles.last
                   User.delete_all "login <> 'admin'"
                   users_map = {}
                   users_migrated = 0
-                  MantisUser.find(:all).each do |user|
+                  MantisUser.all.each do |user|
                     u = User.new :firstname => encode(user.firstname),
                                  :lastname => encode(user.lastname),
                                  :mail => user.email,
                   projects_map = {}
                   versions_map = {}
                   categories_map = {}
-                  MantisProject.find(:all).each do |project|
+                  MantisProject.all.each do |project|
                     p = Project.new :name => encode(project.name),
                                     :description => encode(project.description)
                     p.identifier = project.identifier
                   # Bug relationships
                   print "Migrating bug relations"
-                  MantisBugRelationship.find(:all).each do |relation|
+                  MantisBugRelationship.all.each do |relation|
                     next unless issues_map[relation.source_bug_id] && issues_map[relation.destination_bug_id]
                     r = IssueRelation.new :relation_type => RELATION_TYPE_MAPPING[relation.relationship_type]
                     r.issue_from = Issue.find_by_id(issues_map[relation.source_bug_id])
                   # News
                   print "Migrating news"
                   News.destroy_all
-                  MantisNews.find(:all, :conditions => 'project_id > 0').each do |news|
+                  MantisNews.where('project_id > 0').all.each do |news|
                     next unless projects_map[news.project_id]
                     n = News.new :project_id => projects_map[news.project_id],
                                  :title => encode(news.headline[0..59]),
                   # Custom fields
                   print "Migrating custom fields"
                   IssueCustomField.destroy_all
-                  MantisCustomField.find(:all).each do |field|
+                  MantisCustomField.all.each do |field|
                     f = IssueCustomField.new :name => field.name[0..29],
                                              :field_format => CUSTOM_FIELD_TYPE_MAPPING[field.format],
                                              :min_length => field.length_min,
                     print '.'
                     STDOUT.flush
                     # Trackers association
-                    f.trackers = Tracker.find :all
+                    f.trackers = Tracker.all
                     # Projects association
                     field.projects.each do |project|

lib/tasks/migrate_from_trac.rake +6 -6

                                        'patch' =>TRACKER_FEATURE
                                        }
-                    roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
+                    roles = Role.where(:builtin => 0).order('position ASC').all
                     manager_role = roles[0]
                     developer_role = roles[1]
                     DEFAULT_ROLE = roles.last
                     # Components
                     print "Migrating components"
                     issues_category_map = {}
-                    TracComponent.find(:all).each do |component|
+                    TracComponent.all.each do |component|
                     print '.'
                     STDOUT.flush
                       c = IssueCategory.new :project => @target_project,
                     # Milestones
                     print "Migrating milestones"
                     version_map = {}
-                    TracMilestone.find(:all).each do |milestone|
+                    TracMilestone.all.each do |milestone|
                       print '.'
                       STDOUT.flush
                       # First we try to find the wiki page...
                                                     :field_format => 'string')
                       next if f.new_record?
-                      f.trackers = Tracker.find(:all)
+                      f.trackers = Tracker.all
                       f.projects << @target_project
                       custom_field_map[field.name] = f
                     end
                     r = IssueCustomField.new(:name => 'Resolution',
                                              :field_format => 'list',
                                              :is_filter => true) if r.nil?
-                    r.trackers = Tracker.find(:all)
+                    r.trackers = Tracker.all
                     r.projects << @target_project
                     r.possible_values = (r.possible_values + %w(fixed invalid wontfix duplicate worksforme)).flatten.compact.uniq
                     r.save!
                     # Wiki
                     print "Migrating wiki"
                     if wiki.save
-                      TracWikiPage.find(:all, :order => 'name, version').each do |page|
+                      TracWikiPage.order('name, version').all.each do |page|
                         # Do not migrate Trac manual wiki pages
                         next if TRAC_WIKI_PAGES.include?(page.name)
                         wiki_edit_count += 1

test/functional/roles_controller_test.rb +2 -2

                 assert_template 'index'
                 assert_not_nil assigns(:roles)
-                assert_equal Role.find(:all, :order => 'builtin, position'), assigns(:roles)
+                assert_equal Role.order('builtin, position').all, assigns(:roles)
                 assert_tag :tag => 'a', :attributes => { :href => '/roles/1/edit' },
                                         :content => 'Manager'
                 assert_template 'permissions'
                 assert_not_nil assigns(:roles)
-                assert_equal Role.find(:all, :order => 'builtin, position'), assigns(:roles)
+                assert_equal Role.order('builtin, position').all, assigns(:roles)
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'permissions[3][]',

test/functional/workflows_controller_test.rb +5 -2

               # Returns an array of status transitions that can be compared
               def status_transitions(conditions)
-                WorkflowTransition.find(:all, :conditions => conditions,
+                WorkflowTransition.
-                                    :order => 'tracker_id, role_id, old_status_id, new_status_id').collect {|w| [w.old_status, w.new_status_id]}
+                  where(conditions).
+                  order('tracker_id, role_id, old_status_id, new_status_id').
+                  all.
+                  collect {|w| [w.old_status, w.new_status_id]}
               end
             end

test/unit/helpers/application_helper_test.rb +1 -1

                   # link image
                   '!logo.gif!:http://foo.bar/' => '<a href="http://foo.bar/"><img src="/attachments/download/3" title="This is a logo" alt="This is a logo" /></a>',
                 }
-                attachments = Attachment.find(:all)
+                attachments = Attachment.all
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
               end

test/unit/issue_nested_set_test.rb +1 -1

                 c.reload
                 assert_equal 5, c.issues.count
-                ic1, ic2, ic3, ic4, ic5 = c.issues.find(:all, :order => 'subject')
+                ic1, ic2, ic3, ic4, ic5 = c.issues.order('subject').all
                 assert ic1.root?
                 assert_equal ic1, ic2.parent
                 assert_equal ic1, ic3.parent

test/unit/project_test.rb +2 -2

                 # 2 active members
                 assert_equal 2, @ecookbook.members.size
                 # and 1 is locked
-                assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size
+                assert_equal 3, Member.where('project_id = ?', @ecookbook.id).all.size
                 # some boards
                 assert @ecookbook.boards.any?
               def test_activities_should_use_the_system_activities
                 project = Project.find(1)
-                assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )
+                assert_equal project.activities, TimeEntryActivity.where(:active => true).all
               end

test/unit/repository_bazaar_test.rb +1 -1

                   @project.reload
                   assert_equal NUM_REV, @repository.changesets.count
                   # Remove changesets with revision > 5
-                  @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 2}
+                  @repository.changesets.all.each {|c| c.destroy if c.revision.to_i > 2}
                   @project.reload
                   assert_equal 2, @repository.changesets.count

test/unit/repository_cvs_test.rb +1 -1

                   assert_equal CHANGESETS_NUM, @repository.changesets.count
                   # Remove changesets with revision > 3
-                  @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 3}
+                  @repository.changesets.all.each {|c| c.destroy if c.revision.to_i > 3}
                   @project.reload
                   assert_equal 3, @repository.changesets.count
                   assert_equal %w|3 2 1|, @repository.changesets.all.collect(&:revision)

test/unit/repository_darcs_test.rb +1 -1

                   assert_equal NUM_REV, @repository.changesets.count
                   # Remove changesets with revision > 3
-                  @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 3}
+                  @repository.changesets.all.each {|c| c.destroy if c.revision.to_i > 3}
                   @project.reload
                   assert_equal 3, @repository.changesets.count

test/unit/repository_mercurial_test.rb +1 -1

                   @project.reload
                   assert_equal NUM_REV, @repository.changesets.count
                   # Remove changesets with revision > 2
-                  @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 2}
+                  @repository.changesets.all.each {|c| c.destroy if c.revision.to_i > 2}
                   @project.reload
                   assert_equal 3, @repository.changesets.count

test/unit/repository_subversion_test.rb +1 -1

                   assert_equal NUM_REV, @repository.changesets.count
                   # Remove changesets with revision > 5
-                  @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 5}
+                  @repository.changesets.all.each {|c| c.destroy if c.revision.to_i > 5}
                   @project.reload
                   assert_equal 5, @repository.changesets.count

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