ransack 6.0.1 → 6.1.0

data/lib/ransack/active_record/join_dependency.rb

@@ -6,6 +6,16 @@ module Ransack
     # and exposes the table aliasing Ransack needs to add one association at a
     # time to a relation that may already carry joins of its own.
     module JoinDependencyExtensions
+      # The table aliases a search counted on for one association it added,
+      # by position in its reflection chain (nil where the name could not be
+      # kept), and the join that ended up with them; see #pin_search_tables.
+      SearchPin = Struct.new(:name, :tables, :top_level, :joined_by, :joined_as)
+
+      # Set on a dependency Ransack stashes on a relation for an association
+      # a search added, and whether the search counted the relation's eager
+      # load first.
+      attr_accessor :added_by_search, :after_eager_load
+
       # Replaces ActiveRecord::Associations::JoinDependency#build
       def build(associations, base_klass)
         associations.map do |name, right|
@@ -42,10 +52,14 @@ module Ransack
           @references[table_name.to_sym] = table_name if table_name.is_a?(String)
         end
 
+        pin_search_tables(joins_to_add)
+
         joins = make_join_constraints(join_root, join_type)
 
-        joins.concat joins_to_add.flat_map { |oj|
-          if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
+        joins.concat eager_load_first(joins_to_add.to_a).flat_map { |oj|
+          if oj.added_by_search
+            search_join_constraints(oj)
+          elsif top_level?(oj)
             walk join_root, oj.join_root, oj.join_type
           else
             make_join_constraints(oj.join_root, oj.join_type)
@@ -53,6 +67,41 @@ module Ransack
         }
       end
 
+      # A search binds its conditions to the table aliases its joins are
+      # going to have, and roots a nested join at its parent's alias, all
+      # worked out from the relation it searched. A join added to the result
+      # afterwards (`result.joins(:target_person)`) renders first, and would
+      # take a name one of the search's joins was counting on, moving its
+      # conditions and nested joins onto the new join (#1776).
+      #
+      # So each association a search added keeps its aliases, those of a
+      # through association's intermediate tables included: the names are
+      # reserved before anything is joined, and a join of the same
+      # association added afterwards takes them over and stands in for the
+      # search's join; any other join is aliased around them. A name that a
+      # string or Arel join already claims cannot be kept; the joins nested
+      # under that association then follow the alias it does get.
+      def pin_search_tables(joins)
+        @search_pins = {}.compare_by_identity
+        aliases = alias_tracker.aliases
+        joins.each do |jd|
+          next unless jd.added_by_search
+
+          top_level = top_level?(jd)
+          jd.join_root.children.each do |node|
+            next if node.own_tables.blank?
+
+            tables = node.own_tables.map do |table|
+              next unless aliases[table.name].zero?
+
+              aliases[table.name] = 1
+              table
+            end
+            @search_pins[node] = SearchPin.new(node.own_tables.first.name, tables, top_level)
+          end
+        end
+      end
+
       def construct_tables_for_association!(join_root, association, join_type = self.join_type)
         tables = table_aliases_for(join_root, association, join_type)
         association.table = tables.first
@@ -61,6 +110,85 @@ module Ransack
 
       private
 
+      # Active Record renders the eager load last, after every
+      # `left_outer_joins` dependency. A search of a relation that eager
+      # loads counted the eager load's aliases before those of the joins it
+      # added, and may have rooted one of them at an eager-loaded join
+      # (#1767), so the eager load goes back in front of the first of them.
+      def eager_load_first(joins)
+        index = joins.index(&:after_eager_load)
+        joins.insert(index, joins.pop) if index && !joins.last.added_by_search
+        joins
+      end
+
+      def top_level?(jd)
+        join_root.match?(jd.join_root) && join_root.table.name == jd.join_root.table.name
+      end
+
+      # The pin for a node about to be joined: the search's own node, or a
+      # join of the same association under the root, which stands in for it.
+      # Each pin goes to whichever of them is joined first.
+      def take_search_pin(parent, node)
+        return unless @search_pins
+
+        pin = @search_pins[node]
+        if pin.nil? && parent.equal?(join_root)
+          pin = @search_pins.find { |search_node, p| p.top_level && !p.joined_by && search_node.match?(node) }&.last
+        end
+        return if pin.nil? || pin.joined_by
+
+        pin.joined_by = node
+        pin
+      end
+
+      # A search's join: left out when a join added afterwards stands in for
+      # it, and a nested one hung off the alias its parent actually got.
+      def search_join_constraints(jd)
+        root = jd.join_root
+        if top_level?(jd)
+          root.children.flat_map do |node|
+            joined_by = @search_pins[node]&.joined_by
+            if (joined_by && !joined_by.equal?(node)) || join_root.children.any? { |child| node.match?(child) }
+              []
+            else
+              make_constraints(join_root, node, jd.join_type)
+            end
+          end
+        else
+          parent = @search_pins.each_value.find { |pin| pin.name == root.table.name && pin.joined_as }
+          if parent && parent.joined_as.name != root.table.name
+            root = JoinDependency::JoinBase.new(root.base_klass, parent.joined_as, root.children)
+          end
+          make_join_constraints(root, jd.join_type)
+        end
+      end
+
+      # Replaces ActiveRecord::Associations::JoinDependency#make_constraints,
+      # to join an association a search added with the alias it pinned.
+      def make_constraints(parent, child, join_type)
+        foreign_table = parent.table
+        foreign_klass = parent.base_klass
+        pin = nil
+        child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection, remaining_reflection_chain|
+          table, terminated = @joined_tables[remaining_reflection_chain]
+          root = reflection == child.reflection
+          index = child.reflection.chain.size - remaining_reflection_chain.size
+          pin = take_search_pin(parent, child) if root
+
+          if table && (!root || !terminated) && reusable?(table, pin, index)
+            @joined_tables[remaining_reflection_chain] = [table, root] if root
+            pin.joined_as = table if pin && root
+            next table, true
+          end
+
+          table = aliased_table_for(parent, reflection, index, pin)
+          pin.joined_as = table if pin && root
+
+          @joined_tables[remaining_reflection_chain] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+          table
+        end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
+      end
+
       # The tables for a node's reflection chain, assigned the way Active
       # Record's JoinDependency#make_constraints assigns them, so that the
       # aliases Ransack binds conditions to are the ones the query will have.
@@ -71,28 +199,54 @@ module Ransack
         @joined_tables ||= {}
         chain = node.reflection.chain
         terminated_at = nil
+        pin = nil
 
         chain.each_with_index.map { |reflection, index|
           remaining = chain[index..]
           table, terminated = @joined_tables[remaining]
           root = reflection == node.reflection
+          pin = take_search_pin(parent, node) if root && !terminated_at
 
           if terminated_at
             table || reflection.klass.arel_table
-          elsif table && (!root || !terminated)
+          elsif table && (!root || !terminated) && reusable?(table, pin, index)
             @joined_tables[remaining] = [table, root] if root
+            pin.joined_as = table if pin && root
             terminated_at = index
             table
           else
-            table_name = @references && @references[reflection.name.to_sym]&.to_s
-            table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
-              name = reflection.alias_candidate(parent.table_name)
-              root ? name : "#{name}_join"
-            end
+            table = aliased_table_for(parent, reflection, index, pin)
+            pin.joined_as = table if pin && root
             @joined_tables[remaining] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
             table
           end
-        }
+        }.tap do |tables|
+          # Kept from the search that built the node. A later search of the
+          # same result shares the node and may give it other aliases, but
+          # the first result's conditions still name these.
+          node.own_tables ||= tables.first(terminated_at || tables.size)
+        end
+      end
+
+      # Whether a table an earlier join already provides can stand in for
+      # one position of a node's reflection chain. Not when a search pinned
+      # another alias there: the search's conditions name that one, so the
+      # node is joined on its own (#1776).
+      def reusable?(table, pin, index)
+        pinned = pin&.tables&.at(index)
+        pinned.nil? || pinned.name == table.name
+      end
+
+      # A new table for one position of a node's reflection chain: the one a
+      # search pinned for it, or the next alias Active Record would give.
+      def aliased_table_for(parent, reflection, index, pin)
+        return pin.tables[index] if pin&.tables&.at(index)
+
+        table_name = @references && @references[reflection.name.to_sym]&.to_s
+        alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
+          name = reflection.alias_candidate(parent.table_name)
+          index.zero? ? name : "#{name}_join"
+        end
       end
 
       module ClassMethods

data/lib/ransack/configuration.rb

@@ -7,11 +7,12 @@ module Ransack
     mattr_accessor :predicates, :options
 
     class PredicateCollection
-      attr_reader :sorted_names_with_underscores
+      attr_reader :sorted_names_with_underscores, :max_name_length
 
       def initialize
         @collection = {}
         @sorted_names_with_underscores = []
+        @max_name_length = 0
       end
 
       delegate :[], :keys, :has_key?, to: :@collection
@@ -20,6 +21,7 @@ module Ransack
         @sorted_names_with_underscores << [key, '_' + key]
         @sorted_names_with_underscores.sort! { |(a, _), (b, _)| b.length <=> a.length }
 
+        @max_name_length = key.length if key.length > @max_name_length
         @collection[key] = value
       end
     end
@@ -48,9 +50,26 @@ module Ransack
     def add_predicate(name, opts = {})
       name = name.to_s
       opts[:name] = name
+
+      if opts[:arel_predicate] && opts[:arel_node]
+        raise ArgumentError,
+          "add_predicate '#{name}' takes :arel_predicate or :arel_node, " \
+          "not both"
+      end
+
+      if opts[:arel_node] && !opts[:arel_node].respond_to?(:call)
+        raise ArgumentError,
+          "add_predicate '#{name}' needs :arel_node to be callable, " \
+          "got #{opts[:arel_node].class}"
+      end
+
       compounds = opts.delete(:compounds)
       compounds = true if compounds.nil?
       compounds = false if opts[:wants_array]
+      # _any/_all are built by appending a suffix to an Arel method name
+      # (see #arel_predicate_with_suffix below), which an arel_node builder
+      # has none of.
+      compounds = false if opts[:arel_node]
 
       self.predicates[name] = Predicate.new(opts)
 
@@ -279,7 +298,11 @@ module Ransack
     end
 
     def arel_predicate_with_suffix(arel_predicate, suffix)
-      if arel_predicate === Proc
+      # `arel_predicate === Proc` reads as a class check, but `Proc#===` is
+      # an alias for `#call`: it invokes the proc, passing the `Proc`
+      # class itself as the argument, and branches on whatever comes
+      # back. `#respond_to?(:call)` is a real check.
+      if arel_predicate.respond_to?(:call)
         proc { |v| "#{arel_predicate.call(v)}#{suffix}" }
       else
         "#{arel_predicate}#{suffix}"

data/lib/ransack/context.rb

@@ -3,13 +3,25 @@ require 'ransack/visitor'
 module Ransack
   class Context
     attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
-    attr_accessor :auth_object, :search_key, :ignore_unknown_conditions
+    attr_accessor :search_key, :ignore_unknown_conditions
+    attr_reader :auth_object, :permitted
     attr_writer :null_sentinel
 
+    # The allowlists are read once per model and kept for the life of the
+    # context (see `allowlist_set`), so changing what they depend on drops
+    # the kept copies.
+    def auth_object=(value)
+      reset_name_caches
+      @auth_object = value
+    end
+
     # True when the search was built from `ActionController::Parameters` the
     # controller permitted. A model with no allowlist of its own then lets
     # that permit list be the boundary (see `allowlist` below).
-    attr_accessor :permitted
+    def permitted=(value)
+      reset_name_caches
+      @permitted = value
+    end
 
     class << self
 
@@ -122,7 +134,9 @@ module Ransack
                   # 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)
+                  # Only an Array is spread into several arguments. A bare
+                  # splat would call to_a, turning a Time into ten (#1769).
+                  @object.public_send(scope, *Array.wrap(args))
                 end
     end
 
@@ -202,7 +216,7 @@ module Ransack
     end
 
     def unpolymorphize_association(str)
-      if (match = str.match(/_of_([^_]+?)_type$/)) &&
+      if (match = str.match(/_of_([^_]+?)_type\z/)) &&
          (klass = polymorphic_class(match.captures.first))
         [match.pre_match, klass]
       else
@@ -240,9 +254,19 @@ module Ransack
     # `term_or_daddy` with `term => name_or_email` becomes
     # `name_or_email_or_parent_name`. Returns the name unchanged when it
     # holds no alias.
+    #
+    # A key is resolved several times while a search is built (to check it,
+    # to split it into attributes, to bind them), so the result is kept for
+    # the life of the context, frozen, and dropped with the allowlists it
+    # depends on.
     def resolve_aliases(str)
       return str.to_s unless key_within_depth_limit?(str)
 
+      key = str.to_s
+      (@resolved_aliases ||= {})[key] ||= -resolve_aliases_uncached(key)
+    end
+
+    def resolve_aliases_uncached(str)
       whole = resolve_alias_segment(str)
       return whole if whole != str
       # A name that is an attribute in its own right is never split, even if
@@ -256,17 +280,18 @@ module Ransack
       combinator = str[/_(or|and)_/, 1] || Constants::OR
       resolved.join("_#{combinator}_")
     end
+    private :resolve_aliases_uncached
 
     def ransackable_attribute?(str, klass)
-      attributes_for(klass).any? { |s| s.to_sym == str.to_sym }
+      allowlist_set(klass, :attributes_for).include?(str.to_s)
     end
 
     def ransortable_attribute?(str, klass)
-      sortable_attributes_for(klass).any? { |s| s.to_sym == str.to_sym }
+      allowlist_set(klass, :sortable_attributes_for).include?(str.to_s)
     end
 
     def ransackable_association?(str, klass)
-      associations_for(klass).any? { |s| s.to_sym == str.to_sym }
+      allowlist_set(klass, :associations_for).include?(str.to_s)
     end
 
     def ransackable_scope?(str, klass)
@@ -289,8 +314,31 @@ module Ransack
       associations_for(traverse(str))
     end
 
+    # Hooks a condition calls to record the joins it reads. The Active
+    # Record context overrides them; a context registered for another ORM
+    # need not, and a search through it still builds.
+    def lock_association(_association); end
+
+    def use_association(_association); end
+
+    def use_ancestors_of(_association); end
+
     private
 
+    # Every name in a search is checked against the allowlists several times
+    # over, and each check used to call the model's `ransackable_*` method
+    # and scan the array it returned. They are asked once per model per
+    # context instead, and what is cached here is dropped whenever the auth
+    # object or the permitted flag changes.
+    def reset_name_caches
+      @allowlist_sets = @resolved_aliases = @attribute_methods = nil
+    end
+
+    def allowlist_set(klass, kind)
+      ((@allowlist_sets ||= {})[kind] ||= {})[klass] ||=
+        send(kind, klass).to_set(&:to_s).freeze
+    end
+
     def attributes_for(klass)
       allowlist(klass, :ransackable_attributes) { klass.authorizable_ransackable_attributes }
     end

data/lib/ransack/errors.rb

@@ -0,0 +1,13 @@
+module Ransack
+  # Raised for a search that cannot be built from its params: an unknown
+  # attribute, predicate, combinator or sort under a strict search, or params
+  # of the wrong shape (a string where a hash of conditions belongs) under any
+  # search. Search params usually come from the request, so this is the error
+  # to rescue to turn a bad search into a 400 rather than a 500. It is an
+  # ArgumentError, so code that rescues ArgumentError still catches it.
+  class InvalidSearchError < ArgumentError; end
+
+  # Raised internally when a name does not resolve to an association. The
+  # form builder rescues it; a search never lets it escape.
+  class UntraversableAssociationError < StandardError; end
+end

data/lib/ransack/invalid_search_error.rb

@@ -1,3 +1,3 @@
-module Ransack
-  class InvalidSearchError < ArgumentError; end
-end
+# Kept so that `require 'ransack/invalid_search_error'` still works; the error
+# classes live in ransack/errors.
+require 'ransack/errors'

data/lib/ransack/locale/ar.yml

@@ -50,21 +50,56 @@ ar:
       not_cont: "غير محتو"
       not_cont_any: "غير محتو لواحد على اﻷقل"
       not_cont_all: "غير محتو للجميع"
+      i_cont: "محتو مع تجاهل حالة الأحرف"
+      i_cont_any: "محتو لواحد على اﻷقل مع تجاهل حالة الأحرف"
+      i_cont_all: "محتو لجميع مع تجاهل حالة الأحرف"
+      not_i_cont: "غير محتو مع تجاهل حالة الأحرف"
+      not_i_cont_any: "غير محتو لواحد على اﻷقل مع تجاهل حالة الأحرف"
+      not_i_cont_all: "غير محتو للجميع مع تجاهل حالة الأحرف"
       start: "يبدأ بـ"
       start_any: "يبدأ بواحد على اﻷقل"
       start_all: "يبدأ بالجميع"
       not_start: "لا يبدأ بـ"
       not_start_any: "لا يبدأ بواحد على اﻷقل"
       not_start_all: "لا يبدأ بالجميع"
+      i_start: "يبدأ بـ مع تجاهل حالة الأحرف"
+      i_start_any: "يبدأ بواحد على اﻷقل مع تجاهل حالة الأحرف"
+      i_start_all: "يبدأ بالجميع مع تجاهل حالة الأحرف"
+      not_i_start: "لا يبدأ بـ مع تجاهل حالة الأحرف"
+      not_i_start_any: "لا يبدأ بواحد على اﻷقل مع تجاهل حالة الأحرف"
+      not_i_start_all: "لا يبدأ بالجميع مع تجاهل حالة الأحرف"
       end: "ينتهي بـ"
       end_any: "ينتهي بواحد على اﻷقل"
       end_all: "ينتهي بالجميع"
       not_end: "لا ينتهي بـ"
       not_end_any: "لا ينتهي بواحد على اﻷقل"
       not_end_all: "لا ينتهي بالجميع"
+      i_end: "ينتهي بـ مع تجاهل حالة الأحرف"
+      i_end_any: "ينتهي بواحد على اﻷقل مع تجاهل حالة الأحرف"
+      i_end_all: "ينتهي بالجميع مع تجاهل حالة الأحرف"
+      not_i_end: "لا ينتهي بـ مع تجاهل حالة الأحرف"
+      not_i_end_any: "لا ينتهي بواحد على اﻷقل مع تجاهل حالة الأحرف"
+      not_i_end_all: "لا ينتهي بالجميع مع تجاهل حالة الأحرف"
       'true': "صحيح"
+      not_true: "غير صحيح"
       'false': "خطأ"
+      not_false: "غير خطأ"
       present: "مستقبل"
       blank: "فراغ"
       'null': "عدم"
       not_null: "غير مساو لقيمة عدم"
+      length_eq: "الطول معادل"
+      length_eq_any: "الطول معادل على اﻷقل لواحد"
+      length_eq_all: "الطول معادل للجميع"
+      length_lt: "الطول أصغر من"
+      length_lt_any: "الطول أصغر لواحد على اﻷقل"
+      length_lt_all: "الطول أصغر من الجميع"
+      length_lteq: "الطول أصغر أو مساو لـ"
+      length_lteq_any: "الطول أصغر أو مساو لواحد على اﻷقل"
+      length_lteq_all: "الطول أصغر أو مساو للجميع"
+      length_gt: "الطول أكبر من"
+      length_gt_any: "الطول أكبر من واحد على اﻷقل"
+      length_gt_all: "الطول أكبر من الجميع"
+      length_gteq: "الطول أكبر أو مساو لـ"
+      length_gteq_any: "الطول أكبر أو مساو لواحد على اﻷقل"
+      length_gteq_all: "الطول أكبر أو مساو للجميع"

data/lib/ransack/locale/az.yml

@@ -32,7 +32,7 @@ az:
       lteq: "daha kiçik və ya bərabər"
       lteq_any: "daha kiçik və ya hər hansı birinə bərabər"
       lteq_all: "daha kiçik və ya hamısına bərabər"
-      gt: "daha böyük "
+      gt: "daha böyük"
       gt_any: "hər hansı birindən daha böyük"
       gt_all: "hamısından daha böyük"
       gteq: "daha böyük və ya bərabər"
@@ -50,21 +50,56 @@ az:
       not_cont: "ehtiva etməyən"
       not_cont_any: "hər hansı birini ehtiva etməyən"
       not_cont_all: "heç birini birini ehtiva etməyən"
+      i_cont: "ehtiva edən, hərf halına baxmayaraq"
+      i_cont_any: "hər hansı birini ehtiva edən, hərf halına baxmayaraq"
+      i_cont_all: "hamısını ehtiva edən, hərf halına baxmayaraq"
+      not_i_cont: "ehtiva etməyən, hərf halına baxmayaraq"
+      not_i_cont_any: "hər hansı birini ehtiva etməyən, hərf halına baxmayaraq"
+      not_i_cont_all: "heç birini birini ehtiva etməyən, hərf halına baxmayaraq"
       start: "ilə başlayan"
       start_any: "hər hansı biri ilə başlayan"
       start_all: "hamısı ilə başlayan"
       not_start: "ilə başlamayan"
       not_start_any: "hər hansı biri ilə başlamayan"
       not_start_all: "hiçbiri ilə başlamayan"
+      i_start: "ilə başlayan, hərf halına baxmayaraq"
+      i_start_any: "hər hansı biri ilə başlayan, hərf halına baxmayaraq"
+      i_start_all: "hamısı ilə başlayan, hərf halına baxmayaraq"
+      not_i_start: "ilə başlamayan, hərf halına baxmayaraq"
+      not_i_start_any: "hər hansı biri ilə başlamayan, hərf halına baxmayaraq"
+      not_i_start_all: "hiçbiri ilə başlamayan, hərf halına baxmayaraq"
       end: "ilə bitən"
       end_any: "hər hansı biri ilə bitən"
       end_all: "hamısı ilə bitən"
       not_end: "ilə bitməyən"
       not_end_any: "hər hansı biri ilə bitməyən"
       not_end_all: "heç biri ilə bitməyən"
+      i_end: "ilə bitən, hərf halına baxmayaraq"
+      i_end_any: "hər hansı biri ilə bitən, hərf halına baxmayaraq"
+      i_end_all: "hamısı ilə bitən, hərf halına baxmayaraq"
+      not_i_end: "ilə bitməyən, hərf halına baxmayaraq"
+      not_i_end_any: "hər hansı biri ilə bitməyən, hərf halına baxmayaraq"
+      not_i_end_all: "heç biri ilə bitməyən, hərf halına baxmayaraq"
       'true': "doğru"
+      not_true: "doğru deyil"
       'false': "yanlış"
+      not_false: "yanlış deyil"
       present: "mövcüd"
       blank: "boş"
       'null': "keçərsiz"
       not_null: "keçərli"
+      length_eq: "uzunluğu bərabər"
+      length_eq_any: "uzunluğu hər hansı birinə bərabər"
+      length_eq_all: "uzunluğu hamısına bərabər"
+      length_lt: "uzunluğu daha kiçik"
+      length_lt_any: "uzunluğu hər hansı birindən kiçik"
+      length_lt_all: "uzunluğu hamısından kiçik"
+      length_lteq: "uzunluğu daha kiçik və ya bərabər"
+      length_lteq_any: "uzunluğu daha kiçik və ya hər hansı birinə bərabər"
+      length_lteq_all: "uzunluğu daha kiçik və ya hamısına bərabər"
+      length_gt: "uzunluğu daha böyük"
+      length_gt_any: "uzunluğu hər hansı birindən daha böyük"
+      length_gt_all: "uzunluğu hamısından daha böyük"
+      length_gteq: "uzunluğu daha böyük və ya bərabər"
+      length_gteq_any: "uzunluğu daha böyük və ya hər hansı birine bərabər"
+      length_gteq_all: "uzunluğu daha böyük və ya hamısıne bərabər"

data/lib/ransack/locale/bg.yml

@@ -50,21 +50,56 @@ bg:
       not_cont: "не съдържа"
       not_cont_any: "не съдържа никое"
       not_cont_all: "не съдържа всички"
+      i_cont: "съдържа, без оглед на регистъра"
+      i_cont_any: "съдържа всякое, без оглед на регистъра"
+      i_cont_all: "съдържа всички, без оглед на регистъра"
+      not_i_cont: "не съдържа, без оглед на регистъра"
+      not_i_cont_any: "не съдържа никое, без оглед на регистъра"
+      not_i_cont_all: "не съдържа всички, без оглед на регистъра"
       start: "започва с"
       start_any: "започва с всякое"
       start_all: "започва с всички"
       not_start: "не започва с"
       not_start_any: "не започва с никое"
       not_start_all: "не започва с всички"
+      i_start: "започва с, без оглед на регистъра"
+      i_start_any: "започва с всякое, без оглед на регистъра"
+      i_start_all: "започва с всички, без оглед на регистъра"
+      not_i_start: "не започва с, без оглед на регистъра"
+      not_i_start_any: "не започва с никое, без оглед на регистъра"
+      not_i_start_all: "не започва с всички, без оглед на регистъра"
       end: "завършва с"
       end_any: "завършва с всякое"
       end_all: "завършва с всички"
       not_end: "не завършва с"
       not_end_any: "не завършва с никое"
       not_end_all: "не завършва с всички"
+      i_end: "завършва с, без оглед на регистъра"
+      i_end_any: "завършва с всякое, без оглед на регистъра"
+      i_end_all: "завършва с всички, без оглед на регистъра"
+      not_i_end: "не завършва с, без оглед на регистъра"
+      not_i_end_any: "не завършва с никое, без оглед на регистъра"
+      not_i_end_all: "не завършва с всички, без оглед на регистъра"
       'true': "истина"
+      not_true: "не е истина"
       'false': "неистина"
+      not_false: "не е неистина"
       present: "присъства"
       blank: "е празно"
       'null': "е нула"
       not_null: "не е нула"
+      length_eq: "дължината се равнява на"
+      length_eq_any: "дължината се равнява на всяко"
+      length_eq_all: "дължината се равнява на всички"
+      length_lt: "дължината по-малко от"
+      length_lt_any: "дължината по-малко от някое"
+      length_lt_all: "дължината по-малко от всички"
+      length_lteq: "дължината по-малко или равно на"
+      length_lteq_any: "дължината по-малко или равно на някое"
+      length_lteq_all: "дължината по-малко или равно на всички"
+      length_gt: "дължината по-голямо от"
+      length_gt_any: "дължината по-голямо от всякое"
+      length_gt_all: "дължината по-голямо от всички"
+      length_gteq: "дължината по-голямо или равно на"
+      length_gteq_any: "дължината по-голямо или равно на всякое"
+      length_gteq_all: "дължината по-голямо или равно на всички"