ransack 4.1.1 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbeb7a329e22aabf90d2336f563ebfa162e0fa4a085fa5271896ed106d2d6612
-  data.tar.gz: e65a2f50206b930faaf7d5fd554830c553fc0050777f98f493de8e99940e3c78
+  metadata.gz: 4fe4a128cacdb920f2efe5fc5063cd21b8fa1a4a527fa07e84123f2ead7a6694
+  data.tar.gz: 82f66ffeaa4d8bed52614374fe71617bb1c2d85ac1745dfca7e4520e07782545
 SHA512:
-  metadata.gz: 1c0ece8ec2de53c780769d572369442c93b0c4769fe8394baa32ad87d4ae2b7a2fdc66b2f1227499b7a07df80f24d3cf0671a72a33c988fe43c926e37a42dbe1
-  data.tar.gz: fa6ba91dab6d66369595b8ddee0e46c80b5f1103ca179f67c0be75f78109555a15f784448441fb04c9d8f3afba92c04e56962d77eb4cc4870cff0ecc61f49a1e
+  metadata.gz: a80ce4b0da981c6e3b2d18de8c742d3598a2a7479b44d04adaa1ce3c60a81fa4377f706c78048c1d72f719d488afd379c303b55811053d8613eb82cf0f0dfcad
+  data.tar.gz: cd3f836f63aa19596a3510961bbe64a1f9abcc858473bf9516623e5fe76908bcbb346d36cf1cd7cb83094f0a3c0f4bcdb942b0e137a9020cd8772e28d01d9f51

data/README.md

@@ -13,7 +13,7 @@ There are advanced searching solutions around, like ElasticSearch or Algolia. **
 
 Ready to move beyond the basics? Use **advanced features** like i18n and extensive configuration options.
 
-Ransack is supported for Rails 7.0, 6.1 on Ruby 3.0 and later.
+Ransack is supported for Rails 8.0, 7.2, 7.1 on Ruby 3.1 and later.
 
 ## Installation
 
@@ -33,9 +33,11 @@ gem 'ransack', :github => 'activerecord-hackery/ransack', :branch => 'main'
 
 ### Documentation
 
-There is [extensive documentation on Ransack](https://activerecord-hackery.github.io/ransack/), which is a [Docusaurus](https://docusaurus.io/) project and run as a GitHub Pages site.
+There is [extensive documentation on Ransack](https://activerecord-hackery.github.io/ransack/), which is a [Docusaurus](https://docusaurus.io/) project and run as a GitHub Pages site. Alternatively there is [AI Generated documentation](https://deepwiki.com/activerecord-hackery/ransack/1-overview) produced by [devin.ai](https://devin.ai/).
 
-## Issues tracker
+This [gist](https://gist.github.com/raghubetina/d5fc3df67ddbadcac271) has a quick-start cheatsheet, created by [@raghubetina](https://gist.github.com/raghubetina)
+
+## Issue tracker
 
 * Before filing an issue, please read the [Contributing Guide](CONTRIBUTING.md).
 * File an issue if a bug is caused by Ransack, is new (has not already been reported), and _can be reproduced from the information you provide_.

data/lib/polyamorous/activerecord/join_association_7_2.rb

@@ -0,0 +1,55 @@
+module Polyamorous
+  module JoinAssociationExtensions
+    # Same as #join_constraints, but instead of constructing tables from the
+    # given block, uses the ones passed
+    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
+      joins = []
+      chain = []
+
+      reflection.chain.each.with_index do |reflection, i|
+        table = tables[i]
+
+        @table ||= table
+        chain << [reflection, table]
+      end
+
+      base_klass.with_connection do |connection|
+        # The chain starts with the target table, but we want to end with it here (makes
+        # more sense in this context), so we reverse
+        chain.reverse_each do |reflection, table|
+          klass = reflection.klass
+
+          join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+          unless join_scope.references_values.empty?
+            join_dependency = join_scope.construct_join_dependency(
+              join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+            )
+            join_scope.joins!(join_dependency)
+          end
+
+          arel = join_scope.arel(alias_tracker.aliases)
+          nodes = arel.constraints.first
+
+          if nodes.is_a?(Arel::Nodes::And)
+            others = nodes.children.extract! do |node|
+              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+            end
+          end
+
+          joins << table.create_join(table, table.create_on(nodes), join_type)
+
+          if others && !others.empty?
+            joins.concat arel.join_sources
+            append_constraints(connection, joins.last, others)
+          end
+
+          # The current table in this iteration becomes the foreign table in the next
+          foreign_table, foreign_klass = table, klass
+        end
+
+        joins
+      end
+    end
+  end
+end

data/lib/polyamorous/polyamorous.rb

@@ -1,4 +1,4 @@
-if defined?(::ActiveRecord)
+ActiveSupport.on_load(:active_record) do
   module Polyamorous
     InnerJoin = Arel::Nodes::InnerJoin
     OuterJoin = Arel::Nodes::OuterJoin
@@ -15,6 +15,10 @@ if defined?(::ActiveRecord)
   require 'polyamorous/activerecord/join_dependency'
   require 'polyamorous/activerecord/reflection'
 
+  if ::ActiveRecord.version >= ::Gem::Version.new("7.2") && ::ActiveRecord.version < ::Gem::Version.new("7.2.2.1")
+    require "polyamorous/activerecord/join_association_7_2"
+  end
+
   ActiveRecord::Reflection::AbstractReflection.send(:prepend, Polyamorous::ReflectionExtensions)
 
   Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)

data/lib/ransack/adapters/active_record/context.rb

@@ -19,7 +19,8 @@ module Ransack
           unless schema_cache.send(:data_source_exists?, table)
             raise "No table named #{table} exists."
           end
-          attr.klass.columns.find { |column| column.name == name }.type
+          column = attr.klass.columns.find { |column| column.name == name }
+          column&.type
         end
 
         def evaluate(search, opts = {})
@@ -110,7 +111,7 @@ module Ransack
         #
         def join_sources
           base, joins = begin
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, @object.table.name, [])
+            alias_tracker = @object.alias_tracker
             constraints   = @join_dependency.join_constraints(@object.joins_values, alias_tracker, @object.references_values)
 
             [
@@ -171,7 +172,25 @@ module Ransack
           join_constraints.each do |j|
             subquery.join_sources << Arel::Nodes::InnerJoin.new(j.left, j.right)
           end
-          subquery.where(correlated_key.eq(primary_key))
+
+          # Handle polymorphic associations where correlated_key is an array
+          if correlated_key.is_a?(Array)
+            # For polymorphic associations, we need to add conditions for both the foreign key and type
+            correlated_key.each_with_index do |key, index|
+              if index == 0
+                # This is the foreign key
+                subquery = subquery.where(key.eq(primary_key))
+              else
+                # This is the type key, which should be equal to the model name
+                subquery = subquery.where(key.eq(@klass.name))
+              end
+            end
+          else
+            # Original behavior for non-polymorphic associations
+            subquery = subquery.where(correlated_key.eq(primary_key))
+          end
+
+          subquery
         end
 
         def primary_key
@@ -201,7 +220,15 @@ module Ransack
               nil
             end
           when Arel::Nodes::And
-            extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
+            # And may have multiple children, so we need to check all, not via left/right
+            if join_root.children.any?
+              join_root.children.each do |child|
+                key = extract_correlated_key(child)
+                return key if key
+              end
+            else
+              extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
+            end
           else
             # eg parent was Arel::Nodes::And and the evaluated side was one of
             # Arel::Nodes::Grouping or MultiTenant::TenantEnforcementClause
@@ -278,7 +305,7 @@ module Ransack
 
           join_list = join_nodes + convert_join_strings_to_ast(relation.table, string_joins)
 
-          alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
+          alias_tracker = relation.alias_tracker(join_list)
           join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, Arel::Nodes::OuterJoin)
           join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
           join_nodes.each do |join|

data/lib/ransack/constants.rb

@@ -165,7 +165,7 @@ module Ransack
       when "Mysql2".freeze
         # Necessary for MySQL
         unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
-      when "PostgreSQL".freeze
+      when "PostGIS".freeze, "PostgreSQL".freeze
         # Necessary for PostgreSQL
         unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
       else

data/lib/ransack/context.rb

@@ -77,6 +77,9 @@ module Ransack
       return unless @klass.method(scope) && args != false
       @object = if scope_arity(scope) < 1 && args == true
                   @object.public_send(scope)
+                elsif scope_arity(scope) == 1 && args.is_a?(Array)
+                  # For scopes with arity 1, pass the array as a single argument instead of splatting
+                  @object.public_send(scope, args)
                 else
                   @object.public_send(scope, *args)
                 end
@@ -152,16 +155,16 @@ module Ransack
     end
 
     def ransackable_alias(str)
-      klass._ransack_aliases.fetch(str, str)
+      klass._ransack_aliases.fetch(str, klass._ransack_aliases.fetch(str.to_sym, str))
     end
 
     def ransackable_attribute?(str, klass)
-      klass.ransackable_attributes(auth_object).include?(str) ||
-        klass.ransortable_attributes(auth_object).include?(str)
+      klass.ransackable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym } ||
+        klass.ransortable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym }
     end
 
     def ransackable_association?(str, klass)
-      klass.ransackable_associations(auth_object).include? str
+      klass.ransackable_associations(auth_object).any? { |s| s.to_sym == str.to_sym }
     end
 
     def ransackable_scope?(str, klass)

data/lib/ransack/helpers/form_builder.rb

@@ -6,13 +6,12 @@ module ActionView::Helpers::Tags
   # https://github.com/rails/rails/commit/c1a118a
   class Base
     private
-    if defined? ::ActiveRecord
-      def value
-        if @allow_method_names_outside_object
-          object.send @method_name if object && object.respond_to?(@method_name, true)
-        else
-          object.send @method_name if object
-        end
+
+    def value
+      if @allow_method_names_outside_object
+        object.send @method_name if object && object.respond_to?(@method_name, true)
+      else
+        object.send @method_name if object
       end
     end
   end

data/lib/ransack/helpers/form_helper.rb

@@ -7,30 +7,48 @@ module Ransack
       #   <%= search_form_for(@q) do |f| %>
       #
       def search_form_for(record, options = {}, &proc)
-        if record.is_a? Ransack::Search
-          search = record
-          options[:url] ||= polymorphic_path(
-            search.klass, format: options.delete(:format)
-            )
-        elsif record.is_a?(Array) &&
-        (search = record.detect { |o| o.is_a?(Ransack::Search) })
-          options[:url] ||= polymorphic_path(
-            options_for(record), format: options.delete(:format)
-            )
+        search = extract_search_and_set_url(record, options, 'search_form_for')
+        options[:html] ||= {}
+        html_options = build_html_options(search, options, :get)
+        finalize_form_options(options, html_options)
+        form_for(record, options, &proc)
+      end
+
+      # +search_form_with+
+      #
+      #   <%= search_form_with(model: @q) do |f| %>
+      #
+      def search_form_with(record_or_options = {}, options = {}, &proc)
+        if record_or_options.is_a?(Hash) && record_or_options.key?(:model)
+          # Called with keyword arguments: search_form_with(model: @q)
+          options = record_or_options
+          record = options.delete(:model)
         else
-          raise ArgumentError,
-          'No Ransack::Search object was provided to search_form_for!'
+          # Called with positional arguments: search_form_with(@q)
+          record = record_or_options
         end
+        search = extract_search_and_set_url(record, options, 'search_form_with')
         options[:html] ||= {}
-        html_options = {
-          class:  html_option_for(options[:class], search),
-          id:     html_option_for(options[:id], search),
-          method: :get
-        }
-        options[:as] ||= Ransack.options[:search_key]
-        options[:html].reverse_merge!(html_options)
-        options[:builder] ||= FormBuilder
+        html_options = build_html_options(search, options, :get)
+        finalize_form_with_options(options, html_options)
+        form_with(model: search, **options, &proc)
+      end
 
+      # +turbo_search_form_for+
+      #
+      #   <%= turbo_search_form_for(@q) do |f| %>
+      #
+      # This is a turbo-enabled version of search_form_for that submits via turbo streams
+      # instead of traditional HTML GET requests. Useful for seamless integration with
+      # paginated results and other turbo-enabled components.
+      #
+      def turbo_search_form_for(record, options = {}, &proc)
+        search = extract_search_and_set_url(record, options, 'turbo_search_form_for')
+        options[:html] ||= {}
+        turbo_options = build_turbo_options(options)
+        method = options.delete(:method) || :post
+        html_options = build_html_options(search, options, method).merge(turbo_options)
+        finalize_form_options(options, html_options)
         form_for(record, options, &proc)
       end
 
@@ -68,6 +86,54 @@ module Ransack
 
       private
 
+        def extract_search_and_set_url(record, options, method_name)
+          if record.is_a? Ransack::Search
+            search = record
+            options[:url] ||= polymorphic_path(
+              search.klass, format: options.delete(:format)
+            )
+            search
+          elsif record.is_a?(Array) &&
+          (search = record.detect { |o| o.is_a?(Ransack::Search) })
+            options[:url] ||= polymorphic_path(
+              options_for(record), format: options.delete(:format)
+            )
+            search
+          else
+            raise ArgumentError,
+            "No Ransack::Search object was provided to #{method_name}!"
+          end
+        end
+
+        def build_turbo_options(options)
+          data_options = {}
+          if options[:turbo_frame]
+            data_options[:turbo_frame] = options.delete(:turbo_frame)
+          end
+          data_options[:turbo_action] = options.delete(:turbo_action) || 'advance'
+          { data: data_options }
+        end
+
+        def build_html_options(search, options, method)
+          {
+            class:  html_option_for(options[:class], search),
+            id:     html_option_for(options[:id], search),
+            method: method
+          }
+        end
+
+        def finalize_form_options(options, html_options)
+          options[:as] ||= Ransack.options[:search_key]
+          options[:html].reverse_merge!(html_options)
+          options[:builder] ||= FormBuilder
+        end
+
+        def finalize_form_with_options(options, html_options)
+          options[:scope] ||= Ransack.options[:search_key]
+          options[:html].reverse_merge!(html_options)
+          options[:builder] ||= FormBuilder
+        end
+
         def options_for(record)
           record.map { |r| parse_record(r) }
         end

data/lib/ransack/invalid_search_error.rb

@@ -0,0 +1,3 @@
+module Ransack
+  class InvalidSearchError < ArgumentError; end
+end

data/lib/ransack/locale/ja.yml

@@ -14,57 +14,57 @@ ja:
     asc: "昇順"
     desc: "降順"
     predicates:
-      eq: "は以下と等しい"
-      eq_any: "は以下のいずれかに等しい"
-      eq_all: "は以下の全てに等しい"
-      not_eq: "は以下と等しくない"
-      not_eq_any: "は以下のいずれかに等しくない"
-      not_eq_all: "は以下の全てと等しくない"
-      matches: "は以下と合致している"
-      matches_any: "は以下のいずれかと合致している"
-      matches_all: "は以下の全てと合致している"
-      does_not_match: "は以下と合致していない"
-      does_not_match_any: "は以下のいずれかに合致していない"
-      does_not_match_all: "は以下の全てに合致していない"
-      lt: "は以下よりも小さい"
-      lt_any: "は以下のいずれかより小さい"
-      lt_all: "は以下の全てよりも小さい"
-      lteq: "は以下より小さいか等しい"
-      lteq_any: "は以下のいずれかより小さいか等しい"
-      lteq_all: "は以下の全てより小さいか等しい"
-      gt: "は以下より大きい"
-      gt_any: "は以下のいずれかより大きい"
-      gt_all: "は以下の全てより大きい"
-      gteq: "は以下より大きいか等しい"
-      gteq_any: "は以下のいずれかより大きいか等しい"
-      gteq_all: "は以下の全てより大きいか等しい"
-      in: "は以下の範囲内である"
-      in_any: "は以下のいずれかの範囲内である"
-      in_all: "は以下の全ての範囲内である"
-      not_in: "は以下の範囲内でない"
-      not_in_any: "は以下のいずれかの範囲内でない"
-      not_in_all: "は以下の全ての範囲内"
-      cont: "は以下を含む"
-      cont_any: "はいずれかを含む"
-      cont_all: "は以下の全てを含む"
-      not_cont: "は含まない"
-      not_cont_any: "は以下のいずれかを含まない"
-      not_cont_all: "は以下の全てを含まない"
-      start: "は以下で始まる"
-      start_any: "は以下のどれかで始まる"
-      start_all: "は以下の全てで始まる"
-      not_start: "は以下で始まらない"
-      not_start_any: "は以下のいずれかで始まらない"
-      not_start_all: "は以下の全てで始まらない"
-      end: "は以下で終わる"
-      end_any: "は以下のいずれかで終わる"
-      end_all: "は以下の全てで終わる"
-      not_end: "は以下のどれでも終わらない"
-      not_end_any: "は以下のいずれかで終わらない"
-      not_end_all: "は以下の全てで終わらない"
+      eq: "等しい"
+      eq_any: "いずれかに等しい"
+      eq_all: "全てに等しい"
+      not_eq: "等しくない"
+      not_eq_any: "いずれかに等しくない"
+      not_eq_all: "全てと等しくない"
+      matches: "合致している"
+      matches_any: "いずれかと合致している"
+      matches_all: "全てと合致している"
+      does_not_match: "合致していない"
+      does_not_match_any: "いずれかに合致していない"
+      does_not_match_all: "全てに合致していない"
+      lt: "小さい"
+      lt_any: "いずれかより小さい"
+      lt_all: "全てよりも小さい"
+      lteq: "小さいか等しい"
+      lteq_any: "いずれかより小さいか等しい"
+      lteq_all: "全てより小さいか等しい"
+      gt: "大きい"
+      gt_any: "いずれかより大きい"
+      gt_all: "全てより大きい"
+      gteq: "大きいか等しい"
+      gteq_any: "いずれかより大きいか等しい"
+      gteq_all: "全てより大きいか等しい"
+      in: "範囲内である"
+      in_any: "いずれかの範囲内である"
+      in_all: "全ての範囲内である"
+      not_in: "範囲内でない"
+      not_in_any: "いずれかの範囲内でない"
+      not_in_all: "全ての範囲内"
+      cont: "含む"
+      cont_any: "いずれかを含む"
+      cont_all: "全てを含む"
+      not_cont: "含まない"
+      not_cont_any: "いずれかを含まない"
+      not_cont_all: "全てを含まない"
+      start: "始まる"
+      start_any: "どれかで始まる"
+      start_all: "全てで始まる"
+      not_start: "始まらない"
+      not_start_any: "いずれかで始まらない"
+      not_start_all: "全てで始まらない"
+      end: "終わる"
+      end_any: "いずれかで終わる"
+      end_all: "全てで終わる"
+      not_end: "どれでも終わらない"
+      not_end_any: "いずれかで終わらない"
+      not_end_all: "全てで終わらない"
       'true': "真"
       'false': "偽"
-      present: "は存在する"
-      blank: "は空である"
+      present: "存在する"
+      blank: "空である"
       'null': "無効"
-      not_null: "は無効ではない"
+      not_null: "無効ではない"

data/lib/ransack/locale/ko.yml

@@ -0,0 +1,70 @@
+ko:
+  ransack:
+    search: "검색"
+    predicate: "조건"
+    and: "그리고"
+    or: "또는"
+    any: "어떤 것이든"
+    all: "모두"
+    combinator: "조합기"
+    attribute: "속성"
+    value: "값"
+    condition: "조건"
+    sort: "정렬"
+    asc: "오름차순"
+    desc: "내림차순"
+    predicates:
+      eq: "같음"
+      eq_any: "어떤 것이든 같음"
+      eq_all: "모두 같음"
+      not_eq: "같지 않음"
+      not_eq_any: "어떤 것이든 같지 않음"
+      not_eq_all: "모두 같지 않음"
+      matches: "일치함"
+      matches_any: "어떤 것이든 일치함"
+      matches_all: "모두 일치함"
+      does_not_match: "일치하지 않음"
+      does_not_match_any: "어떤 것이든 일치하지 않음"
+      does_not_match_all: "모두 일치하지 않음"
+      lt: "보다 작음"
+      lt_any: "어떤 것이든 보다 작음"
+      lt_all: "모두 보다 작음"
+      lteq: "보다 작거나 같음"
+      lteq_any: "어떤 것이든 보다 작거나 같음"
+      lteq_all: "모두 보다 작거나 같음"
+      gt: "보다 큼"
+      gt_any: "어떤 것이든 보다 큼"
+      gt_all: "모두 보다 큼"
+      gteq: "보다 크거나 같음"
+      gteq_any: "어떤 것이든 보다 크거나 같음"
+      gteq_all: "모두 보다 크거나 같음"
+      in: "포함됨"
+      in_any: "어떤 것이든 포함됨"
+      in_all: "모두 포함됨"
+      not_in: "포함되지 않음"
+      not_in_any: "어떤 것이든 포함되지 않음"
+      not_in_all: "모두 포함되지 않음"
+      cont: "포함함"
+      cont_any: "어떤 것이든 포함함"
+      cont_all: "모두 포함함"
+      not_cont: "포함하지 않음"
+      not_cont_any: "어떤 것이든 포함하지 않음"
+      not_cont_all: "모두 포함하지 않음"
+      start: "시작함"
+      start_any: "어떤 것이든 시작함"
+      start_all: "모두 시작함"
+      not_start: "시작하지 않음"
+      not_start_any: "어떤 것이든 시작하지 않음"
+      not_start_all: "모두 시작하지 않음"
+      end: "끝남"
+      end_any: "어떤 것이든 끝남"
+      end_all: "모두 끝남"
+      not_end: "끝나지 않음"
+      not_end_any: "어떤 것이든 끝나지 않음"
+      not_end_all: "모두 끝나지 않음"
+      'true': "참"
+      'false': "거짓"
+      present: "존재함"
+      blank: "비어있음"
+      'null': "널"
+      not_null: "널이 아님"

data/lib/ransack/locale/uk.yml

@@ -0,0 +1,72 @@
+# Інші переклади на https://github.com/activerecord-hackery/ransack/blob/main/lib/ransack/locale
+#
+uk:
+  ransack:
+    search: пошук
+    predicate: предикат
+    and: і
+    or: або
+    any: будь-який
+    all: усі
+    combinator: комбінатор
+    attribute: атрибут
+    value: значення
+    condition: умова
+    sort: сортування
+    asc: за зростанням
+    desc: за спаданням
+    predicates:
+      eq: рівний
+      eq_any: рівний будь-якому
+      eq_all: рівний усім
+      not_eq: не рівний
+      not_eq_any: не рівний будь-якому
+      not_eq_all: не рівний усім
+      matches: збігається
+      matches_any: збігається з будь-яким
+      matches_all: збігається з усіма
+      does_not_match: не збігається
+      does_not_match_any: не збігається з будь-яким
+      does_not_match_all: не збігається з усіма
+      lt: менше ніж
+      lt_any: менше за будь-який
+      lt_all: менше за всі
+      lteq: менше або рівне
+      lteq_any: менше або рівне будь-якому
+      lteq_all: менше або рівне всім
+      gt: більше ніж
+      gt_any: більше ніж будь-який
+      gt_all: більше ніж усі
+      gteq: більше або рівне
+      gteq_any: більше або рівне будь-якому
+      gteq_all: більше або рівне всім
+      in: міститься у
+      in_any: міститься в будь-якому
+      in_all: міститься в усіх
+      not_in: не міститься у
+      not_in_any: не міститься в будь-якому
+      not_in_all: не міститься в усіх
+      cont: містить
+      cont_any: містить будь-який
+      cont_all: містить усі
+      not_cont: не містить
+      not_cont_any: не містить жодного
+      not_cont_all: не містить усіх
+      start: починається з
+      start_any: починається з будь-якого
+      start_all: починається з усіх
+      not_start: не починається з
+      not_start_any: не починається з будь-якого
+      not_start_all: не починається з усіх
+      end: закінчується на
+      end_any: закінчується на будь-який
+      end_all: закінчується на всі
+      not_end: не закінчується на
+      not_end_any: не закінчується на будь-який
+      not_end_all: не закінчується на всі
+      'true': так
+      'false': ні
+      present: присутній
+      blank: порожній
+      'null': нульовий
+      not_null: не нульовий