actionset 0.8.2 → 0.9.1

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

data/lib/active_set/filtering/operation.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../attribute_instruction'
-require_relative './enumerable_strategy'
-require_relative './active_record_strategy'
+require_relative './enumerable/strategy'
+require_relative './active_record/strategy'
 
 class ActiveSet
   module Filtering
@@ -17,7 +17,7 @@ class ActiveSet
                                  .map { |k, v| AttributeInstruction.new(k, v) }
 
         activerecord_filtered_set = attribute_instructions.reduce(@set) do |set, attribute_instruction|
-          maybe_set_or_false = ActiveRecordStrategy.new(set, attribute_instruction).execute
+          maybe_set_or_false = ActiveRecord::Strategy.new(set, attribute_instruction).execute
           next set unless maybe_set_or_false
 
           attribute_instruction.processed = true
@@ -27,7 +27,7 @@ class ActiveSet
         return activerecord_filtered_set if attribute_instructions.all?(&:processed?)
 
         attribute_instructions.reject(&:processed?).reduce(activerecord_filtered_set) do |set, attribute_instruction|
-          maybe_set_or_false = EnumerableStrategy.new(set, attribute_instruction).execute
+          maybe_set_or_false = Enumerable::Strategy.new(set, attribute_instruction).execute
           next set unless maybe_set_or_false
 
           attribute_instruction.processed = true

data/lib/helpers/flatten_keys_of.rb

@@ -24,7 +24,7 @@ require 'active_support/core_ext/array/wrap'
 #   => { "key"=>"value", "nested.key"=>"nested_value", "array.0"=>0, "array.1"=>1, "array.2"=>2 }
 
 # refactored from https://stackoverflow.com/a/23861946/2884386
-def flatten_keys_of(input, keys = [], output = {}, flattener: ->(*keys) { keys }, flatten_arrays: false)
+def flatten_keys_of(input, keys = [], output = {}, flattener: ->(*k) { k }, flatten_arrays: false)
   if input.is_a?(Hash)
     input.each do |key, value|
       flatten_keys_of(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionset
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.1
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-15 00:00:00.000000000 Z
+date: 2019-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -270,6 +270,11 @@ files:
 - lib/action_set/helpers/pagination/page_size_for_helper.rb
 - lib/action_set/helpers/pagination/path_for_helper.rb
 - lib/action_set/helpers/pagination/prev_page_link_for_helper.rb
+- lib/action_set/helpers/pagination/record_description_for_helper.rb
+- lib/action_set/helpers/pagination/record_first_for_helper.rb
+- lib/action_set/helpers/pagination/record_last_for_helper.rb
+- lib/action_set/helpers/pagination/record_range_for_helper.rb
+- lib/action_set/helpers/pagination/record_size_for_helper.rb
 - lib/action_set/helpers/pagination/total_pages_for_helper.rb
 - lib/action_set/helpers/params/current_helper.rb
 - lib/action_set/helpers/params/form_for_object_helper.rb
@@ -286,8 +291,15 @@ files:
 - lib/active_set/enumerable_set_instruction.rb
 - lib/active_set/exporting/csv_strategy.rb
 - lib/active_set/exporting/operation.rb
-- lib/active_set/filtering/active_record_strategy.rb
-- lib/active_set/filtering/enumerable_strategy.rb
+- lib/active_set/filtering/active_record/operators.rb
+- lib/active_set/filtering/active_record/query_column.rb
+- lib/active_set/filtering/active_record/query_value.rb
+- lib/active_set/filtering/active_record/set_instruction.rb
+- lib/active_set/filtering/active_record/strategy.rb
+- lib/active_set/filtering/constants.rb
+- lib/active_set/filtering/enumerable/operators.rb
+- lib/active_set/filtering/enumerable/set_instruction.rb
+- lib/active_set/filtering/enumerable/strategy.rb
 - lib/active_set/filtering/operation.rb
 - lib/active_set/paginating/active_record_strategy.rb
 - lib/active_set/paginating/enumerable_strategy.rb

data/lib/active_set/filtering/active_record_strategy.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../active_record_set_instruction'
-require 'active_support/core_ext/module/delegation'
-
-class ActiveSet
-  module Filtering
-    class ActiveRecordStrategy
-      delegate :attribute_model,
-               :arel_column,
-               :arel_operator,
-               :arel_value,
-               :arel_type,
-               :initial_relation,
-               :attribute,
-               to: :@set_instruction
-
-      def initialize(set, attribute_instruction)
-        @set = set
-        @attribute_instruction = attribute_instruction
-        @set_instruction = ActiveRecordSetInstruction.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(
-            arel_column.send(
-              arel_operator,
-              arel_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,
-              arel_value
-            )
-          )
-      end
-    end
-  end
-end

data/lib/active_set/filtering/enumerable_strategy.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../enumerable_set_instruction'
-require 'active_support/core_ext/module/delegation'
-
-class ActiveSet
-  module Filtering
-    class EnumerableStrategy
-      delegate :attribute_instance,
-               :attribute_class,
-               :attribute_value,
-               :attribute_value_for,
-               :operator,
-               :attribute,
-               to: :@set_instruction
-
-      def initialize(set, attribute_instruction)
-        @set = set
-        @attribute_instruction = attribute_instruction
-        @set_instruction = EnumerableSetInstruction.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|
-          attribute_value_for(item)
-            .public_send(
-              operator,
-              attribute_value
-            )
-        end
-      end
-
-      def intersect_operation
-        other_set = attribute_class
-                    .public_send(
-                      attribute,
-                      attribute_value
-                    )
-        @set & other_set
-      end
-    end
-  end
-end