ruby_cms 0.2.1.1 → 1.0.1

data/app/helpers/ruby_cms/bulk_action_table_helper.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module BulkActionTableHelper
-    # Render the bulk action table delete dialog
-    # @param controller_name [String] The Stimulus controller name
-    # @return [String] Rendered HTML for the delete dialog
-    def render_bulk_action_table_delete_dialog(controller_name: "ruby-cms--bulk-action-table")
-      render partial: "ruby_cms/admin/shared/bulk_action_table_delete_dialog",
-             locals: { controller_name: }
-    end
-
-    # Render bulk actions bar
-    # @param controller_name [String]
-    # @param item_name [String]
-    # @param bulk_actions_url [String]
-    # @param bulk_action_buttons [Array<Hash>]
-    def render_bulk_actions_bar(
-      controller_name: "ruby-cms--bulk-action-table",
-      item_name: "item",
-      bulk_actions_url: nil,
-      bulk_action_buttons: []
-    )
-      content_tag :div,
-                  data: { "#{controller_name}_target": "bulkBar" },
-                  class: "flex-shrink-0 hidden border border-gray-200
-                    bg-white px-4 py-2 shadow-md" do
-        content_tag :div, class: "flex items-center justify-between max-w-full" do
-          render_bulk_selection_info(controller_name:, item_name:) +
-            render_bulk_action_buttons(controller_name:, bulk_action_buttons:, bulk_actions_url:)
-        end
-      end
-    end
-
-    private
-
-    def render_bulk_selection_info(controller_name:, item_name:)
-      content_tag :div, class: "flex items-center space-x-3" do
-        selected_count_span(controller_name:, item_name:) +
-          select_all_button(controller_name:) +
-          clear_selection_button
-      end
-    end
-
-    def selected_count_span(controller_name:, item_name:)
-      content_tag(:span,
-                  "0 #{item_name}(s) selected:",
-                  data: { "#{controller_name}_target": "selectedCount" },
-                  class: "text-sm font-medium text-gray-700")
-    end
-
-    def select_all_button(controller_name:)
-      content_tag(:button,
-                  "Select all",
-                  type: "button",
-                  data: {
-                    "#{controller_name}_target": "selectAllButton",
-                    action: "click->#{controller_name}#selectAll"
-                  },
-                  class: "text-sm
-                    text-gray-600
-                    hover:text-gray-900
-                    hover:underline
-                    font-medium
-                    transition-colors
-                    duration-150")
-    end
-
-    def clear_selection_button
-      content_tag(:button,
-                  "Clear selection",
-                  type: "button",
-                  data: { action: "click->ruby-cms--bulk-action-table#clearSelection" },
-                  class: "text-sm
-                    text-gray-600
-                    hover:text-gray-900
-                    hover:underline
-                    font-medium
-                    transition-colors
-                    duration-150")
-    end
-
-    def render_bulk_action_buttons(controller_name:, bulk_action_buttons:, bulk_actions_url:)
-      content_tag(:div, class: "flex items-center space-x-2") do
-        safe_join(
-          bulk_action_buttons.map {|cfg| render_bulk_action_button(cfg, controller_name) } +
-            [render_bulk_delete_button(controller_name: controller_name, url: bulk_actions_url)]
-        )
-      end
-    end
-
-    def render_bulk_action_button(button_config, controller_name)
-      label = button_label(button_config)
-      data_attrs = build_button_data_attrs(button_config, controller_name, label)
-      button_class = build_button_class(button_config)
-
-      content_tag(:button, label, type: "button", data: data_attrs, class: button_class)
-    end
-
-    def button_label(cfg)
-      cfg[:label] || cfg[:text] || cfg[:name]&.humanize || "Button"
-    end
-
-    def build_button_data_attrs(cfg, controller_name, label)
-      attrs = {
-        action: "click->#{controller_name}#showActionDialog",
-        action_name: cfg[:name] || cfg[:action_name],
-        action_url: cfg[:url]&.to_s
-      }
-      if %w[redirect].include?(cfg[:action_type]) || cfg[:action] == "redirect"
-        attrs[:action_type] =
-          "redirect"
-      end
-      if cfg[:confirm].present?
-        attrs[:action_confirm] = cfg[:confirm]
-        attrs[:action_label] = label
-      end
-      attrs
-    end
-
-    def build_button_class(cfg)
-      base = "inline-flex
-      items-center justify-center rounded-md text-sm
-      font-medium ring-offset-background transition-colors
-      focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring
-      focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50
-      border border-input bg-background hover:bg-accent hover:text-accent-foreground h-10 px-4 py-2"
-      cfg[:class].present? ? "#{base} #{cfg[:class]}" : base
-    end
-
-    def render_bulk_delete_button(controller_name:, url:)
-      content_tag(:button,
-                  "Delete Selected",
-                  type: "button",
-                  data: {
-                    action: "click->#{controller_name}#showActionDialog",
-                    action_name: "delete",
-                    action_label: "Delete Selected",
-                    action_confirm: "Are you sure you want to delete the selected items?
-                    This action cannot be undone.",
-                    action_url: url&.to_s
-                  },
-                  class: "inline-flex items-center justify-center rounded-md text-sm
-                    font-medium ring-offset-background transition-colors focus-visible:outline-none
-                    focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2
-                    disabled:pointer-events-none disabled:opacity-50 border border-input
-                    bg-background hover:bg-accent hover:text-accent-foreground h-10 px-4 py-2
-                    text-red-600 hover:text-red-700 border-red-300 hover:border-red-400")
-    end
-  end
-end

data/app/helpers/ruby_cms/content_blocks_helper.rb

@@ -1,399 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module ContentBlocksHelper
-    # Renders a content block by key. Rendering uses the block's content_type from the DB
-    # (text, rich_text, image, link, list).
-    # Usage:
-    #   content_block("hero_title")
-    #   content_block("hero_title", "Welcome")          # key + default when block missing
-    #   content_block("hero_title", default: "Welcome") # same via keyword
-    # Wraps in a span with data-content-key, data-block-id, and .content-block for editor hooks.
-    def content_block(key, default_or_nil=nil, locale: nil, fallback: nil, default: nil,
-                      translation_namespace: nil, **options)
-      # Support content_block("key", "Default") and content_block("key", default: "Default")
-      default = default_or_nil.kind_of?(Hash) ? default : (default_or_nil || default)
-      cache_opts = options.delete(:cache)
-      wrap = options.delete(:wrap)
-      wrap = true if wrap.nil?
-
-      cache_key = cache_key_for_content_block(key, cache_opts)
-
-      if cache_opts && cache_key
-        Rails.cache.fetch(cache_key) do
-          render_content_block(key, locale, default, fallback, translation_namespace, options,
-                               wrap:)
-        end
-      else
-        render_content_block(key, locale, default, fallback, translation_namespace, options, wrap:)
-      end
-    end
-
-    alias cms_content_block content_block
-
-    # Returns plain text (no HTML wrapper)
-    def content_block_text(key, locale: nil, default: nil, fallback: nil,
-                           translation_namespace: nil)
-      locale = normalize_locale(locale)
-      block = find_content_block(key, locale)
-
-      content = content_for_block_text(
-        block, default, fallback, key, translation_namespace, locale
-      )
-
-      strip_html_tags(content)
-    end
-
-    alias cms_content_block_text content_block_text
-
-    # Returns array of strings from list-type content block
-    def content_block_list_items(key, locale: nil, fallback: nil)
-      locale = normalize_locale(locale)
-      block = find_content_block(key, locale)
-      return Array(fallback) if block.blank?
-
-      raw = block.content.to_s
-      items = parse_list_items(raw)
-      items.presence || Array(fallback)
-    end
-
-    alias cms_content_block_list_items content_block_list_items
-
-    private
-
-    def normalize_locale(locale)
-      (locale || I18n.locale.to_s).to_s
-    end
-
-    def find_content_block(key, locale)
-      hash = content_blocks_from_context
-      return find_block_in_hash(hash, key, locale) if hash
-
-      ::ContentBlock.published.find_by_key_and_locale(key, locale:)
-    end
-
-    def content_blocks_from_context
-      instance_variable_get(:@content_blocks)
-    end
-
-    def find_block_in_hash(hash, key, locale)
-      hash.values.find {|b| b.key == key.to_s && b.locale == locale } ||
-        hash.values.find {|b| b.key == key.to_s }
-    end
-
-    def render_content_block(key, locale, default, fallback, translation_namespace, options,
-                             wrap: true)
-      locale = normalize_locale(locale)
-      block = find_content_block(key, locale)
-
-      if wrap
-        render_wrapped_content_block(block, key, locale, default, fallback, translation_namespace, options)
-      else
-        render_unwrapped_content_block(block, key, locale, default, fallback, translation_namespace)
-      end
-    end
-
-    def render_wrapped_content_block(block, key, locale, default, fallback, translation_namespace, options)
-      content = content_for_block(block, default, fallback, key, translation_namespace, locale)
-      wrapper_options = options.dup
-      wrapper_options[:tag] = :div if block&.content_type.to_s == "rich_text"
-      render_block_wrapper(content, key, wrapper_options)
-    end
-
-    def render_unwrapped_content_block(block, key, locale, default, fallback, translation_namespace)
-      content = content_for_block_text(block, default, fallback, key, translation_namespace, locale)
-      strip_html_tags(content)
-    end
-
-    def render_block_wrapper(content, key, options)
-      tag_name = options.delete(:tag) || :span
-      tag.public_send(tag_name, content, class: build_css_class(options),
-                                         data: build_data_attributes(key, options))
-    end
-
-    def build_css_class(options)
-      user_class = options.delete(:class)
-      return user_class.to_s if user_class.present? && !visual_editor_preview_edit_mode?
-      return user_class.to_s unless visual_editor_preview_edit_mode?
-
-      ["ruby_cms-content-block", "content-block", user_class].compact.join(" ")
-    end
-
-    def build_data_attributes(key, options)
-      user_data = options.delete(:data).to_h
-      return user_data unless visual_editor_preview_edit_mode?
-
-      { content_key: key, block_id: key.to_s }.merge(user_data)
-    end
-
-    def visual_editor_preview_edit_mode?
-      return false unless respond_to?(:controller) && controller
-      return false unless controller.respond_to?(:controller_path)
-      return false unless controller.controller_path.to_s == "ruby_cms/admin/visual_editor"
-      return false unless controller.respond_to?(:action_name) && controller.action_name.to_s == "page_preview"
-
-      begin
-        if controller.instance_variable_defined?(:@edit_mode)
-          controller.instance_variable_get(:@edit_mode) ? true : false
-        else
-          true
-        end
-      rescue StandardError
-        true
-      end
-    end
-
-    def content_for_block(block, default, fallback, key, translation_namespace, locale)
-      if block.present? && !block_effectively_blank?(block)
-        render_content_by_type(block)
-      else
-        resolve_fallback(default, fallback, key,
-                         translation_namespace, locale)
-      end
-    end
-
-    def content_for_block_text(block, default, fallback, key, translation_namespace, locale)
-      if block.present? && !block_effectively_blank?(block)
-        render_text_content_by_type(block)
-      else
-        resolve_fallback(default, fallback,
-                         key, translation_namespace, locale)
-      end
-    end
-
-    # Uses block.content_type from the DB (text, rich_text, image, link, list).
-    def render_content_by_type(block)
-      case block.content_type
-      when "rich_text" then render_rich_text_content(block)
-      when "image" then content_block_image(block)
-      when "link" then content_block_link(block)
-      when "list" then content_block_list(block)
-      else block.content.to_s
-      end
-    end
-
-    def render_text_content_by_type(block)
-      case block.content_type
-      when "rich_text" then render_rich_text_as_text(block)
-      when "image", "link" then block_title_or_content(block)
-      when "list" then render_list_as_text(block)
-      else block.content.to_s
-      end
-    end
-
-    # Body-only HTML so content stays inside wrapper (no layout div.trix-content / comments).
-    def render_rich_text_content(block)
-      return block.content.to_s unless action_text_available?(block)
-      return block.content.to_s if block.content.present? && !rich_content_body_present?(block)
-
-      html = rich_content_body_html_for_view(block)
-      sanitize_rich_text_html(html.presence || block.content.to_s)
-    end
-
-    def rich_content_body_html_for_view(block)
-      return "" unless block.rich_content.respond_to?(:body) && block.rich_content.body.present?
-
-      b = block.rich_content.body
-      out = b.respond_to?(:to_html) ? b.to_html : b.to_s
-      out.to_s.strip.presence || ""
-    end
-
-    def render_rich_text_as_text(block)
-      return block.content.to_s unless action_text_available?(block)
-
-      if rich_content_body_present?(block)
-        block.rich_content.to_plain_text
-      elsif block.content.present?
-        block.content.to_s
-      else
-        safe_rich_text_to_plain_text(block)
-      end
-    end
-
-    def action_text_available?(block)
-      block.class.respond_to?(:action_text_available?) &&
-        block.class.action_text_available? &&
-        block.respond_to?(:rich_content)
-    end
-
-    def rich_content_body_present?(block)
-      block.rich_content.respond_to?(:body) && block.rich_content.body.present?
-    end
-
-    def safe_rich_text_to_plain_text(block)
-      block.rich_content.to_plain_text
-    rescue StandardError
-      block.content.to_s
-    end
-
-    def render_list_as_text(block)
-      parse_list_items(block.content.to_s).join(", ")
-    end
-
-    def content_block_list(block)
-      items = parse_list_items(block.content.to_s)
-      return block.content.to_s if items.blank?
-
-      tag.ul(safe_join(items.map {|i| tag.li(i) }))
-    end
-
-    def parse_list_items(raw)
-      parsed = JSON.parse(raw)
-      parsed.kind_of?(Array) ? parsed.map(&:to_s) : split_list_lines(raw)
-    rescue JSON::ParserError, TypeError
-      split_list_lines(raw)
-    end
-
-    def split_list_lines(raw)
-      raw.split("\n").map(&:strip).compact_blank
-    end
-
-    def content_block_image(block)
-      return block.content.to_s unless block.respond_to?(:image) && block.image.attached?
-
-      image_tag(block.image, alt: block.title.presence || block.key)
-    end
-
-    def content_block_link(block)
-      url = block.content.to_s.strip
-      return block.content.to_s if url.blank? || url.start_with?("javascript:", "data:")
-
-      link_to(block.title.presence || url, url)
-    end
-
-    def block_title_or_content(block)
-      block.title.presence || block.content.to_s
-    end
-
-    # Treat "blank" blocks like missing blocks so we can fall back to defaults/translations.
-    # This avoids confusing situations where an empty/unpublished DB record overrides a
-    # perfectly good I18n fallback (common during initial setup or partial edits).
-    def block_effectively_blank?(block)
-      case block.content_type.to_s
-      when "image" then image_block_blank?(block)
-      when "rich_text" then rich_text_block_blank?(block)
-      else other_block_blank?(block)
-      end
-    rescue StandardError
-      false
-    end
-
-    def image_block_blank?(block)
-      return block.content.to_s.blank? unless block.respond_to?(:image)
-
-      !block.image.attached?
-    end
-
-    def rich_text_block_blank?(block)
-      return block.content.to_s.strip.blank? unless action_text_available?(block) && rich_content_body_present?(block)
-
-      rich_content_body_html_for_view(block).to_s.strip.blank?
-    end
-
-    def other_block_blank?(block)
-      block.content.to_s.strip.blank? && block.title.to_s.strip.blank?
-    end
-
-    def resolve_fallback(default, fallback, key, translation_namespace, locale)
-      return fallback.to_s if fallback.present?
-      return default.to_s if default.present?
-
-      translation = find_translation_fallback(key, translation_namespace, locale)
-      translation || key.to_s.humanize
-    end
-
-    def find_translation_fallback(key, translation_namespace, locale)
-      return unless respond_to?(:t)
-
-      I18n.with_locale(locale) do
-        namespace = translation_namespace || translation_namespace_from_config
-        try_namespaced_translation(namespace, key) || try_root_translation(key)
-      end
-    end
-
-    def translation_namespace_from_config
-      Rails.application.config.ruby_cms.content_blocks_translation_namespace.presence ||
-        "content_blocks"
-    rescue StandardError
-      "content_blocks"
-    end
-
-    def try_namespaced_translation(namespace, key)
-      return if namespace.blank?
-
-      namespaced_key = "#{namespace}.#{key}"
-      translation = t(namespaced_key, default: nil)
-      return nil if translation.blank? || translation == namespaced_key
-
-      translation.to_s
-    rescue I18n::MissingTranslationData
-      nil
-    end
-
-    def try_root_translation(key)
-      translation = t(key, default: nil)
-      return nil if translation.blank? || translation == key.to_s
-
-      translation.to_s
-    rescue I18n::MissingTranslationData
-      nil
-    end
-
-    def strip_html_tags(content)
-      if respond_to?(:strip_tags)
-        strip_tags(content.to_s)
-      else
-        content.to_s.gsub(/<[^>]*>/, "").strip
-      end
-    end
-
-    # Allow nested content blocks inside rich text to stay selectable in the visual editor
-    # by preserving the data attributes the preview click handler relies on.
-    def sanitize_rich_text_html(html)
-      str = html.to_s
-      return "" if str.blank?
-
-      base_tags = rails_sanitizer_allowed(:tags)
-      base_attrs = rails_sanitizer_allowed(:attributes)
-
-      extra_attrs = %w[
-        data-content-key
-        data-block-id
-        data-content-target
-      ]
-
-      sanitize_with_extra_attrs(str, base_tags, base_attrs, extra_attrs) || sanitize(str)
-    end
-
-    def sanitize_with_extra_attrs(str, base_tags, base_attrs, extra_attrs)
-      return nil unless base_tags && base_attrs
-
-      sanitize(
-        str,
-        tags: base_tags,
-        attributes: (base_attrs + extra_attrs).uniq
-      )
-    end
-
-    def rails_sanitizer_allowed(kind)
-      return nil unless defined?(Rails::Html::SafeListSanitizer)
-
-      sanitizer = Rails::Html::SafeListSanitizer
-      if kind == :tags && sanitizer.respond_to?(:allowed_tags)
-        sanitizer.allowed_tags.to_a
-      elsif kind == :attributes && sanitizer.respond_to?(:allowed_attributes)
-        sanitizer.allowed_attributes.to_a
-      end
-    rescue StandardError
-      nil
-    end
-
-    def cache_key_for_content_block(key, cache_opts)
-      return nil unless cache_opts
-
-      block = ::ContentBlock.published.find_by(key: key.to_s)
-      part = block ? block.cache_key : "nil"
-      ["ruby_cms", "content_block", key.to_s, part].join("/")
-    end
-  end
-end