ransack 4.4.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9174f26f96f894e12f75427d0bc4fee92d3cda026ed899f2356b42973d1fb3bf
-  data.tar.gz: aa87e6f2d75557369ca2cf1e7821aaf833490c2793380535d9e5514823ebd117
+  metadata.gz: 0251527dc22cca8cb55ff672b598d74fef0ec4c2b1c6336cb0b8d52d69dabafc
+  data.tar.gz: fd218c05d4697cca5b9a8b4111af7a5fa4ddc559071e9a3194aca2f2b2da6c9d
 SHA512:
-  metadata.gz: cdb319a97b23b03a24ac010136212ac53460f03b208e5dff1efae8ff32833256dff1222abbce533e704320740a5bd1cd1d56e14d35d7264a733d0bc1aa75e918
-  data.tar.gz: 12dd3eae7f2cd9bf78d30ab4ae76e5a3ffc80f33ddb3737856cabf3cfb395adf8b9af83eb5feb4e131c8ffd5294e7bf81870da42f7cdbc734288f086902aab96
+  metadata.gz: bc524a7f9a4fac90d6f2e3b9818ccf76bab0f44c872c33db043f049f759f2641c03b338c2cfa28c70a20f6d1d2c4569390e43ec9e5da9daf2537002c519ad3fc
+  data.tar.gz: 3a599c3c9472f0033976ed0301cc0545b62711cccb36817db373c0f19ba0b828640a89bc3784b533346633112fb017353c63c490fa792b3eb3e7aea82f41e527

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://github.com/activerecord-hackery/ransack/workflows/test/badge.svg)](https://github.com/activerecord-hackery/ransack/actions)
 [![Gem Version](https://badge.fury.io/rb/ransack.svg)](http://badge.fury.io/rb/ransack)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/activerecord-hackery/ransack)
 [![Code Climate](https://codeclimate.com/github/activerecord-hackery/ransack/badges/gpa.svg)](https://codeclimate.com/github/activerecord-hackery/ransack)
 [![Backers on Open Collective](https://opencollective.com/ransack/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/ransack/sponsors/badge.svg)](#sponsors)
 
@@ -13,7 +14,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 8.0, 7.2 on Ruby 3.1 and later.
+Ransack is supported for Rails 8.1, 8.0, 7.2 on Ruby 3.1 and later.
 
 ## Installation
 

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

@@ -15,7 +15,7 @@ module Ransack
           relation     = attr.arel_attribute.relation
           name         = attr.arel_attribute.name.to_s
           table        = relation.respond_to?(:table_name) ? relation.table_name : relation.name
-          schema_cache = self.klass.connection.schema_cache
+          schema_cache = self.klass.connection_pool.schema_cache
           unless schema_cache.send(:data_source_exists?, table)
             raise "No table named #{table} exists."
           end
@@ -44,15 +44,15 @@ module Ransack
               if scope_or_sort.is_a?(Symbol)
                 relation = relation.send(scope_or_sort)
               else
-                case Ransack.options[:postgres_fields_sort_option]
+                case Ransack.options[:fields_sort_option]
                 when :nulls_first
-                  scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST") : Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
+                  scope_or_sort = scope_or_sort.direction == :asc ? scope_or_sort.nulls_first : scope_or_sort.nulls_last
                 when :nulls_last
-                  scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS LAST") : Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
+                  scope_or_sort = scope_or_sort.direction == :asc ? scope_or_sort.nulls_last : scope_or_sort.nulls_first
                 when :nulls_always_first
-                  scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
+                  scope_or_sort = scope_or_sort.nulls_first
                 when :nulls_always_last
-                  scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
+                  scope_or_sort = scope_or_sort.nulls_last
                 end
 
                 relation = relation.order(scope_or_sort)
@@ -65,7 +65,8 @@ module Ransack
 
         def attribute_method?(str, klass = @klass)
           exists = false
-          if ransackable_attribute?(str, klass)
+          if ransackable_attribute?(str, klass) ||
+             ransortable_attribute?(str, klass)
             exists = true
           elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
             remainder = []
@@ -212,9 +213,9 @@ module Ransack
             end
           when Arel::Nodes::Equality
             pk = primary_key
-            if join_root.left == pk
+            if join_root.left.eql?(pk)
               join_root.right
-            elsif join_root.right == pk
+            elsif join_root.right.eql?(pk)
               join_root.left
             else
               nil
@@ -239,7 +240,8 @@ module Ransack
         def get_parent_and_attribute_name(str, parent = @base)
           attr_name = nil
 
-          if ransackable_attribute?(str, klassify(parent))
+          if ransackable_attribute?(str, klassify(parent)) ||
+             ransortable_attribute?(str, klassify(parent))
             attr_name = str
           elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
             remainder = []

data/lib/ransack/configuration.rb

@@ -34,8 +34,9 @@ module Ransack
       down_arrow: '▲'.freeze,
       default_arrow: nil,
       sanitize_scope_args: true,
-      postgres_fields_sort_option: nil,
-      strip_whitespace: true
+      fields_sort_option: nil,
+      strip_whitespace: true,
+      ignore_blank_values: true
     }
 
     def configure
@@ -162,13 +163,24 @@ module Ransack
     # User may want to configure it like this:
     #
     # Ransack.configure do |c|
-    #   c.postgres_fields_sort_option = :nulls_first # or e.g. :nulls_always_last
+    #   c.fields_sort_option = :nulls_first # or e.g. :nulls_always_last
     # end
     #
-    # See this feature: https://www.postgresql.org/docs/13/queries-order.html
+    # Emitted through Arel's `nulls_first` / `nulls_last`, so it works on any
+    # backend Arel supports it for. MySQL has no NULLS FIRST / LAST syntax and
+    # Arel does not emulate it, so this option does not apply there.
     #
+    # See https://www.postgresql.org/docs/current/queries-order.html
+    #
+    def fields_sort_option=(setting)
+      self.options[:fields_sort_option] = setting
+    end
+
+    # Renamed to `fields_sort_option` now that NULLS FIRST / NULLS LAST is
+    # emitted through Arel and is no longer PostgreSQL-specific. The old name
+    # still works so existing initializers keep running.
     def postgres_fields_sort_option=(setting)
-      self.options[:postgres_fields_sort_option] = setting
+      self.fields_sort_option = setting
     end
 
     # By default, Ransack displays sort order indicator arrows in sort links.
@@ -197,6 +209,27 @@ module Ransack
       self.options[:strip_whitespace] = boolean
     end
 
+    # By default, Ransack ignores search conditions whose value is blank — an
+    # empty string, or an array containing only blank values. This is what makes
+    # a search form submitted with empty fields return every record rather than
+    # none, and it is almost always what an HTML form wants.
+    #
+    # Set this to false to treat a blank value as a value to search *for*:
+    # `name_eq: ''` then generates `WHERE name = ''`, and `id_in: []` generates a
+    # condition matching nothing rather than being dropped. This is usually what
+    # a JSON API wants, where an empty value is an explicit filter rather than an
+    # untouched form field.
+    #
+    # A `nil` value is ignored either way.
+    #
+    # Ransack.configure do |config|
+    #   config.ignore_blank_values = false
+    # end
+    #
+    def ignore_blank_values=(boolean)
+      self.options[:ignore_blank_values] = boolean
+    end
+
     def arel_predicate_with_suffix(arel_predicate, suffix)
       if arel_predicate === Proc
         proc { |v| "#{arel_predicate.call(v)}#{suffix}" }

data/lib/ransack/constants.rb

@@ -155,22 +155,47 @@ module Ransack
         type: :boolean,
         validator: proc { |v| BOOLEAN_VALUES.include?(v) },
         formatter: proc { |v| nil } }
+      ],
+      ['length_eq'.freeze, {
+        arel_predicate: 'eq'.freeze,
+        type: :integer
+        }
+      ],
+      ['length_lt'.freeze, {
+        arel_predicate: 'lt'.freeze,
+        type: :integer
+        }
+      ],
+      ['length_lteq'.freeze, {
+        arel_predicate: 'lteq'.freeze,
+        type: :integer
+        }
+      ],
+      ['length_gt'.freeze, {
+        arel_predicate: 'gt'.freeze,
+        type: :integer
+        }
+      ],
+      ['length_gteq'.freeze, {
+        arel_predicate: 'gteq'.freeze,
+        type: :integer
+        }
       ]
     ].freeze
 
+    # The character used to escape LIKE wildcards. Emitted as an explicit
+    # `ESCAPE` clause alongside every LIKE / NOT LIKE predicate, so the
+    # behaviour does not depend on a backend's default escape character —
+    # MySQL and PostgreSQL default to backslash, SQLite has no default at all.
+    LIKE_ESCAPE_CHARACTER = '\\'.freeze
+
   module_function
-    # replace % \ to \% \\
+    # Escapes the LIKE wildcards `%` and `_`, and the escape character itself,
+    # so they are matched literally. Paired with the `ESCAPE` clause added in
+    # `Condition#format_predicate`; escaping without it silently does nothing
+    # on SQLite. See https://github.com/activerecord-hackery/ransack/issues/1581
     def escape_wildcards(unescaped)
-      case ActiveRecord::Base.connection.adapter_name
-      when "Mysql2".freeze
-        # Necessary for MySQL
-        unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
-      when "PostGIS".freeze, "PostgreSQL".freeze
-        # Necessary for PostgreSQL
-        unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
-      else
-        unescaped
-      end
+      unescaped.to_s.gsub(/([\\%_])/) { "#{LIKE_ESCAPE_CHARACTER}#{$1}" }
     end
   end
 end

data/lib/ransack/context.rb

@@ -3,8 +3,7 @@ require 'ransack/visitor'
 module Ransack
   class Context
     attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
-    attr_accessor :auth_object, :search_key
-    attr_reader :arel_visitor
+    attr_accessor :auth_object, :search_key, :ignore_unknown_conditions
 
     class << self
 
@@ -34,6 +33,12 @@ module Ransack
 
     end # << self
 
+    # Unknown attributes, predicates and combinators raise rather than being
+    # ignored when either the global option or this search's own option says so.
+    def strict_conditions?
+      !Ransack.options[:ignore_unknown_conditions] || ignore_unknown_conditions == false
+    end
+
     def initialize(object, options = {})
       @object = relation_for(object)
       @klass = @object.klass
@@ -89,6 +94,14 @@ module Ransack
       @klass.method(scope).arity
     end
 
+    def sanitize_scope_args(key, args)
+      if Ransack.options[:sanitize_scope_args] && !ransackable_scope_skip_sanitize_args?(key, object)
+        cast_scope_args(args)
+      else
+        args
+      end
+    end
+
     def bind(object, str)
       return nil unless str
       object.parent, object.attr_name = bind_pair_for(str)
@@ -159,8 +172,11 @@ module Ransack
     end
 
     def ransackable_attribute?(str, klass)
-      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 }
+      klass.ransackable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def ransortable_attribute?(str, klass)
+      klass.ransortable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym }
     end
 
     def ransackable_association?(str, klass)
@@ -186,5 +202,21 @@ module Ransack
     def searchable_associations(str = ''.freeze)
       traverse(str).ransackable_associations(auth_object)
     end
+
+    private
+
+    def cast_scope_args(args)
+      if args.is_a?(Array)
+        args = args.map(&method(:cast_scope_args))
+      end
+
+      if Constants::TRUE_VALUES.include? args
+        true
+      elsif Constants::FALSE_VALUES.include? args
+        false
+      else
+        args
+      end
+    end
   end
 end

data/lib/ransack/helpers/form_builder.rb

@@ -1,22 +1,5 @@
 require 'action_view'
 
-module ActionView::Helpers::Tags
-  # TODO: Find a better way to solve this issue!
-  # This patch is needed since this Rails commit:
-  # https://github.com/rails/rails/commit/c1a118a
-  class Base
-    private
-
-    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
-end
-
 RANSACK_FORM_BUILDER = 'RANSACK_FORM_BUILDER'.freeze
 
 require 'simple_form' if
@@ -129,6 +112,7 @@ module Ransack
 
       def predicate_select(options = {}, html_options = {})
         options[:compounds] = true if options[:compounds].nil?
+        options[:selected] ||= nil
         default = options.delete(:default) || Constants::CONT
 
         keys =

data/lib/ransack/helpers/form_helper.rb

@@ -10,7 +10,7 @@ module Ransack
         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)
+        finalize_form_options(search, options, html_options)
         form_for(record, options, &proc)
       end
 
@@ -30,7 +30,7 @@ module Ransack
         search = extract_search_and_set_url(record, options, 'search_form_with')
         options[:html] ||= {}
         html_options = build_html_options(search, options, :get)
-        finalize_form_with_options(options, html_options)
+        finalize_form_with_options(search, options, html_options)
         form_with(model: search, **options, &proc)
       end
 
@@ -48,7 +48,7 @@ module Ransack
         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)
+        finalize_form_options(search, options, html_options)
         form_for(record, options, &proc)
       end
 
@@ -122,14 +122,14 @@ module Ransack
           }
         end
 
-        def finalize_form_options(options, html_options)
-          options[:as] ||= Ransack.options[:search_key]
+        def finalize_form_options(search, options, html_options)
+          options[:as] ||= search.context.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]
+        def finalize_form_with_options(search, options, html_options)
+          options[:scope] ||= search.context.search_key
           options[:html].reverse_merge!(html_options)
           options[:builder] ||= FormBuilder
         end

data/lib/ransack/nodes/attribute.rb

@@ -20,8 +20,7 @@ module Ransack
 
       def valid?
         bound? && attr &&
-        context.klassify(parent).ransackable_attributes(context.auth_object)
-        .include?(attr_name.split('.').last)
+        context.ransackable_attribute?(attr_name.split('.').last, context.klassify(parent))
       end
 
       def associated_collection?
@@ -31,6 +30,8 @@ module Ransack
       def type
         if ransacker
           ransacker.type
+        elsif enum?
+          :enum
         else
           context.type_for(self)
         end
@@ -54,6 +55,14 @@ module Ransack
         "Attribute <#{name}>"
       end
 
+      private
+
+      def enum?
+        bound? &&
+        klass.respond_to?(:defined_enums) &&
+        klass.defined_enums.key?(attr_name.to_s)
+      end
+
     end
   end
 end

data/lib/ransack/nodes/condition.rb

@@ -81,8 +81,13 @@ module Ransack
       def attributes=(args)
         case args
         when Array
-          args.each do |name|
-            build_attribute(name)
+          args.each do |attr|
+            if attr.is_a?(Hash) && (attr.key?(:name) || attr.key?("name"))
+              attr = attr.with_indifferent_access
+              build_attribute(attr[:name], attr[:ransacker_args])
+            else
+              build_attribute(attr)
+            end
           end
         when Hash
           args.each do |index, attrs|
@@ -104,8 +109,10 @@ module Ransack
         case args
         when Array
           args.each do |val|
-            val = Value.new(@context, val)
-            self.values << val
+            if val.is_a?(Hash) && (val.key?(:value) || val.key?("value"))
+              val = val.with_indifferent_access[:value]
+            end
+            self.values << Value.new(@context, val)
           end
         when Hash
           args.each do |index, attrs|
@@ -124,8 +131,9 @@ module Ransack
       end
 
       def combinator=(val)
-        @combinator = Constants::AND_OR.detect { |v| v == val.to_s } || nil
+        super
       end
+
       alias :m= :combinator=
       alias :m :combinator
 
@@ -171,10 +179,17 @@ module Ransack
         end
       end
 
+      # The long spellings route through the short setters: `p=` resolves a
+      # Predicate object, whereas the `predicate=` attribute writer would store
+      # the bare name.
+      LONG_KEYS = {
+        'attributes' => 'a', 'values' => 'v', 'predicate' => 'p', 'combinator' => 'm'
+      }.freeze
+
       def build(params)
         params.with_indifferent_access.each do |key, value|
-          if key.match(/^(a|v|p|m)$/)
-            self.send("#{key}=", value)
+          if key.match(/^(a|v|p|m|attributes|values|predicate|combinator)$/)
+            self.send("#{LONG_KEYS.fetch(key, key)}=", value)
           end
         end
 
@@ -217,10 +232,6 @@ module Ransack
       end
       alias :p :predicate_name
 
-      def arel_predicate
-        raise "not implemented"
-      end
-
       def validated_values
         values.select { |v| predicate.validator.call(v.value) }
       end
@@ -260,7 +271,7 @@ module Ransack
       end
 
       def attr_value_for_attribute(attr)
-        return attr.attr if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        return attr.attr if ActiveRecord::Base.adapter_class::ADAPTER_NAME == "PostgreSQL"
 
         predicate.case_insensitive ? attr.attr.lower : attr.attr
       rescue
@@ -289,11 +300,11 @@ module Ransack
       end
 
       def arel_predicate
-        predicate = attributes.map { |attribute|
+        attributes.map { |attribute|
           association = attribute.parent
           parent_table = association.table
 
-          if negative? && attribute.associated_collection? && not_nested_condition(attribute, parent_table)
+          predicate = if negative? && attribute.associated_collection? && not_nested_condition(attribute, parent_table)
             query = context.build_correlated_subquery(association)
             context.remove_association(association)
 
@@ -316,18 +327,22 @@ module Ransack
           else
             format_predicate(attribute)
           end
-        }.reduce(combinator_method)
 
-        if replace_right_node?(predicate)
-          # Replace right node object to plain integer value in order to avoid
-          # ActiveModel::RangeError from Arel::Node::Casted.
-          # The error can be ignored here because RDBMSs accept large numbers
-          # in condition clauses.
-          plain_value = predicate.right.value
-          predicate.right = plain_value
-        end
+          # Applied per attribute rather than to the reduced node: once several
+          # attributes are combined, the result is an And/Or whose `right` is
+          # another predicate node rather than a Casted value, so
+          # replace_right_node? returns false and nothing is unwrapped at all.
+          if replace_right_node?(predicate)
+            # Replace right node object to plain integer value in order to avoid
+            # ActiveModel::RangeError from Arel::Node::Casted.
+            # The error can be ignored here because RDBMSs accept large numbers
+            # in condition clauses.
+            plain_value = predicate.right.value
+            predicate.right = plain_value
+          end
 
-        predicate
+          predicate
+        }.reduce(combinator_method)
       end
 
       def not_nested_condition(attribute, parent_table)
@@ -343,14 +358,39 @@ module Ransack
       def format_predicate(attribute)
         arel_pred = arel_predicate_for_attribute(attribute)
         arel_values = formatted_values_for_attribute(attribute)
-        
+
+        # The `present` / `blank` predicate formatters produce `[nil, '']` regardless
+        # of column type. The empty-string half has no meaning on non-string columns:
+        # ActiveRecord casts `''` to NULL for those types, producing the
+        # always-UNKNOWN `column != NULL` (or `column = NULL`) clause. Strip the
+        # empty string when the attribute is not a string-like column.
+        if arel_values.is_a?(Array) && arel_values.include?(''.freeze) && !string_like_attribute?(attribute)
+          arel_values = arel_values.reject { |v| v == ''.freeze }
+        end
+
         # For LIKE predicates, wrap the value in Arel::Nodes.build_quoted to prevent
-        # ActiveRecord normalization from affecting wildcard patterns
+        # ActiveRecord normalization from affecting wildcard patterns, and pass
+        # the escape character so the escaping done by `escape_wildcards` is
+        # actually honoured. Without an explicit ESCAPE clause, SQLite treats a
+        # backslash as a literal character rather than an escape.
+        # See https://github.com/activerecord-hackery/ransack/issues/1581
+        # A length predicate compares LENGTH(column) rather than the column.
+        attr_value = length_predicate? ? length_function_for_attribute(attribute) : attr_value_for_attribute(attribute)
+
         if like_predicate?(arel_pred)
-          arel_values = Arel::Nodes.build_quoted(arel_values)
+          # The compound forms (matches_any / matches_all and their negations)
+          # iterate over an Array of patterns, so each element is quoted on its
+          # own; wrapping the whole Array in one node would hand them a single
+          # Quoted to iterate over.
+          arel_values = if arel_values.is_a?(Array)
+            arel_values.map { |v| Arel::Nodes.build_quoted(v) }
+          else
+            Arel::Nodes.build_quoted(arel_values)
+          end
+          predicate = attr_value.public_send(arel_pred, arel_values, Constants::LIKE_ESCAPE_CHARACTER)
+        else
+          predicate = attr_value.public_send(arel_pred, arel_values)
         end
-        
-        predicate = attr_value_for_attribute(attribute).public_send(arel_pred, arel_values)
 
         if in_predicate?(predicate)
           predicate.right = predicate.right.map do |pr|
@@ -366,8 +406,22 @@ module Ransack
         predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
       end
 
+      LIKE_PREDICATES = %w[
+        matches matches_any matches_all
+        does_not_match does_not_match_any does_not_match_all
+      ].freeze
+
       def like_predicate?(arel_predicate)
-        arel_predicate == 'matches' || arel_predicate == 'does_not_match'
+        LIKE_PREDICATES.include?(arel_predicate)
+      end
+
+      STRING_LIKE_TYPES = %i[string text citext].freeze
+
+      def string_like_attribute?(attribute)
+        type = attribute.type
+        # Treat unknown types as string-like (conservative: keep the existing
+        # empty-string comparison rather than silently dropping it).
+        type.nil? || STRING_LIKE_TYPES.include?(type.to_sym)
       end
 
       def casted_array?(predicate)
@@ -391,6 +445,28 @@ module Ransack
         attribute_type == :integer && arel_node.value.is_a?(Integer)
       end
 
+      def length_predicate?
+        predicate_name.to_s.start_with?('length_')
+      end
+
+      # CHAR_LENGTH counts characters and is the SQL standard spelling; SQLite
+      # has no CHAR_LENGTH and its LENGTH already counts characters for text.
+      CHAR_LENGTH_ADAPTERS = %w[PostgreSQL PostGIS Mysql2 Trilogy].freeze
+
+      def length_function_for_attribute(attribute)
+        function_name =
+          if CHAR_LENGTH_ADAPTERS.include?(ActiveRecord::Base.adapter_class::ADAPTER_NAME)
+            'CHAR_LENGTH'.freeze
+          else
+            'LENGTH'.freeze
+          end
+
+        Arel::Nodes::NamedFunction.new(
+          function_name,
+          [attr_value_for_attribute(attribute)]
+        )
+      end
+
       def valid_combinator?
         attributes.size < 2 || Constants::AND_OR.include?(combinator)
       end