rails_den 2.0.0

data/app/models/rails_den/profile_field.rb

@@ -0,0 +1,150 @@
+module RailsDen
+  class ProfileField < ApplicationRecord
+    FIELD_TYPES = %w[
+      text
+      textarea
+      url
+      select
+      checkbox
+    ].freeze
+
+    RESERVED_KEYS = %w[
+      username
+      avatar
+      avatar_url
+      bio
+      display_name
+      mention_name
+      joined_at
+      last_activity_at
+      topics_count
+      posts_count
+      reactions_received
+    ].freeze
+
+    has_many :profile_field_values,
+             class_name: "RailsDen::ProfileFieldValue",
+             inverse_of: :profile_field,
+             dependent: :restrict_with_exception
+
+    validates :key,
+              presence: true,
+              uniqueness: true,
+              length: {
+                maximum: 50
+              },
+              format: {
+                with: /\A[a-z][a-z0-9_]*\z/,
+                message: "must start with a letter and contain only lowercase letters, numbers, and underscores"
+              }
+
+    validates :label,
+              presence: true
+
+    validates :field_type,
+              presence: true,
+              inclusion: {
+                in: FIELD_TYPES
+              }
+
+    validates :required,
+              :enabled,
+              inclusion: {
+                in: [ true, false ]
+              }
+
+    validates :position,
+              numericality: {
+                only_integer: true
+              }
+
+    validate :key_is_not_reserved
+    validate :key_is_immutable,
+             on: :update
+    validate :select_has_options
+
+    before_validation :normalize_attributes
+
+    scope :ordered,
+          -> { order(:position, :id) }
+
+    scope :enabled,
+          -> { where(enabled: true) }
+
+    def options
+      options_text
+        .to_s
+        .lines
+        .map(&:strip)
+        .reject(&:blank?)
+        .uniq
+    end
+
+    def host_adapter_key
+      key
+    end
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(
+        self,
+        nil,
+        "RailsDen::ProfileField"
+      )
+    end
+
+    private
+
+    def normalize_attributes
+      self.key =
+        key
+          .to_s
+          .strip
+          .downcase
+
+      self.label =
+        label
+          .to_s
+          .strip
+
+      self.field_type =
+        field_type
+          .to_s
+          .strip
+          .downcase
+
+      self.position ||= 0
+
+      if field_type == "select"
+        self.options_text = options.join("\n")
+      end
+    end
+
+    def key_is_not_reserved
+      return unless RESERVED_KEYS.include?(key)
+
+      errors.add(
+        :key,
+        "is reserved by RailsDen"
+      )
+    end
+
+    def key_is_immutable
+      return unless will_save_change_to_key?
+
+      errors.add(
+        :key,
+        "cannot be changed after the profile field is created"
+      )
+    end
+
+    def select_has_options
+      return unless field_type == "select"
+      return if options.any?
+
+      errors.add(
+        :options_text,
+        "must contain at least one option"
+      )
+    end
+  end
+end

data/app/models/rails_den/profile_field_value.rb

@@ -0,0 +1,136 @@
+require "uri"
+
+module RailsDen
+  class ProfileFieldValue < ApplicationRecord
+    belongs_to :member_profile,
+               class_name: "RailsDen::MemberProfile",
+               inverse_of: :profile_field_values
+
+    belongs_to :profile_field,
+               class_name: "RailsDen::ProfileField",
+               inverse_of: :profile_field_values
+
+    validates :profile_field_id,
+              uniqueness: {
+                scope: :member_profile_id
+              }
+
+    validate :value_matches_profile_field
+
+    before_validation :normalize_value
+
+    def checkbox_value?
+      value == "1"
+    end
+
+    private
+
+    def normalize_value
+      return unless profile_field
+
+      self.value =
+        case profile_field.field_type
+        when "checkbox"
+          ActiveModel::Type::Boolean.new.cast(value) ? "1" : "0"
+        else
+          value.to_s.strip
+        end
+    end
+
+    def value_matches_profile_field
+      return unless profile_field
+
+      case profile_field.field_type
+      when "text"
+        validate_text
+      when "textarea"
+        validate_textarea
+      when "url"
+        validate_url
+      when "select"
+        validate_select
+      when "checkbox"
+        validate_checkbox
+      end
+
+      validate_required
+    end
+
+    def validate_text
+      return if value.to_s.length <= 255
+
+      errors.add(
+        :value,
+        "must be 255 characters or fewer"
+      )
+    end
+
+    def validate_textarea
+      return if value.to_s.length <= 2_000
+
+      errors.add(
+        :value,
+        "must be 2,000 characters or fewer"
+      )
+    end
+
+    def validate_url
+      return if value.blank?
+
+      if value.length > 2_048
+        errors.add(
+          :value,
+          "must be 2,048 characters or fewer"
+        )
+
+        return
+      end
+
+      uri = URI.parse(value)
+
+      return if uri.is_a?(URI::HTTP) &&
+                uri.host.present? &&
+                %w[http https].include?(uri.scheme)
+
+      errors.add(
+        :value,
+        "must be a valid HTTP or HTTPS URL"
+      )
+    rescue URI::InvalidURIError
+      errors.add(
+        :value,
+        "must be a valid HTTP or HTTPS URL"
+      )
+    end
+
+    def validate_select
+      return if value.blank?
+      return if profile_field.options.include?(value)
+
+      errors.add(
+        :value,
+        "is not one of the available options"
+      )
+    end
+
+    def validate_checkbox
+      return if %w[0 1].include?(value)
+
+      errors.add(
+        :value,
+        "must be checked or unchecked"
+      )
+    end
+
+    def validate_required
+      return unless profile_field.required?
+      return if profile_field.field_type == "checkbox"
+      return if value.present?
+
+      errors.add(
+        :value,
+        "is required"
+      )
+    end
+  end
+end

data/app/models/rails_den/reaction.rb

@@ -0,0 +1,56 @@
+module RailsDen
+  class Reaction < ApplicationRecord
+    belongs_to :post,
+               class_name: "RailsDen::Post",
+               inverse_of: :reactions
+
+    belongs_to :reaction_type,
+               class_name: "RailsDen::ReactionType",
+               inverse_of: :reactions
+
+    belongs_to :reactor,
+               polymorphic: true
+
+    validates :reaction_type_id,
+              uniqueness: {
+                scope: %i[
+                  post_id
+                  reactor_type
+                  reactor_id
+                ]
+              }
+
+    after_commit :emit_notification_event,
+                 on: :create
+
+    after_commit :record_gamification_activity,
+                 on: :create
+
+    after_commit :remove_notification_event,
+                 on: :destroy
+
+    private
+
+    def emit_notification_event
+      RailsDen::NotificationEvents::Emitter.call(
+        reaction: self
+      )
+    end
+
+    def record_gamification_activity
+      RailsDen::Gamification::ActivityRecorder.reaction_created(
+        self
+      )
+    end
+
+    def remove_notification_event
+      event =
+        RailsDen::NotificationEvent.find_by(
+          dedupe_key:
+            "post_reacted:reaction:#{id}"
+        )
+
+      event&.destroy!
+    end
+  end
+end

data/app/models/rails_den/reaction_type.rb

@@ -0,0 +1,23 @@
+module RailsDen
+  class ReactionType < ApplicationRecord
+    has_many :reactions,
+             class_name: "RailsDen::Reaction",
+             inverse_of: :reaction_type,
+             dependent: :restrict_with_error
+
+    validates :name, :key, :emoji, presence: true
+    validates :key,
+              uniqueness: true,
+              format: { with: /\A[a-z0-9_]+\z/ }
+    validates :position,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :enabled, inclusion: { in: [true, false] }
+
+    scope :ordered, -> { order(:position, :id) }
+    scope :enabled, -> { where(enabled: true) }
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(self, nil, "RailsDen::ReactionType")
+    end
+  end
+end

data/app/models/rails_den/reader_visit.rb

@@ -0,0 +1,61 @@
+module RailsDen
+  class ReaderVisit < ApplicationRecord
+    belongs_to :reader, polymorphic: true
+
+    validates :last_seen_at, presence: true
+
+    def self.record_page_view!(reader:, at: Time.current)
+      ensure_positive_inactivity_window!
+
+      visit =
+        create_or_find_by!(reader: reader) do |new_visit|
+          new_visit.previous_visit_at = at
+          new_visit.last_seen_at = at
+        end
+
+      visit.record_page_view!(at: at)
+    end
+
+    def self.ensure_positive_inactivity_window!
+      inactivity_window =
+        RailsDen.config.visit_inactivity_window
+
+      return if inactivity_window.respond_to?(:positive?) &&
+                inactivity_window.positive?
+
+      raise ArgumentError,
+            "visit_inactivity_window must be positive"
+    end
+    private_class_method :ensure_positive_inactivity_window!
+
+    def record_page_view!(at: Time.current)
+      inactivity_window =
+        RailsDen.config.visit_inactivity_window
+
+      unless inactivity_window.respond_to?(:positive?) &&
+             inactivity_window.positive?
+        raise ArgumentError,
+              "visit_inactivity_window must be positive"
+      end
+
+      with_lock do
+        attributes = {}
+
+        if previous_visit_at.nil?
+          attributes[:previous_visit_at] = created_at
+        end
+
+        if at >= last_seen_at + inactivity_window
+          attributes[:previous_visit_at] = last_seen_at
+          attributes[:last_seen_at] = at
+        elsif at > last_seen_at
+          attributes[:last_seen_at] = at
+        end
+
+        update!(attributes) if attributes.any?
+      end
+
+      self
+    end
+  end
+end

data/app/models/rails_den/report.rb

@@ -0,0 +1,127 @@
+module RailsDen
+  class Report < ApplicationRecord
+    STATUSES = %w[open resolved dismissed].freeze
+
+    belongs_to :reporter, polymorphic: true
+    belongs_to :reportable, polymorphic: true
+    belongs_to :report_reason,
+               class_name: "RailsDen::ReportReason",
+               inverse_of: :reports
+    belongs_to :subject_user, polymorphic: true
+    belongs_to :assigned_to, polymorphic: true, optional: true
+    belongs_to :closed_by, polymorphic: true, optional: true
+
+    has_many :moderation_notes,
+             as: :subject,
+             class_name: "RailsDen::ModerationNote",
+             dependent: :restrict_with_error
+
+    before_validation :derive_subject_user, on: :create
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :subject_label, presence: true
+    validates :details, length: { maximum: 5_000 }
+
+    validate :reason_accepts_new_report, on: :create
+    validate :details_present_for_other_reason, on: :create
+    validate :reporter_is_not_target_owner, on: :create
+    validate :reporter_can_read_target, on: :create
+    validate :no_duplicate_open_report, on: :create
+
+    scope :open, -> { where(status: "open") }
+    scope :history, -> { where(status: %w[resolved dismissed]) }
+
+    STATUSES.each do |value|
+      define_method("#{value}?") { status == value }
+    end
+
+    validate :assignment_fields_are_consistent
+
+    private
+
+    def derive_subject_user
+      self.subject_user =
+        case reportable
+        when RailsDen::Topic, RailsDen::Post
+          reportable.author
+        else
+          reportable
+        end
+    end
+
+    def assignment_fields_are_consistent
+      return if assigned_to.nil? == assigned_at.nil?
+
+      errors.add(:assigned_at, "must be present exactly when an assignee is present")
+    end
+
+    def reason_accepts_new_report
+      return unless report_reason && reportable
+
+      errors.add(:report_reason, "is not available") unless report_reason.enabled?
+      unless report_reason.applicable_to?(reportable)
+        errors.add(:report_reason, "is not applicable to this report")
+      end
+    end
+
+    def details_present_for_other_reason
+      return unless report_reason&.key == "other"
+      return if details.present?
+
+      errors.add(:details, "must be provided when the reason is Other")
+    end
+
+    def reporter_is_not_target_owner
+      return unless reporter && reportable
+
+      owner =
+        case reportable
+        when RailsDen::Topic, RailsDen::Post
+          reportable.author
+        else
+          reportable
+        end
+
+      if owner == reporter
+        errors.add(:reportable, "cannot be your own content or profile")
+      end
+    end
+
+    def reporter_can_read_target
+      return unless reporter && reportable
+
+      readable =
+        case reportable
+        when RailsDen::Topic
+          RailsDen::ReadableCommunityContent.new(viewer: reporter)
+            .topic_readable?(reportable)
+        when RailsDen::Post
+          RailsDen::ReadableCommunityContent.new(viewer: reporter)
+            .post_readable?(reportable)
+        else
+          visible_member_identity?(reportable)
+        end
+
+      errors.add(:reportable, "is not available") unless readable
+    end
+
+    def visible_member_identity?(identity)
+      mention_name = RailsDen.user_mention_name(identity)
+
+      mention_name.present? &&
+        RailsDen.resolve_user_mention(mention_name) == identity
+    end
+
+    def no_duplicate_open_report
+      return unless reporter && reportable
+      return unless status == "open"
+
+      duplicate = self.class.open.where(
+        reporter: reporter,
+        reportable: reportable
+      )
+
+      errors.add(:reportable, "has already been reported by you") if duplicate.exists?
+    end
+  end
+end

data/app/models/rails_den/report_reason.rb

@@ -0,0 +1,52 @@
+module RailsDen
+  class ReportReason < ApplicationRecord
+    TARGET_KINDS = %w[all content user].freeze
+
+    has_many :reports,
+             class_name: "RailsDen::Report",
+             inverse_of: :report_reason,
+             dependent: :restrict_with_error
+
+    validates :name, :key, presence: true
+    validates :key,
+              uniqueness: true,
+              format: {
+                with: /\A[a-z0-9]+(?:_[a-z0-9]+)*\z/,
+                message: "must contain only lowercase letters, numbers, and underscores"
+              }
+    validates :target_kind, inclusion: { in: TARGET_KINDS }
+    validates :position,
+              numericality: {
+                only_integer: true,
+                greater_than_or_equal_to: 0
+              }
+    validates :enabled, inclusion: { in: [true, false] }
+
+    scope :ordered, -> { order(:position, :id) }
+
+    scope :available_for,
+          ->(target) {
+            kinds =
+              if target.is_a?(RailsDen::Topic) ||
+                 target.is_a?(RailsDen::Post)
+                %w[all content]
+              else
+                %w[all user]
+              end
+
+            where(enabled: true, target_kind: kinds).ordered
+          }
+
+    def applicable_to?(target)
+      self.class.available_for(target).where(id: id).exists?
+    end
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(
+        self,
+        nil,
+        "RailsDen::ReportReason"
+      )
+    end
+  end
+end

data/app/models/rails_den/reputation_event.rb

@@ -0,0 +1,92 @@
+module RailsDen
+  class ReputationEvent < ApplicationRecord
+    EVENT_TYPES = %w[
+      topic_created
+      reply_created
+      manual_adjustment
+    ].freeze
+
+    belongs_to :recipient,
+               polymorphic: true
+
+    belongs_to :actor,
+               polymorphic: true,
+               optional: true
+
+    belongs_to :source,
+               polymorphic: true,
+               optional: true
+
+    validates :event_type,
+              presence: true,
+              inclusion: {
+                in: EVENT_TYPES
+              }
+
+    validates :points,
+              numericality: {
+                only_integer: true,
+                other_than: 0
+              }
+
+    validates :dedupe_key,
+              presence: true,
+              uniqueness: true
+
+    validates :reason,
+              length: {
+                maximum: 1_000
+              }
+
+    validate :manual_adjustment_has_actor_and_reason
+    validate :automatic_event_has_source
+
+    before_update :prevent_mutation
+    before_destroy :prevent_mutation
+
+    private
+
+    def manual_adjustment_has_actor_and_reason
+      return unless event_type == "manual_adjustment"
+
+      if actor.nil?
+        errors.add(
+          :actor,
+          "must be present for a manual adjustment"
+        )
+      end
+
+      if reason.blank?
+        errors.add(
+          :reason,
+          "must be present for a manual adjustment"
+        )
+      end
+    end
+
+    def automatic_event_has_source
+      return unless event_type.in?(
+        %w[
+          topic_created
+          reply_created
+        ]
+      )
+
+      return if source.present?
+
+      errors.add(
+        :source,
+        "must be present for an automatic reputation event"
+      )
+    end
+
+    def prevent_mutation
+      errors.add(
+        :base,
+        "Reputation events are immutable"
+      )
+
+      throw :abort
+    end
+  end
+end