katalyst-tables 3.0.0.beta1 → 3.1.0

data/app/components/katalyst/tables/{body → cells}/date_component.rb

@@ -2,13 +2,13 @@
 
 module Katalyst
   module Tables
-    module Body
+    module Cells
       # Formats the value as a date
-      # @param format [String] date format, defaults to :table
+      # @param format [String] date format
       # @param relative [Boolean] if true, the date may be(if within 5 days) shown as a relative date
-      class DateComponent < BodyCellComponent
-        def initialize(table, record, attribute, format: :table, relative: true, **options)
-          super(table, record, attribute, **options)
+      class DateComponent < CellComponent
+        def initialize(format:, relative:, **)
+          super(**)
 
           @format   = format
           @relative = relative
@@ -24,6 +24,13 @@ module Katalyst
 
         private
 
+        def default_html_attributes
+          {
+            class: "type-date",
+            title: (absolute_time if row.body? && @relative && value.present? && days_ago_in_words(value).present?),
+          }
+        end
+
         def absolute_time
           value.present? ? I18n.l(value, format: @format) : ""
         end
@@ -36,10 +43,6 @@ module Katalyst
           end
         end
 
-        def default_html_attributes
-          @relative && value.present? && days_ago_in_words(value).present? ? { title: absolute_time } : {}
-        end
-
         def days_ago_in_words(value)
           from_time        = value.to_time
           to_time          = Date.current.to_time

data/app/components/katalyst/tables/{body → cells}/date_time_component.rb

@@ -2,17 +2,17 @@
 
 module Katalyst
   module Tables
-    module Body
+    module Cells
       # Formats the value as a datetime
-      # @param format [String] datetime format, defaults to :admin
+      # @param format [String] datetime format
       # @param relative [Boolean] if true, the datetime may be(if today) shown as a relative date/time
-      class DateTimeComponent < BodyCellComponent
+      class DateTimeComponent < CellComponent
         include ActionView::Helpers::DateHelper
 
-        def initialize(table, record, attribute, format: :table, relative: true, **options)
-          super(table, record, attribute, **options)
+        def initialize(format:, relative:, **)
+          super(**)
 
-          @format   = format
+          @format = format
           @relative = relative
         end
 
@@ -26,6 +26,13 @@ module Katalyst
 
         private
 
+        def default_html_attributes
+          {
+            class: "type-datetime",
+            title: (absolute_time if row.body? && @relative && today?),
+          }
+        end
+
         def absolute_time
           value.present? ? I18n.l(value, format: @format) : ""
         end
@@ -47,10 +54,6 @@ module Katalyst
             absolute_time
           end
         end
-
-        def default_html_attributes
-          @relative && today? ? { title: absolute_time } : {}
-        end
       end
     end
   end

data/app/components/katalyst/tables/{body → cells}/number_component.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
 module Katalyst
   module Tables
-    module Body
+    module Cells
       # Formats the value as a number
       #
       # Adds a class to the cell to allow for custom styling
-      class NumberComponent < BodyCellComponent
+      class NumberComponent < CellComponent
         def rendered_value
           value.present? ? number_to_human(value) : ""
         end
 
+        private
+
         def default_html_attributes
-          super.merge_html(class: "type-number")
+          { class: "type-number" }
         end
       end
     end

data/app/components/katalyst/tables/cells/ordinal_component.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      class OrdinalComponent < CellComponent
+        def initialize(primary_key:, **)
+          super(**)
+
+          @primary_key = primary_key
+        end
+
+        def rendered_value
+          t("katalyst.tables.orderable.value")
+        end
+
+        private
+
+        def default_html_attributes
+          if @row.header?
+            { class: "ordinal" }
+          else
+            {
+              class: "ordinal",
+              data:  {
+                controller:                                   Orderable::ITEM_CONTROLLER,
+                "#{Orderable::ITEM_CONTROLLER}-params-value": params.to_json,
+              },
+            }
+          end
+        end
+
+        def params
+          {
+            id_name:     @primary_key,
+            id_value:    record.public_send(@primary_key),
+            index_name:  column,
+            index_value: record.public_send(column),
+          }
+        end
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/{body → cells}/rich_text_component.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
 module Katalyst
   module Tables
-    module Body
+    module Cells
       # Displays the plain text for rich text content
       #
       # Adds a title attribute to allow for hover over display of the full content
-      class RichTextComponent < BodyCellComponent
+      class RichTextComponent < CellComponent
+        private
+
         def default_html_attributes
-          { title: value.to_plain_text }
+          {
+            class: "type-rich-text",
+            title: (value.to_plain_text unless row.header?),
+          }
         end
       end
     end

data/app/components/katalyst/tables/cells/select_component.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      class SelectComponent < CellComponent
+        def initialize(params:, form_id:, **)
+          super(**)
+
+          @params  = params
+          @form_id = form_id
+        end
+
+        def rendered_value
+          tag.input(type: :checkbox)
+        end
+
+        private
+
+        def default_html_attributes
+          if @row.header?
+            { class: "selection" }
+          else
+            {
+              class: "selection",
+              data:  {
+                controller:                                    Selectable::ITEM_CONTROLLER,
+                "#{Selectable::ITEM_CONTROLLER}-params-value"              => @params.to_json,
+                "#{Selectable::ITEM_CONTROLLER}-#{Selectable::FORM_CONTROLLER}-outlet" => "##{@form_id}",
+                action:                                        "change->#{Selectable::ITEM_CONTROLLER}#change",
+                turbo_permanent:                               "",
+              },
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/data.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class Data
+      def initialize(record:, column:)
+        @record = record
+        @column = column
+      end
+
+      def value
+        return @value if defined?(@value)
+
+        @value = @record&.public_send(@column)
+      end
+
+      def call
+        ActionView::OutputBuffer.new.tap do |output|
+          output << value.to_s
+        end.to_s
+      end
+
+      alias to_s call
+
+      def inspect
+        "#<#{self.class.name} column: #{@column.inspect}, value: #{value.inspect}>"
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/header_row_component.html.erb

@@ -0,0 +1,5 @@
+<%= tag.tr(**html_attributes) do %>
+<% cells.each do |cell| %>
+  <%= cell %>
+<% end %>
+<% end %>

data/app/components/katalyst/tables/header_row_component.rb

@@ -4,29 +4,11 @@ module Katalyst
   module Tables
     class HeaderRowComponent < ViewComponent::Base # :nodoc:
       include Katalyst::HtmlAttributes
-      include Header::TypedColumns
 
-      renders_many :columns, ->(component) { component }
+      renders_many :cells, ->(cell) { cell }
 
-      def initialize(table, link: {})
-        super()
-
-        @table           = table
-        @link_attributes = link
-      end
-
-      def call
-        content # generate content before rendering
-
-        tag.tr(**html_attributes) do
-          columns.each do |column|
-            concat(column.to_s)
-          end
-        end
-      end
-
-      def cell(attribute, **, &)
-        with_column(@table.header_cell_component.new(@table, attribute, link: @link_attributes, **), &)
+      def before_render
+        content # ensure content is rendered so html_attributes can be set
       end
 
       def header?
@@ -38,11 +20,8 @@ module Katalyst
       end
 
       def inspect
-        "#<#{self.class.name} link_attributes: #{@link_attributes.inspect}>"
+        "#<#{self.class.name}>"
       end
-
-      # Backwards compatibility with tables 1.0
-      alias_method :options, :html_attributes=
     end
   end
 end

data/app/components/katalyst/tables/label.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class Label
+      def initialize(collection:, column:, label: nil)
+        @collection = collection
+        @column = column
+        @label = label
+      end
+
+      def value
+        return @value if defined?(@value)
+
+        @value = if !@label.nil?
+                   @label
+                 elsif @collection.model.present?
+                   @collection.model.human_attribute_name(@column)
+                 else
+                   @column.to_s.humanize.capitalize
+                 end
+      end
+
+      def call
+        ActionView::OutputBuffer.new.tap do |output|
+          output << value.to_s
+        end.to_s
+      end
+
+      alias to_s call
+
+      def inspect
+        "#<#{self.class.name} column: #{@column.inspect} value: #{value.inspect}>"
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/orderable/form_component.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Orderable
+      class FormComponent < ViewComponent::Base # :nodoc:
+        include Katalyst::Tables::Identifiable::Defaults
+
+        attr_reader :id, :url
+
+        # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+        # @param url [String] the url to submit the form to (e.g. <resources>_order_path)
+        # @param id [String] the id of the form element (defaults to <resources>_order_form)
+        # @param scope [String] the base scope to use for form inputs (defaults to order[<resources>])
+        def initialize(collection:, url:, id: nil, scope: nil)
+          super
+
+          @id    = id || Orderable.default_form_id(collection)
+          @url   = url
+          @scope = scope || Orderable.default_scope(collection)
+        end
+
+        def call
+          form_with(id:, url:, method: :patch, data: {
+                      controller:                       FORM_CONTROLLER,
+                      "#{FORM_CONTROLLER}-scope-value": @scope,
+                    }) do |form|
+            form.button(hidden: "")
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name} id: #{id.inspect}, url: #{url.inspect}>"
+        end
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/selectable/form_component.html.erb

@@ -4,11 +4,11 @@
               data:   { controller:      form_controller,
                         turbo_action:    "replace",
                         turbo_permanent: "" },
-              html:   { hidden: "" }) do |form| %>
+              html:   { action: false, hidden: "" }) do |form| %>
   <p class="tables--selection--summary">
     <span data-<%= form_target("count") %>>0</span>
-    <span data-<%= form_target("singular") %> hidden><%= @table.collection.model_name.singular %></span>
-    <span data-<%= form_target("plural") %>><%= @table.collection.model_name.plural %></span>
+    <span data-<%= form_target("singular") %> hidden><%= @collection.model_name.singular %></span>
+    <span data-<%= form_target("plural") %>><%= @collection.model_name.plural %></span>
     selected
   </p>
   <%= content %>

data/app/components/katalyst/tables/selectable/form_component.rb

@@ -4,24 +4,21 @@ module Katalyst
   module Tables
     module Selectable
       class FormComponent < ViewComponent::Base # :nodoc:
+        include Katalyst::Tables::Identifiable::Defaults
+
         attr_reader :id, :primary_key
 
-        def initialize(table:,
+        # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+        # @param id [String] the id of the form element (defaults to <resources>_selection_form)
+        # @param primary_key [String] the primary key of the record in the collection (defaults to :id)
+        def initialize(collection:,
                        id: nil,
                        primary_key: :id)
           super
 
-          @table       = table
-          @id          = id
+          @collection  = collection
+          @id          = id || Selectable.default_form_id(collection)
           @primary_key = primary_key
-
-          if @id.nil?
-            table_id = table.try(:id)
-
-            raise ArgumentError, "Table selection requires an id" if table_id.nil?
-
-            @id = "#{table_id}_selection"
-          end
         end
 
         def inspect

data/app/components/katalyst/tables/summary/body_component.html.erb

@@ -0,0 +1,3 @@
+<% cells.each do |cell| %>
+  <%= cell %>
+<% end %>

data/app/components/katalyst/tables/summary/body_component.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Summary
+      class BodyComponent < Katalyst::Tables::BodyRowComponent
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/summary/header_component.html.erb

@@ -0,0 +1,3 @@
+<% cells.each do |cell| %>
+  <%= cell %>
+<% end %>

data/app/components/katalyst/tables/summary/header_component.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Summary
+      class HeaderComponent < Katalyst::Tables::HeaderRowComponent
+      end
+    end
+  end
+end

data/app/components/katalyst/tables/summary/row_component.html.erb

@@ -0,0 +1,4 @@
+<tr>
+  <%= header %>
+  <%= body %>
+</tr>

data/app/components/katalyst/tables/summary/row_component.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Summary
+      class RowComponent < ViewComponent::Base
+        renders_one :header, Summary::HeaderComponent
+        renders_one :body, Summary::BodyComponent
+      end
+    end
+  end
+end

data/app/controllers/concerns/katalyst/tables/backend.rb

@@ -2,54 +2,43 @@
 
 module Katalyst
   module Tables
-    # Utilities for controllers that are generating collections for visualisation
-    # in a table view using Katalyst::Tables::Frontend.
-    #
-    # Provides `table_sort` for sorting based on column interactions (sort param).
+    # Configuration for controllers to specify which TableComponent should be used in associated views.
     module Backend
       extend ActiveSupport::Concern
 
-      # @deprecated backwards compatibility
-      class SortForm < Katalyst::Tables::Collection::SortForm
-      end
-
-      # Sort the given collection by params[:sort], which is set when a user
-      # interacts with a column header in a frontend table view.
-      #
-      # @return [[SortForm, ActiveRecord::Relation]]
-      def table_sort(collection)
-        column, direction = params[:sort]&.split
-        direction         = "asc" unless SortForm::DIRECTIONS.include?(direction)
-
-        SortForm.new(column:,
-                     direction:)
-          .apply(collection)
-      end
-
-      def self_referred?
-        request.referer.present? && URI.parse(request.referer).path == request.path
-      end
-      alias self_refered? self_referred?
-
       included do
         class_attribute :_default_table_component, instance_accessor: false
+        class_attribute :_default_summary_table_component, instance_accessor: false
       end
 
       class_methods do
         # Set the table component to be used as the default for all tables
         # in the views rendered by this controller and its subclasses.
         #
-        # ==== Parameters
-        # * <tt>component</tt> - Default table component, an instance of +Katalyst::TableComponent+
+        # @param component [Class] the table component class to use
         def default_table_component(component)
           self._default_table_component = component
         end
+
+        # Set the summary table component to be used as the default for all
+        # summary tables in the views rendered by this controller and its
+        # subclasses.
+        #
+        # @param component [Class] the summary table component class to use
+        def default_summary_table_component(component)
+          self._default_summary_table_component = component
+        end
       end
 
       # Default table component for this controller
       def default_table_component
         self.class._default_table_component
       end
+
+      # Default summary table component for this controller
+      def default_summary_table_component
+        self.class._default_summary_table_component
+      end
     end
   end
 end

data/app/helpers/katalyst/tables/frontend.rb

@@ -4,9 +4,69 @@ module Katalyst
   module Tables
     # View Helper for generating HTML tables. Include in your ApplicationHelper, or similar.
     module Frontend
-      def table_with(collection:, component: nil, **, &)
+      # Construct a new table component. This entry point supports a large number
+      # of options for customizing the table. The most common options are:
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param header [Boolean] whether to render the header row (defaults to true, supports options)
+      # @param caption [Boolean Hash] whether to render the caption (defaults to true, supports options)
+      # @param generate_ids [Boolean] whether to generate dom ids for the table and rows
+      #
+      # Blocks will receive the table in row-rendering mode (with row and record defined):
+      # @yieldparam [Katalyst::TableComponent] the row component to render
+      # @yieldparam [Object, nil] the object to render, or nil for header rows
+      #
+      # If no block is provided when the table is rendered then the table will look for a row partial:
+      # @param object_name [Symbol] the name of the object to use for partial rendering
+      #        (defaults to collection.model_name.i18n_key)
+      # @param partial [String] the name of the partial to use for rendering each row
+      #        (defaults to to_partial_path on the object)
+      # @param as [Symbol] the name of the local variable to use for rendering each row
+      #        (defaults to collection.model_name.param_key)
+      #
+      # In addition to these options, standard HTML attributes can be passed which will be added to the table tag.
+      def table_with(collection:,
+                     component: nil,
+                     header: true,
+                     caption: true,
+                     generate_ids: false,
+                     object_name: nil,
+                     partial: nil,
+                     as: nil,
+                     **,
+                     &)
         component ||= default_table_component_class
-        render(component.new(collection:, **), &)
+        component = component.new(collection:, header:, caption:, generate_ids:, object_name:, partial:, as:, **)
+
+        render(component, &)
+      end
+
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param url [String] the url to submit the form to (e.g. <resources>_order_path)
+      # @param id [String] the id of the form element (defaults to <resources>_order_form)
+      # @param scope [String] the base scope to use for form inputs (defaults to order[<resources>])
+      def table_orderable_with(collection:, url:, id: nil, scope: nil, &)
+        render(Orderable::FormComponent.new(collection:, url:, id:, scope:))
+      end
+
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param id [String] the id of the form element (defaults to <resources>_selection_form)
+      # @param primary_key [String] the primary key of the record in the collection (defaults to :id)
+      def table_selection_with(collection:, id: nil, primary_key: :id, &)
+        render(Selectable::FormComponent.new(collection:, id:, primary_key:), &)
+      end
+
+      # Construct a new summary table component.
+      #
+      # @param model [ActiveRecord::Base] subject for the table
+      #
+      # Blocks will receive the table in row-rendering mode (with row and record defined):
+      # @yieldparam [Katalyst::TableComponent] the table component to render rows
+      # @yieldparam [nil, Object] nil for the header column, or the given model for the value column
+      def summary_table_with(model:, **, &)
+        component ||= default_summary_table_component_class
+        component = component.new(model:, **)
+
+        render(component, &)
       end
 
       private
@@ -15,6 +75,11 @@ module Katalyst
         component = controller.try(:default_table_component) || TableComponent
         component.respond_to?(:constantize) ? component.constantize : component
       end
+
+      def default_summary_table_component_class
+        component = controller.try(:default_summary_table_component) || SummaryTableComponent
+        component.respond_to?(:constantize) ? component.constantize : component
+      end
     end
   end
 end

data/app/javascript/tables/application.js

@@ -1,4 +1,3 @@
-import TurboCollectionController from "./turbo/collection_controller";
 import OrderableItemController from "./orderable/item_controller";
 import OrderableListController from "./orderable/list_controller";
 import OrderableFormController from "./orderable/form_controller";
@@ -6,10 +5,6 @@ import SelectionFormController from "./selection/form_controller";
 import SelectionItemController from "./selection/item_controller";
 
 const Definitions = [
-  {
-    identifier: "tables--turbo--collection",
-    controllerConstructor: TurboCollectionController,
-  },
   {
     identifier: "tables--orderable--item",
     controllerConstructor: OrderableItemController,