katalyst-tables 2.6.0 → 3.0.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class CellComponent < ViewComponent::Base # :nodoc:
+      include Katalyst::HtmlAttributes
+
+      attr_reader :collection, :row, :column, :record
+
+      def initialize(collection:, row:, column:, record:, label:, heading:, **)
+        super(**)
+
+        @collection = collection
+        @row = row
+        @column = column
+        @record = record
+        @heading = heading
+
+        if @row.header?
+          @label = Label.new(collection:, column:, label:)
+        else
+          @data = Data.new(record:, column:)
+        end
+      end
+
+      # @return true if the cell is a heading cell (th).
+      def heading?
+        @row.header? || @heading
+      end
+
+      # Adds a component to wrap the content of the cell, similar to a layout in Rails views.
+      def with_content_wrapper(component)
+        @content_wrapper = component
+
+        self
+      end
+
+      def call
+        content = if content?
+                    self.content
+                  elsif @row.header?
+                    label
+                  else
+                    rendered_value
+                  end
+
+        content = @content_wrapper.with_content(content).render_in(view_context) if @content_wrapper
+
+        concat(content_tag(cell_tag, content, **html_attributes))
+      end
+
+      # Return the rendered and sanitized label for the column.
+      def label
+        @label&.to_s
+      end
+
+      # Return the raw value of the cell (i.e. the value of the data read from the record)
+      def value
+        @data&.value
+      end
+
+      # Return the serialized and sanitised data value for rendering in the cell.
+      def rendered_value
+        @data&.to_s
+      end
+
+      # Serialize data for use in blocks, i.e.
+      #   row.text(:name) { |cell| tag.span(cell) }
+      def to_s
+        # Note, this can't be `content` because the block is evaluated in order to produce content.
+        rendered_value
+      end
+
+      def inspect
+        "#<#{self.class.name} method: #{@method.inspect}>"
+      end
+
+      private
+
+      def cell_tag
+        heading? ? :th : :td
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      # Shows Yes/No for boolean values
+      class BooleanComponent < CellComponent
+        def rendered_value
+          value ? "Yes" : "No"
+        end
+
+        private
+
+        def default_html_attributes
+          { class: "type-boolean" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      # Formats the value as a money value
+      #
+      # The value is expected to be in cents.
+      # Adds a class to the cell to allow for custom styling
+      class CurrencyComponent < CellComponent
+        def initialize(options:, **)
+          super(**)
+
+          @options = options
+        end
+
+        def rendered_value
+          value.present? ? number_to_currency(value / 100.0, @options) : ""
+        end
+
+        private
+
+        def default_html_attributes
+          { class: "type-currency" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      # Formats the value as a date
+      # @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 < CellComponent
+        def initialize(format:, relative:, **)
+          super(**)
+
+          @format   = format
+          @relative = relative
+        end
+
+        def value
+          super&.to_date
+        end
+
+        def rendered_value
+          @relative ? relative_time : absolute_time
+        end
+
+        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
+
+        def relative_time
+          if value.blank?
+            ""
+          else
+            days_ago_in_words(value)&.capitalize || absolute_time
+          end
+        end
+
+        def days_ago_in_words(value)
+          from_time        = value.to_time
+          to_time          = Date.current.to_time
+          distance_in_days = ((to_time - from_time) / (24.0 * 60.0 * 60.0)).round
+
+          case distance_in_days
+          when 0
+            "today"
+          when 1
+            "yesterday"
+          when -1
+            "tomorrow"
+          when 2..5
+            "#{distance_in_days} days ago"
+          when -5..-2
+            "#{distance_in_days.abs} days from now"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      # Formats the value as a datetime
+      # @param format [String] datetime format
+      # @param relative [Boolean] if true, the datetime may be(if today) shown as a relative date/time
+      class DateTimeComponent < CellComponent
+        include ActionView::Helpers::DateHelper
+
+        def initialize(format:, relative:, **)
+          super(**)
+
+          @format = format
+          @relative = relative
+        end
+
+        def value
+          super&.to_datetime
+        end
+
+        def rendered_value
+          @relative ? relative_time : absolute_time
+        end
+
+        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
+
+        def today?
+          value&.to_date == Date.current
+        end
+
+        def relative_time
+          return "" if value.blank?
+
+          if today?
+            if value > DateTime.current
+              "#{distance_of_time_in_words(value, DateTime.current)} from now".capitalize
+            else
+              "#{distance_of_time_in_words(value, DateTime.current)} ago".capitalize
+            end
+          else
+            absolute_time
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Cells
+      # Formats the value as a number
+      #
+      # Adds a class to the cell to allow for custom styling
+      class NumberComponent < CellComponent
+        def rendered_value
+          value.present? ? number_to_human(value) : ""
+        end
+
+        private
+
+        def default_html_attributes
+          { class: "type-number" }
+        end
+      end
+    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/cells/rich_text_component.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    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 < CellComponent
+        private
+
+        def default_html_attributes
+          {
+            class: "type-rich-text",
+            title: (value.to_plain_text unless row.header?),
+          }
+        end
+      end
+    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/empty_caption_component.rb

@@ -24,7 +24,7 @@ module Katalyst
       end
 
       def plural_human_model_name
-        human = @table.model_name&.human || @table.object_name.to_s.humanize
+        human = @table.model_name&.human || @table.object_name&.to_s&.humanize || "record"
         human.pluralize.downcase
       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

@@ -5,27 +5,10 @@ module Katalyst
     class HeaderRowComponent < ViewComponent::Base # :nodoc:
       include Katalyst::HtmlAttributes
 
-      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?
@@ -37,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

@@ -1,12 +1,14 @@
 <%= form_with(method: :patch,
               id:,
               class:  "tables--selection--form",
-              data:   { controller: form_controller },
-              html:   { hidden: "" }) do |form| %>
+              data:   { controller:      form_controller,
+                        turbo_action:    "replace",
+                        turbo_permanent: "" },
+              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/controllers/concerns/katalyst/tables/backend.rb

@@ -2,35 +2,10 @@
 
 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
       end
@@ -39,8 +14,7 @@ module Katalyst
         # 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