katalyst-tables 3.4.6 → 3.5.0

data/app/components/katalyst/tables/query/modal_component.rb

@@ -8,6 +8,7 @@ module Katalyst
         include Katalyst::Tables::Frontend
 
         renders_one :footer
+        renders_many :suggestions, SuggestionComponent
 
         attr_reader :collection, :url
 
@@ -17,6 +18,12 @@ module Katalyst
           @collection = collection
         end
 
+        def before_render
+          collection.suggestions.each do |suggestion|
+            with_suggestion(suggestion:)
+          end
+        end
+
         private
 
         def default_html_attributes
@@ -28,68 +35,6 @@ module Katalyst
             },
           }
         end
-
-        using Collection::Type::Helpers::Extensions
-
-        def show_examples?
-          current_key && attributes[current_key]
-        end
-
-        def current_key
-          unless instance_variable_defined?(:@current_key)
-            attributes.each_key do |key|
-              @current_key = key if collection.query_active?(key)
-            end
-          end
-
-          @current_key ||= nil
-        end
-
-        def attributes
-          collection.class.attribute_types
-            .select { |_, a| a.filterable? && a.type != :search }
-            .to_h
-        end
-
-        def available_filters
-          keys = attributes.keys
-
-          if current_token.present?
-            keys = keys.select { |k| k.include?(current_token) }
-          end
-
-          keys.map do |key|
-            [key, collection.model.human_attribute_name(key)]
-          end
-        end
-
-        def examples_for(key)
-          collection.examples_for(key).filter_map do |example|
-            case example
-            when Collection::Type::Example
-              example if example.value.to_s.present?
-            else
-              raise ArgumentError, "Invalid example #{example.inspect} for #{collection.model_name}.#{key}"
-            end
-          end
-        end
-
-        def format_value(value)
-          if /\A[\w.-]*\z/.match?(value.to_s)
-            value.to_s
-          else
-            %("#{value}")
-          end
-        end
-
-        def current_token
-          return nil unless collection.position&.in?(0..collection.query.length)
-
-          prefix = collection.query[...collection.position].match(/\w*\z/)
-          suffix = collection.query[collection.position..].match(/\A\w*/)
-
-          "#{prefix}#{suffix}"
-        end
       end
     end
   end

data/app/components/katalyst/tables/query/suggestion_component.html.erb

@@ -0,0 +1,3 @@
+<%= tag.li(**html_attributes) do %>
+  <span class="value"><%= value %></span>
+<% end %>

data/app/components/katalyst/tables/query/suggestion_component.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Query
+      class SuggestionComponent < ViewComponent::Base
+        include Katalyst::HtmlAttributes
+
+        delegate :type, :value, to: :@suggestion
+
+        def initialize(suggestion:, **)
+          super(**)
+
+          @suggestion = suggestion
+        end
+
+        def default_html_attributes
+          {
+            class: ["suggestion", type.to_s],
+          }
+        end
+
+        private
+
+        def format_value(value)
+          if /\A[\w.-]*\z/.match?(value.to_s)
+            value.to_s
+          else
+            %("#{value}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -86,7 +86,6 @@ module Katalyst
               click->tables--query#openModal:stop
               focusin@window->tables--query#closeModal
               focusin->tables--query#openModal:stop
-              keydown.esc->tables--query#clear:stop
               submit->tables--query#submit
               input->tables--query#update
             ],

data/app/javascript/tables/query_controller.js

@@ -37,11 +37,18 @@ export default class QueryController extends Controller {
     document.addEventListener("selectionchange", this.selection);
   }
 
+  /**
+   * If the user presses escape once, clear the input.
+   * If the user presses escape again, get them out of here.
+   */
   clear() {
     if (this.query.value === "") {
-      // if the user presses escape once, browser clears  the input
-      // if the user presses escape again, get them out of here
       this.closeModal();
+    } else {
+      this.query.value = "";
+      this.query.dispatchEvent(new Event("input"));
+      this.query.dispatchEvent(new Event("change"));
+      this.update();
     }
   }
 
@@ -95,7 +102,7 @@ export default class QueryController extends Controller {
   }
 
   get query() {
-    return this.element.querySelector("input[type=search]");
+    return this.element.querySelector("[role=searchbox]");
   }
 
   get position() {

data/app/javascript/tables/query_input_controller.js

@@ -6,6 +6,11 @@ export default class QueryInputController extends Controller {
 
   connect() {
     this.queryValue = this.inputTarget.value;
+    this.element.dataset.connected = "";
+  }
+
+  disconnect() {
+    delete this.element.dataset.connected;
   }
 
   update() {

data/app/models/concerns/katalyst/tables/collection/query/array_value_parser.rb

@@ -18,6 +18,7 @@ module Katalyst
             query.scan(/#{'\['}\s*/)
 
             until query.eos?
+              @value_start = query.charpos
               break unless take_quoted_value || take_unquoted_value
               break unless take_delimiter
             end
@@ -33,8 +34,25 @@ module Katalyst
             query.scan(/\s*#{','}\s*/)
           end
 
+          def value
+            @value.map(&:value)
+          end
+
           def value=(value)
-            @value << value
+            @value << Value.new(value, @value_start, @query.charpos)
+          end
+
+          def value_at(position)
+            @value.detect { |v| v.range.cover?(position) }&.value
+          end
+
+          class Value
+            attr_accessor :range, :value
+
+            def initialize(value, start, fin)
+              @value = value
+              @range = (start..fin)
+            end
           end
         end
       end

data/app/models/concerns/katalyst/tables/collection/query/parser.rb

@@ -29,6 +29,11 @@ module Katalyst
             self
           end
 
+          def token_at_position(position:)
+            tagged.values.detect { |v| v.range.cover?(position) } ||
+              untagged.detect { |v| v.range.cover?(position) }
+          end
+
           private
 
           def skip_whitespace
@@ -43,31 +48,27 @@ module Katalyst
             key, = query.values_at(1)
             skip_whitespace
 
-            tagged[key] = value_parser(start).parse(query)
+            tagged[key] = value_parser(key, start).parse(query)
           end
 
           def take_untagged
+            start = query.charpos
+
             return unless query.scan(/\S+/)
 
-            untagged << query.matched
+            untagged << UntaggedLiteral.new(value: query.matched, start:)
 
             untagged
           end
 
           using Type::Helpers::Extensions
 
-          def value_parser(start)
+          def value_parser(key, start)
             if query.check(/#{'\['}\s*/)
-              ArrayValueParser.new(start:)
+              ArrayValueParser.new(key:, start:)
             else
-              SingleValueParser.new(start:)
+              SingleValueParser.new(key:, start:)
             end
-
-            # if attribute.type.multiple? || attribute.value.is_a?(::Array)
-            #   ArrayValueParser.new(attribute:, pos:)
-            # else
-            #   SingleValueParser.new(attribute:, pos:)
-            # end
           end
         end
       end

data/app/models/concerns/katalyst/tables/collection/query/single_value_parser.rb

@@ -15,6 +15,8 @@ module Katalyst
           def parse(query)
             @query = query
 
+            @value_start = query.charpos
+
             take_quoted_value || take_unquoted_value
 
             @end = query.charpos
@@ -22,9 +24,17 @@ module Katalyst
             self
           end
 
+          def value
+            @value
+          end
+
           def value=(value)
             @value = value
           end
+
+          def value_at(position)
+            @value if (@value_start..@end).cover?(position)
+          end
         end
       end
     end

data/app/models/concerns/katalyst/tables/collection/query/untagged_literal.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Query
+        class UntaggedLiteral
+          attr_accessor :query, :value
+
+          def initialize(value:, start:)
+            @value = value
+            @start = start
+            @end = start + value.length
+          end
+
+          def literal?
+            true
+          end
+
+          def tagged?
+            false
+          end
+
+          def range
+            @start..@end
+          end
+
+          def to_str
+            @value
+          end
+          alias to_s to_str
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/katalyst/tables/collection/query/value_parser.rb

@@ -5,12 +5,21 @@ module Katalyst
     module Collection
       module Query
         class ValueParser
-          attr_accessor :query, :value
+          attr_accessor :query, :key
 
-          def initialize(start:)
+          def initialize(key:, start:)
+            @key = key
             @start = start
           end
 
+          def literal?
+            false
+          end
+
+          def tagged?
+            true
+          end
+
           def range
             @start..@end
           end

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

@@ -7,6 +7,7 @@ module Katalyst
         extend ActiveSupport::Concern
 
         include Filtering
+        include Suggestions
 
         class_methods do
           def search_attribute
@@ -21,26 +22,13 @@ module Katalyst
         included do
           attribute :q, :query, default: ""
           alias_attribute :query, :q
-
-          attribute :p, :integer, filter: false
-          alias_attribute :position, :p
         end
 
-        using Type::Helpers::Extensions
-
-        def examples_for(key)
-          key = key.to_s
-          examples_method = "#{key.parameterize.underscore}_examples"
-          if respond_to?(examples_method)
-            public_send(examples_method)&.map { |e| e.is_a?(Example) ? e : Example.new(example) }
-          elsif @attributes.key?(key)
-            @attributes[key].type.examples_for(unscoped_items, @attributes[key])
-          end
+        def searchable?
+          self.class.search_attribute.present?
         end
 
-        def query_active?(attribute)
-          @attributes[attribute].query_range&.cover?(position)
-        end
+        using Type::Helpers::Extensions
 
         private
 
@@ -48,19 +36,16 @@ module Katalyst
           result = super
 
           if query_changed?
-            parser = Parser.new(self).parse(query)
+            @query_parser = Parser.new(self).parse(query)
+
+            @query_parser.tagged.each do |k, p|
+              next unless @attributes.key?(k)
 
-            parser.tagged.each do |k, p|
-              if @attributes.key?(k)
-                _assign_attribute(k, p.value)
-                @attributes[k].query_range = p.range
-              else
-                errors.add(k, :unknown)
-              end
+              _assign_attribute(k, p.value)
             end
 
-            if parser.untagged.any? && (search = self.class.search_attribute)
-              _assign_attribute(search, parser.untagged.join(" "))
+            if @query_parser.untagged.any? && (search = self.class.search_attribute)
+              _assign_attribute(search, @query_parser.untagged.map(&:value).join(" "))
             end
           end
 

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Suggestions # :nodoc:
+        extend ActiveSupport::Concern
+
+        included do
+          attribute :p, :integer, filter: false
+          alias_attribute :position, :p
+        end
+
+        using Type::Helpers::Extensions
+
+        def suggestions(position: self.position)
+          query_token = token_at_position(position:)
+
+          attribute = attribute_for_token(query_token:)
+          method    = suggestions_method(attribute) if attribute.present?
+
+          # build a suggestions list
+          suggestions = if method && respond_to?(method)
+                          user_suggestions(attribute:, method:)
+                        elsif attribute
+                          value_suggestions(attribute:)
+                        else
+                          attribute_suggestions(query_token:)
+                        end
+
+          add_context_suggestions(suggestions:, query_token:, attribute:) if query_token
+
+          suggestions
+        end
+
+        private
+
+        def attribute_for_token(query_token:)
+          return unless query_token&.tagged?
+
+          attribute = suggestable_attributes[query_token.key]
+
+          return unless attribute
+
+          # construct an attribute from the input token, so we can focus on what the user is currently typing instead
+          # of searching for the whole input for this attribute (e.g. if we're constructing an array filter)
+          ActiveModel::Attribute.from_user(attribute.name, query_token.value_at(position),
+                                           attribute.type, attribute)
+        end
+
+        # Augments suggestions to ensure the user always has some feedback on their input.
+        def add_context_suggestions(suggestions:, query_token:, attribute:)
+          if query_token.tagged?
+            if !attribute
+              # user has entered a `:` but we don't know the attribute
+              errors.add(:query, :unknown_key, input: query_token.key)
+            elsif suggestions.none?
+              # the user might know more than us about what values are valid
+              suggestions << Tables::Suggestions::SearchValue.new(query_token.value_at(position))
+            end
+          elsif searchable?
+            # user is typing an untagged search term, indicate they can continue
+            suggestions << Tables::Suggestions::SearchValue.new(query_token.value)
+          else
+            errors.add(:query, :no_untagged_search, input: query_token.value)
+          end
+        end
+
+        def attribute_suggestions(query_token:)
+          attributes = suggestable_attributes.values
+
+          if query_token&.literal?
+            attributes = attributes.select { |a| a.name.include?(query_token.value) }
+          end
+
+          attributes.map { |a| Tables::Suggestions::Attribute.new(a.name) }
+        end
+
+        def user_suggestions(attribute:, method:)
+          suggestions = public_send(method, attribute)
+
+          raise TypeError, "Suggestions must be an array" unless suggestions.is_a?(Enumerable)
+
+          suggestions.map do |suggestion|
+            case suggestion
+            when Tables::Suggestions::Base
+              suggestion
+            else
+              Tables::Suggestions::CustomValue.new(suggestion, name: attribute.name, type: attribute.type)
+            end
+          end
+        end
+
+        def value_suggestions(attribute:)
+          attribute.type.suggestions(unscoped_items, attribute)
+        end
+
+        def suggestions_method(attribute)
+          :"#{attribute.name.parameterize.underscore}_suggestions" if attribute.present?
+        end
+
+        def suggestable_attributes
+          @attributes.keys.filter_map do |name|
+            attribute = @attributes[name]
+
+            # skip if the attribute can't generate useful suggestions
+            next unless attribute.type.filterable?
+            next if attribute.type.type == :search
+
+            [name, attribute]
+          end.to_h
+        end
+
+        def token_at_position(position: self.position)
+          @query_parser&.token_at_position(position:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Suggestions
+      class Attribute < Base
+        def type
+          :attribute
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Suggestions
+      class Base
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def type
+          raise NotImplementedError
+        end
+
+        def hash
+          [self.class, value].hash
+        end
+
+        def eql?(other)
+          other.class.eql?(self.class) && other.value.eql?(value)
+        end
+
+        def inspect
+          "#<#{self.class.name} value: #{value.inspect}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Suggestions
+      class ConstantValue < Base
+        delegate :to_param, to: :@attribute_type
+
+        def initialize(name:, type:, model:, column:, value:)
+          super(value)
+
+          @attribute_type = type
+          @model = model
+          @column = column
+          @name = name
+        end
+
+        def type
+          :constant_value
+        end
+
+        def value
+          to_param(@value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Suggestions
+      class CustomValue < Base
+        delegate :to_param, to: :@attribute_type
+
+        def initialize(value, name:, type:)
+          super(value)
+
+          @name = name
+          @attribute_type = type
+        end
+
+        def type
+          :custom_value
+        end
+
+        def value
+          to_param(@value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+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:)
+          super(value)
+
+          @attribute_type = type
+          @model = model
+          @column = column
+          @name = name
+        end
+
+        def type
+          :database_value
+        end
+
+        using Tables::Collection::Type::Helpers::Extensions
+
+        def value
+          if @attribute_type.multiple? && @value.is_a?(Array) && @value.length == 1
+            to_param(@value.first)
+          else
+            to_param(@value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Suggestions
+      class SearchValue < Base
+        def type
+          :search_value
+        end
+      end
+    end
+  end
+end