praxis 2.0.pre.29 → 2.0.pre.30

data/lib/praxis/multipart/part.rb

@@ -255,9 +255,9 @@ module Praxis
       self.content_type = original_content_type
     end
 
-    def self.dump_for_openapi(example_part)
+    def self.dump_for_openapi(_example_part)
       # TODO: This needs to be structured as OpenAPI requires it
-      raise "dumping a part for open api not implemented yet"
+      raise 'dumping a part for open api not implemented yet'
     end
   end
 end

data/lib/praxis/plugins/mapper_plugin.rb

@@ -54,10 +54,11 @@ module Praxis
           filters = request.params.filters if request.params.respond_to?(:filters)
           # Handle filters
           base_query = domain_model.craft_filter_query(base_query, filters: filters)
-          # Handle field and nested field selection
-          base_query = domain_model.craft_field_selection_query(base_query, selectors: selector_generator.selectors)
+
+          selectors = selector_generator.selectors
+          base_query = domain_model.craft_field_selection_query(base_query, selectors: selectors)
           # handle pagination and ordering if the pagination extention is included
-          base_query = domain_model.craft_pagination_query(base_query, pagination: _pagination) if respond_to?(:_pagination)
+          base_query = domain_model.craft_pagination_query(base_query, pagination: _pagination, selectors: selectors) if respond_to?(:_pagination)
 
           base_query
         end

data/lib/praxis/renderer.rb

@@ -12,7 +12,7 @@ module Praxis
         @context = context
 
         first = Attributor.humanize_context(context[0..10])
-        last = Attributor.humanize_context(context[-5..-1])
+        last = Attributor.humanize_context(context[-5..])
         pretty_context = "#{first}...#{last}"
         super("SystemStackError in rendering #{object.class} with context: #{pretty_context}")
       end

data/lib/praxis/routing_config.rb

@@ -25,7 +25,7 @@ module Praxis
       when ''
         @prefix_segments = []
       when ABSOLUTE_PATH_REGEX
-        @prefix_segments = Array(prefix[1..-1])
+        @prefix_segments = Array(prefix[1..])
       else
         @prefix_segments << prefix
       end

data/lib/praxis/tasks/console.rb

@@ -3,36 +3,31 @@
 namespace :praxis do
   desc 'Run interactive pry/irb console'
   task :console do
-    have_pry = false
-
-    begin
-      # Use pry if available; require pry _before_ environment to maximize
-      # debuggability.
-      require 'pry'
-      have_pry = true
-    rescue LoadError
-      # Fall back on irb
-      require 'irb'
-    end
+    # Use irb if available (which it almost always is).
+    require 'irb'
 
     Rake::Task['praxis:environment'].invoke
 
-    if have_pry
-      Praxis::Application.instance.pry
-    else
-      # Keep IRB.setup from complaining about bad ARGV options
-      old_argv = ARGV.dup
-      ARGV.clear
-      IRB.setup nil
-      ARGV.concat(old_argv)
+    # Keep IRB.setup from complaining about bad ARGV options
+    old_argv = ARGV.dup
+    ARGV.clear
+    IRB.setup nil
+    ARGV.concat(old_argv)
+
+    # Allow reentrant IRB
+    IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+    require 'irb/ext/multi-irb'
 
-      # Allow reentrant IRB
-      IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
-      require 'irb/ext/multi-irb'
+    # Remove main object from prompt (its stringify is not useful)
+    nickname = File.basename(::Praxis::Application.instance.root)
+    IRB.conf[:PROMPT][:DEFAULT] = {
+      PROMPT_I: "%N(#{nickname}):%03n:%i> ",
+      PROMPT_N: "%N(#{nickname}):%03n:%i> ",
+      PROMPT_S: "%N(#{nickname}):%03n:%i%l ",
+      PROMPT_C: "%N(#{nickname}):%03n:%i* "
+    }
 
-      # Use some special initialization magic to ensure that 'self' in the
-      # IRB session refers to Praxis::Application.instance.
-      IRB.irb(nil, Praxis::Application.instance)
-    end
+    # Set the IRB main object.
+    IRB.irb(nil, Praxis::Application.instance)
   end
 end

data/lib/praxis/types/multipart_array.rb

@@ -372,7 +372,7 @@ module Praxis
       end
 
       def self.dump_for_openapi(example)
-        example.map {|part| MultipartPart.dump_for_openapi(part)}
+        example.map { |part| MultipartPart.dump_for_openapi(part) }
       end
     end
   end

data/lib/praxis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Praxis
-  VERSION = '2.0.pre.29'
+  VERSION = '2.0.pre.30'
 end

data/lib/praxis.rb

@@ -49,6 +49,7 @@ module Praxis
 
   # Sort of part of the old Blueprints gem...but they're really not scoped...
   autoload :Blueprint, 'praxis/blueprint'
+  autoload :BlueprintAttributeGroup, 'praxis/blueprint_attribute_group'
   autoload :FieldExpander, 'praxis/field_expander'
   autoload :Renderer, 'praxis/renderer'
 

data/praxis.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.homepage = 'https://github.com/praxis/praxis'
   spec.license = 'MIT'
-  spec.required_ruby_version = '>=2.5'
+  spec.required_ruby_version = '>=2.7'
 
   spec.require_paths = ['lib']
   spec.files         = `git ls-files -z`.split("\x0")

data/spec/functional_library_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Functional specs for books with connected DB' do
+  def app
+    Praxis::Application.instance
+  end
+  let(:parsed_response) { JSON.parse(subject.body, symbolize_names: true) }
+  context 'books' do
+    context 'index' do
+      let(:filters_q) { '' }
+      let(:fields_q) { '' }
+      let(:order_q) { '' }
+      subject do
+        get '/api/books', api_version: '1.0', fields: fields_q, filters: filters_q, order: order_q
+      end
+
+      context 'all books' do
+        it 'is successful' do
+          expect(subject).to be_successful
+          expect(subject.headers['Content-Type']).to eq('application/vnd.acme.book; type=collection')
+          expect(parsed_response.size).to eq ActiveBook.count
+        end
+      end
+
+      context 'with deep fields including a group' do
+        let(:fields_q) { 'id,name,author{name,books{name}},tags,grouped{name,moar_tags}' }
+        it 'is successful' do
+          expect(subject).to be_successful
+          first_book = parsed_response.first
+          expect(first_book.keys).to match_array(%i[id name author tags grouped])
+          expect(first_book[:author].keys).to match_array(%i[name books])
+          expect(first_book[:grouped].keys).to match_array(%i[name moar_tags])
+          expect(first_book[:grouped][:name]).to eq(first_book[:name])
+          # grouped.moar_tags is exactly the same result as tags, but tucked in a group with a different name
+          expect(first_book[:grouped][:moar_tags]).to eq(first_book[:tags])
+        end
+      end
+
+      context 'with deep filters' do
+        let(:filters_q) { 'author.name=author*' }
+        it 'is successful' do
+          expect(subject).to be_successful
+          expect(parsed_response.size).to eq ActiveBook.joins(:author).where('active_authors.name LIKE "author%"').count
+        end
+      end
+      context 'with more deep filters' do
+        let(:filters_q) { 'tags.name=green' }
+        it 'is successful' do
+          expect(subject).to be_successful
+          num_books_with_green_tags = ActiveBook.joins(:tags).where('active_tags.name': 'green').count
+          expect(num_books_with_green_tags).to be > 0
+          expect(parsed_response.size).to eq num_books_with_green_tags
+        end
+      end
+
+      context 'with ordering' do
+        context 'by direct attribute' do
+          let(:order_q) { '-id' }
+          it 'is successful' do
+            expect(subject).to be_successful
+            expect(parsed_response.map { |book| book[:id] }).to eq ActiveBook.distinct.order('id DESC').pluck(:id)
+          end
+        end
+        context 'by nested attribute (but without any fields or filter using the attribute)' do
+          let(:order_q) { '-author.name' }
+          it 'is successful' do
+            expect(subject).to be_successful
+            ids = ActiveBook.distinct.left_outer_joins(:author).order('active_authors.name DESC').pluck(:id)
+
+            expect(parsed_response.map { |book| book[:id] }).to eq ids
+          end
+        end
+        context 'combined with filters' do
+          context 'by nested attribute (with fields using the same association, but not the same leaf)' do
+            let(:order_q) { '-author.name' }
+            let(:fields_q) { 'id,author{id}' }
+            it { expect(subject).to be_successful }
+          end
+
+          context 'by nested attribute (with a filter using the same association, but not the same leaf)' do
+            let(:order_q) { '-author.name' }
+            let(:filters_q) { 'author.id=1' }
+            it { expect(subject).to be_successful }
+          end
+
+          context 'by nested attribute (with a filter using the same association AND the same leaf)' do
+            let(:order_q) { '-author.name' }
+            let(:filters_q) { 'author.name=Author1' }
+            it { expect(subject).to be_successful }
+          end
+
+          context 'Using ! on a leaf also makes the order use the alias' do
+            let(:order_q) { '-author.name' }
+            let(:filters_q) { 'author.name!' }
+            it { expect(subject).to be_successful }
+          end
+
+          context 'Using ! on an overlapping association also makes the order use the alias' do
+            let(:order_q) { '-author.name' }
+            let(:filters_q) { 'id=1&author!&author.name!&tags.name=red' }
+            it { expect(subject).to be_successful }
+          end
+        end
+      end
+    end
+
+    context 'show' do
+      let(:fields_q) { '' }
+      subject do
+        get '/api/books/1', api_version: '1.0', fields: fields_q
+      end
+      it 'is successful' do
+        expect(subject).to be_successful
+        expect(parsed_response[:name]).to eq ActiveBook.find_by(id: 1).simple_name
+      end
+
+      context 'with grouped attributes' do
+        let(:fields_q) { 'id,grouped{id,name}' }
+        it 'is successful' do
+          expect(subject).to be_successful
+          model = ActiveBook.find_by(id: 1)
+          expect(parsed_response[:id]).to eq model.id
+          expect(parsed_response[:grouped]).to eq({ id: model.id, name: model.simple_name })
+        end
+
+        context 'it does not invoke the ones that are not rendered' do
+          let(:fields_q) { 'id,grouped{id}' }
+          it 'is successful' do
+            expect(subject).to be_successful
+          end
+        end
+      end
+    end
+  end
+
+  context 'authors (which have a base query that joins itself)' do
+    let(:filters_q) { '' }
+    let(:fields_q) { '' }
+    let(:order_q) { '' }
+    subject do
+      get '/api/authors', api_version: '1.0', fields: fields_q, filters: filters_q, order: order_q
+    end
+
+    context 'all authors' do
+      # Authors have a base query that restricts authors whom have books that start with 'book' and that reach authors with id > 0
+      let(:base_query) do
+        ActiveAuthor.joins(books: :author).where('active_books.simple_name LIKE ?', 'book%').where('authors_active_books.id > ?', 0)
+      end
+      it 'is successful' do
+        expect(subject).to be_successful
+        expect(subject.headers['Content-Type']).to eq('application/vnd.acme.author; type=collection')
+
+        expect(parsed_response.size).to eq base_query.count
+      end
+      context 'ordering' do
+        context 'using direct attributes' do
+          let(:order_q) { '-name,id' }
+          it { expect(subject).to be_successful }
+        end
+        context 'using nested attributes' do
+          let(:order_q) { '-name,books.name' }
+          it 'is successful' do
+            expect(subject).to be_successful
+            ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
+
+            expect(parsed_response.map { |book| book[:id] }).to eq ids
+          end
+        end
+      end
+      context 'filtering and sorting' do
+        context 'using the same tables, including the base query one' do
+          let(:order_q) { '-name,books.name' }
+          let(:filters_q) { 'books.name!' }
+          let(:fields_q) { 'id,books{name}' }
+          it 'is successful' do
+            expect(subject).to be_successful
+            ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
+
+            expect(parsed_response.map { |book| book[:id] }).to eq ids
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 
-require_relative '../support/spec_resources_active_model'
 require 'praxis/extensions/attribute_filtering'
 require 'praxis/extensions/attribute_filtering/active_record_filter_query_builder'
 
@@ -358,6 +357,17 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         SQL
       end
 
+      context 'adds multiple where clauses for same nested relationship join even if it is a ! or !! filter without a value (instead of multiple joins with 1 clause each)' do
+        let(:filters_string) { 'taggings!&(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"
+            LEFT OUTER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
+            WHERE ("/taggings"."id" IS NOT NULL) AND ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+        SQL
+      end
+
       context 'works well with ORs at a parent table along with joined associations with no rows' do
         let(:filters_string) { 'name=Book1005|category!!' }
         it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:category)

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

@@ -13,19 +13,22 @@ describe Praxis::Extensions::AttributeFiltering::FilterTreeNode do
       { name: 'rel1.a1', op: '=', value: 1 },
       { name: 'rel1.a2', op: '=', value: 2 },
       { name: 'rel1.rel2.b1', op: '=', value: 11 },
-      { name: 'rel1.rel2.b2', op: '=', value: 12, node_object: dummy_object }
+      { name: 'rel1.rel2.b2', op: '=', value: 12, node_object: dummy_object },
+      { name: 'rel3', op: '!', value: nil },
+      { name: 'rel4.rel5', op: '!', value: nil }
     ]
   end
   context 'initialization' do
     subject { described_class.new(filters) }
     it 'holds the top conditions and the child in a TreeNode' do
       expect(subject.path).to eq([])
-      expect(subject.conditions.size).to eq(2)
+      expect(subject.conditions.size).to eq(3)
       expect(subject.conditions.map { |i| i.slice(:name, :op, :value) }).to eq([
                                                                                  { name: 'one', op: '>', value: 1 },
-                                                                                 { name: 'one', op: '<', value: 10 }
+                                                                                 { name: 'one', op: '<', value: 10 },
+                                                                                 { name: 'rel3', op: '!', value: nil }
                                                                                ])
-      expect(subject.children.keys).to eq(['rel1'])
+      expect(subject.children.keys).to eq(%w[rel1 rel4])
       expect(subject.children['rel1']).to be_kind_of(described_class)
     end
 
@@ -54,6 +57,15 @@ describe Praxis::Extensions::AttributeFiltering::FilterTreeNode do
                                                                                   { name: 'b2', op: '=', value: 12 }
                                                                                 ])
       expect(rel1rel2.children.keys).to be_empty
+
+      # ! operators have the condition on the association, not the leaf (i.e,. have a condition, no children)
+      rel4 = subject.children['rel4']
+      expect(rel4.path).to eq(['rel4'])
+      expect(rel4.conditions.size).to eq(1)
+      expect(rel4.conditions.map { |i| i.slice(:name, :op, :value) }).to eq([
+                                                                              { name: 'rel5', op: '!', value: nil }
+                                                                            ])
+      expect(rel4.children.keys).to be_empty
     end
   end
 end

data/spec/praxis/extensions/field_selection/active_record_query_selector_spec.rb

@@ -2,8 +2,6 @@
 
 require 'spec_helper'
 
-require_relative '../support/spec_resources_active_model'
-
 describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
   let(:selector_fields) do
     {

data/spec/praxis/extensions/field_selection/sequel_query_selector_spec.rb

@@ -40,8 +40,6 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
   # Pay the price for creating and connecting only in this spec instead in spec helper
   # this way all other specs do not need to be slower and it's a better TDD experience
 
-  require_relative '../support/spec_resources_sequel'
-
   let(:selector_fields) do
     {
       name: true,

data/spec/praxis/extensions/pagination/active_record_pagination_handler_spec.rb

@@ -2,31 +2,26 @@
 
 require 'spec_helper'
 
-require_relative '../support/spec_resources_active_model'
 require 'praxis/extensions/pagination'
 
-class Book < Praxis::MediaType
-  attributes do
-    attribute :id, Integer
-    attribute :simple_name, String
-    attribute :category_uuid, String
+describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
+  let(:book_pagination_params_attribute) do
+    Attributor::Attribute.new(Praxis::Types::PaginationParams.for(Book)) do
+      max_items 3
+      page_size 2
+      #   disallow :paging
+      default by: :id
+    end
   end
-end
-Book.finalize!
-BookPaginationParamsAttribute = Attributor::Attribute.new(Praxis::Types::PaginationParams.for(Book)) do
-  max_items 3
-  page_size 2
-  #   disallow :paging
-  default by: :id
-end
 
-BookOrderingParamsAttribute = Attributor::Attribute.new(Praxis::Types::OrderingParams.for(Book)) do
-  enforce_for :all
-end
+  let(:book_ordering_params_attribute) do
+    Attributor::Attribute.new(Praxis::Types::OrderingParams.for(Book)) do
+      enforce_for :all
+    end
+  end
 
-describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
   shared_examples 'sorts_the_same' do |op, expected|
-    let(:order_params) { BookOrderingParamsAttribute.load(op) }
+    let(:order_params) { book_ordering_params_attribute.load(op) }
     it do
       loaded_ids = subject.all.map(&:id)
       expected_ids = expected.all.map(&:id)
@@ -35,7 +30,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
   end
 
   shared_examples 'paginates_the_same' do |par, expected|
-    let(:paginator_params) { BookPaginationParamsAttribute.load(par) }
+    let(:paginator_params) { book_pagination_params_attribute.load(par) }
     it do
       loaded_ids = subject.all.map(&:id)
       expected_ids = expected.all.map(&:id)
@@ -43,7 +38,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
     end
   end
 
-  let(:query) { ActiveBook }
+  let(:query) { ActiveBook.includes(:author) }
   let(:table) { ActiveBook.table_name }
   let(:paginator_params) { nil }
   let(:order_params) { nil }
@@ -52,7 +47,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
   end
 
   context '.paginate' do
-    subject { described_class.paginate(query, pagination) }
+    subject { described_class.paginate(query, pagination, root_resource: ActiveBookResource) }
 
     context 'empty struct' do
       let(:paginator_params) { nil }
@@ -93,7 +88,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
     end
 
     context 'including order' do
-      let(:order_params) { BookOrderingParamsAttribute.load(op_string) }
+      let(:order_params) { book_ordering_params_attribute.load(op_string) }
 
       context 'when compatible with cursor' do
         let(:op_string) { 'id' }
@@ -104,7 +99,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
 
       context 'when incompatible with cursor' do
         let(:op_string) { 'id' }
-        let(:paginator_params) { BookPaginationParamsAttribute.load('by=simple_name,items=3') }
+        let(:paginator_params) { book_pagination_params_attribute.load('by=simple_name,items=3') }
         it do
           expect { subject.all }.to raise_error(described_class::PaginationException, /is incompatible with pagination/)
         end
@@ -113,7 +108,7 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
   end
 
   context '.order' do
-    subject { described_class.order(query, pagination.order) }
+    subject { described_class.order(query, pagination.order, root_resource: ActiveBookResource) }
 
     it 'does not change the query with an empty struct' do
       expect(subject).to be(query)
@@ -127,5 +122,96 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
                     ::ActiveBook.order(simple_name: :desc, id: :asc)
     it_behaves_like 'sorts_the_same', '-simple_name,-id',
                     ::ActiveBook.order(simple_name: :desc, id: :desc)
+
+    context 'inner joining authors' do
+      let(:query) { ActiveBook.joins(:author) }
+      it_behaves_like 'sorts_the_same', '-author.name',
+                      ::ActiveBook.joins(:author).references(:author).order('active_authors.name': :desc)
+    end
+
+    context 'with mapped order fields' do
+      it_behaves_like 'sorts_the_same', 'name', # name => simple_name
+                      ::ActiveBook.order(simple_name: :asc)
+
+      context 'with deeper joins that map names' do
+        let(:query) { ActiveBook.joins(:author) }
+        context 'of intermediate associations (writer => author)' do
+          it_behaves_like 'sorts_the_same', '-writer.name',
+                          ::ActiveBook.joins(:author).references(:author).order('active_authors.name': :desc)
+        end
+        context 'of leaf properties (display_name => name)' do
+          it_behaves_like 'sorts_the_same', '-author.display_name',
+                          ::ActiveBook.joins(:author).references(:author).order('active_authors.name': :desc)
+        end
+        context 'of both intermediate and leaf properties ((writer => author AND display_name => name)' do
+          it_behaves_like 'sorts_the_same', '-writer.display_name,author.id,',
+                          ::ActiveBook.joins(:author).references(:author).order('active_authors.name': :desc, 'active_authors.id': :asc)
+        end
+        context 'of deep associations' do
+          it_behaves_like 'sorts_the_same', '-writer.books.name,author.id',
+                          ::ActiveBook.joins(author: :books).references(:author, 'books_active_authors')
+                                      .order('books_active_authors.simple_name': :desc, 'active_authors.id': :asc)
+        end
+      end
+    end
+  end
+
+  context '.association_info_for' do
+    let(:resource) { Resources::Book }
+    subject { described_class.association_info_for(resource, path.split('.')) }
+    context 'book -> author.name' do
+      let(:path) { 'author.name' }
+      it 'works' do
+        expect(subject).to eq({
+                                resource: Resources::Author,
+                                includes: { 'author' => {} },
+                                attribute: 'name'
+                              })
+      end
+    end
+
+    context 'book -> taggings.tag.name' do
+      let(:path) { 'taggings.tag.name' }
+      it 'works' do
+        expect(subject).to eq({
+                                resource: Resources::Tag,
+                                includes: { 'taggings' => { 'tag' => {} } },
+                                attribute: 'name'
+                              })
+      end
+    end
+    context 'book -> tags' do
+      let(:path) { 'tags' }
+      it 'works' do
+        expect(subject).to eq({
+                                resource: Resources::Tag,
+                                includes: { 'tags' => {} },
+                                attribute: nil
+                              })
+      end
+    end
+
+    context 'with mapped/aliased names' do
+      context 'book -> writer.name' do
+        let(:path) { 'writer.name' }
+        it 'works' do
+          expect(subject).to eq({
+                                  resource: Resources::Author,
+                                  includes: { 'author' => {} },
+                                  attribute: 'name'
+                                })
+        end
+      end
+      context 'book -> writer.name' do
+        let(:path) { 'writer.display_name' }
+        it 'works' do
+          expect(subject).to eq({
+                                  resource: Resources::Author,
+                                  includes: { 'author' => {} },
+                                  attribute: 'name'
+                                })
+        end
+      end
+    end
   end
 end