Merge tag 'v4.2.0-rc1'

app/models/account.rb

@@ -125,10 +125,10 @@ class Account < ApplicationRecord
   scope :matches_domain, ->(value) { where(arel_table[:domain].matches("%#{value}%")) }
   scope :without_unapproved, -> { left_outer_joins(:user).merge(User.approved.confirmed).or(remote) }
   scope :searchable, -> { without_unapproved.without_suspended.where(moved_to_account_id: nil) }
-  scope :discoverable, -> { searchable.without_silenced.where(discoverable: true).left_outer_joins(:account_stat) }
+  scope :discoverable, -> { searchable.without_silenced.where(discoverable: true).joins(:account_stat) }
   scope :followable_by, ->(account) { joins(arel_table.join(Follow.arel_table, Arel::Nodes::OuterJoin).on(arel_table[:id].eq(Follow.arel_table[:target_account_id]).and(Follow.arel_table[:account_id].eq(account.id))).join_sources).where(Follow.arel_table[:id].eq(nil)).joins(arel_table.join(FollowRequest.arel_table, Arel::Nodes::OuterJoin).on(arel_table[:id].eq(FollowRequest.arel_table[:target_account_id]).and(FollowRequest.arel_table[:account_id].eq(account.id))).join_sources).where(FollowRequest.arel_table[:id].eq(nil)) }
-  scope :by_recent_status, -> { order(Arel.sql('(case when account_stats.last_status_at is null then 1 else 0 end) asc, account_stats.last_status_at desc, accounts.id desc')) }
-  scope :by_recent_sign_in, -> { order(Arel.sql('(case when users.current_sign_in_at is null then 1 else 0 end) asc, users.current_sign_in_at desc, accounts.id desc')) }
+  scope :by_recent_status, -> { order(Arel.sql('account_stats.last_status_at DESC NULLS LAST')) }
+  scope :by_recent_sign_in, -> { order(Arel.sql('users.current_sign_in_at DESC NULLS LAST')) }
   scope :popular, -> { order('account_stats.followers_count desc') }
   scope :by_domain_and_subdomains, ->(domain) { where(domain: Instance.by_domain_and_subdomains(domain).select(:domain)) }
   scope :not_excluded_by_account, ->(account) { where.not(id: account.excluded_from_timeline_account_ids) }

app/models/account_statuses_filter.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-class AccountStatusesFilter
-  KEYS = %i(
-    pinned
-    tagged
-    only_media
-    exclude_replies
-    exclude_reblogs
-  ).freeze
-
-  attr_reader :params, :account, :current_account
-
-  def initialize(account, current_account, params = {})
-    @account         = account
-    @current_account = current_account
-    @params          = params
-  end
-
-  def results
-    scope = initial_scope
-
-    scope.merge!(pinned_scope)     if pinned?
-    scope.merge!(only_media_scope) if only_media?
-    scope.merge!(no_replies_scope) if exclude_replies?
-    scope.merge!(no_reblogs_scope) if exclude_reblogs?
-    scope.merge!(hashtag_scope)    if tagged?
-
-    scope
-  end
-
-  private
-
-  def initial_scope
-    return Status.none if suspended?
-
-    if anonymous?
-      account.statuses.where(visibility: %i(public unlisted))
-    elsif author?
-      account.statuses.all # NOTE: #merge! does not work without the #all
-    elsif blocked?
-      Status.none
-    else
-      filtered_scope
-    end
-  end
-
-  def filtered_scope
-    scope = account.statuses.left_outer_joins(:mentions)
-
-    scope.merge!(scope.where(visibility: follower? ? %i(public unlisted private) : %i(public unlisted)).or(scope.where(mentions: { account_id: current_account.id })).group(Status.arel_table[:id]))
-    scope.merge!(filtered_reblogs_scope) if reblogs_may_occur?
-
-    scope
-  end
-
-  def filtered_reblogs_scope
-    Status.left_outer_joins(:reblog).where(reblog_of_id: nil).or(Status.where.not(reblogs_statuses: { account_id: current_account.excluded_from_timeline_account_ids }))
-  end
-
-  def only_media_scope
-    Status.joins(:media_attachments).merge(account.media_attachments.reorder(nil)).group(Status.arel_table[:id])
-  end
-
-  def no_replies_scope
-    Status.without_replies
-  end
-
-  def no_reblogs_scope
-    Status.without_reblogs
-  end
-
-  def pinned_scope
-    account.pinned_statuses.group(Status.arel_table[:id], StatusPin.arel_table[:created_at])
-  end
-
-  def hashtag_scope
-    tag = Tag.find_normalized(params[:tagged])
-
-    if tag
-      Status.tagged_with(tag.id)
-    else
-      Status.none
-    end
-  end
-
-  def suspended?
-    account.suspended?
-  end
-
-  def anonymous?
-    current_account.nil?
-  end
-
-  def author?
-    current_account.id == account.id
-  end
-
-  def blocked?
-    account.blocking?(current_account) || (current_account.domain.present? && account.domain_blocking?(current_account.domain))
-  end
-
-  def follower?
-    current_account.following?(account)
-  end
-
-  def reblogs_may_occur?
-    !exclude_reblogs? && !only_media? && !tagged?
-  end
-
-  def pinned?
-    truthy_param?(:pinned)
-  end
-
-  def only_media?
-    truthy_param?(:only_media)
-  end
-
-  def exclude_replies?
-    truthy_param?(:exclude_replies)
-  end
-
-  def exclude_reblogs?
-    truthy_param?(:exclude_reblogs)
-  end
-
-  def tagged?
-    params[:tagged].present?
-  end
-
-  def truthy_param?(key)
-    ActiveModel::Type::Boolean.new.cast(params[key])
-  end
-end

app/models/admin/status_batch_action.rb

@@ -22,7 +22,7 @@ class Admin::StatusBatchAction
   private
 
   def statuses
-    Status.with_discarded.where(id: status_ids)
+    Status.with_discarded.where(id: status_ids).reorder(nil)
   end
 
   def process_action!
@@ -140,6 +140,6 @@ class Admin::StatusBatchAction
   end
 
   def allowed_status_ids
-    AccountStatusesFilter.new(@report.target_account, current_account).results.with_discarded.where(id: status_ids).pluck(:id)
+    Admin::AccountStatusesFilter.new(@report.target_account, current_account).results.with_discarded.where(id: status_ids).pluck(:id)
   end
 end

app/models/concerns/account_merging.rb

@@ -20,7 +20,7 @@ module AccountMerging
     ]
 
     owned_classes.each do |klass|
-      klass.where(account_id: other_account.id).find_each do |record|
+      klass.where(account_id: other_account.id).reorder(nil).find_each do |record|
         record.update_attribute(:account_id, id)
       rescue ActiveRecord::RecordNotUnique
         next
@@ -33,7 +33,7 @@ module AccountMerging
     ]
 
     target_classes.each do |klass|
-      klass.where(target_account_id: other_account.id).find_each do |record|
+      klass.where(target_account_id: other_account.id).reorder(nil).find_each do |record|
         record.update_attribute(:target_account_id, id)
       rescue ActiveRecord::RecordNotUnique
         next

app/models/concerns/account_statuses_search.rb

@@ -31,7 +31,7 @@ module AccountStatusesSearch
   def add_to_public_statuses_index!
     return unless Chewy.enabled?
 
-    statuses.without_reblogs.where(visibility: :public).find_in_batches do |batch|
+    statuses.without_reblogs.where(visibility: :public).reorder(nil).find_in_batches do |batch|
       PublicStatusesIndex.import(batch)
     end
   end

app/models/media_attachment.rb

@@ -171,7 +171,7 @@ class MediaAttachment < ApplicationRecord
   DEFAULT_STYLES = [:original].freeze
 
   GLOBAL_CONVERT_OPTIONS = {
-    all: '-quality 90 +profile "!icc,*" +set modify-date +set create-date',
+    all: '-quality 90 +profile "!icc,*" +set modify-date -define jpeg:dct-method=float +set create-date',
   }.freeze
 
   belongs_to :account,          inverse_of: :media_attachments, optional: true

app/models/tag.rb

@@ -20,6 +20,7 @@
 #
 
 class Tag < ApplicationRecord
+  include Paginable
   has_and_belongs_to_many :statuses
   has_and_belongs_to_many :accounts
 

app/models/trends/statuses.rb

@@ -8,7 +8,7 @@ class Trends::Statuses < Trends::Base
   self.default_options = {
     threshold: 5,
     review_threshold: 3,
-    score_halflife: 2.hours.freeze,
+    score_halflife: 1.hour.freeze,
     decay_threshold: 0.3,
   }
 
@@ -62,13 +62,13 @@ class Trends::Statuses < Trends::Base
   def refresh(at_time = Time.now.utc)
     # First, recalculate scores for statuses that were trending previously. We split the queries
     # to avoid having to load all of the IDs into Ruby just to send them back into Postgres
-    Status.where(id: StatusTrend.select(:status_id)).includes(:status_stat, :account).find_in_batches(batch_size: BATCH_SIZE) do |statuses|
+    Status.where(id: StatusTrend.select(:status_id)).includes(:status_stat, :account).reorder(nil).find_in_batches(batch_size: BATCH_SIZE) do |statuses|
       calculate_scores(statuses, at_time)
     end
 
     # Then, calculate scores for statuses that were used today. There are potentially some
     # duplicate items here that we might process one more time, but that should be fine
-    Status.where(id: recently_used_ids(at_time)).includes(:status_stat, :account).find_in_batches(batch_size: BATCH_SIZE) do |statuses|
+    Status.where(id: recently_used_ids(at_time)).includes(:status_stat, :account).reorder(nil).find_in_batches(batch_size: BATCH_SIZE) do |statuses|
       calculate_scores(statuses, at_time)
     end