activeset 0.5.8 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 247cfa01133a97a1cd14001735f39c8893991ba2
-  data.tar.gz: 4486e9c33939988777f2f48b34cd380025754088
+  metadata.gz: 8a2838aec338dd5f82088e61e90e37ad419a2039
+  data.tar.gz: 741731ac20fec572d99e2b7b62019af6116c89fc
 SHA512:
-  metadata.gz: 1fc8a19b38aae78bd7e31e8ab26b670ef8fbdb6f6378c7bf7621f46e8e1b7e34f81f3c44a74c26916fe64d68686d548af0d20ec19ba572ebde493b92ee1b0309
-  data.tar.gz: 49fdcd2b998a7ec0fdfdb1d9dd3febb284d17abadc54085145883e6a4209b6815a45979b0d0ed6388d048f809f3b6501cabbd7082a004b18cb372f0965029878
+  metadata.gz: 406349801340205ffc8035cc71540b8f03cfd89d67ef4c150b2c16fd94dc5838a16acdfee91dc5fd7c74b300fb4b5f39fbee79429b57c4411a2e9d87ee88a60b
+  data.tar.gz: 661719703c5b4b1fd8cee0459ef6e261fdf0094ea85dc855c96115ccaeda55bbb773d0eaf93edfc1d08f67544487dfc737d563b484dabfc608c8feafab49e0e5

data/CHANGELOG

@@ -1,3 +1,5 @@
+v 0.6.0
+  - rewrite from the ground up
 v 0.5.8
   - Avoid a possible error path where relations with a '#union' would blow up when using '#merge' because the '#order' operation was being built with the relation and not with the relation's base class
 v 0.5.7

data/lib/active_set.rb

@@ -2,67 +2,65 @@
 
 require 'active_set/version'
 
-require 'active_set/processors/filter_processor'
-require 'active_set/processors/sort_processor'
-require 'active_set/processors/paginate_processor'
-require 'active_set/processors/transform_processor'
+require 'active_set/processor_filter'
+require 'active_set/processor_sort'
+require 'active_set/processor_paginate'
+require 'active_set/processor_transform'
 
 class ActiveSet
   include Enumerable
 
-  attr_reader :set, :instructions, :total_count
+  attr_reader :set, :view, :instructions
 
-  def initialize(set, instructions: {}, total_count: nil)
+  def initialize(set, view: nil, instructions: {})
     @set = set
+    @view = view || set
     @instructions = instructions
-    @total_count = total_count || @set.count
   end
 
   def each(&block)
-    @set.each(&block)
+    @view.each(&block)
   end
 
   def ==(other)
-    return @set == other unless other.is_a?(ActiveSet)
-    @set == other.set
+    return @view == other unless other.is_a?(ActiveSet)
+    @view == other.view
   end
 
   def method_missing(method_name, *args, &block)
-    @set.send(method_name, *args, &block) || super
+    @view.send(method_name, *args, &block) || super
   end
 
   def respond_to_missing?(method_name, include_private = false)
-    @set.respond_to?(method_name) || super
+    @view.respond_to?(method_name) || super
   end
 
   def filter(instructions)
-    filterer = FilterProcessor.new(@set, instructions)
-    filtered_set = filterer.process
-    new_active_set(filtered_set, :filter, instructions, filtered_set.count)
+    filterer = Processor::Filter.new(@view, instructions)
+    reinitialize(filterer.process, :filter, instructions)
   end
 
   def sort(instructions)
-    sorter = SortProcessor.new(@set, instructions)
-    new_active_set(sorter.process, :sort, instructions)
+    sorter = Processor::Sort.new(@view, instructions)
+    reinitialize(sorter.process, :sort, instructions)
   end
 
   def paginate(instructions)
-    paginater = PaginateProcessor.new(@set, instructions)
-    full_instructions = instructions.reverse_merge(page: paginater.send(:page_number),
-                                                   size: paginater.send(:page_size))
-    new_active_set(paginater.process, :paginate, full_instructions)
+    paginater = Processor::Paginate.new(@view, instructions)
+    reinitialize(paginater.process, :paginate, instructions)
   end
 
   def transform(instructions)
-    transformer = TransformProcessor.new(@set, instructions)
+    transformer = Processor::Transform.new(@view, instructions)
     transformer.process
   end
 
   private
 
-  def new_active_set(set, method, instructions, total_count = nil)
-    self.class.new(set,
-                   instructions: @instructions.merge(method => instructions),
-                   total_count: total_count || @total_count)
+  def reinitialize(processed_set, method, instructions)
+    self.class.new(@set,
+                   view: processed_set,
+                   instructions: @instructions.merge(
+                     method => instructions))
   end
 end

data/lib/active_set/adapter_activerecord.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative './adapter_base'
+
+class ActiveSet
+  class Adapter::ActiveRecord < Adapter::Base
+    private
+
+    def can_query_with_active_record?
+      attribute_is_field?
+    end
+
+    def can_merge_with_active_record?
+      attribute_is_class_method? &&
+        attribute_is_method_with_params?
+    end
+
+    def arel_eager_load_associations
+      @set.eager_load(instruction.associations_hash)
+    end
+
+    def arel_column
+      arel_table[instruction.attribute]
+    end
+
+    def arel_table
+      Arel::Table.new(attribute_model.table_name)
+    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 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
+  end
+end

data/lib/active_set/adapter_base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Adapter
+    class Base
+      attr_accessor :instruction
+
+      def initialize(set, instructions)
+        @set = set
+        @instructions = instructions
+      end
+    end
+  end
+end

data/lib/active_set/instruction.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+
+class ActiveSet
+  class Instruction
+    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('.') }
+      @value = value
+    end
+
+    def attribute
+      attribute = @keypath.last
+      return attribute.sub(operator_regex, '') if attribute&.match operator_regex
+
+      attribute
+    end
+
+    def operator(default: '==')
+      attribute = @keypath.last
+      return attribute[operator_regex, 1] if attribute&.match operator_regex
+
+      default
+    end
+
+    def associations_array
+      return [] unless @keypath.any?
+
+      @keypath.slice(0, @keypath.length - 1)
+    end
+
+    def associations_hash
+      return {} unless @keypath.any?
+
+      associations_array.reverse.reduce({}) do |hash, association|
+        { association => hash }
+      end
+    end
+
+    def value_for(item:)
+      resource_for(item: item).public_send(attribute)
+    rescue
+      nil
+    end
+
+    def resource_for(item:)
+      associations_array.reduce(item) do |resource, association|
+        return nil unless resource.respond_to? association
+
+        resource.public_send(association)
+      end
+    rescue
+      nil
+    end
+
+    private
+
+    def operator_regex
+      /\((.*?)\)/
+    end
+  end
+end

data/lib/active_set/instructions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../patches/core_ext/hash/flatten_keys'
+require_relative './instruction'
+
+class ActiveSet
+  class Instructions
+    include Enumerable
+
+    def initialize(hash)
+      @instructions = hash.flatten_keys.map do |keypath, value|
+        Instruction.new(keypath, value)
+      end
+    end
+
+    def each(&block)
+      @instructions.each(&block)
+    end
+
+    def method_missing(method_name, *args, &block)
+      @instructions.send(method_name, *args, &block) || super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @instructions.respond_to?(method_name) || super
+    end
+
+    def get(key)
+      @instructions.find do |instruction|
+        instruction.attribute.to_s == key.to_s
+      end&.value
+    end
+  end
+end

data/lib/active_set/processor_base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './instructions'
+
+class ActiveSet
+  module Processor
+    class Base
+      attr_reader :set, :instructions, :adapters
+
+      def self.register_adapter(adapter, precedence = 0)
+        @adapters ||= []
+        @adapters.insert(precedence, adapter)
+      end
+
+      def initialize(set, instructions)
+        @set = set
+        @instructions = Instructions.new(validate_instructions(instructions))
+        @adapters = self.class.instance_variable_get(:@adapters)
+      end
+
+      private
+
+      def validate_instructions(instructions)
+        instructions
+      end
+    end
+  end
+end

data/lib/active_set/processor_filter.rb

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

data/lib/active_set/processor_filter/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::Filter < Processor::Base
+    class ActiveRecordAdapter < Adapter::ActiveRecord
+      def process
+        return false unless @set.respond_to?(:to_sql)
+
+        if can_query_with_active_record?
+          statement = arel_eager_load_associations
+                        .where(arel_operation)
+        elsif can_merge_with_active_record?
+          statement = arel_eager_load_associations
+                        .merge(attribute_model.public_send(instruction.attribute,
+                                                           instruction.value))
+        else
+          return false
+        end
+
+        return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
+
+        statement
+      end
+
+      private
+
+      def instruction
+        @instructions.first
+      end
+
+      def arel_operation
+        Arel::Nodes::InfixOperation.new(arel_operator,
+                                        arel_column,
+                                        arel_value)
+      end
+
+      def arel_value
+        Arel.sql(ActiveRecord::Base.connection.quote(instruction.value))
+      end
+
+      def arel_operator
+        instruction.operator
+      end
+    end
+  end
+end

data/lib/active_set/processor_filter/enumerable_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../adapter_base'
+
+class ActiveSet
+  class Processor::Filter < Processor::Base
+    class EnumerableAdapter < Adapter::Base
+      def process
+        return false unless @set.respond_to? :select
+
+        @instructions.reduce(@set) do |set, instruction|
+          set.select do |item|
+            instruction.value_for(item: item)
+                       .send(instruction.operator,
+                             instruction.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_set/processor_paginate.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative './processor_base'
+require_relative './processor_paginate/enumerable_adapter'
+require_relative './processor_paginate/active_record_adapter'
+
+class ActiveSet
+  class Processor::Paginate < Processor::Base
+    def process
+      adapters.each do |adapter|
+        result = adapter.new(@set, @instructions).process
+        break(result) if result
+      end
+    end
+
+    private
+
+    def validate_instructions(instructions)
+      {
+        page:   (instructions[:page] ||
+                 instructions['page'] ||
+                 1).to_i,
+        size:   (instructions[:size] ||
+                 instructions['size'] ||
+                 25).to_i,
+        outset: (instructions[:outset] ||
+                 instructions['outset'] ||
+                 0).to_i
+      }
+    end
+
+    register_adapter(EnumerableAdapter)
+    register_adapter(ActiveRecordAdapter)
+  end
+end