granite-form 0.4.0 → 0.6.0

data/spec/granite/form/model/associations/embeds_one_spec.rb

@@ -22,7 +22,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
   let(:book) { Book.new(title: 'Book') }
   let(:association) { book.association(:author) }
 
-  let(:existing_book) { Book.instantiate title: 'My Life', author: {'name' => 'Johny'} }
+  let(:existing_book) { Book.instantiate title: 'My Life', author: { 'name' => 'Johny' } }
   let(:existing_association) { existing_book.association(:author) }
 
   context 'callbacks' do
@@ -41,6 +41,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
         collection :callbacks, Array
       end
     end
+
     let(:author1) { Author.new(name: 'Author1') }
     let(:author2) { Author.new(name: 'Author2') }
 
@@ -57,9 +58,9 @@ describe Granite::Form::Model::Associations::EmbedsOne do
       end
         .to change { book.callbacks }
         .to([
-          [:before_add, author1], [:after_add, author1],
-          [:before_add, author2], [:after_add, author2]
-        ])
+              [:before_add, author1], [:after_add, author1],
+              [:before_add, author2], [:after_add, author2]
+            ])
     end
 
     specify do
@@ -76,18 +77,18 @@ describe Granite::Form::Model::Associations::EmbedsOne do
       end
         .to change { book.callbacks }
         .to([
-          [:before_add, author1], [:after_add, author1],
-          [:before_add, author1], [:after_add, author1]
-        ])
+              [:before_add, author1], [:after_add, author1],
+              [:before_add, author1], [:after_add, author1]
+            ])
     end
 
     context 'default' do
       before do
         Book.class_eval do
           embeds_one :author,
-            before_add: ->(object) { callbacks.push([:before_add, object]) },
-            after_add: ->(object) { callbacks.push([:after_add, object]) },
-            default: -> { {name: 'Author1'} }
+                     before_add: ->(object) { callbacks.push([:before_add, object]) },
+                     after_add: ->(object) { callbacks.push([:after_add, object]) },
+                     default: -> { { name: 'Author1' } }
 
           collection :callbacks, Array
         end
@@ -97,9 +98,9 @@ describe Granite::Form::Model::Associations::EmbedsOne do
         expect { association.writer(author2) }
           .to change { book.callbacks }
           .to([
-            [:before_add, author1], [:after_add, author1],
-            [:before_add, author2], [:after_add, author2]
-          ])
+                [:before_add, author1], [:after_add, author1],
+                [:before_add, author2], [:after_add, author2]
+              ])
       end
     end
   end
@@ -113,10 +114,12 @@ describe Granite::Form::Model::Associations::EmbedsOne do
     let(:author) { Author.new(name: 'Author') }
 
     specify { expect(association.build.embedder).to eq(book) }
+
     specify do
       expect { association.writer(author) }
         .to change { author.embedder }.from(nil).to(book)
     end
+
     specify do
       expect { association.target = author }
         .to change { author.embedder }.from(nil).to(book)
@@ -125,7 +128,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
     context 'default' do
       before do
         Book.class_eval do
-          embeds_one :author, default: -> { {name: 'Author1'} }
+          embeds_one :author, default: -> { { name: 'Author1' } }
         end
       end
 
@@ -159,12 +162,12 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
     specify do
       expect { association.build(name: 'Fred') }
-        .not_to change { book.read_attribute(:author) }
+        .not_to(change { book.read_attribute(:author) })
     end
 
     specify do
       expect { existing_association.build(name: 'Fred') }
-        .not_to change { existing_book.read_attribute(:author) }
+        .not_to(change { existing_book.read_attribute(:author) })
     end
   end
 
@@ -175,13 +178,14 @@ describe Granite::Form::Model::Associations::EmbedsOne do
   end
 
   describe '#default' do
-    before { Book.embeds_one :author, default: -> { {name: 'Default'} } }
     before do
+      Book.embeds_one :author, default: -> { { name: 'Default' } }
       Author.class_eval do
         include Granite::Form::Model::Primary
         primary :name
       end
     end
+
     let(:new_author) { Author.new.tap { |a| a.name = 'Morty' } }
     let(:existing_book) { Book.instantiate title: 'My Life' }
 
@@ -191,11 +195,18 @@ describe Granite::Form::Model::Associations::EmbedsOne do
     specify { expect { association.replace(nil) }.to change { association.target }.to be_nil }
 
     specify { expect(existing_association.target).to be_nil }
-    specify { expect { existing_association.replace(new_author) }.to change { existing_association.target }.to(an_instance_of(Author)) }
-    specify { expect { existing_association.replace(nil) }.not_to change { existing_association.target } }
+
+    specify do
+      expect { existing_association.replace(new_author) }
+        .to change { existing_association.target }
+        .to(an_instance_of(Author))
+    end
+
+    specify { expect { existing_association.replace(nil) }.not_to(change { existing_association.target }) }
 
     context do
-      before { Author.send(:include, Granite::Form::Model::Dirty) }
+      before { Author.include Granite::Form::Model::Dirty }
+
       specify { expect(association.target).not_to be_changed }
     end
   end
@@ -220,6 +231,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
     context do
       before { association.build(name: 'Fred') }
+
       specify do
         expect { association.reload }
           .to change { association.reader.try(:attributes) }.from('name' => 'Fred').to(nil)
@@ -228,6 +240,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
     context do
       before { existing_association.build(name: 'Fred') }
+
       specify do
         expect { existing_association.reload }
           .to change { existing_association.reader.try(:attributes) }
@@ -256,16 +269,17 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
       specify do
         expect { association.sync }.to change { book.read_attribute(:author) }
-          .from(nil).to('name' => 'Fred', 'reviews' => [{'rating' => 7}])
+          .from(nil).to('name' => 'Fred', 'reviews' => [{ 'rating' => 7 }])
       end
     end
   end
 
   describe '#clear' do
     specify { expect(association.clear).to eq(true) }
-    specify { expect { association.clear }.not_to change { association.reader } }
+    specify { expect { association.clear }.not_to(change { association.reader }) }
 
     specify { expect(existing_association.clear).to eq(true) }
+
     specify do
       expect { existing_association.clear }
         .to change { existing_association.reader.try(:attributes) }.from('name' => 'Johny').to(nil)
@@ -280,6 +294,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
     context do
       before { association.build }
+
       specify { expect(association.reader).to be_a Author }
       specify { expect(association.reader).not_to be_persisted }
       specify { expect(association.reader(true)).to be_nil }
@@ -287,6 +302,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
     context do
       before { existing_association.build(name: 'Fred') }
+
       specify { expect(existing_association.reader.name).to eq('Fred') }
       specify { expect(existing_association.reader(true).name).to eq('Johny') }
     end
@@ -305,8 +321,9 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
       specify do
         expect { association.writer(nil) }
-          .not_to change { book.read_attribute(:author) }
+          .not_to(change { book.read_attribute(:author) })
       end
+
       specify do
         expect { association.writer(new_author) }
           .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty')
@@ -321,6 +338,7 @@ describe Granite::Form::Model::Associations::EmbedsOne do
 
       specify { expect(association.writer(nil)).to be_nil }
       specify { expect(association.writer(new_author)).to eq(new_author) }
+
       specify do
         expect { association.writer(new_author) }
           .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty')
@@ -332,12 +350,17 @@ describe Granite::Form::Model::Associations::EmbedsOne do
       end
 
       specify do
-        expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer(stub_model(:dummy).new) } }
-          .not_to change { existing_association.reader }
+        expect do
+          muffle(Granite::Form::AssociationTypeMismatch) do
+            existing_association.writer(stub_model(:dummy).new)
+          end
+        end
+          .not_to(change { existing_association.reader })
       end
 
       specify { expect(existing_association.writer(nil)).to be_nil }
       specify { expect(existing_association.writer(new_author)).to eq(new_author) }
+
       specify do
         expect { existing_association.writer(new_author) }
           .to change { existing_association.reader.try(:attributes) }

data/spec/granite/form/model/associations/persistence_adapters/active_record_spec.rb

@@ -1,38 +1,43 @@
 require 'spec_helper'
 
 describe Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord do
+  subject(:adapter) { described_class.new(Author, primary_key, scope_proc) }
+
   before do
     stub_class(:author, ActiveRecord::Base)
   end
 
-  subject(:adapter) { described_class.new(Author, primary_key, scope_proc) }
   let(:primary_key) { :id }
   let(:scope_proc) { nil }
 
   describe '#build' do
     subject { adapter.build(name: name) }
+
     let(:name) { 'John Doe' }
 
-    its(:name) { should == name }
+    its(:name) { is_expected.to eq name }
     it { is_expected.to be_a Author }
   end
 
   describe '#find_one' do
     subject { adapter.find_one(nil, author.id) }
+
     let(:author) { Author.create }
 
-    it { should == author }
+    it { is_expected.to eq author }
   end
 
   describe '#find_all' do
     subject { adapter.find_all(nil, authors.map(&:id)) }
+
     let(:authors) { Array.new(2) { Author.create } }
 
-    it { should == authors }
+    it { is_expected.to eq authors }
   end
 
   describe '#scope' do
     subject { adapter.scope(owner, source) }
+
     let(:authors) { ['John Doe', 'Sam Smith', 'John Smith'].map { |name| Author.create(name: name) } }
     let(:source) { authors[0..1].map(&:id) }
     let(:owner) { nil }
@@ -40,19 +45,19 @@ describe Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord d
     it { is_expected.to be_a ActiveRecord::Relation }
 
     context 'without scope_proc' do
-      it { should == Author.where(primary_key => source) }
+      it { is_expected.to eq Author.where(primary_key => source) }
     end
 
     context 'with scope_proc' do
       let(:scope_proc) { -> { where("name LIKE 'John%'") } }
 
-      its(:to_a) { should == [Author.first] }
+      its(:to_a) { is_expected.to eq [Author.first] }
     end
   end
 
   describe '#primary_key_type' do
     subject { adapter.primary_key_type }
 
-    it { should == Integer }
+    it { is_expected.to eq Integer }
   end
 end

data/spec/granite/form/model/associations/references_many_spec.rb

@@ -52,6 +52,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
   describe '#default' do
     before { Book.references_many :authors, default: ->(_book) { author.id } }
+
     let(:existing_book) { Book.instantiate title: 'Genesis' }
 
     specify { expect(association.target).to eq([author]) }
@@ -60,7 +61,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
     specify { expect(existing_association.target).to eq([]) }
     specify { expect { existing_association.replace([other]) }.to change { existing_association.target }.to([other]) }
-    specify { expect { existing_association.replace([]) }.not_to change { existing_association.target } }
+    specify { expect { existing_association.replace([]) }.not_to(change { existing_association.target }) }
   end
 
   describe '#loaded?' do
@@ -77,6 +78,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
     context do
       before { existing_association.reader.last.name = 'Conan' }
+
       specify do
         expect { existing_association.reload }
           .to change { existing_association.reader.map(&:name) }
@@ -87,13 +89,18 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
   describe '#reader' do
     specify { expect(association.reader).to eq([]) }
-    specify { expect(association.reader).to be_a Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord::ReferencedProxy }
+
+    specify do
+      expect(association.reader)
+        .to be_a Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord::ReferencedProxy
+    end
 
     specify { expect(existing_association.reader.first).to be_a Author }
     specify { expect(existing_association.reader.first).to be_persisted }
 
     context do
       before { association.concat author }
+
       specify { expect(association.reader.last).to be_a Author }
       specify { expect(association.reader.size).to eq(1) }
       specify { expect(association.reader(true)).to eq([author]) }
@@ -101,6 +108,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
     context do
       before { existing_association.concat other }
+
       specify { expect(existing_association.reader.size).to eq(2) }
       specify { expect(existing_association.reader.last.name).to eq('Ben') }
       specify { expect(existing_association.reader(true).size).to eq(2) }
@@ -128,10 +136,12 @@ describe Granite::Form::Model::Associations::ReferencesMany do
     specify { expect(association.writer([])).to eq([]) }
 
     specify { expect(association.writer([new_author1])).to eq([new_author1]) }
+
     specify do
       expect { association.writer([new_author1]) }
         .to change { association.reader.map(&:name) }.from([]).to(['John'])
     end
+
     specify do
       expect { association.writer([new_author1]) }
         .to change { book.read_attribute(:author_ids) }
@@ -142,41 +152,57 @@ describe Granite::Form::Model::Associations::ReferencesMany do
       expect { existing_association.writer([new_author1, Dummy.new, new_author2]) }
         .to raise_error Granite::Form::AssociationTypeMismatch
     end
+
     specify do
-      expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer([new_author1, Dummy.new, new_author2]) } }
-        .not_to change { existing_book.read_attribute(:author_ids) }
+      expect do
+        muffle(Granite::Form::AssociationTypeMismatch) do
+          existing_association.writer([new_author1, Dummy.new, new_author2])
+        end
+      end
+        .not_to(change { existing_book.read_attribute(:author_ids) })
     end
+
     specify do
-      expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer([new_author1, Dummy.new, new_author2]) } }
-        .not_to change { existing_association.reader }
+      expect do
+        muffle(Granite::Form::AssociationTypeMismatch) do
+          existing_association.writer([new_author1, Dummy.new, new_author2])
+        end
+      end
+        .not_to(change { existing_association.reader })
     end
 
     specify { expect { existing_association.writer(nil) }.to raise_error NoMethodError }
+
     specify do
       expect { muffle(NoMethodError) { existing_association.writer(nil) } }
-        .not_to change { existing_book.read_attribute(:author_ids) }
+        .not_to(change { existing_book.read_attribute(:author_ids) })
     end
+
     specify do
       expect { muffle(NoMethodError) { existing_association.writer(nil) } }
-        .not_to change { existing_association.reader }
+        .not_to(change { existing_association.reader })
     end
 
     specify { expect(existing_association.writer([])).to eq([]) }
+
     specify do
       expect { existing_association.writer([]) }
         .to change { existing_book.read_attribute(:author_ids) }.to([])
     end
+
     specify do
       expect { existing_association.writer([]) }
         .to change { existing_association.reader }.from([author]).to([])
     end
 
     specify { expect(existing_association.writer([new_author1, new_author2])).to eq([new_author1, new_author2]) }
+
     specify do
       expect { existing_association.writer([new_author1, new_author2]) }
         .to change { existing_association.reader.map(&:name) }
         .from(['Rick']).to(%w[John Adam])
     end
+
     specify do
       expect { existing_association.writer([new_author1, new_author2]) }
         .to change { existing_book.read_attribute(:author_ids) }
@@ -187,6 +213,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
       expect { existing_association.writer([new_author3]) }
         .to change { existing_association.target }.from([author]).to([new_author3])
     end
+
     specify do
       expect { existing_association.writer([new_author3]) }
         .to change { existing_book.read_attribute(:author_ids) }
@@ -209,10 +236,12 @@ describe Granite::Form::Model::Associations::ReferencesMany do
     specify { expect(existing_association.concat).to eq(existing_book.authors) }
 
     specify { expect(association.concat(new_author1)).to eq([new_author1]) }
+
     specify do
       expect { association.concat(new_author1) }
         .to change { association.reader.map(&:name) }.from([]).to(['John'])
     end
+
     specify do
       expect { association.concat(new_author1) }
         .to change { book.read_attribute(:author_ids) }.from([]).to([new_author1.id])
@@ -222,13 +251,23 @@ describe Granite::Form::Model::Associations::ReferencesMany do
       expect { existing_association.concat(new_author1, Dummy.new, new_author2) }
         .to raise_error Granite::Form::AssociationTypeMismatch
     end
+
     specify do
-      expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.concat(new_author1, Dummy.new, new_author2) } }
+      expect do
+        muffle(Granite::Form::AssociationTypeMismatch) do
+          existing_association.concat(new_author1, Dummy.new, new_author2)
+        end
+      end
         .to change { existing_book.read_attribute(:author_ids) }
         .from([author.id]).to([author.id, new_author1.id])
     end
+
     specify do
-      expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.concat(new_author1, Dummy.new, new_author2) } }
+      expect do
+        muffle(Granite::Form::AssociationTypeMismatch) do
+          existing_association.concat(new_author1, Dummy.new, new_author2)
+        end
+      end
         .to change { existing_association.reader.map(&:name) }
         .from(['Rick']).to(%w[Rick John])
     end
@@ -237,11 +276,13 @@ describe Granite::Form::Model::Associations::ReferencesMany do
       expect(existing_association.concat(new_author1, new_author2))
         .to eq([author, new_author1, new_author2])
     end
+
     specify do
       expect { existing_association.concat([new_author1, new_author2]) }
         .to change { existing_association.reader.map(&:name) }
         .from(['Rick']).to(%w[Rick John Adam])
     end
+
     specify do
       expect { existing_association.concat([new_author1, new_author2]) }
         .to change { existing_book.read_attribute(:author_ids) }

data/spec/granite/form/model/associations/references_one_spec.rb

@@ -58,6 +58,7 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
     context do
       before { existing_association.reader.name = 'New' }
+
       specify do
         expect { existing_association.reload }
           .to change { existing_association.reader.name }
@@ -75,6 +76,7 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
   describe '#default' do
     before { Book.references_one :author, default: ->(_book) { author.id } }
+
     let(:existing_book) { Book.instantiate title: 'My Life' }
 
     specify { expect(association.target).to eq(author) }
@@ -83,7 +85,7 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
     specify { expect(existing_association.target).to be_nil }
     specify { expect { existing_association.replace(other) }.to change { existing_association.target }.to(other) }
-    specify { expect { existing_association.replace(nil) }.not_to change { existing_association.target } }
+    specify { expect { existing_association.replace(nil) }.not_to(change { existing_association.target }) }
   end
 
   describe '#writer' do
@@ -98,13 +100,15 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
       specify do
         expect { association.writer(nil) }
-          .not_to change { book.author_id }
+          .not_to(change { book.author_id })
       end
+
       specify do
         expect { association.writer(new_author) }
           .to change { muffle(NoMethodError) { association.reader.name } }
           .from(nil).to('Morty')
       end
+
       specify do
         expect { association.writer(new_author) }
           .not_to change { book.author_id }.from(nil)
@@ -121,17 +125,20 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
       specify { expect(association.writer(nil)).to be_nil }
       specify { expect(association.writer(new_author)).to eq(new_author) }
+
       specify do
         expect { association.writer(nil) }
-          .not_to change { book.read_attribute(:author_id) }
+          .not_to(change { book.read_attribute(:author_id) })
       end
+
       specify do
         expect { association.writer(new_author) }
           .to change { association.reader }.from(nil).to(new_author)
       end
+
       specify do
         expect { association.writer(new_author) }
-          .to change { book.read_attribute(:author_id) }
+          .to(change { book.read_attribute(:author_id) })
       end
 
       context do
@@ -143,26 +150,30 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
         specify do
           expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer(Dummy.new) } }
-            .not_to change { existing_book.read_attribute(:author_id) }
+            .not_to(change { existing_book.read_attribute(:author_id) })
         end
+
         specify do
           expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer(Dummy.new) } }
-            .not_to change { existing_association.reader }
+            .not_to(change { existing_association.reader })
         end
       end
 
       specify { expect(existing_association.writer(nil)).to be_nil }
       specify { expect(existing_association.writer(new_author)).to eq(new_author) }
+
       specify do
         expect { existing_association.writer(nil) }
           .to change { existing_book.read_attribute(:author_id) }
           .from(author.id).to(nil)
       end
+
       specify do
         expect { existing_association.writer(new_author) }
           .to change { existing_association.reader }
           .from(author).to(new_author)
       end
+
       specify do
         expect { existing_association.writer(new_author) }
           .to change { existing_book.read_attribute(:author_id) }