katalyst-tables 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fff2924a5584c83799ccce74292d2597083e81fd771d24022a517f38e89147ef
+  data.tar.gz: d0230ed5a686ef5f5cedeb54f96ff8a206955d718a66420940087550958f7997
+SHA512:
+  metadata.gz: 1655096befcbe0fcd8e11e3bf7240b6975ca3d6d1c3eef6e09d22b04aadd5697b37ebc124b9ebb0ddc7d1742e947a5d42c47f70f2e803bb9e2f04b54517cc99a
+  data.tar.gz: eca6c92288908ef026165bef43b8450187a3e101acfa94e67f8cf635125ade4567eab914bc1f44cae0afef80561efbd226302e9787a007e1bc5fd82e0fe6a5cf

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [1.0.0] - 2022-03-23
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Katalyst Interactive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,341 @@
+# Katalyst::Tables
+
+Tools for building HTML tables from ActiveRecord collections.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "katalyst-tables", git: "https://github.com/katalyst/katalyst-tables", branch: "main" 
+```
+
+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
+entry point is optional, as it's only required if you want to support sorting by column headers.
+
+### Frontend
+
+Add `include Katalyst::Tables::Frontend` to your `ApplicationHelper` or similar.
+
+```erb
+<%= table_with collection: @people do |row, person| %>
+  <%= row.cell :name %>
+  <%= row.cell :email %>
+  <%= row.cell :actions do %>
+   <%= link_to "Edit", person %>
+  <% end %>
+<% end %>
+```
+
+`table_builder` will call your block once per row and accumulate the cells you generate into rows:
+
+```html
+
+<table>
+    <thead>
+    <tr>
+        <th>Name</th>
+        <th>Email</th>
+        <th>Actions</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+        <td>Alice</td>
+        <td>alice@acme.org</td>
+        <td><a href="/people/1/edit">Edit</a></td>
+    </tr>
+    <tr>
+        <td>Bob</td>
+        <td>bob@acme.org</td>
+        <td><a href="/people/2/edit">Edit</a></td>
+    </tr>
+    </tbody>
+</table>
+```
+
+### Options
+
+You can customise the options passed to the table, rows, and cells.
+
+Tables support options via the call to `table_with`, similar to `form_with`.
+
+```erb
+<%= table_with collection: @people, id: "people-table" do |row, person| %>
+  ...
+<% end %>
+```
+
+Cells support the same approach:
+
+```erb
+<%= row.cell :name, class: "name" %>
+```
+
+Rows do not get called directly, so instead you can call `options` on the row builder to customize the row tag
+generation.
+
+```erb
+<%= table_with collection: @people, id: "people-table" do |row, person| %>
+  <% row.options data: { id: person.id } if row.body? %>
+  ...
+<% end %>
+```
+
+Note: because the row builder gets called to generate the header row, you may need to guard calls that access the
+`person` directly as shown in the previous example. You could also check whether `person` is present.
+
+#### Headers
+
+`table_builder` will automatically generate a header row for you by calling your block with no object. During this
+iteration, `row.header?` is true, `row.body?` is false, and the object (`person`) is nil.
+
+All cells generated in the table header iteration will automatically be header cells, but you can also make header cells
+in your body rows by passing `heading: true` when you generate the cell.
+
+```erb
+<%= 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:
+
+* Set the value inline
+    ```erb
+    <%= row.cell :id, label: "ID" %>
+    ```
+* Define a translation for the attribute
+    ```yml
+    # en.yml
+    activerecord:
+      attributes:
+        person:
+          id: "ID"
+    ```
+  
+Note: if the cell is given a block, it is not called during the header pass. This
+is because the block is assumed to be for generating data for the body, not the
+header. We suggest you set `label` instead.
+
+#### Cell values
+
+If you do not provide a value when you call the cell builder, the attribute you
+provide will be retrieved from the current item and the result will be rendered in
+the table cell. This is often all you need to do, but if you do want to customise
+the value you can pass a block instead:
+
+```erb
+<%= row.cell :status do %>
+ <%= person.password.present? ? "Active" : "Invited" %>
+<% end %>
+```
+
+In the context of the block you have access the cell builder if you simply
+want to extend the default behaviour:
+
+```erb
+<%= row.cell :status do |cell| %>
+ <%= link_to cell.value, person %>
+<% end %>
+```
+
+You can also call `options` on the cell builder, similar to the row builder, but
+please note that this will replace any options passed to the cell as arguments.
+
+### Sort
+
+The major reason why you should use this gem, apart the convenience of the
+builder, is for adding efficient and simple column sorting to your tables.
+
+Start by including the backend in your controller(s):
+
+```ruby
+include Katalyst::Tables::Backend
+```
+
+Now, in your controller index actions, you can sort your active record
+collections based on the `sort` param which is appended to the current URL as a
+get parameter when a user clicks on a column header.
+
+Building on our example from earlier:
+
+```ruby
+class PeopleController < ApplicationController
+  include Katalyst::Tables::Backend
+  
+  def index
+    @people = People.all
+
+    @sort, @people = table_sort(@people) # sort
+  end
+end
+```
+
+You then add the sort form object to your view so that it can add column header
+links and show the current sort state:
+
+```erb
+<%= table_with collection: @people, sort: @sort do |row, person| %>
+  <%= row.cell :name %>
+  <%= row.cell :email %>
+  <%= row.cell :actions do %>
+   <%= link_to "Edit", person %>
+  <% end %>
+<% end %>
+```
+
+That's it! Any column that corresponds to an ActiveRecord attribute will now be
+automatically sortable in the frontend.
+
+You can also add sorting to non-attribute columns by defining a scope in your
+model:
+
+```
+scope :order_by_status, ->(direction) { ... }
+```
+
+Finally, you can use sort with a collection that is already ordered, but please
+note that the backend will call `reorder` if the user provides a sort option. If
+you want to provide a tie-breaker default ordering, the best way to do so is after
+calling `table_sort`.
+
+You may also want to whitelist the `sort` param if you encounter strong param warnings.
+
+### Pagination
+
+This gem designed to work with [pagy](https://github.com/ddnexus/pagy/).
+
+```ruby
+
+def index
+  @people = People.all
+
+  @sort, @people = table_sort(@people) # sort
+  @pagy, @people = pagy(@people) # then paginate
+end
+```
+
+```erb
+<%= table_with collection: @people, sort: @sort do |row, person| %>
+  <%= row.cell :name %>
+  <%= row.cell :email %>
+  <%= row.cell :actions do %>
+   <%= link_to "Edit", person %>
+  <% end %>
+<% end %>
+<%== pagy_nav(@pagy) %>
+```
+
+### Customization
+
+A common pattern we use is to have a cell at the end of the table for actions. For example:
+
+```html
+<table class="action-table">
+  <thead>
+    <tr>
+      <th>Name</th>
+      <th class="actions"></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Alice</td>
+      <td class="actions">
+        <a href="/people/1/edit">Edit</a>
+        <a href="/people/1" method="delete">Delete</a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+```
+
+You can write a custom builder that helps generate this type of table by adding the required classes and adding helpers
+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| %>
+    <%= cell.action "Edit", :edit %>
+    <%= cell.action "Delete", :delete, method: :delete %>
+  <% end %>
+<% end %>
+```
+
+And the custom builder:
+
+```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
+
+  def table_header_cell(method, builder = ActionHeaderCell, **options)
+    super
+  end
+
+  def table_body_row(object, builder = ActionBodyRow, &block)
+    super
+  end
+
+  def table_body_cell(object, method, builder = ActionBodyCell, **options, &block)
+    super
+  end
+
+  class ActionHeaderRow < Katalyst::Tables::Frontend::Builder::HeaderRow
+    def actions(&block)
+      cell(:actions, class: "actions", label: "")
+    end
+  end
+
+  class ActionHeaderCell < Katalyst::Tables::Frontend::Builder::HeaderCell
+  end
+
+  class ActionBodyRow < Katalyst::Tables::Frontend::Builder::BodyRow
+    def actions(&block)
+      cell(:actions, class: "actions", &block)
+    end
+  end
+
+  class ActionBodyCell < Katalyst::Tables::Frontend::Builder::BodyCell
+    def action(label, href, **opts)
+      content_tag :a, label, { href: href }.merge(opts)
+    end
+  end
+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:
+
+```html
+class ApplicationController < ActiveController::Base
+  default_table_builder ActionTableBuilder
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/katalyst/katalyst-tables.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Backend
+      # A FormObject (model) representing the sort state of controller for a given
+      # collection/parameter.
+      class SortForm
+        DIRECTIONS = %w[asc desc].freeze
+
+        attr_accessor :column, :direction
+
+        def initialize(controller, column: nil, direction: nil)
+          self.column    = column
+          self.direction = direction
+
+          @controller = controller
+        end
+
+        # 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)`.
+        #
+        # @param collection [ActiveRecord::Relation]
+        # @param column [String, Symbol]
+        # @return [true, false]
+        def supports?(collection, column)
+          collection.respond_to?("order_by_#{column}") ||
+            collection.model.has_attribute?(column.to_s)
+        end
+
+        # Returns the current sort behaviour of the given column, for use as a
+        # column heading class in the table view.
+        #
+        # @param column [String, Symbol] the table column as defined in table_with
+        # @return [String] the current sort behaviour of the given column
+        def status(column)
+          direction if column.to_s == self.column
+        end
+
+        # Generates a url for applying/toggling sort for the given column.
+        #
+        # @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)}"
+
+          "#{request.path}#{query_string}"
+        end
+
+        # Apply the constructed sort ordering to the collection.
+        #
+        # @param collection [ActiveRecord::Relation]
+        # @return [Array(SortForm, ActiveRecord::Relation)]
+        def apply(collection)
+          return [self, collection] if column.nil?
+
+          if collection.respond_to?("order_by_#{column}")
+            collection = collection.reorder(nil).public_send("order_by_#{column}", direction.to_sym)
+          elsif collection.model.has_attribute?(column)
+            collection = collection.reorder(column => direction)
+          else
+            clear!
+          end
+
+          [self, collection]
+        end
+
+        private
+
+        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
+end

data/lib/katalyst/tables/backend.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/concern"
+
+require_relative "backend/sort_form"
+
+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).
+    module Backend
+      extend ActiveSupport::Concern
+
+      # 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(self,
+                     column: column,
+                     direction: direction)
+                .apply(collection)
+      end
+
+      included do
+        class_attribute :_default_table_builder, instance_accessor: false
+      end
+
+      class_methods do
+        # Set the table builder 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
+        end
+      end
+
+      # Default table builder for the controller
+      def default_table_builder
+        self.class._default_table_builder
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,55 @@
+# 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

@@ -0,0 +1,23 @@
+# 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/helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Frontend
+      module Helper # :nodoc:
+        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
+end

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

@@ -0,0 +1,71 @@
+# 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

data/lib/katalyst/tables/frontend.rb

@@ -0,0 +1,52 @@
+# 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)
+      end
+
+      private
+
+      def default_table_builder_class
+        builder = controller.try(:default_table_builder) || TableBuilder
+        builder.respond_to?(:constantize) ? builder.constantize : builder
+      end
+    end
+  end
+end

data/lib/katalyst/tables/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    VERSION = "1.0.0"
+  end
+end

data/lib/katalyst/tables.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "tables/backend"
+require_relative "tables/frontend"
+require_relative "tables/version"
+
+module Katalyst
+  module Tables
+    class Error < StandardError; end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: katalyst-tables
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Katalyst Interactive
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Builder-style HTML table generator for building tabular index views.
+  Supports sorting by columns.
+email:
+- devs@katalyst.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/katalyst/tables.rb
+- lib/katalyst/tables/backend.rb
+- lib/katalyst/tables/backend/sort_form.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:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: HTML table generator for Rails views
+test_files: []