katalyst-tables 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5482118f21175e8c1dbff1a397fa7b5ff68480783a2c47da2a92c0436c66e739
-  data.tar.gz: 99e70f74ef353cce895305e5ad39a98dc690efd7f0c68d4305867fbcdc23c941
+  metadata.gz: 4c4a55f7a1b45c9f70f357eaa670debf6457aca92a8ac7ea8b10df20140d1c23
+  data.tar.gz: 620cff7771f9de2d74c613d6b107136ea34c494862d2da4e612ccb55d8dee51d
 SHA512:
-  metadata.gz: 219380d0ccb99e001c9604594d0aa68a58925bbd745d87898af359316192e61727d3549c4ab64198c31656c663ec00809d93ddc8034921143f8169fcb49f7769
-  data.tar.gz: b9d8a9e03604f9b39389d218bfceb4d354343bd0d1da4ff3bd7ca55f66446ba8f5fbc8430b9d5b22974f1210eed344ce0d579bccb209e29a0d35ca59982d4c63
+  metadata.gz: 15cc508fdbb3ad40baec51314fde01c3889b670d4ccd6366ea49171a45b979d441a4fb3fafe65e5bd07093375615b6d298ebe091f240122edf9d68b10471f251
+  data.tar.gz: e5f4186c070c81c4645bc3cf8a378927f502df6084d235c38416d98eb7e4ab45c775da2d22338d32bf5063774a575b4c7a92a556468f1b35d18c809db421922c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [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

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.rb

@@ -28,23 +28,23 @@ module Katalyst
       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

@@ -6,6 +6,18 @@ module Katalyst
       module Helper # :nodoc:
         extend ActiveSupport::Concern
 
+        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
@@ -14,18 +26,15 @@ module Katalyst
           # Implementation inspired by pagy's `pagy_url_for` helper.
           # Preserve any existing GET parameters
           # CAUTION: these parameters are not sanitised
-          params       = request.GET.merge("sort" => sort).except("page")
+          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
-
-        private
-
-        def html_options_for_table_with(html: {}, **options)
-          html_options = options.slice(:id, :class, :data).merge(html)
-          html_options.stringify_keys!
-        end
       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)&.i18n_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.1.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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Katalyst Interactive
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-18 00:00:00.000000000 Z
-dependencies: []
+date: 2023-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Builder-style HTML table generator for building tabular index views.
   Supports sorting by columns.
 email:
@@ -21,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:

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

@@ -1,63 +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,
-                   :request,
-                   :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, sort_url_for(sort: sort.toggle(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