katalyst-tables 2.6.0 → 3.0.0

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    class HeaderCellComponent < ViewComponent::Base # :nodoc:
-      include Frontend::Helper
-      include Katalyst::HtmlAttributes
-      include Sortable
-
-      delegate :object_name, :collection, :sorting, to: :@table
-
-      def initialize(table, attribute, label: nil, link: {}, **html_attributes)
-        super(**html_attributes)
-
-        @table           = table
-        @attribute       = attribute
-        @value           = label
-        @link_attributes = link
-      end
-
-      def call
-        tag.th(**html_attributes) do
-          if sortable?(@attribute)
-            link_to(value, sort_url(@attribute), **@link_attributes)
-          else
-            value
-          end
-        end
-      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
-
-      def inspect
-        "#<#{self.class.name} attribute: #{@attribute.inspect}, value: #{value.inspect}>"
-      end
-
-      # Backwards compatibility with tables 1.0
-      alias_method :options, :html_attributes=
-
-      private
-
-      def default_html_attributes
-        return {} unless sorting&.supports?(collection, @attribute)
-
-        { data: { sort: sorting.status(@attribute) } }
-      end
-    end
-  end
-end

data/app/components/katalyst/turbo/pagy_nav_component.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Turbo
-    class PagyNavComponent < Tables::PagyNavComponent # :nodoc:
-      include Tables::TurboReplaceable
-
-      def initialize(id:, **options)
-        super(id:, **options)
-      end
-
-      def id
-        pagy_options[:id]
-      end
-
-      private
-
-      def pagy_options
-        super.merge(anchor_string: "data-turbo-stream")
-      end
-    end
-  end
-end

data/app/components/katalyst/turbo/table_component.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Turbo
-    # Renders a table that uses turbo stream replacement when sorting or
-    # paginating.
-    class TableComponent < ::Katalyst::TableComponent
-      include Tables::TurboReplaceable
-
-      attr_reader :id
-
-      def initialize(collection:, id:, header: true, **options)
-        header = if header.is_a?(Hash)
-                   default_header_options.merge(header)
-                 elsif header
-                   default_header_options
-                 end
-
-        @id = id
-
-        super(collection:, header:, id:, **options)
-      end
-
-      private
-
-      def default_html_attributes
-        {
-          data: {
-            controller:                            "tables--turbo--collection",
-            tables__turbo__collection_query_value: current_query,
-            tables__turbo__collection_sort_value:  collection.sort,
-          },
-        }
-      end
-
-      def current_query
-        Rack::Utils.build_nested_query(collection.to_params)
-      end
-
-      def default_header_options
-        { link: { data: { turbo_stream: "" } } }
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    module Frontend
-      # @deprecated Use {Katalyst::TableComponent} instead.
-      module Helper # :nodoc:
-        extend ActiveSupport::Concern
-
-        # 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
-        # @deprecated Use {Katalyst::TablesComponent} instead.
-        def sort_url_for(sort: nil, default: nil)
-          # Implementation inspired by pagy's `pagy_url_for` helper.
-          # Preserve any existing GET parameters
-          # CAUTION: these parameters are not sanitised
-          params = if sort && !sort.eql?(default)
-                     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
-  end
-end

data/app/javascript/tables/turbo/collection_controller.js

@@ -1,38 +0,0 @@
-import { Controller } from "@hotwired/stimulus";
-import { Turbo } from "@hotwired/turbo-rails";
-
-export default class TurboCollectionController extends Controller {
-  static values = {
-    query: String,
-    sort: String,
-  };
-
-  queryValueChanged(query) {
-    Turbo.navigator.history.replace(this.#url(query));
-  }
-
-  sortValueChanged(sort) {
-    document.querySelectorAll(this.#sortSelector).forEach((input) => {
-      if (input) input.value = sort;
-    });
-  }
-
-  get #sortSelector() {
-    return "input[name='sort']";
-  }
-
-  #url(query) {
-    const frame = this.element.closest("turbo-frame");
-    let url;
-
-    if (frame) {
-      url = new URL(frame.baseURI);
-    } else {
-      url = new URL(window.location.href);
-    }
-
-    url.search = query;
-
-    return url;
-  }
-}

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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Katalyst
-  module Tables
-    module Collection
-      # 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, :default
-
-        def self.parse(param, default: nil)
-          column, direction = param.to_s.split
-          direction         = "asc" unless DIRECTIONS.include?(direction)
-
-          default = SortForm.parse(default).to_param if default.present?
-
-          SortForm.new(column:, direction:, default:)
-        end
-
-        def initialize(column: nil, direction: nil, default: nil)
-          self.column    = column
-          self.direction = direction
-          self.default   = default
-        end
-
-        def to_param
-          "#{column} #{direction}"
-        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)
-          scope_for(collection).respond_to?(:"order_by_#{column}") ||
-            model_for(collection).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
-
-        # Calculates the sort parameter to apply when the given column is toggled.
-        #
-        # @param column [String, Symbol]
-        # @return [String]
-        def toggle(column)
-          return "#{column} asc" unless column.to_s == self.column
-
-          case direction
-          when "asc"
-            "#{column} desc"
-          when "desc"
-            "#{column} asc"
-          end
-        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 scope_for(collection)
-          collection.is_a?(Core) ? collection.items : collection
-        end
-
-        def model_for(collection)
-          scope_for(collection).model
-        end
-      end
-    end
-  end
-end