active_record_seek 0.0.1

data/lib/active_record_seek.rb

@@ -0,0 +1,29 @@
+require "byebug"
+require "active_support"
+require "active_support/core_ext"
+require "active_record_seek/version"
+# concerns
+require "active_record_seek/concerns/instance_variable_concern"
+# core
+require "active_record_seek/query"
+require "active_record_seek/component"
+require "active_record_seek/middleware"
+# operators
+require "active_record_seek/operators/base_operator"
+require "active_record_seek/operators/matches_base_operator"
+require "active_record_seek/operators/regexp_base_operator"
+require "active_record_seek/operators/ci_base_operator"
+require "active_record_seek/operators/ci_matches_base_operator"
+require "active_record_seek/operators/ci_regexp_base_operator"
+# scopes
+require "active_record_seek/scopes/base_scope"
+require "active_record_seek/scopes/association_scope"
+require "active_record_seek/scopes/seek_or_scope"
+require "active_record_seek/scopes/seek_scope"
+# callbacks
+require "active_record_seek/concerns/active_record_concern"
+
+ActiveSupport.on_load(:active_record) do
+  # adds builder methods used to initialize seek scopes on columns of a model
+  include ActiveRecordSeek::Concerns::ActiveRecordConcern
+end

data/lib/active_record_seek/component.rb

@@ -0,0 +1,57 @@
+module ActiveRecordSeek
+  class Component
+
+    include Concerns::InstanceVariableConcern
+
+    attr_accessor(*%w[
+      base_query
+      value
+      operator
+      column
+      namespace
+      original_key
+    ])
+    attr_reader(*%w[ association ])
+    delegate(*%w[ active_record_query seek_query ], to: :base_query)
+    delegate(*%w[ table_name adapter_name ], to: :seek_query)
+
+
+    def key=(new_key)
+      self.original_key = new_key.to_s
+      parts = original_key.split(".").select(&:present?)
+      self.operator    = parts.pop
+      self.column      = parts.pop
+      self.association = parts.pop || "self"
+      self.namespace   = parts.pop || "default"
+      key
+    end
+
+    def key
+      "#{namespace}.#{association}.#{column}.#{operator}"
+    end
+
+    def association=(new_association)
+      @association = new_association == "self" ? table_name : new_association
+    end
+
+    def is_base_query_component?
+      association == table_name
+    end
+
+    def operator_class
+      "::ActiveRecordSeek::Operators::#{operator.camelcase}Operator".constantize
+    end
+
+    def apply(query)
+      Middleware.middleware.each do |middleware|
+        action = middleware.call(self)
+        case action
+        when :skip then return query
+        else # no action
+        end
+      end
+      operator_class.new(component: self).apply(query)
+    end
+
+  end
+end

data/lib/active_record_seek/concerns/active_record_concern.rb

@@ -0,0 +1,20 @@
+module ActiveRecordSeek
+  module Concerns
+    module ActiveRecordConcern
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveRecordSeek::Scopes::SeekScope::ActiveRecordScopeConcern
+        include ActiveRecordSeek::Scopes::SeekOrScope::ActiveRecordScopeConcern
+      end
+
+      class_methods do
+        def to_seek_query
+          ::ActiveRecordSeek::Query.new(active_record_query: all)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record_seek/concerns/instance_variable_concern.rb

@@ -0,0 +1,40 @@
+module ActiveRecordSeek
+  module Concerns
+    module InstanceVariableConcern
+
+      extend ActiveSupport::Concern
+
+      def initialize(variables = {})
+        set(variables)
+        after_initialize
+      end
+
+      def after_initialize
+        # noop
+      end
+
+      def set(params = {})
+        params.each { |key, value| send("#{key}=", value) }
+        self
+      end
+
+      def instance_variable_reset(variable, &block)
+        if instance_variable_defined?(variable)
+          remove_instance_variable(variable)
+          true
+        else
+          false
+        end
+      end
+
+      def instance_variable_yield(variable)
+        if instance_variable_defined?(variable)
+          value = instance_variable_get(variable)
+          yield(value)
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record_seek/middleware.rb

@@ -0,0 +1,24 @@
+module ActiveRecordSeek
+  class Middleware
+
+    attr_accessor(*%w[ name middleware_block ])
+
+    def initialize(name:, &middleware_block)
+      raise(ArgumentError, "#{self.class} expects a block") if !middleware_block
+      self.name = name.to_s
+      self.middleware_block = middleware_block
+      self.class.middleware.push(self)
+    end
+
+    def call(*params, &block)
+      middleware_block.call(*params, &block)
+    end
+
+    class << self
+      def middleware
+        @middleware ||= []
+      end
+    end
+
+  end
+end

data/lib/active_record_seek/operators/base_operator.rb

@@ -0,0 +1,65 @@
+module ActiveRecordSeek
+  module Operators
+    class BaseOperator
+
+      include Concerns::InstanceVariableConcern
+
+      attr_accessor(*%w[ component query ])
+      attr_writer(*%w[ arel_table arel_column arel_value ])
+
+      def arel_table
+        query.arel_table
+      end
+
+      def arel_column
+        arel_table[component.column]
+      end
+
+      def arel_value
+        component.value
+      end
+
+      def arel_operation
+        arel_column.send(component.operator, arel_value)
+      end
+
+      def apply(query)
+        set(query: query)
+        query.where(arel_operation)
+      end
+
+    end
+
+    %w[
+      between
+      eq
+      eq_all
+      eq_any
+      gt
+      gt_all
+      gt_any
+      gteq
+      gteq_all
+      gteq_any
+      in
+      in_all
+      in_any
+      lt
+      lt_all
+      lt_any
+      lteq
+      lteq_all
+      lteq_any
+      not_between
+      not_eq
+      not_eq_all
+      not_eq_any
+      not_in
+      not_in_all
+      not_in_any
+    ].each do |operator|
+      const_set("#{operator.camelcase}Operator", Class.new(BaseOperator))
+    end
+  end
+end
+

data/lib/active_record_seek/operators/ci_base_operator.rb

@@ -0,0 +1,66 @@
+module ActiveRecordSeek
+  module Operators
+    class CiBaseOperator < BaseOperator
+
+      def ci_arel_column
+        arel_column.lower
+      end
+
+      def ci_arel_value(value = arel_value)
+        if value.is_a?(Array)
+          value.map { |v| ci_arel_value(v) }
+        elsif value.is_a?(String)
+          arel_table.lower(value)
+        else
+          value
+        end
+      end
+
+      def arel_operation
+        ci_arel_column.send(component.operator, ci_arel_value)
+      end
+
+    end
+
+    %w[
+      eq
+      eq_all
+      eq_any
+      gt
+      gt_all
+      gt_any
+      gteq
+      gteq_all
+      gteq_any
+      in
+      in_all
+      in_any
+      lt
+      lt_all
+      lt_any
+      lteq
+      lteq_all
+      lteq_any
+      not_eq
+      not_eq_all
+      not_eq_any
+      not_in
+      not_in_all
+      not_in_any
+    ].to_h do |operator|
+      [
+        operator.gsub(/\A(not_)?/, '\1ci_'),
+        operator,
+      ]
+    end.each do |seek_operator, arel_operator|
+      operator_class = Class.new(CiBaseOperator) do
+        define_method(:arel_operation) do
+          ci_arel_column.send(arel_operator, ci_arel_value)
+        end
+      end
+
+      const_set("#{seek_operator.to_s.camelcase}Operator", operator_class)
+    end
+  end
+end
+

data/lib/active_record_seek/operators/ci_matches_base_operator.rb

@@ -0,0 +1,38 @@
+module ActiveRecordSeek
+  module Operators
+    class CiMatchesBaseOperator < CiBaseOperator
+
+    end
+
+    {
+      ci_like:         :matches,
+      ci_like_all:     :matches_all,
+      ci_like_any:     :matches_any,
+      not_ci_like:     :does_not_match,
+      not_ci_like_all: :does_not_match_all,
+      not_ci_like_any: :does_not_match_any,
+    }.each do |seek_operator, arel_operator|
+      operator_class = Class.new(CiMatchesBaseOperator) do
+        define_method(:arel_operation) do
+          operation =
+            # manually LOWER for adapters without ILIKE support
+            if component.adapter_name.in?(%w[ SQLite Mysql2 ])
+              ci_arel_column.send(arel_operator, ci_arel_value)
+            else
+              arel_column.send(arel_operator, arel_value)
+            end
+          # switch to ILIKE if supported
+          operation.each do |operation_part|
+            if operation_part.class.in?([Arel::Nodes::Matches, Arel::Nodes::DoesNotMatch])
+              operation_part.case_sensitive = false
+            end
+          end
+          operation
+        end
+      end
+
+      const_set("#{seek_operator.to_s.camelcase}Operator", operator_class)
+    end
+
+  end
+end

data/lib/active_record_seek/operators/ci_regexp_base_operator.rb

@@ -0,0 +1,46 @@
+module ActiveRecordSeek
+  module Operators
+    class CiRegexpBaseOperator < BaseOperator
+
+    end
+
+    {
+      ci_regexp:     :matches_regexp,
+      ci_regexp_all: :matches_regexp,
+      ci_regexp_any: :matches_regexp,
+      not_ci_regexp:     :does_not_match_regexp,
+      not_ci_regexp_all: :does_not_match_regexp,
+      not_ci_regexp_any: :does_not_match_regexp,
+    }.each do |seek_operator, arel_operator|
+      operator_class = Class.new(RegexpBaseOperator) do
+        define_method(:arel_operation) do
+          operation = nil
+          # must manually define _all and _any operations because arel only has matches_regexp
+          if seek_operator =~ /_all\z/
+            arel_value.each do |and_arel_value|
+              and_operation = arel_column.send(arel_operator, and_arel_value)
+              operation = operation ? operation.and(and_operation) : and_operation
+            end
+          elsif seek_operator =~ /_any\z/
+            arel_value.each do |or_arel_value|
+              or_operation = arel_column.send(arel_operator, or_arel_value)
+              operation = operation ? operation.or(or_operation) : or_operation
+            end
+          else
+            operation = arel_column.send(arel_operator, arel_value)
+          end
+          # switch to ~ operator
+          operation.each do |operation_part|
+            if operation_part.class.in?([Arel::Nodes::Regexp, Arel::Nodes::NotRegexp])
+              operation_part.case_sensitive = false
+            end
+          end
+          operation
+        end
+      end
+
+      const_set("#{seek_operator.to_s.camelcase}Operator", operator_class)
+    end
+
+  end
+end

data/lib/active_record_seek/operators/matches_base_operator.rb

@@ -0,0 +1,32 @@
+module ActiveRecordSeek
+  module Operators
+    class MatchesBaseOperator < BaseOperator
+
+    end
+
+    {
+      like:         :matches,
+      like_all:     :matches_all,
+      like_any:     :matches_any,
+      not_like:     :does_not_match,
+      not_like_all: :does_not_match_all,
+      not_like_any: :does_not_match_any,
+    }.each do |seek_operator, arel_operator|
+      operator_class = Class.new(MatchesBaseOperator) do
+        define_method(:arel_operation) do
+          operation = arel_column.send(arel_operator, arel_value)
+          # switch to LIKE operator
+          operation.each do |operation_part|
+            if operation_part.class.in?([Arel::Nodes::Matches, Arel::Nodes::DoesNotMatch])
+              operation_part.case_sensitive = true
+            end
+          end
+          operation
+        end
+      end
+
+      const_set("#{seek_operator.to_s.camelcase}Operator", operator_class)
+    end
+
+  end
+end

data/lib/active_record_seek/operators/regexp_base_operator.rb

@@ -0,0 +1,46 @@
+module ActiveRecordSeek
+  module Operators
+    class RegexpBaseOperator < BaseOperator
+
+    end
+
+    {
+      regexp:     :matches_regexp,
+      regexp_all: :matches_regexp,
+      regexp_any: :matches_regexp,
+      not_regexp:     :does_not_match_regexp,
+      not_regexp_all: :does_not_match_regexp,
+      not_regexp_any: :does_not_match_regexp,
+    }.each do |seek_operator, arel_operator|
+      operator_class = Class.new(RegexpBaseOperator) do
+        define_method(:arel_operation) do
+          operation = nil
+          # must manually define _all and _any operations because arel only has matches_regexp
+          if seek_operator =~ /_all\z/
+            arel_value.each do |and_arel_value|
+              and_operation = arel_column.send(arel_operator, and_arel_value)
+              operation = operation ? operation.and(and_operation) : and_operation
+            end
+          elsif seek_operator =~ /_any\z/
+            arel_value.each do |or_arel_value|
+              or_operation = arel_column.send(arel_operator, or_arel_value)
+              operation = operation ? operation.or(or_operation) : or_operation
+            end
+          else
+            operation = arel_column.send(arel_operator, arel_value)
+          end
+          # switch to ~ operator
+          operation.each do |operation_part|
+            if operation_part.class.in?([Arel::Nodes::Regexp, Arel::Nodes::NotRegexp])
+              operation_part.case_sensitive = true
+            end
+          end
+          operation
+        end
+      end
+
+      const_set("#{seek_operator.to_s.camelcase}Operator", operator_class)
+    end
+
+  end
+end