actionset 0.8.1 → 0.11.0

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
@@ -12,14 +12,12 @@ class ActiveSet
         @instructions_hash = instructions_hash
       end
 
-      # rubocop:disable Metrics/MethodLength
       def execute
-        attribute_instructions = @instructions_hash
-                                 .flatten_keys
+        attribute_instructions = flatten_keys_of(@instructions_hash)
                                  .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
@@ -29,14 +27,13 @@ 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
           maybe_set_or_false
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       def operation_instructions
         @instructions_hash.symbolize_keys

data/lib/active_set/paginating/active_record_strategy.rb

@@ -10,8 +10,6 @@ class ActiveSet
 
       def execute
         return false unless @set.respond_to? :to_sql
-        return @set.none if @set.length <= @operation_instructions[:size] &&
-                            @operation_instructions[:page] > 1
 
         @set.limit(@operation_instructions[:size]).offset(page_offset)
       end

data/lib/active_set/sorting/active_record_strategy.rb

@@ -41,17 +41,23 @@ class ActiveSet
       private
 
       # https://stackoverflow.com/a/44912964/2884386
-      # Force null values to be sorted as if larger than any non-null value
+      # When ActiveSet.configuration.on_asc_sort_nils_come == :last
+      # null values to be sorted as if larger than any non-null value.
       # ASC => [-2, -1, 1, 2, nil]
       # DESC => [nil, 2, 1, -1, -2]
+      # Otherwise sort nulls as if smaller than any non-null value.
+      # ASC => [nil, -2, -1, 1, 2]
+      # DESC => [2, 1, -1, -2, nil]
       def order_operation_for(set_instruction)
         attribute_model = set_instruction.attribute_model
 
         arel_column = set_instruction.arel_column
         arel_direction = direction_operator(set_instruction.value)
-        nil_sorter = arel_column.send(arel_direction == :asc ? :eq : :not_eq, nil)
 
-        attribute_model.order(nil_sorter).order(arel_column.send(arel_direction))
+        attribute_model.order(Arel.sql(nil_sorter_for(set_instruction.arel_table,
+                                                      set_instruction.arel_column_name,
+                                                      arel_direction)))
+                       .order(arel_column.send(arel_direction))
       end
 
       def direction_operator(direction)
@@ -59,6 +65,24 @@ class ActiveSet
 
         :asc
       end
+
+      def nil_sorter_for(model, column, direction)
+        "CASE WHEN #{model.table_name}.#{column} IS NULL #{nil_sorter_then_statement(direction)}"
+      end
+
+      def nil_sorter_then_statement(direction)
+        first = 'THEN 0 ELSE 1 END'
+        last = 'THEN 1 ELSE 0 END'
+        if ActiveSet.configuration.on_asc_sort_nils_come == :last
+          return last if direction == :asc
+
+          return first
+        else
+          return first if direction == :asc
+
+          return last
+        end
+      end
     end
   end
 end

data/lib/active_set/sorting/enumerable_strategy.rb

@@ -21,11 +21,15 @@ class ActiveSet
             value_for_comparison = sortable_numeric_for(set_instruction, item)
             direction_multiplier = direction_multiplier(set_instruction.value)
 
-            # Force null values to be sorted as if larger than any non-null value
+            # When ActiveSet.configuration.on_asc_sort_nils_come == :last
+            # null values to be sorted as if larger than any non-null value.
             # ASC => [-2, -1, 1, 2, nil]
             # DESC => [nil, 2, 1, -1, -2]
+            # Otherwise sort nulls as if smaller than any non-null value.
+            # ASC => [nil, -2, -1, 1, 2]
+            # DESC => [2, 1, -1, -2, nil]
             if value_for_comparison.nil?
-              [direction_multiplier, 0]
+              [direction_multiplier * nil_sorter, 0]
             else
               [0, value_for_comparison * direction_multiplier]
             end
@@ -44,6 +48,12 @@ class ActiveSet
 
         1
       end
+
+      def nil_sorter
+        return 1 if ActiveSet.configuration.on_asc_sort_nils_come == :last
+
+        -1
+      end
     end
   end
 end

data/lib/active_set/sorting/operation.rb

@@ -13,8 +13,7 @@ class ActiveSet
       end
 
       def execute
-        attribute_instructions = @instructions_hash
-                                 .flatten_keys
+        attribute_instructions = flatten_keys_of(@instructions_hash)
                                  .map { |k, v| AttributeInstruction.new(k, v) }
 
         activerecord_strategy = ActiveRecordStrategy.new(@set, attribute_instructions)

data/lib/helpers/flatten_keys_of.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+
+# Returns a flat hash where all nested keys are flattened into an array of keys.
+#
+#   hash = { key: 'value', nested: { key: 'nested_value' }, array: [0, 1, 2] }
+#   flatten_keys_of(hash)
+#   => { [:key]=>"value", [:nested, :key]=>"nested_value", [:array]=>[0, 1, 2] }
+#
+# Can also pass a Proc to change how nested keys are flattened:
+#   flatten_keys_of(hash, flattener: ->(*keys) { keys.join('.') })
+#   => { "key"=>"value", "nested.key"=>"nested_value", "array"=>[0, 1, 2] }
+#   flatten_keys_of(hash, flattener: ->(*keys) { keys.join('-') })
+#   => { "key"=>"value", "nested-key"=>"nested_value", "array"=>[0, 1, 2] }
+#   flatten_keys_of(hash, flattener: ->(*keys) { keys.map(&:to_s).reduce { |memo, key| memo + "[#{key}]" } })
+#   => { "key"=>"value", "nested[key]"=>"nested_value", "array"=>[0, 1, 2] }
+#
+# Can also determine if array values should be flattened as well:
+#   hash = { person: { age: '28', siblings: ['Tom', 'Sally'] } }
+#   flatten_keys_of(hash, flatten_arrays: true)
+#   => { [:key]=>"value", [:nested, :key]=>"nested_value", [:array, 0]=>0, [:array, 1]=>1, [:array, 2]=>2 }
+#   flatten_keys_of(hash, flattener: ->(*keys) { keys.join('.') }, flatten_arrays: true)
+#   => { "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: ->(*k) { k }, flatten_arrays: false)
+  if input.is_a?(Hash)
+    input.each do |key, value|
+      flatten_keys_of(
+        value,
+        keys + Array.wrap(key),
+        output,
+        flattener: flattener,
+        flatten_arrays: flatten_arrays
+      )
+    end
+  elsif input.is_a?(Array) && flatten_arrays
+    input.each_with_index do |value, index|
+      flatten_keys_of(
+        value,
+        keys + Array.wrap(index),
+        output,
+        flattener: flattener,
+        flatten_arrays: flatten_arrays
+      )
+    end
+  else
+    return output.merge!(flattener.call(*keys) => input)
+  end
+
+  output
+end

data/lib/helpers/transform_to_sortable_numeric.rb

@@ -13,7 +13,7 @@
 # transform_to_sortable_numeric(Date.new(2000, 12, 25))
 # => 977720400000
 
-# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 def transform_to_sortable_numeric(value)
   # https://www.justinweiss.com/articles/4-simple-memoization-patterns-in-ruby-and-one-gem/#and-what-about-parameters
   @sortable_numeric ||= Hash.new do |h, key|
@@ -35,8 +35,7 @@ def transform_to_sortable_numeric(value)
   end
   @sortable_numeric[value]
 end
-# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-# rubocop:enable Style/AsciiComments
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
 def string_to_sortable_numeric(string)
   string                                          # 'aB09ü'
@@ -46,6 +45,7 @@ def string_to_sortable_numeric(string)
     .reduce(&:concat)                             # "097.066048057252"
     .to_r                                         # (24266512014313/250000000000)
 end
+# rubocop:enable Style/AsciiComments
 
 def time_to_sortable_numeric(time)
   # https://stackoverflow.com/a/30604935/2884386

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionset
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Stephen Margheim
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-05-11 00:00:00.000000000 Z
+date: 2021-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.1.0
+        version: 5.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.1.0
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -259,6 +259,7 @@ files:
 - config.ru
 - lib/action_set.rb
 - lib/action_set/attribute_value.rb
+- lib/action_set/filter_instructions.rb
 - lib/action_set/helpers/export/path_for_helper.rb
 - lib/action_set/helpers/helper_methods.rb
 - lib/action_set/helpers/pagination/current_page_description_for_helper.rb
@@ -270,6 +271,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
@@ -279,6 +285,7 @@ files:
 - lib/action_set/helpers/sort/link_for_helper.rb
 - lib/action_set/helpers/sort/next_direction_for_helper.rb
 - lib/action_set/helpers/sort/path_for_helper.rb
+- lib/action_set/sort_instructions.rb
 - lib/active_set.rb
 - lib/active_set/active_record_set_instruction.rb
 - lib/active_set/attribute_instruction.rb
@@ -286,8 +293,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
@@ -295,15 +309,14 @@ files:
 - lib/active_set/sorting/active_record_strategy.rb
 - lib/active_set/sorting/enumerable_strategy.rb
 - lib/active_set/sorting/operation.rb
-- lib/helpers/throws.rb
+- lib/helpers/flatten_keys_of.rb
 - lib/helpers/transform_to_sortable_numeric.rb
-- lib/patches/core_ext/hash/flatten_keys.rb
 - pagination.png
 homepage: https://github.com/fractaledmind/actionset
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -318,9 +331,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.6.14.4
+signing_key:
 specification_version: 4
 summary: A toolkit for working with collections.
 test_files: []

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