More status specs (#2564)

* Add rough outline of coverage needed for public timeline

* Specs for visibility, replies, boosts

* Specs for silenced account

* Specs for local_only option

* Specs for blocks and mutes

* Add tentative spec around including other silenced account statuses

* Add with_public_visibility scope

* Add simple coverage for tag_timeline

* Tag timeline includes replies

* Replace tag.statuses with a tagged_with scope in tag timeline method

* Use with_public_visibility in tag timeline

* Extract common scope between public and tag timelines to method

* Extract local domain check to local_only scope

* Extract local_only check to starting scope method

* Move list of excluded from timeline account ids to account model

* Simplify excluded accounts list on account model

* Only join accounts when needed

* Rename method for account specific filtering

* Extract method for account exclusions

* Fix bug where silenced accounts were not including statuses from other silenced accounts

* DRY up filter application from account or no account

* timeline_scope can be private

* Add spec showing that account can find its excluded accounts ids

* Add spec which fails if local_only does not have a left outer join

* rubocop

2 files changed, 43 insertions, 20 deletions

diff --git a/app/models/account.rb b/app/models/account.rb
index eebcf90b8..b8927c51f 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -46,6 +46,8 @@ class Account < ApplicationRecord
   # Block relationships
   has_many :block_relationships, class_name: 'Block', foreign_key: 'account_id', dependent: :destroy
   has_many :blocking, -> { order('blocks.id desc') }, through: :block_relationships, source: :target_account
+  has_many :blocked_by_relationships, class_name: 'Block', foreign_key: :target_account_id, dependent: :destroy
+  has_many :blocked_by, -> { order('blocks.id desc') }, through: :blocked_by_relationships, source: :account
 
   # Mute relationships
   has_many :mute_relationships, class_name: 'Mute', foreign_key: 'account_id', dependent: :destroy
@@ -211,6 +213,10 @@ class Account < ApplicationRecord
     username
   end
 
+  def excluded_from_timeline_account_ids
+    Rails.cache.fetch("exclude_account_ids_for:#{id}") { blocking.pluck(:target_account_id) + blocked_by.pluck(:account_id) + muting.pluck(:target_account_id) }
+  end
+
   class << self
     def find_local!(username)
       find_remote!(username, nil)
diff --git a/app/models/status.rb b/app/models/status.rb
index d69765e96..f005813e5 100644
--- a/app/models/status.rb
+++ b/app/models/status.rb
@@ -37,6 +37,12 @@ class Status < ApplicationRecord
 
   scope :without_replies, -> { where('statuses.reply = FALSE OR statuses.in_reply_to_account_id = statuses.account_id') }
   scope :without_reblogs, -> { where('statuses.reblog_of_id IS NULL') }
+  scope :with_public_visibility, -> { where(visibility: :public) }
+  scope :tagged_with, ->(tag) { joins(:statuses_tags).where(statuses_tags: { tag_id: tag }) }
+  scope :local_only, -> { left_outer_joins(:account).where(accounts: { domain: nil }) }
+  scope :excluding_silenced_accounts, -> { left_outer_joins(:account).where(accounts: { silenced: false }) }
+  scope :including_silenced_accounts, -> { left_outer_joins(:account).where(accounts: { silenced: true }) }
+  scope :not_excluded_by_account, ->(account) { where.not(account_id: account.excluded_from_timeline_account_ids) }
 
   cache_associated :account, :application, :media_attachments, :tags, :stream_entry, mentions: :account, reblog: [:account, :application, :stream_entry, :tags, :media_attachments, mentions: :account], thread: :account
 
@@ -118,25 +124,15 @@ class Status < ApplicationRecord
     end
 
     def as_public_timeline(account = nil, local_only = false)
-      query = joins('LEFT OUTER JOIN accounts ON statuses.account_id = accounts.id')
-              .where(visibility: :public)
-              .without_replies
-              .without_reblogs
+      query = timeline_scope(local_only).without_replies
 
-      query = query.where('accounts.domain IS NULL') if local_only
-
-      account.nil? ? filter_timeline_default(query) : filter_timeline_default(filter_timeline(query, account))
+      apply_timeline_filters(query, account)
     end
 
     def as_tag_timeline(tag, account = nil, local_only = false)
-      query = tag.statuses
-                 .joins('LEFT OUTER JOIN accounts ON statuses.account_id = accounts.id')
-                 .where(visibility: :public)
-                 .without_reblogs
-
-      query = query.where('accounts.domain IS NULL') if local_only
+      query = timeline_scope(local_only).tagged_with(tag)
 
-      account.nil? ? filter_timeline_default(query) : filter_timeline_default(filter_timeline(query, account))
+      apply_timeline_filters(query, account)
     end
 
     def as_outbox_timeline(account)
@@ -185,15 +181,36 @@ class Status < ApplicationRecord
 
     private
 
-    def filter_timeline(query, account)
-      blocked = Rails.cache.fetch("exclude_account_ids_for:#{account.id}") { Block.where(account: account).pluck(:target_account_id) + Block.where(target_account: account).pluck(:account_id) + Mute.where(account: account).pluck(:target_account_id) }
-      query   = query.where('statuses.account_id NOT IN (?)', blocked) unless blocked.empty?  # Only give us statuses from people we haven't blocked, or muted, or that have blocked us
-      query   = query.where('accounts.silenced = TRUE') if account.silenced?                  # and if we're hellbanned, only people who are also hellbanned
-      query
+    def timeline_scope(local_only = false)
+      starting_scope = local_only ? Status.local_only : Status
+      starting_scope
+        .with_public_visibility
+        .without_reblogs
+    end
+
+    def apply_timeline_filters(query, account)
+      if account.nil?
+        filter_timeline_default(query)
+      else
+        filter_timeline_for_account(query, account)
+      end
+    end
+
+    def filter_timeline_for_account(query, account)
+      query = query.not_excluded_by_account(account)
+      query.merge(account_silencing_filter(account))
     end
 
     def filter_timeline_default(query)
-      query.where('accounts.silenced = FALSE')
+      query.excluding_silenced_accounts
+    end
+
+    def account_silencing_filter(account)
+      if account.silenced?
+        including_silenced_accounts
+      else
+        excluding_silenced_accounts
+      end
     end
   end