ruby_cms 0.1.0

data/app/helpers/ruby_cms/bulk_action_table_helper.rb

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

@@ -0,0 +1,375 @@
+# 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)
+      ["ruby_cms-content-block", "content-block", options.delete(:class)].compact.join(" ")
+    end
+
+    def build_data_attributes(key, options)
+      { content_key: key, block_id: key.to_s }.merge(options.delete(:data).to_h)
+    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

data/app/helpers/ruby_cms/settings_helper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module SettingsHelper
+    TAB_CONFIG = {
+      "general" => { icon: "🏠", fallback_label: "General" },
+      "navigation" => { icon: "🧭", fallback_label: "Navigation" },
+      "pagination" => { icon: "📄", fallback_label: "Pagination" },
+      "analytics" => { icon: "📈", fallback_label: "Analytics" },
+      "dashboard" => { icon: "🗂️", fallback_label: "Dashboard" },
+      "content" => { icon: "🧱", fallback_label: "Content" }
+    }.freeze
+
+    def settings_tab_config(category)
+      TAB_CONFIG[category.to_s] || { icon: "⚙️", fallback_label: category.to_s.humanize }
+    end
+
+    def settings_tab_label(category)
+      cfg = settings_tab_config(category)
+      t("ruby_cms.admin.settings.categories.#{category}.label", default: cfg[:fallback_label])
+    end
+
+    def settings_tab_description(category)
+      t("ruby_cms.admin.settings.categories.#{category}.description", default: "")
+    end
+
+    def setting_label(entry)
+      key = entry.key.to_s
+
+      # Keep familiar labels for nav and pagination keys.
+      key = key.delete_prefix("nav_show_")
+      key = key.delete_suffix("_per_page")
+
+      key.tr("_", " ").humanize
+    end
+
+    def render_setting_field(entry:, value:, tab:)
+      case entry.type.to_sym
+      when :integer
+        render_integer_setting_field(entry:, value:, tab:)
+      when :boolean
+        render_boolean_setting_field(entry:, value:, tab:)
+      when :json
+        render_json_setting_field(entry:, value:, tab:)
+      else
+        render_string_setting_field(entry:, value:, tab:)
+      end
+    end
+
+    private
+
+    def input_base_classes
+      "w-full h-9 rounded-md border border-gray-200 bg-white px-3 text-sm text-gray-900 " \
+        "shadow-sm focus:outline-none focus:ring-2 focus:ring-teal-200"
+    end
+
+    def textarea_base_classes
+      "w-full rounded-md border border-gray-200 bg-white px-3 py-2 text-sm text-gray-900 " \
+        "shadow-sm focus:outline-none focus:ring-2 focus:ring-teal-200"
+    end
+
+    def render_integer_setting_field(entry:, value:, tab:)
+      min, max = integer_bounds_for(entry)
+
+      number_field_tag(
+        "preferences[#{entry.key}]",
+        value,
+        id: setting_input_id(entry),
+        class: input_base_classes,
+        min: min,
+        max: max,
+        data: autosave_data(entry.key, tab)
+      )
+    end
+
+    def render_boolean_setting_field(entry:, value:, tab:)
+      checked = ActiveModel::Type::Boolean.new.cast(value)
+      hidden = hidden_field_tag("preferences[#{entry.key}]", "false")
+      checkbox = check_box_tag(
+        "preferences[#{entry.key}]",
+        "true",
+        checked,
+        id: setting_input_id(entry),
+        class: "peer sr-only",
+        data: autosave_data(entry.key, tab)
+      )
+      label = content_tag(
+        :label,
+        "",
+        for: setting_input_id(entry),
+        class: "relative inline-flex h-6 w-11 cursor-pointer items-center rounded-full " \
+               "bg-gray-200 transition-colors peer-checked:bg-teal-600"
+      ) do
+        content_tag(
+          :span,
+          "",
+          class: "inline-block h-5 w-5 transform rounded-full bg-white shadow-sm transition " \
+                 "translate-x-0.5 peer-checked:translate-x-5"
+        )
+      end
+
+      content_tag(:div, class: "inline-flex items-center") { hidden + checkbox + label }
+    end
+
+    def render_json_setting_field(entry:, value:, tab:)
+      formatted = if value.kind_of?(Hash) || value.kind_of?(Array)
+                    JSON.pretty_generate(value)
+                  else
+                    value.to_s
+                  end
+
+      text_area_tag(
+        "preferences[#{entry.key}]",
+        formatted,
+        id: setting_input_id(entry),
+        class: textarea_base_classes,
+        rows: 4,
+        data: autosave_data(entry.key, tab)
+      )
+    end
+
+    def render_string_setting_field(entry:, value:, tab:)
+      text_field_tag(
+        "preferences[#{entry.key}]",
+        value,
+        id: setting_input_id(entry),
+        class: input_base_classes,
+        data: autosave_data(entry.key, tab)
+      )
+    end
+
+    def autosave_data(key, tab)
+      {
+        controller: "ruby-cms--auto-save-preference",
+        action: "change->ruby-cms--auto-save-preference#save",
+        ruby_cms__auto_save_preference_preference_key_value: key.to_s,
+        ruby_cms__auto_save_preference_settings_url_value: ruby_cms_admin_settings_path,
+        ruby_cms__auto_save_preference_tab_value: tab.to_s
+      }
+    end
+
+    def setting_input_id(entry)
+      "pref_#{entry.key}"
+    end
+
+    def integer_bounds_for(entry)
+      key = entry.key.to_s
+
+      if key.end_with?("_per_page")
+        min = RubyCms::Settings.get(:pagination_min_per_page, default: 5).to_i
+        max = RubyCms::Settings.get(:pagination_max_per_page, default: 200).to_i
+        return [min, [max, min].max]
+      end
+
+      [nil, nil]
+    rescue StandardError
+      [nil, nil]
+    end
+  end
+end