activeset 0.6.5 → 0.7.0

data/lib/active_set/paginating/operation.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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
+
+    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
+
+    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/sorting/operation.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../attribute_instruction'
+require_relative '../../helpers/transform_to_sortable_numeric'
+
+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
+
+    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|
+            sortable_numeric_for(instruction, item) * direction_multiplier(instruction.value)
+          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
+
+    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
+
+      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)
+
+        attribute_model.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/helpers/throws.rb

@@ -13,7 +13,7 @@
 
 def throws?(exception) # &block
   yield
-  return false
+  false
 rescue Exception => e
-  return e.is_a? exception
+  e.is_a? exception
 end

data/lib/helpers/transform_to_sortable_numeric.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# 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
+
+def transform_to_sortable_numeric(value)
+  return value if value.is_a?(Numeric)
+  return 1 if value == true
+  return 0 if value == false
+
+  if value.is_a?(String) || value.is_a?(Symbol)
+    return value
+            .to_s                                         # '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
+
+  # https://stackoverflow.com/a/30604935/2884386
+  return (value.to_time.to_f * 1000).round if value.respond_to?(:to_time)
+
+  # :nocov:
+  value
+  # :nocov:
+end

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

@@ -3,30 +3,59 @@
 require 'active_support/core_ext/array/wrap'
 
 class Hash
-  # Returns a flat hash where all nested keys are collapsed into a an array of keys.
+  # 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   # => {[:person, :name, :first]=>"Rob", [:person, :age]=>"28"}
-  #   hash                # => { person: { name: { first: 'Rob' }, age: '28' } }
-  def flatten_keys
+  #   hash.flatten_keys_to_array
+  #   => {[:person, :name, :first] => "Rob", [:person, :age]=>"28" }
+  #   hash
+  #   => { person: { name: { first: 'Rob' }, age: '28' } }
+  def flatten_keys_to_array
     _flatten_keys(self)
   end
+  alias flatten_keys flatten_keys_to_array
 
-  # Replaces current hash with a flat hash where all nested keys are collapsed into a an array of keys.
-  # Returns +nil+ if no changes were made, otherwise returns the hash.
+  # 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!   # => {[:person, :name, :first]=>"Rob", [:person, :age]=>"28"}
-  #   hash                 # => {[:person, :name, :first]=>"Rob", [:person, :age]=>"28"}
-  def flatten_keys!
-    replace(_flatten_keys(self))
+  #   hash.flatten_keys_to_dotpath
+  #   => { 'person.name.first' => "Rob", [:person, :age]=>"28" }
+  #   hash
+  #   => { person: { name: { first: 'Rob' }, 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" }
+  #   hash
+  #   => { person: { name: { first: 'Rob' }, 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" }
+  #   hash
+  #   => { person: { name: { first: 'Rob' }, age: '28' } }
+  def flatten_keys_to_rails_param
+    _flatten_keys(self, ->(*keys) { keys.map(&:to_s).reduce { |memo, key| memo + "[#{key}]" } })
   end
 
   private
 
-  def _flatten_keys(h, keys = [], res = {})
-    return res.merge!(keys => h) unless h.is_a? Hash
-    h.each { |k, r| _flatten_keys(r, keys + Array.wrap(k), res) }
-    res
+  # refactored little from https://stackoverflow.com/a/23861946/2884386
+  def _flatten_keys(input, keypath_gen = ->(*keys) { keys }, keys = [], output = {})
+    return output.merge!(keypath_gen.call(*keys) => input) unless input.is_a? Hash
+
+    input.each { |k, v| _flatten_keys(v, keypath_gen, keys + Array(k), output) }
+
+    output
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeset
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-26 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -39,89 +39,117 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.15'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: combustion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.6.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.6.1
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.1
+        version: 4.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.1
+        version: 4.8.0
 - !ruby/object:Gem::Dependency
-  name: combustion
+  name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 1.8.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 1.8.4
 - !ruby/object:Gem::Dependency
-  name: factory_girl
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.0
+        version: 5.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.0
+        version: 5.1.0
 - !ruby/object:Gem::Dependency
-  name: faker
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.4
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.4
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -173,26 +201,14 @@ files:
 - config.ru
 - lib/.DS_Store
 - lib/active_set.rb
-- lib/active_set/.DS_Store
-- lib/active_set/adapter_activerecord.rb
-- lib/active_set/adapter_base.rb
-- lib/active_set/instruction.rb
-- lib/active_set/instructions.rb
-- lib/active_set/processor_base.rb
-- lib/active_set/processor_filter.rb
-- lib/active_set/processor_filter/active_record_adapter.rb
-- lib/active_set/processor_filter/enumerable_adapter.rb
-- lib/active_set/processor_paginate.rb
-- lib/active_set/processor_paginate/active_record_adapter.rb
-- lib/active_set/processor_paginate/enumerable_adapter.rb
-- lib/active_set/processor_sort.rb
-- lib/active_set/processor_sort/active_record_adapter.rb
-- lib/active_set/processor_sort/active_record_operation.rb
-- lib/active_set/processor_sort/enumerable_adapter.rb
-- lib/active_set/processor_transform.rb
-- lib/active_set/processor_transform/csv_adapter.rb
-- lib/active_set/version.rb
+- lib/active_set/attribute_instruction.rb
+- lib/active_set/column_instruction.rb
+- lib/active_set/exporting/operation.rb
+- lib/active_set/filtering/operation.rb
+- lib/active_set/paginating/operation.rb
+- lib/active_set/sorting/operation.rb
 - lib/helpers/throws.rb
+- lib/helpers/transform_to_sortable_numeric.rb
 - lib/patches/core_ext/hash/flatten_keys.rb
 homepage: https://github.com/fractaledmind/activeset
 licenses: