activeset 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d87d34f54e2c174c5c11379a49ebd92d5f9b60c
-  data.tar.gz: 5053ea2083a2eec445a06320427008452318c803
+  metadata.gz: b7d4ed6e6770fc71dc3a001a2dc9c19a871445e3
+  data.tar.gz: c1db7e7e4a0b3942563018e2404af6e645bcd68e
 SHA512:
-  metadata.gz: 78f7b3a62321ac056cb550185b09b9e8b333b2723e938f1f38ec4d8bcc48c709e92f0a9c53107b3f733965edfadebd4e3ed55be13577e25a3510f9eab5d7c4c3
-  data.tar.gz: c286846a5e54c850bc352d2c03f916e2048e4cbd03c69704fa7fa55dcd7bfb744212448c9744997d56da74c6c5ba3ff8d2ec851644ef224e58526662a0f70f34
+  metadata.gz: fd2718bbacff6f512f9ad90cb33e87a1b14eaadbe85774949e2df5b02439836e1e58a5b21286f6c9481b5efdb6239715d35465ab8341b5be2e907e2007f941c0
+  data.tar.gz: 833e98c0cf55ef9dc7229922070ba6e02f35ce2801728489f968ee08efaf689b62242592a22ca8cc23012263af4003c6f8de1213e6317b1c224e788919c9ff31

data/.hound.yml

@@ -0,0 +1,32 @@
+rubocop:
+  config_file: .rubocop.yml
+
+reek:
+  enabled: true
+
+coffeescript:
+  enabled: false
+credo:
+  enabled: false
+css:
+  enabled: false
+eslint:
+  enabled: false
+flake8:
+  enabled: false
+golint:
+  enabled: false
+haml:
+  enabled: false
+jshint:
+  enabled: false
+sass-lint:
+  enabled: false
+scss:
+  enabled: false
+shellcheck:
+  enabled: false
+swiftlint:
+  enabled: false
+tslint:
+  enabled: false

data/.rubocop.yml

@@ -17,3 +17,7 @@ Metrics/BlockLength:
     - 'activeset.gemspec'
     - 'spec/**/*_spec.rb'
     - '**/schema.rb'
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+Style/DateTime:
+  AllowCoercion: true

data/.travis.yml

@@ -1,5 +1,9 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.15.4
+  - 2.4.1
+before_install:
+  - gem install bundler -v 1.15.4
+  - export TZ=America/New_York
+after_success:
+  - bash < (curl -s https://codecov.io/bash)

data/CHANGELOG

@@ -1,3 +1,9 @@
+v 0.8.0
+  - simplify the `inspect` method for ActiveSet instances, only showing the instructions
+  - split the strategy files from the operation files
+  - update how ActiveRecord filtering works
+    + instruction operators must now be ARel methods, not SQL operators
+  - memoize the `transform_to_sortable_numeric` method
 v 0.7.1
   - Fix a small bug with Enumberable filtering of metaprogrammatically defined getter methods
 v 0.7.0

data/README.md

@@ -1,5 +1,8 @@
 # ActiveSet
 
+[![Build Status](https://travis-ci.com/fractaledmind/activeset.svg?branch=master)](https://travis-ci.com/fractaledmind/activeset)
+[![codecov](https://codecov.io/gh/fractaledmind/activeset/branch/master/graph/badge.svg)](https://codecov.io/gh/fractaledmind/activeset)
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/activeset.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.name          = 'activeset'
-  spec.version       = '0.7.1'
+  spec.version       = '0.8.0'
   spec.authors       = ['Stephen Margheim']
   spec.email         = ['stephen.margheim@gmail.com']
 
@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '>= 4.0.2'
 
   spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'codecov'
   spec.add_development_dependency 'combustion', '~> 0.7.0'
   spec.add_development_dependency 'database_cleaner', '~> 1.6.1'
   spec.add_development_dependency 'factory_bot', '~> 4.8.0'

data/bin/console

@@ -4,20 +4,21 @@
 ENV['RAILS_ENV'] ||= 'test'
 
 require 'bundler'
+require 'simplecov'
+require 'codecov'
+require 'combustion'
+
+Combustion.initialize! :active_record, :action_controller, :action_view
 Bundler.require :default, :development
 
 require 'bundler/setup'
 require 'active_set'
 require 'ostruct'
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-Combustion.initialize! :active_record
-
 begin
   FactoryBot.find_definitions
 rescue FactoryBot::DuplicateDefinitionError
+  nil
 end
 
 # (If you use this, don't forget to add pry to your Gemfile!)

data/lib/active_set.rb

@@ -26,7 +26,7 @@ class ActiveSet
 
   # :nocov:
   def inspect
-    "#<ActiveSet:#{format('0x00%x', (object_id << 1))} @instructions=#{@instructions.inspect}>"
+    "#<ActiveSet:#{object_id} @instructions=#{@instructions.inspect}>"
   end
 
   def ==(other)

data/lib/active_set/column_instruction.rb

@@ -12,12 +12,10 @@ class ActiveSet
     def key
       return @instructions_hash[:key] if @instructions_hash.key? :key
 
-      titleized = attribute_instruction.keypath.map(&:titleize).join(' ')
-      return titleized unless attribute_instruction.attribute
+      return titleized_attribute_key unless attribute_instruction.attribute
 
       attribute_resource = attribute_instruction.resource_for(item: @item)
-      return titleized unless attribute_resource
-      return titleized unless attribute_resource.class.respond_to?(:human_attribute_name)
+      return titleized_attribute_key unless attribute_resource&.class&.respond_to?(:human_attribute_name)
 
       attribute_resource.class.human_attribute_name(attribute_instruction.attribute)
     end
@@ -40,5 +38,9 @@ class ActiveSet
 
       '—'
     end
+
+    def titleized_attribute_key
+      attribute_instruction.keypath.map(&:titleize).join(' ')
+    end
   end
 end

data/lib/active_set/exporting/csv_strategy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../column_instruction'
+
+class ActiveSet
+  module Exporting
+    class CSVStrategy
+      require 'csv'
+
+      def initialize(set, column_instructions)
+        @set = set
+        @column_instructions = column_instructions
+      end
+
+      def execute
+        ::CSV.generate do |output|
+          output << column_keys_for(item: @set.first)
+          @set.each do |item|
+            output << column_values_for(item: item)
+          end
+        end
+      end
+
+      private
+
+      def column_keys_for(item:)
+        columns.map do |column|
+          ColumnInstruction.new(column, item).key
+        end
+      end
+
+      def column_values_for(item:)
+        columns.map do |column|
+          ColumnInstruction.new(column, item).value
+        end
+      end
+
+      def columns
+        @column_instructions.compact
+      end
+    end
+  end
+end

data/lib/active_set/exporting/operation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../column_instruction'
+require_relative './csv_strategy'
 
 class ActiveSet
   module Exporting
@@ -26,41 +26,5 @@ class ActiveSet
         return CSVStrategy if format == 'csv'
       end
     end
-
-    class CSVStrategy
-      require 'csv'
-
-      def initialize(set, column_instructions)
-        @set = set
-        @column_instructions = column_instructions
-      end
-
-      def execute
-        ::CSV.generate do |output|
-          output << column_keys_for(item: @set.first)
-          @set.each do |item|
-            output << column_values_for(item: item)
-          end
-        end
-      end
-
-      private
-
-      def column_keys_for(item:)
-        columns.map do |column|
-          ColumnInstruction.new(column, item).key
-        end
-      end
-
-      def column_values_for(item:)
-        columns.map do |column|
-          ColumnInstruction.new(column, item).value
-        end
-      end
-
-      def columns
-        @column_instructions.compact
-      end
-    end
   end
 end

data/lib/active_set/filtering/active_record_strategy.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    class ActiveRecordStrategy
+      def initialize(set, attribute_instruction)
+        @set = set
+        @attribute_instruction = attribute_instruction
+      end
+
+      def execute
+        return false unless @set.respond_to? :to_sql
+
+        if execute_where_operation?
+          statement = where_operation
+        elsif execute_merge_operation?
+          statement = merge_operation
+        else
+          return false
+        end
+
+        return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
+
+        statement
+      end
+
+      private
+
+      def execute_where_operation?
+        return false unless attribute_model
+        return false unless attribute_model.respond_to?(:attribute_names)
+        return false unless attribute_model.attribute_names.include?(@attribute_instruction.attribute)
+
+        true
+      end
+
+      def execute_merge_operation?
+        return false unless attribute_model
+        return false unless attribute_model.respond_to?(@attribute_instruction.attribute)
+        return false if attribute_model.method(@attribute_instruction.attribute).arity.zero?
+
+        true
+      end
+
+      def where_operation
+        arel_table = Arel::Table.new(attribute_model.table_name)
+        arel_column = arel_table[@attribute_instruction.attribute]
+
+        initial_relation
+          .where(
+            arel_column.send(
+              @attribute_instruction.operator(default: 'eq'),
+              @attribute_instruction.value
+            )
+          )
+      end
+
+      def merge_operation
+        initial_relation
+          .merge(
+            attribute_model.public_send(
+              @attribute_instruction.attribute,
+              @attribute_instruction.value
+            )
+          )
+      end
+
+      def initial_relation
+        return @set if @attribute_instruction.associations_array.empty?
+
+        @set.eager_load(@attribute_instruction.associations_hash)
+      end
+
+      def attribute_model
+        return @set.klass if @attribute_instruction.associations_array.empty?
+        return @attribute_model if defined? @attribute_model
+
+        @attribute_model = @attribute_instruction
+                           .associations_array
+                           .reduce(@set) do |obj, assoc|
+          obj.reflections[assoc.to_s]&.klass
+        end
+      end
+    end
+  end
+end

data/lib/active_set/filtering/enumerable_strategy.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    class EnumerableStrategy
+      def initialize(set, attribute_instruction)
+        @set = set
+        @attribute_instruction = attribute_instruction
+      end
+
+      def execute
+        return false unless @set.respond_to? :select
+
+        @set.select do |item|
+          next attribute_matches_for?(item) if can_match_attribute_for?(item)
+          next class_method_matches_for?(item) if can_match_class_method_for?(item)
+
+          next false
+        end
+      end
+
+      private
+
+      def can_match_attribute_for?(item)
+        attribute_item = attribute_item_for(item)
+
+        return false unless attribute_item
+        return false unless attribute_item.respond_to?(@attribute_instruction.attribute)
+        return false if attribute_item.method(@attribute_instruction.attribute).arity.positive?
+
+        true
+      end
+
+      def can_match_class_method_for?(item)
+        attribute_item = attribute_item_for(item)
+
+        return false unless attribute_item
+        return false unless attribute_item.class
+        return false unless attribute_item.class.respond_to?(@attribute_instruction.attribute)
+        return false if attribute_item.class.method(@attribute_instruction.attribute).arity.zero?
+
+        true
+      end
+
+      def attribute_matches_for?(item)
+        @attribute_instruction
+          .value_for(item: item)
+          .public_send(
+            @attribute_instruction.operator,
+            @attribute_instruction.value
+          )
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def class_method_matches_for?(item)
+        maybe_item_or_collection_or_nil = attribute_item_for(item)
+                                          .class
+                                          .public_send(
+                                            @attribute_instruction.attribute,
+                                            @attribute_instruction.value
+                                          )
+        if maybe_item_or_collection_or_nil.nil?
+          false
+        elsif maybe_item_or_collection_or_nil.respond_to?(:each)
+          maybe_item_or_collection_or_nil.include? attribute_item_for(item)
+        else
+          maybe_item_or_collection_or_nil.present?
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def attribute_item_for(item)
+        @attribute_instruction
+          .resource_for(item: item)
+      end
+    end
+  end
+end

data/lib/active_set/filtering/operation.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../attribute_instruction'
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
 
 class ActiveSet
   module Filtering
@@ -10,10 +12,11 @@ class ActiveSet
         @instructions_hash = instructions_hash
       end
 
+      # rubocop:disable Metrics/MethodLength
       def execute
         attribute_instructions = @instructions_hash
-                                   .flatten_keys
-                                   .map { |k, v| AttributeInstruction.new(k, v) }
+                                 .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
@@ -30,161 +33,11 @@ class ActiveSet
           maybe_set_or_false.presence || set
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def operation_instructions
         @instructions_hash.symbolize_keys
       end
     end
-
-    class EnumerableStrategy
-      def initialize(set, attribute_instruction)
-        @set = set
-        @attribute_instruction = attribute_instruction
-      end
-
-      def execute
-        return false unless @set.respond_to? :select
-
-        @set.select do |item|
-          if can_match_attribute_for?(item)
-            next attribute_matches_for?(item)
-          elsif can_match_class_method_for?(item)
-            next class_method_matches_for?(item)
-          else
-            next false
-          end
-        end
-      end
-
-      private
-
-      def can_match_attribute_for?(item)
-        attribute_item = attribute_item_for(item)
-
-        return false unless attribute_item
-        return false unless attribute_item.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_item.method(@attribute_instruction.attribute).arity > 0
-
-        true
-      end
-
-      def can_match_class_method_for?(item)
-        attribute_item = attribute_item_for(item)
-
-        return false unless attribute_item
-        return false unless attribute_item.class
-        return false unless attribute_item.class.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_item.class.method(@attribute_instruction.attribute).arity.zero?
-
-        true
-      end
-
-      def attribute_matches_for?(item)
-        @attribute_instruction
-          .value_for(item: item)
-          .public_send(
-            @attribute_instruction.operator,
-            @attribute_instruction.value
-          )
-      end
-
-      def class_method_matches_for?(item)
-        maybe_item_or_collection_or_nil = attribute_item_for(item)
-                                          .class
-                                          .public_send(
-                                            @attribute_instruction.attribute,
-                                            @attribute_instruction.value
-                                          )
-        if maybe_item_or_collection_or_nil.nil?
-          false
-        elsif maybe_item_or_collection_or_nil.respond_to?(:each)
-          maybe_item_or_collection_or_nil.include? attribute_item_for(item)
-        else
-          maybe_item_or_collection_or_nil.present?
-        end
-      end
-
-      def attribute_item_for(item)
-        @attribute_instruction
-          .resource_for(item: item)
-      end
-    end
-
-    class ActiveRecordStrategy
-      def initialize(set, attribute_instruction)
-        @set = set
-        @attribute_instruction = attribute_instruction
-      end
-
-      def execute
-        return false unless @set.respond_to? :to_sql
-
-        if execute_where_operation?
-          statement = where_operation
-        elsif execute_merge_operation?
-          statement = merge_operation
-        else
-          return false
-        end
-
-        return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
-
-        statement
-      end
-
-      private
-
-      def execute_where_operation?
-        return false unless attribute_model
-        return false unless attribute_model.respond_to?(:attribute_names)
-        return false unless attribute_model.attribute_names.include?(@attribute_instruction.attribute)
-
-        true
-      end
-
-      def execute_merge_operation?
-        return false unless attribute_model
-        return false unless attribute_model.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_model.method(@attribute_instruction.attribute).arity.zero?
-
-        true
-      end
-
-      def where_operation
-        arel_operator = @attribute_instruction.operator(default: '=')
-        arel_column = Arel::Table.new(attribute_model.table_name)[@attribute_instruction.attribute]
-        arel_value = Arel.sql(ActiveRecord::Base.connection.quote(@attribute_instruction.value))
-
-        @set.eager_load(@attribute_instruction.associations_hash)
-            .where(
-              Arel::Nodes::InfixOperation.new(
-                arel_operator,
-                arel_column,
-                arel_value
-              )
-            )
-      end
-
-      def merge_operation
-        @set.eager_load(@attribute_instruction.associations_hash)
-            .merge(
-              attribute_model.public_send(
-                @attribute_instruction.attribute,
-                @attribute_instruction.value
-              )
-            )
-      end
-
-      def attribute_model
-        return @set.klass if @attribute_instruction.associations_array.empty?
-        return @attribute_model if defined? @attribute_model
-
-        @attribute_model = @attribute_instruction
-                            .associations_array
-                            .reduce(@set) do |obj, assoc|
-                              obj.reflections[assoc.to_s]&.klass
-                            end
-      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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
+
 class ActiveSet
   module Paginating
     class Operation
@@ -47,56 +50,5 @@ class ActiveSet
         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/active_record_strategy.rb

@@ -0,0 +1,76 @@
+# 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
+
+      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/active_set/sorting/enumerable_strategy.rb

@@ -0,0 +1,46 @@
+# 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|
+            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
+  end
+end

data/lib/active_set/sorting/operation.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../attribute_instruction'
-require_relative '../../helpers/transform_to_sortable_numeric'
+require_relative './enumerable_strategy'
+require_relative './active_record_strategy'
 
 class ActiveSet
   module Sorting
@@ -13,8 +14,8 @@ class ActiveSet
 
       def execute
         attribute_instructions = @instructions_hash
-                                   .flatten_keys
-                                   .map { |k, v| AttributeInstruction.new(k, v) }
+                                 .flatten_keys
+                                 .map { |k, v| AttributeInstruction.new(k, v) }
 
         activerecord_strategy = ActiveRecordStrategy.new(@set, attribute_instructions)
         if activerecord_strategy.executable_instructions == attribute_instructions
@@ -30,115 +31,5 @@ class ActiveSet
         @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

@@ -11,9 +11,9 @@
 # throws?(StandardError) { 'foo' }
 # => false
 
-def throws?(exception) # &block
+def throws?(exception)
   yield
   false
-rescue Exception => e
+rescue StandardError => e
   e.is_a? exception
 end

data/lib/helpers/transform_to_sortable_numeric.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
 # Returns a Numeric for `value` that respects sort-order
 # can be used in Enumerable#sort_by
 #
@@ -12,25 +13,32 @@
 # 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)
-  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)
+  # 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)
+               key
+                 .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)
+             elsif key.respond_to?(:to_time)
+               # https://stackoverflow.com/a/30604935/2884386
+               (key.to_time.to_f * 1000).round
+             else
+               key
+             end
   end
-
-  # https://stackoverflow.com/a/30604935/2884386
-  return (value.to_time.to_f * 1000).round if value.respond_to?(:to_time)
-
-  # :nocov:
-  value
-  # :nocov:
+  @sortable_numeric[value]
 end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:enable Style/AsciiComments

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

@@ -8,8 +8,6 @@ class Hash
   #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
   #   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
@@ -19,9 +17,7 @@ class Hash
   #
   #   hash = { person: { name: { first: 'Rob' }, age: '28' } }
   #   hash.flatten_keys_to_dotpath
-  #   => { 'person.name.first' => "Rob", [:person, :age]=>"28" }
-  #   hash
-  #   => { person: { name: { first: 'Rob' }, age: '28' } }
+  #   => { 'person.name.first' => "Rob", 'person.age'=>"28" }
   def flatten_keys_to_dotpath
     _flatten_keys(self, ->(*keys) { keys.join('.') })
   end
@@ -30,31 +26,32 @@ class Hash
   #
   #   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' } }
+  #   => { '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.
+  # 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' } }
+  #   => { '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 little from https://stackoverflow.com/a/23861946/2884386
+  # refactored 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) }
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeset
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-08 00:00:00.000000000 Z
+date: 2018-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: codecov
+  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: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +200,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
@@ -203,9 +218,16 @@ files:
 - lib/active_set.rb
 - lib/active_set/attribute_instruction.rb
 - lib/active_set/column_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/operation.rb
+- lib/active_set/paginating/active_record_strategy.rb
+- lib/active_set/paginating/enumerable_strategy.rb
 - lib/active_set/paginating/operation.rb
+- 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/transform_to_sortable_numeric.rb