Module: Moderate::Macros

Defined in:
lib/moderate/macros.rb

Overview

The class-level DSL the gem adds to every ActiveRecord model.

The engine does ActiveSupport.on_load(:active_record) { extend Moderate::Macros }, so has_reporting_and_blocking, has_reportable_content, and moderates become class methods on ActiveRecord::Base — readable plain-English declarations that sit alongside the rest of a host's stack (has_credits, has_wallets, has_api_keys):

class User    < ApplicationRecord; has_reporting_and_blocking; end
class Listing < ApplicationRecord; has_reportable_content :title, :description; end
class Message < ApplicationRecord; moderates :body, mode: :flag; end

Each macro is exact sugar for an include + a declaration — the README documents both forms as equivalent. The macros are deliberately thin: they lazily include the right concern (only models that opt in pay for it) and then forward to that concern's declaration method. All behavior lives in the concerns, never here.

Instance Method Summary collapse

Instance Method Details

#has_reportable_content(*fields) ⇒ Object

has_reportable_content(*fields) — mark this model as REPORTABLE content, optionally narrowing to specific fields. Bare has_reportable_content (no fields) means "the whole record is reportable" (the field whitelist stays empty, and a blank reported_field is then allowed — see Reportable#reportable_field_allowed?).

Equivalent to include Moderate::Reportable + reportable_fields(*fields).



55
56
57
58
59
 
# File 'lib/moderate/macros.rb', line 55

def has_reportable_content(*fields)
  include Moderate::Reportable unless include?(Moderate::Reportable)
  reportable_fields(*fields) if fields.any?
  self
end

#has_reporting_and_blocking ⇒ Object

has_reporting_and_blocking — make this model an ACTOR in the Trust & Safety system: it can report content/users and block/unblock other users (report!/block!/unblock!/blocks?/blocked_by?/blocked_with?, plus the block & report associations), and — since the actor is usually itself reportable and is the be-banned target — it's also made reportable. One macro, both halves.

Equivalent to include Moderate::Actor. Idempotent: re-declaring (or both macro + explicit include) won't double-include.



44
45
46
 
# File 'lib/moderate/macros.rb', line 44

def has_reporting_and_blocking
  include Moderate::Actor unless include?(Moderate::Actor)
end

#moderates(*fields, mode: nil, with: nil) ⇒ Object

moderates(*fields, mode:, with:) — filter one or more fields before they're saved. mode:/with: default to nil so the field inherits the global config.default_filter_mode / config.filter_adapter (resolved inside config.filter), letting a bare moderates :body Just Work.

Two things happen, per field:

1. The field is registered on the model (Moderate::ContentFilterable), so
 the :block validation and :flag after_commit hook run for it.
2. A Configuration FilterPolicy is recorded keyed by [class_name, field],
 so `Moderate.filter_policy_for` (which the concern consults at
 validate/commit time, walking the ancestor chain) can find the field's
 adapter + mode. This is the exact twin of `config.filter "Class", :field,
 with:, mode:` in the initializer — same storage, same resolution.

Equivalent to include Moderate::ContentFilterable + moderates_fields(*fields) plus the per-field policy registration.



77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/moderate/macros.rb', line 77

def moderates(*fields, mode: nil, with: nil)
  include Moderate::ContentFilterable unless include?(Moderate::ContentFilterable)
  moderates_fields(*fields)

  fields.each do |field|
    # `config.filter` normalizes/validates the adapter+mode and stores the
    # policy; passing `self` (the class) lets it record the class NAME string.
    Moderate.config.filter(self, field, with: with, mode: mode)
  end

  self
end