active_record_extended 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4101b3fcb4c69dd81a2d790731978748e6143c2ec2bdba1145e1b543d47966dc
-  data.tar.gz: 21047b0dc2d05f2a764a00a985e592117ef6908dcb5c77b7cee56e86c239b267
+  metadata.gz: 3f8d2f193f9e0e50c6e83e462c1df30a9b948779ebf3e00f64c735f165bdb5f3
+  data.tar.gz: 0ee6d70e9b6714c6ab3431da2df340ff63fca28bc0ceb6fc2c3e45593b9e87e0
 SHA512:
-  metadata.gz: 32a01ef2194b62d6936afef5b7d5ba4e851ebc9a8b7ef78d471e140a52b7615a91270ae28a8c95b0e6f0a34fad386ad5857ba8c3e305dc99620dd0b3c5ff69ff
-  data.tar.gz: 9d252ca9f8d9f9fc565ab96cd0de21e7ccac35de4b9631d9229ff78fbb0404e2b18957e8988f8e30ec21c1ab707ce8a6d84619bb1d784b5e0a754a722138eed0
+  metadata.gz: 282ad3881cb0ed581dbe1aa0dd605dbc33cb7182d560a015f2de5a57a1ca49f3db8e5b5515229d527130e6f7f35321105bface3669edb15340b1bb76e333d7c4
+  data.tar.gz: c7b38bca14c8ed07faba4f2996a18c455b85dec7def64e184c1a8dc9defa86681c1650b9097112264248c66580685f2f90825e9cf04d981e48b47333e091bde2

data/README.md

@@ -52,12 +52,12 @@ Active Record Extended is essentially providing users with the other half of Pos
 ## Compatibility
 
 This package is designed align and work with any officially supported Ruby and Rails versions.
- - Minimum Ruby Version: 2.4.x **(EOL warning!)**
- - Minimum Rails Version: 5.1.x **(EOL warning!)**
- - Minimum Postgres Version: 9.6.x **(EOL warning!)**
+ - Minimum Ruby Version: 2.5.x **(EOL warning!)**
+ - Minimum Rails Version: 5.2.x **(EOL warning!)**
+ - Minimum Postgres Version: 10.x **(EOL warning!)**
  - Latest Ruby supported: 3.0.x
  - Latest Rails supported: 7.0.x
- - Postgres: 9.6-current(13) (probably works with most older versions to a certain point)
+ - Postgres: 10-current(14) (probably works with most older versions to a certain point)
 
 ## Installation
 

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -13,15 +13,27 @@ module ActiveRecordExtended
     end
 
     module Merger
-      def normal_values
-        super + [:union, :define_window]
-      end
-
       def merge
         merge_ctes!
+        merge_union!
+        merge_windows!
         super
       end
 
+      def merge_union!
+        return if other.unionize_storage.empty?
+
+        relation.union_values          += other.union_values
+        relation.union_operations      += other.union_operations
+        relation.union_ordering_values += other.union_ordering_values
+      end
+
+      def merge_windows!
+        return unless other.window_values?
+
+        relation.window_values |= other.window_values
+      end
+
       def merge_ctes!
         return unless other.with_values?
 

data/lib/active_record_extended/active_record.rb

@@ -5,6 +5,11 @@ require "active_record/relation"
 require "active_record/relation/merger"
 require "active_record/relation/query_methods"
 
+module ActiveRecordExtended
+  # TODO: Deprecate <= AR 6.0 methods & routines
+  AR_VERSION_GTE_6_1 = Gem::Requirement.new(">= 6.1").satisfied_by?(ActiveRecord.gem_version)
+end
+
 require "active_record_extended/predicate_builder/array_handler_decorator"
 
 require "active_record_extended/active_record/relation_patch"
@@ -17,9 +22,4 @@ 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
+require "active_record_extended/patch/5_2/where_clause"

data/lib/active_record_extended/arel/nodes.rb

@@ -5,7 +5,7 @@ require "arel/nodes/function"
 
 module Arel
   module Nodes
-    if Gem::Requirement.new("< 6.1").satisfied_by?(ActiveRecord.gem_version)
+    unless ActiveRecordExtended::AR_VERSION_GTE_6_1
       ["Contains", "Overlaps"].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
 

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

@@ -9,21 +9,25 @@ module ActiveRecordExtended
 
       # rubocop:disable Naming/MethodName
 
-      def visit_Arel_Nodes_Overlaps(object, collector)
-        infix_value object, collector, " && "
+      unless ActiveRecordExtended::AR_VERSION_GTE_6_1
+        def visit_Arel_Nodes_Overlaps(object, collector)
+          infix_value object, collector, " && "
+        end
       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
+      unless ActiveRecordExtended::AR_VERSION_GTE_6_1
+        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)
+          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
       end
 

data/lib/active_record_extended/query_methods/any_of.rb

@@ -29,7 +29,7 @@ module ActiveRecordExtended
 
       def hash_map_queries(queries)
         if queries.size == 1 && queries.first.is_a?(Hash)
-          queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+          queries.first.each_pair.map { |attr, predicate| { attr => predicate } }
         else
           queries
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -26,7 +26,7 @@ module ActiveRecordExtended
       private
 
       def xor_field_sql(options)
-        XOR_FIELD_SQL % Hash[xor_field_options(options)]
+        XOR_FIELD_SQL % xor_field_options(options).to_h
       end
 
       def sort_order_sql(dir)
@@ -35,7 +35,7 @@ module ActiveRecordExtended
 
       def xor_field_options(options)
         str_args = options.flatten.take(XOR_FIELD_KEYS.size).map(&:to_s)
-        Hash[XOR_FIELD_KEYS.zip(str_args)]
+        XOR_FIELD_KEYS.zip(str_args).to_h
       end
 
       def map_columns_to_tables(associations_and_columns)

data/lib/active_record_extended/query_methods/unionize.rb

@@ -107,7 +107,7 @@ module ActiveRecordExtended
       end
 
       def union(opts = :chain, *args)
-        return UnionChain.new(spawn) if :chain == opts
+        return UnionChain.new(spawn) if opts == :chain
 
         opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
       end
@@ -121,7 +121,7 @@ module ActiveRecordExtended
       def union!(opts = :chain, *args, chain_method: :union)
         union_chain    = UnionChain.new(self)
         chain_method ||= :union
-        return union_chain if :chain == opts
+        return union_chain if opts == :chain
 
         union_chain.public_send(chain_method, *([opts] + args))
       end
@@ -178,7 +178,7 @@ module ActiveRecordExtended
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
         union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
-          next resolve_relation_node(relation_node) if union_node.nil?
+          next resolve_relation_node(relation_node) if union_node.nil? # rubocop:disable Lint/UnmodifiedReduceAccumulator
 
           operation = union_operations.fetch(index - 1, :union)
           left      = union_node

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -2,8 +2,6 @@
 
 module ActiveRecordExtended
   module WhereChain
-    AR_VERSION_AT_LEAST_6_1 = ActiveRecord.version >= Gem::Version.new('6.1')
-
     # Finds Records that have an array column that contain any a set of values
     # User.where.overlap(tags: [1,2])
     #   # SELECT * FROM users WHERE tags && {1,2}
@@ -47,6 +45,10 @@ module ActiveRecordExtended
     #   # SELECT tags.* FROM tags INNER JOIN user on user.id = tags.user_id WHERE user.data @> { nickname: 'chainer' }
     #
     def contains(opts, *rest)
+      if ActiveRecordExtended::AR_VERSION_GTE_6_1
+        return substitute_comparisons(opts, rest, Arel::Nodes::Contains, "contains")
+      end
+
       build_where_chain(opts, rest) do |arel|
         case arel
         when Arel::Nodes::In, Arel::Nodes::Equality
@@ -108,7 +110,7 @@ module ActiveRecordExtended
     end
 
     def build_where_clause_for(scope, opts, rest)
-      if AR_VERSION_AT_LEAST_6_1
+      if ActiveRecordExtended::AR_VERSION_GTE_6_1
         scope.send(:build_where_clause, opts, rest)
       else
         scope.send(:where_clause_factory).build(opts, rest)

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -113,14 +113,14 @@ module ActiveRecordExtended
 
       # @param [Hash, WithCTE] opts
       def with(opts = :chain, *rest)
-        return WithChain.new(spawn) if :chain == opts
+        return WithChain.new(spawn) if opts == :chain
 
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
       # @param [Hash, WithCTE] opts
       def with!(opts = :chain, *_rest)
-        return WithChain.new(self) if :chain == opts
+        return WithChain.new(self) if opts == :chain
 
         tap do |scope|
           scope.cte ||= WithCTE.new(self)

data/lib/active_record_extended/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_extended
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - George Protacio-Karaszi
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-14 00:00:00.000000000 Z
+date: 2022-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.0
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.0
@@ -155,7 +155,6 @@ files:
 - lib/active_record_extended/arel/predications.rb
 - lib/active_record_extended/arel/sql_literal.rb
 - lib/active_record_extended/arel/visitors/postgresql_decorator.rb
-- lib/active_record_extended/patch/5_1/where_clause.rb
 - lib/active_record_extended/patch/5_2/where_clause.rb
 - lib/active_record_extended/predicate_builder/array_handler_decorator.rb
 - lib/active_record_extended/query_methods/any_of.rb
@@ -170,34 +169,11 @@ files:
 - lib/active_record_extended/utilities/order_by.rb
 - lib/active_record_extended/utilities/support.rb
 - lib/active_record_extended/version.rb
-- spec/active_record_extended_spec.rb
-- spec/query_methods/any_of_spec.rb
-- spec/query_methods/array_query_spec.rb
-- spec/query_methods/either_spec.rb
-- spec/query_methods/hash_query_spec.rb
-- spec/query_methods/inet_query_spec.rb
-- spec/query_methods/json_spec.rb
-- spec/query_methods/select_spec.rb
-- spec/query_methods/unionize_spec.rb
-- spec/query_methods/window_spec.rb
-- spec/query_methods/with_cte_spec.rb
-- spec/spec_helper.rb
-- spec/sql_inspections/any_of_sql_spec.rb
-- spec/sql_inspections/arel/aggregate_function_name_spec.rb
-- spec/sql_inspections/arel/array_spec.rb
-- spec/sql_inspections/arel/inet_spec.rb
-- spec/sql_inspections/contains_sql_queries_spec.rb
-- spec/sql_inspections/either_sql_spec.rb
-- spec/sql_inspections/json_sql_spec.rb
-- spec/sql_inspections/unionize_sql_spec.rb
-- spec/sql_inspections/window_sql_spec.rb
-- spec/sql_inspections/with_cte_sql_spec.rb
-- spec/support/database_cleaner.rb
-- spec/support/models.rb
 homepage: https://github.com/georgekaraszi/ActiveRecordExtended
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -206,7 +182,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -217,28 +193,4 @@ rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Adds extended functionality to Activerecord Postgres implementation
-test_files:
-- spec/active_record_extended_spec.rb
-- spec/query_methods/any_of_spec.rb
-- spec/query_methods/array_query_spec.rb
-- spec/query_methods/either_spec.rb
-- spec/query_methods/hash_query_spec.rb
-- spec/query_methods/inet_query_spec.rb
-- spec/query_methods/json_spec.rb
-- spec/query_methods/select_spec.rb
-- spec/query_methods/unionize_spec.rb
-- spec/query_methods/window_spec.rb
-- spec/query_methods/with_cte_spec.rb
-- spec/spec_helper.rb
-- spec/sql_inspections/any_of_sql_spec.rb
-- spec/sql_inspections/arel/aggregate_function_name_spec.rb
-- spec/sql_inspections/arel/array_spec.rb
-- spec/sql_inspections/arel/inet_spec.rb
-- spec/sql_inspections/contains_sql_queries_spec.rb
-- spec/sql_inspections/either_sql_spec.rb
-- spec/sql_inspections/json_sql_spec.rb
-- spec/sql_inspections/unionize_sql_spec.rb
-- spec/sql_inspections/window_sql_spec.rb
-- spec/sql_inspections/with_cte_sql_spec.rb
-- spec/support/database_cleaner.rb
-- spec/support/models.rb
+test_files: []

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

@@ -1,11 +0,0 @@
-# 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/spec/active_record_extended_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe ActiveRecordExtended do
-  it "has a version number" do
-    expect(ActiveRecordExtended::VERSION).not_to be nil
-  end
-end

data/spec/query_methods/any_of_spec.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Any / None of Methods" do
-  let!(:one)       { User.create!(personal_id: 1) }
-  let!(:two)       { User.create!(personal_id: 2) }
-  let!(:three)     { User.create!(personal_id: 3) }
-
-  let!(:tag_one)   { Tag.create!(user_id: one.id) }
-  let!(:tag_two)   { Tag.create!(user_id: two.id) }
-  let!(:tag_three) { Tag.create!(user_id: three.id) }
-
-  describe "where.any_of/1" do
-    it "Should return queries that match any of the outlined queries" do
-      query = User.where.any_of({ personal_id: 1 }, { personal_id: 2 })
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-    end
-
-    it "Should accept where query predicates" do
-      personal_one = User.where(personal_id: 1)
-      personal_two = User.where(personal_id: 2)
-      query = User.where.any_of(personal_one, personal_two)
-
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-    end
-
-    it "Should accept query strings" do
-      personal_one = User.where(personal_id: 1)
-
-      query = User.where.any_of(personal_one, "personal_id > 2")
-      expect(query).to include(one, three)
-      expect(query).to_not include(two)
-
-      query = User.where.any_of(["personal_id >= ?", 2])
-      expect(query).to include(two, three)
-      expect(query).to_not include(one)
-    end
-
-    context "Relationship queries" do
-      it "Finds records that are queried from two or more has_many associations" do
-        user_one_tag = Tag.create!(user_id: one.id)
-        user_two_tag = Tag.create!(user_id: two.id)
-        query = Tag.where.any_of(one.hm_tags, two.hm_tags)
-
-        expect(query).to include(tag_one, tag_two, user_one_tag, user_two_tag)
-        expect(query).to_not include(tag_three)
-      end
-
-      it "Finds records that are dynamically joined" do
-        user_one_tag = Tag.where(users: { id: one.id }).includes(:user).references(:user)
-        user_two_tag = Tag.where(users: { id: two.id }).joins(:user)
-        query = Tag.where.any_of(user_one_tag, user_two_tag)
-
-        expect(query).to include(tag_one, tag_two)
-        expect(query).to_not include(tag_three)
-      end
-
-      it "Return matched records of a joined table on the parent level" do
-        query = Tag.joins(:user).where.any_of(
-          { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } }
-        )
-
-        expect(query).to include(tag_one, tag_three)
-        expect(query).to_not include(tag_two)
-      end
-    end
-  end
-
-  describe "where.none_of/1" do
-    it "Should return queries that match none of the outlined queries" do
-      query = User.where.none_of({ personal_id: 1 }, { personal_id: 2 })
-      expect(query).to include(three)
-      expect(query).to_not include(one, two)
-    end
-
-    it "Should accept where query predicates" do
-      personal_one = User.where(personal_id: 1)
-      personal_two = User.where(personal_id: 2)
-      query = User.where.none_of(personal_one, personal_two)
-
-      expect(query).to include(three)
-      expect(query).to_not include(one, two)
-    end
-
-    it "Should accept query strings" do
-      personal_one = User.where(personal_id: 1)
-
-      query = User.where.none_of(personal_one, "personal_id > 2")
-      expect(query).to include(two)
-      expect(query).to_not include(one, three)
-
-      query = User.where.none_of(["personal_id >= ?", 2])
-      expect(query).to include(one)
-      expect(query).to_not include(two, three)
-    end
-
-    context "Relationship queries" do
-      it "Finds records that are queried from two or more has_many associations" do
-        user_one_tag = Tag.create!(user_id: one.id)
-        user_two_tag = Tag.create!(user_id: two.id)
-        query = Tag.where.none_of(one.hm_tags, two.hm_tags)
-
-        expect(query).to include(tag_three)
-        expect(query).to_not include(tag_one, tag_two, user_one_tag, user_two_tag)
-      end
-
-      it "Finds records that are dynamically joined" do
-        user_one_tag = Tag.where(users: { id: one.id }).includes(:user).references(:user)
-        user_two_tag = Tag.where(users: { id: two.id }).joins(:user)
-        query = Tag.where.none_of(user_one_tag, user_two_tag)
-
-        expect(query).to include(tag_three)
-        expect(query).to_not include(tag_one, tag_two)
-      end
-
-      it "Return matched records of a joined table on the parent level" do
-        query = Tag.joins(:user).where.none_of(
-          { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } }
-        )
-
-        expect(query).to include(tag_two)
-        expect(query).to_not include(tag_one, tag_three)
-      end
-    end
-  end
-end

data/spec/query_methods/array_query_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Array Query Methods" do
-  let!(:one)   { User.create!(tags: [1, 2, 3],  personal_id: 33) }
-  let!(:two)   { User.create!(tags: [3, 1, 5],  personal_id: 88) }
-  let!(:three) { User.create!(tags: [2, 8, 20], personal_id: 33) }
-
-  describe "#overlap" do
-    it "Should return matched records" do
-      query = User.where.overlap(tags: [1])
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-
-      query = User.where.overlap(tags: [2, 3])
-      expect(query).to include(one, two, three)
-    end
-  end
-
-  describe "#contains" do
-    it "returns records that contain elements in an array" do
-      query = User.where.contains(tags: [1, 3])
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-
-      query = User.where.contains(tags: [8, 2])
-      expect(query).to include(three)
-      expect(query).to_not include(one, two)
-    end
-  end
-
-  describe "#any" do
-    it "should return any records that match" do
-      query = User.where.any(tags: 3)
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-    end
-
-    it "allows chaining" do
-      query = User.where.any(tags: 3).where(personal_id: 33)
-      expect(query).to include(one)
-      expect(query).to_not include(two, three)
-    end
-  end
-
-  describe "#all" do
-    let!(:contains_all)     { User.create!(tags: [1], personal_id: 1) }
-    let!(:contains_all_two) { User.create!(tags: [1], personal_id: 2) }
-    let!(:contains_some)    { User.create!(tags: [1, 2], personal_id: 2) }
-
-    it "should return any records that match" do
-      query = User.where.all(tags: 1)
-      expect(query).to include(contains_all, contains_all_two)
-      expect(query).to_not include(contains_some)
-    end
-
-    it "allows chaining" do
-      query = User.where.all(tags: 1).where(personal_id: 1)
-      expect(query).to include(contains_all)
-      expect(query).to_not include(contains_all_two, contains_some)
-    end
-  end
-end

data/spec/query_methods/either_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Either Methods" do
-  let!(:one)       { User.create! }
-  let!(:two)       { User.create! }
-  let!(:three)     { User.create! }
-  let!(:profile_l) { ProfileL.create!(user_id: one.id, likes: 100) }
-  let!(:profile_r) { ProfileR.create!(user_id: two.id, dislikes: 50) }
-
-  describe ".either_join/2" do
-    it "Should only only return records that belong to profile L or profile R" do
-      query = User.either_join(:profile_l, :profile_r)
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-    end
-
-    context "Alias .either_joins/2" do
-      it "Should only only return records that belong to profile L or profile R" do
-        query = User.either_joins(:profile_l, :profile_r)
-        expect(query).to include(one, two)
-        expect(query).to_not include(three)
-      end
-    end
-
-    context "Through association .either_joins/2" do
-      let!(:four) { User.create! }
-      let!(:group) { Group.create!(users: [four]) }
-
-      it "Should only only return records that belong to profile L or has group" do
-        query = User.either_joins(:profile_l, :groups)
-        expect(query).to include(one, four)
-        expect(query).to_not include(three, two)
-      end
-    end
-  end
-
-  describe ".either_order/2" do
-    it "Should not exclude anyone who does not have a relationship" do
-      query = User.either_order(:asc, profile_l: :likes, profile_r: :dislikes)
-      expect(query.count).to eq(3)
-      expect(query[0]).to eq(two)
-      expect(query[1]).to eq(one)
-      expect(query[2]).to eq(three)
-    end
-
-    it "Should order users based on their likes and dislikes in ascended order" do
-      query = User.either_order(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query.count).to eq(2)
-      expect(query.first).to eq(two)
-      expect(query.last).to eq(one)
-    end
-
-    it "Should order users based on their likes and dislikes in descending order" do
-      query = User.either_order(:desc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query.first).to eq(one)
-      expect(query.last).to eq(two)
-    end
-
-    context "Alias .either_order/2" do
-      it "Should order users based on their likes and dislikes in ascended order" do
-        query = User.either_orders(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-        expect(query.count).to eq(2)
-        expect(query.first).to eq(two)
-        expect(query.last).to eq(one)
-      end
-    end
-  end
-end