active_record_extended 1.1.0 → 1.2.0

data/lib/active_record_extended/version.rb

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

data/spec/query_methods/any_of_spec.rb

@@ -3,65 +3,65 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Any / None of Methods" do
-  let!(:one)       { Person.create!(personal_id: 1) }
-  let!(:two)       { Person.create!(personal_id: 2) }
-  let!(:three)     { Person.create!(personal_id: 3) }
+  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!(person_id: one.id) }
-  let!(:tag_two)   { Tag.create!(person_id: two.id) }
-  let!(:tag_three) { Tag.create!(person_id: three.id) }
+  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 = Person.where.any_of({ personal_id: 1 }, { personal_id: 2 })
+      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 = Person.where(personal_id: 1)
-      personal_two = Person.where(personal_id: 2)
-      query = Person.where.any_of(personal_one, personal_two)
+      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 = Person.where(personal_id: 1)
+      personal_one = User.where(personal_id: 1)
 
-      query = Person.where.any_of(personal_one, "personal_id > 2")
+      query = User.where.any_of(personal_one, "personal_id > 2")
       expect(query).to include(one, three)
       expect(query).to_not include(two)
 
-      query = Person.where.any_of(["personal_id >= ?", 2])
+      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
-        person_one_tag = Tag.create!(person_id: one.id)
-        person_two_tag = Tag.create!(person_id: two.id)
-        query          = Tag.where.any_of(one.hm_tags, two.hm_tags)
+        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, person_one_tag, person_two_tag)
+        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
-        person_one_tag = Tag.where(people: { id: one.id }).includes(:person).references(:person)
-        person_two_tag = Tag.where(people: { id: two.id }).joins(:person)
-        query          = Tag.where.any_of(person_one_tag, person_two_tag)
+        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(:person).where.any_of(
-          { people: { personal_id: 1 } },
-          { people: { personal_id: 3 } },
+        query = Tag.joins(:user).where.any_of(
+          { users: { personal_id: 1 } },
+          { users: { personal_id: 3 } },
         )
 
         expect(query).to include(tag_one, tag_three)
@@ -72,55 +72,55 @@ RSpec.describe "Active Record Any / None of Methods" do
 
   describe "where.none_of/1" do
     it "Should return queries that match none of the outlined queries" do
-      query = Person.where.none_of({ personal_id: 1 }, { personal_id: 2 })
+      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 = Person.where(personal_id: 1)
-      personal_two = Person.where(personal_id: 2)
-      query = Person.where.none_of(personal_one, personal_two)
+      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 = Person.where(personal_id: 1)
+      personal_one = User.where(personal_id: 1)
 
-      query = Person.where.none_of(personal_one, "personal_id > 2")
+      query = User.where.none_of(personal_one, "personal_id > 2")
       expect(query).to include(two)
       expect(query).to_not include(one, three)
 
-      query = Person.where.none_of(["personal_id >= ?", 2])
+      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
-        person_one_tag = Tag.create!(person_id: one.id)
-        person_two_tag = Tag.create!(person_id: two.id)
-        query          = Tag.where.none_of(one.hm_tags, two.hm_tags)
+        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, person_one_tag, person_two_tag)
+        expect(query).to_not include(tag_one, tag_two, user_one_tag, user_two_tag)
       end
 
       it "Finds records that are dynamically joined" do
-        person_one_tag = Tag.where(people: { id: one.id }).includes(:person).references(:person)
-        person_two_tag = Tag.where(people: { id: two.id }).joins(:person)
-        query          = Tag.where.none_of(person_one_tag, person_two_tag)
+        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(:person).where.none_of(
-          { people: { personal_id: 1 } },
-          { people: { personal_id: 3 } },
+        query = Tag.joins(:user).where.none_of(
+          { users: { personal_id: 1 } },
+          { users: { personal_id: 3 } },
         )
 
         expect(query).to include(tag_two)

data/spec/query_methods/array_query_spec.rb

@@ -3,28 +3,28 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Array Query Methods" do
-  let!(:one)   { Person.create!(tags: [1, 2, 3],  personal_id: 33) }
-  let!(:two)   { Person.create!(tags: [3, 1, 5],  personal_id: 88) }
-  let!(:three) { Person.create!(tags: [2, 8, 20], personal_id: 33) }
+  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 = Person.where.overlap(tags: [1])
+      query = User.where.overlap(tags: [1])
       expect(query).to include(one, two)
       expect(query).to_not include(three)
 
-      query = Person.where.overlap(tags: [2, 3])
+      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 = Person.where.contains(tags: [1, 3])
+      query = User.where.contains(tags: [1, 3])
       expect(query).to include(one, two)
       expect(query).to_not include(three)
 
-      query = Person.where.contains(tags: [8, 2])
+      query = User.where.contains(tags: [8, 2])
       expect(query).to include(three)
       expect(query).to_not include(one, two)
     end
@@ -32,31 +32,31 @@ RSpec.describe "Active Record Array Query Methods" do
 
   describe "#any" do
     it "should return any records that match" do
-      query = Person.where.any(tags: 3)
+      query = User.where.any(tags: 3)
       expect(query).to include(one, two)
       expect(query).to_not include(three)
     end
 
     it "allows chaining" do
-      query = Person.where.any(tags: 3).where(personal_id: 33)
+      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)     { Person.create!(tags: [1], personal_id: 1) }
-    let!(:contains_all_two) { Person.create!(tags: [1], personal_id: 2) }
-    let!(:contains_some)    { Person.create!(tags: [1, 2], personal_id: 2) }
+    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 = Person.where.all(tags: 1)
+      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 = Person.where.all(tags: 1).where(personal_id: 1)
+      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

data/spec/query_methods/either_spec.rb

@@ -3,22 +3,22 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Either Methods" do
-  let!(:one)       { Person.create! }
-  let!(:two)       { Person.create! }
-  let!(:three)     { Person.create! }
-  let!(:profile_l) { ProfileL.create!(person_id: one.id, likes: 100) }
-  let!(:profile_r) { ProfileR.create!(person_id: two.id, dislikes: 50) }
+  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 = Person.either_join(:profile_l, :profile_r)
+      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 = Person.either_joins(:profile_l, :profile_r)
+        query = User.either_joins(:profile_l, :profile_r)
         expect(query).to include(one, two)
         expect(query).to_not include(three)
       end
@@ -27,29 +27,29 @@ RSpec.describe "Active Record Either Methods" do
 
   describe ".either_order/2" do
     it "Should not exclude anyone who does not have a relationship" do
-      query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes)
+      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 people based on their likes and dislikes in ascended order" do
-      query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
+    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 people based on their likes and dislikes in descending order" do
-      query = Person.either_order(:desc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
+    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 people based on their likes and dislikes in ascended order" do
-        query = Person.either_orders(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
+      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)

data/spec/query_methods/hash_query_spec.rb

@@ -3,23 +3,23 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Hash Related Query Methods" do
-  let!(:one)   { Person.create!(data: { nickname: "george" }, jsonb_data: { payment: "zip" }) }
-  let!(:two)   { Person.create!(data: { nickname: "dan"    }, jsonb_data: { payment: "zipper" }) }
-  let!(:three) { Person.create!(data: { nickname: "georgey" }) }
+  let!(:one)   { User.create!(data: { nickname: "george" }, jsonb_data: { payment: "zip" }) }
+  let!(:two)   { User.create!(data: { nickname: "dan"    }, jsonb_data: { payment: "zipper" }) }
+  let!(:three) { User.create!(data: { nickname: "georgey" }) }
 
   describe "#contains" do
     context "HStore Column Type" do
       it "returns records that contain hash elements in joined tables" do
-        tag_one = Tag.create!(person_id: one.id)
-        tag_two = Tag.create!(person_id: two.id)
+        tag_one = Tag.create!(user_id: one.id)
+        tag_two = Tag.create!(user_id: two.id)
 
-        query = Tag.joins(:person).where.contains(people: { data: { nickname: "george" } })
+        query = Tag.joins(:user).where.contains(users: { data: { nickname: "george" } })
         expect(query).to include(tag_one)
         expect(query).to_not include(tag_two)
       end
 
       it "returns records that contain hash value" do
-        query = Person.where.contains(data: { nickname: "george" })
+        query = User.where.contains(data: { nickname: "george" })
         expect(query).to include(one)
         expect(query).to_not include(two, three)
       end
@@ -27,16 +27,16 @@ RSpec.describe "Active Record Hash Related Query Methods" do
 
     context "JSONB Column Type" do
       it "returns records that contains a json hashed value" do
-        query = Person.where.contains(jsonb_data: { payment: "zip" })
+        query = User.where.contains(jsonb_data: { payment: "zip" })
         expect(query).to include(one)
         expect(query).to_not include(two, three)
       end
 
       it "returns records that contain jsonb elements in joined tables" do
-        tag_one = Tag.create!(person_id: one.id)
-        tag_two = Tag.create!(person_id: two.id)
+        tag_one = Tag.create!(user_id: one.id)
+        tag_two = Tag.create!(user_id: two.id)
 
-        query = Tag.joins(:person).where.contains(people: { jsonb_data: { payment: "zip" } })
+        query = Tag.joins(:user).where.contains(users: { jsonb_data: { payment: "zip" } })
         expect(query).to include(tag_one)
         expect(query).to_not include(tag_two)
       end

data/spec/query_methods/inet_query_spec.rb

@@ -3,107 +3,109 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Inet Query Methods" do
+  before { stub_const("User", Namespaced::Record) }
+
   describe "#inet_contained_within" do
-    let!(:local_1)     { Person.create!(ip: "127.0.0.1") }
-    let!(:local_44)    { Person.create!(ip: "127.0.0.44") }
-    let!(:local_99_1)  { Person.create!(ip: "127.0.99.1") }
-    let!(:local_range) { Person.create!(ip: "127.0.0.1/10") }
+    let!(:local_1)     { User.create!(ip: "127.0.0.1") }
+    let!(:local_44)    { User.create!(ip: "127.0.0.44") }
+    let!(:local_99_1)  { User.create!(ip: "127.0.99.1") }
+    let!(:local_range) { User.create!(ip: "127.0.0.1/10") }
 
-    it "Should return people who have an IP within the 127.0.0.1/24 range" do
-      query = Person.where.inet_contained_within(ip: "127.0.0.1/24")
+    it "Should return users who have an IP within the 127.0.0.1/24 range" do
+      query = User.where.inet_contained_within(ip: "127.0.0.1/24")
       expect(query).to include(local_1, local_44)
       expect(query).to_not include(local_99_1, local_range)
     end
 
     it "Should return all users who have an IP within the 127.0.0.1/16 range" do
-      query = Person.where.inet_contained_within(ip: "127.0.0.1/16")
+      query = User.where.inet_contained_within(ip: "127.0.0.1/16")
       expect(query).to include(local_1, local_44, local_99_1)
       expect(query).to_not include(local_range)
     end
   end
 
   describe "inet_contained_within_or_equals" do
-    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { Person.create!(ip: "127.0.0.44/32") }
-    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { User.create!(ip: "127.0.0.44/32") }
+    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
 
     it "Should find records that contain a matching submask" do
-      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.44/32")
+      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.44/32")
       expect(query).to include(local_44)
       expect(query).to_not include(local_1, local_99_1)
     end
 
     it "Should find records that are within range of a given submask" do
-      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.1/16")
+      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.1/16")
       expect(query).to include(local_44, local_99_1)
       expect(query).to_not include(local_1)
 
-      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.1/8")
+      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.1/8")
       expect(query).to include(local_1, local_44, local_99_1)
     end
   end
 
   describe "#inet_contains_or_equals" do
-    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { Person.create!(ip: "127.0.0.44/24") }
-    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { User.create!(ip: "127.0.0.44/24") }
+    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
 
     it "Should find records with submask ranges that contain a given IP" do
-      query = Person.where.inet_contains_or_equals(ip: "127.0.255.255")
+      query = User.where.inet_contains_or_equals(ip: "127.0.255.255")
       expect(query).to include(local_1)
       expect(query).to_not include(local_44, local_99_1)
 
-      query = Person.where.inet_contains_or_equals(ip: "127.0.0.255")
+      query = User.where.inet_contains_or_equals(ip: "127.0.0.255")
       expect(query).to include(local_1, local_44)
       expect(query).to_not include(local_99_1)
     end
 
     it "Finds records when querying with a submasked value" do
-      query = Person.where.inet_contains_or_equals(ip: "127.0.0.1/10")
+      query = User.where.inet_contains_or_equals(ip: "127.0.0.1/10")
       expect(query).to include(local_1)
       expect(query).to_not include(local_44, local_99_1)
 
-      query = Person.where.inet_contains_or_equals(ip: "127.0.0.1/32")
+      query = User.where.inet_contains_or_equals(ip: "127.0.0.1/32")
       expect(query).to include(local_1, local_44)
       expect(query).to_not include(local_99_1)
     end
   end
 
   describe "#inet_contains" do
-    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { Person.create!(ip: "127.0.0.44/24") }
+    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { User.create!(ip: "127.0.0.44/24") }
 
     it "Should find records that the given IP falls within" do
-      query = Person.where.inet_contains(ip: "127.0.0.1")
+      query = User.where.inet_contains(ip: "127.0.0.1")
       expect(query).to include(local_1, local_44)
     end
 
     it "Should not find records when querying with a submasked value" do
-      query = Person.where.inet_contains(ip: "127.0.0.0/8")
+      query = User.where.inet_contains(ip: "127.0.0.0/8")
       expect(query).to be_empty
     end
   end
 
   describe "#inet_contains_or_is_contained_within" do
-    let!(:local_1)    { Person.create!(ip: "127.0.0.1/24") }
-    let!(:local_44)   { Person.create!(ip: "127.0.22.44/8") }
-    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+    let!(:local_1)    { User.create!(ip: "127.0.0.1/24") }
+    let!(:local_44)   { User.create!(ip: "127.0.22.44/8") }
+    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
 
     it "should find records where the records contain the given IP" do
-      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.255.80")
+      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.255.80")
       expect(query).to include(local_44)
       expect(query).to_not include(local_1, local_99_1)
 
-      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80")
+      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80")
       expect(query).to include(local_1, local_44)
       expect(query).to_not include(local_99_1)
     end
 
     it "Should find records that the where query contains a valid range" do
-      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8")
+      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8")
       expect(query).to include(local_1, local_44, local_99_1)
 
-      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/16")
+      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/16")
       expect(query).to include(local_1, local_44, local_99_1)
     end
   end