jro_apps/redmine Commit - r11733:f9ddb562d58a

Cleanup of finders with :conditions option....

Jean-Philippe Lang -

r11733:f9ddb562d58a

parent child

Context file:

r11733:f9ddb562d58a

Expand all files

app/controllers/context_menus_controller.rb +1 -2

                end
                def time_entries
-                 @time_entries = TimeEntry.all(
-                    :conditions => {:id => params[:ids]}, :include => :project)
+                 @time_entries = TimeEntry.where(:id => params[:ids]).preload(:project).to_a
                  (render_404; return) unless @time_entries.present?
                  @projects = @time_entries.collect(&:project).compact.uniq

app/controllers/issues_controller.rb +1 -1

                end
                def destroy
-                 @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
+                 @hours = TimeEntry.where(:issue_id => @issues.map(&:id)).sum(:hours).to_f
                  if @hours > 0
                    case params[:todo]
                    when 'destroy'

app/controllers/messages_controller.rb +1 -1

                  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])
+                   offset = @topic.children.where("#{Message.table_name}.id < ?", params[:r].to_i).count
                    page = 1 + offset / REPLIES_PER_PAGE
                  end

app/controllers/projects_controller.rb +1 -1

                  @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
+                   @total_hours = TimeEntry.visible.where(cond).sum(:hours).to_f
                  end
                  @key = User.current.rss_key

app/controllers/repositories_controller.rb +11 -8

                  @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_day = Changeset.
+                   where("repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
+                   group(:commit_date).
+                   count
                  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_day = Change.
+                   joins(:changeset).
+                   where("#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
+                   group(:commit_date).
+                   count
                  changes_by_month = [0] * 12
                  changes_by_day.each {|c| changes_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                end
                def graph_commits_per_author(repository)
-                 commits_by_author = Changeset.count(:all, :group => :committer, :conditions => ["repository_id = ?", repository.id])
+                 commits_by_author = Changeset.where("repository_id = ?", repository.id).group(:committer).count
                  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])
+                 changes_by_author = Change.joins(:changeset).where("#{Changeset.table_name}.repository_id = ?", repository.id).group(:committer).count
                  h = changes_by_author.inject({}) {|o, i| o[i.first] = i.last; o}
                  fields = commits_by_author.collect {|r| r.first}

app/controllers/sys_controller.rb +1 -5

                before_filter :check_enabled
                def projects
-                 p = Project.active.has_module(:repository).find(
-                                :all,
-                                :include => :repository,
-                                :order => "#{Project.table_name}.identifier"
+                              )
+                 p = Project.active.has_module(:repository).order("#{Project.table_name}.identifier").preload(:repository).all
                  # extra_info attribute from repository breaks activeresource client
                  render :xml => p.to_xml(
                                     :only => [:id, :identifier, :name, :is_public, :status],

app/controllers/users_controller.rb +1 -1

                def show
                  # show projects based on current user visibility
-                 @memberships = @user.memberships.all(:conditions => Project.visible_condition(User.current))
+                 @memberships = @user.memberships.where(Project.visible_condition(User.current)).all
                  events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                  @events_by_day = events.group_by(&:event_date)

app/controllers/versions_controller.rb +5 -5

                      @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 = Issue.visible.
+                         includes(:project, :tracker).
+                         preload(:status, :priority, :fixed_version).
+                         where(: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?}

app/helpers/queries_helper.rb +1 -1

                  if !params[:query_id].blank?
                    cond = "project_id IS NULL"
                    cond << " OR project_id = #{@project.id}" if @project
-                   @query = IssueQuery.find(params[:query_id], :conditions => cond)
+                   @query = IssueQuery.where(cond).find(params[:query_id])
                    raise ::Unauthorized unless @query.visible?
                    @query.project = @project
                    session[:query] = {:id => @query.id, :project_id => @query.project_id}

app/helpers/versions_helper.rb +2 -5

                  h = Hash.new {|k,v| k[v] = [0, 0]}
                  begin
                    # Total issue count
-                   Issue.count(:group => criteria,
-                               :conditions => ["#{Issue.table_name}.fixed_version_id = ?", version.id]).each {|c,s| h[c][0] = s}
+                   Issue.where(:fixed_version_id => version.id).group(criteria).count.each {|c,s| h[c][0] = s}
                    # Open issues count
-                   Issue.count(:group => criteria,
-                               :include => :status,
-                               :conditions => ["#{Issue.table_name}.fixed_version_id = ? AND #{IssueStatus.table_name}.is_closed = ?", version.id, false]).each {|c,s| h[c][1] = s}
+                   Issue.open.where(:fixed_version_id => version.id).group(criteria).count.each {|c,s| h[c][1] = s}
                  rescue ActiveRecord::RecordNotFound
                  # When grouping by an association, Rails throws this exception if there's no result (bug)
                  end

app/models/issue.rb +7 -8

                # Preloads relations for a collection of issues
                def self.load_relations(issues)
                  if issues.any?
-                   relations = IssueRelation.all(:conditions => ["issue_from_id IN (:ids) OR issue_to_id IN (:ids)", {:ids => issues.map(&:id)}])
+                   relations = IssueRelation.where("issue_from_id IN (:ids) OR issue_to_id IN (:ids)", :ids => issues.map(&:id)).all
                    issues.each do |issue|
                      issue.instance_variable_set "@relations", relations.select {|r| r.issue_from_id == issue.id || r.issue_to_id == issue.id}
                    end
                # Preloads visible spent time for a collection of issues
                def self.load_visible_spent_hours(issues, user=User.current)
                  if issues.any?
-                   hours_by_issue_id = TimeEntry.visible(user).sum(:hours, :group => :issue_id)
+                   hours_by_issue_id = TimeEntry.visible(user).group(:issue_id).sum(:hours)
                    issues.each do |issue|
                      issue.instance_variable_set "@spent_hours", (hours_by_issue_id[issue.id] || 0)
                    end
                # Finds an issue relation given its id.
                def find_relation(relation_id)
-                 IssueRelation.find(relation_id, :conditions => ["issue_to_id = ? OR issue_from_id = ?", id, id])
+                 IssueRelation.where("issue_to_id = ? OR issue_from_id = ?", id, id).find(relation_id)
                end
                # Returns all the other issues that depend on the issue
                def self.update_versions(conditions=nil)
                  # Only need to update issues with a fixed_version from
                  # a different project and that is not systemwide shared
-                 Issue.scoped(:conditions => conditions).all(
-                   :conditions => "#{Issue.table_name}.fixed_version_id IS NOT NULL" +
+                 Issue.includes(:project, :fixed_version).
+                   where("#{Issue.table_name}.fixed_version_id IS NOT NULL" +
                      " AND #{Issue.table_name}.project_id <> #{Version.table_name}.project_id" +
-                     " AND #{Version.table_name}.sharing <> 'system'",
-                   :include => [:project, :fixed_version]
-                 ).each do |issue|
+                     " AND #{Version.table_name}.sharing <> 'system'").
+                   where(conditions).each do |issue|
                    next if issue.project.nil? || issue.fixed_version.nil?
                    unless issue.project.shared_versions.include?(issue.fixed_version)
                      issue.init_journal(User.current)

app/models/issue_query.rb +40 -27

                # Returns the issue count
                def issue_count
-                 Issue.visible.count(:include => [:status, :project], :conditions => statement)
+                 Issue.visible.joins(:status, :project).where(statement).count
                rescue ::ActiveRecord::StatementInvalid => e
                  raise StatementInvalid.new(e.message)
                end
                  if grouped?
                    begin
                      # Rails3 will raise an (unexpected) RecordNotFound if there's only a nil group value
-                     r = Issue.visible.count(:joins => joins_for_order_statement(group_by_statement), :group => group_by_statement, :include => [:status, :project], :conditions => statement)
+                     r = Issue.visible.
+                       joins(:status, :project).
+                       where(statement).
+                       joins(joins_for_order_statement(group_by_statement)).
+                       group(group_by_statement).
+                       count
                    rescue ActiveRecord::RecordNotFound
                      r = {nil => issue_count}
                    end
                def issues(options={})
                  order_option = [group_by_sort_order, options[:order]].flatten.reject(&:blank?)
-                 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.join(',')),
-                   :limit  => options[:limit],
-                   :offset => options[:offset]
+                 )
+                 issues = Issue.visible.
+                   joins(:status, :project).
+                   where(statement).
+                   includes(([:status, :project] + (options[:include] || [])).uniq).
+                   where(options[:conditions]).
+                   order(order_option).
+                   joins(joins_for_order_statement(order_option.join(','))).
+                   limit(options[:limit]).
+                   offset(options[:offset]).
+                   all
                  if has_column?(:spent_hours)
                    Issue.load_visible_spent_hours(issues)
                def issue_ids(options={})
                  order_option = [group_by_sort_order, options[:order]].flatten.reject(&:blank?)
-                 Issue.visible.scoped(:conditions => options[:conditions]).scoped(:include => ([:status, :project] + (options[:include] || [])).uniq,
-                                  :conditions => statement,
-                                  :order => order_option,
-                                  :joins => joins_for_order_statement(order_option.join(',')),
-                                  :limit  => options[:limit],
-                                  :offset => options[:offset]).find_ids
+                 Issue.visible.
+                   joins(:status, :project).
+                   where(statement).
+                   includes(([:status, :project] + (options[:include] || [])).uniq).
+                   where(options[:conditions]).
+                   order(order_option).
+                   joins(joins_for_order_statement(order_option.join(','))).
+                   limit(options[:limit]).
+                   offset(options[:offset]).
+                   find_ids
                rescue ::ActiveRecord::StatementInvalid => e
                  raise StatementInvalid.new(e.message)
                end
                # Returns the journals
                # Valid options are :order, :offset, :limit
                def journals(options={})
-                 Journal.visible.all(
-                   :include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
-                   :conditions => statement,
-                   :order => options[:order],
-                   :limit => options[:limit],
-                   :offset => options[:offset]
+                 )
+                 Journal.visible.
+                   joins(:issue => [:project, :status]).
+                   where(statement).
+                   order(options[:order]).
+                   limit(options[:limit]).
+                   offset(options[:offset]).
+                   preload(:details, :user, {:issue => [:project, :author, :tracker, :status]}).
+                   all
                rescue ::ActiveRecord::StatementInvalid => e
                  raise StatementInvalid.new(e.message)
                end
                # Returns the versions
                # Valid options are :conditions
                def versions(options={})
-                 Version.visible.where(options[:conditions]).all(
-                   :include => :project,
-                   :conditions => project_statement
+                 )
+                 Version.visible.
+                   where(project_statement).
+                   where(options[:conditions]).
+                   includes(:project).
+                   all
                rescue ::ActiveRecord::StatementInvalid => e
                  raise StatementInvalid.new(e.message)
                end

app/models/repository.rb +12 -13

                # Default behaviour is to search in cached changesets
                def latest_changesets(path, rev, limit=10)
                  if path.blank?
-                   changesets.find(
-                      :all,
-                      :include => :user,
-                      :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC",
-                      :limit => limit)
+                   changesets.
+                     reorder("#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC").
+                     limit(limit).
+                     preload(:user).
+                     all
                  else
-                   filechanges.find(
-                      :all,
-                      :include => {:changeset => :user},
-                      :conditions => ["path = ?", path.with_leading_slash],
-                      :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC",
-                      :limit => limit
-                    ).collect(&:changeset)
+                   filechanges.
+                     where("path = ?", path.with_leading_slash).
+                     reorder("#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC").
+                     limit(limit).
+                     preload(:changeset => :user).
+                     collect(&:changeset)
                  end
                end
                end
                def set_as_default?
-                 new_record? && project && !Repository.first(:conditions => {:project_id => project.id})
+                 new_record? && project && Repository.where(:project_id => project.id).empty?
                end
                protected

app/models/repository/bazaar.rb +5 -9

                        full_path = File.join(root_url, e.path)
                        e.size = File.stat(full_path).size if File.file?(full_path)
                      end
-                     c = Change.find(
-                            :first,
-                            :include    => :changeset,
-                            :conditions => [
-                                "#{Change.table_name}.revision = ? and #{Changeset.table_name}.repository_id = ?",
-                                e.lastrev.revision,
-                                id
-                                ],
-                            :order => "#{Changeset.table_name}.revision DESC")
+                     c = Change.
+                           includes(:changeset).
+                           where("#{Change.table_name}.revision = ? and #{Changeset.table_name}.repository_id = ?", e.lastrev.revision, id).
+                           order("#{Changeset.table_name}.revision DESC").
+                           first
                      if c
                        e.lastrev.identifier = c.changeset.revision
                        e.lastrev.name       = c.changeset.revision

app/models/repository/cvs.rb +9 -12

              	                           )
                        cmt = Changeset.normalize_comments(revision.message, repo_log_encoding)
                        author_utf8 = Changeset.to_utf8(revision.author, repo_log_encoding)
-                       cs  = changesets.find(
-                         :first,
-                         :conditions => {
-                             :committed_on => tmp_time - time_delta .. tmp_time + time_delta,
-                             :committer    => author_utf8,
-                             :comments     => cmt
+                             }
+                          )
+                       cs  = changesets.where(
+                               :committed_on => tmp_time - time_delta .. tmp_time + time_delta,
+                               :committer    => author_utf8,
+                               :comments     => cmt
+                             ).first
                        # create a new changeset....
                        unless cs
                          # we use a temporaray revision number here (just for inserting)
                    end
                    # Renumber new changesets in chronological order
-                   Changeset.all(
-                           :order => 'committed_on ASC, id ASC',
-                           :conditions => ["repository_id = ? AND revision LIKE 'tmp%'", id]
-                        ).each do |changeset|
+                   Changeset.
+                     order('committed_on ASC, id ASC').
+                     where("repository_id = ? AND revision LIKE 'tmp%'", id).
+                     each do |changeset|
                      changeset.update_attribute :revision, next_revision_number
                    end
                  end # transaction

app/models/repository/git.rb +3 -14

                  offset = 0
                  revisions_copy = revisions.clone # revisions will change
                  while offset < revisions_copy.size
-                   recent_changesets_slice = changesets.find(
-                                                  :all,
-                                                  :conditions => [
-                                                     'scmid IN (?)',
-                                                     revisions_copy.slice(offset, limit).map{|x| x.scmid}
+                                                   ]
+                                                 )
+                   scmids = revisions_copy.slice(offset, limit).map{|x| x.scmid}
+                   recent_changesets_slice = changesets.where(:scmid => scmids).all
                    # Subtract revisions that redmine already knows about
                    recent_revisions = recent_changesets_slice.map{|c| c.scmid}
                    revisions.reject!{|r| recent_revisions.include?(r.scmid)}
                  revisions = scm.revisions(path, nil, rev, :limit => limit, :all => false)
                  return [] if revisions.nil? || revisions.empty?
-                 changesets.find(
-                   :all,
-                   :conditions => [
-                     "scmid IN (?)",
-                     revisions.map!{|c| c.scmid}
+                   ]
+                 )
+                 changesets.where(:scmid => revisions.map {|c| c.scmid}).all
                end
                def clear_extra_info_of_changesets

app/models/wiki.rb +2 -2

                  @page_found_with_redirect = false
                  title = start_page if title.blank?
                  title = Wiki.titleize(title)
-                 page = pages.first(:conditions => ["LOWER(title) = LOWER(?)", title])
+                 page = pages.where("LOWER(title) = LOWER(?)", title).first
                  if !page && !(options[:with_redirect] == false)
                    # search for a redirect
-                   redirect = redirects.first(:conditions => ["LOWER(title) = LOWER(?)", title])
+                   redirect = redirects.where("LOWER(title) = LOWER(?)", title).first
                    if redirect
                      page = find_page(redirect.redirects_to, :with_redirect => false)
                      @page_found_with_redirect = true

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

                              :from => @events_by_day.keys.first %></h3>
              <p>
-             <%=l(:label_reported_issues)%>: <%= Issue.count(:conditions => ["author_id=?", @user.id]) %>
+             <%=l(:label_reported_issues)%>: <%= Issue.where(:author_id => @user.id).count %>
              </p>
              <div id="activity">

lib/redmine/helpers/gantt.rb +6 -5

                      ids = issues.collect(&:project).uniq.collect(&:id)
                      if ids.any?
                        # All issues projects and their visible ancestors
-                       @projects = Project.visible.all(
-                         :joins => "LEFT JOIN #{Project.table_name} child ON #{Project.table_name}.lft <= child.lft AND #{Project.table_name}.rgt >= child.rgt",
-                         :conditions => ["child.id IN (?)", ids],
-                         :order => "#{Project.table_name}.lft ASC"
-                       ).uniq
+                       @projects = Project.visible.
+                         joins("LEFT JOIN #{Project.table_name} child ON #{Project.table_name}.lft <= child.lft AND #{Project.table_name}.rgt >= child.rgt").
+                         where("child.id IN (?)", ids).
+                         order("#{Project.table_name}.lft ASC").
+                         uniq.
+                         all
                      else
                        @projects = []
                      end

test/functional/custom_fields_controller_test.rb +1 -1

                end
                def test_destroy
-                 custom_values_count = CustomValue.count(:conditions => {:custom_field_id => 1})
+                 custom_values_count = CustomValue.where(:custom_field_id => 1).count
                  assert custom_values_count > 0
                  assert_difference 'CustomField.count', -1 do

test/functional/issues_controller_test.rb +2 -2

                def test_bulk_copy_should_allow_changing_the_issue_attributes
                  # Fixes random test failure with Mysql
-                 # where Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
+                 # where Issue.where(:project_id => 2).limit(2).order('id desc')
                  # doesn't return the expected results
                  Issue.delete_all("project_id=2")
                    end
                  end
-                 copied_issues = Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
+                 copied_issues = Issue.where(:project_id => 2).limit(2).order('id desc').to_a
                  assert_equal 2, copied_issues.size
                  copied_issues.each do |issue|
                    assert_equal 2, issue.project_id, "Project is incorrect"

test/functional/projects_controller_test.rb +1 -1

                  assert_response :success
                  assert_template 'common/feed'
                  assert_select 'feed>title', :text => 'Redmine: Latest projects'
-                 assert_select 'feed>entry', :count => Project.count(:conditions => Project.visible_condition(User.current))
+                 assert_select 'feed>entry', :count => Project.visible(User.current).count
                end
                test "#index by non-admin user with view_time_entries permission should show overall spent time link" do

test/functional/repositories_controller_test.rb +1 -1

                          :revision => 100,
                          :comments => 'Committed by foo.'
                        )
-                 assert_no_difference "Changeset.count(:conditions => 'user_id = 3')" do
+                 assert_no_difference "Changeset.where(:user_id => 3).count" do
                    post :committers, :id => 10, :committers => { '0' => ['foo', '2'], '1' => ['dlopper', '3']}
                    assert_response 302
                    assert_equal User.find(2), c.reload.user

test/functional/workflows_controller_test.rb +4 -4

                  assert_response :success
                  assert_template 'index'
-                 count = WorkflowTransition.count(:all, :conditions => 'role_id = 1 AND tracker_id = 2')
+                 count = WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count
                  assert_tag :tag => 'a', :content => count.to_s,
                                          :attributes => { :href => '/workflows/edit?role_id=1&amp;tracker_id=2' }
                end
                end
                def test_clear_workflow
-                 assert WorkflowTransition.count(:conditions => {:tracker_id => 1, :role_id => 2}) > 0
+                 assert WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count > 0
-                 post :edit, :role_id => 2, :tracker_id => 1
-                 assert_equal 0, WorkflowTransition.count(:conditions => {:tracker_id => 1, :role_id => 2})
+                 post :edit, :role_id => 1, :tracker_id => 2
+                 assert_equal 0, WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count
                end
                def test_get_permissions

test/integration/api_test/issue_categories_test.rb +2 -2

                end
                test "DELETE /issue_categories/:id.xml should reassign issues with :reassign_to_id param" do
-                 issue_count = Issue.count(:conditions => {:category_id => 1})
+                 issue_count = Issue.where(:category_id => 1).count
                  assert issue_count > 0
                  assert_difference 'IssueCategory.count', -1 do
-                   assert_difference 'Issue.count(:conditions => {:category_id => 2})', 3 do
+                   assert_difference 'Issue.where(:category_id => 2).count', 3 do
                      delete '/issue_categories/1.xml', {:reassign_to_id => 2}, credentials('jsmith')
                    end
                  end

test/integration/api_test/issues_test.rb +7 -7

                      get '/issues.xml',
                          {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='},
                           :v => {:cf_1 => ['MySQL']}}
-                     expected_ids = Issue.visible.all(
-                         :include => :custom_values,
-                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
+                     expected_ids = Issue.visible.
+                         joins(:custom_values).
+                         where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                      assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                         ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                      end
                    should "show only issues with the custom field value" do
                      get '/issues.xml', { :cf_1 => 'MySQL' }
-                     expected_ids = Issue.visible.all(
-                         :include => :custom_values,
-                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
+                     expected_ids = Issue.visible.
+                         joins(:custom_values).
+                         where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                      assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                        ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  should "show only issues with the status_id" do
                    get '/issues.xml?status_id=5'
-                   expected_ids = Issue.visible.all(:conditions => {:status_id => 5}).map(&:id)
+                   expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
                    assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                       ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }

test/test_helper.rb +1 -1

                end
                def change_user_password(login, new_password)
-                 user = User.first(:conditions => {:login => login})
+                 user = User.where(:login => login).first
                  user.password, user.password_confirmation = new_password, new_password
                  user.save!
                end

test/unit/board_test.rb +1 -1

                      end
                    end
                  end
-                 assert_equal 0, Message.count(:conditions => {:board_id => 1})
+                 assert_equal 0, Message.where(:board_id => 1).count
                end
                def test_destroy_should_nullify_children

test/unit/changeset_test.rb +2 -4

                def test_ref_keywords_any
                  ActionMailer::Base.deliveries.clear
-                 Setting.commit_fix_status_id = IssueStatus.find(
-                                                :first, :conditions => ["is_closed = ?", true]).id
+                 Setting.commit_fix_status_id = IssueStatus.where(:is_closed => true).first.id
                  Setting.commit_fix_done_ratio = '90'
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_fix_keywords = 'fixes , closes'
                end
                def test_ref_keywords_closing_with_timelog
-                 Setting.commit_fix_status_id = IssueStatus.find(
-                                                 :first, :conditions => ["is_closed = ?", true]).id
+                 Setting.commit_fix_status_id = IssueStatus.where(:is_closed => true).first.id
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_fix_keywords = 'fixes , closes'
                  Setting.commit_logtime_enabled = '1'

test/unit/issue_status_test.rb +4 -4

                  assert_difference 'IssueStatus.count', -1 do
                    assert status.destroy
                  end
-                 assert_nil WorkflowTransition.first(:conditions => {:old_status_id => status.id})
-                 assert_nil WorkflowTransition.first(:conditions => {:new_status_id => status.id})
+                 assert_nil WorkflowTransition.where(:old_status_id => status.id).first
+                 assert_nil WorkflowTransition.where(:new_status_id => status.id).first
                end
                def test_destroy_status_in_use
                  with_settings :issue_done_ratio => 'issue_field' do
                    IssueStatus.update_issue_done_ratios
-                   assert_equal 0, Issue.count(:conditions => {:done_ratio => 50})
+                   assert_equal 0, Issue.where(:done_ratio => 50).count
                  end
                end
                  with_settings :issue_done_ratio => 'issue_status' do
                    IssueStatus.update_issue_done_ratios
-                   issues = Issue.all(:conditions => {:status_id => 1})
+                   issues = Issue.where(:status_id => 1).all
                    assert_equal [50], issues.map {|issue| issue.read_attribute(:done_ratio)}.uniq
                  end
                end

test/unit/project_copy_test.rb +5 -5

                    assert_equal @project, issue.project
                  end
-                 copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})
+                 copied_issue = @project.issues.where(:subject => "copy issue status").first
                  assert copied_issue
                  assert copied_issue.status
                  assert_equal "Closed", copied_issue.status.name
                  assert @project.copy(@source_project)
                  @project.reload
-                 copied_issue = @project.issues.first(:conditions => {:subject => "copy issues assigned to a locked version"})
+                 copied_issue = @project.issues.where(:subject => "copy issues assigned to a locked version").first
                  assert copied_issue
                  assert copied_issue.fixed_version
                  assert @project.copy(@source_project)
                  @project.reload
-                 copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})
+                 copied_issue = @project.issues.where(:subject => "change the new issues to use the copied version").first
                  assert copied_issue
                  assert copied_issue.fixed_version
                  assert @project.copy(@source_project)
                  @project.reload
-                 copied_issue = @project.issues.first(:conditions => {:subject => "keep target shared versions"})
+                 copied_issue = @project.issues.where(:subject => "keep target shared versions").first
                  assert copied_issue
                  assert_equal assigned_version, copied_issue.fixed_version
                  @source_project.issues << issue
                  assert @project.copy(@source_project)
-                 copied_issue = @project.issues.first(:conditions => {:subject => "copy with attachment"})
+                 copied_issue = @project.issues.where(:subject => "copy with attachment").first
                  assert_not_nil copied_issue
                  assert_equal 1, copied_issue.attachments.count, "Attachment not copied"
                  assert_equal "testfile.txt", copied_issue.attachments.first.filename

test/unit/project_test.rb +6 -6

                  # Assign an issue of a project to a version of a child project
                  Issue.find(4).update_attribute :fixed_version_id, 4
-                 assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do
+                 assert_no_difference "Project.where(:status => Project::STATUS_ARCHIVED).count" do
                    assert_equal false, @ecookbook.archive
                  end
                  @ecookbook.reload
                  # make sure that the project non longer exists
                  assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
                  # make sure related data was removed
-                 assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})
-                 assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})
-                 assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})
+                 assert_nil Member.where(:project_id => @ecookbook.id).first
+                 assert_nil Board.where(:project_id => @ecookbook.id).first
+                 assert_nil Issue.where(:project_id => @ecookbook.id).first
                end
                def test_destroy_should_destroy_subtasks
                  assert_equal 0, Board.count
                  assert_equal 0, Message.count
                  assert_equal 0, News.count
-                 assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")
+                 assert_equal 0, Query.where("project_id IS NOT NULL").count
                  assert_equal 0, Repository.count
                  assert_equal 0, Changeset.count
                  assert_equal 0, Change.count
                  assert_equal 0, WikiContent::Version.count
                  assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size
                  assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size
-                 assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})
+                 assert_equal 0, CustomValue.where(:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']).count
                end
                def test_move_an_orphan_project_to_a_root_project

test/unit/query_test.rb +1 -1

                  query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
                  result = query.issues
-                 assert_equal Issue.visible.all(:conditions => {:assigned_to_id => ([2] + user.reload.group_ids)}).sort_by(&:id), result.sort_by(&:id)
+                 assert_equal Issue.visible.where(:assigned_to_id => ([2] + user.reload.group_ids)).sort_by(&:id), result.sort_by(&:id)
                  assert result.include?(i1)
                  assert result.include?(i2)

test/unit/repository_test.rb +2 -4

                  Setting.default_language = 'en'
                  # choosing a status to apply to fix issues
-                 Setting.commit_fix_status_id = IssueStatus.find(
-                                                  :first,
-                                                  :conditions => ["is_closed = ?", true]).id
+                 Setting.commit_fix_status_id = IssueStatus.where(:is_closed => true).first.id
                  Setting.commit_fix_done_ratio = "90"
                  Setting.commit_ref_keywords = 'refs , references, IssueID'
                  Setting.commit_fix_keywords = 'fixes , closes'
                end
                def test_manual_user_mapping
-                 assert_no_difference "Changeset.count(:conditions => 'user_id <> 2')" do
+                 assert_no_difference "Changeset.where('user_id <> 2').count" do
                    c = Changeset.create!(
                            :repository => @repository,
                            :committer => 'foo',

test/unit/search_test.rb +1 -1

                def test_search_issue_with_multiple_hits_in_journals
                  i = Issue.find(1)
-                 assert_equal 2, i.journals.count(:all, :conditions => "notes LIKE '%notes%'")
+                 assert_equal 2, i.journals.where("notes LIKE '%notes%'").count
                  r = Issue.search('%notes%').first
                  assert_equal 1, r.size

test/unit/user_test.rb +1 -1

                def test_generate
                  User.generate!(:firstname => 'Testing connection')
                  User.generate!(:firstname => 'Testing connection')
-                 assert_equal 2, User.count(:all, :conditions => {:firstname => 'Testing connection'})
+                 assert_equal 2, User.where(:firstname => 'Testing connection').count
                end
                def test_truth

test/unit/workflow_test.rb +3 -3

                    WorkflowTransition.copy(Tracker.find(2), Role.find(1), Tracker.find(3), Role.find(2))
                  end
-                 assert WorkflowTransition.first(:conditions => {:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false})
-                 assert WorkflowTransition.first(:conditions => {:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 3, :author => false, :assignee => true})
-                 assert WorkflowTransition.first(:conditions => {:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 4, :author => true, :assignee => false})
+                 assert WorkflowTransition.where(:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false).first
+                 assert WorkflowTransition.where(:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 3, :author => false, :assignee => true).first
+                 assert WorkflowTransition.where(:role_id => 2, :tracker_id => 3, :old_status_id => 1, :new_status_id => 4, :author => true, :assignee => false).first
                end
                def test_workflow_permission_should_validate_rule

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