active_record_extended_telescope 2.0.1

data/lib/active_record_extended.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "active_record_extended/version"
+require "active_record_extended/utilities/support"
+require "active_record_extended/utilities/order_by"
+require "active_record_extended/active_record"
+require "active_record_extended/arel"
+
+module ActiveRecordExtended
+end

data/lib/active_record_extended/active_record.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_record/relation"
+require "active_record/relation/merger"
+require "active_record/relation/query_methods"
+
+require "active_record_extended/predicate_builder/array_handler_decorator"
+
+require "active_record_extended/active_record/relation_patch"
+
+require "active_record_extended/query_methods/where_chain"
+require "active_record_extended/query_methods/with_cte"
+require "active_record_extended/query_methods/unionize"
+require "active_record_extended/query_methods/any_of"
+require "active_record_extended/query_methods/either"
+require "active_record_extended/query_methods/inet"
+require "active_record_extended/query_methods/json"
+require "active_record_extended/query_methods/select"
+
+if Gem::Requirement.new("~> 5.1.0").satisfied_by?(ActiveRecord.gem_version)
+  require "active_record_extended/patch/5_1/where_clause"
+else
+  require "active_record_extended/patch/5_2/where_clause"
+end

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_record_extended/query_methods/window"
+require "active_record_extended/query_methods/unionize"
+require "active_record_extended/query_methods/json"
+
+module ActiveRecordExtended
+  module RelationPatch
+    module QueryDelegation
+      delegate :with, :define_window, :select_window, :foster_select, to: :all
+      delegate(*::ActiveRecordExtended::QueryMethods::Unionize::UNIONIZE_METHODS, to: :all)
+      delegate(*::ActiveRecordExtended::QueryMethods::Json::JSON_QUERY_METHODS, to: :all)
+    end
+
+    module Merger
+      def normal_values
+        super + [:union, :define_window]
+      end
+
+      def merge
+        merge_ctes!
+        super
+      end
+
+      def merge_ctes!
+        return unless other.with_values?
+
+        if other.recursive_value? && !relation.recursive_value?
+          relation.with!(:chain).recursive(other.cte)
+        else
+          relation.with!(other.cte)
+        end
+      end
+    end
+
+    module ArelBuildPatch
+      def build_arel(*aliases)
+        super.tap do |arel|
+          build_windows(arel) if window_values?
+          build_unions(arel)  if union_values?
+          build_with(arel)    if with_values?
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::RelationPatch::ArelBuildPatch)
+ActiveRecord::Relation::Merger.prepend(ActiveRecordExtended::RelationPatch::Merger)
+ActiveRecord::Querying.prepend(ActiveRecordExtended::RelationPatch::QueryDelegation)

data/lib/active_record_extended/arel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/sql_literal"
+require "active_record_extended/arel/aggregate_function_name"
+require "active_record_extended/arel/predications"
+require "active_record_extended/arel/visitors/postgresql_decorator"

data/lib/active_record_extended/arel/aggregate_function_name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Arel
+  module Nodes
+    class AggregateFunctionName < ::Arel::Nodes::Node
+      include Arel::Predications
+      include Arel::WindowPredications
+      attr_accessor :name, :expressions, :distinct, :alias, :orderings
+
+      def initialize(name, expr, distinct = false)
+        super()
+        @name        = name.to_s.upcase
+        @expressions = expr
+        @distinct    = distinct
+      end
+
+      def order_by(expr)
+        @orderings = expr
+        self
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@name, @expressions, @distinct, @alias, @orderings].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          expressions == other.expressions &&
+          orderings == other.orderings &&
+          distinct == other.distinct
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/active_record_extended/arel/nodes.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "arel/nodes/binary"
+require "arel/nodes/function"
+
+module Arel
+  module Nodes
+    if Gem::Requirement.new("< 6.1").satisfied_by?(ActiveRecord.gem_version)
+      ["Contains", "Overlaps"].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+    end
+
+    [
+      "ContainsHStore",
+      "ContainsArray",
+      "ContainedInArray"
+    ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+
+    [
+      "RowToJson",
+      "JsonBuildObject",
+      "JsonbBuildObject",
+      "ToJson",
+      "ToJsonb",
+      "Array",
+      "ArrayAgg"
+    ].each do |function_node_name|
+      func_klass = Class.new(::Arel::Nodes::Function) do
+        def initialize(*args)
+          super
+          return if @expressions.is_a?(::Array)
+
+          @expressions = @expressions.is_a?(::Arel::Nodes::Node) ? [@expressions] : [::Arel.sql(@expressions)]
+        end
+      end
+
+      const_set(function_node_name, func_klass)
+    end
+
+    module Inet
+      [
+        "Contains",
+        "ContainsEquals",
+        "ContainedWithin",
+        "ContainedWithinEquals",
+        "ContainsOrContainedWithin"
+      ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+    end
+  end
+end

data/lib/active_record_extended/arel/predications.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "arel/predications"
+
+module Arel
+  module Predications
+    def any(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new("ANY", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
+    end
+
+    def all(other)
+      all_tags_function = Arel::Nodes::NamedFunction.new("ALL", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), all_tags_function)
+    end
+
+    def overlaps(other)
+      Nodes::Overlaps.new(self, Nodes.build_quoted(other, self))
+    end
+    alias overlap overlaps
+
+    def contains(other)
+      Nodes::Contains.new self, Nodes.build_quoted(other, self)
+    end
+
+    def contained_in_array(other)
+      Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
+    end
+
+    def inet_contains(other)
+      Nodes::Inet::Contains.new self, Nodes.build_quoted(other, self)
+    end
+
+    def inet_contains_or_is_contained_within(other)
+      Nodes::Inet::ContainsOrContainedWithin.new self, Nodes.build_quoted(other, self)
+    end
+
+    def inet_contained_within(other)
+      Nodes::Inet::ContainedWithin.new self, Nodes.build_quoted(other, self)
+    end
+
+    def inet_contained_within_or_equals(other)
+      Nodes::Inet::ContainedWithinEquals.new self, Nodes.build_quoted(other, self)
+    end
+
+    def inet_contains_or_equals(other)
+      Nodes::Inet::ContainsEquals.new self, Nodes.build_quoted(other, self)
+    end
+  end
+end

data/lib/active_record_extended/arel/sql_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "arel/nodes/sql_literal"
+
+# CTE alias fix for Rails 6.1
+module Arel
+  module Nodes
+    module SqlLiteralDecorator
+      def name
+        self
+      end
+    end
+  end
+end
+
+Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralDecorator)

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "arel/visitors/postgresql"
+
+module ActiveRecordExtended
+  module Visitors
+    module PostgreSQLDecorator
+      private
+
+      # rubocop:disable Naming/MethodName
+
+      def visit_Arel_Nodes_Overlaps(object, collector)
+        infix_value object, collector, " && "
+      end
+
+      def visit_Arel_Nodes_Contains(object, collector)
+        left_column = object.left.relation.name.classify.constantize.columns.detect do |col|
+          matchable_column?(col, object)
+        end
+
+        if [:hstore, :jsonb].include?(left_column&.type)
+          visit_Arel_Nodes_ContainsHStore(object, collector)
+        elsif left_column.try(:array)
+          visit_Arel_Nodes_ContainsArray(object, collector)
+        else
+          visit_Arel_Nodes_Inet_Contains(object, collector)
+        end
+      end
+
+      def visit_Arel_Nodes_ContainsArray(object, collector)
+        infix_value object, collector, " @> "
+      end
+
+      def visit_Arel_Nodes_ContainsHStore(object, collector)
+        infix_value object, collector, " @> "
+      end
+
+      def visit_Arel_Nodes_ContainedInHStore(object, collector)
+        infix_value object, collector, " <@ "
+      end
+
+      def visit_Arel_Nodes_ContainedInArray(object, collector)
+        infix_value object, collector, " <@ "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainedWithin(object, collector)
+        infix_value object, collector, " << "
+      end
+
+      def visit_Arel_Nodes_RowToJson(object, collector)
+        aggregate "ROW_TO_JSON", object, collector
+      end
+
+      def visit_Arel_Nodes_JsonBuildObject(object, collector)
+        aggregate "JSON_BUILD_OBJECT", object, collector
+      end
+
+      def visit_Arel_Nodes_JsonbBuildObject(object, collector)
+        aggregate "JSONB_BUILD_OBJECT", object, collector
+      end
+
+      def visit_Arel_Nodes_ToJson(object, collector)
+        aggregate "TO_JSON", object, collector
+      end
+
+      def visit_Arel_Nodes_ToJsonb(object, collector)
+        aggregate "TO_JSONB", object, collector
+      end
+
+      def visit_Arel_Nodes_Array(object, collector)
+        aggregate "ARRAY", object, collector
+      end
+
+      def visit_Arel_Nodes_ArrayAgg(object, collector)
+        aggregate "ARRAY_AGG", object, collector
+      end
+
+      def visit_Arel_Nodes_AggregateFunctionName(object, collector)
+        collector << "#{object.name}("
+        collector << "DISTINCT " if object.distinct
+        collector = inject_join(object.expressions, collector, ", ")
+
+        if object.orderings
+          collector << " ORDER BY "
+          collector = inject_join(object.orderings, collector, ", ")
+        end
+        collector << ")"
+
+        if object.alias
+          collector << " AS "
+          visit object.alias, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_Inet_Contains(object, collector)
+        infix_value object, collector, " >> "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainedWithinEquals(object, collector)
+        infix_value object, collector, " <<= "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainsEquals(object, collector)
+        infix_value object, collector, " >>= "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainsOrContainedWithin(object, collector)
+        infix_value object, collector, " && "
+      end
+
+      def matchable_column?(col, object)
+        col.name == object.left.name.to_s || col.name == object.left.relation.name.to_s
+      end
+
+      # rubocop:enable Naming/MethodName
+    end
+  end
+end
+
+Arel::Visitors::PostgreSQL.prepend(ActiveRecordExtended::Visitors::PostgreSQLDecorator)

data/lib/active_record_extended/patch/5_1/where_clause.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module WhereClause
+    def modified_predicates(&block)
+      ::ActiveRecord::Relation::WhereClause.new(predicates.map(&block), binds)
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::WhereClause)

data/lib/active_record_extended/patch/5_2/where_clause.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module WhereClause
+    def modified_predicates(&block)
+      ::ActiveRecord::Relation::WhereClause.new(predicates.map(&block))
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::WhereClause)

data/lib/active_record_extended/predicate_builder/array_handler_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_record/relation/predicate_builder"
+require "active_record/relation/predicate_builder/array_handler"
+
+module ActiveRecordExtended
+  module ArrayHandlerDecorator
+    def call(attribute, value)
+      cache = ActiveRecord::Base.connection.schema_cache
+      if cache.data_source_exists?(attribute.relation.name)
+        column = cache.columns(attribute.relation.name).detect { |col| col.name.to_s == attribute.name.to_s }
+        return attribute.eq(value) if column.try(:array)
+      end
+
+      super(attribute, value)
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder::ArrayHandler.prepend(ActiveRecordExtended::ArrayHandlerDecorator)

data/lib/active_record_extended/query_methods/any_of.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module AnyOf
+      def any_of(*queries)
+        queries = hash_map_queries(queries)
+        build_query(queries) do |arel_query, binds|
+          if binds.any?
+            @scope.where(unprepared_query(arel_query.to_sql), *binds)
+          else
+            @scope.where(arel_query)
+          end
+        end
+      end
+
+      def none_of(*queries)
+        queries = hash_map_queries(queries)
+        build_query(queries) do |arel_query, binds|
+          if binds.any?
+            @scope.where.not(unprepared_query(arel_query.to_sql), *binds)
+          else
+            @scope.where.not(arel_query)
+          end
+        end
+      end
+
+      private
+
+      def hash_map_queries(queries)
+        if queries.size == 1 && queries.first.is_a?(Hash)
+          queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+        else
+          queries
+        end
+      end
+
+      def build_query(queries)
+        query_map = construct_query_mappings(queries)
+        query     = yield(query_map[:arel_query], query_map[:binds])
+        query
+          .joins(query_map[:joins].to_a)
+          .includes(query_map[:includes].to_a)
+          .references(query_map[:references].to_a)
+      end
+
+      def construct_query_mappings(queries) # rubocop:disable Metrics/AbcSize
+        { joins: Set.new, references: Set.new, includes: Set.new, arel_query: nil, binds: [] }.tap do |query_map|
+          query_map[:arel_query] = queries.map do |raw_query|
+            query = generate_where_clause(raw_query)
+            query_map[:joins]      << translate_reference(query.joins_values)      if query.joins_values.any?
+            query_map[:includes]   << translate_reference(query.includes_values)   if query.includes_values.any?
+            query_map[:references] << translate_reference(query.references_values) if query.references_values.any?
+            query_map[:binds] += bind_attributes(query)
+            query.arel.constraints.reduce(:and)
+          end.reduce(:or)
+        end
+      end
+
+      # Rails 5.1 fix
+      # In Rails 5.2 the arel table maintains attribute binds
+      def bind_attributes(query)
+        return [] unless query.respond_to?(:bound_attributes)
+
+        query.bound_attributes.map(&:value)
+      end
+
+      # Rails 5.1 fix
+      def unprepared_query(query)
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/=\ \$\d+/, "= ?") || match
+        end
+      end
+
+      def translate_reference(reference)
+        reference.map { |ref| ref.try(:to_sql) || ref }.compact
+      end
+
+      def generate_where_clause(query)
+        case query
+        when String, Hash
+          @scope.unscoped.where(query)
+        when Array
+          @scope.unscoped.where(*query)
+        else
+          query
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::QueryMethods::WhereChain.prepend(ActiveRecordExtended::QueryMethods::AnyOf)