actionset 0.8.1 → 0.11.0

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

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+
+class ActiveSet
+  module Filtering
+    module Enumerable
+      # rubocop:disable Metrics/ModuleLength
+      module Operators
+        NOT_TRANSFORMER = ->(result) { !result }
+        RANGE_TRANSFORMER = ->(value) { Range.new(*value.sort) }
+        REGEXP_TRANSFORMER = ->(value) { /#{Regexp.quote(value.to_s)}/ }
+        STRING_TRANSFORMER = ->(value) { value.to_s }
+
+        PREDICATES = {
+          EQ: {
+            operator: :'=='
+          },
+          NOT_EQ: {
+            operator: :'!='
+          },
+          EQ_ANY: {
+            operator: :'==',
+            reducer: :any?
+          },
+          EQ_ALL: {
+            operator: :'==',
+            reducer: :all?
+          },
+          NOT_EQ_ANY: {
+            operator: :'!=',
+            reducer: :any?
+          },
+          NOT_EQ_ALL: {
+            operator: :'!=',
+            reducer: :all?
+          },
+
+          IN: {
+            operator: :presence_in
+          },
+          NOT_IN: {
+            operator: :presence_in,
+            result_transformer: NOT_TRANSFORMER
+          },
+          IN_ANY: {
+            operator: :presence_in,
+            reducer: :any?
+          },
+          IN_ALL: {
+            operator: :presence_in,
+            reducer: :all?
+          },
+          NOT_IN_ANY: {
+            operator: :presence_in,
+            reducer: :any?,
+            result_transformer: NOT_TRANSFORMER
+          },
+          NOT_IN_ALL: {
+            operator: :presence_in,
+            reducer: :all?,
+            result_transformer: NOT_TRANSFORMER
+          },
+
+          MATCHES: {
+            operator: :'=~',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+          DOES_NOT_MATCH: {
+            operator: :'!~',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+          MATCHES_ANY: {
+            operator: :'=~',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+          MATCHES_ALL: {
+            operator: :'=~',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+          DOES_NOT_MATCH_ANY: {
+            operator: :'!~',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+          DOES_NOT_MATCH_ALL: {
+            operator: :'!~',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: REGEXP_TRANSFORMER
+          },
+
+          LT: {
+            operator: :'<'
+          },
+          LTEQ: {
+            operator: :'<='
+          },
+          LT_ANY: {
+            operator: :'<',
+            reducer: :any?
+          },
+          LT_ALL: {
+            operator: :'<',
+            reducer: :all?
+          },
+          LTEQ_ANY: {
+            operator: :'<=',
+            reducer: :any?
+          },
+          LTEQ_ALL: {
+            operator: :'<=',
+            reducer: :all?
+          },
+
+          GT: {
+            operator: :'>'
+          },
+          GTEQ: {
+            operator: :'>='
+          },
+          GT_ANY: {
+            operator: :'>',
+            reducer: :any?
+          },
+          GT_ALL: {
+            operator: :'>',
+            reducer: :all?
+          },
+          GTEQ_ANY: {
+            operator: :'>=',
+            reducer: :any?
+          },
+          GTEQ_ALL: {
+            operator: :'>=',
+            reducer: :all?
+          },
+
+          BETWEEN: {
+            operator: :cover?,
+            query_attribute_transformer: RANGE_TRANSFORMER
+          },
+          NOT_BETWEEN: {
+            operator: :cover?,
+            query_attribute_transformer: RANGE_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+
+          IS_TRUE: {
+            operator: :'==',
+            query_attribute_transformer: proc { |_| 1 }
+          },
+          IS_FALSE: {
+            operator: :'==',
+            query_attribute_transformer: proc { |_| 0 }
+          },
+
+          IS_NULL: {
+            operator: :'=='
+          },
+          NOT_NULL: {
+            operator: :'!='
+          },
+
+          IS_PRESENT: {
+            operator: :'!=',
+            reducer: :all?,
+            query_attribute_transformer: proc { |_| Constants::BLANK_VALUES }
+          },
+          IS_BLANK: {
+            operator: :'==',
+            reducer: :any?,
+            query_attribute_transformer: proc { |_| Constants::BLANK_VALUES }
+          },
+
+          MATCH_START: {
+            operator: :'start_with?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_START_ANY: {
+            operator: :'start_with?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_START_ALL: {
+            operator: :'start_with?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_NOT_START: {
+            operator: :'start_with?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_START_ANY: {
+            operator: :'start_with?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_START_ALL: {
+            operator: :'start_with?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_END: {
+            operator: :'end_with?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_END_ANY: {
+            operator: :'end_with?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_END_ALL: {
+            operator: :'end_with?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_NOT_END: {
+            operator: :'end_with?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_END_ANY: {
+            operator: :'end_with?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_END_ALL: {
+            operator: :'end_with?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_CONTAIN: {
+            operator: :'include?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_CONTAIN_ANY: {
+            operator: :'include?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_CONTAIN_ALL: {
+            operator: :'include?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN: {
+            operator: :'include?',
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN_ANY: {
+            operator: :'include?',
+            reducer: :any?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_TRANSFORMER
+          },
+          MATCH_NOT_CONTAIN_ALL: {
+            operator: :'include?',
+            reducer: :all?,
+            object_attribute_transformer: STRING_TRANSFORMER,
+            query_attribute_transformer: STRING_TRANSFORMER,
+            result_transformer: NOT_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/enumerable/set_instruction.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+require_relative '../../enumerable_set_instruction'
+require_relative './operators'
+
+class ActiveSet
+  module Filtering
+    module Enumerable
+      class SetInstruction < EnumerableSetInstruction
+        def item_matches_query?(item)
+          return query_result_for(item, query_attribute_for(instruction_value)) unless operator_hash.key?(:reducer)
+
+          Array.wrap(instruction_value).public_send(operator_hash[:reducer]) do |value|
+            query_result_for(item, query_attribute_for(value))
+          end
+        end
+
+        def set_item
+          return @set_item if defined? @set_item
+
+          @set_item = @set.find(&:present?)
+        end
+
+        def attribute_instance
+          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
+
+        private
+
+        def query_result_for(item, value)
+          result = if operator_method == :cover? && value.is_a?(Range)
+                     value
+                       .public_send(
+                         operator_method,
+                         object_attribute_for(item)
+                       )
+                   else
+                     object_attribute_for(item)
+                       .public_send(
+                         operator_method,
+                         value
+                       )
+                   end
+
+          return result unless operator_hash.key?(:result_transformer)
+
+          operator_hash[:result_transformer].call(result)
+        end
+
+        def object_attribute_for(item)
+          attribute = guarantee_attribute_type(attribute_value_for(item))
+          return attribute unless operator_hash.key?(:object_attribute_transformer)
+
+          operator_hash[:object_attribute_transformer].call(attribute)
+        end
+
+        def query_attribute_for(value)
+          attribute = guarantee_attribute_type(value)
+          return attribute unless operator_hash.key?(:query_attribute_transformer)
+
+          operator_hash[:query_attribute_transformer].call(attribute)
+        end
+
+        def operator_method
+          operator_hash.dig(:operator) || :'=='
+        end
+
+        def operator_hash
+          instruction_operator = @attribute_instruction.operator
+
+          Operators.get(instruction_operator)
+        end
+
+        def guarantee_attribute_type(attribute)
+          # Booleans don't respond to many operator methods,
+          # so we cast them to integers
+          return 1 if attribute == true
+          return 0 if attribute == false
+          return attribute.map { |a| guarantee_attribute_type(a) } if attribute.respond_to?(:each)
+
+          attribute
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative './set_instruction'
+require 'active_support/core_ext/module/delegation'
+
+class ActiveSet
+  module Filtering
+    module Enumerable
+      class Strategy
+        delegate :attribute_instance,
+                 :attribute_class,
+                 :instruction_value,
+                 :attribute_value_for,
+                 :operator,
+                 :attribute,
+                 :set_item,
+                 :resource_for,
+                 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? :select
+
+          if execute_filter_operation?
+            set = filter_operation
+          elsif execute_intersect_operation?
+            begin
+              set = intersect_operation
+            rescue TypeError # thrown if intersecting with a non-Array
+              return false
+            end
+          else
+            return false
+          end
+
+          set
+        end
+
+        private
+
+        def execute_filter_operation?
+          return false unless attribute_instance
+          return false unless attribute_instance.respond_to?(attribute)
+          return false if attribute_instance.method(attribute).arity.positive?
+
+          true
+        end
+
+        def execute_intersect_operation?
+          return false unless attribute_class
+          return false unless attribute_class.respond_to?(attribute)
+          return false if attribute_class.method(attribute).arity.zero?
+
+          true
+        end
+
+        def filter_operation
+          @set.select do |item|
+            @set_instruction.item_matches_query?(item)
+          end
+        end
+
+        def intersect_operation
+          @set & other_set
+        end
+
+        def other_set
+          other_set = attribute_class.public_send(
+            attribute,
+            instruction_value
+          )
+          if attribute_class != set_item.class
+            other_set = begin
+                        @set.select { |item| resource_for(item: item)&.presence_in other_set }
+                        rescue ArgumentError # thrown if other_set is doesn't respond to #include?, like when nil
+                          nil
+                      end
+          end
+
+          other_set
+        end
+      end
+    end
+  end
+end