active_record_extended 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd022475e7df8677d1211cfefe42f7090eca4a29fe54b96254f9490baaf101f0
-  data.tar.gz: ae8827a88842bcba66d440ed1ffa540349007e124516ad2d2d9e8f64d553f840
+  metadata.gz: 6d852a8ee92e11e7a68b77e9763553d43e965778fdebd063a7d9bce6f94e9094
+  data.tar.gz: 72b31962b0f85f57436e2f364022a1f43edae3d471eff1efcb1b8b7d066b05d1
 SHA512:
-  metadata.gz: 5ff916a3e069accb63c3d98c1f46705ac2191de4c40a7b8f67415e0f752c420f6efd5c6601041b11bcc6cf7ae0bd776a4a2c22d2b89c2239bb9fb68c04ba40ed
-  data.tar.gz: 41b2f1e01aab68f69bc6753066c242475a3ecdd6f8fed68214065c5a55ecef5b9c8d261c6bf3f6d9264f9031775ef5d8571f43ca48561a36432c273672d11c9a
+  metadata.gz: 1170988a8f118aaa08a7257177427748c584aebe340310aba9afe93ec4878dc237efd8098c071029ef5df200d30f1349b02f6f0e1a3862b8bc5d14f20d0c00c9
+  data.tar.gz: cc6b9102753928f300986767cf4c9e7466ae8758e55cabc54e0ef967a40c95c981199f4319bde271155868f02bc6fec4b77f3889585354ba56023ca3bf7c271d

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# 0.2.0 - May 6th 2018
+
+Added ActiveRecord Where Chain Functionality
+- .where.any_of
+- .where.none_of
+
+# 0.1.1 - May 2nd 2018
+
+Added ActiveRecord Where Chain Functionality:
+- .where.overlap
+- .where.contained_within
+- .where.contained_within_or_equals
+- .where.contains_or_equals
+- .where.any/1
+- .where.all/1
+
+Added ActiveRecord Base Extentions
+- .either_order/2
+- .either_join/2
+

data/Gemfile.lock

@@ -29,7 +29,7 @@ GEM
     concurrent-ruby (1.0.5)
     database_cleaner (1.7.0)
     diff-lcs (1.3)
-    dotenv (2.2.2)
+    dotenv (2.4.0)
     i18n (1.0.1)
       concurrent-ruby (~> 1.0)
     method_source (0.9.0)

data/active_record_extended.gemspec

@@ -8,8 +8,8 @@ require "active_record_extended/version"
 Gem::Specification.new do |spec|
   spec.name          = "active_record_extended"
   spec.version       = ActiveRecordExtended::VERSION
-  spec.authors       = ["George Protacio-Karaszi", "Dan McClain"]
-  spec.email         = ["georgekaraszi@gmail.com", "git@danmcclain.net"]
+  spec.authors       = ["George Protacio-Karaszi", "Dan McClain", "Olivier El Mekki"]
+  spec.email         = ["georgekaraszi@gmail.com", "git@danmcclain.net", "olivier@el-mekki.com"]
 
   spec.summary       = "Adds extended functionality to Activerecord Postgres implementation"
   spec.description   = "Adds extended functionality to Activerecord Postgres implementation"

data/lib/active_record_extended/active_record.rb

@@ -5,6 +5,7 @@ require "active_record"
 require "active_record_extended/predicate_builder/array_handler_decorator"
 require "active_record_extended/query_methods/where_chain"
 require "active_record_extended/query_methods/either"
+require "active_record_extended/query_methods/any_of"
 
 if ActiveRecord::VERSION::MAJOR >= 5
   if ActiveRecord::VERSION::MINOR >= 2

data/lib/active_record_extended/query_methods/any_of.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module AnyOf
+      def any_of(*queries)
+        queries = hash_map_queries(queries)
+        build_query(queries) do |arel_query, binds|
+          if binds.any?
+            @scope.where(unprepared_query(arel_query.to_sql), *binds)
+          else
+            @scope.where(arel_query)
+          end
+        end
+      end
+
+      def none_of(*queries)
+        queries = hash_map_queries(queries)
+        build_query(queries) do |arel_query, binds|
+          if binds.any?
+            @scope.where.not(unprepared_query(arel_query.to_sql), *binds)
+          else
+            @scope.where.not(arel_query)
+          end
+        end
+      end
+
+      private
+
+      def hash_map_queries(queries)
+        if queries.count == 1 && queries.first.is_a?(Hash)
+          queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+        else
+          queries
+        end
+      end
+
+      def build_query(queries)
+        query_map = construct_query_mappings(queries)
+        query     = yield(query_map[:arel_query], query_map[:binds])
+        query.joins(query_map[:joins].to_a)
+             .includes(query_map[:includes].to_a)
+             .references(query_map[:references].to_a)
+      end
+
+      def construct_query_mappings(queries) # rubocop:disable Metrics/AbcSize
+        { joins: Set.new, references: Set.new, includes: Set.new, arel_query: nil, binds: [] }.tap do |query_map|
+          query_map[:arel_query] = queries.map do |raw_query|
+            query = generate_where_clause(raw_query)
+            query_map[:joins]      << translate_reference(query.joins_values)      if query.joins_values.any?
+            query_map[:includes]   << translate_reference(query.includes_values)   if query.includes_values.any?
+            query_map[:references] << translate_reference(query.references_values) if query.references_values.any?
+            query_map[:binds] += bind_attributes(query)
+            query.arel.constraints.reduce(:and)
+          end.reduce(:group_or)
+        end
+      end
+
+      # Rails 5.1 fix
+      # In Rails 5.2 the arel table maintains attribute binds
+      def bind_attributes(query)
+        return [] unless query.respond_to?(:bound_attributes)
+        query.bound_attributes.map(&:value)
+      end
+
+      # Rails 5.1 fix
+      def unprepared_query(query)
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/\=\ \$\d+/, "= ?") || match
+        end
+      end
+
+      def translate_reference(reference)
+        reference.map { |ref| ref.try(:to_sql) || ref }.compact
+      end
+
+      def generate_where_clause(query)
+        case query
+        when String, Hash
+          @scope.where(query)
+        when Array
+          @scope.where(*query)
+        else
+          query
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::QueryMethods::WhereChain.prepend(ActiveRecordExtended::QueryMethods::AnyOf)

data/lib/active_record_extended/version.rb

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

data/spec/query_methods/any_of_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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!(: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) }
+
+  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 })
+      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)
+
+      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)
+
+      query = Person.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])
+      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)
+
+        expect(query).to include(tag_one, tag_two, person_one_tag, person_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)
+
+        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 } },
+        )
+
+        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 = Person.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)
+
+      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)
+
+      query = Person.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])
+      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)
+
+        expect(query).to include(tag_three)
+        expect(query).to_not include(tag_one, tag_two, person_one_tag, person_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)
+
+        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 } },
+        )
+
+        expect(query).to include(tag_two)
+        expect(query).to_not include(tag_one, tag_three)
+      end
+    end
+  end
+end

data/spec/sql_inspections/any_of_sql_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Any / None of SQL Queries" do
+  let(:equal_query) { "people\".\"personal_id\" = 1" }
+  let(:or_query)    { "OR (\"people\".\"personal_id\" = 2)" }
+  let(:equal_or)    { equal_query + " " + or_query }
+  let(:join_query)  { /INNER JOIN \"tags\" ON \"tags\".\"person_id\" = \"people\".\"id/ }
+
+  describe "where.any_of/1" do
+    it "should group different column arguments into nested or conditions" do
+      query = Person.where.any_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
+      expect(query).to match_regex(/WHERE .+ = 1 OR \(.+\) OR \(.+\)/)
+    end
+
+    it "Should assign where clause predicates for standard queries" do
+      query = Person.where.any_of({ personal_id: 1 }, { personal_id: 2 }).to_sql
+      expect(query).to include(equal_or)
+
+      personal_one = Person.where(personal_id: 1)
+      personal_two = Person.where(personal_id: 2)
+      query = Person.where.any_of(personal_one, personal_two).to_sql
+      expect(query).to include(equal_or)
+    end
+
+    it "Joining queries should be added to the select statement" do
+      person_two_tag = Person.where(personal_id: 1).joins(:hm_tags)
+      query = Person.where.any_of(person_two_tag).to_sql
+      expect(query).to match_regex(join_query)
+      expect(query).to include(equal_query)
+    end
+  end
+
+  describe "where.none_of/1" do
+    it "Should surround the query in a WHERE NOT clause" do
+      query = Person.where.none_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
+      expect(query).to match_regex(/WHERE.+NOT \(.+ = 1 OR \(.+\) OR \(.+\)\)/)
+    end
+  end
+end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: active_record_extended
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - George Protacio-Karaszi
 - Dan McClain
+- Olivier El Mekki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-05 00:00:00.000000000 Z
+date: 2018-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -119,6 +120,7 @@ description: Adds extended functionality to Activerecord Postgres implementation
 email:
 - georgekaraszi@gmail.com
 - git@danmcclain.net
+- olivier@el-mekki.com
 executables:
 - console
 - setup
@@ -132,6 +134,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -153,14 +156,17 @@ files:
 - 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
 - lib/active_record_extended/query_methods/either.rb
 - lib/active_record_extended/query_methods/where_chain.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/spec_helper.rb
+- spec/sql_inspections/any_of_sql_spec.rb
 - spec/sql_inspections/arel/array_spec.rb
 - spec/sql_inspections/contains_sql_queries_spec.rb
 - spec/sql_inspections/either_sql_spec.rb
@@ -192,10 +198,12 @@ 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/spec_helper.rb
+- spec/sql_inspections/any_of_sql_spec.rb
 - spec/sql_inspections/arel/array_spec.rb
 - spec/sql_inspections/contains_sql_queries_spec.rb
 - spec/sql_inspections/either_sql_spec.rb