activeset 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc73d4a0f511ddca2d0c895b7867816dc571102f
-  data.tar.gz: 02ac9b548790d30b2dac78a372b3ccc091769ed2
+  metadata.gz: eaba5e4aae16ae6f0dc4c2fad28b8c7177231448
+  data.tar.gz: 5d9b7ec416a8462f9a98db7f7aa04472357ccd9d
 SHA512:
-  metadata.gz: 029232215b1cd1280f1b75757198bce5e97aa2e64603f2fa5c51aef8304407c7b56e1b0928a0e09fac080c9de272b00716842d94ad122a99f97d8f5337a1d58b
-  data.tar.gz: e73777713e06505233491977d66b4f48966e3ce5a50b4b99dcc242f00db13349e10ac3166a6ac5fff0da0cfcad02fffcf61359cba737b6e20c63d8694df8216a
+  metadata.gz: 79079f1f927cb72e863a15a1f0ccee14a3cb3b2b3f7e32cc5b40e2dc71ee52c0b76ba4af21c46e8b98b896183c739f78662f58e16596fef10f5dccd829486df1
+  data.tar.gz: be55e192739fe5b3bdcb6a1a6775ec932310467440826c7362c102e2aaba0595facd02acba55f30d30f243ba26101a971f7758b37130dcfe47001196d0ef909b

data/CHANGELOG

@@ -1,3 +1,9 @@
+v 0.4.0
+  - fix bug with filtering against falsey values
+  - remove hack of casting DateTime and Time objects to Integer for filtering
+  - add support for ActiveRecord :time columns
+  - ensure that an adapter is only run if necessary for a particular instruction; that is, try to process the instruction with the first adapter, if it succeeds, don't run any other adapters, if it doesn't, try the next adapter, etc.
+  - allow ActiveRecord sets to be filtered by a scope method
 v 0.3.1
   - Implement an Instructions object layer for handling the hashes passed into Processors
 v 0.3.0

data/lib/active_set.rb

@@ -32,18 +32,18 @@ class ActiveSet
     @set.respond_to?(method_name) || super
   end
 
-  def filter(structure)
-    filterer = FilterProcessor.new(@set, structure)
+  def filter(instructions)
+    filterer = FilterProcessor.new(@set, instructions)
     self.class.new(filterer.process)
   end
 
-  def sort(structure)
-    sorter = SortProcessor.new(@set, structure)
+  def sort(instructions)
+    sorter = SortProcessor.new(@set, instructions)
     self.class.new(sorter.process)
   end
 
-  def paginate(structure)
-    paginater = PaginateProcessor.new(@set, structure)
+  def paginate(instructions)
+    paginater = PaginateProcessor.new(@set, instructions)
     self.class.new(paginater.process)
   end
 end

data/lib/active_set/instructions/base.rb

@@ -8,19 +8,27 @@ class ActiveSet
 
     def initialize(hash)
       @hash = hash
-      @flattened_hash = hash.flatten_keys
+      @flattened_hash = hash.flatten_keys.transform_keys { |k| k.map(&:to_s) }
     end
 
     def process_adapter(set:, adapter:)
-      @flattened_hash.reject { |_, v| v.blank? }
-                     .reduce(set) do |inner_set, (keypath, value)|
-                       instruction = Entry.new(keypath, value)
-                       adapter.new(instruction).process(inner_set)
-                     end
+      @flattened_hash.reduce(set) do |inner_set, (keypath, value)|
+        instruction = Entry.new(keypath, value)
+        output = adapter.new(inner_set, instruction).process
+        remove_from_instruction_set(key: instruction.path) if output[:processed]
+
+        output[:set]
+      end
     end
 
     def get(keypath)
       @hash.dig(*keypath)
     end
+
+    private
+
+    def remove_from_instruction_set(key:)
+      @flattened_hash.delete(key)
+    end
   end
 end

data/lib/active_set/instructions/entry.rb

@@ -10,7 +10,8 @@ class ActiveSet
     class Entry
       attr_reader :keypath
 
-      delegate :attribute, :operator, :associations_array, :associations_hash, :value_for, :resource_for,
+      delegate :path, :attribute, :operator, :associations_array,
+               :associations_hash, :value_for, :resource_for,
                to: :keypath
 
       def initialize(keypath, value)

data/lib/active_set/processors/base_adapter.rb

@@ -2,8 +2,16 @@
 
 class ActiveSet
   class BaseAdapter
-    def initialize(instruction)
+    def initialize(set, instruction)
+      @set = set
       @instruction = instruction
     end
+
+    def return_set(set = nil)
+      {}.tap do |h|
+        h[:set] = set || @set
+        h[:processed] = set ? true : false
+      end
+    end
   end
 end

data/lib/active_set/processors/filter/active_record_adapter.rb

@@ -6,26 +6,40 @@ require_relative '../base_processor'
 class ActiveSet
   class FilterProcessor < BaseProcessor
     class ActiveRecordAdapter < BaseAdapter
-      def process(set)
-        @set = set
-        return @set unless @set.respond_to? :to_sql
-        return @set unless attribute_is_field?
+      def process
+        return return_set unless @set.respond_to? :to_sql
+        return return_set(processed_query_set) if attribute_is_field?
+        return return_set(processed_scope_set) if attribute_is_class_method? && attribute_is_method_with_params?
 
-        query
+        return_set
       end
 
       private
 
+      def processed_query_set
+        arel_eager_load_associations.where(arel_operation)
+      end
+
+      def processed_scope_set
+        tmp_results = attribute_model.public_send(@instruction.attribute, @instruction.value)
+        return @set unless tmp_results.is_a?(ActiveRecord::Relation)
+        arel_eager_load_associations.merge(tmp_results)
+      end
+
       def attribute_is_field?
         return false unless attribute_model
         attribute_model.attribute_names
                        .include?(@instruction.attribute)
       end
 
-      def query
-        @set.includes(@instruction.associations_hash)
-            .references(@instruction.associations_hash)
-            .where(arel_operation)
+      def attribute_is_class_method?
+        return false unless attribute_model
+        attribute_model.respond_to?(@instruction.attribute)
+      end
+
+      def attribute_is_method_with_params?
+        return false unless attribute_model
+        attribute_model.method(@instruction.attribute).arity != 0
       end
 
       def arel_operation
@@ -41,6 +55,11 @@ class ActiveSet
                     end
       end
 
+      def arel_eager_load_associations
+        @set.includes(@instruction.associations_hash)
+            .references(@instruction.associations_hash)
+      end
+
       def arel_column
         arel_table[@instruction.attribute]
       end

data/lib/active_set/processors/filter/enumerable_adapter.rb

@@ -5,28 +5,22 @@ require_relative '../base_adapter'
 class ActiveSet
   class FilterProcessor < BaseProcessor
     class EnumerableAdapter < BaseAdapter
-      def process(set)
-        set.select do |item|
-          value_for(item).send(@instruction.operator,
-                               passed_value)
-        end
+      def process
+        return_set(filtered_set)
       end
 
       private
 
-      def value_for(item)
-        convert_datetime_values_to_integer(@instruction.value_for(item: item))
-      end
-
-      def passed_value
-        convert_datetime_values_to_integer(@instruction.value)
+      def filtered_set
+        @set.select do |item|
+          select_comparison_for(item: item)
+        end
       end
 
-      def convert_datetime_values_to_integer(value)
-        # DateTimes (and Times) are tricky to compare, Integers are easier
-        # and I only care about second precision
-        return value unless value.is_a?(DateTime)
-        value.to_i
+      def select_comparison_for(item:)
+        @instruction.value_for(item: item)
+                    .send(@instruction.operator,
+                          @instruction.value)
       end
     end
   end

data/lib/active_set/processors/paginate/enumerable_adapter.rb

@@ -6,12 +6,17 @@ require_relative '../base_processor'
 class ActiveSet
   class PaginateProcessor < BaseProcessor
     class EnumerableAdapter < BaseAdapter
-      def process(set)
-        set.each_slice(pagesize).take(page_number).last
+      def process
+        return return_set if @set.count < pagesize
+        return_set(paginated_set)
       end
 
       private
 
+      def paginated_set
+        @set.each_slice(pagesize).take(page_number).last
+      end
+
       def pagesize
         @instruction.value
       end

data/lib/active_set/processors/paginate_processor.rb

@@ -6,8 +6,7 @@ require_relative './paginate/enumerable_adapter'
 class ActiveSet
   class PaginateProcessor < BaseProcessor
     def process
-      return @set if @set.count < pagesize
-      adapter.new(instruction).process(@set)
+      adapter.new(@set, instruction).process
     end
 
     private

data/lib/active_set/processors/sort/active_record_adapter.rb

@@ -6,14 +6,11 @@ require_relative '../base_processor'
 class ActiveSet
   class SortProcessor < BaseProcessor
     class ActiveRecordAdapter < BaseAdapter
-      def process(set)
-        @set = set
-        return @set unless @set.respond_to? :to_sql
-        return @set unless attribute_is_field?
+      def process
+        return return_set unless @set.respond_to? :to_sql
+        return return_set unless attribute_is_field?
 
-        @set.includes(@instruction.associations_hash)
-            .references(@instruction.associations_hash)
-            .merge(arel_operation)
+        return_set(processed_set)
       end
 
       private
@@ -24,6 +21,12 @@ class ActiveSet
                        .include?(@instruction.attribute)
       end
 
+      def processed_set
+        @set.includes(@instruction.associations_hash)
+            .references(@instruction.associations_hash)
+            .merge(arel_operation)
+      end
+
       def arel_operation
         column = case_insensitive? ? arel_column.lower : arel_column
         attribute_model.order(column.send(@instruction.value))

data/lib/active_set/processors/sort/enumerable_adapter.rb

@@ -6,15 +6,22 @@ require_relative '../base_processor'
 class ActiveSet
   class SortProcessor < BaseProcessor
     class EnumerableAdapter < BaseAdapter
-      def process(set)
-        set.sort_by do |item|
-          attribute_value = @instruction.value_for(item: item)
-          case_insensitive?(attribute_value) ? insensify(attribute_value) : attribute_value
-        end.tap { |c| c.reverse! if @instruction.value.to_s == 'desc' }
+      def process
+        return_set(sorted_set)
       end
 
       private
 
+      def sorted_set
+        @set.sort_by { |item| sortable_attribute_for(item: item) }
+            .tap { |c| c.reverse! if descending? }
+      end
+
+      def sortable_attribute_for(item:)
+        attribute_value = @instruction.value_for(item: item)
+        case_insensitive?(attribute_value) ? insensify(attribute_value) : attribute_value
+      end
+
       def case_insensitive?(value)
         # Cannot sort pure Booleans or Nils, so we _must_ cast to Strings
         return true if value.is_a?(TrueClass) || value.is_a?(FalseClass)
@@ -25,6 +32,10 @@ class ActiveSet
       def insensify(value)
         value.to_s.downcase
       end
+
+      def descending?
+        @instruction.value.to_s == 'desc'
+      end
     end
   end
 end

data/lib/active_set/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ActiveSet
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeset
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport