ruby_cms 0.2.1.1 → 1.0.0

data/lib/generators/ruby_cms/templates/controllers/admin/visual_editor_controller.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+module Admin
+  class VisualEditorController < Admin::ApplicationController
+    include AuditLoggable
+
+    before_action { require_permission!(:manage_content_blocks) }
+    before_action :apply_visual_editor_locale
+
+    def index
+      @available_pages = available_pages
+      @current_page = determine_current_page
+      @edit_mode = edit_mode_enabled?
+      @all_page_variants = load_all_page_variants
+      @current_variant = determine_current_variant(@all_page_variants[@current_page.to_s] || [])
+    end
+
+    def page_preview
+      @page_key = params[:page] || "home"
+      @page = @page_key
+      @edit_mode = edit_mode_enabled?
+      @content_blocks = load_content_blocks_for_locale
+      template = template_for_page(@page_key)
+
+      return render_invalid_page unless template
+
+      @current_variant = params[:variant].presence
+      load_preview_data(@page_key, @current_variant)
+      render template: template, layout: "admin/minimal"
+    end
+
+    def quick_update
+      block = find_or_initialize_content_block
+      was_new = block.new_record?
+      update_content_block_attributes(block)
+      assign_content_block_content(block)
+
+      if block.save
+        audit!(
+          was_new ? :content_block_created : :content_block_updated,
+          target: block,
+          summary: "#{was_new ? 'Created' : 'Updated'} #{block.key} via visual editor",
+          meta: { key: block.key, locale: block.locale, source: "visual_editor" }
+        )
+        render json: success_response(block)
+      else
+        render json: error_response(block), status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def apply_visual_editor_locale
+      requested = params[:locale].presence
+      return if requested.blank?
+
+      locale = requested.to_s
+      return unless available_locales.include?(locale)
+
+      session[:ruby_cms_locale] = locale
+      I18n.locale = locale.to_sym
+    end
+
+    def available_locales
+      I18n.available_locales.map(&:to_s)
+    rescue StandardError
+      [ I18n.default_locale.to_s ]
+    end
+
+    def determine_current_page
+      requested = params[:page].presence
+      return requested if requested && @available_pages.key?(requested)
+      return @available_pages.keys.first if @available_pages.any?
+
+      "home"
+    end
+
+    def edit_mode_enabled?
+      params[:edit_mode].nil? || params[:edit_mode] == "true"
+    end
+
+    def template_for_page(page_key)
+      template_from_config(page_key) || template_from_auto_detect(page_key)
+    end
+
+    def template_from_config(page_key)
+      load_config_templates[page_key]
+    end
+
+    def template_from_auto_detect(page_key)
+      auto_detect_templates[page_key]
+    end
+
+    def load_config_templates
+      Rails.application.config.ruby_cms.preview_templates
+    rescue StandardError
+      {}
+    end
+
+    def render_invalid_page
+      all_templates = load_config_templates.merge(auto_detect_templates)
+      available_keys = all_templates.keys.join(", ")
+      message = if available_keys.present?
+                  "Invalid page: #{@page_key}. Available pages: #{available_keys}"
+      else
+                  "Invalid page: #{@page_key}. No pages found in app/views. " \
+                    "Create a template like app/views/pages/home.html.erb or " \
+                    "configure manually in config/initializers/ruby_cms.rb"
+      end
+      render plain: message, status: :bad_request
+    end
+
+    def load_content_blocks_for_locale
+      blocks = ::ContentBlock.all
+      blocks_by_locale = blocks.group_by(&:locale)
+      locale_blocks = blocks_by_locale[current_locale] || []
+      default_blocks = default_locale_blocks(blocks_by_locale)
+
+      content_blocks = {}
+      default_blocks&.each { |b| content_blocks[b.key] = b }
+      locale_blocks.each { |b| content_blocks[b.key] = b }
+      content_blocks
+    end
+
+    def default_locale_blocks(blocks_by_locale)
+      return nil if current_locale == default_locale
+
+      blocks_by_locale[default_locale] || []
+    end
+
+    def find_or_initialize_content_block
+      key = params[:key]
+      locale = content_block_locale
+      ::ContentBlock.find_or_initialize_by(key: key, locale: locale.to_s)
+    end
+
+    def content_block_locale
+      params[:locale].presence || session[:ruby_cms_locale].presence || I18n.locale.to_s
+    end
+
+    def update_content_block_attributes(block)
+      block.content_type = params[:content_type]
+      block.updated_by = current_user_cms
+      block.published = true
+    end
+
+    def assign_content_block_content(block)
+      if rich_text_content?
+        assign_rich_text_content(block)
+      elsif params[:content].present?
+        block.content = params[:content]
+      end
+    end
+
+    def assign_rich_text_content(block)
+      rich_content = params[:rich_content].to_s
+
+      if block.respond_to?(:rich_content=)
+        block.rich_content = rich_content
+      else
+        block.content = ActionController::Base.helpers.strip_tags(rich_content)
+      end
+    end
+
+    def rich_text_content?
+      params[:content_type] == "rich_text" && params[:rich_content].present?
+    end
+
+    def success_response(block)
+      {
+        success: true,
+        message: "Content updated successfully",
+        content: content_block_content_text(block),
+        rich_content_html: rich_content_html(block),
+        content_type: block.content_type,
+        locale: block.locale,
+        updated_at: formatted_updated_at(block)
+      }
+    end
+
+    def content_block_content_text(block)
+      return block.content unless block.content_type == "rich_text"
+      return block.content unless block.respond_to?(:rich_content)
+      return block.content unless block.rich_content.respond_to?(:to_plain_text)
+
+      block.rich_content.to_plain_text
+    end
+
+    # Return body HTML only (no layout/comments) so preview and Trix get clean HTML.
+    def rich_content_html(block)
+      return nil unless block.content_type == "rich_text"
+      return nil unless block.respond_to?(:rich_content)
+      return nil unless block.rich_content.respond_to?(:body) && block.rich_content.body.present?
+
+      body = block.rich_content.body
+      body.respond_to?(:to_html) ? body.to_html : body.to_s
+    end
+
+    def formatted_updated_at(block)
+      block.updated_at.strftime("%B %d, %Y at %I:%M %p")
+    end
+
+    def error_response(block)
+      {
+        success: false,
+        message: block.errors.full_messages.join(", ")
+      }
+    end
+
+    def available_pages
+      pages = {}
+      add_config_pages(pages)
+      add_auto_detected_pages(pages) if pages.empty?
+      prioritize_home_page(pages)
+    end
+
+    def prioritize_home_page(pages)
+      return pages unless pages.key?("home")
+
+      { "home" => pages["home"] }.merge(pages.except("home"))
+    end
+
+    def add_auto_detected_pages(pages)
+      auto_detect_templates.each do |key, template_path|
+        next if pages.key?(key)
+
+        pages[key] = build_page_hash(key, template_path)
+      end
+    end
+
+    def add_config_pages(pages)
+      config_pages.each do |key, template_path|
+        pages[key] ||= build_page_hash(key, template_path)
+      end
+    end
+
+    def build_page_hash(key, template_path)
+      {
+        name: key.humanize,
+        url: page_url_for(key),
+        key_prefix: "#{key}_",
+        template_path: template_path
+      }
+    end
+
+    def config_pages
+      Rails.application.config.ruby_cms.preview_templates
+    rescue StandardError
+      {}
+    end
+
+    def page_url_for(key)
+      public_page_path(key:)
+    rescue NoMethodError, ActionController::UrlGenerationError
+      "/p/#{key}"
+    end
+
+    def current_locale
+      (params[:locale] || session[:ruby_cms_locale] || I18n.locale.to_s).to_s
+    end
+
+    def default_locale
+      I18n.default_locale.to_s
+    rescue StandardError
+      "en"
+    end
+
+    def auto_detect_templates
+      @auto_detect_templates ||= detect_templates_at_runtime
+    end
+
+    def detect_templates_at_runtime
+      views_dir = Rails.root.join("app/views")
+      return {} unless Dir.exist?(views_dir)
+
+      templates = {}
+      scan_views_for_templates(views_dir, templates)
+      templates
+    rescue StandardError
+      {}
+    end
+
+    def scan_views_for_templates(dir_path, templates, relative_path = "")
+      Dir.glob(File.join(dir_path, "*")).each do |path|
+        if File.directory?(path)
+          scan_subdirectory(path, templates, relative_path)
+        else
+          process_template_file(path, templates, relative_path)
+        end
+      end
+    end
+
+    def scan_subdirectory(path, templates, relative_path)
+      dir_name = File.basename(path)
+      return if skip_directory?(dir_name, relative_path)
+
+      new_relative_path = relative_path.empty? ? dir_name : "#{relative_path}/#{dir_name}"
+      return if depth_exceeded?(new_relative_path)
+
+      scan_views_for_templates(path, templates, new_relative_path)
+    end
+
+    def skip_directory?(dir_name, relative_path)
+      %w[
+        layouts shared mailers components
+        admin
+      ].include?(dir_name) ||
+        dir_name.end_with?("_mailer") ||
+        dir_name.end_with?("_mailers") ||
+        relative_path.start_with?("admin")
+    end
+
+    def depth_exceeded?(relative_path)
+      relative_path.split("/").length > 2
+    end
+
+    CRUD_TEMPLATE_NAMES = %w[edit new].freeze
+
+    def process_template_file(file_path, templates, relative_path)
+      return unless file_path.match?(/\.(html\.erb|html\.haml|html\.slim)$/)
+
+      base_name = File.basename(file_path, ".*").sub(/\.html$/, "")
+      return if base_name.start_with?("_")
+      return if relative_path == "layouts" || relative_path.start_with?("admin")
+      return if CRUD_TEMPLATE_NAMES.include?(base_name)
+
+      page_key, template_path = build_page_key_and_template_path(base_name, relative_path)
+      templates[page_key] ||= template_path
+    end
+
+    def build_page_key_and_template_path(base_name, relative_path)
+      if relative_path.empty?
+        [ base_name, base_name ]
+      elsif base_name == "index"
+        key = relative_path.split("/").last
+        [ key, "#{relative_path}/index" ]
+      else
+        parent = relative_path.split("/").last
+        [ "#{parent}_#{base_name}", "#{relative_path}/#{base_name}" ]
+      end
+    end
+
+    def load_all_page_variants
+      @available_pages.each_with_object({}) do |(key, _), hash|
+        variants = load_variants(key.to_s)
+        hash[key.to_s] = variants if variants.any?
+      end
+    rescue StandardError
+      {}
+    end
+
+    def load_variants(page_key)
+      variants_proc = Rails.application.config.ruby_cms.preview_variants
+      return [] unless variants_proc.respond_to?(:call)
+
+      Array(variants_proc.call(page_key))
+    rescue StandardError
+      []
+    end
+
+    def determine_current_variant(variants)
+      requested = params[:variant].presence
+      return requested if requested && variants.any? { |v| v[:value].to_s == requested }
+
+      variants.first&.fetch(:value, nil)
+    end
+
+    def load_preview_data(page_key, variant = nil)
+      @page_title = page_key.humanize
+
+      data_proc = Rails.application.config.ruby_cms.preview_data
+      return unless data_proc.respond_to?(:call)
+
+      data = data_proc.call(page_key, view_context, variant)
+      return unless data.kind_of?(Hash)
+
+      data.each do |k, v|
+        instance_variable_set(:"@#{k}", v)
+      end
+    rescue StandardError => e
+      Rails.logger.warn("[RubyCMS] preview_data failed for #{page_key}: #{e.message}")
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/concerns/admin_bulk_actions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Shared helpers for bulk admin actions.
+#
+# Replaces 7-line repeated blocks like:
+#   ids = Array(params[:item_ids]).filter_map(&:to_i)
+#   count = Model.where(id: ids).destroy_all.size
+#   audit!(:thing_deleted, target: "Thing (bulk)", summary: "Deleted #{count}")
+#   redirect_to ...
+#
+# Usage:
+#   include AdminBulkActions
+#
+#   def bulk_delete
+#     count = bulk_destroy(Redirect, audit: :redirect_deleted, target_label: "Redirect")
+#     redirect_to admin_redirects_path, notice: "#{count} verwijderd"
+#   end
+module AdminBulkActions
+  extend ActiveSupport::Concern
+
+  private
+
+  # Pulls ids from either :item_ids or :ids (we have both conventions).
+  def bulk_ids
+    Array(params[:item_ids].presence || params[:ids]).filter_map(&:to_i)
+  end
+
+  # Destroys + audits. Returns count.
+  def bulk_destroy(model, audit: nil, target_label: nil, soft: false, audit_action: nil)
+    ids = bulk_ids
+    scope = model.where(id: ids)
+    count = if soft && model.include?(Discard::Model)
+              scope.find_each(&:discard)
+              ids.size
+    else
+              scope.destroy_all.size
+    end
+    if (action = audit_action || audit) && respond_to?(:audit!, true)
+      audit!(action,
+             target: "#{target_label || model.name} (bulk)",
+             summary: "#{soft ? 'Discarded' : 'Deleted'} #{count} #{(target_label || model.name).downcase}(s)",
+             meta: { count:, ids: })
+    end
+    count
+  end
+
+  # Updates a column on selected rows + audits. Returns count.
+  def bulk_update(model, attrs, audit: nil, target_label: nil)
+    ids = bulk_ids
+    count = model.where(id: ids).update_all(attrs)
+    if audit && respond_to?(:audit!, true)
+      audit!(audit,
+             target: "#{target_label || model.name} (bulk)",
+             summary: "Updated #{count} #{(target_label || model.name).downcase}(s): #{attrs.inspect}",
+             meta: { count: count, ids: ids, changes: attrs })
+    end
+    count
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/concerns/admin_pagination.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Unified pagination concern for all admin index pages.
+module AdminPagination
+  extend ActiveSupport::Concern
+
+  DEFAULT_MIN_PER_PAGE = 5
+  DEFAULT_MAX_PER_PAGE = 200
+
+  included do
+    class_attribute :pagination_per_page, default: 50
+    class_attribute :pagination_turbo_frame, default: nil
+    class_attribute :pagination_min_per_page, default: DEFAULT_MIN_PER_PAGE
+    class_attribute :pagination_max_per_page, default: DEFAULT_MAX_PER_PAGE
+  end
+
+  def set_pagination_vars(collection, per_page: nil, turbo_frame: nil)
+    per_page = calculate_per_page(per_page)
+    turbo_frame ||= self.class.pagination_turbo_frame
+
+    page = sanitize_page_param(params[:page])
+    paginated, total_count, total_pages, offset = paginate_collection_internal(collection, page,
+                                                                               per_page)
+
+    @pagination = build_pagination_hash(page, per_page, total_count, total_pages, offset)
+    @pagination_path = build_pagination_path_lambda
+    @turbo_frame = turbo_frame
+
+    paginated
+  end
+
+  def paginate_collection(collection, per_page: nil, turbo_frame: nil)
+    set_pagination_vars(collection, per_page:, turbo_frame:)
+  end
+
+  module ClassMethods
+    def paginates(per_page: 50, turbo_frame: nil, min_per_page: nil, max_per_page: nil)
+      self.pagination_per_page = per_page
+      self.pagination_turbo_frame = turbo_frame
+      self.pagination_min_per_page = min_per_page if min_per_page.present?
+      self.pagination_max_per_page = max_per_page if max_per_page.present?
+    end
+
+    # Sugar: `paginates_with_pref :visitor_errors, default: 25`
+    # Reads Preference("visitor_errors_per_page") at request time.
+    def paginates_with_pref(key, default: 25, turbo_frame: "admin_table_content")
+      paginates(per_page: -> { Preference.get(:"#{key}_per_page", default:) }, turbo_frame: turbo_frame)
+    end
+  end
+
+  private
+
+  def calculate_per_page(per_page = nil)
+    per_page ||= self.class.pagination_per_page
+    per_page = per_page.call if per_page.respond_to?(:call)
+
+    min = RubyCms::Settings.get(:pagination_min_per_page,
+                                default: self.class.pagination_min_per_page).to_i
+    max = RubyCms::Settings.get(:pagination_max_per_page,
+                                default: self.class.pagination_max_per_page).to_i
+    max = [ max, min ].max
+
+    per_page.to_i.clamp(min, max)
+  end
+
+  def sanitize_page_param(page_param)
+    page = (page_param || params[:page]).to_i
+    [ page, 1 ].max
+  end
+
+  def paginate_collection_internal(collection, page, per_page)
+    count = collection.kind_of?(Array) ? collection.size : collection.count
+    pagy = Pagy::Offset.new(count: count, page: page, limit: per_page)
+    paginated =
+      if collection.kind_of?(Array)
+        collection[pagy.offset, pagy.limit] || []
+      else
+        collection.offset(pagy.offset).limit(pagy.limit)
+      end
+    [ paginated, pagy.count, pagy.pages, pagy.offset ]
+  end
+
+  def build_pagination_hash(page, per_page, total_count, total_pages, offset)
+    {
+      current_page: page,
+      total_pages: total_pages,
+      total_count: total_count,
+      per_page: per_page,
+      has_next: page < total_pages,
+      has_previous: page > 1,
+      next_page: page < total_pages ? page + 1 : nil,
+      previous_page: page > 1 ? page - 1 : nil,
+      start_item: total_count.positive? ? offset + 1 : 0,
+      end_item: [ offset + per_page, total_count ].min
+    }
+  end
+
+  def build_pagination_path_lambda
+    lambda do |page_num|
+      query_params = request.query_parameters.except(:page).merge(page: page_num)
+      base_path = request.path
+      query_string = query_params.to_query
+      query_string.present? ? "#{base_path}?#{query_string}" : base_path
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/concerns/admin_turbo_table.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AdminTurboTable
+  extend ActiveSupport::Concern
+
+  def turbo_frame_request?
+    request.headers["Turbo-Frame"].present?
+  end
+
+  def turbo_render_index(turbo_frame_id: "admin_table_content")
+    if turbo_frame_request?
+      render partial: turbo_frame_id, layout: false
+    else
+      render :index
+    end
+  end
+
+  # Re-render a form template after a validation failure. Returns 422 so Turbo
+  # replaces the frame/page with the re-rendered form (and its error messages)
+  # instead of treating the response as a successful navigation.
+  def turbo_render_form(template, status: :unprocessable_entity)
+    render template, status: status
+  end
+
+  def turbo_redirect_to(url, **)
+    redirect_to(url, **) unless turbo_frame_request?
+  end
+
+  def turbo_frame_id
+    request.headers["Turbo-Frame"]
+  end
+
+  def turbo_stream_request?
+    request.headers["Accept"]&.include?("text/vnd.turbo-stream.html")
+  end
+
+  def turbo_stream_update_table(turbo_frame_id: "admin_table_content", partial: nil)
+    partial ||= turbo_frame_id
+    render turbo_stream: turbo_stream.update(turbo_frame_id, partial:)
+  end
+
+  def turbo_stream_replace_table(turbo_frame_id: "admin_table_content", partial: nil)
+    partial ||= turbo_frame_id
+    render turbo_stream: turbo_stream.replace(turbo_frame_id, partial:)
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/concerns/audit_loggable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Include in any admin controller to expose `audit!` for one-line logging.
+#
+#   audit!(:content_block_updated, target: @block, summary: "Updated #{@block.key}")
+module AuditLoggable
+  extend ActiveSupport::Concern
+
+  private
+
+  def audit!(action, target: nil, summary: nil, meta: {})
+    AuditLog.record(
+      action: action,
+      actor: audit_actor,
+      target: target,
+      summary: summary,
+      request: request,
+      meta: meta
+    )
+  end
+
+  def audit_actor
+    return current_user_cms if respond_to?(:current_user_cms, true) && current_user_cms
+    return current_user if respond_to?(:current_user, true) && current_user
+
+    nil
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/concerns/authentication.rb

@@ -0,0 +1,63 @@
+module Authentication
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :require_authentication
+    helper_method :authenticated?, :current_user
+  end
+
+  class_methods do
+    def allow_unauthenticated_access(**options)
+      skip_before_action :require_authentication, **options
+    end
+  end
+
+  private
+
+  def current_user
+    Current.user
+  end
+
+  def authenticated?
+    resume_session
+  end
+
+  def require_authentication
+    resume_session || request_authentication
+  end
+
+  def resume_session
+    Current.session ||= find_session_by_cookie
+  end
+
+  def find_session_by_cookie
+    Session.find_by(id: cookies.signed[:session_id]) if cookies.signed[:session_id]
+  end
+
+  def request_authentication
+    # Only remember navigational GET requests. Asset/favicon/XHR/404 fetches (e.g.
+    # /icon.svg) must never become the post-login destination.
+    session[:return_to_after_authenticating] = request.url if request.get? && request.format.html?
+    redirect_to new_session_path
+  end
+
+  def after_authentication_url
+    session.delete(:return_to_after_authenticating) || admin_root_url
+  end
+
+  def start_new_session_for(user)
+    attrs = { user_agent: request.user_agent, ip_address: request.remote_ip }
+    # Host apps generated before the auth concern shipped may lack this column.
+    attrs[:authenticated_at] = Time.current if user.sessions.klass.column_names.include?("authenticated_at")
+
+    user.sessions.create!(**attrs).tap do |session|
+      Current.session = session
+      cookies.signed.permanent[:session_id] = { value: session.id, httponly: true, same_site: :lax }
+    end
+  end
+
+  def terminate_session
+    Current.session.destroy
+    cookies.delete(:session_id)
+  end
+end