ruby_cms 0.1.0

data/app/components/ruby_cms/admin/bulk_action_table/bulk_action_table_header_bar.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module BulkActionTable
+      # Header bar with optional title, filter, action icons (+ button) and search form
+      # Renders using Phlex elements - no raw() needed
+      #
+      # @param title [String, nil] Page title (when present, filter/icons/search go on right)
+      # @param header_filter [String, nil] HTML for filter content (e.g. locale links)
+      # @param action_icons [Array<Hash>] Array of icon configs (url, title, color, icon, data)
+      # @param search_url [String] URL for search form
+      # @param search_param [String] Query param name (default: "q")
+      # @param turbo_frame [String, nil] Turbo Frame ID for search/filter updates
+      class BulkActionTableHeaderBar < BaseComponent
+        def initialize(
+          title: nil,
+          header_filter: nil,
+          action_icons: [],
+          search_url: "#",
+          search_param: "q",
+          turbo_frame: nil
+        )
+          super
+          @title = title
+          @header_filter = header_filter
+          @action_icons = action_icons || []
+          @search_url = search_url
+          @search_param = search_param
+          @turbo_frame = turbo_frame
+        end
+
+        def view_template
+          div(class: "px-6 py-4 border-b border-gray-200/80 bg-white") do
+            div(class: "flex flex-wrap items-center justify-between gap-4") do
+              render_title_group if @title.present?
+              div(class: "flex items-center gap-2 flex-wrap") do
+                render_header_filter if @header_filter.present?
+                render_action_icons
+                render_search_form
+              end
+            end
+          end
+        end
+
+        private
+
+        def render_title_group
+          div(class: "min-w-0") do
+            h2(class: "text-sm font-semibold text-gray-900") { @title }
+          end
+        end
+
+        def render_header_filter
+          raw(@header_filter) # rubocop:disable Rails/OutputSafety -- filter HTML from trusted view
+        end
+
+        def render_action_icons
+          @action_icons.each {|icon_config| render_action_icon(icon_config) }
+        end
+
+        def render_action_icon(config)
+          url = config[:url] || "#"
+          title = config[:title]
+          color = config[:color] || "blue"
+          icon_path = config[:icon] || "M12 4.5v15m7.5-7.5h-15"
+          data_attrs = config[:data] || {}
+
+          color_class = icon_color_class(color)
+
+          a(**icon_link_attrs(url, title, data_attrs, color_class)) { render_icon_svg(icon_path) }
+        end
+
+        def render_search_form
+          form_options = {
+            url: @search_url,
+            method: :get,
+            class: "w-full sm:w-auto"
+          }
+          form_options[:data] = { turbo_frame: @turbo_frame } if @turbo_frame.present?
+
+          form_with(**form_options) do
+            div(class: "relative flex items-center") do
+              render_search_icon
+              render_search_input
+            end
+          end
+        end
+
+        def render_search_icon
+          span(class: "absolute left-3 text-gray-400 pointer-events-none") do
+            svg(class: "h-4 w-4", fill: "none", stroke: "currentColor",
+                viewBox: "0 0 24 24") do |s|
+              s.path(
+                stroke_linecap: "round",
+                stroke_linejoin: "round",
+                stroke_width: "2",
+                d: "M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"
+              )
+            end
+          end
+        end
+
+        def render_search_input
+          input(
+            type: "search",
+            name: @search_param,
+            placeholder: "Search",
+            class: "h-9 w-full sm:w-72 rounded-md border border-gray-200 bg-white pl-9 " \
+                   "pr-3 text-sm shadow-sm focus:outline-none focus:ring-2 focus:ring-teal-200",
+            value: search_value,
+            data: { action: "input->turbo-frame#submit" }
+          )
+        end
+
+        def search_value
+          helpers.params[@search_param.to_sym] if helpers.respond_to?(:params)
+        end
+
+        def icon_color_class(color)
+          icon_color_class_map.fetch(color.to_s, icon_color_class_map["blue"])
+        end
+
+        def icon_color_class_map
+          {
+            "blue" => "text-blue-600 hover:bg-blue-50",
+            "green" => "text-emerald-600 hover:bg-emerald-50",
+            "red" => "text-rose-600 hover:bg-rose-50",
+            "purple" => "text-violet-600 hover:bg-violet-50",
+            "gray" => "text-gray-700 hover:bg-gray-50",
+            "teal" => "text-teal-600 hover:bg-teal-50"
+          }
+        end
+
+        def icon_button_base_classes
+          "inline-flex items-center justify-center h-9 w-9 rounded-md border border-gray-200 " \
+            "bg-white shadow-sm transition-colors"
+        end
+
+        def icon_link_attrs(url, title, data_attrs, color_class)
+          {
+            href: url,
+            class: build_classes(icon_button_base_classes, color_class),
+            title: title,
+            data: data_attrs
+          }
+        end
+
+        def render_icon_svg(icon_path)
+          svg(class: "h-4 w-4", fill: "none", stroke: "currentColor",
+              viewBox: "0 0 24 24") do |s|
+            s.path(stroke_linecap: "round", stroke_linejoin: "round", stroke_width: "2",
+                   d: icon_path)
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/ruby_cms/admin/bulk_action_table/bulk_action_table_pagination.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module BulkActionTable
+      # Pagination component
+      # Renders pagination controls with Previous/Next and page numbers
+      #
+      # @param pagination [Hash] Pagination hash with current_page, total_pages, etc.
+      # @param pagination_path [Proc] Lambda that generates pagination URLs
+      # @param turbo_frame [String, nil] Turbo Frame ID for updates
+      class BulkActionTablePagination < BaseComponent
+        def initialize(
+          pagination:,
+          pagination_path:,
+          turbo_frame: nil
+        )
+          super
+          @pagination = pagination || {}
+          @pagination_path = pagination_path
+          @turbo_frame = turbo_frame
+        end
+
+        def view_template
+          return unless @pagination[:total_pages] && @pagination[:total_pages] > 1
+
+          div(class: "px-6 py-3 flex items-center justify-between gap-4") do
+            render_pagination_info
+            render_pagination_controls
+          end
+        end
+
+        private
+
+        def render_pagination_info
+          return unless @pagination[:start_item] && @pagination[:end_item] && @pagination[:total_count]
+
+          div(class: "text-sm text-gray-500") { pagination_info_text }
+        end
+
+        def pagination_info_text
+          start_item = @pagination[:start_item]
+          end_item = @pagination[:end_item]
+          total_count = @pagination[:total_count]
+          "Showing #{start_item}-#{end_item} of #{total_count} items"
+        end
+
+        def render_pagination_controls
+          nav(class: "inline-flex items-center gap-1") do
+            render_previous_button
+            render_page_numbers
+            render_next_button
+          end
+        end
+
+        def render_previous_button
+          if @pagination[:has_previous]
+            render_previous_link
+          else
+            render_previous_disabled
+          end
+        end
+
+        def render_previous_link
+          link_options = {
+            href: @pagination_path.call(@pagination[:previous_page]),
+            class: pagination_button_classes
+          }
+          link_options[:data] = { turbo_frame: @turbo_frame } if @turbo_frame
+          a(**link_options) { "Previous" }
+        end
+
+        def render_previous_disabled
+          span(class: pagination_button_disabled_classes) { "Previous" }
+        end
+
+        def pagination_button_classes
+          "inline-flex h-9 items-center justify-center rounded-md border border-gray-200 " \
+            "bg-white px-3 text-sm font-medium text-gray-900 shadow-sm hover:bg-gray-50 " \
+            "transition-colors"
+        end
+
+        def pagination_button_disabled_classes
+          "inline-flex h-9 items-center justify-center rounded-md border border-gray-200 " \
+            "bg-white px-3 text-sm font-medium text-gray-400 opacity-60 cursor-not-allowed"
+        end
+
+        def render_next_button
+          if @pagination[:has_next]
+            render_next_link
+          else
+            render_next_disabled
+          end
+        end
+
+        def render_next_link
+          link_options = {
+            href: @pagination_path.call(@pagination[:next_page]),
+            class: pagination_button_classes
+          }
+          link_options[:data] = { turbo_frame: @turbo_frame } if @turbo_frame
+          a(**link_options) { "Next" }
+        end
+
+        def render_next_disabled
+          span(class: pagination_button_disabled_classes) { "Next" }
+        end
+
+        def render_page_numbers
+          current_page = @pagination[:current_page] || 1
+          total_pages = @pagination[:total_pages] || 1
+          pages_to_show = calculate_pages_to_show(current_page, total_pages)
+
+          pages_to_show.each do |page_num|
+            render_page_number(page_num, current_page)
+          end
+        end
+
+        def render_page_number(page_num, current_page)
+          if page_num == :ellipsis
+            render_ellipsis
+          elsif page_num == current_page
+            render_current_page(page_num)
+          else
+            render_page_link(page_num)
+          end
+        end
+
+        def render_ellipsis
+          span(class: "px-2 text-sm text-gray-500") { "…" }
+        end
+
+        def render_current_page(page_num)
+          span(class: current_page_classes) { page_num.to_s }
+        end
+
+        def render_page_link(page_num)
+          link_options = {
+            href: @pagination_path.call(page_num),
+            class: pagination_button_classes
+          }
+          link_options[:data] = { turbo_frame: @turbo_frame } if @turbo_frame
+          a(**link_options) { page_num.to_s }
+        end
+
+        def current_page_classes
+          "inline-flex h-9 items-center justify-center rounded-md border border-gray-200 " \
+            "bg-gray-900 px-3 text-sm font-medium text-white shadow-sm"
+        end
+
+        def calculate_pages_to_show(current_page, total_pages)
+          return [1] if total_pages <= 1
+
+          max_pages = 7
+          if total_pages <= max_pages
+            all_pages_array(total_pages)
+          else
+            complex_pages_array(current_page, total_pages)
+          end
+        end
+
+        def all_pages_array(total_pages)
+          (1..total_pages).to_a
+        end
+
+        def complex_pages_array(current_page, total_pages)
+          pages = [1]
+          start_page = calculate_start_page(current_page)
+          end_page = calculate_end_page(current_page, total_pages)
+
+          add_middle_section(pages, start_page, end_page, total_pages)
+          pages << total_pages unless pages.include?(total_pages)
+          pages
+        end
+
+        def calculate_start_page(current_page)
+          [current_page - 1, 2].max
+        end
+
+        def calculate_end_page(current_page, total_pages)
+          [current_page + 1, total_pages - 1].min
+        end
+
+        def add_middle_section(pages, start_page, end_page, total_pages)
+          pages << :ellipsis if start_page > 2
+          (start_page..end_page).each {|p| pages << p unless pages.include?(p) }
+          pages << :ellipsis if end_page < total_pages - 1
+        end
+      end
+    end
+  end
+end

data/app/components/ruby_cms/admin/bulk_action_table/bulk_action_table_row.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module BulkActionTable
+      # Table row component
+      # Individual table row with clickable support and checkbox
+      #
+      # @param click_url [String, nil] URL to navigate when row is clicked
+      # @param data [Hash] Data attributes (e.g., { item_id: 1 })
+      # @param cells [Array, nil] Array of cell content (alternative to block)
+      # @param bulk_actions_enabled [Boolean] Whether to show checkbox cell
+      # @param controller_name [String] Stimulus controller identifier
+      # @param class [String, nil] Additional CSS classes
+      class BulkActionTableRow < BaseComponent
+        def initialize(
+          click_url: nil,
+          data: {},
+          cells: nil,
+          bulk_actions_enabled: true,
+          controller_name: "ruby-cms--bulk-action-table",
+          class: nil,
+          **user_attrs
+        )
+          super
+          @click_url = click_url
+          @data = data || {}
+          @cells = cells
+          @bulk_actions_enabled = bulk_actions_enabled
+          @controller_name = controller_name
+          @row_class = binding.local_variable_get(:class)
+          @user_attrs = user_attrs
+        end
+
+        def view_template(&block)
+          tr(**row_attributes) do
+            render_bulk_checkbox
+            render_cells_or_block(&block)
+          end
+        end
+
+        private
+
+        def row_attributes
+          {
+            class: build_row_classes,
+            data: (build_row_data_attributes || {}).merge(@data || {})
+          }
+        end
+
+        def render_bulk_checkbox
+          return unless @bulk_actions_enabled && @data&.[](:item_id)
+
+          render BulkActionTableCheckboxCell.new(
+            item_id: @data[:item_id],
+            controller_name: @controller_name
+          )
+        end
+
+        def render_cells_or_block(&block)
+          if @cells.nil? && block
+            # Block returns HTML from render partial - output as raw to avoid escaping
+            return raw(yield) # rubocop:disable Rails/OutputSafety -- partial output is trusted
+          end
+
+          Array(@cells).each do |cell|
+            if cell.kind_of?(Hash)
+              td(class: cell[:class]) { cell[:content] }
+            else
+              td { cell }
+            end
+          end
+        end
+
+        def build_row_classes
+          classes = ["hover:bg-gray-50 transition-colors"]
+          classes << @row_class if @row_class
+          classes << "cursor-pointer" if @click_url
+          build_classes(classes)
+        end
+
+        def build_row_data_attributes
+          attrs = {}
+          attrs[:item_id] = @data[:item_id] if @data[:item_id]
+
+          if @click_url
+            attrs[:controller] = "clickable-row"
+            attrs[:clickable_row_click_url_value] = @click_url
+            attrs[:action] = "click->clickable-row#navigate"
+          end
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/app/components/ruby_cms/admin/bulk_action_table/bulk_actions.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Admin
+    module BulkActionTable
+      # Bulk actions bar component
+      # Appears when items are selected, shows selected count and action buttons
+      #
+      # @param controller_name [String] Stimulus controller identifier
+      # @param item_name [String] Singular name for items
+      # @param bulk_actions_url [String, nil] URL for bulk delete action
+      # @param bulk_action_buttons [Array<Hash>] Array of custom bulk action button configs
+      class BulkActions < BaseComponent
+        def initialize(
+          controller_name: "ruby-cms--bulk-action-table",
+          item_name: "item",
+          bulk_actions_url: nil,
+          bulk_action_buttons: []
+        )
+          super
+          @controller_name = controller_name
+          @item_name = item_name
+          @bulk_actions_url = bulk_actions_url
+          @bulk_action_buttons = bulk_action_buttons || []
+        end
+
+        def view_template
+          div(
+            class: "hidden px-6 py-3",
+            data: {
+              "#{@controller_name}-target": "bulkBar"
+            }
+          ) do
+            div(
+              class: "flex items-center justify-between gap-3 rounded-lg border " \
+                     "border-gray-200/80 bg-white px-4 py-3 shadow-sm"
+            ) do
+              render_selection_info
+              render_action_buttons
+            end
+          end
+        end
+
+        private
+
+        def render_selection_info
+          div(class: "flex items-center gap-3 flex-wrap") do
+            span(
+              class: "text-sm font-medium text-gray-700",
+              data: {
+                "#{@controller_name}-target": "selectedCount"
+              }
+            ) { "0 #{@item_name}s selected:" }
+            button(
+              type: "button",
+              class: "text-sm font-medium text-gray-600 hover:text-gray-900 hover:underline " \
+                     "transition-colors",
+              data: {
+                "#{@controller_name}-target": "selectAllButton",
+                action: "click->#{@controller_name}#selectAll"
+              }
+            ) { "Select all" }
+            button(
+              type: "button",
+              class: "text-sm font-medium text-gray-600 hover:text-gray-900 hover:underline " \
+                     "transition-colors",
+              data: {
+                action: "click->#{@controller_name}#clearSelection"
+              }
+            ) { "Clear selection" }
+          end
+        end
+
+        def render_action_buttons
+          div(class: "flex items-center gap-2 flex-wrap") do
+            @bulk_action_buttons.each do |button_config|
+              render_custom_action_button(button_config)
+            end
+
+            render_delete_button if @bulk_actions_url
+          end
+        end
+
+        def render_custom_action_button(config)
+          label = config[:label] || config[:text] || config[:name]&.humanize || "Button"
+          action_name = config[:name] || config[:action_name]
+
+          button(
+            type: "button",
+            class: build_button_class(config),
+            data: build_button_data_attrs(config, label, action_name)
+          ) { label }
+        end
+
+        def build_button_class(config)
+          base = "inline-flex items-center justify-center rounded-md border border-gray-200 " \
+                 "bg-white px-3 py-2 text-sm font-medium text-gray-900 shadow-sm " \
+                 "hover:bg-gray-50 transition-colors"
+          config[:class].present? ? "#{base} #{config[:class]}" : base
+        end
+
+        def build_button_data_attrs(config, label, action_name)
+          data_attrs = {
+            action: "click->#{@controller_name}#showActionDialog",
+            action_name: action_name,
+            action_url: config[:url]&.to_s,
+            action_label: label
+          }
+
+          # Pass through action_type
+          data_attrs[:action_type] = config[:action_type] if config[:action_type].present?
+
+          data_attrs[:action_confirm] = config[:confirm] if config[:confirm].present?
+
+          data_attrs
+        end
+
+        def render_delete_button
+          button(
+            type: "button",
+            class: "inline-flex items-center justify-center rounded-md border border-rose-200 " \
+                   "bg-white px-3 py-2 text-sm font-medium text-rose-700 shadow-sm " \
+                   "hover:bg-rose-50 transition-colors",
+            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: @bulk_actions_url&.to_s
+            }
+          ) { "Delete Selected" }
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/ruby_cms/admin_pagination.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "ruby_cms/settings"
+
+module RubyCms
+  # Unified pagination concern for all admin index pages.
+  # Uses RubyCms::Preference for per_page when configured via paginates(per_page: proc).
+  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
+    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)
+      if collection.kind_of?(Array)
+        paginate_array(collection, page, per_page)
+      elsif defined?(Kaminari) && collection.respond_to?(:page)
+        paginated = collection.page(page).per(per_page)
+        [paginated, paginated.total_count, paginated.total_pages, paginated.offset_value]
+      else
+        paginate_relation(collection, page, per_page)
+      end
+    end
+
+    def paginate_array(array, page, per_page)
+      total_count = array.size
+      offset = (page - 1) * per_page
+      total_pages = total_count.positive? ? (total_count.to_f / per_page).ceil : 1
+      paginated = array.slice(offset, per_page) || []
+      [paginated, total_count, total_pages, offset]
+    end
+
+    def paginate_relation(collection, page, per_page)
+      total_count = collection.count
+      offset = (page - 1) * per_page
+      total_pages = total_count.positive? ? (total_count.to_f / per_page).ceil : 1
+      paginated = collection.limit(per_page).offset(offset)
+      [paginated, total_count, total_pages, 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
+end