Split ThreadFollower into separate models for posts and threads

.rubocop.yml

@@ -58,7 +58,7 @@ Naming/BlockForwarding:
   EnforcedStyle: explicit
 Naming/PredicateMethod:
   Mode: conservative
-  AllowedPatterns: ['verify_.*', 'check_.*', 'enforce_.*', 'setup_.*']
+  AllowedPatterns: ['verify_.*', 'check_.*', 'enforce_.*', 'setup_.*','add_.*', 'remove_.*']
   AllowedMethods:
     - post_sign_in # returns a boolean but is a necessary after-sign-in method for both normal and SAML flows
     - comment_rate_limited? # returns a tuple with the boolean as the first value

app/assets/javascripts/comments.js

@@ -250,11 +250,32 @@ $(() => {
 
     QPixel.handleJSONResponse(data, () => {
       const wrapper = getCommentThreadWrapper($tgt);
-      const inline = isInlineCommentThread(wrapper);
-      openThread(wrapper, threadID, { inline });
+
+      if (wrapper) {
+        const inline = isInlineCommentThread(wrapper);
+        openThread(wrapper, threadID, { inline });
+      }
     });
   });
 
+  $(document).on('click', '.js--unfollow-thread', async (ev) => {
+    ev.preventDefault();
+
+    const $tgt = $(ev.target);
+    const threadID = $tgt.data('thread');
+
+    const data = await QPixel.unfollowThread(threadID);
+
+    QPixel.handleJSONResponse(data, () => {
+      const wrapper = getCommentThreadWrapper($tgt);
+
+      if (wrapper) {
+        const inline = isInlineCommentThread(wrapper);
+        openThread(wrapper, threadID, { inline });
+      }
+    });
+  })
+
   /**
    * @param {Element} target
    */

app/assets/javascripts/qpixel_api.js

@@ -506,6 +506,14 @@ window.QPixel = {
     return QPixel.parseJSONResponse(resp, 'Failed to follow thread');
   },
 
+  unfollowThread: async (id) => {
+    const resp = await QPixel.fetchJSON(`/comments/thread/${id}/unfollow`, {}, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    return QPixel.parseJSONResponse(resp, 'Failed to unfollow thread');
+  },
+
   lockThread: async (id, duration) => {
     const resp = await QPixel.fetchJSON(`/comments/thread/${id}/lock`, {
       duration,

app/controllers/comments_controller.rb

@@ -12,6 +12,7 @@ class CommentsController < ApplicationController
                                     :archive_thread,
                                     :delete_thread,
                                     :follow_thread,
+                                    :unfollow_thread,
                                     :lock_thread,
                                     :thread_unrestrict,
                                     :thread_followers]
@@ -59,11 +60,11 @@ def create_thread
         @comment.post.user.create_notification(notification, helpers.comment_link(@comment))
       end
 
-      ThreadFollower.where(post: @post).each do |tf|
-        unless tf.user == current_user || tf.user == @comment.post.user
-          tf.user.create_notification(notification, helpers.comment_link(@comment))
+      NewThreadFollower.where(post: @post).each do |ntf|
+        unless ntf.user == current_user || ntf.user == @comment.post.user
+          ntf.user.create_notification(notification, helpers.comment_link(@comment))
         end
-        ThreadFollower.create(user: tf.user, comment_thread: @comment_thread)
+        ThreadFollower.create(user: ntf.user, comment_thread: @comment_thread)
       end
 
       apply_pings(pings)
@@ -188,14 +189,16 @@ def show
   end
 
   def thread
-    respond_to do |format|
-      format.html { render 'comments/thread' }
-      format.json { render json: @comment_thread }
+    if stale?(last_modified: @comment_thread.last_activity.utc)
+      respond_to do |format|
+        format.html { render 'comments/thread' }
+        format.json { render json: @comment_thread }
+      end
     end
   end
 
   def thread_content
-    if stale?(last_modified: @comment_thread.last_activity_at.utc)
+    if stale?(last_modified: @comment_thread.last_activity.utc)
       render partial: 'comment_threads/expanded',
              locals: { inline: params[:inline] == 'true',
                        show_deleted: params[:show_deleted_comments] == '1',
@@ -264,7 +267,7 @@ def delete_thread
   end
 
   def follow_thread
-    status = ThreadFollower.create(comment_thread: @comment_thread, user: current_user)
+    status = @comment_thread.add_follower(current_user)
     restrict_thread_response(@comment_thread, status)
   end
 
@@ -293,7 +296,7 @@ def undelete_thread
   end
 
   def unfollow_thread
-    status = ThreadFollower.find_by(comment_thread: @comment_thread, user: current_user)&.destroy
+    status = @comment_thread.remove_follower(current_user)
     restrict_thread_response(@comment_thread, status)
   end
 
@@ -311,8 +314,6 @@ def thread_unrestrict
       unarchive_thread
     when 'delete'
       undelete_thread
-    when 'follow'
-      unfollow_thread
     else
       not_found!
     end
@@ -330,8 +331,8 @@ def post
   end
 
   def post_follow
-    if ThreadFollower.where(post: @post, user: current_user).none?
-      ThreadFollower.create(post: @post, user: current_user)
+    if NewThreadFollower.where(post: @post, user: current_user).none?
+      NewThreadFollower.create(post: @post, user: current_user)
     end
 
     respond_to do |format|
@@ -341,7 +342,7 @@ def post_follow
   end
 
   def post_unfollow
-    ThreadFollower.where(post: @post, user: current_user).destroy_all
+    NewThreadFollower.where(post: @post, user: current_user).destroy_all
 
     respond_to do |format|
       format.html { redirect_to post_path(@post) }

app/jobs/clean_up_new_thread_followers_job.rb

@@ -0,0 +1,24 @@
+class CleanUpNewThreadFollowersJob < ApplicationJob
+  queue_as :default
+
+  def perform
+    sql = File.read(Rails.root.join('db/scripts/posts_with_duplicate_new_thread_followers.sql'))
+    posts = ActiveRecord::Base.connection.execute(sql).to_a
+
+    posts.each do |post|
+      user_id, post_id = post
+
+      followers = NewThreadFollower.where(post_id: post_id, user_id: user_id)
+
+      next unless followers.many?
+
+      duplicate = followers.first
+      result = duplicate.destroy
+
+      unless result
+        puts "failed to destroy new thread follower duplicate \"#{duplicate.id}\""
+        duplicate.errors.each { |e| puts e.full_message }
+      end
+    end
+  end
+end

app/jobs/clean_up_thread_followers_job.rb

@@ -0,0 +1,24 @@
+class CleanUpThreadFollowersJob < ApplicationJob
+  queue_as :default
+
+  def perform
+    sql = File.read(Rails.root.join('db/scripts/threads_with_duplicate_followers.sql'))
+    threads = ActiveRecord::Base.connection.execute(sql).to_a
+
+    threads.each do |thread|
+      user_id, thread_id = thread
+
+      followers = ThreadFollower.where(comment_thread_id: thread_id, user_id: user_id)
+
+      next unless followers.many?
+
+      duplicate = followers.first
+      result = duplicate.destroy
+
+      unless result
+        puts "failed to destroy thread follower duplicate \"#{duplicate.id}\""
+        duplicate.errors.each { |e| puts e.full_message }
+      end
+    end
+  end
+end

app/models/comment.rb

@@ -17,16 +17,12 @@ class Comment < ApplicationRecord
   after_create :create_follower
   after_update :delete_thread
 
+  before_save :bump_last_activity
+
   counter_culture :comment_thread, column_name: proc { |model| model.deleted? ? nil : 'reply_count' }, touch: true
 
   validate :content_length
 
-  # Gets last activity date and time on the comment
-  # @return [DateTime] last activity date and time
-  def last_activity_at
-    [created_at, updated_at].compact.max
-  end
-
   def root
     # If parent_question is nil, the comment is already on a question, so we can just return post.
     parent_question || post
@@ -41,12 +37,28 @@ def content_length
     end
   end
 
+  # Gets last activity date and time on the comment
+  # @return [DateTime] last activity date and time
+  def last_activity
+    [created_at, updated_at, last_activity_at].compact.max
+  end
+
   def pings
     pingable = comment_thread.pingable
     matches = content.scan(USER_PING_REG_EXP)
     matches.flatten.select { |m| pingable.include?(m.to_i) }.map(&:to_i)
   end
 
+  # Directly bumps the comment's last activity date & time
+  # @param persist_changes [Boolean] if set to +true+, will persist the changes
+  def bump_last_activity(persist_changes: false)
+    self.last_activity_at = DateTime.now
+
+    if persist_changes
+      save
+    end
+  end
+
   private
 
   def create_follower

app/models/comment_thread.rb

@@ -16,6 +16,8 @@ class CommentThread < ApplicationRecord
 
   after_create :create_follower
 
+  before_save :bump_last_activity
+
   # Gets threads appropriately scoped for a given user & post
   # @param user [User, nil] user to check
   # @para post [Post] post to check
@@ -51,9 +53,9 @@ def can_access?(user)
 
   # Gets last activity date and time on the thread
   # @return [DateTime] last activity date and time
-  def last_activity_at
-    last_comment_activity_at = comments.map(&:last_activity_at).max
-    [created_at, locked_at, updated_at, last_comment_activity_at].compact.max
+  def last_activity
+    last_comment_activity = comments.map(&:last_activity).compact.max
+    [created_at, updated_at, last_activity_at, last_comment_activity].compact.max
   end
 
   # Gets a list of user IDs who should be pingable in the thread.
@@ -86,6 +88,40 @@ def maximum_title_length
     end
   end
 
+  # Registers a given user as a follower of the thread
+  # @param user [User] user to register as a follower
+  # @return [Boolean] status of the operation
+  def add_follower(user)
+    if ThreadFollower.where(comment_thread: self, user: user).any?
+      bump_last_activity(persist_changes: true)
+      return true
+    end
+
+    ThreadFollower.create(comment_thread: self, user: user)
+  end
+
+  # Directly bumps the thread's last activity date & time
+  # @param persist_changes [Boolean] if set to +true+, will persist the changes
+  def bump_last_activity(persist_changes: false)
+    self.last_activity_at = DateTime.now
+
+    if persist_changes
+      save
+    end
+  end
+
+  # Removes a given user from the thread's followers
+  # @param user [User] user to remove from followers
+  # @return [Boolean] status of the operation
+  def remove_follower(user)
+    if ThreadFollower.where(comment_thread: self, user: user).none?
+      bump_last_activity(persist_changes: true)
+      return true
+    end
+
+    ThreadFollower.where(comment_thread: self, user: user).destroy_all.any?
+  end
+
   private
 
   # Comment author and post author are automatically followed to the thread. Question author is NOT

app/models/concerns/user_merge.rb

@@ -71,6 +71,7 @@ def update_thread_references(target_user)
       CommentThread.where(archived_by_id: id).update_all(archived_by_id: target_user.id)
       CommentThread.where(deleted_by_id: id).update_all(deleted_by_id: target_user.id)
       ThreadFollower.where(user_id: id).update_all(user_id: target_user.id)
+      NewThreadFollower.where(user_id: id).update_all(user_id: target_user.id)
     end
 
     def update_post_action_references(target_user)

app/models/new_thread_follower.rb

@@ -0,0 +1,4 @@
+class NewThreadFollower < ApplicationRecord
+  belongs_to :user
+  belongs_to :post
+end

app/models/post.rb

@@ -243,7 +243,7 @@ def deleted_by_owner?
   # @param user [User] user to check
   # @return [Boolean] check result
   def followed_by?(user)
-    ThreadFollower.where(post: self, user: user).any?
+    NewThreadFollower.where(post: self, user: user).any?
   end
 
   # Is the post an imported post?

app/models/thread_follower.rb

@@ -1,15 +1,13 @@
 class ThreadFollower < ApplicationRecord
-  belongs_to :comment_thread, optional: true
-  belongs_to :post, optional: true
+  belongs_to :comment_thread
   belongs_to :user
 
-  validate :thread_or_post
+  after_create :bump_thread_last_activity
+  before_destroy :bump_thread_last_activity
 
   private
 
-  def thread_or_post
-    if comment_thread.nil? && post.nil?
-      errors.add(:base, 'Must refer to either a comment thread or a post.')
-    end
+  def bump_thread_last_activity
+    comment_thread&.bump_last_activity(persist_changes: true)
   end
 end

app/models/user.rb

@@ -483,13 +483,13 @@ def active_flags(post)
   end
 
   # Anonymizes the user (f.e., for the purpose of soft deletion)
-  # @param persist_changes [Boolean] if set to +false+, will persist the changes
+  # @param persist_changes [Boolean] if set to +true+, will persist the changes
   def anonymize(persist_changes: false)
     assign_attributes(username: "user#{id}",
                       email: "#{id}@deleted.localhost",
                       password: SecureRandom.hex(32))
 
-    unless persist_changes
+    if persist_changes
       skip_reconfirmation!
       save
     end
@@ -505,7 +505,7 @@ def soft_delete(attribute_to)
                       deleted_by_id: attribute_to.id,
                       deleted_at: DateTime.now)
 
-    anonymize(persist_changes: true)
+    anonymize(persist_changes: false)
 
     skip_reconfirmation!
     save

app/views/comments/_thread_follow_link.html.erb

@@ -8,8 +8,7 @@
 
 <% if thread.followed_by?(user) %>
   <a href="#"
-     class="widget--header-link js--unrestrict-thread"
-     data-action="follow"
+     class="widget--header-link js--unfollow-thread"
      data-thread="<%= thread.id %>"
      title="You are following this thread and will be notified of every response. You can unfollow at any time."
      role="button"

config/routes.rb

@@ -247,6 +247,7 @@
     post   'thread/:id/archive',           to: 'comments#archive_thread', as: :archive_comment_thread
     post   'thread/:id/delete',            to: 'comments#delete_thread', as: :delete_comment_thread
     post   'thread/:id/follow',            to: 'comments#follow_thread', as: :follow_comment_thread
+    post   'thread/:id/unfollow',          to: 'comments#unfollow_thread', as: :unfollow_comment_thread
     post   'thread/:id/lock',              to: 'comments#lock_thread', as: :lock_comment_thread
 
     post   'thread/:id/unrestrict',        to: 'comments#thread_unrestrict', as: :unrestrict_comment_thread