rails_den 2.0.0

data/app/services/rails_den/search/adapters/postgresql.rb

@@ -0,0 +1,73 @@
+module RailsDen
+  module Search
+    module Adapters
+      class Postgresql
+        CONFIGURATION = "simple".freeze
+
+        def search(relation:, columns:, query:)
+          normalized_query =
+            query
+              .to_s
+              .strip
+
+          return relation.none if normalized_query.blank?
+
+          verify_postgresql!(relation)
+
+          tsquery =
+            prefix_tsquery(
+              normalized_query
+            )
+
+          return relation.none if tsquery.blank?
+
+          relation.where(
+            "#{search_vector(columns)} @@ " \
+              "to_tsquery('#{CONFIGURATION}', ?)",
+            tsquery
+          )
+        end
+
+        private
+
+        def search_vector(columns)
+          expressions =
+            Array(columns).map do |column|
+              "COALESCE(#{column}, '')"
+            end
+
+          combined =
+            expressions.join(
+              " || ' ' || "
+            )
+
+          "to_tsvector('#{CONFIGURATION}', #{combined})"
+        end
+
+        def prefix_tsquery(query)
+          query
+            .downcase
+            .scan(/[[:alnum:]_]+/)
+            .map do |term|
+              "#{term}:*"
+            end
+            .join(" & ")
+        end
+
+        def verify_postgresql!(relation)
+          adapter_name =
+            relation
+              .connection
+              .adapter_name
+              .to_s
+              .downcase
+
+          return if adapter_name.include?("postgres")
+
+          raise ArgumentError,
+                "RailsDen's :postgresql search adapter requires PostgreSQL"
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/search/adapters.rb

@@ -0,0 +1,21 @@
+module RailsDen
+  module Search
+    module Adapters
+      class << self
+        def resolve(adapter = RailsDen.config.search_adapter)
+          return adapter if adapter.respond_to?(:search)
+
+          case adapter.to_s
+          when "", "basic"
+            Basic.new
+          when "postgresql"
+            Postgresql.new
+          else
+            raise ArgumentError,
+                  "Unknown RailsDen search adapter: #{adapter.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/search/query.rb

@@ -0,0 +1,358 @@
+module RailsDen
+  module Search
+    class Query
+      RESULT_LIMIT = 50
+      MEMBER_RESULT_LIMIT = 25
+      AUTHOR_FILTER_LIMIT = 100
+
+      Result =
+        Data.define(
+          :record,
+          :type
+        )
+
+      def self.call(
+        query:,
+        viewer:,
+        board_id: nil,
+        author: nil,
+        from_date: nil,
+        to_date: nil
+      )
+        new(
+          query: query,
+          viewer: viewer,
+          board_id: board_id,
+          author: author,
+          from_date: from_date,
+          to_date: to_date
+        ).call
+      end
+
+      def initialize(
+        query:,
+        viewer:,
+        board_id:,
+        author:,
+        from_date:,
+        to_date:
+      )
+        @query =
+          query
+            .to_s
+            .strip
+
+        @viewer = viewer
+        @board_id = board_id.to_s.strip
+        @author = author.to_s.strip
+        @from_date = from_date.to_s.strip
+        @to_date = to_date.to_s.strip
+      end
+
+      def call
+        return [] if query.blank?
+
+        content_results =
+          topic_results +
+          post_results
+
+        return content_results if content_filters_active?
+
+        content_results +
+          tag_results +
+          member_results
+      end
+
+      private
+
+      attr_reader :query,
+                  :viewer,
+                  :board_id,
+                  :author,
+                  :from_date,
+                  :to_date
+
+      def topic_results
+        relation =
+          readable_content
+            .topics
+            .includes(:board)
+
+        relation =
+          apply_content_filters(
+            relation
+          )
+
+        relation =
+          search_adapter.search(
+            relation: relation,
+            columns: [
+              "rails_den_topics.title"
+            ],
+            query: query
+          )
+
+        relation
+          .order(
+            created_at: :desc,
+            id: :desc
+          )
+          .limit(RESULT_LIMIT)
+          .map do |topic|
+            Result.new(
+              record: topic,
+              type: :topic
+            )
+          end
+      end
+
+      def post_results
+        relation =
+          readable_content
+            .posts
+            .includes(
+              topic: :board
+            )
+
+        relation =
+          apply_content_filters(
+            relation
+          )
+
+        relation =
+          search_adapter.search(
+            relation: relation,
+            columns: [
+              "rails_den_posts.body"
+            ],
+            query: query
+          )
+
+        relation
+          .order(
+            created_at: :desc,
+            id: :desc
+          )
+          .limit(RESULT_LIMIT)
+          .map do |post|
+            Result.new(
+              record: post,
+              type: :post
+            )
+          end
+      end
+
+      def tag_results
+        relation =
+          RailsDen::Tag
+            .where(enabled: true)
+
+        relation =
+          search_adapter.search(
+            relation: relation,
+            columns: [
+              "rails_den_tags.title",
+              "rails_den_tags.slug",
+              "rails_den_tags.description"
+            ],
+            query: query
+          )
+
+        relation
+          .ordered
+          .limit(RESULT_LIMIT)
+          .map do |tag|
+            Result.new(
+              record: tag,
+              type: :tag
+            )
+          end
+      end
+
+      def member_results
+        resolver =
+          RailsDen.config
+            .user_search_resolver
+
+        return [] unless resolver.respond_to?(:call)
+
+        Array(
+          resolver.call(
+            normalized_query,
+            MEMBER_RESULT_LIMIT
+          )
+        )
+          .compact
+          .uniq do |identity|
+            [
+              identity.class.polymorphic_name,
+              identity.id
+            ]
+          end
+          .map do |identity|
+            Result.new(
+              record: identity,
+              type: :member
+            )
+          end
+      end
+
+      def apply_content_filters(relation)
+        relation =
+          apply_board_filter(
+            relation
+          )
+
+        relation =
+          apply_author_filter(
+            relation
+          )
+
+        relation =
+          apply_from_date_filter(
+            relation
+          )
+
+        apply_to_date_filter(
+          relation
+        )
+      end
+
+      def apply_board_filter(relation)
+        return relation if board_id.blank?
+
+        id =
+          normalized_board_id
+
+        return relation.none unless id
+
+        relation.where(
+          rails_den_topics: {
+            board_id: id
+          }
+        )
+      end
+
+      def apply_author_filter(relation)
+        return relation if author.blank?
+
+        identities =
+          author_identities
+
+        return relation.none if identities.empty?
+
+        relation.where(
+          author: identities
+        )
+      end
+
+      def apply_from_date_filter(relation)
+        return relation if from_date.blank?
+
+        time =
+          parsed_from_date
+
+        return relation.none unless time
+
+        relation.where(
+          "#{relation.klass.table_name}.created_at >= ?",
+          time
+        )
+      end
+
+      def apply_to_date_filter(relation)
+        return relation if to_date.blank?
+
+        time =
+          parsed_to_date
+
+        return relation.none unless time
+
+        relation.where(
+          "#{relation.klass.table_name}.created_at <= ?",
+          time
+        )
+      end
+
+      def author_identities
+        @author_identities ||=
+          begin
+            resolver =
+              RailsDen.config
+                .user_search_resolver
+
+            if resolver.respond_to?(:call)
+              Array(
+                resolver.call(
+                  author.downcase,
+                  AUTHOR_FILTER_LIMIT
+                )
+              )
+                .compact
+                .uniq do |identity|
+                  [
+                    identity.class.polymorphic_name,
+                    identity.id
+                  ]
+                end
+            else
+              []
+            end
+          end
+      end
+
+      def normalized_board_id
+        Integer(
+          board_id,
+          10
+        )
+      rescue ArgumentError
+        nil
+      end
+
+      def parsed_from_date
+        parse_date(
+          from_date
+        )&.in_time_zone&.beginning_of_day
+      end
+
+      def parsed_to_date
+        parse_date(
+          to_date
+        )&.in_time_zone&.end_of_day
+      end
+
+      def parse_date(value)
+        Date.iso8601(
+          value
+        )
+      rescue Date::Error
+        nil
+      end
+
+      def content_filters_active?
+        board_id.present? ||
+          author.present? ||
+          from_date.present? ||
+          to_date.present?
+      end
+
+      def readable_content
+        @readable_content ||=
+          ReadableCommunityContent.new(
+            viewer: viewer
+          )
+      end
+
+      def search_adapter
+        @search_adapter ||=
+          RailsDen::Search::Adapters.resolve
+      end
+
+      def normalized_query
+        @normalized_query ||=
+          query.downcase
+      end
+    end
+  end
+end

data/app/services/rails_den/topic_following.rb

@@ -0,0 +1,91 @@
+module RailsDen
+  class TopicFollowing
+    Result = Data.define(
+      :topic_follow,
+      :following,
+      :changed
+    )
+
+    def initialize(topic:, follower:)
+      raise ArgumentError, "topic is required" if topic.nil?
+      raise ArgumentError, "follower is required" if follower.nil?
+
+      @topic = topic
+      @follower = follower
+    end
+
+    def follow
+      existing_follow = find_follow
+
+      if existing_follow
+        return result(
+          topic_follow: existing_follow,
+          following: true,
+          changed: false
+        )
+      end
+
+      topic_follow =
+        topic
+          .topic_follows
+          .create_or_find_by!(
+            follower: follower
+          )
+
+      result(
+        topic_follow: topic_follow,
+        following: true,
+        changed: topic_follow.previously_new_record?
+      )
+    rescue ActiveRecord::RecordNotUnique
+      result(
+        topic_follow: find_follow!,
+        following: true,
+        changed: false
+      )
+    end
+
+    def unfollow
+      topic_follow = find_follow
+
+      unless topic_follow
+        return result(
+          topic_follow: nil,
+          following: false,
+          changed: false
+        )
+      end
+
+      TopicFollow.transaction do
+        topic_follow.destroy!
+      end
+
+      result(
+        topic_follow: nil,
+        following: false,
+        changed: true
+      )
+    end
+
+    private
+
+    attr_reader :topic,
+                :follower
+
+    def find_follow
+      topic.topic_follows.find_by(
+        follower: follower
+      )
+    end
+
+    def find_follow!
+      topic.topic_follows.find_by!(
+        follower: follower
+      )
+    end
+
+    def result(**attributes)
+      Result.new(**attributes)
+    end
+  end
+end

data/app/services/rails_den/topic_merger.rb

@@ -0,0 +1,27 @@
+module RailsDen
+  class TopicMerger
+    def self.call(source:, destination:, actor:)
+      raise ArgumentError, "topics must differ" if source == destination
+      TopicModeration.authorize!(actor, source)
+      TopicModeration.authorize!(actor, destination)
+      destination_opening_post = destination.opening_post || destination.posts.order(:created_at, :id).first
+
+      Topic.transaction do
+        source.topic_follows.includes(:follower).each do |follow|
+          destination.topic_follows.create_or_find_by!(follower: follow.follower)
+        end
+        destination.tags = (destination.tags.to_a + source.tags.to_a).uniq.first(RailsDen.config.max_tags_per_topic)
+        source.topic_read_states.destroy_all
+        source.posts.update_all(topic_id: destination.id)
+        destination.update!(opening_post: destination_opening_post) if destination_opening_post
+        source.update!(merged_into: destination)
+        ModerationAudit.record!(action: "topic.merged", subject: source, actor: actor,
+                                scope_board: destination.board,
+                                metadata: { "source_topic" => source.title,
+                                            "destination_topic" => destination.title,
+                                            "destination_topic_id" => destination.id })
+      end
+      destination
+    end
+  end
+end

data/app/services/rails_den/topic_moderation.rb

@@ -0,0 +1,57 @@
+module RailsDen
+  class TopicModeration
+    def self.authorize!(actor, topic)
+      raise ActiveRecord::RecordNotFound unless PermissionResolver.allowed?(
+        user: actor, capability: :moderate, topic: topic
+      )
+    end
+
+    def self.toggle!(topic:, actor:, attribute:, value:)
+      authorize!(actor, topic)
+      action = {
+        [:pinned, true] => "topic.pinned",
+        [:pinned, false] => "topic.unpinned",
+        [:locked, true] => "topic.locked",
+        [:locked, false] => "topic.unlocked"
+      }.fetch([attribute, value])
+      Topic.transaction do
+        changes = { attribute => value }
+        changes.merge!(pinned_at: value ? Time.current : nil, pinned_by: value ? actor : nil) if attribute == :pinned
+        topic.update!(changes)
+        ModerationAudit.record!(action: action, subject: topic, actor: actor, scope_board: topic.board)
+      end
+      topic
+    end
+
+    def self.move!(topic:, destination:, actor:)
+      authorize!(actor, topic)
+      raise ActiveRecord::RecordNotFound unless PermissionResolver.allowed?(
+        user: actor, capability: :moderate, board: destination
+      )
+      source = topic.board
+      Topic.transaction do
+        topic.update!(board: destination)
+        ModerationAudit.record!(action: "topic.moved", subject: topic, actor: actor,
+                                scope_board: destination,
+                                metadata: { "source_board" => source.title, "destination_board" => destination.title })
+      end
+      topic
+    end
+
+    def self.soft_delete!(topic:, actor:)
+      authorize!(actor, topic)
+      Topic.transaction do
+        topic.update!(deleted_at: Time.current, deleted_by: actor)
+        ModerationAudit.record!(action: "topic.deleted", subject: topic, actor: actor, scope_board: topic.board)
+      end
+    end
+
+    def self.restore!(topic:, actor:)
+      authorize!(actor, topic)
+      Topic.transaction do
+        topic.update!(deleted_at: nil, deleted_by: nil)
+        ModerationAudit.record!(action: "topic.restored", subject: topic, actor: actor, scope_board: topic.board)
+      end
+    end
+  end
+end

data/app/services/rails_den/topic_splitter.rb

@@ -0,0 +1,36 @@
+module RailsDen
+  class TopicSplitter
+    def self.call(source:, starting_post:, destination_board:, title:, actor:)
+      TopicModeration.authorize!(actor, source)
+      raise ActiveRecord::RecordNotFound unless PermissionResolver.allowed?(
+        user: actor, capability: :moderate, board: destination_board
+      )
+      raise ArgumentError, "cannot split from the opening post" if starting_post.opening_post?
+
+      new_topic = nil
+      Topic.transaction do
+        moving = source.posts.where(
+          "created_at > ? OR (created_at = ? AND id >= ?)",
+          starting_post.created_at, starting_post.created_at, starting_post.id
+        ).order(:created_at, :id).to_a
+        new_topic = Topic.create!(board: destination_board, author: starting_post.author, title: title)
+        Post.where(id: moving.map(&:id)).update_all(topic_id: new_topic.id)
+        new_topic.update!(opening_post: starting_post)
+
+        Post.where(id: moving.map(&:id)).find_each do |post|
+          changes = {}
+          changes[:reply_to_id] = nil if post.reply_to_id && !moving.any? { |item| item.id == post.reply_to_id }
+          changes[:quoted_post_id] = nil if post.quoted_post_id && !moving.any? { |item| item.id == post.quoted_post_id }
+          post.update_columns(changes) if changes.any?
+        end
+        source.topic_read_states.where(last_read_post_id: moving.map(&:id)).destroy_all
+        ModerationAudit.record!(action: "topic.split", subject: source, actor: actor,
+                                scope_board: destination_board,
+                                metadata: { "new_topic" => new_topic.title, "new_topic_id" => new_topic.id,
+                                            "starting_post_id" => starting_post.id,
+                                            "destination_board" => destination_board.title })
+      end
+      new_topic
+    end
+  end
+end