threddedDANIEL 0.14.5

data/app/mailer_previews/thredded/post_mailer_preview.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Previews for the PostMailer
+  class PostMailerPreview < BaseMailerPreview
+    def post_notification
+      PostMailer.post_notification(
+        mock_post(content: mock_content(mention_users: %w[glebm joel])),
+        %w[glebm@test.com joel@test.com]
+      )
+    end
+  end
+end

data/app/mailer_previews/thredded/private_topic_mailer_preview.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Previews for the PrivateTopicMailer
+  class PrivateTopicMailerPreview < BaseMailerPreview
+    def message_notification
+      PrivateTopicMailer.message_notification(
+        mock_private_post(content: mock_content(mention_users: ['glebm'])),
+        %w[glebm@test.com joel@test.com]
+      )
+    end
+  end
+end

data/app/mailers/thredded/base_mailer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Thredded
+  class BaseMailer < Thredded.parent_mailer.constantize
+    helper ::Thredded::UrlsHelper
+
+    protected
+
+    # Find a record by ID, or return the passed record.
+    # @param [Class<ActiveRecord::Base>] klass
+    # @param [Integer, String, klass] id_or_record
+    # @return [klass]
+    def find_record(klass, id_or_record)
+      # Check by name because in development the Class might have been reloaded after id was initialized
+      id_or_record.class.name == klass.name ? id_or_record : klass.find(id_or_record)
+    end
+  end
+end

data/app/mailers/thredded/post_mailer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PostMailer < Thredded::BaseMailer
+    def post_notification(post_id, emails)
+      @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,
+           to: email_details.no_reply,
+           bcc: emails,
+           subject: [
+             Thredded.email_outgoing_prefix,
+             t('thredded.emails.post_notification.subject',
+               user: @post.user.thredded_display_name,
+               topic_title: @post.postable.title)
+           ].compact.join
+    end
+  end
+end

data/app/mailers/thredded/private_topic_mailer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivateTopicMailer < Thredded::BaseMailer
+    def message_notification(post_id, emails)
+      @post = find_record Thredded::PrivatePost, post_id
+      email_details = Thredded::TopicEmailView.new(@post.postable)
+      headers['X-SMTPAPI'] = email_details.smtp_api_tag('private_topic_mailer')
+
+      mail from: email_details.no_reply,
+           to: email_details.no_reply,
+           bcc: emails,
+           subject: [
+             Thredded.email_outgoing_prefix,
+             t('thredded.emails.message_notification.subject',
+               user: @post.user.thredded_display_name,
+               topic_title: @post.postable.title)
+           ].compact.join
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Moderation state of a piece of content, such as a Thredded::Topic or a Thredded::Post.
+  # Requires an integer moderation_state column, a user_id column, and a user_detail association on the including class.
+  # @api private
+  module ContentModerationState
+    extend ActiveSupport::Concern
+    include Thredded::ModerationState
+
+    included do
+      before_validation :set_default_moderation_state, on: :create
+
+      scope :moderation_state_visible_to_all, -> { where(visible_to_all_arel_node) }
+
+      scope :moderation_state_visible_to_user, (lambda do |user|
+        visible = visible_to_all_arel_node
+        # @type [Arel::Table]
+        table = arel_table
+        if user && !user.thredded_anonymous?
+          # Own content
+          visible = visible.or(table[:user_id].eq(user.id))
+          # Content that one can moderate
+          moderatable_messageboard_ids = user.thredded_can_moderate_messageboards.map(&:id)
+          if moderatable_messageboard_ids.present?
+            visible = visible.or(table[:messageboard_id].in(moderatable_messageboard_ids))
+          end
+        end
+        where(visible)
+      end)
+
+      # @return [Arel::Nodes::Node]
+      # @api private
+      def self.visible_to_all_arel_node
+        if Thredded.content_visible_while_pending_moderation
+          # All non-blocked content
+          arel_table[:moderation_state].not_eq(moderation_states[:blocked])
+        else
+          # Only approved content
+          arel_table[:moderation_state].eq(moderation_states[:approved])
+        end
+      end
+    end
+
+    # Whether this is visible to anyone based on the moderation state.
+    def moderation_state_visible_to_all?
+      if Thredded.content_visible_while_pending_moderation
+        !blocked?
+      else
+        approved?
+      end
+    end
+
+    # Whether this is visible to the given user based on the moderation state.
+    def moderation_state_visible_to_user?(user)
+      moderation_state_visible_to_all? ||
+        (!user.thredded_anonymous? &&
+          (user_id == user.id || user.thredded_can_moderate_messageboards.map(&:id).include?(messageboard_id)))
+    end
+
+    private
+
+    def set_default_moderation_state
+      self.moderation_state ||= user_detail.moderation_state
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'set'
+module Thredded
+  # Excludes pagination routes in addition to the given list of reserved words.
+  class FriendlyIdReservedWordsAndPagination
+    PAGINATION_PATTERN = /\Apage-\d+\z/i
+
+    def initialize(words = [])
+      @words = Set.new(words)
+    end
+
+    def include?(slug)
+      @words.include?(slug) || slug =~ PAGINATION_PATTERN
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Defines a moderation_state enum
+  # Requires an integer moderation_state column on the including class.
+  module ModerationState
+    extend ActiveSupport::Concern
+
+    included do
+      enum moderation_state: %i[pending_moderation approved blocked]
+      validates :moderation_state, presence: true
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Thredded
+  # @abstract Classes that include this module are expected to implement {#readers}.
+  # @!method readers
+  #     @abstract
+  #     @return [ActiveRecord::Relation<Thredded.user_class>] users from that can read this post.
+  module PostCommon
+    extend ActiveSupport::Concern
+
+    included do
+      paginates_per 50
+
+      delegate :email, to: :user, prefix: true, allow_nil: true
+
+      validates :content, presence: true
+
+      scope :order_oldest_first, -> { order(created_at: :asc, id: :asc) }
+      scope :order_newest_first, -> { order(created_at: :desc, id: :desc) }
+
+      before_validation :ensure_user_detail, on: :create
+    end
+
+    def avatar_url
+      Thredded.avatar_url.call(user)
+    end
+
+    def calculate_page(postable_posts, per_page)
+      1 + postable_posts.where(postable_posts.arel_table[:created_at].lt(created_at)).count / per_page
+    end
+
+    # @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) }, **options)
+      Thredded::ContentFormatter.new(view_context, users_provider: users_provider, **options).format_content(content)
+    end
+
+    def first_post_in_topic?
+      postable.first_post == self
+    end
+
+    # @return [ActiveRecord::Relation<Thredded.user_class>] users from the list of user names that can read this post.
+    # @api private
+    def readers_from_user_names(user_names)
+      DbTextSearch::CaseInsensitive
+        .new(readers, Thredded.user_name_column)
+        .in(user_names)
+    end
+
+    # Marks all the posts from the given one as unread for the given user
+    # @param user [Thredded.user_class]
+    # @param page [Integer]
+    def mark_as_unread(user, page)
+      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,
+          page: page
+        ).find_or_create_by(user_id: user.id)
+        read_state.update_columns(read_at: previous_post.created_at, page: page)
+      end
+    end
+
+    def previous_post
+      @previous_post ||= postable.posts.order_newest_first.find_by('created_at < ?', created_at)
+    end
+
+    private
+
+    def ensure_user_detail
+      build_user_detail if user && !user_detail
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Thredded
+  class SearchParser
+    def initialize(query)
+      @query = query
+      @keywords = %w[in by order]
+    end
+
+    def parse
+      parsed_input = parse_keywords
+      parsed_input['text'] = parse_text
+      parsed_input
+    end
+
+    def parse_keywords
+      found_terms_hash = {}
+
+      @keywords.each do |keyword|
+        regex = Regexp.new(keyword + '\s*:\s*\w+', Regexp::IGNORECASE)
+        keyword_scan = @query.scan(regex)
+        @query = @query.gsub(regex, '')
+
+        next if keyword_scan.blank?
+        keyword_scan.each do |term|
+          found_terms_hash[keyword] ||= []
+          found_terms_hash[keyword] << term.delete(' ').split(':')[1]
+        end
+      end
+
+      found_terms_hash
+    end
+
+    def parse_text
+      regex = Regexp.new('\"[^"]*\"')
+      found_terms = @query.scan(regex)
+      @query = @query.sub(regex, '')
+      found_terms.concat(@query.split(/\s+/))
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Thredded
+  module TopicCommon
+    extend ActiveSupport::Concern
+    included do
+      paginates_per 50 if respond_to?(:paginates_per)
+
+      belongs_to :last_user,
+                 class_name: Thredded.user_class_name,
+                 foreign_key: 'last_user_id',
+                 **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+      scope :order_recently_posted_first, -> { order(last_post_at: :desc, id: :desc) }
+      scope :on_page, ->(page_num) { page(page_num) }
+
+      validates :hash_id, presence: true, uniqueness: true
+      validates :posts_count, numericality: true
+
+      before_validation do
+        self.hash_id = SecureRandom.hex(10) if hash_id.nil?
+      end
+
+      delegate :name, :name=, :email, :email=, to: :user, prefix: true
+
+      before_validation :ensure_user_detail, on: :create
+    end
+
+    def user
+      super || Thredded::NullUser.new
+    end
+
+    def last_user
+      super || Thredded::NullUser.new
+    end
+
+    def private?
+      !public?
+    end
+
+    private
+
+    def ensure_user_detail
+      build_user_detail if user && !user_detail
+    end
+
+    module ClassMethods
+      # @param user [Thredded.user_class]
+      # @return [ActiveRecord::Relation]
+      def unread(user)
+        topics      = arel_table
+        reads_class = reflect_on_association(:user_read_states).klass
+        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
+
+      private
+
+      # @param user [Thredded.user_class]
+      # @return [ByPostableLookup]
+      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))
+        Thredded::TopicCommon::CachingHash.from_relation(read_states)
+      end
+
+      public
+
+      # @param user [Thredded.user_class]
+      # @return [Array<[TopicCommon, UserTopicReadStateCommon]>]
+      def with_read_states(user)
+        null_read_state = Thredded::NullUserTopicReadState.new
+        return current_scope.zip([null_read_state]) if user.thredded_anonymous?
+        read_states_by_postable = read_states_by_postable_hash(user)
+        current_scope.map do |postable|
+          [postable, read_states_by_postable[postable] || null_read_state]
+        end
+      end
+    end
+
+    class CachingHash < Hash
+      def self.from_relation(postable_relation)
+        self[postable_relation.map { |related| [related.postable_id, related] }]
+      end
+
+      # lookup related item by postable and set the inverse lookup
+      def [](postable)
+        super(postable.id).tap { |related| related.postable = postable if related }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Thredded
+  class TopicsSearch
+    def initialize(query, scope)
+      @terms = Thredded::SearchParser.new(query).parse
+      @scope = scope
+
+      @search_categories = @search_users = @search_text = nil
+    end
+
+    # @return [ActiveRecord::Relation<Thredded::Topic>]
+    def search
+      if categories.present?
+        @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)
+      else
+        @scope
+      end
+    end
+
+    protected
+
+    def search_topics
+      scope = @scope
+      scope = @scope.where(user_id: users) if users.present?
+      scope = DbTextSearch::FullText.new(scope, :title).search(text) if text.present?
+      scope
+    end
+
+    def search_posts
+      posts_scope = Thredded::Post
+      posts_scope = posts_scope.where(user_id: users) if users.present?
+      posts_scope = DbTextSearch::FullText.new(posts_scope, :content).search(text) if text.present?
+      @scope.joins(:posts).merge(posts_scope)
+    end
+
+    def categories
+      @search_categories ||=
+        if @terms['in'].present?
+          DbTextSearch::CaseInsensitive
+            .new(Category, :name)
+            .in(@terms['in']).pluck(:id)
+        else
+          []
+        end
+    end
+
+    def users
+      @search_users ||=
+        if @terms['by']
+          DbTextSearch::CaseInsensitive
+            .new(Thredded.user_class, Thredded.user_name_column)
+            .in(@terms['by']).pluck(:id)
+        else
+          []
+        end
+    end
+
+    # @return [Array<String>]
+    def text
+      @terms['text']
+    end
+  end
+end