praxis 2.0.pre.18 → 2.0.pre.19

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

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require 'praxis/extensions/field_selection'
 
 describe Praxis::Extensions::FieldSelection::FieldSelector do
-
   let(:type) { described_class.for(Address) }
 
-
   subject(:field_selector) { type.load(fields) }
 
   context '.example' do
@@ -21,7 +21,6 @@ describe Praxis::Extensions::FieldSelection::FieldSelector do
     it 'validates' do
       expect(type.example.validate).to be_empty
     end
-
   end
 
   context '.load' do
@@ -32,22 +31,20 @@ describe Praxis::Extensions::FieldSelection::FieldSelector do
       expect(type.load('').fields).to be(true)
     end
 
-
     it 'loads fields' do
       fields = 'id,name,owner{name}'
 
-      expect(Attributor::FieldSelector).to receive(:load).
-        with(fields).and_return(parsed_fields)
+      expect(Attributor::FieldSelector).to receive(:load)
+        .with(fields).and_return(parsed_fields)
 
       result = type.load(fields)
       expect(result.fields).to be parsed_fields
     end
-
   end
 
   context '#dump' do
     it 'is dumpable' do
-      expect( type.load('id') ).to be_kind_of( Attributor::Dumpable )
+      expect(type.load('id')).to be_kind_of(Attributor::Dumpable)
     end
 
     it 'dumps nested fields properly' do
@@ -72,14 +69,13 @@ describe Praxis::Extensions::FieldSelection::FieldSelector do
     context 'validating subattributes' do
       let(:selector_string) { 'id,resident,owner{age}' }
       it 'validates subattributes' do
-        errors =  type.validate(selector_string)
+        errors = type.validate(selector_string)
         expect(errors).to match_array([
-          "Attribute with name resident not found in Address",
-          "Attribute with name age not found in Person"
-        ])
+                                        'Attribute with name resident not found in Address',
+                                        'Attribute with name age not found in Person'
+                                      ])
       end
     end
-
   end
 
   context '#validate' do
@@ -90,7 +86,4 @@ describe Praxis::Extensions::FieldSelection::FieldSelector do
       expect(type.validate('id,owner{foo}')).to have(1).items
     end
   end
-
-
-
 end

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

@@ -1,46 +1,49 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'sequel'
 
 require 'praxis/extensions/field_selection/sequel_query_selector'
 
+class QTest
+  attr_reader :object, :cols
 
-describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
-  class Q
-    attr_reader :object, :cols
-    def initialize
-      @object = {}
-      @cols = []
-    end
-    def eager(hash)
-      raise "we are only calling eager one at a time!" if hash.keys.size > 1
-      name = hash.keys.first
-      # Actually call the incoming proc with an instance of Q, to collect the further select/eager calls
-      @object[name] = hash[name].call(Q.new)
-      self
-    end
-    def select(*names)
-      @cols += names.map(&:column)
-      self
-    end
-    def dump
-      eagers = @object.each_with_object({}) do |(name, val), hash|
-        hash[name] = val.dump
-      end
-      {
-        columns: @cols,
-        eagers: eagers
-      }
-    end
+  def initialize
+    @object = {}
+    @cols = []
+  end
+
+  def eager(hash)
+    raise 'we are only calling eager one at a time!' if hash.keys.size > 1
+
+    name = hash.keys.first
+    # Actually call the incoming proc with an instance of QTest, to collect the further select/eager calls
+    @object[name] = hash[name].call(QTest.new)
+    self
+  end
+
+  def select(*names)
+    @cols += names.map(&:column)
+    self
   end
 
+  def dump
+    eagers = @object.transform_values(&:dump)
+    {
+      columns: @cols,
+      eagers: eagers
+    }
+  end
+end
 
+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.rb'
-  
+  require_relative '../support/spec_resources_sequel'
+
   let(:selector_fields) do
-    { 
+    {
       name: true,
       other_model: {
         id: true
@@ -64,15 +67,15 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
     ]
   end
 
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields).selectors  }
-  subject {described_class.new(query: query, selectors: selector_node, debug: debug) }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource, selector_fields).selectors }
+  subject { described_class.new(query: query, selectors: selector_node, debug: debug) }
 
   context 'generate' do
     let(:debug) { false }
     context 'using the real models and DB' do
       let(:query) { SequelSimpleModel }
 
-      it 'calls the select columns for the top level, and includes the right association hashes' do      
+      it 'calls the select columns for the top level, and includes the right association hashes' do
         ds = subject.generate
         opts = ds.opts
         # Top model is our simplemodel
@@ -80,26 +83,26 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
         selected_column_names = opts[:select].map(&:column)
         expect(selected_column_names).to match_array(expected_select_from_to_query)
         # 2 Eager loaded associations as well
-        expect(opts[:eager].keys).to match_array([:other_model, :parent, :tags])
+        expect(opts[:eager].keys).to match_array(%i[other_model parent tags])
         # We can not introspect those eagers, as they are procs...but at least validate they are
         expect(opts[:eager][:other_model]).to be_a Proc
         expect(opts[:eager][:parent]).to be_a Proc
-        
+
         # Also, let's make sure the query actually works by making Sequel attempt to retrieve it and finding the right things.
         result = ds.all
         # 2 simple models
-        expect(result.size).to be 2 
+        expect(result.size).to be 2
         # First simple model points to other_model 11 and parent 1
-        simple_one = result.find{|i| i.id == 1}
+        simple_one = result.find { |i| i.id == 1 }
         expect(simple_one.other_model.id).to be 11
         expect(simple_one.parent.id).to be 1
         # also, its' parent in turn has 2 children (1 and 2) linked by its parent_uuid
-        expect(simple_one.parent.children.map(&:id)).to match_array([1,2])
+        expect(simple_one.parent.children.map(&:id)).to match_array([1, 2])
         # Has the blue and red tags
-        expect(simple_one.tags.map(&:tag_name)).to match_array(['blue','red'])
+        expect(simple_one.tags.map(&:tag_name)).to match_array(%w[blue red])
 
         # second simple model points to other_model 22 and parent 2
-        simple_two = result.find{|i| i.id == 2}
+        simple_two = result.find { |i| i.id == 2 }
         expect(simple_two.other_model.id).to be 22
         expect(simple_two.parent.id).to be 2
         # also, its' parent in turn has no children (as no simple models point to it by uuid)
@@ -112,36 +115,34 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
           # Actually make it run all the way...but suppressing the output
           subject.generate
         end
-      end 
+      end
     end
     context 'just mocking the query' do
-      let(:query) { Q.new }
+      let(:query) { QTest.new }
 
-      it 'creates the right recursive lambdas for the eager loading' do      
-        
+      it 'creates the right recursive lambdas for the eager loading' do
         ds = subject.generate
         result = ds.dump
         expect(result[:columns]).to match_array(expected_select_from_to_query)
         # 2 eager loads
-        expect(result[:eagers].keys).to match_array([:other_model, :parent, :tags])
+        expect(result[:eagers].keys).to match_array(%i[other_model parent tags])
         # 1 - other model
         other_model_eagers = result[:eagers][:other_model]
         expect(other_model_eagers[:columns]).to match_array([:id])
 
         # 2 - parent association
         parent_eagers = result[:eagers][:parent]
-        expect(parent_eagers[:columns]).to match_array([:id,:uuid]) # uuid is necessary for the "children" assoc
+        expect(parent_eagers[:columns]).to match_array(%i[id uuid]) # uuid is necessary for the "children" assoc
         expect(parent_eagers[:eagers].keys).to match_array([:children])
         # 2.1 - children association off of the parent
         parent_children_eagers = parent_eagers[:eagers][:children]
-        expect(parent_children_eagers[:columns]).to match_array([:id,:parent_uuid]) # parent_uuid is required for the assoc
+        expect(parent_children_eagers[:columns]).to match_array(%i[id parent_uuid]) # parent_uuid is required for the assoc
         expect(parent_children_eagers[:eagers]).to be_empty
 
         # 3 - tags association
         tags_eagers = result[:eagers][:tags]
-        expect(tags_eagers[:columns]).to match_array([:id, :tag_name]) # uuid is necessary for the "children" assoc
+        expect(tags_eagers[:columns]).to match_array(%i[id tag_name]) # uuid is necessary for the "children" assoc
         expect(tags_eagers[:eagers].keys).to be_empty
-        
       end
     end
   end

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-require_relative '../support/spec_resources_active_model.rb'
+require_relative '../support/spec_resources_active_model'
 require 'praxis/extensions/pagination'
 
 class Book < Praxis::MediaType
@@ -15,7 +17,7 @@ BookPaginationParamsAttribute = Attributor::Attribute.new(Praxis::Types::Paginat
   max_items 3
   page_size 2
   #   disallow :paging
-  default by: :id  
+  default by: :id
 end
 
 BookOrderingParamsAttribute = Attributor::Attribute.new(Praxis::Types::OrderingParams.for(Book)) do
@@ -49,10 +51,9 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
     Praxis::Extensions::Pagination::PaginationStruct.new(paginator_params, order_params)
   end
 
-  
   context '.paginate' do
-    subject {described_class.paginate(query, pagination) }
-    
+    subject { described_class.paginate(query, pagination) }
+
     context 'empty struct' do
       let(:paginator_params) { nil }
 
@@ -63,68 +64,68 @@ describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
 
     context 'page-based' do
       it_behaves_like 'paginates_the_same', 'page=1,items=3',
-        ::ActiveBook.limit(3)
+                      ::ActiveBook.limit(3)
       it_behaves_like 'paginates_the_same', 'page=2,items=3',
-        ::ActiveBook.offset(3).limit(3)
+                      ::ActiveBook.offset(3).limit(3)
     end
 
     context 'page-based with defaults' do
       it_behaves_like 'paginates_the_same', '',
-        ::ActiveBook.offset(0).limit(2)
+                      ::ActiveBook.offset(0).limit(2)
       it_behaves_like 'paginates_the_same', 'page=2',
-        ::ActiveBook.offset(2).limit(2)
+                      ::ActiveBook.offset(2).limit(2)
     end
 
     context 'cursor-based' do
       it_behaves_like 'paginates_the_same', 'by=id,items=3',
-        ::ActiveBook.limit(3).order(id: :asc)
+                      ::ActiveBook.limit(3).order(id: :asc)
       it_behaves_like 'paginates_the_same', 'by=id,from=1000,items=3',
-        ::ActiveBook.where("id > 1000").limit(3).order(id: :asc)
+                      ::ActiveBook.where('id > 1000').limit(3).order(id: :asc)
       it_behaves_like 'paginates_the_same', 'by=simple_name,from=Book1000,items=3',
-        ::ActiveBook.where("simple_name > 'Book1000'").limit(3).order(simple_name: :asc)
+                      ::ActiveBook.where("simple_name > 'Book1000'").limit(3).order(simple_name: :asc)
     end
 
     context 'cursor-based with defaults' do
       it_behaves_like 'paginates_the_same', '',
-        ::ActiveBook.limit(2).order(id: :asc)
+                      ::ActiveBook.limit(2).order(id: :asc)
       it_behaves_like 'paginates_the_same', 'by=id,from=1000',
-        ::ActiveBook.where("id > 1000").limit(2).order(id: :asc)
+                      ::ActiveBook.where('id > 1000').limit(2).order(id: :asc)
     end
 
     context 'including order' do
       let(:order_params) { BookOrderingParamsAttribute.load(op_string) }
 
       context 'when compatible with cursor' do
-        let(:op_string){ 'id'}
+        let(:op_string) { 'id' }
         # Compatible cursor field
         it_behaves_like 'paginates_the_same', 'by=id,items=3',
-          ::ActiveBook.limit(3).order(id: :asc)
+                        ::ActiveBook.limit(3).order(id: :asc)
       end
-  
+
       context 'when incompatible with cursor' do
-        let(:op_string){ 'id'}
+        let(:op_string) { 'id' }
         let(:paginator_params) { BookPaginationParamsAttribute.load('by=simple_name,items=3') }
-        it do          
-          expect{subject.all}.to raise_error(described_class::PaginationException, /is incompatible with pagination/)
+        it do
+          expect { subject.all }.to raise_error(described_class::PaginationException, /is incompatible with pagination/)
         end
       end
     end
   end
 
-  context '.order' do  
-    subject {described_class.order(query, pagination.order) }
-    
+  context '.order' do
+    subject { described_class.order(query, pagination.order) }
+
     it 'does not change the query with an empty struct' do
       expect(subject).to be(query)
     end
 
-    it_behaves_like 'sorts_the_same', 'simple_name', 
-      ::ActiveBook.order(simple_name: :asc)
-    it_behaves_like 'sorts_the_same', '-simple_name', 
-      ::ActiveBook.order(simple_name: :desc)
-    it_behaves_like 'sorts_the_same', '-simple_name,id', 
-      ::ActiveBook.order(simple_name: :desc, id: :asc)        
-    it_behaves_like 'sorts_the_same', '-simple_name,-id', 
-      ::ActiveBook.order(simple_name: :desc, id: :desc)
+    it_behaves_like 'sorts_the_same', 'simple_name',
+                    ::ActiveBook.order(simple_name: :asc)
+    it_behaves_like 'sorts_the_same', '-simple_name',
+                    ::ActiveBook.order(simple_name: :desc)
+    it_behaves_like 'sorts_the_same', '-simple_name,id',
+                    ::ActiveBook.order(simple_name: :desc, id: :asc)
+    it_behaves_like 'sorts_the_same', '-simple_name,-id',
+                    ::ActiveBook.order(simple_name: :desc, id: :desc)
   end
 end

data/spec/praxis/extensions/rendering_spec.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Extensions::Rendering do
-
   let(:test_class) do
-    Struct.new(:media_type, :expanded_fields, :response, :request) do |klass|
+    Struct.new(:media_type, :expanded_fields, :response, :request) do |_klass|
       include Praxis::Extensions::Rendering
     end
   end
 
   let(:media_type) { Person }
-  let(:expanded_fields) { {id: true, name: true} }
+  let(:expanded_fields) { { id: true, name: true } }
   let(:response) { double('response', headers: {}) }
   let(:request) { double('request') }
 
-  let(:object) { {id: '1', name: 'bob', href: '/people/bob'} }
+  let(:object) { { id: '1', name: 'bob', href: '/people/bob' } }
   subject(:instance) { test_class.new(media_type, expanded_fields, response, request) }
 
   context '#render' do
@@ -26,7 +27,7 @@ describe Praxis::Extensions::Rendering do
   context '#display' do
     context 'without exception' do
       before do
-        expect(response).to receive(:body=).with({id: 1, name: 'bob'})
+        expect(response).to receive(:body=).with({ id: 1, name: 'bob' })
       end
 
       subject!(:output) { instance.display(object) }
@@ -43,15 +44,15 @@ describe Praxis::Extensions::Rendering do
     context 'with a rendering exception' do
       let(:handler_params) do
         {
-          summary: "Circular Rendering Error when rendering response. " +
-                 "Please especify a view to narrow the dependent fields, or narrow your field set.",
+          summary: 'Circular Rendering Error when rendering response. ' \
+            'Please especify a view to narrow the dependent fields, or narrow your field set.',
           exception: circular_exception,
           request: request,
           stage: :action,
           errors: nil
         }
       end
-      let(:circular_exception){ Praxis::Renderer::CircularRenderingError.new(object, "ctx") }
+      let(:circular_exception) { Praxis::Renderer::CircularRenderingError.new(object, 'ctx') }
       it 'catches a circular rendering exception' do
         expect(instance).to receive(:render).and_raise(circular_exception)
         expect(Praxis::Application.instance.validation_handler).to receive(:handle!).with(handler_params)
@@ -59,5 +60,4 @@ describe Praxis::Extensions::Rendering do
       end
     end
   end
-
 end

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
 require 'praxis/mapper/active_model_compat'
 
 # Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the  models in this file
 def create_tables
-
   ActiveRecord::Base.establish_connection(
-      adapter:  'sqlite3',
-      dbfile:  ':memory:',
-      database: ':memory:'
+    adapter: 'sqlite3',
+    dbfile: ':memory:',
+    database: ':memory:'
   )
-  
+
   ActiveRecord::Schema.define do
     ActiveRecord::Migration.suppress_messages do
       create_table :active_books do |table|
@@ -19,20 +20,20 @@ def create_tables
         table.column :category_uuid, :string
         table.column :author_id, :integer
       end
-  
+
       create_table :active_authors do |table|
         table.column :name, :string
       end
-  
+
       create_table :active_categories do |table|
         table.column :uuid, :string
         table.column :name, :string
       end
-  
+
       create_table :active_tags do |table|
         table.column :name, :string
       end
-  
+
       create_table :active_taggings do |table|
         table.column :book_id, :integer
         table.column :tag_id, :integer
@@ -51,7 +52,7 @@ class ActiveBook < ActiveRecord::Base
   belongs_to :author, class_name: 'ActiveAuthor'
 
   has_many :taggings, class_name: 'ActiveTagging', foreign_key: :book_id
-  has_many :primary_taggings, lambda { where(label: 'primary')}, class_name: 'ActiveTagging', foreign_key: :book_id
+  has_many :primary_taggings, -> { where(label: 'primary') }, class_name: 'ActiveTagging', foreign_key: :book_id
 
   has_many :tags, class_name: 'ActiveTag', through: :taggings
   has_many :primary_tags, class_name: 'ActiveTag', through: :primary_taggings, source: :tag
@@ -79,7 +80,6 @@ class ActiveTagging < ActiveRecord::Base
   belongs_to :tag, class_name: 'ActiveTag', foreign_key: :tag_id
 end
 
-
 # A set of resource classes for use in specs
 class ActiveBaseResource < Praxis::Mapper::Resource
 end
@@ -102,63 +102,47 @@ class ActiveBookResource < ActiveBaseResource
   model ActiveBook
 
   filters_mapping(
-    id: :id,
-    # category_uuid: :category_uuid  #NOTE: we do not need to define same-name-mappings if they exist
     'fake_nested.name': 'simple_name',
     'name': 'simple_name',
     'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing
-      { name: :simple_name, value: spec[:value] , op: '!=' } # Can be an array for multiple conditions as well
-      end,
-    'author.id': 'author.id',
-    'author.name': 'author.name',
-    'taggings.label': 'taggings.label',
-    'taggings.tag_id': 'taggings.tag_id',
-    'taggings.tag.taggings.tag_id': 'taggings.tag.taggings.tag_id',
-    'tags.name': 'tags.name',
-    'primary_tags.name': 'primary_tags.name',
-    'category.name': 'category.name',
-    'category.books.name': 'category.books.simple_name',
-    'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
-    'category.books.taggings.label': 'category.books.taggings.label',
-    'primary_tags': 'primary_tags',
-    'category.books.taggings': 'category.books.taggings',
+                     { name: :simple_name, value: spec[:value], op: '!=' } # Can be an array for multiple conditions as well
+                   end,
+    'category.books.name': 'category.books.simple_name'
   )
   # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate
-  property :author, dependencies: [:author, :added_column, :author_id]
+  property :author, dependencies: %i[author added_column author_id]
 
   property :name, dependencies: [:simple_name]
 end
 
-
 def seed_data
-  cat1 = ActiveCategory.create( id: 1 , uuid: 'deadbeef1', name: 'cat1' )
-  cat2 = ActiveCategory.create( id: 2 , uuid: 'deadbeef2', name: 'cat2' )
-  
-  author1 = ActiveAuthor.create(  id: 11, name: 'author1' )
-  author2 = ActiveAuthor.create(  id: 22, name: 'author2' )
-  author3 = ActiveAuthor.create(  id: 33, name: nil )
-  
-  tag_blue = ActiveTag.create(id: 1 , name: 'blue' )
-  tag_red = ActiveTag.create(id: 2 , name: 'red' )
-  tag_green = ActiveTag.create(id: 3 , name: 'green' )
-
-  book1 = ActiveBook.create( id: 1 , simple_name: 'Book1', category_uuid: 'deadbeef1')
+  cat1 = ActiveCategory.create(id: 1, uuid: 'deadbeef1', name: 'cat1')
+  cat2 = ActiveCategory.create(id: 2, uuid: 'deadbeef2', name: 'cat2')
+
+  author1 = ActiveAuthor.create(id: 11, name: 'author1')
+  author2 = ActiveAuthor.create(id: 22, name: 'author2')
+  author3 = ActiveAuthor.create(id: 33, name: nil)
+
+  tag_blue = ActiveTag.create(id: 1, name: 'blue')
+  tag_red = ActiveTag.create(id: 2, name: 'red')
+  tag_green = ActiveTag.create(id: 3, name: 'green')
+
+  book1 = ActiveBook.create(id: 1, simple_name: 'Book1', category_uuid: 'deadbeef1')
   book1.author = author1
   book1.category = cat1
   book1.save
   ActiveTagging.create(book: book1, tag: tag_blue, label: 'primary')
   ActiveTagging.create(book: book1, tag: tag_red)
   ActiveTagging.create(book: book1, tag: tag_green, label: 'primary')
-  
 
-  book2 = ActiveBook.create( id: 2 , simple_name: 'Book2', category_uuid: 'deadbeef1')
+  book2 = ActiveBook.create(id: 2, simple_name: 'Book2', category_uuid: 'deadbeef1')
   book2.author = author2
   book2.category = cat2
   book2.save
   ActiveTagging.create(book: book2, tag: tag_red, label: 'primary')
 
-  book3 = ActiveBook.create( id: 3 , simple_name: 'Book3', category_uuid: 'deadbeef1')
+  book3 = ActiveBook.create(id: 3, simple_name: 'Book3', category_uuid: 'deadbeef1')
   book3.author = author3
   book3.save
   ActiveTagging.create(book: book3, tag: tag_red, label: 'primary')
@@ -166,10 +150,9 @@ def seed_data
   # More stuff
 
   10.times do |i|
-    bid = 1000+i
-    ActiveBook.create( id: bid , simple_name: "Book#{bid}")
+    bid = 1000 + i
+    ActiveBook.create(id: bid, simple_name: "Book#{bid}")
   end
-
 end
 
-seed_data
+seed_data