praxis 2.0.pre.16 → 2.0.pre.20

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) }
 
@@ -134,10 +134,21 @@ describe Praxis::Mapper::Resource do
       expect(resource.other_resource).to be(SimpleResource.new(record).other_resource)
     end
 
-  end
+    it 'memoizes result of related associations' do
+      expect(record).to receive(:parent).once.and_return(parent_record)
+      expect(resource.parent).to be(resource.parent)
+    end
 
+    it 'can clear memoization' do
+      expect(record).to receive(:parent).twice.and_return(parent_record)
 
-  context ".wrap" do
+      expect(resource.parent).to be(resource.parent) # One time only calling the record parent method
+      resource.clear_memoization
+      expect(resource.parent).to be(resource.parent) # One time only time calling the record parent method after the reset
+    end
+  end
+
+  context '.wrap' do
     it 'memoizes resource creation' do
       expect(SimpleResource.wrap(record)).to be(SimpleResource.wrap(record))
     end
@@ -153,9 +164,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 +176,4 @@ describe Praxis::Mapper::Resource do
       expect(SimpleResource.wrap(record)).to be(OtherResource.wrap(record))
     end
   end
-
 end