activeset 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58ac4ca493d503b7c0801bcad0c24bf2ab050732
-  data.tar.gz: c5e1c3d571a14ed3abed1b2e26db9b4009457302
+  metadata.gz: 4c88778d3e9cdb17bb755baad18eccf5a1ec41f1
+  data.tar.gz: 25b78baf469767293cf301fd3589a00a5a0c9b94
 SHA512:
-  metadata.gz: 42284a6d184c695acf3ff502e0d32de0f3a4c00707e375ba56d3e2c91fc099884ce1313783b16b1d5db9b488ef8199f60a2b789a6566f19b8784d3708658da47
-  data.tar.gz: 8c693840d6b28e1ebd6e3a245e41c68cc6dbb8c60817355e2e913492502177377739345d119e9786c1275f247f108cff08125ad23577d83c7f1b048700b45678
+  metadata.gz: c8e848d5d4fde3130fec90980e8e0530db6612bf4e11663f0fdaf2d52c5f60e319bd162674a5fd298fa71249f15dfa15fda1320917c160487ba0485461a527b1
+  data.tar.gz: 6f695aa0590f3a8ead38041bc94818ac6faaf0e3cd3c2b85b831593c6ec3a64a910fd37fc87ebfef9f3755434f4613cef88317e2f64e2f09fee9e1aa28995c13

data/.gitignore

@@ -12,3 +12,4 @@
 .rspec_status
 *.gem
 *.sqlite
+.DS_Store

data/.rubocop.yml

@@ -1,11 +1,5 @@
 AllCops:
   TargetRubyVersion: 2.3
-  Include:
-    - Rakefile
-  Exclude:
-    - bin/*
-    - db/**/*
-    - spec/*_helper.rb
 Metrics/LineLength:
   Max: 120
   # To make it possible to copy or click on URIs in the code, we allow lines

data/CHANGELOG

@@ -1,3 +1,8 @@
+v 0.7.0
+  - another rewrite from the ground up
+  - allow each operation to exist and function in its own way and in its own context
+  - only write tests against the public interface of the ActiveSet class, not any internal classes
+  - attempt a proper and complete sorting implementation that offers multi-dimensional, multi-directional sorting for either ActiveRecord or Enumerable sets
 v 0.6.5
   - Fix the ActiveRecord filtering adapter to use the correct operator (=) for Oracle WHERE clauses
 v 0.6.4

data/README.md

@@ -18,17 +18,69 @@ Or install it yourself as:
 
 ## Usage
 
-The `ActiveSet` class is an extension of `Enumerable` that adds methods for filtering, sorting, paginating, and transforming (as of right now).
+The `ActiveSet` class provides convenience methods for filtering, sorting, paginating, and transforming collections of data-objects, whether `ActiveRecord::Relation`s or Ruby `Array`s or custom classes that extend the `Enumerable` module.
 
-Every convenience method added to the `ActiveSet` class is handled via a `Processor` class, and that `Processor` class will then use 1 or more `Adapter` classes to actually fulfill the functional contract.
+When calling a convenience method on an instance of `ActiveSet`, you pass only 1 argument: a plain-old-Ruby-hash that encodes the instructions for that operation. Each convenience method works with hashes of differing signatures.
 
-an `Adapter` for a particular `Processor` simply handles doing the job of the processor for a particular kind of Set.
+## Filtering
 
-So, for example, the `Filter::Processor` will have an `EnumerableAdapter` (to work with generic enumerable sets) and an `ActiveRecordAdapter` (to work with active record relations).
+`ActiveSet` allows for you to filter your collection by:
 
-When calling a convenience method on an instance of `ActiveSet`, you pass only 1 argument: what I am currently calling a `structure`, which is a plain-old-Ruby-hash. Each convenience method works with hashes of differing signatures.
+- "direct" attributes (i.e. for an `ActiveRecord` model, a database attribute)
+- "computed" attributes (i.e. Ruby getter-methods on your data-objects)
+- "associated" attributes (i.e. either direct or computed attributes on objects associated with your data-objects)
+- "called" attributes (i.e. Ruby methods with non-zero arity)
 
-e.g. `filter(attribute: 'value', association: { field: 'value' })` or `sort(attribute: :asc, association: { field: 'desc' })` or `paginate(page: 1, size: 10)`
+The syntax for the instructions hash is relatively simple:
+
+```ruby
+{
+    attribute: 'value',
+    association: {
+        field: 'value'
+    }
+}
+```
+
+Every entry in the instructions hash is treated and processed as an independent operation, and all operations are _conjoined_ ("AND"-ed). At the moment, you cannot use disjointed ("OR"-ed) operations.
+
+The logic of this method is to attempt to process every instruction with the ActiveRecordStrategy, marking all successful attempts. If we successfully processed every instruction, we simply returned the processed result. If there are any instructions that went unprocessed, we take only those instructions and process them against the set processed by the ActiveRecordStrategy.
+
+This filtering operation does not preserve the order of the filters, enforces conjunction, and will functionally discard any unprocessable instruction.
+
+## Sorting
+
+`ActiveSet` allows for multi-dimensional, multi-directional sorting across the same kinds of attributes as filtering ("direct", "computed", "associated", and "called").
+
+The syntax for the instructions hash is relatively simple:
+
+```ruby
+{
+    attribute: :desc,
+    association: {
+        field: :asc
+    }
+}
+```
+
+The logic for this method is to check whether all of the instructions appear to be processable by the ActiveRecordStrategy, and if they are to attempt to sort using the ActiveRecordStrategy (with all of the instructions, as you can't split sorting instructions). We then double check that all of the instructions were indeed successfully processed by the ActiveRecordStrategy, and if they were, we return that result. Otherwise (if either some instructions don't appear to be processable by ActiveRecord or some instructions weren't processed by ActiveRecord), we sort with the EnumerableStrategy.
+
+## Paginating
+
+`ActiveSet` also allows for paginating both ActiveRecord or plain Ruby enumerable sets.
+
+The syntax for the instructions hash remains relatively simple:
+
+```ruby
+{
+    size: 25,
+    page: 1
+}
+```
+
+Unlike the filtering or sorting operations, you do not have to pass an instructions hash, as the operation will default to paginating with a `size` of 25 and starting on `page` 1.
+
+Paginating as an operation works with "direct" instructions (that is, the instructions don't represent attribute paths or column structures; the instructions hash is a simple, flat hash), and the operation requires all instruction entries together (as opposed to filtering for example, where we can process each instruction entry separately).
 
 ## Future Feature Ideas
 

data/activeset.gemspec

@@ -1,14 +1,12 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'active_set/version'
 
 Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.name          = 'activeset'
-  spec.version       = ActiveSet::VERSION
+  spec.version       = '0.7.0'
   spec.authors       = ['Stephen Margheim']
   spec.email         = ['stephen.margheim@gmail.com']
 
@@ -27,12 +25,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '>= 4.0.2'
 
   spec.add_development_dependency 'bundler', '~> 1.15'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'database_cleaner', '~> 1.6.1'
   spec.add_development_dependency 'combustion', '~> 0.7.0'
-  spec.add_development_dependency 'factory_girl', '~> 4.8.0'
+  spec.add_development_dependency 'database_cleaner', '~> 1.6.1'
+  spec.add_development_dependency 'factory_bot', '~> 4.8.0'
   spec.add_development_dependency 'faker', '~> 1.8.4'
+  spec.add_development_dependency 'rails', '~> 5.1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'simplecov', '~> 0.15.0'
   spec.add_development_dependency 'simplecov-console', '~> 0.4.2'
 end

data/bin/console

@@ -1,11 +1,25 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'bundler'
+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
+end
+
 # (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"
 # Pry.start

data/lib/active_set.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require 'active_set/version'
-
 require 'active_support/core_ext/hash/reverse_merge'
-require 'active_set/processor_filter'
-require 'active_set/processor_sort'
-require 'active_set/processor_paginate'
-require 'active_set/processor_transform'
+require 'patches/core_ext/hash/flatten_keys'
+require 'helpers/throws'
+require 'active_set/attribute_instruction'
+require 'active_set/filtering/operation'
+require 'active_set/sorting/operation'
+require 'active_set/paginating/operation'
+require 'active_set/exporting/operation'
 
 class ActiveSet
   include Enumerable
@@ -23,8 +24,14 @@ class ActiveSet
     @view.each(&block)
   end
 
+  # :nocov:
+  def inspect
+    "#<ActiveSet:#{format('0x00%x', (object_id << 1))} @instructions=#{@instructions.inspect}>"
+  end
+
   def ==(other)
     return @view == other unless other.is_a?(ActiveSet)
+
     @view == other.view
   end
 
@@ -37,27 +44,26 @@ class ActiveSet
   def respond_to_missing?(method_name, include_private = false)
     @view.respond_to?(method_name) || super
   end
+  # :nocov:
 
-  def filter(instructions)
-    filterer = Processor::Filter.new(@view, instructions)
-    reinitialize(filterer.process, :filter, instructions)
+  def filter(instructions_hash)
+    filterer = Filtering::Operation.new(@view, instructions_hash)
+    reinitialize(filterer.execute, :filter, filterer.operation_instructions)
   end
 
-  def sort(instructions)
-    sorter = Processor::Sort.new(@view, instructions)
-    reinitialize(sorter.process, :sort, instructions)
+  def sort(instructions_hash)
+    sorter = Sorting::Operation.new(@view, instructions_hash)
+    reinitialize(sorter.execute, :sort, sorter.operation_instructions)
   end
 
-  def paginate(instructions)
-    paginater = Processor::Paginate.new(@view, instructions)
-    full_instructions = instructions.reverse_merge(page: paginater.instructions.get(:page),
-                                                   size: paginater.instructions.get(:size))
-    reinitialize(paginater.process, :paginate, full_instructions)
+  def paginate(instructions_hash)
+    paginater = Paginating::Operation.new(@view, instructions_hash)
+    reinitialize(paginater.execute, :paginate, paginater.operation_instructions)
   end
 
-  def transform(instructions)
-    transformer = Processor::Transform.new(@view, instructions)
-    transformer.process
+  def export(instructions_hash)
+    exporter = Exporting::Operation.new(@view, instructions_hash)
+    exporter.execute
   end
 
   private
@@ -66,6 +72,7 @@ class ActiveSet
     self.class.new(@set,
                    view: processed_set,
                    instructions: @instructions.merge(
-                     method => instructions))
+                     method => instructions
+                   ))
   end
 end

data/lib/active_set/{instruction.rb → attribute_instruction.rb}

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/array/wrap'
-
 class ActiveSet
-  class Instruction
+  class AttributeInstruction
+    attr_accessor :processed
     attr_reader :keypath, :value
 
     def initialize(keypath, value)
-      # `keypath` can be an Array (e.g. [:parent, :child, :grandchild])
-      # or a String (e.g. 'parent.child.grandchild')
-      @keypath = Array.wrap(keypath).map(&:to_s).flat_map { |x| x.split('.') }
+      # `keypath` can be an Array (e.g. [:parent, :child, :grandchild, :attribute])
+      # or a String (e.g. 'parent.child.grandchild.attribute')
+      @keypath = Array(keypath).map(&:to_s).flat_map { |x| x.split('.') }
       @value = value
+      @processed = false
+    end
+
+    def processed?
+      @processed
     end
 
     def attribute
@@ -43,7 +47,7 @@ class ActiveSet
 
     def value_for(item:)
       resource_for(item: item).public_send(attribute)
-    rescue
+    rescue StandardError
       # :nocov:
       nil
       # :nocov:
@@ -55,7 +59,7 @@ class ActiveSet
 
         resource.public_send(association)
       end
-    rescue
+    rescue StandardError
       # :nocov:
       nil
       # :nocov:

data/lib/active_set/column_instruction.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative './attribute_instruction'
+
+class ActiveSet
+  class ColumnInstruction
+    def initialize(instructions_hash, item)
+      @instructions_hash = instructions_hash.symbolize_keys
+      @item = item
+    end
+
+    def key
+      return @instructions_hash[:key] if @instructions_hash.key? :key
+
+      titleized = attribute_instruction.keypath.map(&:titleize).join(' ')
+      return titleized 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)
+
+      attribute_resource.class.human_attribute_name(attribute_instruction.attribute)
+    end
+
+    def value
+      return default unless @instructions_hash.key?(:value)
+      return @instructions_hash[:value].call(@item) if @instructions_hash[:value]&.respond_to? :call
+
+      attribute_instruction.value_for(item: @item)
+    end
+
+    private
+
+    def attribute_instruction
+      AttributeInstruction.new(@instructions_hash[:value], nil)
+    end
+
+    def default
+      return @instructions_hash[:default] if @instructions_hash.key? :default
+
+      '—'
+    end
+  end
+end

data/lib/active_set/exporting/operation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../column_instruction'
+
+class ActiveSet
+  module Exporting
+    class Operation
+      def initialize(set, instructions_hash)
+        @set = set
+        @instructions_hash = instructions_hash
+      end
+
+      def execute
+        strategy_for(format: operation_instructions[:format].to_s.downcase)
+          .new(@set, operation_instructions[:columns])
+          .execute
+      end
+
+      def operation_instructions
+        @instructions_hash.symbolize_keys
+      end
+
+      private
+
+      def strategy_for(format:)
+        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/operation.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative '../attribute_instruction'
+
+class ActiveSet
+  module Filtering
+    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_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
+          maybe_set_or_false.presence || set
+        end
+      end
+
+      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 unless attribute_item.method(@attribute_instruction.attribute).arity.zero?
+
+        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