katalyst-tables 3.0.0.beta1 → 3.0.0

data/app/components/katalyst/tables/body/link_component.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Body
-      # Displays a link to the record
-      # The link text is the value of the attribute
-      # @see Koi::Tables::BodyRowComponent#link
-      class LinkComponent < BodyCellComponent
-        def initialize(table, record, attribute, url:, link: {}, **options)
-          super(table, record, attribute, **options)
-
-          @url = url
-          @link_options = link
-        end
-
-        def call
-          content # ensure content is set before rendering options
-
-          link = content.present? && url.present? ? link_to(content, url, @link_options) : content.to_s
-          content_tag(@type, link, **html_attributes)
-        end
-
-        def url
-          case @url
-          when Symbol
-            # helpers are not available until the component is rendered
-            @url = helpers.public_send(@url, record)
-          when Proc
-            @url = @url.call(record)
-          else
-            @url
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +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(rendered_value) 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 rendered_value
-        value.to_s
-      end
-
-      def to_s
-        value.to_s
-      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

data/app/components/katalyst/tables/header/attachment_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class AttachmentComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-attachment")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/boolean_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class BooleanComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-boolean")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/currency_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class CurrencyComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-currency")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/date_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class DateComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-date")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/date_time_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class DateTimeComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-datetime")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/link_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class LinkComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-link")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/number_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class NumberComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-number")
-        end
-      end
-    end
-  end
-end

data/app/components/katalyst/tables/header/rich_text_component.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-module Katalyst
-  module Tables
-    module Header
-      class RichTextComponent < HeaderCellComponent
-        def default_html_attributes
-          super.merge_html(class: "type-rich-text")
-        end
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-using Katalyst::HtmlAttributes::HasHtmlAttributes
-
-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: {}, width: nil, **html_attributes)
-        super(**html_attributes)
-
-        @table           = table
-        @attribute       = attribute
-        @value           = label
-        @width           = width
-        @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 width_class
-        case @width
-        when :xs
-          "width-xs"
-        when :s
-          "width-s"
-        when :m
-          "width-m"
-        when :l
-          "width-l"
-        else
-          ""
-        end
-      end
-
-      def link_attributes
-        { data: { turbo_action: "replace" } }.merge_html(@link_attributes)
-      end
-
-      def default_html_attributes
-        sort_data.merge(width_data)
-      end
-
-      def width_data
-        return {} unless @width
-
-        { class: width_class }
-      end
-
-      def sort_data
-        return {} unless sorting&.supports?(collection, @attribute)
-
-        { data: { sort: sorting.status(@attribute) } }
-      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,120 +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.normalize(param)
-          new(param:).to_param
-        end
-
-        def self.parse(param, **args)
-          new(param:, **args)
-        end
-
-        def initialize(param: nil, column: nil, direction: nil, default: nil)
-          if param.present?
-            column, direction = param.to_s.split
-            direction         = "asc" unless DIRECTIONS.include?(direction)
-          end
-
-          self.column    = column
-          self.direction = direction
-          self.default   = SortForm.normalize(default) if default
-        end
-
-        def to_param
-          "#{column} #{direction}"
-        end
-
-        def default?
-          to_param == default.to_param
-        end
-
-        def hash
-          to_param.hash
-        end
-
-        def eql?(other)
-          to_param == other.to_param
-        end
-
-        alias to_s to_param
-
-        # 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