active_record_extended 1.1.0 → 2.0.0

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

data/spec/query_methods/json_spec.rb

@@ -1,29 +1,44 @@
 # frozen_string_literal: true
 
 RSpec.describe "Active Record JSON methods" do
-  let!(:person_one) { Person.create! }
-  let!(:person_two) { Person.create! }
+  let!(:user_one) { User.create! }
+  let!(:user_two) { User.create! }
 
   describe ".select_row_to_json" do
-    let!(:tag_one)    { Tag.create!(person: person_one, tag_number: 2) }
-    let!(:tag_two)    { Tag.create!(person: person_two, tag_number: 5) }
-    let(:sub_query)   { Tag.select(:tag_number).where("tags.person_id = people.id") }
+    let!(:tag_one)    { Tag.create!(user: user_one, tag_number: 2) }
+    let!(:tag_two)    { Tag.create!(user: user_two, tag_number: 5) }
+    let(:sub_query)   { Tag.select(:tag_number).where("tags.user_id = users.id") }
 
     it "should nest a json object in the query results" do
-      query = Person.select(:id).select_row_to_json(sub_query, as: :results).where(id: person_one.id)
+      query = User.select(:id).select_row_to_json(sub_query, as: :results).where(id: user_one.id)
       expect(query.size).to eq(1)
       expect(query.take.results).to be_a(Hash).and(match("tag_number" => 2))
     end
 
     # ugh wording here sucks, brain is fried.
     it "accepts a block for appending additional scopes to the middle-top level" do
-      query = Person.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do |scope|
+      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do |scope|
         scope.where("tag_row.tag_number = 5")
       end
 
       expect(query.size).to eq(2)
       query.each do |result|
-        if result.id == person_one.id
+        if result.id == user_one.id
+          expect(result.results).to be_blank
+        else
+          expect(result.results).to be_present.and(match("tag_number" => 5))
+        end
+      end
+    end
+
+    it "accepts a scope-block without arguments" do
+      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do
+        where("tag_row.tag_number = 5")
+      end
+
+      expect(query.size).to eq(2)
+      query.each do |result|
+        if result.id == user_one.id
           expect(result.results).to be_blank
         else
           expect(result.results).to be_present.and(match("tag_number" => 5))
@@ -32,58 +47,58 @@ RSpec.describe "Active Record JSON methods" do
     end
 
     it "allows for casting results in an aggregate-able Array function" do
-      query = Person.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_as_array: true)
+      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_with: :array)
       expect(query.take.results).to be_a(Array).and(be_present)
       expect(query.take.results.first).to be_a(Hash)
     end
 
     it "raises an error if a from clause key is missing" do
       expect do
-        Person.select(:id).select_row_to_json(key: :tag_row, as: :results)
+        User.select(:id).select_row_to_json(key: :tag_row, as: :results)
       end.to raise_error(ArgumentError)
     end
   end
 
   describe ".json_build_object" do
     let(:sub_query) do
-      Person.select_row_to_json(from: Person.select(:id), cast_as_array: true, as: :ids).where(id: person_one.id)
+      User.select_row_to_json(from: User.select(:id), cast_with: :array, as: :ids).where(id: user_one.id)
     end
 
     it "defaults the column alias if one is not provided" do
-      query = Person.json_build_object(:personal, sub_query)
+      query = User.json_build_object(:personal, sub_query)
       expect(query.size).to eq(1)
       expect(query.take.results).to match(
-        "personal" => match("ids" => match_array([{ "id" => person_one.id }, { "id" => person_two.id }])),
+        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }]))
       )
     end
 
     it "allows for re-aliasing the default 'results' column" do
-      query = Person.json_build_object(:personal, sub_query, as: :cool_dudes)
+      query = User.json_build_object(:personal, sub_query, as: :cool_dudes)
       expect(query.take).to respond_to(:cool_dudes)
     end
   end
 
   describe ".jsonb_build_object" do
-    let(:sub_query) { Person.select(:id, :number).where(id: person_one.id) }
+    let(:sub_query) { User.select(:id, :number).where(id: user_one.id) }
 
     it "defaults the column alias if one is not provided" do
-      query = Person.jsonb_build_object(:personal, sub_query)
+      query = User.jsonb_build_object(:personal, sub_query)
       expect(query.size).to eq(1)
       expect(query.take.results).to be_a(Hash).and(be_present)
-      expect(query.take.results).to match("personal" => match("id" => person_one.id, "number" => person_one.number))
+      expect(query.take.results).to match("personal" => match("id" => user_one.id, "number" => user_one.number))
     end
 
     it "allows for re-aliasing the default 'results' column" do
-      query = Person.jsonb_build_object(:personal, sub_query, as: :cool_dudes)
+      query = User.jsonb_build_object(:personal, sub_query, as: :cool_dudes)
       expect(query.take).to respond_to(:cool_dudes)
     end
 
     it "allows for custom value statement" do
-      query = Person.jsonb_build_object(
+      query = User.jsonb_build_object(
         :personal,
-        sub_query.where.not(id: person_one),
+        sub_query.where.not(id: user_one),
         value: "COALESCE(array_agg(\"personal\"), '{}')",
-        as:    :cool_dudes,
+        as:    :cool_dudes
       )
 
       expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
@@ -91,11 +106,11 @@ RSpec.describe "Active Record JSON methods" do
 
     it "will raise a warning if the value doesn't include a double quoted input" do
       expect do
-        Person.jsonb_build_object(
+        User.jsonb_build_object(
           :personal,
-          sub_query.where.not(id: person_one),
+          sub_query.where.not(id: user_one),
           value: "COALESCE(array_agg(personal), '{}')",
-          as:    :cool_dudes,
+          as:    :cool_dudes
         )
       end.to output.to_stderr
     end
@@ -109,19 +124,19 @@ RSpec.describe "Active Record JSON methods" do
       let(:method) { raise "You are expected to over ride this!" }
 
       it "will accept a hash arguments that will return itself" do
-        query = Person.send(method.to_sym, original_hash)
+        query = User.send(method.to_sym, original_hash)
         expect(query.take.results).to be_a(Hash).and(be_present)
         expect(query.take.results).to match(original_hash.stringify_keys)
       end
 
       it "will accept a standard array of key values" do
-        query = Person.send(method.to_sym, hash_as_array_objs)
+        query = User.send(method.to_sym, hash_as_array_objs)
         expect(query.take.results).to be_a(Hash).and(be_present)
         expect(query.take.results).to match(original_hash.stringify_keys)
       end
 
       it "will accept a splatted array of key-values" do
-        query = Person.send(method.to_sym, *hash_as_array_objs)
+        query = User.send(method.to_sym, *hash_as_array_objs)
         expect(query.take.results).to be_a(Hash).and(be_present)
         expect(query.take.results).to match(original_hash.stringify_keys)
       end

data/spec/query_methods/select_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Select Methods" do
+  let(:numbers) { (1..10).to_a }
+
+  describe ".foster_select" do
+    context "with an aggregate function" do
+      context "agg_array" do
+        let(:number_set) { numbers.sample(6).to_enum }
+        let!(:users) { Array.new(6) { User.create!(number: number_set.next, ip: "127.0.0.1") } }
+        let!(:tags) { users.flat_map { |u| Array.new(2) { Tag.create!(user: u, tag_number: numbers.sample) } } }
+
+        it "can accept a subquery" do
+          subquery = Tag.select("count(*)").joins("JOIN users u ON tags.user_id = u.id").where("u.ip = users.ip")
+          query    =
+            User.foster_select(tag_count: [subquery, { cast_with: :array_agg, distinct: true }])
+                .joins(:hm_tags)
+                .group(:ip)
+                .take
+
+          expect(query.tag_count).to eq([tags.size])
+        end
+
+        it "can be ordered" do
+          query = User.foster_select(
+            asc_ordered_numbers:  [:number, { cast_with: :array_agg, order_by: { number: :asc } }],
+            desc_ordered_numbers: [:number, { cast_with: :array_agg, order_by: { number: :desc } }]
+          ).take
+
+          expect(query.asc_ordered_numbers).to eq(number_set.to_a.sort)
+          expect(query.desc_ordered_numbers).to eq(number_set.to_a.sort.reverse)
+        end
+
+        it "works with joined relations" do
+          query =
+            User.foster_select(tag_numbers: { tags: :tag_number, cast_with: :array_agg })
+                .joins(:hm_tags)
+                .take
+          expect(query.tag_numbers).to match_array(Tag.pluck(:tag_number))
+        end
+      end
+
+      context "bool_[and|or]" do
+        let!(:users) do
+          enum_numbers = numbers.to_enum
+          Array.new(6) { User.create!(number: enum_numbers.next, ip: "127.0.0.1") }
+        end
+
+        it "will return a boolean expression" do
+          query = User.foster_select(
+            truthly_expr:     ["users.number > 0",   { cast_with: :bool_and }],
+            falsey_expr:      ["users.number > 200", { cast_with: :bool_and }],
+            other_true_expr:  ["users.number > 4",   { cast_with: :bool_or }],
+            other_false_expr: ["users.number > 6",   { cast_with: :bool_or }]
+          ).take
+
+          expect(query.truthly_expr).to be_truthy
+          expect(query.falsey_expr).to be_falsey
+          expect(query.other_true_expr).to be_truthy
+          expect(query.other_false_expr).to be_falsey
+        end
+      end
+
+      context "with math functions: sum|max|min|avg" do
+        before { 2.times.flat_map { |i| Array.new(2) { |j| User.create!(number: (i + 1) * j + 3) } } }
+
+        it "max" do
+          query = User.foster_select(max_num: [:number, { cast_with: :max }]).take
+          expect(query.max_num).to eq(5)
+        end
+
+        it "min" do
+          query = User.foster_select(max_num: [:number, { cast_with: :min }]).take
+          expect(query.max_num).to eq(3)
+        end
+
+        it "sum" do
+          query = User.foster_select(
+            num_sum:      [:number, { cast_with: :sum }],
+            distinct_sum: [:number, { cast_with: :sum, distinct: true }]
+          ).take
+
+          expect(query.num_sum).to eq(15)
+          expect(query.distinct_sum).to eq(12)
+        end
+
+        it "avg" do
+          query = User.foster_select(
+            num_avg:      [:number, { cast_with: :avg }],
+            distinct_avg: [:number, { cast_with: :avg, distinct: true }]
+          ).take
+
+          expect(query.num_avg).to eq(3.75)
+          expect(query.distinct_avg).to eq(4.0)
+        end
+      end
+    end
+
+    context "with standard select items" do
+      let!(:user) { User.create!(name: "Test") }
+
+      it "works with no alias" do
+        query = User.foster_select(:name).take
+        expect(query.name).to eq(user.name)
+      end
+
+      it "works with alias" do
+        query = User.foster_select(my_name: :name).take
+        expect(query.my_name).to eq(user.name)
+      end
+    end
+  end
+end