rails_den 2.0.0

data/app/services/rails_den/chat/whisper_delivery.rb

@@ -0,0 +1,287 @@
+require "securerandom"
+
+module RailsDen
+  module Chat
+    class WhisperDelivery
+      class << self
+        def whisper_candidate?(body)
+          body
+            .to_s
+            .lstrip
+            .start_with?("@")
+        end
+
+        def call(channel:, sender:, body:)
+          new(
+            channel: channel,
+            sender: sender,
+            body: body
+          ).call
+        end
+      end
+
+      def initialize(channel:, sender:, body:)
+        @channel = channel
+        @sender = sender
+        @body = body.to_s
+      end
+
+      def call
+        parsed =
+          parse_body
+
+        return parsed unless parsed.fetch(:ok)
+
+        mention_name =
+          parsed.fetch(:mention_name)
+
+        whisper_body =
+          parsed.fetch(:body)
+
+        target =
+          RailsDen.resolve_user_mention(
+            mention_name
+          )
+
+        unless canonical_target?(
+          target,
+          mention_name
+        )
+          return failure(
+            "@#{mention_name} could not be found."
+          )
+        end
+
+        if target == sender
+          return failure(
+            "You cannot whisper to yourself."
+          )
+        end
+
+        room =
+          RailsDen::Chat::SpatialRoom.resolve(
+            slug: channel.slug,
+            viewer: sender
+          )
+
+        unless room&.channel?
+          return failure(
+            "Whispers are available only inside a 3-D chat room."
+          )
+        end
+
+        unless room.readable_by?(target)
+          return failure(
+            "@#{mention_name} is not available in this room."
+          )
+        end
+
+        candidate =
+          channel.chat_messages.build(
+            body: whisper_body,
+            author: sender
+          )
+
+        unless candidate.valid?
+          errors =
+            candidate.errors
+              .full_messages_for(:body)
+
+          return failure(
+            errors.presence&.join(", ") ||
+              "That whisper is invalid."
+          )
+        end
+
+        snapshots =
+          spatial_registry.room_snapshots(
+            room: room
+          )
+
+        sender_snapshots =
+          snapshots.select do |snapshot|
+            snapshot_matches_identity?(
+              snapshot,
+              sender
+            )
+          end
+
+        if sender_snapshots.empty?
+          return failure(
+            "Whispers are available only while you are in the 3-D room."
+          )
+        end
+
+        target_snapshots =
+          snapshots.select do |snapshot|
+            snapshot_matches_identity?(
+              snapshot,
+              target
+            )
+          end
+
+        if target_snapshots.empty?
+          return failure(
+            "@#{mention_name} is not in this room."
+          )
+        end
+
+        whisper_id =
+          "whisper-#{SecureRandom.uuid}"
+
+        created_at =
+          Time.current.iso8601(3)
+
+        target_member_key =
+          RailsDen::Chat::SpatialSnapshot
+            .member_key_for(
+              target
+            )
+
+        sender_message = {
+          id: whisper_id,
+          body: whisper_body,
+          author_name:
+            "Whisper to @#{mention_name}",
+          author_member_key:
+            target_member_key,
+          created_at: created_at,
+          whisper: true,
+          whisper_role: "sender"
+        }
+
+        recipient_message = {
+          id: whisper_id,
+          body: whisper_body,
+          author_name:
+            "#{RailsDen.user_display_name(sender)} whispers",
+          author_member_key:
+            target_member_key,
+          created_at: created_at,
+          whisper: true,
+          whisper_role: "recipient"
+        }
+
+        RailsDen::Chat::SpatialBroadcaster
+          .whisper_to_sessions(
+            room: room,
+            session_ids:
+              sender_snapshots.map(
+                &:session_id
+              ),
+            message:
+              sender_message
+          )
+
+        RailsDen::Chat::SpatialBroadcaster
+          .whisper_to_sessions(
+            room: room,
+            session_ids:
+              target_snapshots.map(
+                &:session_id
+              ),
+            message:
+              recipient_message
+          )
+
+        {
+          ok: true,
+          target_mention_name:
+            mention_name,
+          body:
+            whisper_body
+        }
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        failure(
+          "Whispers are unavailable right now."
+        )
+      end
+
+      private
+
+      attr_reader :channel,
+                  :sender,
+                  :body
+
+      def parse_body
+        source =
+          body.strip
+
+        match =
+          source.match(
+            /\A@([^\s]+)\s+(.+)\z/m
+          )
+
+        unless match
+          return failure(
+            "Use @username followed by a whisper message."
+          )
+        end
+
+        mention_name =
+          match[1]
+            .to_s
+            .strip
+            .downcase
+
+        whisper_body =
+          match[2]
+            .to_s
+            .strip
+
+        if mention_name.blank? ||
+           whisper_body.blank?
+          return failure(
+            "Use @username followed by a whisper message."
+          )
+        end
+
+        {
+          ok: true,
+          mention_name:
+            mention_name,
+          body:
+            whisper_body
+        }
+      end
+
+      def canonical_target?(
+        target,
+        mention_name
+      )
+        return false unless target
+
+        RailsDen.user_mention_name(
+          target
+        ) ==
+          mention_name
+      end
+
+      def snapshot_matches_identity?(
+        snapshot,
+        identity
+      )
+        snapshot.identity_type ==
+          identity
+            .class
+            .polymorphic_name
+            .to_s &&
+          snapshot.identity_id ==
+            identity.id.to_s
+      end
+
+      def spatial_registry
+        @spatial_registry ||=
+          RailsDen::Chat::SpatialRegistry.new
+      end
+
+      def failure(message)
+        {
+          ok: false,
+          error: message
+        }
+      end
+    end
+  end
+end

data/app/services/rails_den/chat_channel_access.rb

@@ -0,0 +1,97 @@
+module RailsDen
+  class ChatChannelAccess
+    class << self
+      def readable_scope(viewer:)
+        return ChatChannel.none unless viewer
+
+        unless PermissionResolver.allowed?(
+          user: viewer,
+          capability: :view
+        )
+          return ChatChannel.none
+        end
+
+        return ChatChannel.all if administrator?(viewer)
+
+        member_channel_ids =
+          ChatChannelMembership
+            .where(member: viewer)
+            .select(:chat_channel_id)
+
+        ChatChannel
+          .where(visibility: "public")
+          .or(
+            ChatChannel.where(
+              id: member_channel_ids
+            )
+          )
+      end
+
+      private
+
+      def administrator?(viewer)
+        RailsDen::RoleResolver.has_role?(
+          user: viewer,
+          role: :administrator
+        )
+      end
+    end
+
+    def initialize(viewer:, channel:)
+      @viewer = viewer
+      @channel = channel
+    end
+
+    def readable?
+      return false unless viewer
+
+      return false unless PermissionResolver.allowed?(
+        user: viewer,
+        capability: :view
+      )
+
+      channel.visibility_public? ||
+        administrator? ||
+        member?
+    end
+
+    def postable?
+      readable? &&
+        PermissionResolver.allowed?(
+          user: viewer,
+          capability: :message
+        ) &&
+        RestrictionResolver.can_participate?(
+          user: viewer
+        )
+    end
+
+    def manageable?
+      administrator? ||
+        (
+          channel.visibility_private? &&
+          channel.created_by == viewer
+        )
+    end
+
+    private
+
+    attr_reader :viewer,
+                :channel
+
+    def administrator?
+      RailsDen::RoleResolver.has_role?(
+        user: viewer,
+        role: :administrator
+      )
+    end
+
+    def member?
+      channel
+        .chat_channel_memberships
+        .exists?(
+          member: viewer
+        )
+    end
+  end
+end

data/app/services/rails_den/default_report_reason_provisioner.rb

@@ -0,0 +1,30 @@
+module RailsDen
+  class DefaultReportReasonProvisioner
+    REASON_DEFINITIONS = [
+      { name: "Spam", key: "spam", target_kind: "all", position: 0 },
+      {
+        name: "Harassment or abuse",
+        key: "harassment_or_abuse",
+        target_kind: "all",
+        position: 10
+      },
+      {
+        name: "Inappropriate content",
+        key: "inappropriate_content",
+        target_kind: "content",
+        position: 20
+      },
+      { name: "Other", key: "other", target_kind: "all", position: 30 }
+    ].freeze
+
+    class << self
+      def call
+        REASON_DEFINITIONS.each do |definition|
+          reason = ReportReason.find_or_initialize_by(key: definition.fetch(:key))
+          reason.assign_attributes(**definition, enabled: true)
+          reason.save!
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/emoji_catalog.rb

@@ -0,0 +1,101 @@
+require "unicode/emoji"
+require "unicode/name"
+require "unicode/sequence_name"
+
+module RailsDen
+  class EmojiCatalog
+    Entry = Data.define(
+      :id,
+      :emoji,
+      :name,
+      :key,
+      :category,
+      :subgroup,
+      :search_terms
+    )
+
+    class << self
+      def entries
+        @entries ||= build_entries.freeze
+      end
+
+      def count
+        entries.length
+      end
+
+      def find(id)
+        entries_by_id[id.to_s]
+      end
+
+      def resolve(ids)
+        Array(ids).filter_map { |id| find(id) }.uniq(&:id)
+      end
+
+      def search(query, limit: nil, offset: 0)
+        matches =
+          if query.to_s.strip.empty?
+            entries
+          else
+            tokens = normalize(query).split
+            entries.select do |entry|
+              tokens.all? { |token| entry.search_terms.include?(token) }
+            end
+          end
+
+        matches = matches.drop(offset)
+        limit ? matches.first(limit) : matches
+      end
+
+      private
+
+      def entries_by_id
+        @entries_by_id ||= entries.index_by(&:id).freeze
+      end
+
+      def build_entries
+        Unicode::Emoji.list.flat_map do |category, subgroups|
+          subgroups.flat_map do |subgroup, emojis|
+            emojis.map do |emoji|
+              build_entry(emoji, category, subgroup)
+            end
+          end
+        end.uniq(&:emoji)
+      end
+
+      def build_entry(emoji, category, subgroup)
+        source_id = emoji.codepoints.map { |codepoint| codepoint.to_s(16) }.join("-")
+        raw_name = Unicode::SequenceName.of(emoji) || Unicode::Name.readable(emoji)
+        name = humanize_name(raw_name)
+
+        Entry.new(
+          id: source_id,
+          emoji: emoji,
+          name: name,
+          key: "emoji_#{source_id.tr("-", "_")}",
+          category: category,
+          subgroup: subgroup,
+          search_terms: normalize([name, raw_name, category, subgroup, source_id].join(" "))
+        )
+      end
+
+      def humanize_name(name)
+        name
+          .to_s
+          .sub(/ \((?:emoji|text) style\)\z/i, "")
+          .downcase
+          .split
+          .map(&:capitalize)
+          .join(" ")
+      end
+
+      def normalize(value)
+        value
+          .to_s
+          .unicode_normalize(:nfkd)
+          .downcase
+          .gsub(/[^a-z0-9]+/, " ")
+          .squish
+      end
+    end
+  end
+end

data/app/services/rails_den/gamification/activity_recorder.rb

@@ -0,0 +1,69 @@
+module RailsDen
+  module Gamification
+    class ActivityRecorder
+      class << self
+        def topic_created(topic)
+          return unless RailsDen::Gamification.enabled?
+
+          points =
+            RailsDen::Gamification.topic_points
+
+          if points.positive?
+            RailsDen::Gamification::ReputationLedger.record!(
+              recipient: topic.author,
+              actor: topic.author,
+              source: topic,
+              event_type: "topic_created",
+              points: points,
+              dedupe_key:
+                "gamification:topic_created:topic:#{topic.id}"
+            )
+          else
+            RailsDen::Gamification::BadgeEvaluator.call(
+              recipient: topic.author
+            )
+          end
+        end
+
+        def post_created(post)
+          return unless RailsDen::Gamification.enabled?
+
+          if post.opening_post?
+            RailsDen::Gamification::BadgeEvaluator.call(
+              recipient: post.author
+            )
+
+            return
+          end
+
+          points =
+            RailsDen::Gamification.reply_points
+
+          if points.positive?
+            RailsDen::Gamification::ReputationLedger.record!(
+              recipient: post.author,
+              actor: post.author,
+              source: post,
+              event_type: "reply_created",
+              points: points,
+              dedupe_key:
+                "gamification:reply_created:post:#{post.id}"
+            )
+          else
+            RailsDen::Gamification::BadgeEvaluator.call(
+              recipient: post.author
+            )
+          end
+        end
+
+        def reaction_created(reaction)
+          return unless RailsDen::Gamification.enabled?
+
+          RailsDen::Gamification::BadgeEvaluator.call(
+            recipient: reaction.post.author
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/gamification/badge_evaluator.rb

@@ -0,0 +1,55 @@
+module RailsDen
+  module Gamification
+    class BadgeEvaluator
+      class << self
+        def call(recipient:)
+          new(
+            recipient: recipient
+          ).call
+        end
+      end
+
+      def initialize(recipient:)
+        @recipient = recipient
+      end
+
+      def call
+        return [] unless RailsDen::Gamification.enabled?
+
+        badges =
+          RailsDen::Badge
+            .enabled
+            .where(
+              award_mode: "automatic"
+            )
+            .ordered
+            .to_a
+
+        return [] if badges.empty?
+
+        metrics =
+          RailsDen::Gamification::Metrics.call(
+            recipient: recipient,
+            criteria: badges.map(&:criterion)
+          )
+
+        badges.filter_map do |badge|
+          next unless metrics.fetch(
+            badge.criterion
+          ) >= badge.threshold
+
+          RailsDen::BadgeAward.create_or_find_by!(
+            badge: badge,
+            recipient: recipient
+          ) do |award|
+            award.award_kind = "automatic"
+          end
+        end
+      end
+
+      private
+
+      attr_reader :recipient
+    end
+  end
+end

data/app/services/rails_den/gamification/current_trust_level.rb

@@ -0,0 +1,21 @@
+module RailsDen
+  module Gamification
+    class CurrentTrustLevel
+      class << self
+        def call(reputation_points:)
+          RailsDen::TrustLevel
+            .enabled
+            .where(
+              "minimum_reputation <= ?",
+              reputation_points.to_i
+            )
+            .order(
+              minimum_reputation: :desc,
+              id: :desc
+            )
+            .first
+        end
+      end
+    end
+  end
+end