ruby_cms 0.2.1.0 → 1.0.0

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

@@ -1,345 +0,0 @@
-# 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: "admin/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?
-          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
-
-      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

@@ -1,35 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,159 +0,0 @@
-# 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/admin/dashboard_helper.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module Admin
-    module DashboardHelper
-      # Renders a dashboard block from the registry (+ :locals from the controller).
-      def render_dashboard_block(block)
-        locals = block[:locals]
-        locals = {} if locals.nil?
-        if block[:partial].present?
-          render partial: block[:partial], locals: locals
-        elsif block[:render].respond_to?(:call)
-          block[:render].call(self, locals)
-        else
-          ""
-        end
-      end
-    end
-  end
-end

data/app/helpers/ruby_cms/application_helper.rb

@@ -1,41 +0,0 @@
-# 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