rails_den 2.0.0

data/app/services/rails_den/mentions/parser.rb

@@ -0,0 +1,185 @@
+module RailsDen
+  module Mentions
+    class Parser
+      MAX_NAME_LENGTH = 30
+      NAME_PATTERN = /[A-Za-z0-9_]/
+
+      Occurrence = Data.define(
+        :start_offset,
+        :end_offset,
+        :source,
+        :mention_name
+      )
+
+      Result = Data.define(
+        :occurrences,
+        :mention_names
+      )
+
+      class << self
+        def parse(body)
+          new(body).parse
+        end
+      end
+
+      def initialize(body)
+        @body = body.to_s
+      end
+
+      def parse
+        occurrences = []
+
+        each_parseable_line do |line, line_offset|
+          excluded_ranges = excluded_ranges_for(line)
+
+          line.to_enum(:scan, mention_pattern).each do
+            match = Regexp.last_match
+            start_offset = match.begin(1)
+
+            next if excluded?(start_offset, excluded_ranges)
+            next if escaped?(line, start_offset)
+
+            source = match[1]
+
+            occurrences << Occurrence.new(
+              start_offset: line_offset + start_offset,
+              end_offset: line_offset + match.end(1),
+              source: source,
+              mention_name: source.delete_prefix("@").downcase
+            )
+          end
+        end
+
+        Result.new(
+          occurrences: occurrences.freeze,
+          mention_names: occurrences
+            .map(&:mention_name)
+            .uniq
+            .freeze
+        )
+      end
+
+      private
+
+      attr_reader :body
+
+      def mention_pattern
+        @mention_pattern ||= /(?:\A|[^A-Za-z0-9_@])(\@[A-Za-z0-9_]{1,#{MAX_NAME_LENGTH}})(?![A-Za-z0-9_])/
+      end
+
+      def each_parseable_line
+        return enum_for(__method__) unless block_given?
+
+        offset = 0
+        fence = nil
+
+        body.each_line do |line|
+          marker = fence_marker(line)
+
+          if fence
+            fence = nil if marker == fence
+          elsif marker
+            fence = marker
+          elsif !blockquote?(line)
+            yield line, offset
+          end
+
+          offset += line.length
+        end
+      end
+
+      def fence_marker(line)
+        match = line.match(/\A {0,3}(`{3,}|~{3,})/)
+
+        match && match[1][0]
+      end
+
+      def blockquote?(line)
+        line.match?(/\A {0,3}>/)
+      end
+
+      def excluded_ranges_for(line)
+        ranges = []
+
+        add_match_ranges(
+          ranges,
+          line,
+          /!?\[[^\]]*\]\([^\)]*\)/
+        )
+        add_match_ranges(
+          ranges,
+          line,
+          /!?\[[^\]]*\]\[[^\]]*\]/
+        )
+        add_match_ranges(
+          ranges,
+          line,
+          /<([A-Za-z][A-Za-z0-9:-]*)\b[^>]*>.*?<\/\1\s*>/
+        )
+        add_match_ranges(
+          ranges,
+          line,
+          /<[^>]*>/
+        )
+        add_match_ranges(
+          ranges,
+          line,
+          %r{(?:https?://|mailto:|www\.)[^\s<]+}i
+        )
+
+        ranges.concat(inline_code_ranges(line))
+        ranges
+      end
+
+      def add_match_ranges(ranges, line, pattern)
+        line.to_enum(:scan, pattern).each do
+          match = Regexp.last_match
+          ranges << (match.begin(0)...match.end(0))
+        end
+      end
+
+      def inline_code_ranges(line)
+        ranges = []
+        index = 0
+
+        while index < line.length
+          unless line[index] == "`"
+            index += 1
+            next
+          end
+
+          run_end = index
+          run_end += 1 while line[run_end] == "`"
+          delimiter = line[index...run_end]
+          closing = line.index(delimiter, run_end)
+
+          unless closing
+            index = run_end
+            next
+          end
+
+          ranges << (index...(closing + delimiter.length))
+          index = closing + delimiter.length
+        end
+
+        ranges
+      end
+
+      def excluded?(offset, ranges)
+        ranges.any? { |range| range.cover?(offset) }
+      end
+
+      def escaped?(line, offset)
+        slash_count = 0
+        index = offset - 1
+
+        while index >= 0 && line[index] == "\\"
+          slash_count += 1
+          index -= 1
+        end
+
+        slash_count.odd?
+      end
+    end
+  end
+end

data/app/services/rails_den/mentions/reconciler.rb

@@ -0,0 +1,46 @@
+module RailsDen
+  module Mentions
+    class Reconciler
+      class << self
+        def call(post:)
+          new(post: post).call
+        end
+      end
+
+      def initialize(post:)
+        @post = post
+      end
+
+      def call
+        parsed = Parser.parse(post.body)
+        mention_names = parsed.mention_names
+        existing_by_name = post.mentions.index_by(&:mention_name)
+
+        mention_names.each do |mention_name|
+          next if existing_by_name.key?(mention_name)
+
+          mentioned = RailsDen.resolve_user_mention(mention_name)
+
+          next unless mentioned&.id
+          next unless RailsDen.user_mention_name(mentioned) == mention_name
+
+          post.mentions.create!(
+            mentioned: mentioned,
+            mention_name: mention_name
+          )
+        end
+
+        post.mentions
+            .where.not(mention_name: mention_names)
+            .find_each(&:destroy!)
+
+        post.mentions.reset
+        true
+      end
+
+      private
+
+      attr_reader :post
+    end
+  end
+end

data/app/services/rails_den/mentions/renderer.rb

@@ -0,0 +1,165 @@
+require "nokogiri"
+
+module RailsDen
+  module Mentions
+    class Renderer
+      PLACEHOLDER_PREFIX = "RAILSDENMENTIONPLACEHOLDER"
+
+      class << self
+        def call(source:, mentions:, profile_path_resolver: nil)
+          new(
+            source: source,
+            mentions: mentions,
+            profile_path_resolver: profile_path_resolver
+          ).call
+        end
+      end
+
+      def initialize(source:, mentions:, profile_path_resolver: nil)
+        @source = source.to_s
+        @mentions = mentions.to_a
+        @profile_path_resolver = profile_path_resolver
+      end
+
+      def call
+        replacements = replacement_occurrences
+
+        return RailsDen.format(source) if replacements.empty?
+
+        placeholder_source, placeholders =
+          insert_placeholders(replacements)
+
+        fragment = Nokogiri::HTML5.fragment(
+          RailsDen.format(placeholder_source).to_s
+        )
+
+        replace_placeholders(fragment, placeholders)
+
+        RailsDen::Formatting.sanitize(
+          fragment.to_html
+        )
+      end
+
+      private
+
+      attr_reader :source, :mentions, :profile_path_resolver
+
+      def replacement_occurrences
+        mentions_by_name = mentions.index_by(&:mention_name)
+
+        Parser.parse(source)
+              .occurrences
+              .filter_map do |occurrence|
+          mention = mentions_by_name[occurrence.mention_name]
+
+          [occurrence, mention] if mention
+        end
+      end
+
+      def insert_placeholders(replacements)
+        output = +""
+        placeholders = {}
+        cursor = 0
+
+        replacements.each_with_index do |(occurrence, mention), index|
+          placeholder = "#{PLACEHOLDER_PREFIX}#{index}END"
+
+          output << source[cursor...occurrence.start_offset]
+          output << placeholder
+
+          placeholders[placeholder] = [occurrence, mention]
+          cursor = occurrence.end_offset
+        end
+
+        output << source[cursor..]
+
+        [output, placeholders]
+      end
+
+      def replace_placeholders(fragment, placeholders)
+        fragment.xpath(".//text()").to_a.each do |text_node|
+          next unless text_node.text.include?(PLACEHOLDER_PREFIX)
+
+          replace_text_node(
+            text_node,
+            placeholders
+          )
+        end
+      end
+
+      def replace_text_node(text_node, placeholders)
+        pattern = Regexp.union(placeholders.keys)
+        cursor = 0
+
+        text_node.text.to_enum(:scan, pattern).each do
+          match = Regexp.last_match
+
+          insert_text(
+            text_node,
+            text_node.text[cursor...match.begin(0)]
+          )
+
+          occurrence, mention = placeholders.fetch(match[0])
+
+          text_node.add_previous_sibling(
+            mention_node(
+              text_node.document,
+              occurrence,
+              mention
+            )
+          )
+
+          cursor = match.end(0)
+        end
+
+        insert_text(
+          text_node,
+          text_node.text[cursor..]
+        )
+
+        text_node.remove
+      end
+
+      def insert_text(text_node, text)
+        return if text.nil? || text.empty?
+
+        text_node.add_previous_sibling(
+          Nokogiri::XML::Text.new(
+            text,
+            text_node.document
+          )
+        )
+      end
+
+      def mention_node(document, occurrence, mention)
+        identity = mention.mentioned
+        path =
+          if profile_path_resolver.respond_to?(:call)
+            profile_path_resolver.call(identity)
+          else
+            RailsDen.user_mention_path(identity)
+          end
+
+        path = nil unless RailsDen::Formatting.safe_url?(path)
+        node_name = path ? "a" : "span"
+        node = Nokogiri::XML::Node.new(node_name, document)
+
+        node["class"] = "rails-den-mention"
+        node.content = occurrence.source
+
+        if path
+          node["href"] = path
+          node["aria-label"] =
+            "View profile for #{occurrence.source}"
+        end
+
+        node
+      rescue ActiveRecord::RecordNotFound
+        node = Nokogiri::XML::Node.new("span", document)
+        node["class"] = "rails-den-mention"
+        node.content = occurrence.source
+        node
+      end
+    end
+  end
+end

data/app/services/rails_den/moderation_access.rb

@@ -0,0 +1,42 @@
+module RailsDen
+  class ModerationAccess
+    class << self
+      def allowed?(user:)
+        return false unless user
+        return true if RailsDen::ReportReviewPolicy.new(viewer: user).global_moderator?
+
+        RailsDen::BoardRoleAssignment
+          .where(user: user)
+          .includes(board: :category)
+          .any? do |assignment|
+            RailsDen::PermissionResolver.allowed?(
+              user: user,
+              capability: :moderate,
+              board: assignment.board
+            )
+          end || globally_assigned_board_override?(user)
+      end
+
+      private
+
+      def globally_assigned_board_override?(user)
+        role_ids = RailsDen::RoleAssignment.where(user: user).select(:role_id)
+
+        RailsDen::BoardRolePermission
+          .where(
+            role_id: role_ids,
+            capability: "moderate",
+            allowed: true
+          )
+          .includes(board: :category)
+          .any? do |permission|
+            RailsDen::PermissionResolver.allowed?(
+              user: user,
+              capability: :moderate,
+              board: permission.board
+            )
+          end
+      end
+    end
+  end
+end

data/app/services/rails_den/moderation_audit.rb

@@ -0,0 +1,38 @@
+module RailsDen
+  class ModerationAudit
+    class << self
+      def record!(action:, subject:, actor: nil, report: nil, note: nil,
+                  scope_board: nil, metadata: {}, dedupe_key: nil)
+        attributes = {
+          action: action,
+          actor: actor,
+          actor_label: actor ? RailsDen.user_display_name(actor) : "System",
+          subject: subject,
+          subject_label: label_for(subject),
+          report: report,
+          note: note,
+          scope_board: scope_board,
+          metadata: metadata,
+          dedupe_key: dedupe_key
+        }
+
+        return ModerationEvent.create!(attributes) unless dedupe_key
+
+        ModerationEvent.create_or_find_by!(dedupe_key: dedupe_key) do |event|
+          event.assign_attributes(attributes.except(:dedupe_key))
+        end
+      end
+
+      private
+
+      def label_for(subject)
+        case subject
+        when RailsDen::Report then subject.subject_label
+        when RailsDen::Topic then subject.title
+        when RailsDen::Post then "Post by #{RailsDen.user_display_name(subject.author)}"
+        else RailsDen.user_display_name(subject)
+        end.to_s.each_grapheme_cluster.take(255).join
+      end
+    end
+  end
+end

data/app/services/rails_den/moderation_event_scope.rb

@@ -0,0 +1,12 @@
+module RailsDen
+  class ModerationEventScope
+    def self.call(viewer:, relation: RailsDen::ModerationEvent.all)
+      global = RailsDen::ReportReviewPolicy.new(viewer: viewer).global_moderator?
+      relation.includes(:actor, :subject, :scope_board).order(created_at: :desc, id: :desc).select do |event|
+        global || (event.scope_board && RailsDen::PermissionResolver.allowed?(
+          user: viewer, capability: :moderate, board: event.scope_board
+        ))
+      end
+    end
+  end
+end

data/app/services/rails_den/moderation_notification_delivery.rb

@@ -0,0 +1,23 @@
+module RailsDen
+  class ModerationNotificationDelivery
+    def self.call(subject:, recipient:, event_type:)
+      event = NotificationEvent.create_or_find_by!(
+        dedupe_key: "#{event_type}:#{subject.class.polymorphic_name}:#{subject.id}"
+      ) do |record|
+        record.assign_attributes(event_type: event_type, actor: event_actor(subject),
+                                 subject: subject, target: recipient)
+      end
+      Notifications::Materializer.call(events: [event])
+      event
+    rescue StandardError => error
+      Rails.logger.error("RailsDen moderation notification failed: #{error.class}: #{error.message}")
+      nil
+    end
+
+    def self.event_actor(subject)
+      subject.respond_to?(:issued_by) ? subject.issued_by :
+        (subject.respond_to?(:created_by) ? subject.created_by : subject.lifted_by)
+    end
+    private_class_method :event_actor
+  end
+end