katalyst-tables 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fff2924a5584c83799ccce74292d2597083e81fd771d24022a517f38e89147ef
-  data.tar.gz: d0230ed5a686ef5f5cedeb54f96ff8a206955d718a66420940087550958f7997
+  metadata.gz: 4c4a55f7a1b45c9f70f357eaa670debf6457aca92a8ac7ea8b10df20140d1c23
+  data.tar.gz: 620cff7771f9de2d74c613d6b107136ea34c494862d2da4e612ccb55d8dee51d
 SHA512:
-  metadata.gz: 1655096befcbe0fcd8e11e3bf7240b6975ca3d6d1c3eef6e09d22b04aadd5697b37ebc124b9ebb0ddc7d1742e947a5d42c47f70f2e803bb9e2f04b54517cc99a
-  data.tar.gz: eca6c92288908ef026165bef43b8450187a3e101acfa94e67f8cf635125ade4567eab914bc1f44cae0afef80561efbd226302e9787a007e1bc5fd82e0fe6a5cf
+  metadata.gz: 15cc508fdbb3ad40baec51314fde01c3889b670d4ccd6366ea49171a45b979d441a4fb3fafe65e5bd07093375615b6d298ebe091f240122edf9d68b10471f251
+  data.tar.gz: e5f4186c070c81c4645bc3cf8a378927f502df6084d235c38416d98eb7e4ab45c775da2d22338d32bf5063774a575b4c7a92a556468f1b35d18c809db421922c

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [2.0.0]
+
+- Replaces builders with view_components 
+  We want view components to be the way to build custom tables, and add more
+  complete features to the gem. This will be a breaking change, but we have
+  tried hard to retain compatibility with existing code. Unless you are using
+  a custom builder then it's unlikely that you will see any changes.
+- If you are using custom builders, then you will need to update them to use
+  view components. See [[README.md]] for examples.
+
+## [1.1.0] - 2023-07-18
+
+- Replaces `param_key` with `i18n_key` for attribute lookup in locale file
+- Remove controller and url helpers from backend
+  - No changes required to existing code unless you were using the internal
+    classes directly
+
 ## [1.0.0] - 2022-03-23
 
 - Initial release

data/README.md

@@ -7,18 +7,16 @@ Tools for building HTML tables from ActiveRecord collections.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "katalyst-tables", git: "https://github.com/katalyst/katalyst-tables", branch: "main" 
+gem "katalyst-tables" 
 ```
 
 And then execute:
 
     $ bundle install
 
-**Reminder:** If you have a rails server running, remember to restart the server to prevent the `uninitialized constant` error.
-
 ## Usage
 
-This gem provides two entry points: Frontend for use in your views, and Backend for use in your controllers. The backend
+This gem provides two entry points: `Frontend` for use in your views, and `Backend` for use in your controllers. The backend
 entry point is optional, as it's only required if you want to support sorting by column headers.
 
 ### Frontend
@@ -35,7 +33,7 @@ Add `include Katalyst::Tables::Frontend` to your `ApplicationHelper` or similar.
 <% end %>
 ```
 
-`table_builder` will call your block once per row and accumulate the cells you generate into rows:
+The table builder will call your block once per row and accumulate the cells you generate into rows:
 
 ```html
 
@@ -102,14 +100,14 @@ All cells generated in the table header iteration will automatically be header c
 in your body rows by passing `heading: true` when you generate the cell.
 
 ```erb
-<%= row.cell :id, heading: true %>
+<% row.cell :id, heading: true %>
 ```
 
-The table header cells default to showing the titleized column name, but you can customize this in one of two ways:
+The table header cells default to showing the capitalized column name, but you can customize this in one of two ways:
 
 * Set the value inline
     ```erb
-    <%= row.cell :id, label: "ID" %>
+    <% row.cell :id, label: "ID" %>
     ```
 * Define a translation for the attribute
     ```yml
@@ -261,56 +259,42 @@ You can write a custom builder that helps generate this type of table by adding
 for generating the actions. This allows for a declarative table syntax, something like this:
 
 ```erb
-<%= table_with(collection: collection, builder: Test::ActionTable) do |row| %>
-  <%= row.cell :name %>
-  <%= row.actions do |cell| %>
+<%= table_with(collection: collection, component: ActionTableComponent) do |row| %>
+  <% row.cell :name %>
+  <% row.actions do |cell| %>
     <%= cell.action "Edit", :edit %>
     <%= cell.action "Delete", :delete, method: :delete %>
   <% end %>
 <% end %>
 ```
 
-And the custom builder:
+And the customized component:
 
 ```ruby
-class ActionTable < Katalyst::Tables::Frontend::TableBuilder
-  def build(&block)
-    (@html_options[:class] ||= []) << "action-table"
-    super
-  end
-
-  def table_header_row(builder = ActionHeaderRow, &block)
-    super
-  end
+class ActionTableComponent < Katalyst::TableComponent
 
-  def table_header_cell(method, builder = ActionHeaderCell, **options)
-    super
-  end
+  config.header_row = "ActionHeaderRow"
+  config.body_row   = "ActionBodyRow"
+  config.body_cell  = "ActionBodyCell"
 
-  def table_body_row(object, builder = ActionBodyRow, &block)
+  def call
+    options(class: "action-table")
     super
   end
 
-  def table_body_cell(object, method, builder = ActionBodyCell, **options, &block)
-    super
-  end
-
-  class ActionHeaderRow < Katalyst::Tables::Frontend::Builder::HeaderRow
+  class ActionHeaderRow < Katalyst::Tables::HeaderRowComponent
     def actions(&block)
-      cell(:actions, class: "actions", label: "")
+      cell(:actions, class: "actions", label: "", &block)
     end
   end
 
-  class ActionHeaderCell < Katalyst::Tables::Frontend::Builder::HeaderCell
-  end
-
-  class ActionBodyRow < Katalyst::Tables::Frontend::Builder::BodyRow
+  class ActionBodyRow < Katalyst::Tables::BodyRowComponent
     def actions(&block)
       cell(:actions, class: "actions", &block)
     end
   end
 
-  class ActionBodyCell < Katalyst::Tables::Frontend::Builder::BodyCell
+  class ActionBodyCell < Katalyst::Tables::BodyCellComponent
     def action(label, href, **opts)
       content_tag :a, label, { href: href }.merge(opts)
     end
@@ -318,11 +302,11 @@ class ActionTable < Katalyst::Tables::Frontend::TableBuilder
 end
 ```
 
-If you have a table builder you want to reuse, you can set it as a default for some or all of your controllers:
+If you have a table component you want to reuse, you can set it as a default for some or all of your controllers:
 
 ```html
 class ApplicationController < ActiveController::Base
-  default_table_builder ActionTableBuilder
+  default_table_component ActionTableComponent
 end
 ```
 

data/app/components/katalyst/table_component.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Katalyst
+  # A component for rendering a table from a collection, with a header row.
+  # ```erb
+  # <%= Katalyst::TableComponent.new(collection: @people) do |row, person| %>
+  #   <%= row.cell :name do |cell| %>
+  #     <%= link_to cell.value, person %>
+  #   <% end %>
+  #   <%= row.cell :email %>
+  # <% end %>
+  # ```
+  class TableComponent < ViewComponent::Base
+    include ActiveSupport::Configurable
+    include Tables::Frontend::Helper
+
+    attr_reader :collection, :sort, :object_name
+
+    # Workaround: ViewComponent::Base.config is incompatible with ActiveSupport::Configurable
+    @_config = Class.new(Configuration).new
+
+    config_accessor :header_row
+    config_accessor :header_cell
+    config_accessor :body_row
+    config_accessor :body_cell
+
+    def initialize(collection:,
+                   sort: nil,
+                   header: true,
+                   object_name: collection.try(:model_name)&.i18n_key,
+                   **html_options)
+      super
+
+      @collection   = collection
+      @sort         = sort
+      @header       = header
+      @object_name  = object_name
+    end
+
+    def call
+      tag.table(**@html_options) do
+        thead + tbody
+      end
+    end
+
+    def thead
+      return "".html_safe unless @header
+
+      tag.thead do
+        concat(render_header)
+      end
+    end
+
+    def tbody
+      tag.tbody do
+        collection.each do |record|
+          concat(render_row(record))
+        end
+      end
+    end
+
+    def render_header
+      # extract the column's block from the slot and pass it to the cell for rendering
+      self.class.header_row_component.new(self).render_in(view_context, &@__vc_render_in_block)
+    end
+
+    def render_row(record)
+      # extract the column's block from the slot and pass it to the cell for rendering
+      block = @__vc_render_in_block
+      self.class.body_row_component.new(self, record).render_in(view_context) do |row|
+        block.call(row, record)
+      end
+    end
+
+    def self.header_row_component
+      @header_row_component ||= const_get(config.header_row || "Katalyst::Tables::HeaderRowComponent")
+    end
+
+    def self.header_cell_component
+      @header_cell_component ||= const_get(config.header_cell || "Katalyst::Tables::HeaderCellComponent")
+    end
+
+    def self.body_row_component
+      @body_row_component ||= const_get(config.body_row || "Katalyst::Tables::BodyRowComponent")
+    end
+
+    def self.body_cell_component
+      @body_cell_component ||= const_get(config.body_cell || "Katalyst::Tables::BodyCellComponent")
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class BodyCellComponent < ViewComponent::Base # :nodoc:
+      include Frontend::Helper
+
+      attr_reader :record
+
+      def initialize(table, record, attribute, heading: false, **html_options)
+        super(**html_options)
+
+        @table     = table
+        @record    = record
+        @attribute = attribute
+        @type      = heading ? :th : :td
+      end
+
+      def before_render
+        # fallback if no content block is given
+        with_content(value.to_s) unless content?
+      end
+
+      def call
+        content # ensure content is set before rendering options
+
+        content_tag(@type, content, **@html_options)
+      end
+
+      # @return the object for this row.
+      def object
+        @record
+      end
+
+      def value
+        @record.public_send(@attribute)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class BodyRowComponent < ViewComponent::Base # :nodoc:
+      include Frontend::Helper
+
+      renders_many :columns, ->(component) { component }
+
+      def initialize(table, record)
+        super()
+
+        @table  = table
+        @record = record
+      end
+
+      def call
+        content # generate content before rendering
+
+        tag.tr(**@html_options) do
+          columns.each do |column|
+            concat(column.to_s)
+          end
+        end
+      end
+
+      def cell(attribute, **options, &block)
+        with_column(@table.class.body_cell_component.new(@table, @record, attribute, **options), &block)
+      end
+
+      def header?
+        false
+      end
+
+      def body?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class HeaderCellComponent < ViewComponent::Base # :nodoc:
+      include Frontend::Helper
+
+      delegate :object_name, :sort, to: :@table
+
+      def initialize(table, attribute, label: nil, **html_options)
+        super(**html_options)
+
+        @table        = table
+        @attribute    = attribute
+        @value        = label
+      end
+
+      def call
+        content = if @table.sort&.supports?(@table.collection, @attribute)
+                    sort_link(value) # writes to html_options
+                  else
+                    value
+                  end
+
+        tag.th(content, **@html_options)
+      end
+
+      def value
+        if !@value.nil?
+          @value
+        elsif object_name.present?
+          translation
+        else
+          default_value
+        end
+      end
+
+      def translation(key = "activerecord.attributes.#{object_name}.#{@attribute}")
+        translate(key, default: default_value)
+      end
+
+      def default_value
+        @attribute.to_s.humanize.capitalize
+      end
+
+      private
+
+      def sort_link(content)
+        (@html_options["data"] ||= {})["sort"] = sort.status(@attribute)
+        link_to(content, sort_url_for(sort: sort.toggle(@attribute)))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    class HeaderRowComponent < ViewComponent::Base # :nodoc:
+      include Frontend::Helper
+
+      renders_many :columns, ->(component) { component }
+
+      def initialize(table)
+        super()
+
+        @table = table
+      end
+
+      def call
+        content # generate content before rendering
+
+        tag.tr(**@html_options) do
+          columns.each do |column|
+            concat(column.to_s)
+          end
+        end
+      end
+
+      def cell(attribute, **options, &block)
+        with_column(@table.class.header_cell_component.new(@table, attribute, **options), &block)
+      end
+
+      def header?
+        true
+      end
+
+      def body?
+        false
+      end
+    end
+  end
+end

data/lib/katalyst/tables/backend/sort_form.rb

@@ -10,11 +10,9 @@ module Katalyst
 
         attr_accessor :column, :direction
 
-        def initialize(controller, column: nil, direction: nil)
+        def initialize(column: nil, direction: nil)
           self.column    = column
           self.direction = direction
-
-          @controller = controller
         end
 
         # Returns true if the given collection supports sorting on the given
@@ -38,35 +36,19 @@ module Katalyst
           direction if column.to_s == self.column
         end
 
-        # Generates a url for applying/toggling sort for the given column.
+        # Calculates the sort parameter to apply when the given column is toggled.
         #
-        # @param column [String, Symbol] the table column as defined in table_with
-        # @return [String] URL for use as a link in a column header
-        def url_for(column)
-          # Implementation inspired by pagy's `pagy_url_for` helper.
-
-          request = @controller.request
-
-          # Preserve any existing GET parameters
-          # CAUTION: these parameters are not sanitised
-          params       = request.GET.merge("sort" => "#{column} #{toggle_direction(column)}").except("page")
-          query_string = params.empty? ? "" : "?#{Rack::Utils.build_nested_query(params)}"
-
-          "#{request.path}#{query_string}"
-        end
-
-        # Generates a url for the current page without any sorting parameters.
-        #
-        # @return [String] URL for use as a link in a column header
-        def unsorted_url
-          request = @controller.request
-
-          # Preserve any existing GET parameters but remove sort.
-          # CAUTION: these parameters are not sanitised
-          params       = request.GET.except("sort", "page")
-          query_string = params.empty? ? "" : "?#{Rack::Utils.build_nested_query(params)}"
+        # @param column [String, Symbol]
+        # @return [String]
+        def toggle(column)
+          return "#{column} asc" unless column.to_s == self.column
 
-          "#{request.path}#{query_string}"
+          case direction
+          when "asc"
+            "#{column} desc"
+          when "desc"
+            "#{column} asc"
+          end
         end
 
         # Apply the constructed sort ordering to the collection.
@@ -92,17 +74,6 @@ module Katalyst
         def clear!
           self.column = self.direction = nil
         end
-
-        def toggle_direction(column)
-          return "asc" unless column.to_s == self.column
-
-          case direction
-          when "asc"
-            "desc"
-          when "desc"
-            "asc"
-          end
-        end
       end
     end
   end

data/lib/katalyst/tables/backend.rb

@@ -22,30 +22,29 @@ module Katalyst
         column, direction = params[:sort]&.split(" ")
         direction         = "asc" unless SortForm::DIRECTIONS.include?(direction)
 
-        SortForm.new(self,
-                     column: column,
+        SortForm.new(column: column,
                      direction: direction)
                 .apply(collection)
       end
 
       included do
-        class_attribute :_default_table_builder, instance_accessor: false
+        class_attribute :_default_table_component, instance_accessor: false
       end
 
       class_methods do
-        # Set the table builder to be used as the default for all tables
+        # 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>builder</tt> - Default table builder, an instance of +Katalyst::Tables::Frontend::TableBuilder+
-        def default_table_builder(builder)
-          self._default_table_builder = builder
+        # * <tt>component</tt> - Default table component, an instance of +Katalyst::TableComponent+
+        def default_table_component(component)
+          self._default_table_component = component
         end
       end
 
-      # Default table builder for the controller
-      def default_table_builder
-        self.class._default_table_builder
+      # Default table component for this controller
+      def default_table_component
+        self.class._default_table_component
       end
     end
   end

data/lib/katalyst/tables/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module Katalyst
+  module Tables
+    class Engine < ::Rails::Engine # :nodoc:
+      isolate_namespace Katalyst::Tables
+    end
+  end
+end

data/lib/katalyst/tables/frontend/helper.rb

@@ -4,11 +4,36 @@ module Katalyst
   module Tables
     module Frontend
       module Helper # :nodoc:
-        private
+        extend ActiveSupport::Concern
 
-        def html_options_for_table_with(html: {}, **options)
-          html_options = options.slice(:id, :class, :data).merge(html)
-          html_options.stringify_keys!
+        def initialize(**options)
+          super()
+
+          options(**options)
+        end
+
+        # Add HTML options to the current component.
+        def options(html: {}, **options)
+          @html_options = options.slice(:id, :aria, :class, :data).merge(html)
+          @html_options.stringify_keys!
+        end
+
+        # Generates a url for applying/toggling sort for the given column.
+        #
+        # @param sort [String, nil] sort parameter to apply, or nil to remove sorting
+        # @return [String] URL for toggling column sorting
+        def sort_url_for(sort: nil)
+          # Implementation inspired by pagy's `pagy_url_for` helper.
+          # Preserve any existing GET parameters
+          # CAUTION: these parameters are not sanitised
+          params = if sort
+                     request.GET.merge("sort" => sort).except("page")
+                   else
+                     request.GET.except("page", "sort")
+                   end
+          query_string = params.empty? ? "" : "?#{Rack::Utils.build_nested_query(params)}"
+
+          "#{request.path}#{query_string}"
         end
       end
     end

data/lib/katalyst/tables/frontend.rb

@@ -1,51 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "frontend/builder/base"
-require_relative "frontend/builder/body_cell"
-require_relative "frontend/builder/body_row"
-require_relative "frontend/builder/header_cell"
-require_relative "frontend/builder/header_row"
 require_relative "frontend/helper"
-require_relative "frontend/table_builder"
 
 module Katalyst
   module Tables
     # View Helper for generating HTML tables. Include in your ApplicationHelper, or similar.
     module Frontend
-      include Helper
-
-      def table_with(collection:, **options, &block)
-        table_options = options.slice(:header, :object_name, :sort)
-
-        table_options[:object_name] ||= collection.try(:model_name)&.param_key
-
-        html_options = html_options_for_table_with(**options)
-
-        builder = options.fetch(:builder) { default_table_builder_class }
-        builder.new(self, collection, table_options, html_options).build(&block)
-      end
-
-      def table_header_row(table, builder, &block)
-        builder.new(table).build(&block)
-      end
-
-      def table_header_cell(table, method, builder, **options, &block)
-        builder.new(table, method, **options).build(&block)
-      end
-
-      def table_body_row(table, object, builder, &block)
-        builder.new(table, object).build(&block)
-      end
-
-      def table_body_cell(table, object, method, builder, **options, &block)
-        builder.new(table, object, method, **options).build(&block)
+      def table_with(collection:, component: nil, **options, &block)
+        component ||= default_table_component_class
+        render(component.new(collection: collection, **options), &block)
       end
 
       private
 
-      def default_table_builder_class
-        builder = controller.try(:default_table_builder) || TableBuilder
-        builder.respond_to?(:constantize) ? builder.constantize : builder
+      def default_table_component_class
+        component = controller.try(:default_table_component) || TableComponent
+        component.respond_to?(:constantize) ? component.constantize : component
       end
     end
   end

data/lib/katalyst/tables/version.rb

@@ -2,6 +2,6 @@
 
 module Katalyst
   module Tables
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
   end
 end

data/lib/katalyst/tables.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require "view_component"
+
 require_relative "tables/backend"
+require_relative "tables/engine"
 require_relative "tables/frontend"
 require_relative "tables/version"
 
+require_relative "tables/engine" if Object.const_defined?("Rails")
+
 module Katalyst
   module Tables
     class Error < StandardError; end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Katalyst Interactive
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2023-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: view_component
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
 description: Builder-style HTML table generator for building tabular index views.
   Supports sorting by columns.
 email:
@@ -35,17 +35,17 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- app/components/katalyst/table_component.rb
+- app/components/katalyst/tables/body_cell_component.rb
+- app/components/katalyst/tables/body_row_component.rb
+- app/components/katalyst/tables/header_cell_component.rb
+- app/components/katalyst/tables/header_row_component.rb
 - lib/katalyst/tables.rb
 - lib/katalyst/tables/backend.rb
 - lib/katalyst/tables/backend/sort_form.rb
+- lib/katalyst/tables/engine.rb
 - lib/katalyst/tables/frontend.rb
-- lib/katalyst/tables/frontend/builder/base.rb
-- lib/katalyst/tables/frontend/builder/body_cell.rb
-- lib/katalyst/tables/frontend/builder/body_row.rb
-- lib/katalyst/tables/frontend/builder/header_cell.rb
-- lib/katalyst/tables/frontend/builder/header_row.rb
 - lib/katalyst/tables/frontend/helper.rb
-- lib/katalyst/tables/frontend/table_builder.rb
 - lib/katalyst/tables/version.rb
 homepage: https://github.com/katalyst/katalyst-tables
 licenses:
@@ -56,7 +56,7 @@ metadata:
   homepage_uri: https://github.com/katalyst/katalyst-tables
   source_code_uri: https://github.com/katalyst/katalyst-tables
   changelog_uri: https://github.com/katalyst/katalyst-tables/blobs/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -71,8 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.4.12
+signing_key:
 specification_version: 4
 summary: HTML table generator for Rails views
 test_files: []

data/lib/katalyst/tables/frontend/builder/base.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/core_ext/module/delegation"
-
-require_relative "../helper"
-
-module Katalyst
-  module Tables
-    module Frontend
-      module Builder
-        class Base # :nodoc:
-          include Helper
-
-          attr_reader :table
-
-          delegate :sort,
-                   :table_header_cell,
-                   :table_header_row,
-                   :table_body_cell,
-                   :table_body_row,
-                   :template,
-                   to: :table
-
-          delegate :content_tag,
-                   :link_to,
-                   :render,
-                   :translate,
-                   :with_output_buffer,
-                   to: :template
-
-          def initialize(table, **options)
-            @table  = table
-            @header = false
-            self.options(**options)
-          end
-
-          def header?
-            @header
-          end
-
-          def body?
-            !@header
-          end
-
-          def options(**options)
-            @html_options = html_options_for_table_with(**options)
-          end
-
-          private
-
-          def table_tag(type, value = nil, &block)
-            # capture output before calling tag, to allow users to modify `options` during body execution
-            value = with_output_buffer(&block) if block_given?
-
-            content_tag(type, value, @html_options, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/katalyst/tables/frontend/builder/body_cell.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Katalyst
-  module Tables
-    module Frontend
-      module Builder
-        class BodyCell < Base # :nodoc:
-          attr_reader :object, :method
-
-          def initialize(table, object, method, **options)
-            super table, **options
-
-            @type   = options.fetch(:heading, false) ? :th : :td
-            @object = object
-            @method = method
-          end
-
-          def build
-            table_tag(@type) { block_given? ? yield(self).to_s : value.to_s }
-          end
-
-          def value
-            object.public_send(method)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/katalyst/tables/frontend/builder/body_row.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Katalyst
-  module Tables
-    module Frontend
-      module Builder
-        class BodyRow < Base # :nodoc:
-          attr_reader :object
-
-          def initialize(table, object)
-            super table
-
-            @object = object
-          end
-
-          def build
-            table_tag(:tr) { yield self, object }
-          end
-
-          def cell(method, **options, &block)
-            table_body_cell(object, method, **options, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/katalyst/tables/frontend/builder/header_cell.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "body_cell"
-
-module Katalyst
-  module Tables
-    module Frontend
-      module Builder
-        class HeaderCell < BodyCell # :nodoc:
-          def initialize(table, method, **options)
-            super(table, nil, method, **options)
-
-            @value  = options[:label]
-            @header = true
-          end
-
-          def build(&_block)
-            # NOTE: block ignored intentionally but subclasses may consume it
-            if @table.sort&.supports?(@table.collection, method)
-              content = sort_link(value) # writes to html_options
-              table_tag :th, content # consumes options
-            else
-              table_tag :th, value
-            end
-          end
-
-          def value
-            if !@value.nil?
-              @value
-            elsif @table.object_name.present?
-              translation
-            else
-              default_value
-            end
-          end
-
-          def translation(key = "activerecord.attributes.#{@table.object_name}.#{method}")
-            translate(key, default: default_value)
-          end
-
-          def default_value
-            method.to_s.humanize.titleize
-          end
-
-          private
-
-          def sort_link(content)
-            (@html_options["data"] ||= {})["sort"] = sort.status(method)
-            link_to(content, @table.sort.url_for(method))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/katalyst/tables/frontend/builder/header_row.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "body_row"
-
-module Katalyst
-  module Tables
-    module Frontend
-      module Builder
-        class HeaderRow < BodyRow # :nodoc:
-          def initialize(table)
-            super table, nil
-
-            @header = true
-          end
-
-          def cell(method, **options, &block)
-            table_header_cell(method, **options, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/katalyst/tables/frontend/table_builder.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "builder/body_cell"
-require_relative "builder/body_row"
-require_relative "builder/header_cell"
-require_relative "builder/header_row"
-
-module Katalyst
-  module Tables
-    module Frontend
-      # Builder API for generating HTML tables from ActiveRecord.
-      # @see Frontend#table_with
-      class TableBuilder
-        attr_reader :template, :collection, :object_name, :sort
-
-        def initialize(template, collection, options, html_options)
-          @template     = template
-          @collection   = collection
-          @header       = options.fetch(:header, true)
-          @object_name  = options.fetch(:object_name, nil)
-          @sort         = options[:sort]
-          @html_options = html_options
-        end
-
-        def table_header_row(builder = nil, &block)
-          @template.table_header_row(self, builder || Builder::HeaderRow, &block)
-        end
-
-        def table_header_cell(method, builder = nil, **options, &block)
-          @template.table_header_cell(self, method, builder || Builder::HeaderCell, **options, &block)
-        end
-
-        def table_body_row(object, builder = nil, &block)
-          @template.table_body_row(self, object, builder || Builder::BodyRow, &block)
-        end
-
-        def table_body_cell(object, method, builder = nil, **options, &block)
-          @template.table_body_cell(self, object, method, builder || Builder::BodyCell, **options, &block)
-        end
-
-        def build(&block)
-          template.content_tag("table", @html_options) do
-            thead(&block) + tbody(&block)
-          end
-        end
-
-        private
-
-        def thead(&block)
-          return "".html_safe unless @header
-
-          template.content_tag("thead") do
-            table_header_row(&block)
-          end
-        end
-
-        def tbody(&block)
-          template.content_tag("tbody") do
-            buffer = ActiveSupport::SafeBuffer.new
-
-            collection.each do |object|
-              buffer << table_body_row(object, &block)
-            end
-
-            buffer
-          end
-        end
-      end
-    end
-  end
-end