activeset 0.6.5 → 0.7.0

data/lib/active_set/adapter_activerecord.rb

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

@@ -1,14 +0,0 @@
-# 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/instructions.rb

@@ -1,42 +0,0 @@
-# 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
-
-    # :nocov:
-    def method_missing(method_name, *args, &block)
-      @instructions.send(method_name, *args, &block) || super
-    end
-    # :nocov:
-
-    # :nocov:
-    def respond_to_missing?(method_name, include_private = false)
-      @instructions.respond_to?(method_name) || super
-    end
-    # :nocov:
-
-    def associations_hash
-      @instructions.reduce({}) { |h, i| h.merge(i.associations_hash) }
-    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

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

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

@@ -1,50 +0,0 @@
-# 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(default: '=')
-      end
-    end
-  end
-end

data/lib/active_set/processor_filter/enumerable_adapter.rb

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

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

data/lib/active_set/processor_paginate/active_record_adapter.rb

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

data/lib/active_set/processor_paginate/enumerable_adapter.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../adapter_base'
-require_relative '../processor_base'
-
-class ActiveSet
-  class Processor::Paginate < Processor::Base
-    class EnumerableAdapter < Adapter::Base
-      def process
-        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
-        @instructions.get('size').to_i
-      end
-
-      def page_number
-        num = @instructions.get('page').to_i
-        (num.to_i - 1).negative? ? 0 : num
-      end
-    end
-  end
-end

data/lib/active_set/processor_sort.rb

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../adapter_activerecord'
-require_relative '../processor_base'
-require_relative '../../helpers/throws'
-require_relative './active_record_operation'
-
-class ActiveSet
-  class Processor::Sort < Processor::Base
-    class ActiveRecordAdapter < Adapter::ActiveRecord
-      def process
-        return false unless @set.respond_to?(:to_sql)
-
-        @instructions.reduce(@set.eager_load(@instructions.associations_hash)) do |set, instruction|
-          ar_operation = ActiveRecordOperation.new(instruction, @set.klass)
-          return false unless ar_operation.attribute_is_field?
-
-          statement = set.merge(ar_operation.operation)
-
-          return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
-
-          statement
-        end
-      end
-    end
-  end
-end

data/lib/active_set/processor_sort/active_record_operation.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../adapter_activerecord'
-require_relative '../processor_base'
-require_relative '../../helpers/throws'
-
-class ActiveSet
-  class Processor::Sort < Processor::Base
-    class ActiveRecordOperation
-      def initialize(instruction, klass)
-        @instruction = instruction
-        @klass = klass
-      end
-
-      def operation
-        attribute_model.order(column.send(validate_direction(@instruction.value)))
-      end
-
-      def attribute_is_field?
-        return false unless attribute_model
-
-        attribute_model.attribute_names
-                       .include?(@instruction.attribute)
-      end
-
-      def case_insensitive?
-        @instruction.operator.to_s.downcase == 'i'
-      end
-
-      def column
-        column = table[@instruction.attribute]
-        case_insensitive? ? column.lower : column
-      end
-
-      def table
-        Arel::Table.new(attribute_model.table_name)
-      end
-
-      def validate_direction(direction)
-        return 'desc' if direction.to_s.downcase.start_with? 'desc'
-
-        'asc'
-      end
-
-      def attribute_model
-        tmp_model = @instruction.associations_array
-                                .reduce(@klass) 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
-end