actionset 0.8.1 → 0.11.0

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

data/lib/active_set/filtering/constants.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    # rubocop:disable Metrics/ModuleLength
+    module Constants
+      BLANK_VALUES = [nil, ''].freeze
+
+      PREDICATES = {
+        EQ: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive,
+          shorthand: :'=='
+        },
+        NOT_EQ: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive,
+          shorthand: :'!='
+        },
+        EQ_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E=='
+        },
+        EQ_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A=='
+        },
+        NOT_EQ_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E!='
+        },
+        NOT_EQ_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A!='
+        },
+
+        IN: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'<<'
+        },
+        NOT_IN: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'!<'
+        },
+        IN_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E<<'
+        },
+        IN_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A<<'
+        },
+        NOT_IN_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E!<'
+        },
+        NOT_IN_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A!<'
+        },
+
+        MATCHES: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive,
+          shorthand: :'=~'
+        },
+        DOES_NOT_MATCH: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive,
+          shorthand: :'!~'
+        },
+        MATCHES_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E=~'
+        },
+        MATCHES_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A=~'
+        },
+        DOES_NOT_MATCH_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E!~'
+        },
+        DOES_NOT_MATCH_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A!~'
+        },
+
+        LT: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive,
+          shorthand: :'<'
+        },
+        LTEQ: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive,
+          shorthand: :'<='
+        },
+        LT_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inconclusive,
+          shorthand: :'E<'
+        },
+        LT_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A<'
+        },
+        LTEQ_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E<='
+        },
+        LTEQ_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :inconclusive,
+          shorthand: :'A<='
+        },
+
+        GT: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive,
+          shorthand: :'>'
+        },
+        GTEQ: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive,
+          shorthand: :'>='
+        },
+        GT_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inconclusive,
+          shorthand: :'E>'
+        },
+        GT_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A>'
+        },
+        GTEQ_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E>='
+        },
+        GTEQ_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :inconclusive,
+          shorthand: :'A>='
+        },
+
+        BETWEEN: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'..'
+        },
+        NOT_BETWEEN: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'!.'
+        },
+
+        IS_TRUE: {
+          type: :unary,
+          operator: :eq,
+          compound: false,
+          behavior: :inconclusive
+        },
+        IS_FALSE: {
+          type: :unary,
+          operator: :eq,
+          compound: false,
+          behavior: :inconclusive
+        },
+
+        IS_NULL: {
+          type: :unary,
+          operator: :eq,
+          compound: false,
+          behavior: :exclusive,
+          query_attribute_transformer: proc { |_| nil }
+        },
+        NOT_NULL: {
+          type: :unary,
+          operator: :not_eq,
+          compound: false,
+          behavior: :inclusive,
+          query_attribute_transformer: proc { |_| nil }
+        },
+
+        IS_PRESENT: {
+          type: :unary,
+          operator: :not_eq_all,
+          compound: false,
+          behavior: :inclusive
+        },
+        IS_BLANK: {
+          type: :unary,
+          operator: :eq_any,
+          compound: false,
+          behavior: :exclusive
+        },
+
+        MATCH_START: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive
+        },
+        MATCH_START_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive
+        },
+        MATCH_START_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive
+        },
+        MATCH_NOT_START: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive
+        },
+        MATCH_NOT_START_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive
+        },
+        MATCH_NOT_START_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive
+        },
+        MATCH_END: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive
+        },
+        MATCH_END_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive
+        },
+        MATCH_END_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive
+        },
+        MATCH_NOT_END: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive
+        },
+        MATCH_NOT_END_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive
+        },
+        MATCH_NOT_END_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive
+        },
+        MATCH_CONTAIN: {
+          type: :binary,
+          compound: false,
+          behavior: :inclusive,
+          shorthand: :'~*'
+        },
+        MATCH_CONTAIN_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E~*'
+        },
+        MATCH_CONTAIN_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A~*'
+        },
+        MATCH_NOT_CONTAIN: {
+          type: :binary,
+          compound: false,
+          behavior: :exclusive,
+          shorthand: :'!*'
+        },
+        MATCH_NOT_CONTAIN_ANY: {
+          type: :binary,
+          compound: true,
+          behavior: :inclusive,
+          shorthand: :'E!*'
+        },
+        MATCH_NOT_CONTAIN_ALL: {
+          type: :binary,
+          compound: true,
+          behavior: :exclusive,
+          shorthand: :'A!*'
+        }
+      }.freeze
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end