activeset 0.5.8 → 0.6.0

data/lib/active_set/instructions/entry/keypath.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/string/inflections'
-
-class ActiveSet
-  class Instructions
-    class Entry
-      class KeyPath
-        attr_reader :path
-
-        def initialize(path)
-          # `path` can be an Array (e.g. [:parent, :child, :grandchild])
-          # or a String (e.g. 'parent.child.grandchild')
-          @path = Array.wrap(path).map(&:to_s).flat_map { |x| x.split('.') }
-        end
-
-        def attribute
-          attribute = @path.last
-          return attribute.sub(operator_regex, '') if attribute&.match operator_regex
-          attribute
-        end
-
-        def operator(default: '==')
-          attribute = @path.last
-          return attribute[operator_regex, 1] if attribute&.match operator_regex
-          default
-        end
-
-        def associations_array
-          return [] unless @path.any?
-          @path.slice(0, @path.length - 1)
-        end
-
-        def associations_hash
-          return {} unless @path.any?
-          associations_array.reverse.reduce({}) { |a, e| { e => a } }
-        end
-
-        def value_for(item:)
-          resource_for(item: item).send(attribute)
-        rescue
-          nil
-        end
-
-        def resource_for(item:)
-          associations_array.reduce(item, :try)
-        rescue
-          nil
-        end
-
-        def titleized
-          @path.map(&:titleize).join(' ')
-        end
-
-        private
-
-        def operator_regex
-          /\((.*?)\)/
-        end
-      end
-    end
-  end
-end

data/lib/active_set/instructions/entry/value.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveSet
-  class Instructions
-    class Entry
-      class Value
-        attr_reader :raw
-
-        def initialize(value)
-          @raw = value
-        end
-      end
-    end
-  end
-end

data/lib/active_set/processors/base_adapter.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveSet
-  class BaseAdapter
-    def initialize(set, instruction)
-      @set = set
-      @instruction = instruction
-    end
-
-    def return_set(set = nil)
-      {}.tap do |h|
-        h[:set] = set || @set
-        h[:processed] = set ? true : false
-      end
-    end
-  end
-end

data/lib/active_set/processors/base_processor.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'patches/core_ext/hash/flatten_keys'
-require_relative '../instructions/base'
-
-class ActiveSet
-  class BaseProcessor
-    def self.queue_adapter(adapter)
-      @adapters ||= []
-      @adapters |= [adapter]
-    end
-
-    def initialize(set, instructions)
-      @set = set
-      @instructions = Instructions.new(instructions)
-    end
-
-    def adapters
-      self.class.instance_variable_get(:@adapters)
-    end
-  end
-end

data/lib/active_set/processors/filter/active_record_adapter.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_adapter'
-require_relative '../base_processor'
-
-class ActiveSet
-  class FilterProcessor < BaseProcessor
-    class ActiveRecordAdapter < BaseAdapter
-      def process
-        return return_set unless @set.respond_to? :to_sql
-        return return_set(processed_query_set) if attribute_is_field?
-        return return_set(processed_scope_set) if attribute_is_class_method? && attribute_is_method_with_params?
-
-        return_set
-      end
-
-      private
-
-      def processed_query_set
-        arel_eager_load_associations.where(arel_operation)
-      end
-
-      def processed_scope_set
-        tmp_results = attribute_model.public_send(@instruction.attribute, @instruction.value)
-        return @set unless tmp_results.is_a?(ActiveRecord::Relation)
-        arel_eager_load_associations.merge(tmp_results)
-      end
-
-      def attribute_is_field?
-        return false unless attribute_model
-        attribute_model.attribute_names
-                       .include?(@instruction.attribute)
-      end
-
-      def attribute_is_class_method?
-        return false unless attribute_model
-        attribute_model.respond_to?(@instruction.attribute)
-      end
-
-      def attribute_is_method_with_params?
-        return false unless attribute_model
-        attribute_model.method(@instruction.attribute).arity != 0
-      end
-
-      def arel_operation
-        Arel::Nodes::InfixOperation.new(@instruction.operator(default: '='),
-                                        arel_column,
-                                        arel_value)
-      end
-
-      def attribute_model
-        tmp_model = @instruction.associations_array
-                                .reduce(@set) do |obj, assoc|
-                                  obj.reflections[assoc.to_s]&.klass
-                                end
-        return tmp_model.klass if tmp_model.is_a?(ActiveRecord::Relation)
-        tmp_model
-      end
-
-      def arel_eager_load_associations
-        @set.includes(@instruction.associations_hash)
-            .references(@instruction.associations_hash)
-      end
-
-      def arel_column
-        arel_table[@instruction.attribute]
-      end
-
-      def arel_value
-        Arel.sql(ActiveRecord::Base.connection.quote(@instruction.value))
-      end
-
-      def arel_table
-        Arel::Table.new(attribute_model.table_name)
-      end
-    end
-  end
-end

data/lib/active_set/processors/filter/enumerable_adapter.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_adapter'
-
-class ActiveSet
-  class FilterProcessor < BaseProcessor
-    class EnumerableAdapter < BaseAdapter
-      def process
-        return_set(filtered_set)
-      end
-
-      private
-
-      def filtered_set
-        @set.select do |item|
-          select_comparison_for(item: item)
-        end
-      end
-
-      def select_comparison_for(item:)
-        @instruction.value_for(item: item)
-                    .send(@instruction.operator,
-                          @instruction.value)
-      end
-    end
-  end
-end

data/lib/active_set/processors/filter_processor.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './base_processor'
-require_relative './filter/enumerable_adapter'
-require_relative './filter/active_record_adapter'
-
-class ActiveSet
-  class FilterProcessor < BaseProcessor
-    queue_adapter ActiveRecordAdapter
-    queue_adapter EnumerableAdapter
-
-    def process
-      adapters.reduce(@set) do |outer_set, adapter|
-        @instructions.process_adapter(set: outer_set, adapter: adapter)
-      end
-    end
-  end
-end

data/lib/active_set/processors/paginate_processor.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './base_processor'
-require_relative './paginate/enumerable_adapter'
-require_relative './paginate/active_record_adapter'
-
-class ActiveSet
-  class PaginateProcessor < BaseProcessor
-    queue_adapter ActiveRecordAdapter
-    queue_adapter EnumerableAdapter
-
-    def process
-      adapters.each do |adapter|
-        output = adapter.new(@set, instruction).process
-
-        return output[:set] if output[:processed]
-      end
-
-      @set
-    end
-
-    private
-
-    def instruction
-      Instructions::Entry.new(page_number, page_size)
-    end
-
-    def page_number
-      @instructions.get(:page) || 1
-    end
-
-    def page_size
-      @instructions.get(:size) || 25
-    end
-  end
-end

data/lib/active_set/processors/sort/active_record_adapter.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_adapter'
-require_relative '../base_processor'
-
-class ActiveSet
-  class SortProcessor < BaseProcessor
-    class ActiveRecordAdapter < BaseAdapter
-      def process
-        return return_set unless @set.respond_to? :to_sql
-        return return_set unless attribute_is_field?
-
-        return_set(processed_set)
-      end
-
-      private
-
-      def attribute_is_field?
-        return false unless attribute_model
-        attribute_model.attribute_names
-                       .include?(@instruction.attribute)
-      end
-
-      def processed_set
-        @set.includes(@instruction.associations_hash)
-            .references(@instruction.associations_hash)
-            .merge(arel_operation)
-      end
-
-      def arel_operation
-        column = case_insensitive? ? arel_column.lower : arel_column
-        attribute_model.order(column.send(@instruction.value))
-      end
-
-      def attribute_model
-        @instruction.associations_array
-                    .reduce(@set.klass) do |obj, assoc|
-                      obj.reflections[assoc.to_s]&.klass
-                    end
-      end
-
-      def arel_column
-        arel_table[@instruction.attribute]
-      end
-
-      def arel_table
-        Arel::Table.new(attribute_model.table_name)
-      end
-
-      def case_insensitive?
-        @instruction.operator.to_s == 'i'
-      end
-    end
-  end
-end

data/lib/active_set/processors/sort/enumerable_adapter.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_adapter'
-require_relative '../base_processor'
-
-class ActiveSet
-  class SortProcessor < BaseProcessor
-    class EnumerableAdapter < BaseAdapter
-      def process
-        return_set(sorted_set)
-      end
-
-      private
-
-      def sorted_set
-        @set.sort_by { |item| sortable_attribute_for(item: item) }
-            .tap { |c| c.reverse! if descending? }
-      end
-
-      def sortable_attribute_for(item:)
-        attribute_value = @instruction.value_for(item: item)
-        case_insensitive?(attribute_value) ? insensify(attribute_value) : attribute_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 == 'i'
-      end
-
-      def insensify(value)
-        value.to_s.downcase
-      end
-
-      def descending?
-        @instruction.value.to_s == 'desc'
-      end
-    end
-  end
-end

data/lib/active_set/processors/sort_processor.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './base_processor'
-require_relative './sort/enumerable_adapter'
-require_relative './sort/active_record_adapter'
-
-class ActiveSet
-  class SortProcessor < BaseProcessor
-    queue_adapter ActiveRecordAdapter
-    queue_adapter EnumerableAdapter
-
-    def process
-      adapters.reduce(@set) do |outer_set, adapter|
-        @instructions.process_adapter(set: outer_set, adapter: adapter)
-      end
-    end
-  end
-end