praxis 2.0.pre.11 → 2.0.pre.16

data/lib/praxis/responses/http.rb

@@ -160,7 +160,9 @@ module Praxis
 
           media_type media_type if media_type
           location location if location
-          headers headers if headers
+          headers&.each do |(name, value)|
+            header(name: name, value: value)
+          end
         end
       end
 

data/lib/praxis/tasks/routes.rb

@@ -7,14 +7,14 @@ namespace :praxis do
     table = Terminal::Table.new title: "Routes",
     headings:  [
       "Version", "Path", "Verb",
-      "Resource", "Action", "Implementation", "Options"
+      "Endpoint", "Action", "Implementation", "Options"
     ]
 
     rows = []
-    Praxis::Application.instance.endpoint_definitions.each do |resource_definition|
-      resource_definition.actions.each do |name, action|
+    Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
+      endpoint_definition.actions.each do |name, action|
         method = begin
-          m = resource_definition.controller.instance_method(name)
+          m = endpoint_definition.controller.instance_method(name)
         rescue
           nil
         end
@@ -22,13 +22,13 @@ namespace :praxis do
         method_name = method ? "#{method.owner.name}##{method.name}" : 'n/a'
 
         row = {
-          resource: resource_definition.name,
+          resource: endpoint_definition.name,
           action: name,
           implementation: method_name,
         }
 
         unless action.route
-          warn "Warning: No routes defined for #{resource_definition.name}##{name}."
+          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
           rows << row
         else
           route = action.route

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.11'
+  VERSION = '2.0.pre.16'
 end

data/spec/praxis/action_definition_spec.rb

@@ -40,7 +40,9 @@ describe Praxis::ActionDefinition do
 
         media_type media_type
         location location
-        headers headers if headers
+        headers&.each do |(name, value)|
+          header(name, value)
+        end
       end
     end
     Praxis::ActionDefinition.new(:foo, endpoint_definition) do

data/spec/praxis/extensions/attribute_filtering/active_record_filter_query_builder_spec.rb

@@ -14,6 +14,7 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   shared_examples 'subject_equivalent_to' do |expected_result|
     it do
       loaded_ids = subject.all.map(&:id).sort
+      expected_result = expected_result.call if expected_result.is_a?(Proc)
       expected_ids = expected_result.all.map(&:id).sort
       expect(loaded_ids).to_not be_empty
       expect(loaded_ids).to eq(expected_ids)
@@ -23,12 +24,11 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   # Poorman's way to compare SQL queries...
   shared_examples 'subject_matches_sql' do |expected_sql|
     it do
-       # Remove parenthesis as our queries have WHERE clauses using them...
-      gen_sql = subject.all.to_sql.gsub(/[()]/,'')
+      gen_sql = subject.all.to_sql
       # Strip blank at the beggining (and end) of every line
       # ...and recompose it by adding an extra space at the beginning of each one instead
       exp = expected_sql.split(/\n/).map do |line|
-        " " + line.strip.gsub(/[()]/,'')
+        " " + line.strip
       end.join.strip
       expect(gen_sql).to eq(exp)
     end
@@ -37,7 +37,7 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   context 'initialize' do
     it 'sets the right things to the instance' do
       instance
-      expect(instance.query).to eq(base_query)
+      expect(instance.instance_variable_get(:@initial_query)).to eq(base_query)
       expect(instance.model).to eq(base_model)
       expect(instance.filters_map).to eq(filters_map)
     end
@@ -52,208 +52,295 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         expect(subject).to be(base_query)
       end
     end
-    context 'by a simple field' do
-      context 'that maps to the same name' do
-        let(:filters_string) { 'category_uuid=deadbeef1' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
-      end
-      context 'same-name filter mapping works' do
-        context 'even if ther was not a filter explicitly defined for it' do
+    context 'with flat AND conditions' do
+      context 'by a simple field' do
+        context 'that maps to the same name' do
           let(:filters_string) { 'category_uuid=deadbeef1' }
           it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
         end
+        context 'same-name filter mapping works' do
+          context 'even if ther was not a filter explicitly defined for it' do
+            let(:filters_string) { 'category_uuid=deadbeef1' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
+          end
 
-        context 'but if it is a field that does not exist in the model' do
-          let(:filters_string) { 'nonexisting=valuehere' }
-          it 'it blows up with the right error' do
-            expect{subject}.to raise_error(/Filtering by nonexisting is not allowed/)
+          context 'but if it is a field that does not exist in the model' do
+            let(:filters_string) { 'nonexisting=valuehere' }
+            it 'it blows up with the right error' do
+              expect{subject}.to raise_error(/Filtering by nonexisting is not allowed/)
+            end
           end
         end
-      end
         context 'that maps to a different name' do
-        let(:filters_string) { 'name=Book1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
-      end
-      context 'that is mapped as a nested struct' do
-        let(:filters_string) { 'fake_nested.name=Book1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
+          let(:filters_string) { 'name=Book1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
+        end
+        context 'that is mapped as a nested struct' do
+          let(:filters_string) { 'fake_nested.name=Book1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
+        end
+        context 'passing multiple values' do
+          context 'without fuzzy matching' do
+            let(:filters_string) { 'category_uuid=deadbeef1,deadbeef2' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: ['deadbeef1','deadbeef2'])
+          end
+          context 'with fuzzy matching' do
+            let(:filters_string) { 'category_uuid=*deadbeef1,deadbeef2*' }
+            it 'is not supported' do
+              expect{
+                subject
+              }.to raise_error(
+                Praxis::Extensions::AttributeFiltering::MultiMatchWithFuzzyNotAllowedByAdapter,
+                /Please use multiple OR clauses instead/
+              )
+            end
+          end
+        end
       end
-    end
 
-    context 'by a field or a related model' do
-      context 'for a belongs_to association' do
-        let(:filters_string) { 'author.name=author2'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name' => 'author2')
-      end
-      context 'for a has_many association' do
-        let(:filters_string) { 'taggings.label=primary' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
-      end
-      context 'for a has_many through association' do
-        let(:filters_string) { 'tags.name=blue' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
+      context 'by a field or a related model' do
+        context 'for a belongs_to association' do
+          let(:filters_string) { 'author.name=author2'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name' => 'author2')
+        end
+        context 'for a has_many association' do
+          let(:filters_string) { 'taggings.label=primary' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+        end
+        context 'for a has_many through association' do
+          let(:filters_string) { 'tags.name=blue' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
+        end
       end
-    end
 
-    context 'by using all supported operators' do
-      PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
-      COMMON_SQL_PREFIX = <<~SQL
-            SELECT "active_books".* FROM "active_books"
-            INNER JOIN
-              "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
-          SQL
-      context '=' do
-        let(:filters_string) { 'author.id=11'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" = 11
-          SQL
-      end
-      context '= (with array)' do
-        let(:filters_string) { 'author.id=11,22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" IN (11,22)
-          SQL
-      end      
-      context '!=' do
-        let(:filters_string) { 'author.id!=11'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" <> 11
-          SQL
-      end
-      context '!= (with array)' do
-        let(:filters_string) { 'author.id!=11,888'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" NOT IN (11,888)
-          SQL
-      end
-      context '>' do
-        let(:filters_string) { 'author.id>1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" > 1
-          SQL
-      end
-      context '<' do
-        let(:filters_string) { 'author.id<22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" < 22
-          SQL
-      end
-      context '>=' do
-        let(:filters_string) { 'author.id>=22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" >= 22
-          SQL
-      end
-      context '<=' do
-        let(:filters_string) { 'author.id<=22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" <= 22
-          SQL
-      end
-      context '!' do
-        let(:filters_string) { 'author.id!'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" IS NOT NULL
-          SQL
-      end
-      context '!!' do
-        let(:filters_string) { 'author.name!!'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" IS NULL
-          SQL
-      end      
-      context 'including LIKE fuzzy queries' do
-        context 'LIKE' do
-          let(:filters_string) { 'author.name=author*'}
-          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
+      # NOTE: apparently AR when conditions are build with strings in the where clauses (instead of names, etc)
+      # it decides to parenthesize them, even when there's only 1 condition. Hence the silly parentization of
+      # these SQL fragments here (and others)
+      context 'by using all supported operators' do
+        PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
+        COMMON_SQL_PREFIX = <<~SQL
+              SELECT "active_books".* FROM "active_books"
+              INNER JOIN
+                "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
+            SQL
+        context '=' do
+          let(:filters_string) { 'author.id=11'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" = 11)
+            SQL
+        end
+        context '= (with array)' do
+          let(:filters_string) { 'author.id=11,22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" IN (11,22))
+            SQL
+        end      
+        context '!=' do
+          let(:filters_string) { 'author.id!=11'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" <> 11)
+            SQL
+        end
+        context '!= (with array)' do
+          let(:filters_string) { 'author.id!=11,888'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" NOT IN (11,888))
+            SQL
+        end
+        context '>' do
+          let(:filters_string) { 'author.id>1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" > 1)
+            SQL
+        end
+        context '<' do
+          let(:filters_string) { 'author.id<22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" < 22)
+            SQL
+        end
+        context '>=' do
+          let(:filters_string) { 'author.id>=22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" >= 22)
+            SQL
+        end
+        context '<=' do
+          let(:filters_string) { 'author.id<=22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" LIKE 'author%'
-          SQL
+              WHERE ("#{PREF}/author"."id" <= 22)
+            SQL
         end
-        context 'NOT LIKE' do
-          let(:filters_string) { 'author.name!=foobar*'}
-          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
+        context '!' do
+          let(:filters_string) { 'author.id!'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" NOT LIKE 'foobar%'
-          SQL
+              WHERE ("#{PREF}/author"."id" IS NOT NULL)
+            SQL
+        end
+        context '!!' do
+          let(:filters_string) { 'author.name!!'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."name" IS NULL)
+            SQL
+        end      
+        context 'including LIKE fuzzy queries' do
+          context 'LIKE' do
+            let(:filters_string) { 'author.name=author*'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
+            it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."name" LIKE 'author%')
+            SQL
+          end
+          context 'NOT LIKE' do
+            let(:filters_string) { 'author.name!=foobar*'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
+            it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."name" NOT LIKE 'foobar%')
+            SQL
+          end
         end
       end
-    end
 
-    context 'with a field mapping using a proc' do
-      let(:filters_string) { 'name_is_not=Book1' }
-      it_behaves_like 'subject_equivalent_to', ActiveBook.where.not(simple_name: 'Book1')
-    end
+      context 'with a field mapping using a proc' do
+        let(:filters_string) { 'name_is_not=Book1' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where.not(simple_name: 'Book1')
+      end
 
-    context 'with a deeply nested chains' do
-      context 'of depth 2' do
-        let(:filters_string) { 'category.books.name=Book2' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books).where('books_active_categories.simple_name': 'Book2')
+      context 'with a deeply nested chains' do
+        context 'of depth 2' do
+          let(:filters_string) { 'category.books.name=Book2' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books).where('books_active_categories.simple_name': 'Book2')
+        end
+        context 'multiple conditions on a nested relationship' do
+          let(:filters_string) { 'category.books.taggings.tag_id=1&category.books.taggings.label=primary' }
+          it_behaves_like 'subject_equivalent_to', 
+            ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
+          it_behaves_like 'subject_matches_sql', <<~SQL
+              SELECT "active_books".* FROM "active_books"
+                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
+                INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
+                WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
+                AND ("#{PREF}/category/books/taggings"."label" = 'primary')
+            SQL
+        end
+        context 'that contain multiple joins to the same table' do
+          let(:filters_string) { 'taggings.tag.taggings.tag_id=1' }
+          it_behaves_like 'subject_equivalent_to', 
+            ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1')
+        end
       end
-      context 'multiple conditions on a nested relationship' do
-        let(:filters_string) { 'category.books.taggings.tag_id=1&category.books.taggings.label=primary' }
-        it_behaves_like 'subject_equivalent_to', 
-          ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
-        it_behaves_like 'subject_matches_sql', <<~SQL
-            SELECT "active_books".* FROM "active_books"
-              INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-              INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
-              INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
-              WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
-              AND ("#{PREF}/category/books/taggings"."label" = 'primary')
-          SQL
+
+      context 'by multiple fields' do
+        context 'adds the where clauses for the top model if fields belong to it' do
+          let(:filters_string) { 'category_uuid=deadbeef1&name=Book1' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1',  simple_name: 'Book1')
+        end
+        context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
+          let(:filters_string) { 'taggings.label=primary&taggings.tag_id=2' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary', 'active_taggings.tag_id' => 2)
+        end
       end
-      context 'that contain multiple joins to the same table' do
-        let(:filters_string) { 'taggings.tag.taggings.tag_id=1' }
-        it_behaves_like 'subject_equivalent_to', 
-          ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1')
+
+      context 'uses fully qualified names for conditions (disambiguate fields)' do
+        context 'when we have a join table condition that has the same field' do
+          let(:filters_string) { 'name=Book1&category.books.name=Book3' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books)
+                                                    .where('simple_name': 'Book1')
+                                                    .where('books_active_categories.simple_name': 'Book3')
+          it_behaves_like 'subject_matches_sql', <<~SQL
+              SELECT "active_books".* FROM "active_books"
+                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
+              WHERE ("active_books"."simple_name" = 'Book1')
+              AND ("#{PREF}/category/books"."simple_name" = 'Book3')
+            SQL
+        end
+
+        context 'it qualifis them even if there are no joined tables/conditions at all' do
+          let(:filters_string) { 'id=11'}
+          it_behaves_like 'subject_matches_sql', <<~SQL
+            SELECT "active_books".* FROM "active_books"
+              WHERE ("active_books"."id" = 11)
+            SQL
+        end
+
       end
     end
 
-    context 'by multiple fields' do
+    context 'with simple OR conditions' do
       context 'adds the where clauses for the top model if fields belong to it' do
-        let(:filters_string) { 'category_uuid=deadbeef1&name=Book1' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1',  simple_name: 'Book1')
+        let(:filters_string) { 'category_uuid=deadbeef1|name=Book1' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(simple_name: 'Book1'))
+      end
+      context 'supports top level parenthesis' do
+        let(:filters_string) { '(category_uuid=deadbeef1|name=Book1)' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(simple_name: 'Book1'))
       end
       context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
-        let(:filters_string) { 'taggings.label=primary&taggings.tag_id=2' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary', 'active_taggings.tag_id' => 2)
+        let(:filters_string) { 'taggings.label=primary|taggings.tag_id=2' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+                                                .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))        
       end
     end
 
-    context 'uses fully qualified names for conditions (disambiguate fields)' do
-      context 'when we have a join table condition that has the same field' do
-        let(:filters_string) { 'name=Book1&category.books.name=Book3' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books)
-                                                  .where('simple_name': 'Book1')
-                                                  .where('books_active_categories.simple_name': 'Book3')
-        it_behaves_like 'subject_matches_sql', <<~SQL
-            SELECT "active_books".* FROM "active_books"
-              INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-              INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
-            WHERE ("#{PREF}/category/books"."simple_name" = 'Book3')
-            AND ("active_books"."simple_name" = 'Book1')
-          SQL
-      end
+    context 'with combined AND and OR conditions' do
+      let(:filters_string) { '(category_uuid=deadbeef1|category_uuid=deadbeef2)&(name=Book1|name=Book2)' }
+      it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(category_uuid: 'deadbeef2'))
+                                              .and(ActiveBook.where(simple_name: 'Book1').or(ActiveBook.where(simple_name: 'Book2')))
+      it_behaves_like 'subject_matches_sql', <<~SQL
+        SELECT "active_books".* FROM "active_books"
+          WHERE ("active_books"."category_uuid" = 'deadbeef1' OR "active_books"."category_uuid" = 'deadbeef2')
+          AND ("active_books"."simple_name" = 'Book1' OR "active_books"."simple_name" = 'Book2')
+      SQL
 
-      context 'it qualifis them even if there are no joined tables/conditions at all' do
-        let(:filters_string) { 'id=11'}
+      context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
+        let(:filters_string) { 'taggings.label=primary|taggings.tag_id=2' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+                                                .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))
         it_behaves_like 'subject_matches_sql', <<~SQL
           SELECT "active_books".* FROM "active_books"
-            WHERE "active_books"."id" = 11
-          SQL
+            INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
+            WHERE ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+        SQL
       end
 
+      context '3-deep AND and OR conditions' do
+        let(:filters_string) { '(category.name=cat2|(taggings.label=primary&tags.name=red))&category_uuid=deadbeef1' }
+        it_behaves_like('subject_equivalent_to', Proc.new do
+          base=ActiveBook.joins(:category,:taggings,:tags)
+
+          and1_or1 = base.where('category.name': 'cat2')
+
+          and1_or2_and1 = base.where('taggings.label': 'primary')
+          and1_or2_and2 = base.where('tags.name': 'red')
+          and1_or2 = and1_or2_and1.and(and1_or2_and2)
+
+          and1 = and1_or1.or(and1_or2)
+          and2=base.where(category_uuid: 'deadbeef1')
+
+          query = and1.and(and2)
+        end)
+
+        it_behaves_like 'subject_matches_sql', <<~SQL
+        SELECT "active_books".* FROM "active_books" 
+          INNER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
+          INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
+          INNER JOIN "active_taggings" "taggings_active_books_join" ON "taggings_active_books_join"."book_id" = "active_books"."id" 
+          INNER JOIN "active_tags" "/tags" ON "/tags"."id" = "taggings_active_books_join"."tag_id"         
+          WHERE ("/category"."name" = 'cat2' OR ("/taggings"."label" = 'primary') AND ("/tags"."name" = 'red')) AND ("active_books"."category_uuid" = 'deadbeef1')
+        SQL
+      end
     end
 
     context 'ActiveRecord continues to work as expected (with our patches)' do