katalyst-tables 2.6.0 → 3.0.0.beta1

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Body
+      # Shows an attachment
+      #
+      # The value is expected to be an ActiveStorage attachment
+      #
+      # If it is representable, shows as a image tag using a default variant named :thumb.
+      #
+      # Otherwise shows as a link to download.
+      class AttachmentComponent < BodyCellComponent
+        def initialize(table, record, attribute, variant: :thumb, **options)
+          super(table, record, attribute, **options)
+
+          @variant = variant
+        end
+
+        def rendered_value
+          representation
+        end
+
+        def representation
+          if value.try(:variable?) && named_variant.present?
+            image_tag(value.variant(@variant))
+          elsif value.try(:attached?)
+            filename.to_s
+          else
+            ""
+          end
+        end
+
+        def filename
+          value.blob.filename
+        end
+
+        # Utility for accessing the path Rails provides for retrieving the
+        # attachment for use in cells. Example:
+        #    <% row.attachment :file do |cell| %>
+        #       <%= link_to "Download", cell.internal_path %>
+        #    <% end %>
+        def internal_path
+          rails_blob_path(value, disposition: :attachment)
+        end
+
+        private
+
+        # Find the reflective variant by name (i.e. :thumb by default)
+        def named_variant
+          object.attachment_reflections[@attribute.to_s].named_variants[@variant.to_sym]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Body
+      # Shows Yes/No for boolean values
+      class BooleanComponent < BodyCellComponent
+        def rendered_value
+          value ? "Yes" : "No"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Body
+      # 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 < BodyCellComponent
+        def initialize(table, record, attribute, options: {}, **html_attributes)
+          super(table, record, attribute, **html_attributes)
+
+          @options = options
+        end
+
+        def rendered_value
+          value.present? ? number_to_currency(value / 100.0, @options) : ""
+        end
+
+        def default_html_attributes
+          super.merge_html(class: "type-currency")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Body
+      # Formats the value as a date
+      # @param format [String] date format, defaults to :table
+      # @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)
+
+          @format   = format
+          @relative = relative
+        end
+
+        def value
+          super&.to_date
+        end
+
+        def rendered_value
+          @relative ? relative_time : absolute_time
+        end
+
+        private
+
+        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 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
+          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/body/date_time_component.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Body
+      # Formats the value as a datetime
+      # @param format [String] datetime format, defaults to :admin
+      # @param relative [Boolean] if true, the datetime may be(if today) shown as a relative date/time
+      class DateTimeComponent < BodyCellComponent
+        include ActionView::Helpers::DateHelper
+
+        def initialize(table, record, attribute, format: :table, relative: true, **options)
+          super(table, record, attribute, **options)
+
+          @format   = format
+          @relative = relative
+        end
+
+        def value
+          super&.to_datetime
+        end
+
+        def rendered_value
+          @relative ? relative_time : absolute_time
+        end
+
+        private
+
+        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
+
+        def default_html_attributes
+          @relative && today? ? { title: absolute_time } : {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Body
+      # Displays a link to the record
+      # The link text is the value of the attribute
+      # @see Koi::Tables::BodyRowComponent#link
+      class LinkComponent < BodyCellComponent
+        def initialize(table, record, attribute, url:, link: {}, **options)
+          super(table, record, attribute, **options)
+
+          @url = url
+          @link_options = link
+        end
+
+        def call
+          content # ensure content is set before rendering options
+
+          link = content.present? && url.present? ? link_to(content, url, @link_options) : content.to_s
+          content_tag(@type, link, **html_attributes)
+        end
+
+        def url
+          case @url
+          when Symbol
+            # helpers are not available until the component is rendered
+            @url = helpers.public_send(@url, record)
+          when Proc
+            @url = @url.call(record)
+          else
+            @url
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Body
+      # 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
+        def default_html_attributes
+          { title: value.to_plain_text }
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Katalyst
 
       def before_render
         # fallback if no content block is given
-        with_content(value.to_s) unless content?
+        with_content(rendered_value) unless content?
       end
 
       def call
@@ -36,6 +36,14 @@ module Katalyst
         @record.public_send(@attribute)
       end
 
+      def rendered_value
+        value.to_s
+      end
+
+      def to_s
+        value.to_s
+      end
+
       def inspect
         "#<#{self.class.name} attribute: #{@attribute.inspect}, value: #{value.inspect}>"
       end

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

@@ -4,6 +4,7 @@ module Katalyst
   module Tables
     class BodyRowComponent < ViewComponent::Base # :nodoc:
       include Katalyst::HtmlAttributes
+      include Body::TypedColumns
 
       renders_many :columns, ->(component) { component }
 
@@ -36,6 +37,12 @@ module Katalyst
         true
       end
 
+      def default_html_attributes
+        return {} unless @table.generate_ids?
+
+        { id: dom_id(@record) }
+      end
+
       def inspect
         "#<#{self.class.name} record: #{record.inspect}>"
       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/attachment_component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class AttachmentComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-attachment")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class BooleanComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-boolean")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class CurrencyComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-currency")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class DateComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-date")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class DateTimeComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-datetime")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class LinkComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-link")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class NumberComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-number")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
+module Katalyst
+  module Tables
+    module Header
+      class RichTextComponent < HeaderCellComponent
+        def default_html_attributes
+          super.merge_html(class: "type-rich-text")
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Katalyst::HtmlAttributes::HasHtmlAttributes
+
 module Katalyst
   module Tables
     class HeaderCellComponent < ViewComponent::Base # :nodoc:
@@ -9,19 +11,20 @@ module Katalyst
 
       delegate :object_name, :collection, :sorting, to: :@table
 
-      def initialize(table, attribute, label: nil, link: {}, **html_attributes)
+      def initialize(table, attribute, label: nil, link: {}, width: nil, **html_attributes)
         super(**html_attributes)
 
         @table           = table
         @attribute       = attribute
         @value           = label
+        @width           = width
         @link_attributes = link
       end
 
       def call
         tag.th(**html_attributes) do
           if sortable?(@attribute)
-            link_to(value, sort_url(@attribute), **@link_attributes)
+            link_to(value, sort_url(@attribute), **link_attributes)
           else
             value
           end
@@ -47,7 +50,7 @@ module Katalyst
       end
 
       def inspect
-        "#<#{self.class.name} attribute: #{@attribute.inspect}, value: #{value.inspect}>"
+        "#<#{self.class.name} attribute: #{@attribute.inspect}, value: #{@value.inspect}>"
       end
 
       # Backwards compatibility with tables 1.0
@@ -55,7 +58,36 @@ module Katalyst
 
       private
 
+      def width_class
+        case @width
+        when :xs
+          "width-xs"
+        when :s
+          "width-s"
+        when :m
+          "width-m"
+        when :l
+          "width-l"
+        else
+          ""
+        end
+      end
+
+      def link_attributes
+        { data: { turbo_action: "replace" } }.merge_html(@link_attributes)
+      end
+
       def default_html_attributes
+        sort_data.merge(width_data)
+      end
+
+      def width_data
+        return {} unless @width
+
+        { class: width_class }
+      end
+
+      def sort_data
         return {} unless sorting&.supports?(collection, @attribute)
 
         { data: { sort: sorting.status(@attribute) } }

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

@@ -4,6 +4,7 @@ module Katalyst
   module Tables
     class HeaderRowComponent < ViewComponent::Base # :nodoc:
       include Katalyst::HtmlAttributes
+      include Header::TypedColumns
 
       renders_many :columns, ->(component) { component }
 

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

@@ -1,7 +1,9 @@
 <%= form_with(method: :patch,
               id:,
               class:  "tables--selection--form",
-              data:   { controller: form_controller },
+              data:   { controller:      form_controller,
+                        turbo_action:    "replace",
+                        turbo_permanent: "" },
               html:   { hidden: "" }) do |form| %>
   <p class="tables--selection--summary">
     <span data-<%= form_target("count") %>>0</span>

data/app/models/concerns/katalyst/tables/collection/pagination.rb

@@ -35,7 +35,14 @@ module Katalyst
         end
 
         def paginate_options
-          @paginate.is_a?(Hash) ? @paginate : {}
+          opts = @paginate.is_a?(Hash) ? @paginate : {}
+          opts = opts.dup
+          opts[:anchor_string] ||= anchor_string
+          opts
+        end
+
+        def anchor_string
+          "data-turbo-action=\"replace\""
         end
 
         class Paginate # :nodoc:

data/app/models/concerns/katalyst/tables/collection/sorting.rb

@@ -22,16 +22,16 @@ module Katalyst
         end
 
         def initialize(sorting: config.sorting, **options)
-          @sorting = SortForm.parse(sorting) if sorting
+          @sorting = SortForm.parse(sorting, default: sorting) if sorting
 
-          super(sort: sorting, **options) # set default sort based on config
+          super(sort: @sorting.to_param, **options) # set default sort based on config
         end
 
         def sort=(value)
           return unless @sorting
 
           # update internal proxy
-          @sorting = SortForm.parse(value, default: attribute_was(:sort))
+          @sorting = SortForm.parse(value, default: @sorting.default)
 
           # update attribute based on normalized value
           super(@sorting.to_param)

data/app/models/katalyst/tables/collection/sort_form.rb

@@ -10,25 +10,43 @@ module Katalyst
 
         attr_accessor :column, :direction, :default
 
-        def self.parse(param, default: nil)
-          column, direction = param.to_s.split
-          direction         = "asc" unless DIRECTIONS.include?(direction)
-
-          default = SortForm.parse(default).to_param if default.present?
+        def self.normalize(param)
+          new(param:).to_param
+        end
 
-          SortForm.new(column:, direction:, default:)
+        def self.parse(param, **args)
+          new(param:, **args)
         end
 
-        def initialize(column: nil, direction: nil, default: nil)
+        def initialize(param: nil, column: nil, direction: nil, default: nil)
+          if param.present?
+            column, direction = param.to_s.split
+            direction         = "asc" unless DIRECTIONS.include?(direction)
+          end
+
           self.column    = column
           self.direction = direction
-          self.default   = default
+          self.default   = SortForm.normalize(default) if default
         end
 
         def to_param
           "#{column} #{direction}"
         end
 
+        def default?
+          to_param == default.to_param
+        end
+
+        def hash
+          to_param.hash
+        end
+
+        def eql?(other)
+          to_param == other.to_param
+        end
+
+        alias to_s to_param
+
         # Returns true if the given collection supports sorting on the given
         # column. A column supports sorting if it is a database column or if
         # the collection responds to `order_by_#{column}(direction)`.