ruby_cms 0.2.1.1 → 1.0.0

data/lib/{ruby_cms → generators/ruby_cms/templates/lib/ruby_cms}/settings.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "settings_registry"
-
 module RubyCms
   module Settings
     IMPORT_SENTINEL_KEY = "__internal_initializer_import_v1"
@@ -25,18 +23,18 @@ module RubyCms
         entry = RubyCms::SettingsRegistry.fetch(k)
         coerced = coerce_by_entry(value, entry)
 
-        RubyCms::Preference.set(k, coerced)
+        ::Preference.set(k, coerced)
       end
 
       def ensure_defaults!
         RubyCms::SettingsRegistry.seed_defaults!
-        RubyCms::Preference.ensure_defaults!
+        ::Preference.ensure_defaults!
       end
 
       def all
         return {} unless preference_table_available?
 
-        RubyCms::Preference.all_as_hash
+        ::Preference.all_as_hash
       end
 
       # Imports initializer values for any key that exists in SettingsRegistry
@@ -78,7 +76,7 @@ module RubyCms
       def imported_from_initializer?
         return false unless preference_table_available?
 
-        RubyCms::Preference.exists?(key: IMPORT_SENTINEL_KEY)
+        ::Preference.exists?(key: IMPORT_SENTINEL_KEY)
       rescue StandardError
         false
       end
@@ -98,7 +96,7 @@ module RubyCms
       end
 
       def mark_imported!(imported_keys)
-        RubyCms::Preference.set(
+        ::Preference.set(
           IMPORT_SENTINEL_KEY,
           {
             version: 1,
@@ -111,15 +109,67 @@ module RubyCms
       def fetch_preference(key)
         return nil unless preference_table_available?
 
-        RubyCms::Preference.find_by(key:)
+        cache = Thread.current[:ruby_cms_pref_cache]
+        if cache
+          return cache[key.to_s] if cache.key?(key.to_s)
+
+          rec = ::Preference.find_by(key:)
+          cache[key.to_s] = rec
+          return rec
+        end
+
+        ::Preference.find_by(key:)
       rescue StandardError
         nil
       end
 
+      public
+
+      # Bulk-load preferences into a request-scoped cache so the nav rendering
+      # does not run one SELECT per nav_show_* key. Called from
+      # Admin::ApplicationController#preload_nav_prefs.
+      def preload_preferences(prefix:)
+        return unless preference_table_available?
+
+        Thread.current[:ruby_cms_pref_cache] ||= {}
+        cache = Thread.current[:ruby_cms_pref_cache]
+        ::Preference.where("key LIKE ?", "#{prefix}%").each do |pref|
+          cache[pref.key] = pref
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Bulk-load a specific list of keys into the request cache. Cheaper than
+      # calling .get per key in a loop (used by Settings index for the active tab).
+      def preload_keys(keys)
+        return unless preference_table_available?
+        return if keys.blank?
+
+        Thread.current[:ruby_cms_pref_cache] ||= {}
+        cache = Thread.current[:ruby_cms_pref_cache]
+        str_keys = Array(keys).map(&:to_s)
+        ::Preference.where(key: str_keys).each { |pref| cache[pref.key] = pref }
+        # Mark missing keys as nil in cache so fetch_preference doesn't re-query.
+        str_keys.each { |k| cache[k] = nil unless cache.key?(k) }
+      rescue StandardError
+        nil
+      end
+
+      def reset_preference_cache
+        Thread.current[:ruby_cms_pref_cache] = nil
+      end
+
+      # Memoizes the positive result: once the preferences table exists it won't
+      # vanish for the life of the process, so we skip the per-lookup probe (this is
+      # called many times per admin request via the nav). Stays false-and-rechecks
+      # during boot/migrate until the table appears.
       def preference_table_available?
-        return false unless defined?(ActiveRecord::Base) && defined?(RubyCms::Preference)
+        return true if @preference_table_available
+        return false unless defined?(ActiveRecord::Base) && defined?(::Preference)
 
-        ActiveRecord::Base.connection.data_source_exists?("preferences")
+        @preference_table_available = true if ActiveRecord::Base.connection.data_source_exists?("preferences")
+        @preference_table_available || false
       rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
         false
       end

data/lib/{ruby_cms → generators/ruby_cms/templates/lib/ruby_cms}/settings_registry.rb

@@ -12,7 +12,25 @@ module RubyCms
 
     mattr_accessor :entries, default: {}
 
+    # Host apps register their own settings here (see configure). The proc runs
+    # on every seed so custom keys survive regardless of initializer load order.
+    mattr_accessor :custom_registrar, default: nil
+
     class << self
+      # Host hook. Call from an initializer:
+      #
+      #   RubyCms::SettingsRegistry.configure do |r|
+      #     r.register(key: :ui_v3_enabled, type: :boolean, default: true,
+      #                category: :custom, description: "Use the new public UI")
+      #   end
+      #
+      # Use category: :custom (or any name) to get a dedicated block in Settings.
+      def configure(&block)
+        self.custom_registrar = block
+        seed_defaults! if @gem_defaults_seeded
+        block
+      end
+
       def register(key:, type:, default:, category: "general", description: nil)
         k = key.to_s
         entries[k] = Entry.new(
@@ -49,7 +67,16 @@ module RubyCms
       end
 
       def seed_defaults!
-        return unless entries.empty?
+        seed_gem_defaults!
+        custom_registrar&.call(self)
+      end
+
+      # Gem defaults seed exactly once; kept separate from the host registrar so the
+      # two never clobber each other and order of registration does not matter.
+      def seed_gem_defaults!
+        return if @gem_defaults_seeded
+
+        @gem_defaults_seeded = true
 
         # Pagination
         register(
@@ -294,14 +321,14 @@ module RubyCms
         register(
           key: :reserved_key_prefixes,
           type: :json,
-          default: ["admin_"],
+          default: [ "admin_" ],
           category: :content,
           description: "Reserved prefixes blocked for content block keys"
         )
         register(
           key: :image_content_types,
           type: :json,
-          default: ["image/png", "image/jpeg", "image/gif", "image/webp"],
+          default: [ "image/png", "image/jpeg", "image/gif", "image/webp" ],
           category: :content,
           description: "Allowed MIME types for content block images"
         )
@@ -312,6 +339,55 @@ module RubyCms
           category: :content,
           description: "Max image attachment size in bytes"
         )
+
+        # General — site behaviour an admin actually controls.
+        register(
+          key: :maintenance_mode,
+          type: :boolean,
+          default: false,
+          category: :general,
+          description: "Toont een onderhouds-banner aan bezoekers."
+        )
+        register(
+          key: :maintenance_message,
+          type: :string,
+          default: "Onze site is tijdelijk in onderhoud. We zijn snel weer terug.",
+          category: :general,
+          description: "Bericht getoond aan bezoekers tijdens maintenance mode."
+        )
+
+        # Visual editor preview — lets a host make the preview iframe match its public
+        # site without forking the minimal layout.
+        register(
+          key: :visual_editor_preview_title,
+          type: :string,
+          default: "Page Preview",
+          category: :visual_editor,
+          description: "Titel van het preview-tabblad in de visual editor."
+        )
+        register(
+          key: :visual_editor_preview_stylesheets,
+          type: :string,
+          default: "tailwind,application,actiontext",
+          category: :visual_editor,
+          description: "Komma-lijst van stylesheet-namen die de preview laadt (bv. je publieke CSS + actiontext)."
+        )
+        register(
+          key: :visual_editor_preview_head,
+          type: :string,
+          default: "",
+          category: :visual_editor,
+          description: "Extra <head> HTML voor de preview (bv. font-preloads). Wordt rauw ingevoegd — alleen admin."
+        )
+
+        # Site identity — used in host app (mailers, branding, etc.).
+        register(
+          key: :site_name,
+          type: :string,
+          default: "",
+          category: :general,
+          description: "Naam van de site (algemeen, bv. in e-mails of meta)."
+        )
       end
 
       private

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

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require_relative "ruby_cms/settings_registry"
+require_relative "ruby_cms/settings"
+require_relative "ruby_cms/icons"
+require_relative "ruby_cms/dashboard_blocks"
+require_relative "ruby_cms/commands_registry"
+require_relative "ruby_cms/content_blocks_sync"
+require_relative "ruby_cms/content_blocks_grouping"
+
+module RubyCms
+  class Error < StandardError; end
+
+  mattr_accessor :nav_registry
+  self.nav_registry = []
+
+  DEFAULT_PERMISSION_KEYS = %w[
+    manage_admin
+    manage_permissions
+    manage_content_blocks
+    manage_visitor_errors
+    manage_analytics
+  ].freeze
+
+  mattr_accessor :extra_permission_keys, default: []
+  mattr_accessor :permission_templates, default: {}
+
+  def self.register_permission_keys(*keys)
+    self.extra_permission_keys = (extra_permission_keys + keys.flatten.map(&:to_s)).uniq
+  end
+
+  def self.register_permission_template(name, label:, keys:, description: nil)
+    permission_templates[name.to_sym] = {
+      label: label,
+      keys: keys.map(&:to_s),
+      description: description
+    }
+  end
+
+  NAV_SECTION_MAIN   = "main"
+  NAV_SECTION_BOTTOM = "Settings"
+
+  def self.configure
+    config = Rails.application.config
+    config.ruby_cms = ActiveSupport::OrderedOptions.new unless ruby_cms_options?(config)
+    yield(config.ruby_cms)
+  end
+
+  # True when config.ruby_cms is already an OrderedOptions. Reading an unset custom
+  # config key raises NoMethodError on Rails::Application::Configuration, so guard it.
+  def self.ruby_cms_options?(config)
+    config.ruby_cms.is_a?(ActiveSupport::OrderedOptions)
+  rescue NoMethodError
+    false
+  end
+
+  def self.setting(key, default: nil)
+    RubyCms::Settings.get(key, default:)
+  end
+
+  def self.nav_register(key:, label:, path:, icon: nil, section: nil, order: nil, permission: nil, default_visible: true, **options)
+    normalized_key     = key.to_sym
+    normalized_section = section.to_s == "settings" ? NAV_SECTION_BOTTOM : NAV_SECTION_MAIN
+    resolved_path      = path.kind_of?(Symbol) ? ->(v) { v.main_app.send(path) } : path
+    resolved_icon      = icon.nil? ? nil : RubyCms::Icons.resolve(icon)
+    entry = {
+      type: :link,
+      key: normalized_key,
+      label: label.to_s,
+      path: resolved_path,
+      icon: resolved_icon,
+      section: normalized_section,
+      order: order,
+      permission: permission&.to_s,
+      default_visible: default_visible ? true : false,
+      if: options[:if]
+    }
+
+    self.nav_registry = nav_registry.reject { |e| e[:key] == normalized_key }
+    self.nav_registry += [ entry ]
+    register_navigation_setting!(entry)
+    entry
+  end
+
+  def self.nav_group(
+    key:, label:, children:,
+    path: nil, icon: nil, section: nil, order: nil,
+    permission: nil, default_visible: true, default_open: true, **options
+  )
+    normalized_key      = key.to_sym
+    normalized_section  = section.to_s == "settings" ? NAV_SECTION_BOTTOM : NAV_SECTION_MAIN
+    resolved_path       = if path.nil?
+                            nil
+    else
+                            (path.kind_of?(Symbol) ? ->(v) { v.main_app.send(path) } : path)
+    end
+    resolved_icon       = icon.nil? ? nil : RubyCms::Icons.resolve(icon)
+    normalized_children = Array(children).map(&:to_s).map(&:strip).reject(&:blank?).map(&:to_sym)
+
+    entry = {
+      type: :group,
+      key: normalized_key,
+      label: label.to_s,
+      path: resolved_path,
+      icon: resolved_icon,
+      section: normalized_section,
+      order: order,
+      permission: permission&.to_s,
+      default_visible: default_visible ? true : false,
+      default_open: default_open ? true : false,
+      children: normalized_children,
+      if: options[:if]
+    }
+
+    self.nav_registry = nav_registry.reject { |e| e[:key] == normalized_key }
+    self.nav_registry += [ entry ]
+    register_navigation_setting!(entry)
+    entry
+  end
+
+  VALID_PAGE_SECTIONS = %i[main settings].freeze
+
+  def self.register_page(
+    key:, label:, path:, icon: nil, section: :main, order: nil,
+    permission: nil, default_visible: true, **
+  )
+    raise ArgumentError, "register_page section must be :main or :settings, got #{section.inspect}" unless VALID_PAGE_SECTIONS.include?(section.to_s.to_sym)
+
+    register_permission_keys(permission) if permission.present?
+    nav_register(key:, label:, path:, icon:, section:, order:, permission:, default_visible:, **)
+  end
+
+  def self.visible_nav_registry(view_context: nil, user: nil)
+    cache_key = nav_request_cache_key(user)
+    if cache_key && (cached = Thread.current[:ruby_cms_visible_nav]&.dig(cache_key))
+      return cached
+    end
+
+    list = nav_registry
+           .select { |item| nav_entry_visible?(item, view_context:, user:) }
+           .sort_by { |item| nav_sort_tuple(item) }
+    result = localize_nav_labels(apply_nav_order(list))
+
+    if cache_key
+      Thread.current[:ruby_cms_visible_nav] ||= {}
+      Thread.current[:ruby_cms_visible_nav][cache_key] = result
+    end
+    result
+  rescue StandardError => e
+    Rails.logger.error("[RubyCMS] Error filtering navigation: #{e.message}") if defined?(Rails.logger)
+    []
+  end
+
+  def self.reset_visible_nav_cache
+    Thread.current[:ruby_cms_visible_nav] = nil
+  end
+
+  def self.nav_request_cache_key(user)
+    locale = I18n.locale.to_s
+    if user.respond_to?(:id) && user.id
+      "u:#{user.id}:#{locale}"
+    elsif user
+      "obj:#{user.object_id}:#{locale}"
+    end
+  end
+
+  def self.visible_nav_sidebar_rows(section:, view_context: nil, user: nil)
+    visible      = visible_nav_registry(view_context:, user:)
+    links        = visible.select { |e| e[:type].to_s == "link" }
+    groups       = visible.select { |e| e[:type].to_s == "group" }
+    links_by_key = links.index_by { |e| e[:key].to_sym }
+    nested_keys  = groups.flat_map { |g| Array(g[:children]) }.map(&:to_sym).to_set
+    position     = visible.each_with_index.to_h { |e, i| [ e[:key], i ] }
+
+    section_name = section.to_s == "settings" ? NAV_SECTION_BOTTOM : NAV_SECTION_MAIN
+
+    group_rows = groups
+                 .select { |g| g[:section].to_s == section_name }
+                 .filter_map do |g|
+                   # Preserve g[:children] order — apply_nav_order may have reordered it per user preference.
+                   child_entries = Array(g[:children]).map { |k| links_by_key[k.to_sym] }.compact
+                   next if child_entries.empty? && g[:path].blank?
+
+                   [ { type: :group, group: g, children: child_entries }, position.fetch(g[:key], 9999) ]
+                 end
+
+    link_rows = links
+                .select { |e| e[:section].to_s == section_name }
+                .reject { |e| nested_keys.include?(e[:key].to_sym) }
+                .map { |e| [ { type: :link, entry: e }, position.fetch(e[:key], 9999) ] }
+
+    (group_rows + link_rows).sort_by { |(_, pos)| pos }.map(&:first)
+  end
+
+  module Nav
+    def self.register(key:, label:, path:, icon: nil, section: nil, order: nil, permission: nil, default_visible: true, **)
+      RubyCms.nav_register(key:, label:, path:, icon:, section:, order:, permission:, default_visible:, **)
+    end
+  end
+
+  class << self
+    private
+
+    def nav_sort_tuple(item)
+      section  = item[:section].to_s.presence || NAV_SECTION_MAIN
+      priority = nav_section_priority(section)
+      [ priority, item[:order] || 1000, item[:label].to_s ]
+    end
+
+    def localize_nav_labels(list)
+      list.map do |item|
+        translated = I18n.t("ruby_cms.nav.items.#{item[:key]}", default: item[:label].to_s)
+        item.merge(label: translated)
+      end
+    end
+
+    def nav_section_priority(section)
+      section.to_s == NAV_SECTION_MAIN ? 0 : 2
+    end
+
+    def apply_nav_order(list)
+      pref = ::Preference.find_by(key: "nav_order")
+      return list unless pref&.value_type == "json" && pref.value.present?
+
+      saved = JSON.parse(pref.value)
+
+      # Hash form: { "main" => [keys...], "settings" => [keys...], "groups" => { group_key => [child_keys...] } }
+      # Lets cross-section moves persist (item dragged main → settings overrides section)
+      # AND lets users reorder children inside each collapsible group.
+      if saved.kind_of?(Hash)
+        main_keys     = Array(saved["main"]).map(&:to_s)
+        settings_keys = Array(saved["settings"]).map(&:to_s)
+        groups_map    = saved["groups"].kind_of?(Hash) ? saved["groups"].transform_keys(&:to_s).transform_values { |v| Array(v).map(&:to_sym) } : {}
+        section_map   = {}
+        main_keys.each     { |k| section_map[k] = NAV_SECTION_MAIN }
+        settings_keys.each { |k| section_map[k] = NAV_SECTION_BOTTOM }
+        pos_map = {}
+        (main_keys + settings_keys).each_with_index { |k, i| pos_map[k] = i }
+
+        # Every registered key the user has placed in some group via the order
+        # UI. Lets us tell "user removed this child" (it lives elsewhere now)
+        # from "this is a brand-new declared child the user hasn't seen yet".
+        registered_keys          = list.map { |i| i[:key].to_sym }.to_set
+        keys_dragged_into_groups = groups_map.values.flatten.map(&:to_sym).to_set & registered_keys
+
+        return list.map do |item|
+          new_item = item.dup
+          if (override = section_map[item[:key].to_s])
+            new_item[:section] = override
+          end
+          # Group children = saved order + any never-placed-yet declared children appended.
+          # A key dragged elsewhere by the user stays out of its old group; a key never
+          # referenced by saved.groups (e.g. just added to config) falls back to its
+          # registered group so new defaults still appear.
+          if item[:type].to_s == "group"
+            saved_children = Array(groups_map[item[:key].to_s])
+            existing       = Array(item[:children]).map(&:to_sym)
+            valid_saved    = saved_children.select { |k| registered_keys.include?(k) }
+            fresh_existing = existing - keys_dragged_into_groups.to_a
+            reordered      = valid_saved + (fresh_existing - valid_saved)
+            new_item[:children] = reordered
+          end
+          new_item
+        end.sort_by do |item|
+          [
+            nav_section_priority(item[:section].to_s),
+            pos_map.fetch(item[:key].to_s, 9999),
+            item[:order] || 1000,
+            item[:label].to_s
+          ]
+        end
+      end
+
+      # Legacy flat array form
+      return list unless saved.kind_of?(Array) && saved.any?
+
+      order_map = saved.each_with_index.to_h { |k, i| [ k.to_s, i ] }
+      list.sort_by { |item| order_map.fetch(item[:key].to_s, 9999) }
+    rescue StandardError
+      list
+    end
+
+    def nav_entry_visible?(item, view_context:, user:)
+      return false unless setting_enabled_for_nav_item?(item)
+      return false unless permission_allows_nav_item?(item, view_context:, user:)
+      return false unless condition_allows_nav_item?(item, view_context:)
+
+      true
+    end
+
+    def setting_enabled_for_nav_item?(item)
+      pref_key = :"nav_show_#{item[:key]}"
+      RubyCms::Settings.get(pref_key, default: item.fetch(:default_visible, true))
+    rescue StandardError
+      item.fetch(:default_visible, true)
+    end
+
+    def permission_allows_nav_item?(item, view_context:, user:)
+      permission_key = item[:permission]
+      return true if permission_key.blank?
+
+      current_user = user || user_from_view_context(view_context)
+      return false if current_user.nil?
+      return true unless current_user.respond_to?(:can?)
+
+      current_user.can?(permission_key.to_sym)
+    rescue StandardError
+      false
+    end
+
+    def condition_allows_nav_item?(item, view_context:)
+      condition = item[:if]
+      return true unless condition.respond_to?(:call)
+
+      condition.arity == 1 ? condition.call(view_context) : condition.call
+    rescue StandardError
+      false
+    end
+
+    def user_from_view_context(view_context)
+      return nil unless view_context
+      return view_context.current_user_cms if view_context.respond_to?(:current_user_cms)
+      return view_context.current_user if view_context.respond_to?(:current_user)
+
+      nil
+    end
+
+    def register_navigation_setting!(entry)
+      RubyCms::SettingsRegistry.register(
+        key: :"nav_show_#{entry[:key]}",
+        type: :boolean,
+        default: entry.fetch(:default_visible, true),
+        category: :navigation,
+        description: "Show #{entry[:label]} in navigation"
+      )
+    rescue StandardError => e
+      Rails.logger.warn("[RubyCMS] Failed to register nav setting for #{entry[:key]}: #{e.message}") if defined?(Rails.logger)
+    end
+  end
+end
+
+RubyCms::SettingsRegistry.seed_defaults!

data/lib/{tasks → generators/ruby_cms/templates/lib/tasks}/admin.rake

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-namespace :admin do # rubocop:disable Metrics/BlockLength
+namespace :admin do
   def ruby_cms_user_class
     Object.const_get(Rails.application.config.ruby_cms.user_class_name.presence ||
                         "User")
@@ -27,9 +27,9 @@ namespace :admin do # rubocop:disable Metrics/BlockLength
   end
 
   def ruby_cms_grant_all_permissions_to!(user, email:)
-    RubyCms::Permission.ensure_defaults!
-    RubyCms::UserPermission.where(user:).destroy_all
-    RubyCms::Engine.grant_manage_admin_permission(user, email)
+    Permission.ensure_defaults!
+    UserPermission.where(user:).destroy_all
+    RubyCmsTasks.grant_manage_admin_permission(user, email)
   end
 
   desc "Make a user a full admin with all permissions (no templates). Usage: rails admin:make_admin email=user@example.com"
@@ -43,14 +43,14 @@ namespace :admin do # rubocop:disable Metrics/BlockLength
     ruby_cms_make_user_full_admin!(user)
     ruby_cms_grant_all_permissions_to!(user, email:)
 
-    keys = RubyCms::UserPermission.where(user:)
-                                  .joins(:permission)
-                                  .pluck("permissions.key")
-                                  .sort
-                                  .uniq
+    keys = UserPermission.where(user:)
+                         .joins(:permission)
+                         .pluck("permissions.key")
+                         .sort
+                         .uniq
 
     puts "#{email} is now admin with #{keys.size} permission(s):"
-    keys.each {|k| puts "  - #{k}" }
+    keys.each { |k| puts "  - #{k}" }
   end
 
   desc "List all users with their admin status and permission keys"
@@ -66,10 +66,10 @@ namespace :admin do # rubocop:disable Metrics/BlockLength
     end
 
     users.each do |user|
-      keys = RubyCms::UserPermission.where(user:)
-                                    .joins(:permission)
-                                    .pluck("permissions.key")
-                                    .sort
+      keys = UserPermission.where(user:)
+                           .joins(:permission)
+                           .pluck("permissions.key")
+                           .sort
 
       admin_flag = user.respond_to?(:admin?) ? user.admin? : false
 
@@ -79,11 +79,11 @@ namespace :admin do # rubocop:disable Metrics/BlockLength
 
   desc "Seed all permission keys into the database (no templates)."
   task seed_permissions: :environment do
-    RubyCms::Permission.ensure_defaults!
+    Permission.ensure_defaults!
     RubyCms::Settings.ensure_defaults! if defined?(RubyCms::Settings)
     RubyCms::Settings.import_initializer_values! if defined?(RubyCms::Settings)
 
-    puts "Permissions: #{RubyCms::Permission.pluck(:key).sort.join(', ')}"
+    puts "Permissions: #{Permission.pluck(:key).sort.join(', ')}"
   end
 
   desc "Delete admin user. Usage: rails admin:delete email=user@example.com"