ruby_cms 0.2.1.1 → 1.0.1

data/lib/generators/ruby_cms/templates/lib/tasks/ruby_cms.rake

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+namespace :ruby_cms do
+  desc "Create default permissions/settings and grant manage_admin to admin users"
+  task seed_permissions: :environment do
+    Permission.ensure_defaults!
+    RubyCms::Settings.ensure_defaults!
+    RubyCms::Settings.import_initializer_values!
+    RubyCmsTasks.grant_admin_permissions_to_admin_users
+  end
+
+  desc "Import RubyCMS initializer values into DB settings once"
+  task import_initializer_settings: :environment do
+    result = RubyCms::Settings.import_initializer_values!
+    if result[:skipped]
+      puts "Initializer import skipped: #{result[:reason]}"
+    else
+      puts "Imported #{result[:imported_count]} initializer setting(s)."
+    end
+  end
+
+  desc "Interactively create or select first admin user and grant full permissions"
+  task setup_admin: :environment do
+    require "ruby_cms/cli"
+    RubyCms::RunSetupAdmin.call(shell: Thor::Shell::Basic.new)
+  end
+
+  desc "Grant manage_admin to a user by email. Usage: rails ruby_cms:grant_manage_admin email=user@example.com"
+  task :grant_manage_admin, [ :email ] => :environment do |_t, args|
+    email = args[:email] || ENV["email"] || ENV.fetch("EMAIL", nil)
+    raise "Usage: rails ruby_cms:grant_manage_admin email=user@example.com" if email.blank?
+
+    Permission.ensure_defaults!
+    user = RubyCmsTasks.find_user_by_email(email)
+    raise "User not found: #{email}" unless user
+
+    RubyCmsTasks.grant_manage_admin_permission(user, email)
+  end
+
+  namespace :content_blocks do
+    desc "Export content blocks from database to YAML locale files"
+    task :export, %i[namespace locales_dir] => :environment do |_t, args|
+      namespace = args[:namespace].presence
+      locales_dir = args[:locales_dir].presence ? Pathname.new(args[:locales_dir]) : nil
+      flatten = ENV["flatten"] == "true"
+
+      sync = RubyCms::ContentBlocksSync.new(namespace:, locales_dir:)
+      summary = sync.export_to_yaml(only_published: true, flatten_keys: flatten)
+
+      RubyCmsTasks.display_export_summary(summary)
+    end
+
+    desc "Import content blocks from YAML locale files to database"
+    task :import, %i[locale namespace locales_dir] => :environment do |_t, args|
+      locale = args[:locale].presence&.to_sym
+      namespace = args[:namespace].presence ||
+                  Rails.application.config.ruby_cms.content_blocks_translation_namespace
+      locales_dir = args[:locales_dir].presence ? Pathname.new(args[:locales_dir]) : Rails.root.join("config/locales")
+      import_options = {
+        create_missing: ENV["create_missing"] != "false",
+        update_existing: ENV["update_existing"] != "false",
+        published: ENV["published"] == "true"
+      }
+
+      sync = RubyCms::ContentBlocksSync.new(namespace:, locales_dir:)
+      summary = sync.import_from_yaml(locale:, **import_options)
+
+      RubyCmsTasks.display_import_summary(summary)
+    end
+
+    desc "Sync content blocks: export DB to YAML, optionally import from YAML"
+    task :sync, %i[namespace locales_dir] => :environment do |_t, args|
+      namespace = args[:namespace].presence
+      locales_dir = args[:locales_dir].presence ? Pathname.new(args[:locales_dir]) : nil
+      import_after = ENV["import_after"] == "true"
+
+      sync = RubyCms::ContentBlocksSync.new(namespace:, locales_dir:)
+      result = sync.sync(import_after_export: import_after)
+
+      RubyCmsTasks.display_sync_summary(result, import_after)
+    end
+  end
+end
+
+module RubyCmsTasks
+  module_function
+
+  def grant_admin_permissions_to_admin_users
+    return unless defined?(::User) && User.column_names.include?("admin")
+
+    permission_keys = ::Permission.all_keys
+    permissions = ::Permission.where(key: permission_keys).index_by(&:key)
+    User.where(admin: true).find_each do |u|
+      permission_keys.each do |key|
+        perm = permissions[key]
+        next if perm.nil?
+
+        ::UserPermission.find_or_create_by!(user: u, permission: perm)
+      end
+    end
+  end
+
+  def find_user_by_email(email)
+    user_class = Rails.application.config.ruby_cms.user_class_name.constantize
+    if user_class.column_names.include?("email_address")
+      found = user_class.find_by(email_address: email)
+      return found if found
+    end
+    return user_class.find_by(email:) if user_class.column_names.include?("email")
+
+    nil
+  end
+
+  def grant_manage_admin_permission(user, email)
+    ::Permission.ensure_defaults!
+    ::Permission.all_keys.each do |key|
+      perm = ::Permission.find_by(key:)
+      next unless perm
+
+      ::UserPermission.find_or_create_by!(user: user, permission: perm)
+    end
+    puts "Granted full admin permissions to #{email}"
+  end
+
+  def display_export_summary(summary)
+    if summary.empty?
+      puts "No content blocks found to export."
+    else
+      puts "Exported content blocks to locale files:"
+      summary.each do |locale, count|
+        puts "  #{locale}: #{count} block(s) updated in config/locales/#{locale}.yml"
+      end
+    end
+  end
+
+  def display_import_summary(summary)
+    $stdout.puts "Import summary:"
+    $stdout.puts "  Created: #{summary[:created]}"
+    $stdout.puts "  Updated: #{summary[:updated]}"
+    $stdout.puts "  Skipped: #{summary[:skipped]}"
+    return unless summary[:errors].any?
+
+    $stdout.puts "  Errors:"
+    summary[:errors].each { |e| $stdout.puts "    - #{e}" }
+  end
+
+  def display_sync_summary(result, import_after)
+    $stdout.puts "Sync complete!"
+    $stdout.puts "\nExport summary:"
+    result[:export].each { |locale, count| $stdout.puts "  #{locale}: #{count} block(s) updated" }
+    return unless import_after && result[:import].any?
+
+    $stdout.puts "\nImport summary:"
+    $stdout.puts "  Created: #{result[:import][:created]}"
+    $stdout.puts "  Updated: #{result[:import][:updated]}"
+    $stdout.puts "  Skipped: #{result[:import][:skipped]}"
+  end
+end

data/lib/generators/ruby_cms/templates/models/audit_log_entry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class AuditLogEntry < ApplicationRecord
+  include Ransackable
+  include PgSearch::Model
+
+  ransack_attrs :actor_email, :action, :target_label, :summary, :ip, :created_at
+
+  pg_search_scope :search_fulltext,
+                  against: %i[actor_email action target_label summary ip],
+                  using: { tsearch: { prefix: true, dictionary: "english" } }
+
+  BUCKETS = %w[content users system security].freeze
+
+  validates :action, presence: true
+
+  scope :recent, -> { order(created_at: :desc) }
+
+  scope :by_actor, ->(email) { where(actor_email: email) if email.present? }
+
+  scope :by_bucket, lambda { |bucket|
+    case bucket.to_s
+    when "content"  then where("action LIKE ANY (ARRAY[?])", %w[content_block% media% form% redirect%])
+    when "users"    then where("action LIKE ANY (ARRAY[?])", %w[user% permission% token% login%])
+    when "system"   then where("action LIKE ANY (ARRAY[?])", %w[system% job% backup% deploy% cache% sitemap%])
+    when "security" then where("action ~ ?", "(failed|webhook|integration|settings)")
+    end
+  }
+
+  scope :search, lambda { |term|
+    return all if term.blank?
+
+    q = "%#{term.to_s.strip}%"
+    where(
+      "actor_email ILIKE :q OR action ILIKE :q OR target_label ILIKE :q OR summary ILIKE :q OR ip ILIKE :q",
+      q:
+    )
+  }
+
+  def bucket
+    case action.to_s
+    when /\A(content_block|media|form|redirect)/ then "content"
+    when /\A(user|permission|token|login)/       then "users"
+    when /\A(system|job|backup|deploy|cache|sitemap)/ then "system"
+    when /(failed|webhook|integration|settings)/ then "security"
+    else                                              "system"
+    end
+  end
+
+  def severity
+    return :danger  if action.to_s.match?(/(failed|delete)/)
+    return :success if action.to_s.match?(/(publish|complete|success)/)
+
+    :default
+  end
+end

data/lib/generators/ruby_cms/templates/models/command_run.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class CommandRun < ApplicationRecord
+  STATUSES = %w[ok failed].freeze
+
+  belongs_to :ran_by, class_name: "User", optional: true
+
+  validates :command_key, presence: true
+  validates :status, inclusion: { in: STATUSES }
+  validates :started_at, presence: true
+
+  scope :for_key,       ->(k) { where(command_key: k.to_s) }
+  scope :recent,        -> { order(started_at: :desc) }
+  scope :last_per_key,  -> {
+    from(
+      "(SELECT DISTINCT ON (command_key) * FROM command_runs ORDER BY command_key, started_at DESC) AS command_runs"
+    )
+  }
+
+  def ok?
+    status == "ok"
+  end
+
+  def by_label
+    return ran_by.email_address if ran_by&.respond_to?(:email_address) && ran_by.email_address.present?
+    return ran_by.email if ran_by&.respond_to?(:email) && ran_by.email.present?
+    ran_by_label.presence || "system"
+  end
+end

data/lib/generators/ruby_cms/templates/models/concerns/content_block/searchable.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# DHH-style concern for search behavior.
+# Extracts search and filtering logic to a reusable module.
+#
+# @example
+#   ContentBlock.search_by_term("welcome")
+module ContentBlock::Searchable # rubocop:disable Style/ClassAndModuleChildren
+  extend ActiveSupport::Concern
+
+  included do
+    include PgSearch::Model
+
+    pg_search_scope :search_by_term,
+                    against: %i[key title],
+                    using: { tsearch: { prefix: true, dictionary: "english" } }
+  end
+end

data/{app → lib/generators/ruby_cms/templates}/models/concerns/content_block/versionable.rb

@@ -62,7 +62,7 @@ module ContentBlock::Versionable # rubocop:disable Style/ClassAndModuleChildren
     versions.create!(
       user: updated_by,
       version_number: current_version_number + 1,
-      title: title,
+      title: title.to_s,
       content: content,
       rich_content_html: rich_html,
       content_type: content_type,

data/lib/generators/ruby_cms/templates/models/concerns/ransackable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Ransack 4 safety: every model exposed to Ransack must whitelist its
+# searchable attributes/associations. This concern is a tiny DSL:
+#
+#   class ContactMessage < ApplicationRecord
+#     include Ransackable
+#     ransack_attrs :name, :email, :message_body, :read, :created_at
+#     ransack_assocs :user
+#   end
+#
+# Default: nothing searchable. Sortable headers can't pass through unknown
+# attributes, which is exactly the safety guarantee we want.
+module Ransackable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def ransack_attrs(*names)
+      attrs = names.map(&:to_s).freeze
+      define_singleton_method(:ransackable_attributes) do |_auth_object = nil|
+        attrs
+      end
+    end
+
+    def ransack_assocs(*names)
+      assocs = names.map(&:to_s).freeze
+      define_singleton_method(:ransackable_associations) do |_auth_object = nil|
+        assocs
+      end
+    end
+  end
+end

data/{app → lib/generators/ruby_cms/templates}/models/content_block.rb

@@ -5,6 +5,14 @@ class ContentBlock < ApplicationRecord
   include Publishable
   include Searchable
   include Versionable
+  include Discard::Model
+  include Ransackable
+
+  ransack_attrs :key, :title, :content, :locale, :content_type, :published, :created_at, :updated_at, :discarded_at
+
+  # audited tracks per-field diffs in the `audits` table. Coexists with the
+  # custom ContentBlockVersion model (which captures bigger snapshots).
+  audited only: %i[key title content content_type locale published]
 
   self.table_name = "content_blocks"
 
@@ -52,7 +60,7 @@ class ContentBlock < ApplicationRecord
   scope :for_current_locale, -> { where(locale: I18n.locale.to_s) }
   scope :preloaded, -> { includes(:updated_by) }
 
-  scope :indexed_by, lambda {|index|
+  scope :indexed_by, lambda { |index|
     case index.to_s
     when "published" then published
     when "unpublished" then unpublished
@@ -60,7 +68,7 @@ class ContentBlock < ApplicationRecord
     end
   }
 
-  scope :sorted_by, lambda {|sort|
+  scope :sorted_by, lambda { |sort|
     case sort.to_s
     when "latest" then reverse_chronologically
     when "oldest" then chronologically
@@ -116,7 +124,7 @@ class ContentBlock < ApplicationRecord
 
   def key_not_reserved
     prefixes =
-      Array(RubyCms::Settings.get(:reserved_key_prefixes, default: ["admin_"])).map(&:to_s)
+      Array(RubyCms::Settings.get(:reserved_key_prefixes, default: [ "admin_" ])).map(&:to_s)
     return unless key.to_s.start_with?(*prefixes)
 
     errors.add(:key, :reserved)
@@ -138,11 +146,11 @@ class ContentBlock < ApplicationRecord
     Array(
       RubyCms::Settings.get(
         :image_content_types,
-        default: ["image/png", "image/jpeg", "image/gif", "image/webp"]
+        default: [ "image/png", "image/jpeg", "image/gif", "image/webp" ]
       )
     ).map(&:to_s)
   rescue StandardError
-    ["image/png", "image/jpeg", "image/gif", "image/webp"]
+    [ "image/png", "image/jpeg", "image/gif", "image/webp" ]
   end
 
   def image_size

data/lib/generators/ruby_cms/templates/models/email_blocklist.rb

@@ -0,0 +1,21 @@
+class EmailBlocklist < ApplicationRecord
+  validates :email,
+            presence: true,
+            format: { with: URI::MailTo::EMAIL_REGEXP },
+            uniqueness: { case_sensitive: false }
+
+  before_validation :normalize_email
+
+  scope :ordered, -> { order(created_at: :desc) }
+
+  def self.blocked?(email)
+    normalized = email.to_s.strip.downcase
+    normalized.present? && where(email: normalized).exists?
+  end
+
+  private
+
+  def normalize_email
+    self.email = email.to_s.strip.downcase
+  end
+end

data/lib/generators/ruby_cms/templates/models/invitation.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class Invitation < ApplicationRecord
+  DEFAULT_TTL = 14.days
+
+  belongs_to :invited_by, class_name: "User", optional: true
+
+  normalizes :email, with: ->(e) { e.to_s.strip.downcase }
+
+  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+  validates :token, presence: true, uniqueness: true
+
+  validate :unique_pending_email_per_invite
+
+  before_validation :ensure_token
+  before_validation :ensure_expiry
+
+  scope :pending,  -> { where(accepted_at: nil, revoked_at: nil).where("expires_at > ?", Time.current) }
+  scope :expired,  -> { where(accepted_at: nil, revoked_at: nil).where("expires_at <= ?", Time.current) }
+  scope :accepted, -> { where.not(accepted_at: nil) }
+  scope :revoked,  -> { where.not(revoked_at: nil) }
+
+  def status
+    return :accepted if accepted_at
+    return :revoked  if revoked_at
+    return :expired  if expires_at && expires_at <= Time.current
+
+    :pending
+  end
+
+  def pending?
+    status == :pending
+  end
+
+  def role_label
+    admin ? "Beheerder" : "Gebruiker"
+  end
+
+  def accept!(password:, password_confirmation: nil)
+    raise "Niet uitnodigbaar" unless pending?
+
+    user_class = Object.const_get(Rails.application.config.ruby_cms.user_class_name.presence || "User")
+    user = user_class.new(
+      email_address: email,
+      password: password,
+      password_confirmation: password_confirmation || password,
+      admin: admin
+    )
+    user.transaction do
+      user.save!
+      update!(accepted_at: Time.current)
+    end
+    user
+  end
+
+  def revoke!
+    update!(revoked_at: Time.current)
+  end
+
+  def touch_sent!
+    update!(last_sent_at: Time.current)
+  end
+
+  def extend_expiry!(by: DEFAULT_TTL)
+    update!(expires_at: Time.current + by)
+  end
+
+  private
+
+  def ensure_token
+    self.token ||= SecureRandom.urlsafe_base64(32)
+  end
+
+  def ensure_expiry
+    self.expires_at ||= Time.current + DEFAULT_TTL
+  end
+
+  def unique_pending_email_per_invite
+    return if email.blank?
+    return if accepted_at || revoked_at
+
+    scope = self.class.pending.where(email:)
+    scope = scope.where.not(id:) if persisted?
+    errors.add(:email, "heeft al een openstaande uitnodiging") if scope.exists?
+  end
+end

data/lib/generators/ruby_cms/templates/models/ip_blocklist.rb

@@ -0,0 +1,34 @@
+class IpBlocklist < ApplicationRecord
+  validates :ip_address,
+            presence: true,
+            uniqueness: { case_sensitive: false }
+
+  before_validation :normalize_ip
+  after_save :clear_cache
+  after_destroy :clear_cache
+
+  scope :ordered, -> { order(created_at: :desc) }
+
+  def self.blocked?(ip_address)
+    normalized = normalize_ip_address(ip_address)
+    normalized.present? && where(ip_address: normalized).exists?
+  end
+
+  private
+
+  def normalize_ip
+    self.ip_address = self.class.normalize_ip_address(ip_address)
+  end
+
+  def self.normalize_ip_address(ip)
+    return nil if ip.blank?
+
+    ip.to_s.strip
+  end
+
+  def clear_cache
+    # Clear the Rack::Attack cache for this IP
+    cache_key = "ip_blocklist:#{ip_address}"
+    Rails.cache.delete(cache_key)
+  end
+end

data/lib/generators/ruby_cms/templates/models/media_asset.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# A media library asset (image, video, document, or other binary).
+#
+# The actual binary lives in Active Storage (+file+); the row captures metadata
+# (kind, mime type, dimensions, folder, tags, usage count, etc.) so the index can
+# render quickly without hitting the blob service for every record.
+class MediaAsset < ApplicationRecord
+  include Discard::Model
+  include Ransackable
+  include PgSearch::Model
+
+  ransack_attrs :name, :folder, :kind, :mime_type, :size_kb, :used_count, :created_at, :discarded_at
+
+  pg_search_scope :search_by_term,
+                  against: %i[name folder],
+                  using: { tsearch: { prefix: true, dictionary: "english" } }
+
+  KINDS = %w[image video doc other].freeze
+  TONES = %w[coral purple blue sand].freeze
+
+  has_one_attached :file
+
+  belongs_to :uploaded_by, class_name: "User", optional: true
+
+  validates :name, :folder, :kind, presence: true
+  validates :kind, inclusion: { in: KINDS }
+  validates :tone, inclusion: { in: TONES, allow_nil: true }
+
+  scope :in_folder, ->(folder) { where(folder:) }
+  scope :with_tag, ->(tag) { where("tags @> ?", [tag].to_json) }
+  scope :unused, -> { where(used_count: 0) }
+  scope :recent, -> { order(created_at: :desc) }
+  scope :largest, -> { order(size_kb: :desc) }
+
+  def self.kinds
+    KINDS
+  end
+
+  # Hash a name into one of TONES so the same name always picks the same tone.
+  def self.tone_for(name)
+    TONES[name.to_s.sum % TONES.size]
+  end
+
+  # Infer kind ("image"|"video"|"doc"|"other") from a mime type string.
+  def self.kind_from_mime(mime)
+    case mime.to_s
+    when %r{\Aimage/}        then "image"
+    when %r{\Avideo/}        then "video"
+    when "application/pdf",
+         %r{\Aapplication/(msword|vnd\.openxmlformats|vnd\.oasis)},
+         "text/plain",
+         "text/csv" then "doc"
+    else "other"
+    end
+  end
+
+  # Full-text on name/folder via pg_search, plus tag containment fallback so
+  # exact tag matches still hit even when tsearch tokenises them out.
+  def self.search(term)
+    return all if term.blank?
+
+    fulltext_ids = search_by_term(term).select(:id)
+    tag_match = where("tags @> ?", [term].to_json)
+    where(id: fulltext_ids).or(tag_match)
+  end
+
+  # { "general" => 5, "events" => 2, ..., "all" => total }. Memoised on
+  # +Current+ so a single request only runs the GROUP BY once.
+  def self.folder_counts
+    cached = Current.respond_to?(:media_folder_counts) && Current.media_folder_counts
+    return cached if cached
+
+    computed = group(:folder).count
+    computed["all"] = computed.values.sum
+    Current.media_folder_counts = computed if Current.respond_to?(:media_folder_counts=)
+    computed
+  end
+
+  # Stringified URL to the attached file, or nil when nothing is attached.
+  # Falls back to a path-only blob URL when +default_url_options+ is unset
+  # (e.g. in console / runners).
+  def cdn_url
+    return nil unless file.attached?
+
+    Rails.application.routes.url_helpers.url_for(file)
+  rescue ArgumentError
+    Rails.application.routes.url_helpers.rails_blob_path(file, only_path: true)
+  end
+end

data/lib/generators/ruby_cms/templates/models/passkey_credential.rb

@@ -0,0 +1,6 @@
+class PasskeyCredential < ApplicationRecord
+  belongs_to :user
+
+  validates :external_id, presence: true, uniqueness: true
+  validates :public_key, presence: true
+end

data/lib/generators/ruby_cms/templates/models/permission.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class Permission < ApplicationRecord
+  include Ransackable
+
+  ransack_attrs :key, :name
+
+  self.table_name = "permissions"
+
+  has_many :user_permissions, dependent: :destroy, class_name: "UserPermission"
+  has_many :users, through: :user_permissions
+
+  validates :key, presence: true, uniqueness: true
+  validates :name, presence: true
+
+  DEFAULT_KEYS = RubyCms::DEFAULT_PERMISSION_KEYS
+
+  before_destroy :prevent_builtin_deletion
+
+  # Built-in permission keys are part of the gem's contract (manage_admin etc.);
+  # deleting their row would silently strip the permission from every user.
+  def prevent_builtin_deletion
+    return unless DEFAULT_KEYS.map(&:to_s).include?(key.to_s)
+
+    errors.add(:base, "Kan een ingebouwde permissie (#{key}) niet verwijderen.")
+    throw :abort
+  end
+
+  class << self
+    def ensure_defaults!
+      all_keys.each do |k|
+        find_or_create_by!(key: k) { |p| p.name = k.titleize }
+      end
+    end
+
+    def all_keys
+      (DEFAULT_KEYS + RubyCms.extra_permission_keys.map(&:to_s)).uniq.freeze
+    end
+
+    def templates
+      RubyCms.permission_templates
+    end
+
+    def register_keys(*keys)
+      RubyCms.register_permission_keys(*keys)
+    end
+
+    def register_template(name, label:, keys:, description: nil)
+      RubyCms.register_permission_template(name, label:, keys:, description:)
+    end
+
+    def apply_template!(user, template_name)
+      tmpl = templates[template_name.to_sym]
+      raise ArgumentError, "Unknown template: #{template_name}" unless tmpl
+
+      ensure_defaults!
+      perms = where(key: tmpl[:keys])
+      perms.each do |perm|
+        UserPermission.find_or_create_by!(user: user, permission: perm)
+      end
+    end
+
+    def matching_templates(user)
+      user_keys = UserPermission.where(user:)
+                                .joins(:permission)
+                                .pluck("permissions.key")
+      templates.select { |_, tmpl| (tmpl[:keys] - user_keys).empty? }
+               .keys
+    end
+  end
+end