actionset 0.7.0 → 0.8.0

data/lib/active_set/filtering/operation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../attribute_instruction'
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
+
+class ActiveSet
+  module Filtering
+    class Operation
+      def initialize(set, instructions_hash)
+        @set = set
+        @instructions_hash = instructions_hash
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def execute
+        attribute_instructions = @instructions_hash
+                                 .flatten_keys
+                                 .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
+          next set unless maybe_set_or_false
+
+          attribute_instruction.processed = true
+          maybe_set_or_false
+        end
+
+        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
+          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
+      end
+    end
+  end
+end

data/lib/active_set/paginating/active_record_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Paginating
+    class ActiveRecordStrategy
+      def initialize(set, operation_instructions)
+        @set = set
+        @operation_instructions = operation_instructions
+      end
+
+      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
+
+      private
+
+      def page_offset
+        return 0 if @operation_instructions[:page] == 1
+
+        @operation_instructions[:size] * (@operation_instructions[:page] - 1)
+      end
+    end
+  end
+end

data/lib/active_set/paginating/enumerable_strategy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Paginating
+    class EnumerableStrategy
+      def initialize(set, operation_instructions)
+        @set = set
+        @operation_instructions = operation_instructions
+      end
+
+      def execute
+        return [] if @set.count <= @operation_instructions[:size] &&
+                     @operation_instructions[:page] > 1
+
+        @set[page_start..page_end] || []
+      end
+
+      private
+
+      def page_start
+        return 0 if @operation_instructions[:page] == 1
+
+        @operation_instructions[:size] * (@operation_instructions[:page] - 1)
+      end
+
+      def page_end
+        return page_start if @operation_instructions[:size] == 1
+
+        page_start + @operation_instructions[:size] - 1
+      end
+    end
+  end
+end

data/lib/active_set/paginating/operation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
+
+class ActiveSet
+  module Paginating
+    class Operation
+      def initialize(set, instructions_hash)
+        @set = set
+        @instructions_hash = instructions_hash
+      end
+
+      def execute
+        [ActiveRecordStrategy, EnumerableStrategy].each do |strategy|
+          maybe_set_or_false = strategy.new(@set, operation_instructions).execute
+          break(maybe_set_or_false) if maybe_set_or_false
+        end
+      end
+
+      def operation_instructions
+        @instructions_hash.symbolize_keys.tap do |h|
+          h[:page] = page_operation_instruction(h[:page])
+          h[:size] = size_operation_instruction(h[:size])
+          h[:count] = count_operation_instruction(@set)
+        end
+      end
+
+      private
+
+      def page_operation_instruction(initial)
+        return 1 unless initial
+        return 1 if initial.to_i <= 0
+
+        initial.to_i
+      end
+
+      def size_operation_instruction(initial)
+        return 25 unless initial
+        return 25 if initial.to_i <= 0
+
+        initial.to_i
+      end
+
+      def count_operation_instruction(set)
+        # https://work.stevegrossi.com/2015/04/25/how-to-count-with-activerecord/
+        maybe_integer_or_hash = set.size
+        return maybe_integer_or_hash.count if maybe_integer_or_hash.is_a?(Hash)
+
+        maybe_integer_or_hash
+      end
+    end
+  end
+end

data/lib/active_set/sorting/active_record_strategy.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Sorting
+    class ActiveRecordStrategy
+      def initialize(set, attribute_instructions)
+        @set = set
+        @attribute_instructions = attribute_instructions
+      end
+
+      def execute
+        return false unless @set.respond_to? :to_sql
+
+        executable_instructions.reduce(set_with_eager_loaded_associations) do |set, attribute_instruction|
+          statement = set.merge(order_operation_for(attribute_instruction))
+
+          return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
+
+          attribute_instruction.processed = true
+          statement
+        end
+      end
+
+      def executable_instructions
+        return {} unless @set.respond_to? :to_sql
+
+        @attribute_instructions.select do |attribute_instruction|
+          attribute_model = attribute_model_for(attribute_instruction)
+          next false unless attribute_model
+          next false unless attribute_model.respond_to?(:attribute_names)
+          next false unless attribute_model.attribute_names.include?(attribute_instruction.attribute)
+
+          true
+        end
+      end
+
+      private
+
+      def set_with_eager_loaded_associations
+        associations_hash = @attribute_instructions.reduce({}) { |h, i| h.merge(i.associations_hash) }
+        @set.eager_load(associations_hash)
+      end
+
+      # https://stackoverflow.com/a/44912964/2884386
+      # Force 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]
+      def order_operation_for(attribute_instruction)
+        attribute_model = attribute_model_for(attribute_instruction)
+
+        arel_column = Arel::Table.new(attribute_model.table_name)[attribute_instruction.attribute]
+        arel_column = case_insensitive?(attribute_instruction) ? arel_column.lower : arel_column
+        arel_direction = direction_operator(attribute_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))
+      end
+
+      def attribute_model_for(attribute_instruction)
+        return @set.klass if attribute_instruction.associations_array.empty?
+
+        attribute_instruction
+          .associations_array
+          .reduce(@set) do |obj, assoc|
+            obj.reflections[assoc.to_s]&.klass
+          end
+      end
+
+      def case_insensitive?(attribute_instruction)
+        attribute_instruction.operator.to_s.casecmp('i').zero?
+      end
+
+      def direction_operator(direction)
+        return :desc if direction.to_s.downcase.start_with? 'desc'
+
+        :asc
+      end
+    end
+  end
+end

data/lib/active_set/sorting/enumerable_strategy.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../helpers/transform_to_sortable_numeric'
+
+class ActiveSet
+  module Sorting
+    class EnumerableStrategy
+      def initialize(set, attribute_instructions)
+        @set = set
+        @attribute_instructions = attribute_instructions
+      end
+
+      def execute
+        # http://brandon.dimcheff.com/2009/11/18/rubys-sort-vs-sort-by/
+        @set.sort_by do |item|
+          @attribute_instructions.map do |instruction|
+            value_for_comparison = sortable_numeric_for(instruction, item)
+            direction_multiplier = direction_multiplier(instruction.value)
+
+            # Force 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]
+            if value_for_comparison.nil?
+              [direction_multiplier, 0]
+            else
+              [0, value_for_comparison * direction_multiplier]
+            end
+          end
+        end
+      end
+
+      def sortable_numeric_for(instruction, item)
+        value = instruction.value_for(item: item)
+        if value.is_a?(String) || value.is_a?(Symbol)
+          value = if case_insensitive?(instruction, value)
+                    value.to_s.downcase
+                  else
+                    value.to_s
+                  end
+        end
+
+        transform_to_sortable_numeric(value)
+      end
+
+      def case_insensitive?(instruction, _value)
+        instruction.operator.to_s.casecmp('i').zero?
+      end
+
+      def direction_multiplier(direction)
+        return -1 if direction.to_s.downcase.start_with? 'desc'
+
+        1
+      end
+    end
+  end
+end

data/lib/active_set/sorting/operation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../attribute_instruction'
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
+
+class ActiveSet
+  module Sorting
+    class Operation
+      def initialize(set, instructions_hash)
+        @set = set
+        @instructions_hash = instructions_hash
+      end
+
+      def execute
+        attribute_instructions = @instructions_hash
+                                 .flatten_keys
+                                 .map { |k, v| AttributeInstruction.new(k, v) }
+
+        activerecord_strategy = ActiveRecordStrategy.new(@set, attribute_instructions)
+        if activerecord_strategy.executable_instructions == attribute_instructions
+          activerecord_sorted_set = activerecord_strategy.execute
+        end
+
+        return activerecord_sorted_set if attribute_instructions.all?(&:processed?)
+
+        EnumerableStrategy.new(@set, attribute_instructions).execute
+      end
+
+      def operation_instructions
+        @instructions_hash.symbolize_keys
+      end
+    end
+  end
+end

data/lib/helpers/throws.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Returns a Boolean for whether the block raises the Exception expected
+#
+# throws?(StandardError) { raise }
+# => true
+# throws?(NameError) { raise NameError }
+# => true
+# throws?(NoMethodError) { raise NameError }
+# => false
+# throws?(StandardError) { 'foo' }
+# => false
+
+def throws?(exception)
+  yield
+  false
+rescue StandardError => e
+  e.is_a? exception
+end

data/lib/helpers/transform_to_sortable_numeric.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+# Returns a Numeric for `value` that respects sort-order
+# can be used in Enumerable#sort_by
+#
+# transform_to_sortable_numeric(1)
+# => 1
+# transform_to_sortable_numeric('aB09ü')
+# => (24266512014313/250000000000)
+# transform_to_sortable_numeric(true)
+# => 1
+# transform_to_sortable_numeric(Date.new(2000, 12, 25))
+# => 977720400000
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, 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|
+    h[key] = if key.is_a?(Numeric)
+               key
+             elsif key == true
+               1
+             elsif key == false
+               0
+             elsif key.is_a?(String) || key.is_a?(Symbol)
+               string_to_sortable_numeric(key.to_s)
+             elsif key.is_a?(Date)
+               time_to_sortable_numeric(Time.new(key.year, key.month, key.day, 0o0, 0o0, 0o0, 0))
+             elsif key.respond_to?(:to_time)
+               time_to_sortable_numeric(key.to_time)
+             else
+               key
+             end
+  end
+  @sortable_numeric[value]
+end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:enable Style/AsciiComments
+
+def string_to_sortable_numeric(string)
+  string                                          # 'aB09ü'
+    .split('')                                    # ["a", "B", "0", "9", "ü"]
+    .map { |char| char.ord.to_s.rjust(3, '0') }   # ["097", "066", "048", "057", "252"]
+    .insert(1, '.')                               # ["097", ".", "066", "048", "057", "252"]
+    .reduce(&:concat)                             # "097.066048057252"
+    .to_r                                         # (24266512014313/250000000000)
+end
+
+def time_to_sortable_numeric(time)
+  # https://stackoverflow.com/a/30604935/2884386
+  (time.utc.to_f * 1000).round
+end

data/lib/patches/core_ext/hash/flatten_keys.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+
+class Hash
+  # Returns a flat hash where all nested keys are collapsed into an array of keys.
+  #
+  #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
+  #   hash.flatten_keys_to_array
+  #   => {[:person, :name, :first] => "Rob", [:person, :age]=>"28" }
+  def flatten_keys_to_array
+    _flatten_keys(self)
+  end
+  alias flatten_keys flatten_keys_to_array
+
+  # Returns a flat hash where all nested keys are collapsed into a dot-separated string of keys.
+  #
+  #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
+  #   hash.flatten_keys_to_dotpath
+  #   => { 'person.name.first' => "Rob", 'person.age'=>"28" }
+  def flatten_keys_to_dotpath
+    _flatten_keys(self, ->(*keys) { keys.join('.') })
+  end
+
+  # Returns a flat hash where all nested keys are collapsed into a dast-separated string of keys.
+  #
+  #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
+  #   hash.flatten_keys_to_html_attribute
+  #   => { 'person-name-first' => "Rob", 'person-age'=>"28" }
+  def flatten_keys_to_html_attribute
+    _flatten_keys(self, ->(*keys) { keys.join('-') })
+  end
+
+  # Returns a flat hash where all nested keys are collapsed into a string of keys
+  # fitting the Rails request param pattern.
+  #
+  #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
+  #   hash.flatten_keys_to_rails_param
+  #   => { 'person[name][first]' => "Rob", 'person[age]'=>"28" }
+  def flatten_keys_to_rails_param
+    _flatten_keys(self, ->(*keys) { keys.map(&:to_s).reduce { |memo, key| memo + "[#{key}]" } })
+  end
+
+  private
+
+  # refactored from https://stackoverflow.com/a/23861946/2884386
+  def _flatten_keys(input, keypath_gen = ->(*keys) { keys }, keys = [], output = {})
+    if input.is_a? Hash
+      input.each { |k, v| _flatten_keys(v, keypath_gen, keys + Array(k), output) }
+    # elsif input.is_a? Array
+    #   input.each_with_index { |v, i| _flatten_keys(v, keypath_gen, keys + Array(i), output) }
+    else
+      return output.merge!(keypath_gen.call(*keys) => input)
+    end
+
+    output
+  end
+end