thredded 0.15.5 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bd8be4009af787b59ded83d2baa329f83fe8af37162b24d44191bbdae5623a7
-  data.tar.gz: 66601634a6691c8b0488011034dc5a03d872d203452651bf5e792ed87edfa801
+  metadata.gz: a642798592ef42f04c27440bdeb2b9930273fca1bbb2cb41da3138dd10af429c
+  data.tar.gz: 78e334145b31fc55950554b3909864fbe6617a262fbfa07006eec2262ab526bf
 SHA512:
-  metadata.gz: 416d1ccbef43a2d7b2127151cba2727013a348cf3b36bb5db91cae85e179f7eb579359e945e70296fe965685b73d394125db5bb66dac691c37a756ac4ca49ac4
-  data.tar.gz: 37e9420a65e8278e3dd85c6159817c0336ca544d09119720234a87bad97ba4189238e159eb9a739ce5a90748eb8b6f230cfb95486b05e0c156e41b019c7ff8eb
+  metadata.gz: 5b134c56f3c79b38ed2b13b42e45c6c5fa7dbb54258ab941980fa7791077a8f1fdc1e76ba24d0c5658478ce762beddaf080133fe16fbd8684c467f2d1efbbe80
+  data.tar.gz: 560bfe2c2922595f5a93728bffb7becb25a32a39fa4ddc209ff8f5778c28ccc87cd46b0a08d106383cf2bb440c83f1a7a532bd0247683ff2e63d30028ca99e3f

data/README.md

@@ -95,7 +95,7 @@ Then, see the rest of this Readme for more information about using and customizi
 Add the gem to your Gemfile:
 
 ```ruby
-gem 'thredded', '~> 0.15.5'
+gem 'thredded', '~> 0.16.0'
 ```
 
 Add the Thredded [initializer] to your parent app by running the install generator.
@@ -104,12 +104,6 @@ Add the Thredded [initializer] to your parent app by running the install generat
 rails generate thredded:install
 ```
 
-Copy emoji images to your `public/emoji` directory.
-
-```console
-rake thredded:install:emoji
-```
-
 Thredded needs to know the base application User model name and certain columns on it. Configure
 these in the initializer installed with the command above.
 

data/app/assets/stylesheets/thredded/_thredded.scss

@@ -1,5 +1,6 @@
 @import "base";
 
+@import "utilities/flex";
 @import "utilities/is-compact";
 @import "utilities/is-expanded";
 

data/app/assets/stylesheets/thredded/components/_messageboard.scss

@@ -33,7 +33,6 @@
   float: left;
   font-size: 1.125rem; // 18px
   line-height: 1.2;
-  margin-right: $thredded-small-spacing;
   vertical-align: baseline;
 }
 
@@ -66,6 +65,19 @@
   vertical-align: baseline;
 }
 
+.thredded--messageboard--unread-followed-topics-count {
+  @extend %thredded--nav-tabs--item--badge;
+  align-self: baseline;
+  line-height: inherit;
+  display: flex;
+}
+
+.thredded--messageboard--unread-followed-icon {
+  fill: currentColor;
+  width: 1rem;
+  height: 1rem;
+}
+
 .thredded--messageboard--description {
   @extend %thredded--paragraph;
   clear: both;
@@ -96,7 +108,9 @@
     &--header {
       display: flex;
       flex-wrap: wrap;
-      justify-content: space-between;
+      > .thredded--flex-spacer {
+        margin-right: $thredded-small-spacing;
+      }
     }
     &--meta {
       text-align: right;
@@ -149,7 +163,6 @@
         margin-bottom: $margin-y;
         padding: $thredded-messageboards-grid-item-padding-y $thredded-messageboards-grid-item-padding-x;
       }
-
     }
   }
 }

data/app/assets/stylesheets/thredded/utilities/_flex.scss

@@ -0,0 +1,3 @@
+.thredded--flex-spacer {
+  flex-grow: 1;
+}

data/app/commands/thredded/mark_all_read.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
 module Thredded
+  # Marks all private topics as read for the given user.
   class MarkAllRead
     def self.run(user)
-      unread_topics = Thredded::PrivateTopic.unread(user)
-      return if unread_topics.empty?
-
-      unread_topics.each do |topic|
-        last_post = topic.posts.order_oldest_first.last
-
-        Thredded::UserPrivateTopicReadState.touch!(user.id, topic.id, last_post)
+      Thredded::PrivateTopic.unread(user).each do |topic|
+        Thredded::UserPrivateTopicReadState.touch!(user.id, topic.last_post)
       end
     end
   end

data/app/controllers/thredded/messageboards_controller.rb

@@ -8,7 +8,10 @@ module Thredded
     after_action :verify_policy_scoped, except: %i[new create edit update]
 
     def index
-      @groups = Thredded::MessageboardGroupView.grouped(policy_scope(Thredded::Messageboard.all))
+      @groups = Thredded::MessageboardGroupView.grouped(
+        policy_scope(Thredded::Messageboard.all),
+        user: thredded_current_user
+      )
     end
 
     def new

data/app/controllers/thredded/moderation_controller.rb

@@ -54,8 +54,13 @@ module Thredded
 
     def users
       @users = Thredded.user_class
-        .left_join_thredded_user_details
-        .merge(Thredded::UserDetail.order(moderation_state_changed_at: :desc))
+        .eager_load(:thredded_user_detail)
+        .merge(
+          Thredded::UserDetail.order(
+            Arel.sql('COALESCE(thredded_user_details.moderation_state, 0) ASC,'\
+                     'thredded_user_details.moderation_state_changed_at DESC')
+          )
+        )
       @query = params[:q].to_s
       @users = DbTextSearch::CaseInsensitive.new(@users, Thredded.user_name_column).prefix(@query) if @query.present?
       @users = @users.page(current_page)

data/app/controllers/thredded/private_topics_controller.rb

@@ -32,11 +32,7 @@ module Thredded
         .page(current_page)
       return redirect_to(last_page_params(page_scope)) if page_beyond_last?(page_scope)
       @posts = Thredded::TopicPostsPageView.new(thredded_current_user, private_topic, page_scope)
-
-      if thredded_signed_in?
-        Thredded::UserPrivateTopicReadState.touch!(thredded_current_user.id, private_topic.id, page_scope.last)
-      end
-
+      Thredded::UserPrivateTopicReadState.touch!(thredded_current_user.id, page_scope.last) if thredded_signed_in?
       @new_post = Thredded::PrivatePostForm.new(
         user: thredded_current_user, topic: private_topic, post_params: new_private_post_params
       )

data/app/controllers/thredded/theme_previews_controller.rb

@@ -10,7 +10,11 @@ module Thredded
               else
                 thredded_current_user
               end
-      @messageboards = Thredded::Messageboard.all
+      @messageboard_views = [
+        Thredded::MessageboardView.new(@messageboard, unread_topics_count: 3, unread_followed_topics_count: 2),
+        Thredded::MessageboardView.new(Thredded::Messageboard.first(2)[-1], unread_topics_count: 2),
+        Thredded::MessageboardView.new(Thredded::Messageboard.first(3)[-1]),
+      ]
       @topics = Thredded::TopicsPageView.new(@user, @messageboard.topics.page(1).limit(3))
       @private_topics = Thredded::PrivateTopicsPageView.new(@user, @user.thredded_private_topics.page(1).limit(3))
       topic = Thredded::Topic.new(messageboard: @messageboard, title: 'Hello', slug: 'hello', user: @user)

data/app/controllers/thredded/topics_controller.rb

@@ -60,7 +60,7 @@ module Thredded
         .page(current_page)
       return redirect_to(last_page_params(page_scope)) if page_beyond_last?(page_scope)
       @posts = Thredded::TopicPostsPageView.new(thredded_current_user, topic, page_scope)
-      Thredded::UserTopicReadState.touch!(thredded_current_user.id, topic.id, page_scope.last) if thredded_signed_in?
+      Thredded::UserTopicReadState.touch!(thredded_current_user.id, page_scope.last) if thredded_signed_in?
       @new_post = Thredded::PostForm.new(user: thredded_current_user, topic: topic, post_params: new_post_params)
     end
 

data/app/forms/thredded/post_form.rb

@@ -49,7 +49,7 @@ module Thredded
       return false unless @post.valid?
       was_persisted = @post.persisted?
       @post.save!
-      Thredded::UserTopicReadState.touch!(@post.user.id, @topic.id, @post) unless was_persisted
+      Thredded::UserTopicReadState.touch!(@post.user.id, @post) unless was_persisted
       true
     end
   end

data/app/forms/thredded/private_post_form.rb

@@ -45,7 +45,7 @@ module Thredded
       return false unless @post.valid?
       was_persisted = @post.persisted?
       @post.save!
-      Thredded::UserPrivateTopicReadState.touch!(@post.user.id, @topic.id, @post) unless was_persisted
+      Thredded::UserPrivateTopicReadState.touch!(@post.user.id, @post) unless was_persisted
       true
     end
   end

data/app/forms/thredded/private_topic_form.rb

@@ -44,8 +44,10 @@ module Thredded
       return false unless valid?
 
       ActiveRecord::Base.transaction do
+        new_topic = !private_topic.persisted?
         private_topic.save!
         post.save!
+        Thredded::UserPrivateTopicReadState.read_on_first_post!(user, post) if new_topic
       end
       true
     end

data/app/forms/thredded/topic_form.rb

@@ -31,9 +31,10 @@ module Thredded
       return false unless valid?
 
       ActiveRecord::Base.transaction do
+        new_topic = !topic.persisted?
         topic.save!
         post.save!
-        Thredded::UserTopicReadState.read_on_first_post!(user, topic) if topic.previous_changes.include?(:id)
+        Thredded::UserTopicReadState.read_on_first_post!(user, post) if new_topic
       end
       true
     end

data/app/forms/thredded/user_preferences_form.rb

@@ -50,7 +50,11 @@ module Thredded
     end
 
     def messageboard_groups
-      @messageboard_groups ||= Thredded::MessageboardGroupView.grouped(@messageboards)
+      @messageboard_groups ||= Thredded::MessageboardGroupView.grouped(
+        @messageboards,
+        user: @user,
+        with_unread_topics_counts: false
+      )
     end
 
     def notifications_for_private_topics

data/app/models/concerns/thredded/post_common.rb

@@ -19,6 +19,8 @@ module Thredded
       scope :order_newest_first, -> { order(created_at: :desc, id: :desc) }
 
       before_validation :ensure_user_detail, on: :create
+
+      after_commit :update_unread_posts_count, on: %i[create destroy]
     end
 
     def avatar_url
@@ -48,17 +50,13 @@ module Thredded
     end
 
     # Marks all the posts from the given one as unread for the given user
-    # @param user [Thredded.user_class]
-    # @param page [Integer]
+    # @param [Thredded.user_class] user
     def mark_as_unread(user)
       if previous_post.nil?
         read_state = postable.user_read_states.find_by(user_id: user.id)
         read_state.destroy if read_state
       else
-        read_state = postable.user_read_states.create_with(
-          read_at: previous_post.created_at
-        ).find_or_create_by(user_id: user.id)
-        read_state.update_columns(read_at: previous_post.created_at)
+        postable.user_read_states.touch!(user.id, previous_post, overwrite_newer: true)
       end
     end
 
@@ -66,6 +64,12 @@ module Thredded
       @previous_post ||= postable.posts.order_newest_first.find_by('created_at < ?', created_at)
     end
 
+    protected
+
+    def update_unread_posts_count
+      postable.user_read_states.update_post_counts!
+    end
+
     private
 
     def ensure_user_detail

data/app/models/concerns/thredded/topic_common.rb

@@ -50,16 +50,12 @@ module Thredded
       # @param user [Thredded.user_class]
       # @return [ActiveRecord::Relation]
       def unread(user)
-        topics      = arel_table
+        topics = arel_table
         reads_class = reflect_on_association(:user_read_states).klass
-        reads       = reads_class.arel_table
+        reads = reads_class.arel_table
         joins(topics.join(reads, Arel::Nodes::OuterJoin)
                 .on(topics[:id].eq(reads[:postable_id]).and(reads[:user_id].eq(user.id))).join_sources)
-          .merge(reads_class.where(reads[:id].eq(nil).or(reads[:read_at].lt(topics[:last_post_at]))))
-      end
-
-      def post_class
-        reflect_on_association(:posts).klass
+          .merge(reads_class.where(reads[:id].eq(nil).or(reads[:unread_posts_count].not_eq(0))))
       end
 
       private
@@ -69,7 +65,7 @@ module Thredded
       def read_states_by_postable_hash(user)
         read_states = reflect_on_association(:user_read_states).klass
           .where(user_id: user.id, postable_id: current_scope.map(&:id))
-          .with_page_info(posts_scope: Pundit.policy_scope(user, post_class.all))
+          .with_page_info
         Thredded::TopicCommon::CachingHash.from_relation(read_states)
       end
 

data/app/models/concerns/thredded/user_topic_read_state_common.rb

@@ -21,79 +21,73 @@ module Thredded
       post.created_at <= read_at
     end
 
-    module ClassMethods
-      # @param user_id [Integer]
-      # @param topic_id [Integer]
-      # @param post [Thredded::PostCommon]
-      def touch!(user_id, topic_id, post)
-        # TODO: Switch to upsert once Travis supports PostgreSQL 9.5.
-        # Travis issue: https://github.com/travis-ci/travis-ci/issues/4264
-        # Upsert gem: https://github.com/seamusabshere/upsert
-        state = find_or_initialize_by(user_id: user_id, postable_id: topic_id)
-        return unless !state.read_at? || state.read_at < post.created_at
-        state.update!(read_at: post.created_at)
-      end
+    def calculate_post_counts
+      unread_posts_count, read_posts_count =
+        self.class.visible_posts_scope(user)
+          .where(postable_id: postable_id)
+          .pluck(*self.class.post_counts_arel(read_at))[0]
+      { unread_posts_count: unread_posts_count || 0, read_posts_count: read_posts_count || 0 }
+    end
 
-      def read_on_first_post!(user, topic)
-        create!(user: user, postable: topic, read_at: Time.zone.now)
-      end
+    module ClassMethods
+      delegate :post_class, to: :topic_class
 
       # Adds `first_unread_post_page` and `last_read_post_page` columns onto the scope.
       # Skips the records that have no read posts.
-      def with_page_info( # rubocop:disable Metrics/MethodLength
-        posts_per_page: post_class.default_per_page, posts_scope: post_class.all
-      )
+      def with_page_info(posts_per_page: post_class.default_per_page)
         states = arel_table
-        self_relation = is_a?(ActiveRecord::Relation) ? self : all
-        if self_relation == unscoped
-          states_select_manager = states
-        else
-          # Using the relation here is redundant but massively improves performance.
-          states_select_manager = Thredded::ArelCompat.new_arel_select_manager(
-            Arel::Nodes::TableAlias.new(Thredded::ArelCompat.relation_to_arel(self_relation), table_name)
-          )
-        end
-        read = if posts_scope == post_class.unscoped
-                 post_class.arel_table
-               else
-                 posts_subquery = Thredded::ArelCompat.relation_to_arel(posts_scope)
-                 Arel::Nodes::TableAlias.new(posts_subquery, 'read_posts')
-               end
-        unread_topics = topic_class.arel_table
-        page_info =
-          states_select_manager
-            .project(
-              states[:id],
-              Arel::Nodes::Case.new(unread_topics[:id].not_eq(nil))
-                .when(Thredded::ArelCompat.true_value(self)).then(
-                  Arel::Nodes::Addition.new(
-                    Thredded::ArelCompat.integer_division(self, read[:id].count, posts_per_page), 1
-                  )
-                ).else(nil)
-                .as('first_unread_post_page'),
+        selects = []
+        selects << states[Arel.star] if !is_a?(ActiveRecord::Relation) || select_values.empty?
+        selects += [
+          Arel::Nodes::Case.new(states[:unread_posts_count].not_eq(0))
+            .when(Thredded::ArelCompat.true_value(self)).then(
               Arel::Nodes::Addition.new(
-                Thredded::ArelCompat.integer_division(self, read[:id].count, posts_per_page),
-                Arel::Nodes::Case.new(Arel::Nodes::InfixOperation.new(:%, read[:id].count, posts_per_page))
-                  .when(0).then(0).else(1)
-              ).as('last_read_post_page')
-            )
-            .join(read)
-            .on(read[:postable_id].eq(states[:postable_id]).and(read[:created_at].lteq(states[:read_at])))
-            .outer_join(unread_topics)
-            .on(states[:postable_id].eq(unread_topics[:id]).and(unread_topics[:last_post_at].gt(states[:read_at])))
-            .group(states[:id], unread_topics[:id])
-            .as('id_and_page_info')
+                Thredded::ArelCompat.integer_division(self, states[:read_posts_count], posts_per_page), 1
+              )
+            ).else(nil).as('first_unread_post_page'),
+          Arel::Nodes::Addition.new(
+            Thredded::ArelCompat.integer_division(self, states[:read_posts_count], posts_per_page),
+            Arel::Nodes::Case.new(Arel::Nodes::InfixOperation.new(:%, states[:read_posts_count], posts_per_page))
+              .when(0).then(0).else(1)
+          ).as('last_read_post_page')
+        ]
+        select(selects)
+      end
 
-        # We use a subquery because selected fields must appear in the GROUP BY or be used in an aggregate function.
-        select(states[Arel.star], page_info[:first_unread_post_page], page_info[:last_read_post_page])
-          .joins(states.join(page_info).on(states[:id].eq(page_info[:id])).join_sources)
+      # Calculates and saves the `unread_posts_count` and `read_posts_count` columns.
+      def update_post_counts!
+        id_counts = calculate_post_counts_for_users(Thredded.user_class.where(id: distinct.select(:user_id)))
+        transaction do
+          id_counts.each do |(id, unread_posts_count, read_posts_count)|
+            where(id: id).update_all(unread_posts_count: unread_posts_count, read_posts_count: read_posts_count)
+          end
+        end
       end
 
-      def topic_class
-        reflect_on_association(:postable).klass
+      # @param [DateTime, Arel::Node] read_at
+      # @param [Arel::Table] posts
+      # @return [[Arel::Node, Arel::Node]] `unread_posts_count` and `read_posts_count` nodes.
+      def post_counts_arel(read_at, posts: post_class.arel_table)
+        [
+          Arel::Nodes::Sum.new(
+            [Arel::Nodes::Case.new(posts[:created_at].gt(read_at))
+               .when(Thredded::ArelCompat.true_value(self)).then(1).else(0)]
+          ).as('unread_posts_count'),
+          Arel::Nodes::Sum.new(
+            [Arel::Nodes::Case.new(posts[:created_at].gt(read_at))
+               .when(Thredded::ArelCompat.true_value(self)).then(0).else(1)]
+          ).as('read_posts_count')
+        ]
       end
 
-      delegate :post_class, to: :topic_class
+      # @return [Array<[id, unread_posts_count, read_posts_count]>]
+      def calculate_post_counts
+        states = arel_table
+        posts = post_class.arel_table
+        joins(states.join(posts).on(states[:postable_id].eq(posts[:postable_id])).join_sources)
+          .group(states[:id])
+          .pluck(states[:id], *post_counts_arel(states[:read_at], posts: posts))
+      end
     end
   end
 end

data/app/models/thredded/messageboard.rb

@@ -4,7 +4,7 @@ module Thredded
   class Messageboard < ActiveRecord::Base
     extend FriendlyId
     friendly_id :slug_candidates,
-                use:            %i[slugged reserved],
+                use: %i[slugged reserved],
                 # Avoid route conflicts
                 reserved_words: ::Thredded::FriendlyIdReservedWordsAndPagination.new(
                   %w[
@@ -51,6 +51,11 @@ module Thredded
              through:    :recently_active_user_details,
              source:     :user
 
+    has_many :user_topic_read_states,
+             class_name: 'Thredded::UserTopicReadState',
+             inverse_of: :messageboard,
+             dependent: :delete_all
+
     belongs_to :group,
                inverse_of: :messageboards,
                foreign_key: :messageboard_group_id,
@@ -114,5 +119,26 @@ module Thredded
         [:name, '-board']
       ]
     end
+
+    class << self
+      # @param [Thredded.user_class] user
+      # @param [ActiveRecord::Relation<Thredded::Topic>] topics_scope
+      def unread_topics_counts(user:, topics_scope: Thredded::Topic.all)
+        messageboards = arel_table
+        read_states = Thredded::UserTopicReadState.arel_table
+        topics = topics_scope.arel_table
+        joins(:topics).merge(topics_scope).joins(
+          messageboards.outer_join(read_states).on(
+            messageboards[:id].eq(read_states[:messageboard_id])
+              .and(read_states[:postable_id].eq(topics[:id]))
+              .and(read_states[:user_id].eq(user.id))
+              .and(read_states[:unread_posts_count].eq(0))
+          ).join_sources
+        ).group(messageboards[:id]).pluck(
+          :id,
+          Arel::Nodes::Subtraction.new(topics[:id].count, read_states[:id].count)
+        ).to_h
+      end
+    end
   end
 end