ruby_cms 0.1.0

data/app/controllers/ruby_cms/admin/visual_editor_controller.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    class VisualEditorController < BaseController
+      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?
+      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
+
+        load_preview_data(@page_key)
+        render template: template, layout: "ruby_cms/minimal"
+      end
+
+      def quick_update
+        block = find_or_initialize_content_block
+        update_content_block_attributes(block)
+        assign_content_block_content(block)
+
+        if block.save
+          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?
+          block.rich_content = params[:rich_content]
+        elsif params[:content].present?
+          block.content = params[: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)
+        block.content_type == "rich_text" ? block.rich_content.to_plain_text : block.content
+      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?
+        pages
+      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) || relative_path.start_with?("admin")
+      end
+
+      def depth_exceeded?(relative_path)
+        relative_path.split("/").length > 2
+      end
+
+      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$/, "")
+        if base_name.start_with?("_") || relative_path == "layouts" ||
+           relative_path.start_with?("admin")
+          return
+        end
+
+        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
+          [base_name, "#{relative_path}/#{base_name}"]
+        end
+      end
+
+      def load_preview_data(page_key)
+        @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)
+        return unless data.kind_of?(Hash)
+
+        data.each do |k, v|
+          instance_variable_set(:"@#{k}", v)
+        end
+      end
+    end
+  end
+end

data/app/controllers/ruby_cms/errors_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyCms
+  # Handles 404 errors from catch-all routes.
+  # Add this to the BOTTOM of your routes.rb to capture routing errors:
+  #
+  #   match "*path", to: "ruby_cms/errors#not_found", via: :all,
+  #         constraints: ->(req) { !req.path.start_with?("/rails/") }
+  #
+  class ErrorsController < ApplicationController
+    def not_found
+      # Log the routing error to VisitorError (skips in development)
+      RubyCms::VisitorError.log_routing_error(request)
+
+      respond_to do |format|
+        format.html do
+          render_html_not_found
+        end
+        format.json { render json: { error: "Not found" }, status: :not_found }
+        format.any { head :not_found }
+      end
+    end
+
+    private
+
+    def render_html_not_found
+      static_not_found = Rails.public_path.join("404.html")
+      if static_not_found.exist?
+        render file: static_not_found, status: :not_found, layout: false
+      else
+        render :not_found, status: :not_found, layout: false
+      end
+    end
+  end
+end

data/app/helpers/ruby_cms/admin/admin_page_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module AdminPageHelper
+      def admin_page(title: nil, subtitle: nil, footer: nil, **, &)
+        render RubyCms::Admin::AdminPage.new(
+          title:,
+          subtitle:,
+          footer:,
+          **,
+          &
+        )
+      end
+
+      def admin_table_content(id: "admin_table_content", **attrs, &)
+        render RubyCms::Admin::AdminPage::AdminTableContent.new(id:, **attrs, &)
+      end
+    end
+  end
+end

data/app/helpers/ruby_cms/admin/bulk_action_table_helper.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module BulkActionTableHelper
+      # Render a complete bulk action table using Phlex components
+      #
+      # @param collection [ActiveRecord::Relation] The collection to display
+      # @param headers [Array<String, Hash>] Array of header labels or hashes with :text and :class
+      # @param turbo_frame [String, nil] Turbo Frame ID for seamless updates
+      # @param pagination [Hash, nil] Pagination hash from AdminPagination concern
+      # @param pagination_path [Proc, nil] Lambda for generating pagination URLs
+      # @param bulk_actions_url [String, nil] URL for bulk delete action
+      # @param bulk_action_buttons [Array<Hash>] Array of custom bulk action button configs
+      # @param item_name [String] Singular name for items (default: "item")
+      # @param controller_name [String] Stimulus controller identifier
+      # @param block [Proc] Block that renders table rows
+      # @return [String] Rendered HTML
+      #
+      # @example Basic usage
+      #   <%= render_bulk_action_table(
+      #     collection: @items,
+      #     headers: ["Name", "Status", { text: "Actions", class: "text-right" }],
+      #     bulk_actions_url: bulk_delete_items_path,
+      #     item_name: "item"
+      #   ) do %>
+      #     <% @items.each do |item| %>
+      #       <%= render RubyCms::Admin::BulkActionTable::BulkActionTableRow.new(
+      #         data: { item_id: item.id }
+      #       ) do %>
+      #         <td><%= item.name %></td>
+      #         <td><%= item.status %></td>
+      #         <td class="text-right">
+      #           <%= render RubyCms::Admin::BulkActionTable::BulkActionTableActions.new(
+      #             edit_path: edit_item_path(item),
+      #             delete_path: item_path(item),
+      #             item_id: item.id
+      #           ) %>
+      #         </td>
+      #       <% end %>
+      #     <% end %>
+      #   <% end %>
+      def render_bulk_action_table(
+        headers:,
+        turbo_frame: "admin_table_content",
+        pagination: nil,
+        pagination_path: nil,
+        bulk_actions_url: nil,
+        bulk_action_buttons: [],
+        item_name: "item",
+        controller_name: "ruby-cms--bulk-action-table",
+        &block
+      )
+        render RubyCms::Admin::BulkActionTable::BulkActionTable.new(
+          turbo_frame: turbo_frame,
+          pagination: pagination,
+          pagination_path: pagination_path,
+          bulk_actions_url: bulk_actions_url,
+          bulk_actions_buttons: bulk_action_buttons,
+          item_name: item_name,
+          controller_name: controller_name,
+          csrf_token: form_authenticity_token
+        ) do
+          render RubyCms::Admin::BulkActionTable::BulkActionTableHeader.new(
+            headers: headers,
+            bulk_actions_enabled: bulk_actions_url.present? || bulk_action_buttons.any?,
+            controller_name: controller_name
+          )
+
+          render RubyCms::Admin::BulkActionTable::BulkActionTableBody.new(&block)
+        end
+      end
+
+      # Render an admin page with consistent layout
+      #
+      # @param title [String] Page title
+      # @param subtitle [String, nil] Optional subtitle
+      # @param actions [Array<Hash>, nil] Array of action button configs
+      # @param breadcrumbs [Array<Hash>, nil] Array of breadcrumb items
+      # @param padding [Boolean] Add padding classes (default: true)
+      # @param overflow [Boolean] Allow overflow (default: true)
+      # @param turbo_frame [String, nil] Turbo Frame ID for wrapping
+      # @param turbo_frame_options [Hash, nil] Custom Turbo Frame options
+      # @param block [Proc] Block that renders page content
+      # @return [String] Rendered HTML
+      #
+      # @example
+      #   <%= render_admin_page(
+      #     title: "Content Blocks",
+      #     actions: [
+      #       { label: "New Block", url: new_content_block_path, primary: true }
+      #     ],
+      #     turbo_frame: "admin_table_content"
+      #   ) do %>
+      #     <div class="ruby_cms-card">
+      #       <!-- Content here -->
+      #     </div>
+      #   <% end %>
+      def render_admin_page(
+        title:,
+        subtitle: nil,
+        actions: nil,
+        breadcrumbs: nil,
+        padding: true,
+        overflow: true,
+        turbo_frame: nil,
+        turbo_frame_options: nil
+      )
+        render RubyCms::Admin::AdminPage.new(
+          title:,
+          subtitle:,
+          actions:,
+          breadcrumbs:,
+          padding:,
+          overflow:,
+          turbo_frame:,
+          turbo_frame_options:
+        ) do
+          yield if block_given?
+        end
+      end
+
+      # Build bulk action button configuration hash
+      #
+      # @param name [String] Action name (used internally)
+      # @param label [String] Button label text
+      # @param url [String] Action URL
+      # @param confirm [String, nil] Confirmation message
+      # @param action_type [String] "redirect" for redirect actions, nil for dialog actions
+      # @param class [String, nil] Additional CSS classes
+      # @return [Hash] Button configuration hash
+      #
+      # @example
+      #   bulk_action_button(
+      #     name: "publish",
+      #     label: "Publish Selected",
+      #     url: bulk_publish_path,
+      #     confirm: "Are you sure?"
+      #   )
+      def bulk_action_button(
+        name:,
+        label:,
+        url:,
+        confirm: nil,
+        action_type: nil,
+        class: nil
+      )
+        {
+          name: name,
+          label: label,
+          url: url,
+          confirm: confirm,
+          action_type: action_type,
+          class: binding.local_variable_get(:class)
+        }.compact
+      end
+    end
+  end
+end

data/app/helpers/ruby_cms/application_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module ApplicationHelper
+    include RubyCms::Engine.routes.url_helpers if defined?(RubyCms::Engine)
+
+    def ruby_cms_locale_display_name(locale)
+      key = "ruby_cms.admin.locales.#{locale}"
+      t(key, default: locale.to_s)
+    end
+
+    def ruby_cms_user_display(user)
+      return "—" if user.blank?
+
+      %i[email_address email username name].each do |attr|
+        return user.public_send(attr) if user.respond_to?(attr) && user.public_send(attr).present?
+      end
+      user.respond_to?(:id) ? "User ##{user.id}" : user.to_s
+    end
+
+    def ruby_cms_nav_entries
+      RubyCms.visible_nav_registry(
+        view_context: self,
+        user: (current_user_cms if respond_to?(:current_user_cms))
+      )
+    end
+
+    # Render an SVG fragment (typically <path ...>) safely.
+    # Used for nav icons which may come from host app configuration.
+    def ruby_cms_safe_svg_fragment(fragment)
+      sanitize(
+        fragment.to_s,
+        tags: %w[svg path g circle rect line polygon polyline ellipse],
+        attributes: %w[
+          fill stroke stroke-linecap stroke-linejoin stroke-width d
+          class viewBox cx cy r x y points x1 y1 x2 y2 aria-hidden aria-label focusable
+        ]
+      )
+    end
+  end
+end