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

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

@@ -1,56 +1,57 @@
+# frozen_string_literal: true
+
 require 'sequel'
 
 require 'praxis/mapper/sequel_compat'
 
-
 # Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the sequel models in this file
 def create_and_seed_tables
-    sequeldb = Sequel.sqlite 
-    # sequeldb.loggers = [Logger.new($stdout)] # Uncomment to see sequel logs
-
-    sequeldb.create_table! :sequel_simple_models do
-      primary_key :id
-      String :simple_name
-      Integer :parent_id
-      String :parent_uuid
-      Integer :other_model_id
-      String :added_column
+  sequeldb = Sequel.sqlite
+  # sequeldb.loggers = [Logger.new($stdout)] # Uncomment to see sequel logs
+
+  sequeldb.create_table! :sequel_simple_models do
+    primary_key :id
+    String :simple_name
+    Integer :parent_id
+    String :parent_uuid
+    Integer :other_model_id
+    String :added_column
+  end
+  sequeldb.create_table! :sequel_other_models do
+    primary_key :id
+  end
+  sequeldb.create_table! :sequel_parent_models do
+    primary_key :id
+    String :uuid
+  end
+  sequeldb.create_table! :sequel_tag_models do
+    primary_key :id
+    String :tag_name
+  end
+  sequeldb.create_table! :sequel_simple_models_sequel_tag_models do
+    Integer :sequel_simple_model_id
+    Integer :tag_id
   end
-    sequeldb.create_table! :sequel_other_models do
-      primary_key :id
-    end
-    sequeldb.create_table! :sequel_parent_models do
-      primary_key :id
-      String :uuid
-    end
-    sequeldb.create_table! :sequel_tag_models do
-      primary_key :id
-      String :tag_name
-    end
-    sequeldb.create_table! :sequel_simple_models_sequel_tag_models do
-      Integer :sequel_simple_model_id
-      Integer :tag_id
-    end
-
-    sequeldb[:sequel_parent_models] << { id: 1 , uuid: 'deadbeef1'}
-    sequeldb[:sequel_parent_models] << { id: 2 , uuid: 'deadbeef2'}
-    
-    sequeldb[:sequel_other_models] << { id: 11 }
-    sequeldb[:sequel_other_models] << { id: 22 }
-
-    sequeldb[:sequel_tag_models] << { id: 1 , tag_name: 'blue' }
-    sequeldb[:sequel_tag_models] << { id: 2 , tag_name: 'red' }
-
-    # Simple model 1 is tagged as blue and red
-    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 1 }
-    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 2 }
-    # Simple model 2 is tagged as red
-    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 2, tag_id: 2 }
-
-    # It's weird to have a parent id and parent uuid (which points to different actual parents)
-    # But it allows us to check pointing to both PKs and not PK columns
-    sequeldb[:sequel_simple_models] << { id: 1 , simple_name: 'Simple1', parent_id: 1, other_model_id: 11, parent_uuid: 'deadbeef1'}
-    sequeldb[:sequel_simple_models] << { id: 2 , simple_name: 'Simple2', parent_id: 2, other_model_id: 22, parent_uuid: 'deadbeef1'}
+
+  sequeldb[:sequel_parent_models] << { id: 1, uuid: 'deadbeef1' }
+  sequeldb[:sequel_parent_models] << { id: 2, uuid: 'deadbeef2' }
+
+  sequeldb[:sequel_other_models] << { id: 11 }
+  sequeldb[:sequel_other_models] << { id: 22 }
+
+  sequeldb[:sequel_tag_models] << { id: 1, tag_name: 'blue' }
+  sequeldb[:sequel_tag_models] << { id: 2, tag_name: 'red' }
+
+  # Simple model 1 is tagged as blue and red
+  sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 1 }
+  sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 2 }
+  # Simple model 2 is tagged as red
+  sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 2, tag_id: 2 }
+
+  # It's weird to have a parent id and parent uuid (which points to different actual parents)
+  # But it allows us to check pointing to both PKs and not PK columns
+  sequeldb[:sequel_simple_models] << { id: 1, simple_name: 'Simple1', parent_id: 1, other_model_id: 11, parent_uuid: 'deadbeef1' }
+  sequeldb[:sequel_simple_models] << { id: 2, simple_name: 'Simple2', parent_id: 2, other_model_id: 22, parent_uuid: 'deadbeef1' }
 end
 
 create_and_seed_tables
@@ -76,7 +77,6 @@ class SequelTagModel < Sequel::Model
   include Praxis::Mapper::SequelCompat
 end
 
-
 # A set of resource classes for use in specs
 class SequelBaseResource < Praxis::Mapper::Resource
 end
@@ -100,7 +100,7 @@ class SequelSimpleResource < SequelBaseResource
 
   # Forces to add an extra column (added_column)...and yet another (parent_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate
-  property :parent, dependencies: [:parent, :added_column, :parent_id]
+  property :parent, dependencies: %i[parent added_column parent_id]
 
   property :name, dependencies: [:simple_name]
 end

data/spec/praxis/field_expander_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::FieldExpander do
   let(:field_expander) { Praxis::FieldExpander.new }
   let(:expanded_person_default_fieldset) do
     # The only ones that are not already leaves is the full name, which can expand to first, last
-    PersonBlueprint.default_fieldset.merge!(full_name: {first: true, last: true})
+    PersonBlueprint.default_fieldset.merge!(full_name: { first: true, last: true })
   end
   let(:expanded_address_default_fieldset) do
     # AddressBlueprint' default fieldset already has all attributes as leaves
@@ -96,20 +97,20 @@ describe Praxis::FieldExpander do
 
   context 'expanding a two-dimensional collection' do
     it 'expands the fields discarding the collection nexting nesting' do
-      matrix_type =  Attributor::Collection.of(Attributor::Collection.of(FullName))
+      matrix_type = Attributor::Collection.of(Attributor::Collection.of(FullName))
       expect(field_expander.expand(matrix_type)).to eq(first: true, last: true)
     end
   end
 
   context 'circular expansions' do
     it 'preserve field object identity for circular references' do
-      result = field_expander.expand(PersonBlueprint, address: {resident: true}, work_address: {resident: true})
+      result = field_expander.expand(PersonBlueprint, address: { resident: true }, work_address: { resident: true })
       expect(result[:address][:resident]).to be(result[:work_address][:resident])
     end
 
     context 'with collections of Blueprints' do
       it 'still preserves object identity' do
-        result = field_expander.expand(PersonBlueprint, address: {resident: true}, prior_addresses: {resident: true})
+        result = field_expander.expand(PersonBlueprint, address: { resident: true }, prior_addresses: { resident: true })
         expect(result[:address][:resident]).to be(result[:prior_addresses][:resident])
       end
     end
@@ -146,4 +147,4 @@ describe Praxis::FieldExpander do
       expect(field_expander.expand(type, true)).to eq(expected)
     end
   end
-end
+end

data/spec/praxis/file_group_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::FileGroup do
   let(:app) { Praxis::Application.instance }
   let(:layout) { app.file_layout }
 
-  context '#initialize' do 
+  context '#initialize' do
     it 'raises an error if given nil for the base path' do
       expect { Praxis::FileGroup.new(nil) }.to raise_error(ArgumentError)
     end

data/spec/praxis/handlers/json_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Handlers::JSON do
-  let(:dictionary) { {"foo" => 1} }
+  let(:dictionary) { { 'foo' => 1 } }
   let(:dictionary_json) { '{"foo":1}' }
 
-  let(:array) { [1,2,3] }
+  let(:array) { [1, 2, 3] }
   let(:array_json) { '[1,2,3]' }
 
   describe '#parse' do
@@ -14,14 +16,13 @@ describe Praxis::Handlers::JSON do
 
     it 'handles arrays' do
       expect(subject.parse(array_json)).to eq(array)
-
     end
   end
 
   # slightly cheesy: use #parse to test #generate by round-tripping everything
   describe '#generate' do
     it 'pretty-prints' do
-      result = subject.generate({"foo" => 1})
+      result = subject.generate({ 'foo' => 1 })
       expect(result).to include("\n")
       expect(result).to match(/^  /m)
     end
@@ -34,4 +35,4 @@ describe Praxis::Handlers::JSON do
       expect(subject.parse(subject.generate(array))).to eq(array)
     end
   end
-end
+end

data/spec/praxis/mapper/resource_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Mapper::Resource do
   let(:parent_record) { ParentModel.new(id: 100, name: 'george sr') }
-  let(:parent_records) { [ParentModel.new(id: 101, name: "georgia"),ParentModel.new(id: 102, name: 'georgina')] }
+  let(:parent_records) { [ParentModel.new(id: 101, name: 'georgia'), ParentModel.new(id: 102, name: 'georgina')] }
   let(:record) { SimpleModel.new(id: 103, name: 'george xvi') }
-  let(:model) { SimpleModel}
+  let(:model) { SimpleModel }
 
   context 'configuration' do
     subject(:resource) { SimpleResource }
@@ -30,10 +32,10 @@ describe Praxis::Mapper::Resource do
   context 'retrieving resources' do
     context 'getting a single resource' do
       before do
-       expect(SimpleModel).to receive(:get).with(name: 'george xvi').and_return(record)
+        expect(SimpleModel).to receive(:get).with(name: 'george xvi').and_return(record)
       end
 
-      subject(:resource)  { SimpleResource.get(:name => 'george xvi') }
+      subject(:resource)  { SimpleResource.get(name: 'george xvi') }
 
       it { is_expected.to be_kind_of(SimpleResource) }
 
@@ -45,7 +47,7 @@ describe Praxis::Mapper::Resource do
         expect(SimpleModel).to receive(:all).with(name: ['george xvi']).and_return([record])
       end
 
-      subject(:resource_collection) { SimpleResource.all(:name => ["george xvi"]) }
+      subject(:resource_collection) { SimpleResource.all(name: ['george xvi']) }
 
       it { is_expected.to be_kind_of(Array) }
 
@@ -58,7 +60,6 @@ describe Praxis::Mapper::Resource do
   end
 
   context 'delegating to the underlying model' do
-
     subject { SimpleResource.new(record) }
 
     it 'does respond_to attributes in the model' do
@@ -66,13 +67,13 @@ describe Praxis::Mapper::Resource do
     end
 
     it 'does not respond_to :id if the model does not have it' do
-      resource = OtherResource.new(OtherModel.new(:name => "foo"))
+      resource = OtherResource.new(OtherModel.new(name: 'foo'))
       expect(resource).not_to respond_to(:id)
     end
 
     it 'returns raw results for simple attributes' do
       expect(record).to receive(:name).and_call_original
-      expect(subject.name).to eq("george xvi")
+      expect(subject.name).to eq('george xvi')
     end
 
     it 'wraps model objects in Resource instances' do
@@ -81,14 +82,14 @@ describe Praxis::Mapper::Resource do
       parent = subject.parent
 
       expect(parent).to be_kind_of(ParentResource)
-      expect(parent.name).to eq("george sr")
+      expect(parent.name).to eq('george sr')
       expect(parent.record).to eq(parent_record)
     end
 
-    context "for serialized array associations" do
-      let(:record) { YamlArrayModel.new(:id => 1)}
+    context 'for serialized array associations' do
+      let(:record) { YamlArrayModel.new(id: 1) }
 
-      subject { YamlArrayResource.new(record)}
+      subject { YamlArrayResource.new(record) }
 
       it 'wraps arrays of model objects in an array of resource instances' do
         expect(record).to receive(:parents).and_return(parent_records)
@@ -98,34 +99,33 @@ describe Praxis::Mapper::Resource do
         expect(parents).to be_kind_of(Array)
 
         parents.each { |parent| expect(parent).to be_kind_of(ParentResource) }
-        expect(parents.collect { |parent| parent.record }).to match_array(parent_records)
+        expect(parents.collect(&:record)).to match_array(parent_records)
       end
     end
   end
 
   context 'resource_delegate' do
-    let(:other_name) { "foo" }
-    let(:other_attribute) { "other value" }
-    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+    let(:other_name) { 'foo' }
+    let(:other_attribute) { 'other value' }
+    let(:other_record) { OtherModel.new(name: other_name, other_attribute: other_attribute) }
     let(:other_resource) { OtherResource.new(other_record) }
 
-    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+    let(:record) { SimpleModel.new(id: 105, name: 'george xvi', other_name: other_name) }
 
     subject(:resource) { SimpleResource.new(record) }
-    
+
     it 'delegates to the target' do
       expect(record).to receive(:other_model).and_return(other_record)
       expect(resource.other_attribute).to eq(other_attribute)
     end
   end
 
-
-  context "memoized resource creation" do
-    let(:other_name) { "foo" }
-    let(:other_attribute) { "other value" }
-    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+  context 'memoized resource creation' do
+    let(:other_name) { 'foo' }
+    let(:other_attribute) { 'other value' }
+    let(:other_record) { OtherModel.new(name: other_name, other_attribute: other_attribute) }
     let(:other_resource) { OtherResource.new(other_record) }
-    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+    let(:record) { SimpleModel.new(id: 105, name: 'george xvi', other_name: other_name) }
 
     subject(:resource) { SimpleResource.new(record) }
 
@@ -133,11 +133,9 @@ describe Praxis::Mapper::Resource do
       allow(record).to receive(:other_model).and_return(other_record)
       expect(resource.other_resource).to be(SimpleResource.new(record).other_resource)
     end
-
   end
 
-
-  context ".wrap" do
+  context '.wrap' do
     it 'memoizes resource creation' do
       expect(SimpleResource.wrap(record)).to be(SimpleResource.wrap(record))
     end
@@ -153,9 +151,9 @@ describe Praxis::Mapper::Resource do
       expect(wrapped_set).to be_kind_of(Array)
       expect(wrapped_set.length).to be(1)
     end
-    
+
     it 'works with non-enumerable objects, that respond to collect' do
-      collectable = double("ArrayProxy", to_a: [record, record] )
+      collectable = double('ArrayProxy', to_a: [record, record])
 
       wrapped_set = SimpleResource.wrap(collectable)
       expect(wrapped_set.length).to be(2)
@@ -165,5 +163,4 @@ describe Praxis::Mapper::Resource do
       expect(SimpleResource.wrap(record)).to be(OtherResource.wrap(record))
     end
   end
-
 end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -1,49 +1,50 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 describe Praxis::Mapper::SelectorGenerator do
   let(:resource) { SimpleResource }
-  subject(:generator) {described_class.new }
+  subject(:generator) { described_class.new }
 
   context '#add' do
     let(:resource) { SimpleResource }
     shared_examples 'a proper selector' do
       it { expect(generator.add(resource, fields).selectors.dump).to be_deep_equal selectors }
     end
-    
+
     context 'basic combos' do
       context 'direct column fields' do
-        let(:fields) { {id: true, foobar: true} }
-        let(:selectors) do 
+        let(:fields) { { id: true, foobar: true } }
+        let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:id, :foobar]
-          } 
+            columns: %i[id foobar]
+          }
         end
         it_behaves_like 'a proper selector'
       end
 
       context 'aliased column fields' do
-        let(:fields) { {id: true, name: true} }
+        let(:fields) { { id: true, name: true } }
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:id, :simple_name]
+            columns: %i[id simple_name]
           }
         end
         it_behaves_like 'a proper selector'
       end
 
       context 'pure associations without recursion' do
-        let(:fields) { {other_model: true} }
+        let(:fields) { { other_model: true } }
         let(:selectors) do
           {
             model: SimpleModel,
             columns: [:other_model_id], # FK of the other_model association
             tracks: {
-              other_model: { 
+              other_model: {
                 columns: [:id], # joining key for the association
-                model: OtherModel 
+                model: OtherModel
               }
             }
           }
@@ -52,15 +53,15 @@ describe Praxis::Mapper::SelectorGenerator do
       end
 
       context 'aliased associations without recursion' do
-        let(:fields) { {other_resource: true} }
+        let(:fields) { { other_resource: true } }
         let(:selectors) do
           {
             model: SimpleModel,
             columns: [:other_model_id], # FK of the other_model association
             tracks: {
-              other_model: { 
+              other_model: {
                 columns: [:id], # joining key for the association
-                model: OtherModel 
+                model: OtherModel
               }
             }
           }
@@ -68,15 +69,15 @@ describe Praxis::Mapper::SelectorGenerator do
         it_behaves_like 'a proper selector'
       end
       context 'aliased associations without recursion (that map to columns and other associations)' do
-        let(:fields) { {aliased_method: true} }
+        let(:fields) { { aliased_method: true } }
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:column1, :other_model_id], # other_model_id => because of the association
+            columns: %i[column1 other_model_id], # other_model_id => because of the association
             tracks: {
-              other_model: { 
+              other_model: {
                 columns: [:id], # joining key for the association
-                model: OtherModel 
+                model: OtherModel
               }
             }
           }
@@ -85,13 +86,13 @@ describe Praxis::Mapper::SelectorGenerator do
       end
 
       context 'redefined associations that add some extra columns (would need both the underlying association AND the columns in place)' do
-        let(:fields) { {parent: true} }
+        let(:fields) { { parent: true } }
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:parent_id, :added_column],
+            columns: %i[parent_id added_column],
             tracks: {
-              parent: { 
+              parent: {
                 columns: [:id],
                 model: ParentModel
               }
@@ -102,29 +103,29 @@ describe Praxis::Mapper::SelectorGenerator do
       end
 
       context 'a simple property that requires all fields' do
-        let(:fields) { {everything: true} }
+        let(:fields) { { everything: true } }
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:*],
+            columns: [:*]
           }
         end
         it_behaves_like 'a proper selector'
       end
 
       context 'a simple property that requires itself' do
-        let(:fields) { {circular_dep: true} }
+        let(:fields) { { circular_dep: true } }
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:circular_dep, :column1], #allows to "expand" the dependency into itself + others
+            columns: %i[circular_dep column1] # allows to "expand" the dependency into itself + others
           }
         end
         it_behaves_like 'a proper selector'
       end
 
       context 'a simple property without dependencies' do
-        let(:fields) { {no_deps: true} }
+        let(:fields) { { no_deps: true } }
         let(:selectors) do
           {
             model: SimpleModel
@@ -132,13 +133,12 @@ describe Praxis::Mapper::SelectorGenerator do
         end
         it_behaves_like 'a proper selector'
       end
-
     end
 
     context 'nested tracking' do
       context 'pure associations follow the nested fields' do
         let(:fields) do
-          { 
+          {
             other_model: {
               id: true
             }
@@ -196,7 +196,7 @@ describe Praxis::Mapper::SelectorGenerator do
         let(:selectors) do
           {
             model: SimpleModel,
-            columns: [:parent_id, :added_column],
+            columns: %i[parent_id added_column],
             tracks: {
               parent: {
                 model: ParentModel,
@@ -225,7 +225,7 @@ describe Praxis::Mapper::SelectorGenerator do
             tracks: {
               other_model: {
                 model: OtherModel,
-                columns: [:id, :name]
+                columns: %i[id name]
               }
             }
           }
@@ -242,7 +242,7 @@ describe Praxis::Mapper::SelectorGenerator do
             tracks: {
               other_model: {
                 model: OtherModel,
-                columns: [:id, :name]
+                columns: %i[id name]
               }
             }
           }
@@ -251,13 +251,13 @@ describe Praxis::Mapper::SelectorGenerator do
       end
 
       context 'for a property that requires all fields from an association' do
-        let(:fields) { {everything_from_parent: true} }
+        let(:fields) { { everything_from_parent: true } }
         let(:selectors) do
           {
             model: SimpleModel,
             columns: [:parent_id],
             tracks: {
-              parent: { 
+              parent: {
                 model: ParentModel,
                 columns: [:*]
               }
@@ -270,15 +270,15 @@ describe Praxis::Mapper::SelectorGenerator do
 
     context 'required extra select fields due to associations' do
       context 'many_to_one' do
-        let(:fields) { {other_model: true} }
+        let(:fields) { { other_model: true } }
         let(:selectors) do
           {
             model: SimpleModel,
             columns: [:other_model_id], # FK of the other_model association
             tracks: {
-              other_model: { 
+              other_model: {
                 columns: [:id],
-                model: OtherModel 
+                model: OtherModel
               }
             }
           }
@@ -287,38 +287,38 @@ describe Praxis::Mapper::SelectorGenerator do
       end
       context 'one_to_many' do
         let(:resource) { ParentResource }
-        let(:fields) { {simple_children: true} }
+        let(:fields) { { simple_children: true } }
         let(:selectors) do
           {
             model: ParentModel,
             columns: [:id], # No FKs in the source model for one_to_many
             tracks: {
-              simple_children: { 
+              simple_children: {
                 columns: [:parent_id],
-                model: SimpleModel 
+                model: SimpleModel
               }
             }
           }
         end
         it_behaves_like 'a proper selector'
-      end      
+      end
       context 'many_to_many' do
         let(:resource) { OtherResource }
-        let(:fields) { {simple_models: true} }
+        let(:fields) { { simple_models: true } }
         let(:selectors) do
           {
             model: OtherModel,
-            columns: [:id], #join key in the source model for many_to_many (where the middle table points to)
+            columns: [:id], # join key in the source model for many_to_many (where the middle table points to)
             tracks: {
-              simple_models: { 
-                columns: [:id], #join key in the target model for many_to_many (where the middle table points to)
+              simple_models: {
+                columns: [:id], # join key in the target model for many_to_many (where the middle table points to)
                 model: SimpleModel
               }
             }
           }
         end
         it_behaves_like 'a proper selector'
-      end      
+      end
 
       context 'that are several attriutes deep' do
         let(:fields) { { deep_nested_deps: true } }
@@ -331,17 +331,17 @@ describe Praxis::Mapper::SelectorGenerator do
                 model: ParentModel,
                 columns: [:id], # No FKs in the source model for one_to_many
                 tracks: {
-                  simple_children: { 
-                    columns: [:parent_id, :other_model_id],
+                  simple_children: {
+                    columns: %i[parent_id other_model_id],
                     model: SimpleModel,
                     tracks: {
                       other_model: {
                         model: OtherModel,
-                        columns: [:id, :parent_id],
+                        columns: %i[id parent_id],
                         tracks: {
                           parent: {
                             model: ParentModel,
-                            columns: [:id, :simple_name, :other_attribute]
+                            columns: %i[id simple_name other_attribute]
                           }
                         }
                       }