active_record_extended 1.1.0 → 1.2.0

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,56 +47,56 @@ 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_as_array: true)
       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_as_array: true, 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,
       )
@@ -91,9 +106,9 @@ 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,
         )
@@ -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

data/spec/query_methods/unionize_spec.rb

@@ -3,15 +3,15 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Union Methods" do
-  let!(:person_one)     { Person.create!(number: 8) }
-  let!(:person_two)     { Person.create!(number: 10) }
-  let!(:person_three)   { Person.create!(number: 1) }
-  let!(:person_one_pl)  { ProfileL.create!(person: person_one, likes: 100) }
-  let!(:person_two_pl)  { ProfileL.create!(person: person_two, likes: 200) }
+  let!(:user_one)     { User.create!(number: 8) }
+  let!(:user_two)     { User.create!(number: 10) }
+  let!(:user_three)   { User.create!(number: 1) }
+  let!(:user_one_pl)  { ProfileL.create!(user: user_one, likes: 100) }
+  let!(:user_two_pl)  { ProfileL.create!(user: user_two, likes: 200) }
 
   shared_examples_for "standard set of errors" do
-    let(:person_one_query)  { Person.select(:id).where(id: person_one.id) }
-    let(:person_two_query)  { Person.select(:id, :tags).where(id: person_two.id) }
+    let(:user_one_query)  { User.select(:id).where(id: user_one.id) }
+    let(:user_two_query)  { User.select(:id, :tags).where(id: user_two.id) }
     let(:misaligned_cmd)    { raise("required to override this 'let' statement") }
     let(:lacking_union_cmd) { raise("required to override this 'let' statement") }
 
@@ -30,85 +30,86 @@ RSpec.describe "Active Record Union Methods" do
 
   describe ".union" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union(person_one_query) }
+      let!(:misaligned_cmd)    { User.union(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union(user_one_query) }
     end
 
     it "should return two users that match the where conditions" do
-      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id))
-      expect(query).to match_array([person_one, person_three])
+      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id))
+      expect(query).to match_array([user_one, user_three])
     end
 
     it "should allow joins on union statements" do
-      query = Person.union(Person.where(id: person_one.id), Person.joins(:profile_l).where.not(id: person_one.id))
-      expect(query).to match_array([person_one, person_two])
+      query = User.union(User.where(id: user_one.id), User.joins(:profile_l).where.not(id: user_one.id))
+      expect(query).to match_array([user_one, user_two])
     end
 
     it "should eliminate duplicate results" do
-      expected_ids = Person.pluck(:id)
-      query        = Person.union(Person.select(:id), Person.select(:id))
+      expected_ids = User.pluck(:id)
+      query        = User.union(User.select(:id), User.select(:id))
       expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
     end
   end
 
   describe ".union.all" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.all(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.all(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.all(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.all(user_one_query) }
     end
 
     it "should keep duplicate results from each union statement" do
-      expected_ids = Person.pluck(:id) * 2
-      query        = Person.union.all(Person.select(:id), Person.select(:id))
+      expected_ids = User.pluck(:id) * 2
+      query        = User.union.all(User.select(:id), User.select(:id))
       expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
     end
   end
 
   describe ".union.except" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.except(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.except(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.except(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.except(user_one_query) }
     end
 
     it "should eliminate records that match a given except statement" do
-      query = Person.union.except(Person.select(:id), Person.select(:id).where(id: person_one.id))
-      expect(query).to match_array([person_two, person_three])
+      query = User.union.except(User.select(:id), User.select(:id).where(id: user_one.id))
+      expect(query).to match_array([user_two, user_three])
     end
   end
 
   describe "union.intersect" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.intersect(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.intersect(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.intersect(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.intersect(user_one_query) }
     end
 
     it "should find records with similar attributes" do
-      ProfileL.create!(person: person_three, likes: 120)
+      ProfileL.create!(user: user_three, likes: 120)
 
       query =
-        Person.union.intersect(
-          Person.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
-          Person.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150"),
+        User.union.intersect(
+          User.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
+          User.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150"),
         )
 
-      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([person_one_pl.id]))
-      expect(query.first.likes).to eq(person_one_pl.likes)
+      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([user_one_pl.id]))
+      expect(query.first.likes).to eq(user_one_pl.likes)
     end
   end
 
   describe "union.as" do
     let(:query) do
-      Person.select("happy_people.id")
-            .union(Person.where(id: person_one.id), Person.where(id: person_three.id))
-            .union_as(:happy_people)
+      User
+        .select("happy_users.id")
+        .union(User.where(id: user_one.id), User.where(id: user_three.id))
+        .union_as(:happy_users)
     end
 
-    it "should return two people" do
+    it "should return two users" do
       expect(query.size).to eq(2)
     end
 
-    it "should return two peoples id's" do
-      expect(query.map(&:id)).to match_array([person_one.id, person_three.id])
+    it "should return two userss id's" do
+      expect(query.map(&:id)).to match_array([user_one.id, user_three.id])
     end
 
     it "should alias the tables being union'd but still allow for accessing table methods" do
@@ -120,43 +121,42 @@ RSpec.describe "Active Record Union Methods" do
 
   describe "union.order_union" do
     it "should order the .union commands" do
-      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id)).order_union(id: :desc)
-      expect(query).to eq([person_three, person_one])
+      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id)).order_union(id: :desc)
+      expect(query).to eq([user_three, user_one])
     end
 
     it "should order the .union.all commands" do
       query =
-        Person.union.all(
-          Person.where(id: person_one.id),
-          Person.where(id: person_three.id),
+        User.union.all(
+          User.where(id: user_one.id),
+          User.where(id: user_three.id),
         ).order_union(id: :desc)
 
-      expect(query).to eq([person_three, person_one])
+      expect(query).to eq([user_three, user_one])
     end
 
     it "should order the union.except commands" do
-      query = Person.union.except(Person.order(id: :asc), Person.where(id: person_one.id)).order_union(id: :desc)
-      expect(query).to eq([person_three, person_two])
+      query = User.union.except(User.order(id: :asc), User.where(id: user_one.id)).order_union(id: :desc)
+      expect(query).to eq([user_three, user_two])
     end
 
     it "should order the .union.intersect commands" do
       query =
-        Person.union.intersect(
-          Person.where("id < ?", person_three.id),
-          Person.where("id >= ?", person_one.id),
+        User.union.intersect(
+          User.where("id < ?", user_three.id),
+          User.where("id >= ?", user_one.id),
         ).order_union(id: :desc)
 
-      expect(query).to eq([person_two, person_one])
+      expect(query).to eq([user_two, user_one])
     end
   end
 
   describe "union.reorder_union" do
     it "should replace the ordering with the new parameters" do
-      person_a         = Person.create!(number: 1)
-      person_b         = Person.create!(number: 10)
-      initial_ordering = [person_b, person_a]
-      query            = Person.union(Person.where(id: person_a.id), Person.where(id: person_b.id))
-                               .order_union(id: :desc)
+      user_a           = User.create!(number: 1)
+      user_b           = User.create!(number: 10)
+      initial_ordering = [user_b, user_a]
+      query            = User.union(User.where(id: user_a.id), User.where(id: user_b.id)).order_union(id: :desc)
 
       expect(query).to eq(initial_ordering)
       expect(query.reorder_union(number: :asc)).to eq(initial_ordering.reverse)