thredded 0.8.4 → 0.9.1

data/app/forms/thredded/user_preferences_form.rb

@@ -9,12 +9,12 @@ module Thredded
     validate :validate_children
 
     delegate :follow_topics_on_mention, :follow_topics_on_mention=,
-             :notify_on_message, :notify_on_message=,
-             :followed_topic_emails, :followed_topic_emails=,
+             :messageboard_notifications_for_followed_topics_attributes=,
+             :notifications_for_followed_topics_attributes=,
+             :notifications_for_private_topics_attributes=,
              to: :user_preference
 
     delegate :follow_topics_on_mention, :follow_topics_on_mention=,
-             :followed_topic_emails, :followed_topic_emails=,
              to: :user_messageboard_preference,
              prefix: :messageboard
 
@@ -36,6 +36,25 @@ module Thredded
       true
     end
 
+    def notifications_for_private_topics
+      for_every_notifier(user_preference.notifications_for_private_topics)
+    end
+
+    def notifications_for_followed_topics
+      for_every_notifier(user_preference.notifications_for_followed_topics)
+    end
+
+    def messageboard_notifications_for_followed_topics
+      return nil unless messageboard
+      for_every_notifier(user_preference.messageboard_notifications_for_followed_topics.for_messageboard(messageboard))
+    end
+
+    def for_every_notifier(prefs)
+      Thredded.notifiers.map do |notifier|
+        prefs.find { |n| n.notifier_key == notifier.key } || prefs.build(notifier_key: notifier.key)
+      end
+    end
+
     private
 
     # @return [Thredded::UserPreference]
@@ -52,7 +71,7 @@ module Thredded
 
     def validate_children
       promote_errors(user_preference.errors) if user_preference.invalid?
-      if messageboard && user_messageboard_preference.invalid?
+      if messageboard && user_messageboard_preference.invalid? # rubocop:disable Style/GuardClause
         promote_errors(user_messageboard_preference.errors, :messageboard)
       end
     end

data/app/helpers/thredded/application_helper.rb

@@ -52,11 +52,21 @@ module Thredded
     def time_ago(datetime, default: '-')
       timeago_tag datetime,
                   lang: I18n.locale.to_s.downcase,
-                  format: -> (t, _opts) { t.year == Time.current.year ? :short : :long },
+                  format: ->(t, _opts) { t.year == Time.current.year ? :short : :long },
                   nojs: true,
+                  date_only: false,
                   default: default
     end
 
+    # Override the default timeago_tag_content from rails-timeago
+    def timeago_tag_content(time, time_options = {})
+      if time_options[:nojs] && (time_options[:limit].nil? || time_options[:limit] < time)
+        t 'thredded.time_ago', time: time_ago_in_words(time)
+      else
+        I18n.l time.to_date, format: time_options[:format]
+      end
+    end
+
     def paginate(collection, args = {})
       super(collection, args.reverse_merge(views_prefix: 'thredded'))
     end

data/app/mailers/thredded/post_mailer.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-require_dependency 'thredded/topic_email_view'
 module Thredded
   class PostMailer < Thredded::BaseMailer
     def post_notification(post_id, emails)
-      @post                = find_record Post, post_id
-      email_details        = TopicEmailView.new(@post.postable)
+      @post                = find_record Thredded::Post, post_id
+      email_details        = Thredded::TopicEmailView.new(@post.postable)
       headers['X-SMTPAPI'] = email_details.smtp_api_tag('post_notification')
 
       mail from:     email_details.no_reply,

data/app/mailers/thredded/private_topic_mailer.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-require_dependency 'thredded/topic_email_view'
 module Thredded
   class PrivateTopicMailer < Thredded::BaseMailer
     def message_notification(private_topic_id, emails)
-      @topic               = find_record PrivateTopic, private_topic_id
-      email_details        = TopicEmailView.new(@topic)
+      @topic               = find_record Thredded::PrivateTopic, private_topic_id
+      email_details        = Thredded::TopicEmailView.new(@topic)
       headers['X-SMTPAPI'] = email_details.smtp_api_tag('private_topic_mailer')
 
       mail from:     email_details.no_reply,

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

@@ -5,7 +5,7 @@ module Thredded
   # @api private
   module ContentModerationState
     extend ActiveSupport::Concern
-    include ModerationState
+    include Thredded::ModerationState
 
     included do
       before_validation :set_default_moderation_state, on: :create

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Thredded
+  module NotifierPreference
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :human_name, to: :notifier, prefix: true
+
+      def self.detect_or_default(prefs, notifier)
+        (prefs && prefs.find { |pref| pref.notifier_key == notifier.key }) || default(notifier)
+      end
+    end
+
+    def notifier
+      @notifier ||= Thredded.notifiers.find { |notifier| notifier.key == notifier_key }
+    end
+  end
+end

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

@@ -28,10 +28,14 @@ module Thredded
 
     # @param view_context [Object] the context of the rendering view.
     # @return [String] formatted and sanitized html-safe post content.
-    def filtered_content(view_context, users_provider: -> (names) { readers_from_user_names(names) })
+    def filtered_content(view_context, users_provider: ->(names) { readers_from_user_names(names) })
       Thredded::ContentFormatter.new(view_context, users_provider: users_provider).format_content(content)
     end
 
+    def first_post_in_topic?
+      postable.first_post == self
+    end
+
     private
 
     def ensure_user_detail

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

@@ -10,7 +10,7 @@ module Thredded
                  foreign_key: 'last_user_id'
 
       scope :order_recently_posted_first, -> { order(last_post_at: :desc, id: :desc) }
-      scope :on_page, -> (page_num) { page(page_num) }
+      scope :on_page, ->(page_num) { page(page_num) }
 
       validates :hash_id, presence: true, uniqueness: true
       validates :posts_count, numericality: true
@@ -25,11 +25,11 @@ module Thredded
     end
 
     def user
-      super || NullUser.new
+      super || Thredded::NullUser.new
     end
 
     def last_user
-      super || NullUser.new
+      super || Thredded::NullUser.new
     end
 
     def private?

data/{lib → app/models/concerns}/thredded/topics_search.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
-require 'thredded/search_parser'
 module Thredded
   class TopicsSearch
     def initialize(query, scope)
-      @terms = SearchParser.new(query).parse
+      @terms = Thredded::SearchParser.new(query).parse
       @scope = scope
 
       @search_categories = @search_users = @search_text = nil
@@ -12,7 +11,7 @@ module Thredded
     # @return [ActiveRecord::Relation<Thredded::Topic>]
     def search
       if categories.present?
-        @scope = @scope.joins(:topic_categories).merge(TopicCategory.where(category_id: categories))
+        @scope = @scope.joins(:topic_categories).merge(Thredded::TopicCategory.where(category_id: categories))
       end
       if text.present? || users.present?
         [search_topics, search_posts].compact.reduce(:union)

data/app/models/thredded/messageboard.rb

@@ -81,6 +81,17 @@ module Thredded
       order(topics_count: :desc)
     }
     # rubocop:enable Style/Lambda
+
+    # Finds the messageboard by its slug or ID, or raises Thredded::Errors::MessageboardNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::Messageboard]
+    # @raise [Thredded::Errors::MessageboardNotFound] if the messageboard with the given slug does not exist.
+    def self.friendly_find!(slug_or_id)
+      friendly.find(slug_or_id)
+    rescue ActiveRecord::RecordNotFound
+      raise Thredded::Errors::MessageboardNotFound
+    end
+
     def last_user
       last_topic.try(:last_user)
     end

data/app/models/thredded/messageboard_notifications_for_followed_topics.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Thredded
+  class MessageboardNotificationsForFollowedTopics < ActiveRecord::Base
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :messageboard_notifications_for_followed_topics
+    belongs_to :user,
+               class_name: Thredded.user_class,
+               inverse_of: :thredded_user_messageboard_preferences
+    belongs_to :messageboard
+    scope :for_messageboard, ->(messageboard) { where(messageboard_id: messageboard.id) }
+
+    validates :user_id, presence: true
+    validates :messageboard_id, presence: true
+
+    def self.in(messageboard)
+      where(messageboard_id: messageboard.id)
+    end
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to `notifier.defaults(:notifications_for_followed_topics)` or
+      # `notifier.defaults(:messageboard_notifications_for_followed_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/notifications_for_followed_topics.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Thredded
+  class NotificationsForFollowedTopics < ActiveRecord::Base
+    belongs_to :user,
+               class_name: Thredded.user_class,
+               inverse_of: :thredded_notifications_for_followed_topics
+    belongs_to :messageboard # or is global
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :notifications_for_followed_topics
+
+    validates :user_id, presence: true
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to  `notifier.defaults(:notifications_for_followed_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/notifications_for_private_topics.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Thredded
+  class NotificationsForPrivateTopics < ActiveRecord::Base
+    belongs_to :user,
+               class_name: Thredded.user_class,
+               inverse_of: :thredded_notifications_for_private_topics
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :notifications_for_private_topics
+
+    validates :user_id, presence: true
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to  `notifier.defaults(:notifications_for_private_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/post.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 module Thredded
   class Post < ActiveRecord::Base
-    include PostCommon
-    include ContentModerationState
+    include Thredded::PostCommon
+    include Thredded::ContentModerationState
 
     belongs_to :user,
                class_name: Thredded.user_class,
@@ -54,7 +54,9 @@ module Thredded
     def auto_follow_and_notify
       return unless user
       # need to do this in-process so that it appears to them immediately
-      UserTopicFollow.create_unless_exists(user.id, postable_id, :posted)
+      if first_post_in_topic? ? Thredded.auto_follow_when_creating_topic : Thredded.auto_follow_when_posting_in_topic
+        UserTopicFollow.create_unless_exists(user.id, postable_id, :posted)
+      end
       # everything else can happen later
       AutoFollowAndNotifyJob.perform_later(id)
     end

data/app/models/thredded/post_moderation_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Thredded
   class PostModerationRecord < ActiveRecord::Base
-    include ModerationState
+    include Thredded::ModerationState
     # Rails 4 doesn't support enum _prefix
     if Rails::VERSION::MAJOR >= 5
       enum previous_moderation_state: moderation_states, _prefix: :previous

data/app/models/thredded/private_post.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Thredded
   class PrivatePost < ActiveRecord::Base
-    include PostCommon
+    include Thredded::PostCommon
 
     belongs_to :user,
                class_name: Thredded.user_class,

data/app/models/thredded/private_topic.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 module Thredded
   class PrivateTopic < ActiveRecord::Base
-    include TopicCommon
+    include Thredded::TopicCommon
 
-    scope :for_user, -> (user) { joins(:private_users).merge(PrivateUser.where(user_id: user.id)) }
+    scope :for_user, ->(user) { joins(:private_users).merge(PrivateUser.where(user_id: user.id)) }
 
     extend FriendlyId
     friendly_id :slug_candidates,
@@ -48,8 +48,12 @@ module Thredded
 
     before_validation :ensure_user_in_private_users
 
-    def self.find_by_slug(slug)
-      friendly.find(slug)
+    # Finds the topic by its slug or ID, or raises Thredded::Errors::PrivateTopicNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::PrivateTopic]
+    # @raise [Thredded::Errors::PrivateTopicNotFound] if the topic with the given slug does not exist.
+    def self.friendly_find!(slug_or_id)
+      friendly.find(slug_or_id)
     rescue ActiveRecord::RecordNotFound
       raise Thredded::Errors::PrivateTopicNotFound
     end

data/app/models/thredded/stats.rb

@@ -18,7 +18,7 @@ module Thredded
     private
 
     def messageboards
-      @messageboards ||= Messageboard.ordered
+      @messageboards ||= Thredded::Messageboard.ordered
     end
   end
 end

data/app/models/thredded/topic.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
-require 'thredded/topics_search'
 module Thredded
   class Topic < ActiveRecord::Base
-    include TopicCommon
-    include ContentModerationState
+    include Thredded::TopicCommon
+    include Thredded::ContentModerationState
 
-    scope :for_messageboard, -> (messageboard) { where(messageboard_id: messageboard.id) }
+    scope :for_messageboard, ->(messageboard) { where(messageboard_id: messageboard.id) }
 
     scope :stuck, -> { where(sticky: true) }
     scope :unstuck, -> { where(sticky: false) }
 
     # Using `search_query` instead of `search` to avoid conflict with Ransack.
-    scope :search_query, -> (query) { ::Thredded::TopicsSearch.new(query, self).search }
+    scope :search_query, ->(query) { ::Thredded::TopicsSearch.new(query, self).search }
 
     scope :order_sticky_first, -> { order(sticky: :desc) }
 
@@ -77,8 +76,12 @@ module Thredded
     after_commit :update_messageboard_last_topic, on: :update, if: -> { previous_changes.include?('moderation_state') }
     after_update :update_last_user_and_time_from_last_post!, if: -> { previous_changes.include?('moderation_state') }
 
-    def self.find_by_slug!(slug)
-      friendly.find(slug)
+    # Finds the topic by its slug or ID, or raises Thredded::Errors::TopicNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::Topic]
+    # @raise [Thredded::Errors::TopicNotFound] if the topic with the given slug does not exist.
+    def self.friendly_find!(slug_or_id)
+      friendly.find(slug_or_id)
     rescue ActiveRecord::RecordNotFound
       raise Thredded::Errors::TopicNotFound
     end

data/app/models/thredded/user_detail.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Thredded
   class UserDetail < ActiveRecord::Base
-    include ModerationState
+    include Thredded::ModerationState
 
     belongs_to :user, class_name: Thredded.user_class, inverse_of: :thredded_user_detail
     validates :user_id, presence: true, uniqueness: true

data/app/models/thredded/user_extender.rb

@@ -9,7 +9,7 @@ module Thredded
     include ::Thredded::UserPermissions::Moderate::IfModeratorColumnTrue
     include ::Thredded::UserPermissions::Admin::IfAdminColumnTrue
 
-    included do
+    included do # rubocop:disable Metrics/BlockLength
       with_options dependent: :nullify, foreign_key: 'user_id', inverse_of: :user do |opt|
         opt.has_many :thredded_posts, class_name: 'Thredded::Post'
         opt.has_many :thredded_topics, class_name: 'Thredded::Topic'
@@ -24,6 +24,8 @@ module Thredded
 
       with_options dependent: :destroy, foreign_key: 'user_id', inverse_of: :user do |opt|
         opt.has_many :thredded_user_messageboard_preferences, class_name: 'Thredded::UserMessageboardPreference'
+        opt.has_many :thredded_notifications_for_followed_topics, class_name: 'Thredded::NotificationsForFollowedTopics'
+        opt.has_many :thredded_notifications_for_private_topics, class_name: 'Thredded::NotificationsForPrivateTopics'
         opt.has_many :thredded_private_users, class_name: 'Thredded::PrivateUser'
         opt.has_many :thredded_topic_read_states, class_name: 'Thredded::UserTopicReadState'
         opt.has_many :thredded_private_topic_read_states, class_name: 'Thredded::UserPrivateTopicReadState'

data/app/models/thredded/user_preference.rb

@@ -2,11 +2,22 @@
 module Thredded
   class UserPreference < ActiveRecord::Base
     belongs_to :user, class_name: Thredded.user_class, inverse_of: :thredded_user_preference
-    has_many :messageboard_preferences,
-             class_name: 'Thredded::UserMessageboardPreference',
-             primary_key: :user_id,
-             foreign_key: :user_id,
-             inverse_of: :user_preference
+
+    with_options(inverse_of: :user_preference, primary_key: :user_id, foreign_key: :user_id,
+                 dependent: :destroy) do |opt|
+      opt.has_many :messageboard_preferences,
+                   class_name: 'Thredded::UserMessageboardPreference'
+      opt.has_many :messageboard_notifications_for_followed_topics,
+                   class_name: 'Thredded::MessageboardNotificationsForFollowedTopics'
+      opt.has_many :notifications_for_followed_topics,
+                   class_name: 'Thredded::NotificationsForFollowedTopics'
+      opt.has_many :notifications_for_private_topics,
+                   class_name: 'Thredded::NotificationsForPrivateTopics'
+    end
     validates :user_id, presence: true
+
+    accepts_nested_attributes_for :notifications_for_followed_topics,
+                                  :notifications_for_private_topics,
+                                  :messageboard_notifications_for_followed_topics
   end
 end