katalyst-tables 3.6.2 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05aff6fc311793d266ae5a3761941285825a267ac012637cb78a8c388664f73d
-  data.tar.gz: 86ceb51ecfa4ddbfc23a43851623c16b64f490655a02cb4730b0e31a4ed1043a
+  metadata.gz: 5362e93821945472e9bc8c20574ab9325d6273f6f28f673722746ae9fec38f25
+  data.tar.gz: 36035838a96c61dab64a945dcee186771f5f83e74b2e28692d0a7da1558b9ef5
 SHA512:
-  metadata.gz: 1885b0cc4f4f63a2518aaf798af9711d0dd20fbc5bb1644207227c92980855d50fd6e327acade867296a6cd5abb6096b1756622c7d5b29ff8f293c9e1b1eb130
-  data.tar.gz: 15e7961aceb65df747cfe8d65dd18bfeb6cbdc0cae5be03795d44495491188a4eabf1d1b6d57aa8e0ff34e67cc3d81ec13f6182460fe8b57a45da80436567ac6
+  metadata.gz: 576d8272e2a6d5c9c8a8d043e2550191d7fc989f763876287db925b07c9b7336a9044e155ded05d48410331cb37b2bfeddae25dbe0b6e4e244c94932559b80bf
+  data.tar.gz: 6e198574c8eecd43ee24d042a2ef23669142a8c434637285471a7aef6d71f079b27b26e095a9b227356c2c4bfdb6b7cef97e187cd6735fb5596e3f16568fd81f

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [3.7.0]
+
+Adds support for generating filter expressions for self-referencing models.
+
+## [3.6.0]
+
+Keyboard navigation for query suggestions.
+
+## [3.5.0]
+
+Adds a new query input for creating text-based filtering expressions.
+See [query](docs/developers/collections/query.md) for collection extensions and
+[filtering](docs/developers/frontend/filtering.md) for frontend support.
+
+## [3.4.0]
+
+Support for selection columns and bulk actions.
+See [docs](docs/developers/frontend/bulk-actions.md).
+
 ## [3.3.0]
 - Custom types for collections which support extensions for filtering with ranges and arrays.
 

data/app/models/katalyst/tables/suggestions/constant_value.rb

@@ -6,12 +6,10 @@ module Katalyst
       class ConstantValue < Base
         delegate :to_param, to: :@attribute_type
 
-        def initialize(name:, type:, model:, column:, value:)
+        def initialize(name:, type:, value:)
           super(value)
 
           @attribute_type = type
-          @model = model
-          @column = column
           @name = name
         end
 

data/app/models/katalyst/tables/suggestions/database_value.rb

@@ -4,16 +4,12 @@ module Katalyst
   module Tables
     module Suggestions
       class DatabaseValue < Base
-        attr_reader :model, :column
-
         delegate :to_param, to: :@attribute_type
 
-        def initialize(name:, type:, model:, column:, value:)
+        def initialize(name:, type:, value:)
           super(value)
 
           @attribute_type = type
-          @model = model
-          @column = column
           @name = name
         end
 

data/lib/katalyst/tables/collection/type/boolean.rb

@@ -22,16 +22,14 @@ module Katalyst
             end
           end
 
-          def suggestions(scope, attribute)
-            _, model, column = model_and_column_for(scope, attribute)
-
+          def suggestions(_scope, attribute)
             values = %w[true false]
 
             if attribute.value_before_type_cast.present?
               values = values.select { |value| value.include?(attribute.value_before_type_cast) }
             end
 
-            values.map { |v| constant_suggestion(attribute:, model:, column:, value: deserialize(v)) }
+            values.map { |v| constant_suggestion(attribute:, value: deserialize(v)) }
           end
         end
       end

data/lib/katalyst/tables/collection/type/date.rb

@@ -23,14 +23,12 @@ module Katalyst
           end
 
           def suggestions(scope, attribute)
-            _, model, column = model_and_column_for(scope, attribute)
-
             [
               *super(scope, attribute, limit: 6, order: :desc),
-              database_suggestion(attribute:, model:, column:, value: ::Date.current.beginning_of_week..),
-              database_suggestion(attribute:, model:, column:, value: ::Date.current.beginning_of_month..),
-              database_suggestion(attribute:, model:, column:, value: 1.month.ago.all_month),
-              database_suggestion(attribute:, model:, column:, value: 1.year.ago.all_year),
+              database_suggestion(attribute:, value: ::Date.current.beginning_of_week..),
+              database_suggestion(attribute:, value: ::Date.current.beginning_of_month..),
+              database_suggestion(attribute:, value: 1.month.ago.all_month),
+              database_suggestion(attribute:, value: 1.year.ago.all_year),
             ]
           end
 

data/lib/katalyst/tables/collection/type/enum.rb

@@ -16,7 +16,15 @@ module Katalyst
           end
 
           def suggestions(scope, attribute)
-            _, model, column = model_and_column_for(scope, attribute)
+            model = scope.model
+            column = attribute.name
+
+            if attribute.name.include?(".")
+              table_name, column = attribute.name.split(".")
+              model = scope.model.reflections[table_name].klass
+
+              raise(ArgumentError, "Unknown association '#{table_name}' for #{scope.model}") unless model
+            end
 
             raise ArgumentError, "Unknown enum #{column} for #{model}" unless model.defined_enums.has_key?(column)
 
@@ -26,7 +34,7 @@ module Katalyst
               values = values.select { |key| key.include?(attribute.value_before_type_cast) }
             end
 
-            values.map { |value| constant_suggestion(attribute:, model:, column:, value:) }
+            values.map { |value| constant_suggestion(attribute:, value:) }
           end
 
           private

data/lib/katalyst/tables/collection/type/string.rb

@@ -5,8 +5,6 @@ module Katalyst
     module Collection
       module Type
         class String < Value
-          include ActiveRecord::Sanitization::ClassMethods
-
           attr_reader :exact
           alias_method :exact?, :exact
 
@@ -21,11 +19,32 @@ module Katalyst
 
           private
 
-          def filter_condition(model, column, value)
-            if exact? || scope
+          class Match
+            include ActiveRecord::Sanitization::ClassMethods
+
+            attr_reader :value
+
+            def initialize(value)
+              @value = value
+            end
+
+            def to_sql
+              "%#{sanitize_sql_like(value)}%"
+            end
+          end
+
+          class MatchHandler
+            def call(attribute, value)
+              attribute.matches(value.to_sql)
+            end
+          end
+
+          def apply_filter(scope, model, attribute, value)
+            if exact?
               super
             else
-              model.where(model.arel_table[column].matches("%#{sanitize_sql_like(value)}%"))
+              model.predicate_builder.register_handler(Match, MatchHandler.new)
+              scope.where(attribute.name => Match.new(value))
             end
           end
         end

data/lib/katalyst/tables/collection/type/value.rb

@@ -33,10 +33,18 @@ module Katalyst
           def filter(scope, attribute, value: filter_value(attribute))
             return scope unless filter?(attribute, value)
 
-            scope, model, column = model_and_column_for(scope, attribute)
-            condition = filter_condition(model, column, value)
+            if self.scope.present?
+              scope.public_send(self.scope, value)
+            elsif attribute.name.include?(".")
+              table_name, = attribute.name.split(".")
+              association = scope.model.reflections[table_name]
 
-            scope.merge(condition)
+              raise(ArgumentError, "Unknown association '#{table_name}' for #{scope.model}") unless association
+
+              apply_filter(scope.joins(table_name.to_sym), association.klass, attribute, value)
+            else
+              apply_filter(scope, scope.model, attribute, value)
+            end
           end
 
           def to_param(value)
@@ -44,54 +52,51 @@ module Katalyst
           end
 
           def suggestions(scope, attribute, limit: 10, order: :asc)
-            scope, model, column = model_and_column_for(scope, attribute)
+            model = scope.model
+            column = attribute.name
+
+            if attribute.name.include?(".")
+              table_name, column = attribute.name.split(".")
+              model = scope.model.reflections[table_name].klass
+
+              raise(ArgumentError, "Unknown association '#{table_name}' for #{scope.model}") unless model
+
+              scope = scope.joins(table_name.to_sym)
+            end
 
             unless model.attribute_types.has_key?(column)
               raise(ArgumentError, "Unknown column '#{column}' for #{model}. " \
                                    "Consider defining '#{attribute.name.parameterize.underscore}_suggestions'")
             end
 
-            arel_column = model.arel_table[column]
-
             filter(scope, attribute)
-              .group(arel_column)
+              .group(attribute.name)
               .distinct
               .limit(limit)
-              .reorder(arel_column => order)
-              .pluck(arel_column)
-              .map { |v| database_suggestion(attribute:, model:, column:, value: deserialize(v)) }
+              .reorder(attribute.name => order)
+              .pluck(attribute.name)
+              .map { |v| database_suggestion(attribute:, value: deserialize(v)) }
           end
 
           private
 
-          def constant_suggestion(attribute:, model:, column:, value:)
-            Tables::Suggestions::ConstantValue.new(name: attribute.name, type: attribute.type, model:, column:, value:)
+          def constant_suggestion(attribute:, value:)
+            Tables::Suggestions::ConstantValue.new(name: attribute.name, type: attribute.type, value:)
           end
 
-          def database_suggestion(attribute:, model:, column:, value:)
-            Tables::Suggestions::DatabaseValue.new(name: attribute.name, type: attribute.type, model:, column:, value:)
+          def database_suggestion(attribute:, value:)
+            Tables::Suggestions::DatabaseValue.new(name: attribute.name, type: attribute.type, value:)
           end
 
           def filter_value(attribute)
             attribute.value
           end
 
-          def filter_condition(model, column, value)
+          def apply_filter(scope, _model, attribute, value)
             if value.nil?
-              model.none
-            elsif scope
-              model.public_send(scope, value)
-            else
-              model.where(column => serialize(value))
-            end
-          end
-
-          def model_and_column_for(scope, attribute)
-            if attribute.name.include?(".")
-              table, column = attribute.name.split(".")
-              [scope.joins(table.to_sym), scope.model.reflections[table].klass, column]
+              scope.none
             else
-              [scope, scope.model, attribute.name]
+              scope.where(attribute.name => serialize(value))
             end
           end
         end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 3.6.2
+  version: 3.7.0
 platform: ruby
 authors:
 - Katalyst Interactive
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-06 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: katalyst-html-attributes
@@ -175,7 +174,6 @@ 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: 
 rdoc_options: []
 require_paths:
 - lib
@@ -190,8 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: HTML table generator for Rails views
 test_files: []