actionset 0.8.2 → 0.9.1

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

@@ -0,0 +1,277 @@
+# 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]
+            [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)
+
+          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)
+
+          '%' + 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)
+
+          '%' + 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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    module ActiveRecord
+      module QueryValue
+        def query_value
+          return @query_value if defined? @query_value
+
+          query_value = @attribute_instruction.value
+          query_value = query_attribute_for(query_value)
+          query_value = query_value.downcase if case_insensitive_operation?
+
+          @query_value = query_value
+        end
+
+        private
+
+        def query_attribute_for(value)
+          return value unless operator_hash.key?(:query_attribute_transformer)
+
+          context = {
+            raw: value,
+            sql: to_sql_str(value),
+            type: arel_type
+          }
+
+          operator_hash[:query_attribute_transformer].call(context)
+        end
+
+        def to_sql_str(value)
+          return value.map { |a| to_sql_str(a) } if value.respond_to?(:map)
+
+          arel_node = Arel::Nodes::Casted.new(value, arel_column)
+          sql_value = arel_node.to_sql
+          unwrap_sql_str(sql_value)
+        end
+
+        def unwrap_sql_str(sql_str)
+          return sql_str unless sql_str[0] == "'" && sql_str[-1] == "'"
+
+          sql_str[1..-2]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../active_record_set_instruction'
+require_relative './operators'
+require_relative './query_value'
+require_relative './query_column'
+
+class ActiveSet
+  module Filtering
+    module ActiveRecord
+      class SetInstruction < ActiveRecordSetInstruction
+        include QueryValue
+        include QueryColumn
+
+        def arel_operator
+          operator_hash.fetch(:operator, :eq)
+        end
+
+        private
+
+        def operator_hash
+          instruction_operator = @attribute_instruction.operator
+
+          Operators.get(instruction_operator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative './set_instruction'
+require 'active_support/core_ext/module/delegation'
+
+class ActiveSet
+  module Filtering
+    module ActiveRecord
+      class Strategy
+        delegate :attribute_model,
+                 :query_column,
+                 :arel_operator,
+                 :query_value,
+                 :arel_type,
+                 :initial_relation,
+                 :attribute,
+                 to: :@set_instruction
+
+        def initialize(set, attribute_instruction)
+          @set = set
+          @attribute_instruction = attribute_instruction
+          @set_instruction = SetInstruction.new(attribute_instruction, set)
+        end
+
+        def execute
+          return false unless @set.respond_to? :to_sql
+
+          if execute_filter_operation?
+            statement = filter_operation
+          elsif execute_intersect_operation?
+            begin
+              statement = intersect_operation
+            rescue ArgumentError # thrown if merging a non-ActiveRecord::Relation
+              return false
+            end
+          else
+            return false
+          end
+
+          statement
+        end
+
+        private
+
+        def execute_filter_operation?
+          return false unless attribute_model
+          return false unless attribute_model.respond_to?(:attribute_names)
+          return false unless attribute_model.attribute_names.include?(attribute)
+
+          true
+        end
+
+        def execute_intersect_operation?
+          return false unless attribute_model
+          return false unless attribute_model.respond_to?(attribute)
+          return false if attribute_model.method(attribute).arity.zero?
+
+          true
+        end
+
+        def filter_operation
+          initial_relation
+            .where(
+              query_column.send(
+                arel_operator,
+                query_value
+              )
+            )
+        end
+
+        def intersect_operation
+          # NOTE: If merging relations that contain duplicate column conditions,
+          # the second condition will replace the first.
+          # e.g. Thing.where(id: [1,2]).merge(Thing.where(id: [2,3]))
+          # => [Thing<2>, Thing<3>] NOT [Thing<2>]
+          initial_relation
+            .merge(
+              attribute_model.public_send(
+                attribute,
+                query_value
+              )
+            )
+        end
+      end
+    end
+  end
+end