katalyst-tables 2.6.0 → 3.0.0

data/app/helpers/katalyst/tables/frontend.rb

@@ -4,9 +4,55 @@ module Katalyst
   module Tables
     # View Helper for generating HTML tables. Include in your ApplicationHelper, or similar.
     module Frontend
-      def table_with(collection:, component: nil, **, &)
+      # Construct a new table component. This entry point supports a large number
+      # of options for customizing the table. The most common options are:
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param header [Boolean] whether to render the header row (defaults to true, supports options)
+      # @param caption [Boolean Hash] whether to render the caption (defaults to true, supports options)
+      # @param generate_ids [Boolean] whether to generate dom ids for the table and rows
+      #
+      # Blocks will receive the table in row-rendering mode (with row and record defined):
+      # @yieldparam [Katalyst::TableComponent] the row component to render
+      # @yieldparam [Object, nil] the object to render, or nil for header rows
+      #
+      # If no block is provided when the table is rendered then the table will look for a row partial:
+      # @param object_name [Symbol] the name of the object to use for partial rendering
+      #        (defaults to collection.model_name.i18n_key)
+      # @param partial [String] the name of the partial to use for rendering each row
+      #        (defaults to to_partial_path on the object)
+      # @param as [Symbol] the name of the local variable to use for rendering each row
+      #        (defaults to collection.model_name.param_key)
+      #
+      # In addition to these options, standard HTML attributes can be passed which will be added to the table tag.
+      def table_with(collection:,
+                     component: nil,
+                     header: true,
+                     caption: true,
+                     generate_ids: false,
+                     object_name: nil,
+                     partial: nil,
+                     as: nil,
+                     **,
+                     &)
         component ||= default_table_component_class
-        render(component.new(collection:, **), &)
+        component = component.new(collection:, header:, caption:, generate_ids:, object_name:, partial:, as:, **)
+
+        render(component, &)
+      end
+
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param url [String] the url to submit the form to (e.g. <resources>_order_path)
+      # @param id [String] the id of the form element (defaults to <resources>_order_form)
+      # @param scope [String] the base scope to use for form inputs (defaults to order[<resources>])
+      def table_orderable_with(collection:, url:, id: nil, scope: nil, &)
+        render(Orderable::FormComponent.new(collection:, url:, id:, scope:))
+      end
+
+      # @param collection [Katalyst::Tables::Collection::Core] the collection to render
+      # @param id [String] the id of the form element (defaults to <resources>_selection_form)
+      # @param primary_key [String] the primary key of the record in the collection (defaults to :id)
+      def table_selection_with(collection:, id: nil, primary_key: :id, &)
+        render(Selectable::FormComponent.new(collection:, id:, primary_key:), &)
       end
 
       private

data/app/javascript/tables/application.js

@@ -1,4 +1,3 @@
-import TurboCollectionController from "./turbo/collection_controller";
 import OrderableItemController from "./orderable/item_controller";
 import OrderableListController from "./orderable/list_controller";
 import OrderableFormController from "./orderable/form_controller";
@@ -6,10 +5,6 @@ import SelectionFormController from "./selection/form_controller";
 import SelectionItemController from "./selection/item_controller";
 
 const Definitions = [
-  {
-    identifier: "tables--turbo--collection",
-    controllerConstructor: TurboCollectionController,
-  },
   {
     identifier: "tables--orderable--item",
     controllerConstructor: OrderableItemController,

data/app/javascript/tables/orderable/form_controller.js

@@ -1,13 +1,15 @@
 import { Controller } from "@hotwired/stimulus";
 
 export default class OrderableFormController extends Controller {
+  static values = { scope: String };
+
   add(item) {
-    const { id_name, id_value, index_name } = item.paramsValue;
-    this.element.insertAdjacentHTML(
-      "beforeend",
-      `<input type="hidden" name="${id_name}" value="${id_value}" data-generated>
-              <input type="hidden" name="${index_name}" value="${item.index}" data-generated>`,
-    );
+    item.params(this.scopeValue).forEach(({ name, value }) => {
+      this.element.insertAdjacentHTML(
+        "beforeend",
+        `<input type="hidden" name="${name}" value="${value}" data-generated>`,
+      );
+    });
   }
 
   submit() {

data/app/javascript/tables/orderable/item_controller.js

@@ -48,6 +48,15 @@ export default class OrderableRowController extends Controller {
     this.index = index;
   }
 
+  /** Retrieve params for use in the form */
+  params(scope) {
+    const { id_name, id_value, index_name } = this.paramsValue;
+    return [
+      { name: `${scope}[${id_value}][${id_name}]`, value: this.id },
+      { name: `${scope}[${id_value}][${index_name}]`, value: this.index },
+    ];
+  }
+
   /**
    * Restore any visual changes made during drag and remove the drag state.
    */

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

@@ -18,7 +18,7 @@ module Katalyst
           def permitted_params
             _default_attributes.to_h.each_with_object([]) do |(k, v), h|
               h << case v
-                   when Array
+                   when ::Array
                      { k => [] }
                    else
                      k
@@ -39,6 +39,11 @@ module Katalyst
           clear_changes_information
         end
 
+        # Collections that do not include Sorting are never sortable.
+        def sortable?
+          false
+        end
+
         def apply(items)
           @items = items
           reducers.build do |_|

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

@@ -14,27 +14,88 @@ module Katalyst
       module Sorting
         extend ActiveSupport::Concern
 
-        included do
-          config_accessor :sorting
-          attr_accessor :sorting
+        DIRECTIONS = %w[asc desc].freeze
+
+        module SortParams
+          refine Hash do
+            def to_param
+              "#{self[:column]} #{self[:direction]}"
+            end
+          end
+
+          refine String do
+            def to_param
+              to_h.to_param
+            end
 
+            def to_h
+              column, direction = split(/[ +]/, 2)
+
+              direction = "asc" unless DIRECTIONS.include?(direction)
+              { column:, direction: }
+            end
+          end
+        end
+
+        using SortParams
+
+        included do
           attribute :sort, :string
+
+          attr_reader :default_sort
         end
 
         def initialize(sorting: config.sorting, **options)
-          @sorting = SortForm.parse(sorting) if sorting
+          @default_sort = sorting.to_param if sorting.present?
+
+          super(sort: @default_sort, **options) # set default sort based on config
+        end
 
-          super(sort: sorting, **options) # set default sort based on config
+        def default_sort?
+          sort == @default_sort
         end
 
+        # Returns true if the 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 column [String, Symbol]
+        # @return [true, false]
+        def sortable?(column = nil)
+          if column.nil?
+            @default_sort.present?
+          else
+            items.respond_to?(:"order_by_#{column}") || items.model.has_attribute?(column.to_s)
+          end
+        end
+
+        # Set the current sort behaviour of the collection.
+        #
+        # @param value [String, Hash] "column direction", or { column:, direction: }
         def sort=(value)
-          return unless @sorting
+          super(value.to_param) if @default_sort
+        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 sort_status(column)
+          current, direction = sort.to_h.values_at(:column, :direction)
+          direction if column.to_s == current
+        end
 
-          # update internal proxy
-          @sorting = SortForm.parse(value, default: attribute_was(:sort))
+        # Calculates the sort parameter to apply when the given column is toggled.
+        #
+        # @param column [String, Symbol]
+        # @return [String]
+        def toggle_sort(column)
+          current, direction = sort.to_h.values_at(:column, :direction)
 
-          # update attribute based on normalized value
-          super(@sorting.to_param)
+          return "#{column} asc" unless column.to_s == current
+
+          direction == "asc" ? "#{column} desc" : "#{column} asc"
         end
 
         class Sort # :nodoc:
@@ -44,15 +105,22 @@ module Katalyst
             @app = app
           end
 
+          using SortParams
+
           def call(collection)
-            @collection                            = @app.call(collection)
-            @collection.sorting, @collection.items = @collection.sorting.apply(@collection.items) if @collection.sorting
-            @collection
-          end
+            collection = @app.call(collection)
+
+            column, direction = collection.sort.to_h.values_at(:column, :direction)
+
+            return collection if column.nil?
+
+            if collection.items.respond_to?(:"order_by_#{column}")
+              collection.items = collection.items.reorder(nil).public_send(:"order_by_#{column}", direction.to_sym)
+            elsif collection.items.model.has_attribute?(column)
+              collection.items = collection.items.reorder(column => direction)
+            end
 
-          # pagy shim
-          def params
-            @collection.attributes
+            collection
           end
         end
       end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      # Entry point for creating a collection from an array for use with table components.
+      class Array
+        include Core
+        include Filtering
+
+        def self.with_params(params)
+          new.with_params(params)
+        end
+
+        def model
+          items.first&.class || ActiveRecord::Base
+        end
+
+        def model_name
+          @model_name ||= items.first&.model_name || ActiveModel::Name.new(Object, nil, "record")
+        end
+
+        def with_params(params)
+          # test support
+          params = ActionController::Parameters.new(params) unless params.is_a?(ActionController::Parameters)
+
+          self.attributes = params.permit(self.class.permitted_params)
+
+          self
+        end
+
+        def inspect
+          "#<#{self.class.name} @attributes=#{attributes.inspect} @model_name=\"#{model_name}\" @count=#{items&.count}>"
+        end
+      end
+    end
+  end
+end

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

@@ -34,6 +34,10 @@ module Katalyst
           new.with_params(params)
         end
 
+        def model
+          items.model
+        end
+
         def model_name
           @model_name ||= items.model_name.dup.tap do |name|
             name.param_key = ""

data/lib/katalyst/tables/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/configurable"
+
+module Katalyst
+  module Tables
+    class Config
+      include ActiveSupport::Configurable
+
+      config_accessor(:component_extensions) do
+        %w[
+          Katalyst::Tables::Identifiable
+          Katalyst::Tables::Orderable
+          Katalyst::Tables::Selectable
+          Katalyst::Tables::Sortable
+        ]
+      end
+
+      config_accessor(:date_format) { :default }
+      config_accessor(:datetime_format) { :default }
+    end
+  end
+end

data/lib/katalyst/tables.rb

@@ -3,10 +3,19 @@
 require "view_component"
 require "katalyst/html_attributes"
 
+require_relative "tables/config"
 require_relative "tables/engine"
 
 module Katalyst
   module Tables
     class Error < StandardError; end
+
+    def self.config
+      @config ||= Config.new
+    end
+
+    def self.configure
+      yield config
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Katalyst Interactive
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-04 00:00:00.000000000 Z
+date: 2024-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: katalyst-html-attributes
@@ -54,48 +54,65 @@ files:
 - app/assets/builds/katalyst/tables.min.js
 - app/assets/builds/katalyst/tables.min.js.map
 - app/assets/config/katalyst-tables.js
-- app/components/concerns/katalyst/tables/configurable_component.rb
+- app/assets/stylesheets/katalyst/tables/_index.scss
+- app/assets/stylesheets/katalyst/tables/_ordinal.scss
+- app/assets/stylesheets/katalyst/tables/_table.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_boolean.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_currency.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_date.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_datetime.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_index.scss
+- app/assets/stylesheets/katalyst/tables/typed-columns/_number.scss
 - app/components/concerns/katalyst/tables/has_table_content.rb
+- app/components/concerns/katalyst/tables/identifiable.rb
 - app/components/concerns/katalyst/tables/orderable.rb
 - app/components/concerns/katalyst/tables/row_renderer.rb
 - app/components/concerns/katalyst/tables/selectable.rb
 - app/components/concerns/katalyst/tables/sortable.rb
-- app/components/concerns/katalyst/tables/turbo_replaceable.rb
 - app/components/katalyst/table_component.html.erb
 - app/components/katalyst/table_component.rb
-- app/components/katalyst/tables/body_cell_component.rb
+- app/components/katalyst/tables/body_row_component.html.erb
 - app/components/katalyst/tables/body_row_component.rb
+- app/components/katalyst/tables/cell_component.rb
+- app/components/katalyst/tables/cells/boolean_component.rb
+- app/components/katalyst/tables/cells/currency_component.rb
+- app/components/katalyst/tables/cells/date_component.rb
+- app/components/katalyst/tables/cells/date_time_component.rb
+- app/components/katalyst/tables/cells/number_component.rb
+- app/components/katalyst/tables/cells/ordinal_component.rb
+- app/components/katalyst/tables/cells/rich_text_component.rb
+- app/components/katalyst/tables/cells/select_component.rb
+- app/components/katalyst/tables/data.rb
 - app/components/katalyst/tables/empty_caption_component.html.erb
 - app/components/katalyst/tables/empty_caption_component.rb
-- app/components/katalyst/tables/header_cell_component.rb
+- app/components/katalyst/tables/header_row_component.html.erb
 - app/components/katalyst/tables/header_row_component.rb
+- app/components/katalyst/tables/label.rb
+- app/components/katalyst/tables/orderable/form_component.rb
 - app/components/katalyst/tables/pagy_nav_component.rb
 - app/components/katalyst/tables/selectable/form_component.html.erb
 - app/components/katalyst/tables/selectable/form_component.rb
-- app/components/katalyst/turbo/pagy_nav_component.rb
-- app/components/katalyst/turbo/table_component.rb
 - app/controllers/concerns/katalyst/tables/backend.rb
 - app/helpers/katalyst/tables/frontend.rb
-- app/helpers/katalyst/tables/frontend/helper.rb
 - app/javascript/tables/application.js
 - app/javascript/tables/orderable/form_controller.js
 - app/javascript/tables/orderable/item_controller.js
 - app/javascript/tables/orderable/list_controller.js
 - app/javascript/tables/selection/form_controller.js
 - app/javascript/tables/selection/item_controller.js
-- app/javascript/tables/turbo/collection_controller.js
 - app/models/concerns/katalyst/tables/collection/core.rb
 - app/models/concerns/katalyst/tables/collection/filtering.rb
 - app/models/concerns/katalyst/tables/collection/has_params.rb
 - app/models/concerns/katalyst/tables/collection/pagination.rb
 - app/models/concerns/katalyst/tables/collection/reducers.rb
 - app/models/concerns/katalyst/tables/collection/sorting.rb
+- app/models/katalyst/tables/collection/array.rb
 - app/models/katalyst/tables/collection/base.rb
 - app/models/katalyst/tables/collection/filter.rb
-- app/models/katalyst/tables/collection/sort_form.rb
 - config/importmap.rb
 - config/locales/tables.en.yml
 - lib/katalyst/tables.rb
+- lib/katalyst/tables/config.rb
 - lib/katalyst/tables/engine.rb
 homepage: https://github.com/katalyst/tables
 licenses:
@@ -106,7 +123,7 @@ metadata:
   homepage_uri: https://github.com/katalyst/tables
   source_code_uri: https://github.com/katalyst/tables
   changelog_uri: https://github.com/katalyst/tables/blobs/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -121,8 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.5.9
+signing_key: 
 specification_version: 4
 summary: HTML table generator for Rails views
 test_files: []

data/app/components/concerns/katalyst/tables/configurable_component.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    module ConfigurableComponent # :nodoc:
-      extend ActiveSupport::Concern
-
-      include ActiveSupport::Configurable
-
-      included do
-        # Workaround: ViewComponent::Base.config is incompatible with ActiveSupport::Configurable
-        @_config = Class.new(ActiveSupport::Configurable::Configuration).new
-      end
-
-      class_methods do
-        # Define a configurable sub-component.
-        # Sub-components are cached on the table instance. We want to allow run
-        # time mixins for tables so that we can extend tables with cross-cutting
-        # concerns that affect multiple sub-components by including the concern
-        # into the top-level table class. We achieve this by subclassing the
-        # component as soon as it is created so that when a mixin is added to
-        # the table class, it can immediately retrieve and modify the
-        # sub-component class as well without needing to worry about affecting
-        # other tables.
-        def config_component(name, component_name: "#{name}_component", default: nil) # rubocop:disable Metrics/MethodLength
-          config_accessor(name)
-          config.public_send(:"#{name}=", default)
-          define_method(component_name) do
-            return instance_variable_get(:"@#{component_name}") if instance_variable_defined?(:"@#{component_name}")
-
-            klass     = config.public_send(name)
-            component = klass ? self.class.const_get(klass) : nil
-
-            # subclass to allow table-specific extensions
-            if component
-              component = Class.new(component)
-              component.extend(HiddenSubcomponent)
-            end
-
-            instance_variable_set(:"@#{component_name}", component) if component
-          end
-        end
-      end
-
-      # View Component uses `name` to resolve the template path, so we need to
-      # hide the subclass from the template resolver.
-      module HiddenSubcomponent
-        delegate :name, to: :superclass
-      end
-    end
-  end
-end

data/app/components/concerns/katalyst/tables/turbo_replaceable.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    # Adds support for turbo stream replacement to ViewComponents. Components
-    # that are rendered from a turbo-stream-compatible response will be rendered
-    # using turbo stream replacement. Components must define `id`.
-    #
-    # Turbo stream replacement rendering will only be enabled if the component
-    # passes `turbo: true` as a constructor option.
-    module TurboReplaceable
-      extend ActiveSupport::Concern
-
-      include ::Turbo::StreamsHelper
-
-      # Is turbo rendering enabled for this component?
-      def turbo?
-        @turbo
-      end
-
-      # Are we rendering a turbo stream response?
-      def turbo_stream_response?
-        response.media_type.eql?("text/vnd.turbo-stream.html")
-      end
-
-      def initialize(turbo: true, **options)
-        super(**options)
-
-        @turbo = turbo
-      end
-
-      class_methods do
-        # Redefine the compiler to use our custom compiler.
-        # Compiler is set on `inherited` so we need to re-set it if it's not the expected type.
-        def compiler
-          @vc_compiler = @vc_compiler.is_a?(TurboCompiler) ? @vc_compiler : TurboCompiler.new(self)
-        end
-      end
-
-      included do
-        # ensure that our custom compiler is used, as `inherited` calls `compile` before our module is included.
-        compile(force: true) if compiled?
-      end
-
-      # Wraps the default compiler provided by ViewComponent to add turbo support.
-      class TurboCompiler < ViewComponent::Compiler
-        private
-
-        def define_render_template_for # rubocop:disable Metrics/MethodLength
-          super
-
-          redefinition_lock.synchronize do
-            # Capture the instance method added by the default compiler and
-            # wrap it in a turbo stream replacement. Take care to ensure that
-            # subclasses of this component don't break delegation, as each
-            # subclass of ViewComponent::Base defines its own version of this
-            # method.
-            vc_render_template = component_class.instance_method(:render_template_for)
-            component_class.define_method(:render_template_for) do |variant = nil|
-              # VC discards the output from this method and uses the buffer
-              # if both are set. Capture and wrap the output.
-              content = capture { vc_render_template.bind_call(self, variant) }
-              # In turbo mode, replace the inner-most element using a turbo
-              # stream. Note that we only want one turbo stream per component
-              # from this mechanism, as subclasses may want to concat their
-              # own additional streams.
-              if turbo? && turbo_stream_response? && !@streamed
-                @streamed = true
-                concat(turbo_stream.replace(id, content))
-              else
-                concat(content)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    class BodyCellComponent < ViewComponent::Base # :nodoc:
-      include Katalyst::HtmlAttributes
-
-      attr_reader :record
-
-      def initialize(table, record, attribute, heading: false, **html_attributes)
-        super(**html_attributes)
-
-        @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_attributes)
-      end
-
-      # @return the object for this row.
-      def object
-        @record
-      end
-
-      def value
-        @record.public_send(@attribute)
-      end
-
-      def inspect
-        "#<#{self.class.name} attribute: #{@attribute.inspect}, value: #{value.inspect}>"
-      end
-
-      # Backwards compatibility with tables 1.0
-      alias_method :options, :html_attributes=
-    end
-  end
-end