rails_den 2.0.0

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

@@ -0,0 +1,93 @@
+module RailsDen
+  module Gamification
+    class Metrics
+      class << self
+        def call(recipient:, criteria:)
+          new(
+            recipient: recipient,
+            criteria: criteria
+          ).call
+        end
+      end
+
+      def initialize(recipient:, criteria:)
+        @recipient = recipient
+        @criteria =
+          Array(criteria)
+            .map(&:to_s)
+            .uniq
+      end
+
+      def call
+        unknown =
+          criteria -
+          RailsDen::Badge::CRITERIA
+
+        if unknown.any?
+          raise ArgumentError,
+                "Unknown badge criteria: #{unknown.join(", ")}"
+        end
+
+        criteria.each_with_object({}) do |criterion, values|
+          values[criterion] =
+            public_send(
+              criterion
+            )
+        end
+      end
+
+      private
+
+      attr_reader :recipient,
+                  :criteria
+
+      def topics_created
+        RailsDen::Topic
+          .where(
+            author_type: polymorphic_type,
+            author_id: recipient.id,
+            deleted_at: nil
+          )
+          .count
+      end
+
+      def posts_created
+        RailsDen::Post
+          .where(
+            author_type: polymorphic_type,
+            author_id: recipient.id,
+            deleted_at: nil
+          )
+          .count
+      end
+
+      def reactions_received
+        RailsDen::Reaction
+          .joins(
+            :post
+          )
+          .where(
+            rails_den_posts: {
+              author_type: polymorphic_type,
+              author_id: recipient.id,
+              deleted_at: nil
+            }
+          )
+          .count
+      end
+
+      def reputation
+        RailsDen::MemberProfile
+          .find_by(
+            profile_owner: recipient
+          )
+          &.reputation_points
+          .to_i
+      end
+
+      def polymorphic_type
+        recipient.class.polymorphic_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,261 @@
+module RailsDen
+  module Gamification
+    class ReputationLedger
+      Result =
+        Struct.new(
+          :event,
+          :created,
+          :reputation_points,
+          :disabled,
+          keyword_init: true
+        )
+
+      class << self
+        def record!(
+          recipient:,
+          event_type:,
+          points:,
+          dedupe_key:,
+          actor: nil,
+          source: nil,
+          reason: nil
+        )
+          new(
+            recipient: recipient,
+            event_type: event_type,
+            points: points,
+            dedupe_key: dedupe_key,
+            actor: actor,
+            source: source,
+            reason: reason
+          ).record!
+        end
+      end
+
+      def initialize(
+        recipient:,
+        event_type:,
+        points:,
+        dedupe_key:,
+        actor:,
+        source:,
+        reason:
+      )
+        @recipient = recipient
+        @event_type = event_type.to_s
+        @points = normalize_points(points)
+        @dedupe_key = dedupe_key.to_s.strip
+        @actor = actor
+        @source = source
+        @reason = normalize_reason(reason)
+
+        validate_input!
+      end
+
+      def record!
+        unless RailsDen::Gamification.enabled?
+          return Result.new(
+            event: nil,
+            created: false,
+            reputation_points: nil,
+            disabled: true
+          )
+        end
+
+        profile = member_profile
+
+        event = nil
+        created = false
+        total = nil
+
+        profile.with_lock do
+          existing =
+            RailsDen::ReputationEvent.find_by(
+              dedupe_key: dedupe_key
+            )
+
+          if existing
+            verify_existing!(
+              existing
+            )
+
+            event = existing
+
+            total =
+              reconcile_profile!(
+                profile
+              )
+          else
+            current_total =
+              reputation_total
+
+            if current_total + points < 0
+              raise RailsDen::Gamification::NegativeReputationError,
+                    "Reputation cannot be reduced below zero."
+            end
+
+            event =
+              RailsDen::ReputationEvent.create_or_find_by!(
+                dedupe_key: dedupe_key
+              ) do |record|
+                record.recipient = recipient
+                record.actor = actor
+                record.source = source
+                record.event_type = event_type
+                record.points = points
+                record.reason = reason
+              end
+
+            created =
+              event.previously_new_record?
+
+            verify_existing!(
+              event
+            )
+
+            total =
+              reconcile_profile!(
+                profile
+              )
+          end
+        end
+
+        RailsDen::Gamification::TrustLevelEvaluator.call(
+          recipient: recipient,
+          reputation_points: total
+        )
+
+        RailsDen::Gamification::BadgeEvaluator.call(
+          recipient: recipient
+        )
+
+        Result.new(
+          event: event,
+          created: created,
+          reputation_points: total,
+          disabled: false
+        )
+      end
+
+      private
+
+      attr_reader :recipient,
+                  :event_type,
+                  :points,
+                  :dedupe_key,
+                  :actor,
+                  :source,
+                  :reason
+
+      def member_profile
+        RailsDen::MemberProfile.find_or_create_by!(
+          profile_owner: recipient
+        )
+      rescue ActiveRecord::RecordNotUnique
+        RailsDen::MemberProfile.find_by!(
+          profile_owner: recipient
+        )
+      end
+
+      def reputation_total
+        RailsDen::ReputationEvent
+          .where(
+            recipient_type: polymorphic_type(recipient),
+            recipient_id: recipient.id
+          )
+          .sum(
+            :points
+          )
+      end
+
+      def reconcile_profile!(profile)
+        total =
+          reputation_total
+
+        if total.negative?
+          raise RailsDen::Gamification::NegativeReputationError,
+                "Reputation cannot be reduced below zero."
+        end
+
+        if profile.reputation_points != total
+          profile.update_columns(
+            reputation_points: total,
+            updated_at: Time.current
+          )
+        end
+
+        total
+      end
+
+      def verify_existing!(event)
+        matches =
+          event.recipient == recipient &&
+          event.event_type == event_type &&
+          event.points == points &&
+          event.actor == actor &&
+          event.source == source &&
+          event.reason.to_s == reason.to_s
+
+        return if matches
+
+        raise RailsDen::Gamification::DedupeCollisionError,
+              "Reputation event dedupe key #{dedupe_key.inspect} " \
+              "already belongs to a different event."
+      end
+
+      def validate_input!
+        unless recipient.respond_to?(:persisted?) &&
+               recipient.persisted?
+          raise ArgumentError,
+                "recipient must be a persisted Active Record identity"
+        end
+
+        unless event_type.in?(
+          RailsDen::ReputationEvent::EVENT_TYPES
+        )
+          raise ArgumentError,
+                "Unknown reputation event type: #{event_type.inspect}"
+        end
+
+        if dedupe_key.empty?
+          raise ArgumentError,
+                "dedupe_key must be present"
+        end
+      end
+
+      def normalize_points(value)
+        integer =
+          case value
+          when Integer
+            value
+          when String
+            stripped = value.strip
+
+            stripped.match?(/\A[+-]?\d+\z/) ? stripped.to_i : nil
+          end
+
+        if integer.nil? || integer.zero?
+          raise ArgumentError,
+                "points must be a non-zero integer"
+        end
+
+        integer
+      end
+
+      def normalize_reason(value)
+        return nil if value.nil?
+
+        normalized =
+          value
+            .to_s
+            .strip
+
+        normalized.empty? ? nil : normalized
+      end
+
+      def polymorphic_type(record)
+        record.class.polymorphic_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module RailsDen
+  module Gamification
+    class TrustLevelEvaluator
+      class << self
+        def call(recipient:, reputation_points:)
+          new(
+            recipient: recipient,
+            reputation_points: reputation_points
+          ).call
+        end
+      end
+
+      def initialize(recipient:, reputation_points:)
+        @recipient = recipient
+        @reputation_points = reputation_points.to_i
+      end
+
+      def call
+        return [] unless RailsDen::Gamification.enabled?
+
+        achievements =
+          qualifying_levels.each_with_object([]) do |trust_level, created|
+            achievement =
+              RailsDen::TrustLevelAchievement.create_or_find_by!(
+                trust_level: trust_level,
+                recipient: recipient
+              ) do |record|
+                record.reached_at = Time.current
+              end
+
+            if achievement.previously_new_record?
+              created << achievement
+            end
+          end
+
+        emit_highest_notification(
+          achievements
+        )
+
+        achievements
+      end
+
+      private
+
+      attr_reader :recipient,
+                  :reputation_points
+
+      def qualifying_levels
+        RailsDen::TrustLevel
+          .enabled
+          .where(
+            "minimum_reputation > 0"
+          )
+          .where(
+            "minimum_reputation <= ?",
+            reputation_points
+          )
+          .ordered
+      end
+
+      def emit_highest_notification(achievements)
+        highest =
+          achievements.max_by do |achievement|
+            [
+              achievement.trust_level.minimum_reputation,
+              achievement.trust_level.id
+            ]
+          end
+
+        return unless highest
+
+        RailsDen::NotificationEvents::Emitter.call(
+          trust_level_achievement: highest
+        )
+      end
+    end
+  end
+end

data/app/services/rails_den/global_moderation_policy.rb

@@ -0,0 +1,32 @@
+module RailsDen
+  class GlobalModerationPolicy
+    def initialize(actor:)
+      @actor = actor
+    end
+
+    def allowed?
+      RailsDen::PermissionResolver.allowed?(user: actor, capability: :moderate)
+    end
+
+    def administrator?
+      RailsDen::RoleResolver.has_role?(user: actor, role: :administrator)
+    end
+
+    def may_sanction?(target)
+      return false unless allowed?
+      return false if same_identity?(actor, target)
+      return true if administrator?
+
+      !RailsDen::RoleResolver.has_role?(user: target, role: :administrator) &&
+        !RailsDen::PermissionResolver.allowed?(user: target, capability: :moderate)
+    end
+
+    private
+
+    attr_reader :actor
+
+    def same_identity?(first, second)
+      first.class.polymorphic_name == second.class.polymorphic_name && first.id == second.id
+    end
+  end
+end

data/app/services/rails_den/member_profile_bio_renderer.rb

@@ -0,0 +1,28 @@
+module RailsDen
+  class MemberProfileBioRenderer
+    class << self
+      def call(source:)
+        new(source).call
+      end
+    end
+
+    def initialize(source)
+      @source = source.to_s
+    end
+
+    def call
+      escaped = ERB::Util.html_escape(source)
+      formatted = ActionController::Base.helpers.simple_format(escaped)
+
+      ActionController::Base.helpers.sanitize(
+        formatted,
+        tags: %w[p br],
+        attributes: []
+      )
+    end
+
+    private
+
+    attr_reader :source
+  end
+end

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

@@ -0,0 +1,69 @@
+module RailsDen
+  module Mentions
+    class Autocomplete
+      DEFAULT_LIMIT = 8
+      MAX_LIMIT = 10
+      NAME_PATTERN = /\A[A-Za-z0-9_]{1,#{Parser::MAX_NAME_LENGTH}}\z/
+
+      class << self
+        def call(prefix:, limit: DEFAULT_LIMIT)
+          new(prefix: prefix, limit: limit).call
+        end
+      end
+
+      def initialize(prefix:, limit: DEFAULT_LIMIT)
+        @prefix = prefix.to_s.strip.downcase
+        @limit = normalize_limit(limit)
+      end
+
+      def call
+        return [] unless valid_name?(prefix)
+
+        identities = RailsDen.user_mention_candidates(
+          prefix,
+          limit: limit
+        )
+
+        Array(identities)
+          .filter_map { |identity| candidate_for(identity) }
+          .uniq(&:mention_name)
+          .sort_by { |candidate| sort_key(candidate) }
+          .first(limit)
+      end
+
+      private
+
+      attr_reader :prefix, :limit
+
+      def normalize_limit(value)
+        parsed = Integer(value, exception: false)
+        parsed = DEFAULT_LIMIT unless parsed&.positive?
+        parsed.clamp(1, MAX_LIMIT)
+      end
+
+      def candidate_for(identity)
+        mention_name = RailsDen.user_mention_name(identity)
+
+        return unless valid_name?(mention_name)
+        return unless mention_name.start_with?(prefix)
+
+        Candidate.new(
+          mention_name: mention_name,
+          display_name: RailsDen.user_display_name(identity).to_s
+        )
+      end
+
+      def valid_name?(value)
+        value.match?(NAME_PATTERN)
+      end
+
+      def sort_key(candidate)
+        [
+          candidate.mention_name == prefix ? 0 : 1,
+          candidate.mention_name,
+          candidate.display_name
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module RailsDen
+  module Mentions
+    class Candidate
+      attr_reader :mention_name, :display_name
+
+      def initialize(mention_name:, display_name:)
+        @mention_name = mention_name
+        @display_name = display_name
+      end
+
+      def as_json(*)
+        {
+          mention_name: mention_name,
+          display_name: display_name
+        }
+      end
+    end
+  end
+end