katalyst-tables 3.3.0 → 3.3.2

data/app/javascript/tables/query_input_controller.js

@@ -0,0 +1,228 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class QueryInputController extends Controller {
+  static targets = ["input", "highlight"];
+  static values = { query: String };
+
+  connect() {
+    this.queryValue = this.inputTarget.value;
+  }
+
+  update() {
+    this.queryValue = this.inputTarget.value;
+  }
+
+  queryValueChanged(query) {
+    this.highlightTarget.innerHTML = "";
+
+    new Parser().parse(query).tokens.forEach((token) => {
+      this.highlightTarget.appendChild(token.render());
+    });
+  }
+}
+
+class Parser {
+  constructor() {
+    this.tokens = [];
+    this.values = null;
+  }
+
+  parse(input) {
+    const query = new StringScanner(input);
+
+    while (!query.isEos()) {
+      this.push(this.skipWhitespace(query));
+
+      const value = this.takeTagged(query) || this.takeUntagged(query);
+
+      if (!this.push(value)) break;
+    }
+
+    return this;
+  }
+
+  push(token) {
+    if (token) {
+      this.values ? this.values.push(token) : this.tokens.push(token);
+    }
+
+    return !!token;
+  }
+
+  skipWhitespace(query) {
+    if (!query.scan(/\s+/)) return;
+
+    return new Token(query.matched());
+  }
+
+  takeUntagged(query) {
+    if (!query.scan(/\S+/)) return;
+
+    return new Untagged(query.matched());
+  }
+
+  takeTagged(query) {
+    if (!query.scan(/(\w+(?:\.\w+)?)(:\s*)/)) return;
+
+    const key = query.valueAt(1);
+    const separator = query.valueAt(2);
+
+    const value =
+      this.takeArrayValue(query) || this.takeSingleValue(query) || new Token();
+
+    return new Tagged(key, separator, value);
+  }
+
+  takeArrayValue(query) {
+    if (!query.scan(/\[\s*/)) return;
+
+    const start = new Token(query.matched());
+    const values = (this.values = []);
+
+    while (!query.isEos()) {
+      if (!this.push(this.takeSingleValue(query))) break;
+      if (!this.push(this.takeDelimiter(query))) break;
+    }
+
+    query.scan(/\s*]/);
+    const end = new Token(query.matched());
+
+    this.values = null;
+
+    return new Array(start, values, end);
+  }
+
+  takeDelimiter(query) {
+    if (!query.scan(/\s*,\s*/)) return;
+
+    return new Token(query.matched());
+  }
+
+  takeSingleValue(query) {
+    return this.takeQuotedValue(query) || this.takeUnquotedValue(query);
+  }
+
+  takeQuotedValue(query) {
+    if (!query.scan(/"([^"]*)"/)) return;
+
+    return new Value(query.matched());
+  }
+
+  takeUnquotedValue(query) {
+    if (!query.scan(/[^ \],]*/)) return;
+
+    return new Value(query.matched());
+  }
+}
+
+class Token {
+  constructor(value = "") {
+    this.value = value;
+  }
+
+  render() {
+    return document.createTextNode(this.value);
+  }
+}
+
+class Value extends Token {
+  render() {
+    const span = document.createElement("span");
+    span.className = "value";
+    span.innerText = this.value;
+
+    return span;
+  }
+}
+
+class Tagged extends Token {
+  constructor(key, separator, value) {
+    super();
+
+    this.key = key;
+    this.separator = separator;
+    this.value = value;
+  }
+
+  render() {
+    const span = document.createElement("span");
+    span.className = "tag";
+
+    const key = document.createElement("span");
+    key.className = "key";
+    key.innerText = this.key;
+
+    span.appendChild(key);
+    span.appendChild(document.createTextNode(this.separator));
+    span.appendChild(this.value.render());
+
+    return span;
+  }
+}
+
+class Untagged extends Token {
+  render() {
+    const span = document.createElement("span");
+    span.className = "untagged";
+    span.innerText = this.value;
+    return span;
+  }
+}
+
+class Array extends Token {
+  constructor(start, values, end) {
+    super();
+
+    this.start = start;
+    this.values = values;
+    this.end = end;
+  }
+
+  render() {
+    const array = document.createElement("span");
+    array.className = "array-values";
+    array.appendChild(this.start.render());
+
+    this.values.forEach((value) => {
+      const span = document.createElement("span");
+      span.appendChild(value.render());
+      array.appendChild(span);
+    });
+
+    array.appendChild(this.end.render());
+
+    return array;
+  }
+}
+
+class StringScanner {
+  constructor(input) {
+    this.input = input;
+    this.position = 0;
+    this.last = null;
+  }
+
+  isEos() {
+    return this.position >= this.input.length;
+  }
+
+  scan(regex) {
+    const match = regex.exec(this.input.substring(this.position));
+    if (match?.index === 0) {
+      this.last = match;
+      this.position += match[0].length;
+      return true;
+    } else {
+      this.last = {};
+      return false;
+    }
+  }
+
+  matched() {
+    return this.last && this.last[0];
+  }
+
+  valueAt(index) {
+    return this.last && this.last[index];
+  }
+}

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

@@ -46,7 +46,7 @@ module Katalyst
         end
 
         included do
-          attr_accessor :items
+          attr_accessor :items, :unscoped_items
 
           delegate :each, :count, :empty?, to: :items, allow_nil: true
         end
@@ -73,7 +73,7 @@ module Katalyst
         end
 
         def apply(items)
-          @items = items
+          @unscoped_items = @items = items
           reducers.build do |_|
             filter
             self
@@ -86,7 +86,9 @@ module Katalyst
         end
 
         def filters
-          changes.except("sort", "page", "query").transform_values(&:second)
+          changes
+            .select { |k, _| self.class._default_attributes[k].type.filterable? }
+            .transform_values(&:second)
         end
 
         def model

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

@@ -5,49 +5,36 @@ module Katalyst
     module Collection
       module Query
         class ArrayValueParser < ValueParser
+          def initialize(...)
+            super
+
+            @value = []
+          end
+
           # @param query [StringScanner]
           def parse(query)
             @query = query
 
-            skip_whitespace
-
-            if query.scan(/#{'\['}/)
-              take_values
-            else
-              take_value
-            end
-          end
+            query.scan(/#{'\['}\s*/)
 
-          def take_values
             until query.eos?
-              skip_whitespace
               break unless take_quoted_value || take_unquoted_value
-
-              skip_whitespace
               break unless take_delimiter
             end
 
-            skip_whitespace
-            take_end_of_list
-          end
+            query.scan(/\s*#{'\]'}?/)
 
-          def take_value
-            take_quoted_value || take_unquoted_value
-          end
+            @end = query.charpos
 
-          def take_delimiter
-            query.scan(/#{','}/)
+            self
           end
 
-          def take_end_of_list
-            query.scan(/#{']'}/)
+          def take_delimiter
+            query.scan(/\s*#{','}\s*/)
           end
 
           def value=(value)
-            return if @attribute.type_cast(value).nil? # undefined attribute
-
-            current = @collection.attributes[@attribute.name]
-            @collection.assign_attributes(@attribute.name => current + [value])
+            @value << value
           end
         end
       end

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

@@ -7,11 +7,12 @@ module Katalyst
         class Parser # :nodoc:
           # query [StringScanner]
           attr_accessor :query
-          attr_reader :collection, :untagged
+          attr_reader :collection, :untagged, :tagged
 
           def initialize(collection)
             @collection = collection
-            @untagged   = []
+            @tagged = {}
+            @untagged = []
           end
 
           # @param query [String]
@@ -25,10 +26,6 @@ module Katalyst
               break unless take_tagged || take_untagged
             end
 
-            if untagged.any? && (search = collection.class.search_attribute)
-              collection.assign_attributes(search => untagged.join(" "))
-            end
-
             self
           end
 
@@ -39,12 +36,14 @@ module Katalyst
           end
 
           def take_tagged
+            start = query.charpos
+
             return unless query.scan(/(\w+(\.\w+)?):/)
 
             key, = query.values_at(1)
             skip_whitespace
 
-            parser_for(key).parse(query)
+            tagged[key] = value_parser(start).parse(query)
           end
 
           def take_untagged
@@ -57,14 +56,18 @@ module Katalyst
 
           using Type::Helpers::Extensions
 
-          def parser_for(key)
-            attribute = collection.class._default_attributes[key]
-
-            if attribute.type.multiple? || attribute.value.is_a?(::Array)
-              ArrayValueParser.new(collection:, attribute:)
+          def value_parser(start)
+            if query.check(/#{'\['}\s*/)
+              ArrayValueParser.new(start:)
             else
-              SingleValueParser.new(collection:, attribute:)
+              SingleValueParser.new(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

@@ -5,17 +5,25 @@ module Katalyst
     module Collection
       module Query
         class SingleValueParser < ValueParser
+          def initialize(...)
+            super
+
+            @value = nil
+          end
+
           # @param query [StringScanner]
           def parse(query)
             @query = query
 
             take_quoted_value || take_unquoted_value
+
+            @end = query.charpos
+
+            self
           end
 
           def value=(value)
-            return if @attribute.type_cast(value).nil? # undefined attribute
-
-            @collection.assign_attributes(@attribute.name => value)
+            @value = value
           end
         end
       end

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

@@ -5,11 +5,14 @@ module Katalyst
     module Collection
       module Query
         class ValueParser
-          attr_accessor :query
+          attr_accessor :query, :value
 
-          def initialize(collection:, attribute:)
-            @collection = collection
-            @attribute  = attribute
+          def initialize(start:)
+            @start = start
+          end
+
+          def range
+            @start..@end
           end
 
           def take_quoted_value
@@ -19,7 +22,9 @@ module Katalyst
           end
 
           def take_unquoted_value
-            return unless query.scan(/([^" \],]*)/)
+            # note, we allow unquoted values to begin with a " so that partial
+            # inputs can be accepted
+            return unless query.scan(/"?([^ \],]*)/)
 
             self.value, = query.values_at(1)
           end

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

@@ -13,20 +13,58 @@ module Katalyst
             _default_attributes.each_value do |attribute|
               return attribute.name if attribute.type.type == :search
             end
+
+            nil
           end
         end
 
         included do
-          attribute :query, :query, default: ""
+          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
+          values_method = "#{key.parameterize.underscore}_values"
+          if respond_to?(values_method)
+            public_send(values_method)
+          elsif @attributes.key?(key)
+            @attributes[key].type.examples_for(unscoped_items, @attributes[key])
+          end
+        end
 
-          # Note: this is defined inline so that we can overwrite query=
-          def query=(value)
-            query = super
+        def query_active?(attribute)
+          @attributes[attribute].query_range&.cover?(position)
+        end
+
+        private
 
-            Parser.new(self).parse(query)
+        def _assign_attributes(new_attributes)
+          result = super
 
-            query
+          if query_changed?
+            parser = Parser.new(self).parse(query)
+
+            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
+            end
+
+            if parser.untagged.any? && (search = self.class.search_attribute)
+              _assign_attribute(search, parser.untagged.join(" "))
+            end
           end
+
+          result
         end
       end
     end

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

@@ -35,6 +35,16 @@ module Katalyst
               { column:, direction: }
             end
           end
+
+          refine Symbol do
+            def to_param
+              to_s.to_param
+            end
+
+            def to_h
+              to_s.to_h
+            end
+          end
         end
 
         using SortParams
@@ -116,7 +126,7 @@ module Katalyst
 
             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)
+            elsif collection.model.has_attribute?(column)
               collection.items = collection.items.reorder(column => direction)
             end
 

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

@@ -48,6 +48,16 @@ module Katalyst
           self
         end
 
+        def apply(items)
+          if items.is_a?(Class) && items < ActiveRecord::Base
+            super(items.all)
+          elsif items.is_a?(ActiveRecord::Relation)
+            super
+          else
+            raise ArgumentError, "Collection requires an ActiveRecord scope, given #{items.class}"
+          end
+        end
+
         def inspect
           "#<#{self.class.name} @attributes=#{attributes.inspect} @model_name=\"#{model_name}\" @count=#{items&.count}>"
         end

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

@@ -69,6 +69,16 @@ module Katalyst
           end
         end
 
+        def apply(items)
+          if items.is_a?(Class) && items < ActiveRecord::Base
+            super(items.all)
+          elsif items.is_a?(ActiveRecord::Relation)
+            super
+          else
+            raise ArgumentError, "Collection requires an ActiveRecord scope, given #{items.class}"
+          end
+        end
+
         def inspect
           "#<#{self.class.name} @param_key=#{param_key.inspect} " +
             "@attributes=#{attributes.inspect} @model=\"#{model}\" @count=#{items&.count}>"

data/app/models/katalyst/tables/collection/type/boolean.rb

@@ -13,7 +13,17 @@ module Katalyst
           end
 
           def filter?(attribute, value)
-            (!value.nil? && !value.eql?([])) || attribute.came_from_user?
+            return false unless filterable?
+
+            if attribute.came_from_user?
+              attribute.value_before_type_cast.present? || value === false
+            else
+              !value.nil? && !value.eql?([])
+            end
+          end
+
+          def examples_for(...)
+            [true, false]
           end
         end
       end

data/app/models/katalyst/tables/collection/type/date.rb

@@ -5,44 +5,41 @@ module Katalyst
     module Collection
       module Type
         class Date < Value
+          include Helpers::Range
+
+          define_range_patterns /\d{4}-\d\d-\d\d/
+
           def type
             :date
           end
 
           def serialize(value)
-            if value.is_a?(Date)
+            if value.is_a?(::Date)
               value.to_fs(:db)
-            elsif value.is_a?(Range)
-              if value.begin.nil?
-                "<#{value.end.to_fs(:db)}"
-              elsif value.end.nil?
-                ">#{value.begin.to_fs(:db)}"
-              else
-                "#{value.begin.to_fs(:db)}..#{value.end.to_fs(:db)}"
-              end
             else
-              value.to_s
+              super
             end
           end
 
+          def examples_for(...)
+            [
+              ::Date.current,
+              ::Date.yesterday,
+              ::Date.current.beginning_of_week..,
+              ::Date.current.beginning_of_month..,
+              ::Date.current.beginning_of_year..,
+            ].map { |d| serialize(d) }
+          end
+
           private
 
-          ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-          LOWER_BOUND = /\A>(\d{4})-(\d\d)-(\d\d)\z/
-          UPPER_BOUND = /\A<(\d{4})-(\d\d)-(\d\d)\z/
-          BOUNDED = /\A(\d{4})-(\d\d)-(\d\d)\.\.(\d{4})-(\d\d)-(\d\d)\z/
+          ISO_DATE = /\A(?<year>\d{4})-(?<month>\d\d)-(?<day>\d\d)\z/
 
           def cast_value(value)
             return value unless value.is_a?(::String)
 
-            if value =~ ISO_DATE
-              new_date($1.to_i, $2.to_i, $3.to_i)
-            elsif value =~ LOWER_BOUND
-              (new_date($1.to_i, $2.to_i, $3.to_i)..)
-            elsif value =~ UPPER_BOUND
-              (..new_date($1.to_i, $2.to_i, $3.to_i))
-            elsif value =~ BOUNDED
-              (new_date($1.to_i, $2.to_i, $3.to_i)..new_date($4.to_i, $5.to_i, $6.to_i))
+            if /\A(?<year>\d{4})-(?<month>\d\d)-(?<day>\d\d)\z/ =~ value
+              new_date(year.to_i, month.to_i, day.to_i)
             end
           end
 

data/app/models/katalyst/tables/collection/type/enum.rb

@@ -14,6 +14,17 @@ module Katalyst
           def type
             :enum
           end
+
+          def examples_for(scope, attribute)
+            _, model, column = model_and_column_for(scope, attribute)
+            keys = model.defined_enums[column]&.keys
+
+            if attribute.value_before_type_cast.present?
+              keys.select { |key| key.include?(attribute.value_before_type_cast.last) }
+            else
+              keys
+            end
+          end
         end
       end
     end