praxis 2.0.pre.1 → 2.0.pre.6

data/lib/praxis/trait.rb

@@ -76,7 +76,7 @@ module Praxis
             dsl_compiler: ActionDefinition::HeadersDSLCompiler,
             case_insensitive_load: true
           }
-          Attributor::Hash.of(key: String).construct(Proc.new {}, hash_opts)
+          Attributor::Hash.of(key: String).construct(Proc.new {}, **hash_opts)
         else
           Attributor::Hash.construct(Proc.new {})
         end

data/lib/praxis/types/media_type_common.rb

@@ -14,6 +14,16 @@ module Praxis
           hash
         end
 
+        def as_json_schema(**args)
+          the_type = @attribute && @attribute.type || member_type
+          the_type.as_json_schema(args)
+        end
+
+        def json_schema_type
+          the_type = @attribute && @attribute.type || member_type
+          the_type.json_schema_type
+        end
+    
         def description(text=nil)
           @description = text if text
           @description
@@ -32,8 +42,8 @@ module Praxis
         #
         # @return [String] the string-representation of this type's identifier
         def identifier(identifier=nil)
-          return @identifier.to_s unless identifier
-          (@identifier = MediaTypeIdentifier.load(identifier)).to_s
+          return @identifier unless identifier
+          @identifier = MediaTypeIdentifier.load(identifier)
         end
       end
 

data/lib/praxis/types/multipart.rb

@@ -12,7 +12,7 @@ module Praxis
       return value if value.kind_of?(self) || value.nil?
 
       unless (value.kind_of?(::String) && ! content_type.nil?)
-        raise Attributor::CoercionError, context: context, from: value.class, to: self.name, value: value
+        raise Attributor::CoercionError.new(context: context, from: value.class, to: self.name, value: value)
       end
 
       headers = {'Content-Type' => content_type}

data/lib/praxis/types/multipart_array.rb

@@ -83,7 +83,7 @@ module Praxis
 
         self.multiple << name if multiple
 
-        compiler = Attributor::DSLCompiler.new(self, opts)
+        compiler = Attributor::DSLCompiler.new(self, **opts)
 
         if filename
           filename_attribute = compiler.define('filename', String, required: true)
@@ -153,6 +153,68 @@ module Praxis
         example
       end
 
+      def self.json_schema_type
+        :object
+      end
+
+      # Multipart request bodies are special in OPEN API
+      # schema:            # Request payload
+      # type: object
+      # properties:      # Request parts
+      #   id:            # Part 1 (string value)
+      #     type: string
+      #     format: uuid
+      #   address:       # Part2 (object)
+      #     type: object
+      #     properties:
+      #       street:
+      #         type: string
+      #       city:
+      #         type: string
+      #   profileImage:  # Part 3 (an image)
+      #     type: string
+      #     format: binary
+      # 
+      # NOTE: not sure if this 
+      def self.as_openapi_request_body( attribute_options: {} )
+        hash = { type: json_schema_type }
+        opts = self.options.merge( attribute_options )
+        hash[:description] = opts[:description] if opts[:description]
+        hash[:default] = opts[:default] if opts[:default]
+
+        unless self.attributes.empty?
+          props = {}
+          encoding = {}
+          self.attributes.each do |part_name, part_attribute|
+            part_example = part_attribute.example
+            key_to_use = part_name.is_a?(Regexp) ? part_name.source : part_name
+            
+            part_info = {}
+            if (payload_attribute = part_attribute.options[:payload_attribute])
+              props[key_to_use] = payload_attribute.as_json_schema(example: part_example.payload)
+            end
+            #{
+            # contentType: 'fff',
+            # headers: {
+            #   custom1: 'safd'
+            # }
+            if (headers_attribute = part_attribute.options[:headers_attribute])
+              # Does this 'Content-Type' string check work?...can it be a symbol? what does it mean anyway?
+              encoding[key_to_use][:contentType] = headers_attribute['Content-Type'] if headers_attribute['Content-Type']
+              # TODO?rethink? ...is this correct?: att a 'headers' key with some header schemas if this part have some
+              encoding[key_to_use]['headers'] = headers_attribute.as_json_schema(example: part_example.headers)
+            end
+          end
+
+          hash[:properties] = props
+          hash[:encoding] = encoding unless encoding.empty?
+        end
+        hash
+      end
+
+      def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        as_openapi_request_body(attribute_options: attribute_options)
+      end
 
       def self.describe(shallow=true, example: nil)
         type_name = Attributor.type_name(self)
@@ -218,7 +280,7 @@ module Praxis
       attr_accessor :preamble
       attr_reader :content_type
 
-      def initialize(content_type: self.class.identifier)
+      def initialize(content_type: self.class.identifier.to_s)
         self.content_type = content_type
       end
 

data/lib/praxis/types/multipart_array/part_definition.rb

@@ -14,7 +14,7 @@ module Praxis
 
         def update_attribute(attribute, options, block)
           attribute.options.merge!(options)
-          attribute.type.attributes(options, &block)
+          attribute.type.attributes(**options, &block)
         end
 
         def create_attribute(type=Attributor::Struct, **opts, &block)

data/lib/praxis/validation_handler.rb

@@ -3,8 +3,7 @@ module Praxis
 
     # Should return the Response to send back
     def handle!(summary:, request:, stage:, errors: nil, exception: nil, **opts)
-      documentation = Docs::LinkBuilder.instance.for_request request
-      Responses::ValidationError.new(summary: summary, errors: errors, exception: exception, documentation: documentation, **opts)
+      Responses::ValidationError.new(summary: summary, errors: errors, exception: exception, **opts)
     end
 
   end

data/lib/praxis/version.rb

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

data/praxis.gemspec

@@ -21,21 +21,21 @@ Gem::Specification.new do |spec|
   spec.executables << 'praxis'
 
   spec.add_dependency 'rack', '>= 1'
-  spec.add_dependency 'mustermann', '>=0', '<=1'
+  spec.add_dependency 'mustermann', '>=1.1', '<=2'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'praxis-blueprints', '~> 3.3'
-  spec.add_dependency 'attributor', '~> 5.1'
+  spec.add_dependency 'praxis-blueprints', '>= 3.5'
+  spec.add_dependency 'attributor', '>= 5.5'
   spec.add_dependency 'thor'
   spec.add_dependency 'terminal-table', '~> 1.4'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 0.9'
-  spec.add_development_dependency 'rake-notes', '~> 0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  
   if RUBY_PLATFORM !~ /java/
-    spec.add_development_dependency 'pry', '~> 0'
-    spec.add_development_dependency 'pry-byebug', '~> 1'
-    spec.add_development_dependency 'pry-stack_explorer', '~> 0'
+    spec.add_development_dependency 'pry'
+    spec.add_development_dependency 'pry-byebug'
+    spec.add_development_dependency 'pry-stack_explorer'
     spec.add_development_dependency 'sqlite3', '~> 1'
   else
     spec.add_development_dependency 'jdbc-sqlite3'
@@ -49,6 +49,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rack-test', '~> 0'
   spec.add_development_dependency 'simplecov', '~> 0'
   spec.add_development_dependency 'fuubar', '~> 2'
-  spec.add_development_dependency 'yard', ">= 0.9.20"
   spec.add_development_dependency 'coveralls'
+  # Just for the query selector extensions etc...
+  spec.add_development_dependency 'sequel', '~> 5'
+  spec.add_development_dependency 'activerecord', '> 4'
 end

data/spec/functional_spec.rb

@@ -331,12 +331,15 @@ describe 'Functional specs' do
   end
 
   context 'wildcard verb routing' do
+    let(:content_type){ 'application/json' }
     it 'can terminate instances with POST' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'CONTENT_TYPE' => content_type, 'global_session' => session
+      puts last_response.body
+      #binding.pry
       expect(last_response.status).to eq(200)
     end
     it 'can terminate instances with DELETE' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'CONTENT_TYPE' => content_type, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
@@ -355,7 +358,7 @@ describe 'Functional specs' do
 
   context 'auth_plugin' do
     it 'can terminate' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
@@ -366,8 +369,8 @@ describe 'Functional specs' do
   end
 
   context 'with mismatch between Content-Type and payload' do
-    let(:body) { '{}' }
-    let(:content_type) { 'application/x-www-form-urlencoded' }
+    let(:body) { 'some-text' }
+    let(:content_type) { 'application/json' }
 
     before do
       post '/api/clouds/1/instances/2/terminate?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
@@ -376,7 +379,7 @@ describe 'Functional specs' do
     it 'returns a useful error message' do
       body = JSON.parse(last_response.body)
       expect(body['name']).to eq('ValidationError')
-      expect(body['summary']).to match("Error loading payload. Used Content-Type: 'application/x-www-form-urlencoded'")
+      expect(body['summary']).to match("Error loading payload. Used Content-Type: 'application/json'")
       expect(body['errors']).to_not be_empty
     end
   end

data/spec/praxis/action_definition_spec.rb

@@ -115,7 +115,7 @@ describe Praxis::ActionDefinition do
     end
 
     its('params.attributes.keys') { should eq [:inherited, :app_name, :name, :one]}
-    its('routes.first.path.to_s') { should eq '/api/foobars/hello_world/test_trait/:app_name/:one' }
+    its('route.path.to_s') { should eq '/api/foobars/hello_world/test_trait/:app_name/:one' }
     its(:traits) { should eq [:test] }
 
     it 'is reflected in the describe output' do
@@ -231,7 +231,7 @@ describe Praxis::ActionDefinition do
       let(:parent_param) { ApiResources::Volumes.actions[:show].params.attributes[:id] }
 
       it 'has the right path' do
-        expect(action.primary_route.path.to_s).to eq '/api/clouds/:cloud_id/volumes/:volume_id/snapshots/:id'
+        expect(action.route.path.to_s).to eq '/api/clouds/:cloud_id/volumes/:volume_id/snapshots/:id'
       end
 
       its('params.attributes'){ should have_key(:cloud_id) }
@@ -281,22 +281,10 @@ describe Praxis::ActionDefinition do
     subject(:action) { resource_definition.actions[:show] }
 
     it 'works' do
-      expansion = action.primary_route.path.expand(cloud_id:232, id: 2)
+      expansion = action.route.path.expand(cloud_id:232, id: 2)
       expect(expansion).to eq "/api/clouds/232/instances/2"
     end
 
-    context '#primary_route' do
-      it 'is the first-defined route' do
-        expect(action.primary_route).to be(action.routes.first)
-      end
-    end
-
-    context '#named_routes' do
-      subject(:named_routes) { action.named_routes }
-
-      its([:alternate]) { should be(action.routes[1]) }
-    end
-
   end
 
   context 'with nodoc!' do
@@ -339,7 +327,7 @@ describe Praxis::ActionDefinition do
       allow(Praxis::ApiDefinition).to receive(:instance).and_return(non_singleton_api)
     end
 
-    its('routes.first.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }
+    its('route.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }
     its('params.attributes.keys') { should match_array [:inherited, :app_name, :one]}
 
     context 'where the action overrides a base_param' do

data/spec/praxis/api_general_info_spec.rb

@@ -17,8 +17,8 @@ describe Praxis::ApiGeneralInfo do
       endpoint 'api.example.com'
       base_path "/base"
 
-      consumes 'xml', 'x-www-form-urlencoded'
-      produces 'json', 'x-www-form-urlencoded'
+      consumes 'json'
+      produces 'json'
 
       base_params do
         attribute :name, String
@@ -40,8 +40,8 @@ describe Praxis::ApiGeneralInfo do
     end
 
     its(:name) { should eq 'Name' }
-    its(:consumes) { should eq ['xml', 'x-www-form-urlencoded']}
-    its(:produces) { should eq ['json', 'x-www-form-urlencoded']}
+    its(:consumes) { should eq ['json']}
+    its(:produces) { should eq ['json']}
   end
 
   context '.describe' do
@@ -59,8 +59,8 @@ describe Praxis::ApiGeneralInfo do
     its([:base_params, :name, :type, :name]) { should eq 'String' }
     its([:version_with]) { should eq([:header, :params]) }
     its([:endpoint]) { should eq 'api.example.com' }
-    its([:consumes]) { should eq ['xml', 'x-www-form-urlencoded'] }
-    its([:produces]) { should eq ['json', 'x-www-form-urlencoded'] }
+    its([:consumes]) { should eq ['json'] }
+    its([:produces]) { should eq ['json'] }
   end
 
   context 'base_path with versioning' do

data/spec/praxis/application_spec.rb

@@ -27,7 +27,7 @@ describe Praxis::Application do
       end
 
       it 'passes the params and block to config' do
-        ret = app.config(:key, Attributor::Hash, {option: :one}, &myblock)
+        ret = app.config(:key, Attributor::Hash, **{option: :one}, &myblock)
         expect(ret).to eq([:key, Attributor::Hash, {option: :one}, myblock])
       end
 

data/spec/praxis/collection_spec.rb

@@ -8,6 +8,7 @@ describe Praxis::Collection do
   subject!(:collection) do
     Praxis::Collection.of(member_type)
   end
+  let(:identifier_string) { subject.identifier.to_s }
 
   context '.of' do
     let(:member_type) do
@@ -16,7 +17,7 @@ describe Praxis::Collection do
       end
     end
 
-    its(:identifier) { should eq 'application/an-awesome-type; type=collection' }
+    it { expect(identifier_string).to eq('application/an-awesome-type; type=collection') }
 
     it 'sets the collection on the media type' do
       expect(member_type::Collection).to be(collection)
@@ -34,7 +35,7 @@ describe Praxis::Collection do
   context 'defined explicitly' do
     subject(:type) { Volume::Collection }
     its(:member_type) { should be Volume }
-    its(:identifier) { should eq 'application/vnd.acme.volumes' }
+    it { expect(identifier_string).to eq('application/vnd.acme.volumes') }
   end
 
   context '.member_type' do

data/spec/praxis/config_spec.rb

@@ -72,12 +72,12 @@ describe Praxis::Config do
       
       it 'it is not allowed if its for the top key' do
         expect{
-          config.define nil, config_type, config_opts
+          config.define nil, config_type, **config_opts
         }.to raise_error(/You cannot define the top level configuration with a non-Struct type/)
       end
       
       before do
-        config.define config_key, config_type, config_opts
+        config.define config_key, config_type, **config_opts
       end
 
       it 'sets the attribute to the defined type' do

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

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+require_relative '../support/spec_resources_active_model.rb'
+require 'praxis/extensions/attribute_filtering'
+require 'praxis/extensions/attribute_filtering/active_record_filter_query_builder'
+
+describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder do
+  let(:root_resource) { ActiveBookResource }
+  let(:filters_map) { root_resource.instance_variable_get(:@_filters_map)}
+  let(:base_model) { root_resource.model }
+  let(:base_query) { base_model }
+  let(:instance) { described_class.new(query: base_query, model: base_model, filters_map: filters_map) }
+
+  shared_examples 'subject_equivalent_to' do |expected_result|
+    it do
+      loaded_ids = subject.all.map(&:id).sort
+      expected_ids = expected_result.all.map(&:id).sort
+      expect(loaded_ids).to_not be_empty
+      expect(loaded_ids).to eq(expected_ids)
+    end
+  end
+
+  # 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(/[()]/,'')
+      # 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(/[()]/,'')
+      end.join.strip
+      expect(gen_sql).to eq(exp)
+    end
+  end
+
+  context 'initialize' do
+    it 'sets the right things to the instance' do
+      instance
+      expect(instance.query).to eq(base_query)
+      expect(instance.model).to eq(base_model)
+      expect(instance.attr_to_column).to eq(filters_map)
+    end
+  end
+  context 'generate' do
+    subject { instance.generate(filters) }
+    let(:filters) { Praxis::Types::FilteringParams.load(filters_string)}
+
+    context 'with no filters' do
+      let(:filters_string) { '' }
+      it 'does not modify the query' do
+        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 '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')
+      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')
+      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%"')
+          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
+
+    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')
+      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 '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 'uses fully qualified names for conditions (disambiguate fields)' do
+      context 'when we have a join table condition that has the same field' do
+        COMMON_SQL_PREFIX = <<~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"    
+        SQL
+        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', COMMON_SQL_PREFIX + <<~SQL
+            WHERE ("#{PREF}/category/books"."simple_name" = 'Book3')
+            AND ("active_books"."simple_name" = 'Book1')
+          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
+
+    context 'ActiveRecord continues to work as expected (with our patches)' do
+      context 'using a deep join with repeated tables' do
+        subject{ ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1') }
+        it 'performs query' do
+          expect(subject.to_a).to_not be_empty 
+        end
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books"
+            INNER JOIN "active_taggings" ON "active_taggings"."book_id" = "active_books"."id"
+            INNER JOIN "active_tags" ON "active_tags"."id" = "active_taggings"."tag_id"
+            INNER JOIN "active_taggings" "taggings_active_tags" ON "taggings_active_tags"."tag_id" = "active_tags"."id"
+            WHERE (taggings_active_tags.tag_id=1)
+        SQL
+      end
+      context 'a deep join with repeated tables with the root AND the join, along with :through joins as well' do
+        subject!{ ActiveBook.joins(tags: {books: {taggings: :book}}).where('books_active_taggings.simple_name="Book2"') }
+        it 'performs query' do
+          expect(subject.to_a).to_not be_empty 
+        end
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books" 
+               INNER JOIN "active_taggings" ON "active_taggings"."book_id" = "active_books"."id"
+               INNER JOIN "active_tags" ON "active_tags"."id" = "active_taggings"."tag_id"
+               INNER JOIN "active_taggings" "taggings_active_tags_join" ON "taggings_active_tags_join"."tag_id" = "active_tags"."id" 
+               INNER JOIN "active_books" "books_active_tags" ON "books_active_tags"."id" = "taggings_active_tags_join"."book_id" 
+               INNER JOIN "active_taggings" "taggings_active_books" ON "taggings_active_books"."book_id" = "books_active_tags"."id" 
+               INNER JOIN "active_books" "books_active_taggings" ON "books_active_taggings"."id" = "taggings_active_books"."book_id"
+               WHERE (books_active_taggings.simple_name="Book2")             
+        SQL
+      end
+    end
+
+    context 'respects scopes' do
+      context 'for a has_many through association' do
+        let(:filters_string) { 'primary_tags.name=blue' }
+        it_behaves_like 'subject_equivalent_to', 
+          ActiveBook.joins(:primary_tags).where('active_tags.name="blue"')
+
+        it 'adds the association scope clause to the join' do
+          inner_join_pieces = subject.to_sql.split('INNER')
+          found = inner_join_pieces.any? do |line|
+            line =~ /\s+JOIN "active_taggings".+ON.+\."label" = 'primary'/
+          end
+          expect(found).to be_truthy
+        end
+        # This is slightly incorrect in AR 6.1+ (since the picked aliases for active_taggings tables vary)
+        # it_behaves_like 'subject_matches_sql', <<~SQL
+        #   SELECT "active_books".* FROM "active_books"
+        #     INNER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
+        #                 AND "active_taggings"."book_id" = "active_books"."id"
+        #     INNER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
+        #     WHERE ("/primary_tags"."name" = 'blue')
+        # SQL
+      end
+    end
+  end
+end