active_record_extended_telescope 2.0.1

data/lib/active_record_extended/version.rb

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

data/lib/active_record_extended_telescope.rb

@@ -0,0 +1,4 @@
+require_relative "./active_record_extended"
+module ActiveRecordExtendedTelescope
+  VERSION = "2.0.1"
+end

data/spec/active_record_extended_spec.rb

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,131 @@
+# 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

@@ -0,0 +1,64 @@
+# 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

@@ -0,0 +1,59 @@
+# 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
+  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

data/spec/query_methods/hash_query_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Hash Related Query Methods" do
+  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!(user_id: one.id)
+        tag_two = Tag.create!(user_id: two.id)
+
+        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 = User.where.contains(data: { nickname: "george" })
+        expect(query).to include(one)
+        expect(query).to_not include(two, three)
+      end
+    end
+
+    context "JSONB Column Type" do
+      it "returns records that contains a json hashed value" do
+        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!(user_id: one.id)
+        tag_two = Tag.create!(user_id: two.id)
+
+        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
+    end
+  end
+end

data/spec/query_methods/inet_query_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+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)     { 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 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 = 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)    { 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 = 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 = 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 = 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)    { 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 = 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 = 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 = 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 = 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)    { 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 = 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 = 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)    { 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 = 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 = 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 = 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 = 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
+end

data/spec/query_methods/json_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+RSpec.describe "Active Record JSON methods" do
+  let!(:user_one) { User.create! }
+  let!(:user_two) { User.create! }
+
+  describe ".select_row_to_json" do
+    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 = 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 = 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 == 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))
+        end
+      end
+    end
+
+    it "allows for casting results in an aggregate-able Array function" do
+      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
+        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
+      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 = 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" => user_one.id }, { "id" => user_two.id }]))
+      )
+    end
+
+    it "allows for re-aliasing the default 'results' column" do
+      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) { User.select(:id, :number).where(id: user_one.id) }
+
+    it "defaults the column alias if one is not provided" do
+      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" => user_one.id, "number" => user_one.number))
+    end
+
+    it "allows for re-aliasing the default 'results' column" do
+      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 = User.jsonb_build_object(
+        :personal,
+        sub_query.where.not(id: user_one),
+        value: "COALESCE(array_agg(\"personal\"), '{}')",
+        as:    :cool_dudes
+      )
+
+      expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
+    end
+
+    it "will raise a warning if the value doesn't include a double quoted input" do
+      expect do
+        User.jsonb_build_object(
+          :personal,
+          sub_query.where.not(id: user_one),
+          value: "COALESCE(array_agg(personal), '{}')",
+          as:    :cool_dudes
+        )
+      end.to output.to_stderr
+    end
+  end
+
+  describe "Json literal builds" do
+    let(:original_hash)      { { p: 1, b: "three", x: 3.14 } }
+    let(:hash_as_array_objs) { original_hash.to_a.flatten }
+
+    shared_examples_for "literal builds" do
+      let(:method) { raise "You are expected to over ride this!" }
+
+      it "will accept a hash arguments that will return itself" do
+        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 = 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 = 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
+    end
+
+    describe ".json_build_literal" do
+      it_behaves_like "literal builds" do
+        let!(:method) { :json_build_literal }
+      end
+    end
+
+    describe ".jsonb_build_literal" do
+      it_behaves_like "literal builds" do
+        let!(:method) { :jsonb_build_literal }
+      end
+    end
+  end
+end