threddedDANIEL 0.14.5

data/app/assets/stylesheets/thredded/utilities/_is-expanded.scss

@@ -0,0 +1,16 @@
+.thredded--is-expanded {
+  label {
+    height: auto;
+    margin-bottom: $thredded-small-spacing / 2;
+    opacity: 1;
+    visibility: visible;
+  }
+
+  .private_users,
+  .content,
+  .submit {
+    height: auto;
+    opacity: 1;
+    visibility: visible;
+  }
+}

data/app/commands/thredded/at_notification_extractor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Thredded
+  class AtNotificationExtractor
+    def initialize(post)
+      @post = post
+    end
+
+    # @return [Array<Thredded.user_class>]
+    def run
+      view_context = Thredded::ApplicationController.new.view_context
+      # Do not highlight @-mentions at first, because:
+      # * When parsing, @-mentions within <a> tags will not be considered.
+      # * We can't always generate the user URL here because request.host is not available.
+      html = @post.filtered_content(view_context, users_provider: nil)
+      Thredded::HtmlPipeline::AtMentionFilter.new(
+        html,
+        view_context: view_context,
+        users_provider: ->(user_names) { @post.readers_from_user_names(user_names).to_a }
+      ).mentioned_users
+    end
+  end
+end

data/app/commands/thredded/autofollow_users.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Thredded
+  class AutofollowUsers
+    def initialize(post)
+      @post = post
+    end
+
+    def run
+      new_followers.each do |user, reason|
+        Thredded::UserTopicFollow.create_unless_exists(user.id, post.postable_id, reason)
+      end
+    end
+
+    # @return [Array<Thredded.user_class>]
+    def mentioned_users
+      @mentioned_users ||= Thredded::AtNotificationExtractor.new(post).run
+    end
+
+    # @return [Hash<Thredded.user_class, Symbol]>] a map of users that should get subscribed to their the follow reason.
+    def new_followers
+      result = {}
+      auto_followers.each { |user| result[user] = :auto }
+      exclude_follow_on_mention_opt_outs(mentioned_users).each { |user| result[user] = :mentioned }
+      result.delete(post.user)
+      result
+    end
+
+    private
+
+    attr_reader :post
+
+    # Returns the users that have:
+    #   UserMessageboardPreference#auto_follow_topics? && UserPreference#auto_follow_topics?
+    # If the `user_preference` for a given does not exist, its default value is used.
+    # @return [Enumerable<Thredded.user_class>]
+    def auto_followers
+      user_board_prefs = post.messageboard.user_messageboard_preferences.each_with_object({}) do |ump, h|
+        h[ump.user_id] = ump
+      end
+      Thredded.user_class.includes(:thredded_user_preference)
+        .select(Thredded.user_class.primary_key)
+        .find_each(batch_size: 50_000).select do |user|
+
+        result = user_board_prefs[user.id]
+        result ||= Thredded::UserMessageboardPreference.new(
+          messageboard: post.messageboard,
+          user_preference: user.thredded_user_preference
+        )
+        result.auto_follow_topics?
+      end
+    end
+
+    # @return [Enumerable<Thredded.user_class>]
+    def exclude_follow_on_mention_opt_outs(users)
+      users.select do |user|
+        user.thredded_user_preference.follow_topics_on_mention? &&
+          user.thredded_user_messageboard_preferences.in(post.messageboard).follow_topics_on_mention?
+      end
+    end
+  end
+end

data/app/commands/thredded/create_messageboard.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Creates a new messageboard and seeds it with a topic.
+  class CreateMessageboard
+    # @param messageboard [Thredded::Messageboard]
+    # @param user [Thredded.user_class]
+    def initialize(messageboard, user)
+      @messageboard = messageboard
+      @user = user
+    end
+
+    # @return [boolean] true if the messageboard was created and seeded with a topic successfully.
+    def run
+      Thredded::Messageboard.transaction do
+        fail ActiveRecord::Rollback unless @messageboard.save
+        topic = Thredded::Topic.create!(
+          messageboard: @messageboard,
+          user: @user,
+          title: first_topic_title
+        )
+        Thredded::Post.create!(
+          messageboard: @messageboard,
+          user: @user,
+          postable: topic,
+          content: first_topic_content
+        )
+        true
+      end
+    end
+
+    def first_topic_title
+      I18n.t('thredded.messageboard_first_topic.title')
+    end
+
+    def first_topic_content
+      <<-MARKDOWN
+#{I18n.t('thredded.messageboard_first_topic.content', thredded_version: Thredded::VERSION)}
+      MARKDOWN
+    end
+  end
+end

data/app/commands/thredded/mark_all_read.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Thredded
+  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
+        total_pages = topic.posts.page(1).total_pages
+
+        Thredded::UserPrivateTopicReadState.touch!(
+          user.id,
+          topic.id,
+          last_post,
+          total_pages
+        )
+      end
+    end
+  end
+end

data/app/commands/thredded/moderate_post.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Thredded
+  module ModeratePost
+    module_function
+
+    # @param [Post] post
+    # @param [Symbol] moderation_state
+    # @param [Thredded.user_class] moderator
+    # @return [Thredded::PostModerationRecord]
+    def run!(post:, moderation_state:, moderator:)
+      Thredded::Post.transaction do
+        post_moderation_record = Thredded::PostModerationRecord.record!(
+          moderator: moderator,
+          post: post,
+          previous_moderation_state: post.moderation_state,
+          moderation_state: moderation_state,
+        )
+        if post.user_id && post.user_detail.pending_moderation?
+          update_without_timestamping!(post.user_detail, moderation_state: moderation_state)
+        end
+        if post.postable.first_post == post
+          update_without_timestamping!(post.postable, moderation_state: moderation_state)
+          if moderation_state == :blocked
+            # When blocking the first post of a topic, also block all the other posts in the topic by this user.
+            post.postable.posts.where(user_id: post.user.id).where.not(id: post.id).each do |a_post|
+              update_without_timestamping!(a_post, moderation_state: moderation_state)
+            end
+          end
+        end
+        update_without_timestamping!(post, moderation_state: moderation_state)
+        post_moderation_record
+      end
+    end
+
+    # @param record [ActiveRecord]
+    # @api private
+    def update_without_timestamping!(record, *attr)
+      record_timestamps_was = record.record_timestamps
+      begin
+        record.record_timestamps = false
+        record.update!(*attr)
+      ensure
+        record.record_timestamps = record_timestamps_was
+      end
+    end
+  end
+end

data/app/commands/thredded/notify_following_users.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Thredded
+  class NotifyFollowingUsers
+    def initialize(post)
+      @post = post
+    end
+
+    def run
+      subscribed_users.select! do |user|
+        # Record idempotently that the notification happened.
+        # If a notification was already created (e.g. from another thread/process),
+        # this will return false due to the unique constraint on the table
+        # and the user will be excluded.
+        subscribed_via_any_notifier?(user) && record_as_notified_successful?(user)
+      end
+      Thredded.notifiers.each do |notifier|
+        notifiable_users = targeted_users(notifier)
+        next if notifiable_users.empty?
+        notifier.new_post(@post, notifiable_users)
+      end
+    end
+
+    def targeted_users(notifier)
+      subscribed_users.select do |user|
+        user_subscribed_via?(user, notifier)
+      end
+    end
+
+    def user_subscribed_via?(user, notifier)
+      Thredded::NotificationsForFollowedTopics
+        .detect_or_default(user.thredded_notifications_for_followed_topics, notifier).enabled? &&
+        Thredded::MessageboardNotificationsForFollowedTopics
+          .detect_or_default(messageboard_notifier_prefs_by_user_id[user.id], notifier).enabled?
+    end
+
+    # @return [Array<User>]
+    def subscribed_users
+      @subscribed_users ||=
+        @post.postable.followers.includes(:thredded_notifications_for_followed_topics).select do |user|
+          !already_notified?(user) && !originator?(user) && can_read_post?(user)
+        end
+    end
+
+    private
+
+    def originator?(user)
+      user == @post.user
+    end
+
+    def can_read_post?(user)
+      Thredded::PostPolicy.new(user, @post).read?
+    end
+
+    def already_notified?(user)
+      # We memoize the set so that records created during this task do not affect the result,
+      # so that a user can receive notifications via multiple notifiers.
+      @already_notified_user_ids ||= Set.new Thredded::UserPostNotification.notified_user_ids(@post)
+      @already_notified_user_ids.include?(user.id)
+    end
+
+    def subscribed_via_any_notifier?(user)
+      Thredded.notifiers.any? { |notifier| user_subscribed_via?(user, notifier) }
+    end
+
+    def record_as_notified_successful?(user)
+      Thredded::UserPostNotification.create_from_post_and_user(@post, user)
+    end
+
+    def messageboard_notifier_prefs_by_user_id
+      @messageboard_notifier_prefs_by_user_id ||= Thredded::MessageboardNotificationsForFollowedTopics
+        .where(user_id: subscribed_users.map(&:id))
+        .for_messageboard(@post.messageboard).group_by(&:user_id)
+    end
+  end
+end

data/app/commands/thredded/notify_private_topic_users.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Thredded
+  class NotifyPrivateTopicUsers
+    def initialize(private_post)
+      @post = private_post
+      @private_topic = private_post.postable
+    end
+
+    def run
+      Thredded.notifiers.each do |notifier|
+        notifiable_users = targeted_users(notifier)
+        notifier.new_private_post(@post, notifiable_users) if notifiable_users.present?
+      end
+    end
+
+    def targeted_users(notifier)
+      users = private_topic.users.includes(:thredded_notifications_for_private_topics) - [post.user]
+      users = only_those_with_this_notifier_enabled(users, notifier)
+      users
+    end
+
+    private
+
+    attr_reader :post, :private_topic
+
+    def only_those_with_this_notifier_enabled(users, notifier)
+      users.select do |user|
+        Thredded::NotificationsForPrivateTopics
+          .detect_or_default(user.thredded_notifications_for_private_topics, notifier).enabled?
+      end
+    end
+  end
+end

data/app/controllers/concerns/thredded/new_post_params.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Thredded
+  # @api private
+  module NewPostParams
+    protected
+
+    def new_post_params
+      params.fetch(:post, {})
+        .permit(:content, :quote_post_id)
+        .merge(ip: request.remote_ip).tap do |p|
+        quote_id = p.delete(:quote_post_id)
+        if quote_id
+          post = Thredded::Post.find(quote_id)
+          authorize_reading post
+          p[:quote_post] = post
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/thredded/new_private_post_params.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Thredded
+  # @api private
+  module NewPrivatePostParams
+    protected
+
+    def new_private_post_params
+      params.fetch(:post, {})
+        .permit(:content, :quote_private_post_id)
+        .merge(ip: request.remote_ip).tap do |p|
+        quote_id = p.delete(:quote_private_post_id)
+        if quote_id
+          post = Thredded::PrivatePost.find(quote_id)
+          authorize_reading post
+          p[:quote_post] = post
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/thredded/new_private_topic_params.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Thredded
+  # @api private
+  module NewPrivateTopicParams
+    protected
+
+    def new_private_topic_params
+      params
+        .fetch(:private_topic, {})
+        .permit(:title, :content, :user_names, user_ids: [])
+        .merge(
+          user: thredded_current_user,
+          ip: request.remote_ip
+        ).tap { |p| adapt_user_ids! p }
+    end
+
+    private
+
+    # Allow a string of IDs joined with commas.
+    def adapt_user_ids!(p)
+      p[:user_ids] = p[:user_ids].split(',') if p[:user_ids].is_a?(String)
+    end
+  end
+end

data/app/controllers/concerns/thredded/new_topic_params.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Thredded
+  # @api private
+  module NewTopicParams
+    protected
+
+    def new_topic_params
+      params
+        .fetch(:topic, {})
+        .permit(:title, :locked, :sticky, :content, category_ids: [])
+        .merge(
+          messageboard: messageboard,
+          user: thredded_current_user,
+          ip: request.remote_ip,
+        )
+    end
+  end
+end

data/app/controllers/concerns/thredded/render_preview.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  module RenderPreview
+    protected
+
+    def render_preview
+      if request.xhr?
+        render layout: false
+      else
+        @preview_content = render_to_string(layout: false)
+        render template: 'thredded/shared/preview'
+      end
+    end
+  end
+end

data/app/controllers/thredded/application_controller.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Thredded
+  class ApplicationController < ::ApplicationController
+    layout :thredded_layout
+    include ::Thredded::UrlsHelper
+    include Pundit
+
+    helper Thredded::Engine.helpers
+    helper_method \
+      :active_users,
+      :thredded_current_user,
+      :messageboard,
+      :messageboard_or_nil,
+      :preferences,
+      :thredded_signed_in?
+
+    rescue_from Thredded::Errors::MessageboardNotFound,
+                Thredded::Errors::PrivateTopicNotFound,
+                Thredded::Errors::TopicNotFound,
+                Thredded::Errors::UserNotFound do |exception|
+      @error   = exception
+      @message = exception.message
+      render template: 'thredded/error_pages/not_found', status: :not_found
+    end
+
+    rescue_from Pundit::NotAuthorizedError,
+                Thredded::Errors::LoginRequired,
+                Thredded::Errors::TopicCreateDenied,
+                Thredded::Errors::MessageboardCreateDenied,
+                Thredded::Errors::PrivateTopicCreateDenied,
+                Thredded::Errors::MessageboardReadDenied do |exception|
+      @error   = exception
+      @message = if @error.is_a?(Pundit::NotAuthorizedError)
+                   t('thredded.errors.not_authorized')
+                 else
+                   exception.message
+                 end
+      render template: 'thredded/error_pages/forbidden', status: :forbidden
+    end
+
+    protected
+
+    # The `current_user` and `signed_in?` methods are prefixed with `thredded_`
+    # to avoid conflicts with methods from the parent controller.
+
+    def thredded_current_user
+      send(Thredded.current_user_method) || NullUser.new
+    end
+
+    def thredded_signed_in?
+      !thredded_current_user.thredded_anonymous?
+    end
+
+    if Rails::VERSION::MAJOR < 5
+      # redirect_back polyfill
+      def redirect_back(fallback_location:, **args)
+        redirect_to :back, args
+      rescue ActionController::RedirectBackError
+        redirect_to fallback_location, args
+      end
+    end
+
+    # @param given [Hash]
+    # @return [Boolean] whether the given params are a subset of the controller's {#params}.
+    def params_match?(given = {})
+      given.all? { |k, v| v == params[k] }
+    end
+
+    # Returns true if the current page is beyond the end of the collection
+    def page_beyond_last?(page_scope)
+      page_scope.to_a.empty? && page_scope.current_page != 1
+    end
+
+    # Returns URL parameters for the last page of the given page scope.
+    def last_page_params(page_scope)
+      { page: page_scope.total_pages }
+    end
+
+    private
+
+    def thredded_layout
+      Thredded.layout
+    end
+
+    def authorize_reading(obj)
+      authorize obj, :read?
+    rescue Pundit::NotAuthorizedError
+      raise "#{obj.class.to_s.sub(/Thredded::/, 'Thredded::Errors::')}ReadDenied".constantize
+    end
+
+    def authorize_creating(obj)
+      authorize obj, :create?
+    rescue Pundit::NotAuthorizedError
+      raise "#{obj.class.to_s.sub(/Thredded::/, 'Thredded::Errors::')}CreateDenied".constantize
+    end
+
+    def update_user_activity
+      return if !messageboard_or_nil || !thredded_signed_in?
+
+      Thredded::ActivityUpdaterJob.perform_later(
+        thredded_current_user.id,
+        messageboard.id
+      )
+    end
+
+    def pundit_user
+      thredded_current_user
+    end
+
+    # Returns the `@messageboard` instance variable.
+    # If `@messageboard` is not set, it first sets it to the messageboard with the slug or ID given by
+    # `params[:messageboard_id]`.
+    #
+    # @return [Thredded::Messageboard]
+    # @raise [Thredded::Errors::MessageboardNotFound] if the messageboard with the given slug does not exist.
+    def messageboard
+      @messageboard ||= Thredded::Messageboard.friendly_find!(params[:messageboard_id])
+    end
+
+    def messageboard_or_nil
+      messageboard
+    rescue Thredded::Errors::MessageboardNotFound
+      nil
+    end
+
+    def preferences
+      @preferences ||= thredded_current_user.thredded_user_preference
+    end
+
+    def active_users
+      users = if messageboard_or_nil
+                messageboard.recently_active_users
+              else
+                Thredded.user_class.joins(:thredded_user_detail).merge(Thredded::UserDetail.recently_active).to_a
+              end.to_a
+      users.push(thredded_current_user) unless thredded_current_user.is_a?(NullUser)
+      users.uniq
+    end
+
+    def thredded_require_login!
+      fail Thredded::Errors::LoginRequired if thredded_current_user.thredded_anonymous?
+    end
+  end
+end