activeset 0.5.8 → 0.6.0

data/lib/active_set/{processors/paginate → processor_paginate}/active_record_adapter.rb

@@ -1,37 +1,35 @@
 # frozen_string_literal: true
 
-require_relative '../base_adapter'
-require_relative '../base_processor'
+require_relative '../adapter_base'
+require_relative '../processor_base'
 
 class ActiveSet
-  class PaginateProcessor < BaseProcessor
-    class ActiveRecordAdapter < BaseAdapter
+  class Processor::Paginate < Processor::Base
+    class ActiveRecordAdapter < Adapter::Base
       def process
-        return return_set unless @set.respond_to? :to_sql
+        return false unless @set.respond_to? :to_sql
+        return @set.none if @set.length <= page_size && page_number > 1
 
-        return_set(paginated_set)
+        @set.limit(page_size).offset(page_offset)
       end
 
       private
 
-      def paginated_set
-        return @set.none if @set.length <= page_size && page_number > 1
-        @set.limit(page_size).offset(page_offset)
-      end
-
       def page_offset
         return 0 if page_number == 1
+
         page_size * (page_number - 1)
       end
 
       def page_size
-        @instruction.value
+        @instructions.get('size').to_i
       end
 
       def page_number
-        num = @instruction.attribute.to_i
+        num = @instructions.get('page').to_i
         return 1 if (num - 1).negative?
         return 1 if (num - 1).zero?
+
         num
       end
     end

data/lib/active_set/{processors/paginate → processor_paginate}/enumerable_adapter.rb

@@ -1,39 +1,37 @@
 # frozen_string_literal: true
 
-require_relative '../base_adapter'
-require_relative '../base_processor'
+require_relative '../adapter_base'
+require_relative '../processor_base'
 
 class ActiveSet
-  class PaginateProcessor < BaseProcessor
-    class EnumerableAdapter < BaseAdapter
+  class Processor::Paginate < Processor::Base
+    class EnumerableAdapter < Adapter::Base
       def process
-        return_set(paginated_set)
-      end
-
-      private
-
-      def paginated_set
         return [] if @set.count <= page_size && page_number > 1
 
         @set[page_start..page_end] || []
       end
 
+      private
+
       def page_start
         return 0 if page_number == 1
+
         page_size * (page_number - 1)
       end
 
       def page_end
         return page_start if page_size == 1
+
         page_start + page_size - 1
       end
 
       def page_size
-        @instruction.value
+        @instructions.get('size').to_i
       end
 
       def page_number
-        num = @instruction.attribute.to_i
+        num = @instructions.get('page').to_i
         (num.to_i - 1).negative? ? 0 : num
       end
     end

data/lib/active_set/processor_sort.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative './processor_base'
+require_relative './processor_sort/enumerable_adapter'
+require_relative './processor_sort/active_record_adapter'
+
+class ActiveSet
+  class Processor::Sort < Processor::Base
+    def process
+      adapters.each do |adapter|
+        result = adapter.new(@set, @instructions).process
+        break(result) if result
+      end
+    end
+
+    register_adapter(EnumerableAdapter)
+    register_adapter(ActiveRecordAdapter)
+  end
+end

data/lib/active_set/processor_sort/active_record_adapter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../adapter_activerecord'
+require_relative '../processor_base'
+require_relative '../../helpers/throws'
+
+class ActiveSet
+  class Processor::Sort < Processor::Base
+    class ActiveRecordAdapter < Adapter::ActiveRecord
+      def process
+        @instructions.reduce(@set) do |set, _instruction|
+          # set Adapter::Base#instruction, which many methods depend on
+          self.instruction = _instruction
+
+          return false unless @set.respond_to?(:to_sql)
+          return false unless can_query_with_active_record?
+
+          statement = arel_eager_load_associations
+                        .merge(arel_operation)
+
+          return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
+
+          statement
+        end
+      end
+
+      private
+
+      def arel_operation
+        arel_direction = arel_direction(instruction.value)
+
+        attribute_model.order(arel_column.send(arel_direction))
+      end
+
+      def arel_column
+        case_insensitive? ? super.lower : super
+      end
+
+      def case_insensitive?
+        instruction.operator.to_s.downcase == 'i'
+      end
+
+      def arel_direction(direction)
+        return 'desc' if direction.to_s.downcase.start_with? 'desc'
+
+        'asc'
+      end
+    end
+  end
+end

data/lib/active_set/processor_sort/enumerable_adapter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../adapter_base'
+require_relative '../processor_base'
+
+class ActiveSet
+  class Processor::Sort < Processor::Base
+    class EnumerableAdapter < Adapter::Base
+      def process
+        @set.sort do |left, right|
+          @instructions.reduce(0) do |diff, instruction|
+            # set Adapter::Base#instruction, which many methods depend on
+            self.instruction = instruction
+
+            # `left` and `right` differed at an earlier order entry
+            next diff if diff != 0
+
+            left_value = sortable_attribute_for(left)
+            right_value = sortable_attribute_for(right)
+
+            # handle `nil` values
+            next  0 if left_value.nil? && right_value.nil?
+            next  1 if left_value.nil?
+            next -1 if right_value.nil?
+
+            # do the actual comparison
+            comparison = left_value <=> right_value
+            next comparison * direction_multiplier(instruction.value)
+          end
+        end
+      end
+
+      private
+
+      def sortable_attribute_for(item)
+        value = instruction.value_for(item: item)
+
+        return value.to_s.downcase if case_insensitive?(value)
+
+        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)
+        return true if value.is_a?(NilClass)
+
+        instruction.operator.to_s.downcase == 'i'
+      end
+
+      def direction_multiplier(direction)
+        return -1 if direction.to_s.downcase.start_with? 'desc'
+
+        1
+      end
+    end
+  end
+end

data/lib/active_set/{processors/transform_processor.rb → processor_transform.rb}

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative './base_processor'
-require_relative './transform/csv_adapter'
+require_relative './processor_base'
+require_relative './processor_transform/csv_adapter'
 
 class ActiveSet
-  class TransformProcessor < BaseProcessor
+  class Processor::Transform < Processor::Base
     def process
       fail "Format #{format} is not currently supported as option for tranform" unless %w[csv].include?(format)
 
-      adapter = adapter_for(format: format)
-      output = adapter.new(@set, columns).process
-      output[:set]
+      adapter_for(format: format)
+        .new(@set, columns)
+        .process
     end
 
     private

data/lib/active_set/{processors/transform → processor_transform}/csv_adapter.rb

@@ -2,20 +2,15 @@
 
 require 'csv'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
 
-require_relative '../base_adapter'
-require_relative '../base_processor'
+require_relative '../adapter_base'
+require_relative '../processor_base'
 
 class ActiveSet
-  class TransformProcessor < BaseProcessor
-    class CSVAdapter < BaseAdapter
+  class Processor::Transform < Processor::Base
+    class CSVAdapter < Adapter::Base
       def process
-        return_set(transformed_set)
-      end
-
-      private
-
-      def transformed_set
         ::CSV.generate do |output|
           output << column_keys_for(item: @set.first)
           @set.each do |item|
@@ -24,6 +19,8 @@ class ActiveSet
         end
       end
 
+      private
+
       def column_keys_for(item:)
         columns.map do |column|
           ColumnInstruction.new(column, item).key
@@ -37,7 +34,7 @@ class ActiveSet
       end
 
       def columns
-        @instruction.compact
+        @instructions.compact
       end
 
       class ColumnInstruction
@@ -48,8 +45,8 @@ class ActiveSet
 
         def key
           return @hash[:key] if @hash.key? :key
-          return attribute_model.human_attribute_name(instruction_entry.attribute) if attribute_model.respond_to? :human_attribute_name
-          instruction_entry.titleized
+          return attribute_model.human_attribute_name(instructions_entry.attribute) if attribute_model.respond_to? :human_attribute_name
+          instruction_entry.keypath.map(&:titleize).join(' ')
         end
 
         def value
@@ -61,7 +58,7 @@ class ActiveSet
         private
 
         def instruction_entry
-          Instructions::Entry.new(@hash[:value], nil)
+          Instruction.new(@hash[:value], nil)
         end
 
         def attribute_model

data/lib/active_set/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ActiveSet
-  VERSION = '0.5.8'
+  VERSION = '0.6.0'
 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) # &block
+  yield
+  return false
+rescue Exception => e
+  return e.is_a? exception
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeset
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.6.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-30 00:00:00.000000000 Z
+date: 2018-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -171,25 +171,27 @@ files:
 - bin/console
 - bin/setup
 - config.ru
+- lib/.DS_Store
 - lib/active_set.rb
-- lib/active_set/instructions/base.rb
-- lib/active_set/instructions/entry.rb
-- lib/active_set/instructions/entry/keypath.rb
-- lib/active_set/instructions/entry/value.rb
-- lib/active_set/processors/base_adapter.rb
-- lib/active_set/processors/base_processor.rb
-- lib/active_set/processors/filter/active_record_adapter.rb
-- lib/active_set/processors/filter/enumerable_adapter.rb
-- lib/active_set/processors/filter_processor.rb
-- lib/active_set/processors/paginate/active_record_adapter.rb
-- lib/active_set/processors/paginate/enumerable_adapter.rb
-- lib/active_set/processors/paginate_processor.rb
-- lib/active_set/processors/sort/active_record_adapter.rb
-- lib/active_set/processors/sort/enumerable_adapter.rb
-- lib/active_set/processors/sort_processor.rb
-- lib/active_set/processors/transform/csv_adapter.rb
-- lib/active_set/processors/transform_processor.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/enumerable_adapter.rb
+- lib/active_set/processor_transform.rb
+- lib/active_set/processor_transform/csv_adapter.rb
 - lib/active_set/version.rb
+- lib/helpers/throws.rb
 - lib/patches/core_ext/hash/flatten_keys.rb
 homepage: https://github.com/fractaledmind/activeset
 licenses:

data/lib/active_set/instructions/base.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/indifferent_access'
-
-require_relative './entry'
-
-class ActiveSet
-  class Instructions
-    attr_reader :hash
-
-    def initialize(hash)
-      @hash = hash.with_indifferent_access
-      @flattened_hash = hash.flatten_keys.transform_keys { |k| k.map(&:to_s) }
-    end
-
-    def process_adapter(set:, adapter:)
-      @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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/module/delegation'
-
-require_relative 'entry/keypath'
-require_relative 'entry/value'
-
-class ActiveSet
-  class Instructions
-    class Entry
-      attr_reader :keypath
-
-      delegate :path, :attribute, :operator, :associations_array,
-               :associations_hash, :value_for, :resource_for, :titleized,
-               to: :keypath
-
-      def initialize(keypath, value)
-        @keypath = KeyPath.new(keypath)
-        @value = Value.new(value)
-      end
-
-      def value
-        @value.raw
-      end
-    end
-  end
-end