actionset 0.8.1 → 0.11.0

data/lib/active_set/active_record_set_instruction.rb

@@ -9,15 +9,37 @@ class ActiveSet
     end
 
     def initial_relation
-      return @set if @attribute_instruction.associations_array.empty?
+      return @initial_relation if defined? @initial_relation
 
-      @set.eager_load(@attribute_instruction.associations_hash)
+      @initial_relation = if @attribute_instruction.associations_array.empty?
+                            @set
+                          else
+                            @set.eager_load(@attribute_instruction.associations_hash)
+                          end
     end
 
-    def arel_type
-      attribute_model
-        .columns_hash[@attribute_instruction.attribute]
-        .type
+    def arel_column
+      return @arel_column if defined? @arel_column
+
+      arel_column = arel_table[@attribute_instruction.attribute]
+      arel_column = arel_column.lower if case_insensitive_operation?
+
+      @arel_column = arel_column
+    end
+
+    def arel_column_name
+      arel_table[@attribute_instruction.attribute].name
+    end
+
+    def attribute_model
+      return @set.klass if @attribute_instruction.associations_array.empty?
+      return @attribute_model if defined? @attribute_model
+
+      @attribute_model = @attribute_instruction
+                         .associations_array
+                         .reduce(@set) do |obj, assoc|
+        obj.reflections[assoc.to_s]&.klass
+      end
     end
 
     def arel_table
@@ -31,37 +53,16 @@ class ActiveSet
       end
     end
 
-    def arel_column
-      _arel_column = arel_table[@attribute_instruction.attribute]
-      return _arel_column.lower if case_insensitive_operation?
+    private
 
-      _arel_column
-    end
-
-    def arel_operator
-      @attribute_instruction.operator(default: :eq)
-    end
-
-    def arel_value
-      _arel_value = @attribute_instruction.value
-      return _arel_value.downcase if case_insensitive_operation?
-
-      _arel_value
+    def arel_type
+      attribute_model
+        &.columns_hash[@attribute_instruction.attribute]
+        &.type
     end
 
     def case_insensitive_operation?
       @attribute_instruction.case_insensitive? && arel_type.presence_in(%i[string text])
     end
-
-    def attribute_model
-      return @set.klass if @attribute_instruction.associations_array.empty?
-      return @attribute_model if defined? @attribute_model
-
-      @attribute_model = @attribute_instruction
-                         .associations_array
-                         .reduce(@set) do |obj, assoc|
-        obj.reflections[assoc.to_s]&.klass
-      end
-    end
   end
 end

data/lib/active_set/attribute_instruction.rb

@@ -32,11 +32,11 @@ class ActiveSet
       @attribute = attribute
     end
 
-    def operator(default: '==')
+    def operator
       return @operator if defined? @operator
 
       attribute_instruction = @keypath.last
-      @operator = (attribute_instruction[operator_regex, 1] || default).to_sym
+      @operator = attribute_instruction[operator_regex, 1]&.to_sym
     end
 
     def options
@@ -92,7 +92,7 @@ class ActiveSet
     private
 
     def operator_regex
-      %r{\((.*?)\)}
+      /\((.*?)\)/
     end
 
     def options_regex

data/lib/active_set/enumerable_set_instruction.rb

@@ -9,16 +9,21 @@ class ActiveSet
     end
 
     def attribute_value_for(item)
-      item_value = @attribute_instruction
-                    .value_for(item: item)
-      item_value = item_value.downcase if case_insensitive_operation_for?(item_value)
-      item_value
+      @item_values ||= Hash.new do |h, key|
+        item_value = @attribute_instruction.value_for(item: key)
+        item_value = item_value.downcase if case_insensitive_operation_for?(item_value)
+        h[key] = item_value
+      end
+
+      @item_values[item]
     end
 
-    def attribute_value
-      _attribute_value = @attribute_instruction.value
-      _attribute_value = _attribute_value.downcase if case_insensitive_operation_for?(_attribute_value)
-      _attribute_value
+    def instruction_value
+      return @instruction_value if defined? @instruction_value
+
+      instruction_value = @attribute_instruction.value
+      instruction_value = instruction_value.downcase if case_insensitive_operation_for?(instruction_value)
+      @instruction_value = instruction_value
     end
 
     def case_insensitive_operation_for?(value)
@@ -26,21 +31,5 @@ class ActiveSet
 
       value.is_a?(String) || value.is_a?(Symbol)
     end
-
-    def attribute_instance
-      set_item = @set.find(&:present?)
-      return set_item if @attribute_instruction.associations_array.empty?
-      return @attribute_model if defined? @attribute_model
-
-      @attribute_model = @attribute_instruction
-                         .associations_array
-                         .reduce(set_item) do |obj, assoc|
-        obj.public_send(assoc)
-      end
-    end
-
-    def attribute_class
-      attribute_instance&.class
-    end
   end
 end

data/lib/active_set/filtering/active_record/operators.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+
+class ActiveSet
+  module Filtering
+    module ActiveRecord
+      # rubocop:disable Metrics/ModuleLength
+      module Operators
+        RANGE_TRANSFORMER = proc do |raw:, sql:, type:|
+          if type.presence_in %i[boolean]
+            Range.new(*sql.sort)
+          else
+            Range.new(*raw.sort)
+          end
+        end
+        BLANK_TRANSFORMER = proc do |type:, **_ctx|
+          if type.presence_in %i[date float integer time datetime boolean]
+            [nil]
+          else
+            Constants::BLANK_VALUES
+          end
+        end
+        MATCHER_TRANSFORMER = proc do |sql:, type:, **ctx|
+          next sql.map { |str| MATCHER_TRANSFORMER.call(sql: str, type: type, **ctx) } if sql.respond_to?(:map)
+
+          next sql if type != :decimal
+          next sql[0..-3] if sql.ends_with?('.0')
+          next sql[0..-4] + '%' if sql.ends_with?('.0%')
+
+          sql
+        end
+        START_MATCHER_TRANSFORMER = proc do |sql:, type:, **ctx|
+          next sql.map { |str| START_MATCHER_TRANSFORMER.call(sql: str, type: type, **ctx) } if sql.respond_to?(:map)
+
+          str = MATCHER_TRANSFORMER.call(sql: sql, type: type, **ctx)
+          next str if ['boolean'].include? type.to_s
+
+          str + '%'
+        end
+        END_MATCHER_TRANSFORMER = proc do |sql:, type:, **ctx|
+          next sql.map { |str| END_MATCHER_TRANSFORMER.call(sql: str, type: type, **ctx) } if sql.respond_to?(:map)
+
+          str = MATCHER_TRANSFORMER.call(sql: sql, type: type, **ctx)
+          next str if ['boolean'].include? type.to_s
+
+          '%' + str
+        end
+        CONTAIN_MATCHER_TRANSFORMER = proc do |sql:, type:, **ctx|
+          next sql.map { |str| CONTAIN_MATCHER_TRANSFORMER.call(sql: str, type: type, **ctx) } if sql.respond_to?(:map)
+
+          str = MATCHER_TRANSFORMER.call(sql: sql, type: type, **ctx)
+          next str if ['boolean'].include? type.to_s
+
+          '%' + str + '%'
+        end
+
+        PREDICATES = {
+          EQ: {
+            operator: :eq
+          },
+          NOT_EQ: {
+            operator: :not_eq
+          },
+          EQ_ANY: {
+            operator: :eq_any
+          },
+          EQ_ALL: {
+            operator: :eq_all
+          },
+          NOT_EQ_ANY: {
+            operator: :not_eq_any
+          },
+          NOT_EQ_ALL: {
+            operator: :not_eq_all
+          },
+
+          IN: {
+            operator: :in
+          },
+          NOT_IN: {
+            operator: :not_in
+          },
+          IN_ANY: {
+            operator: :in_any
+          },
+          IN_ALL: {
+            operator: :in_all
+          },
+          NOT_IN_ANY: {
+            operator: :not_in_any
+          },
+          NOT_IN_ALL: {
+            operator: :not_in_all
+          },
+
+          MATCHES: {
+            operator: :matches,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+          DOES_NOT_MATCH: {
+            operator: :does_not_match,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+          MATCHES_ANY: {
+            operator: :matches_any,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+          MATCHES_ALL: {
+            operator: :matches_all,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+          DOES_NOT_MATCH_ANY: {
+            operator: :does_not_match_any,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+          DOES_NOT_MATCH_ALL: {
+            operator: :does_not_match_all,
+            query_attribute_transformer: MATCHER_TRANSFORMER
+          },
+
+          LT: {
+            operator: :lt
+          },
+          LTEQ: {
+            operator: :lteq
+          },
+          LT_ANY: {
+            operator: :lt_any
+          },
+          LT_ALL: {
+            operator: :lt_all
+          },
+          LTEQ_ANY: {
+            operator: :lteq_any
+          },
+          LTEQ_ALL: {
+            operator: :lteq_all
+          },
+
+          GT: {
+            operator: :gt
+          },
+          GTEQ: {
+            operator: :gteq
+          },
+          GT_ANY: {
+            operator: :gt_any
+          },
+          GT_ALL: {
+            operator: :gt_all
+          },
+          GTEQ_ANY: {
+            operator: :gteq_any
+          },
+          GTEQ_ALL: {
+            operator: :gteq_all
+          },
+
+          BETWEEN: {
+            operator: :between,
+            query_attribute_transformer: RANGE_TRANSFORMER
+          },
+          NOT_BETWEEN: {
+            operator: :not_between,
+            query_attribute_transformer: RANGE_TRANSFORMER
+          },
+
+          IS_TRUE: {
+            operator: :eq,
+            query_attribute_transformer: proc { |_| true }
+          },
+          IS_FALSE: {
+            operator: :eq,
+            query_attribute_transformer: proc { |_| false }
+          },
+
+          IS_NULL: {
+            operator: :eq
+          },
+          NOT_NULL: {
+            operator: :not_eq
+          },
+
+          IS_PRESENT: {
+            operator: :not_eq_all,
+            query_attribute_transformer: BLANK_TRANSFORMER
+          },
+          IS_BLANK: {
+            operator: :eq_any,
+            query_attribute_transformer: BLANK_TRANSFORMER
+          },
+
+          MATCH_START: {
+            operator: :matches,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_START_ANY: {
+            operator: :matches_any,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_START_ALL: {
+            operator: :matches_all,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_START: {
+            operator: :does_not_match,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_START_ANY: {
+            operator: :does_not_match_any,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_START_ALL: {
+            operator: :does_not_match_all,
+            query_attribute_transformer: START_MATCHER_TRANSFORMER
+          },
+          MATCH_END: {
+            operator: :matches,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_END_ANY: {
+            operator: :matches_any,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_END_ALL: {
+            operator: :matches_all,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_END: {
+            operator: :does_not_match,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_END_ANY: {
+            operator: :does_not_match_any,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_END_ALL: {
+            operator: :does_not_match_all,
+            query_attribute_transformer: END_MATCHER_TRANSFORMER
+          },
+          MATCH_CONTAIN: {
+            operator: :matches,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          },
+          MATCH_CONTAIN_ANY: {
+            operator: :matches_any,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          },
+          MATCH_CONTAIN_ALL: {
+            operator: :matches_all,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN: {
+            operator: :does_not_match,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN_ANY: {
+            operator: :does_not_match_any,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN_ALL: {
+            operator: :does_not_match_all,
+            query_attribute_transformer: CONTAIN_MATCHER_TRANSFORMER
+          }
+        }.freeze
+
+        def self.get(operator_name)
+          operator_key = operator_name.to_s.upcase.to_sym
+
+          base_operator_hash = Constants::PREDICATES.fetch(operator_key, {})
+          this_operator_hash = Operators::PREDICATES.fetch(operator_key, {})
+
+          base_operator_hash.merge(this_operator_hash)
+        end
+      end
+      # rubocop:enable Metrics/ModuleLength
+    end
+  end
+end

data/lib/active_set/filtering/active_record/query_column.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    module ActiveRecord
+      module QueryColumn
+        def query_column
+          return @query_column if defined? @query_column
+
+          @query_column = if must_cast_numerical_column?
+                            column_cast_as_char
+                          else
+                            arel_column
+                          end
+        end
+
+        private
+
+        def column_cast_as_char
+          # In order to use LIKE, we must CAST the numeric column as a CHAR column.
+          # NOTE: this is can be quite inefficient, as it forces the DB engine to perform that cast on all rows.
+          # https://www.ryadel.com/en/like-operator-equivalent-integer-numeric-columns-sql-t-sql-database/
+          Arel::Nodes::NamedFunction.new('CAST', [arel_column.as('CHAR')])
+        end
+
+        def must_cast_numerical_column?
+          # The LIKE operator can't be used if the column hosts numeric types.
+          return false unless arel_type.presence_in(%i[integer float])
+
+          arel_operator.to_s.downcase.include?('match')
+        end
+      end
+    end
+  end
+end