granite-form 0.5.0 → 0.6.0

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) }

data/spec/granite/form/model/associations/reflections/embeds_many_spec.rb

@@ -14,6 +14,7 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
       embeds_many :projects
     end
   end
+
   let(:user) { User.new }
 
   context ':read, :write' do
@@ -24,14 +25,14 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
         attribute :name
         embeds_many :projects,
-          read: lambda { |reflection, object|
-            value = object.instance_variable_get("@_value_#{reflection.name}")
-            JSON.parse(value) if value.present?
-          },
-          write: lambda { |reflection, object, value|
-            value = value.to_json if value
-            object.instance_variable_set("@_value_#{reflection.name}", value)
-          }
+                    read: lambda { |reflection, object|
+                      value = object.instance_variable_get("@_value_#{reflection.name}")
+                      JSON.parse(value) if value.present?
+                    },
+                    write: lambda { |reflection, object, value|
+                      value = value.to_json if value
+                      object.instance_variable_set("@_value_#{reflection.name}", value)
+                    }
       end
     end
 
@@ -55,16 +56,18 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
     describe '#build' do
       let(:project) { Project.new title: 'Project' }
+
       specify { expect(user.projects.build(title: 'Project')).to eq(project) }
       specify { expect { user.projects.build(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
     end
 
     describe '#reload' do
       let(:project) { Project.new title: 'Project' }
+
       before do
-        user.write_attribute(:projects, [{title: 'Project'}])
+        user.write_attribute(:projects, [{ title: 'Project' }])
+        user.projects.build
       end
-      before { user.projects.build }
 
       specify { expect(user.projects.count).to eq(2) }
       specify { expect(user.projects.reload).to eq([project]) }
@@ -72,26 +75,42 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
     describe '#concat' do
       let(:project) { Project.new title: 'Project' }
+
       specify { expect { user.projects.concat project }.to change { user.projects }.from([]).to([project]) }
-      specify { expect { user.projects.concat project, 'string' }.to raise_error Granite::Form::AssociationTypeMismatch }
+
+      specify do
+        expect do
+          user.projects.concat project, 'string'
+        end.to raise_error Granite::Form::AssociationTypeMismatch
+      end
 
       context do
         let(:other) { Project.new title: 'Other' }
+
         before { user.projects = [other] }
-        specify { expect { user.projects.concat project }.to change { user.projects }.from([other]).to([other, project]) }
+
+        specify do
+          expect { user.projects.concat project }
+            .to change { user.projects }
+            .from([other])
+            .to([other, project])
+        end
       end
     end
   end
 
   describe '#projects=' do
     let(:project) { Project.new title: 'Project' }
+
     specify { expect { user.projects = [] }.not_to change { user.projects }.from([]) }
     specify { expect { user.projects = [project] }.to change { user.projects }.from([]).to([project]) }
     specify { expect { user.projects = [project, 'string'] }.to raise_error Granite::Form::AssociationTypeMismatch }
 
     context do
       let(:other) { Project.new title: 'Other' }
+
       before { user.projects = [other] }
+
       specify { expect { user.projects = [project] }.to change { user.projects }.from([other]).to([project]) }
       specify { expect { user.projects = [] }.to change { user.projects }.from([other]).to([]) }
     end
@@ -112,8 +131,18 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project')]) }
+
+      specify do
+        user = User.new
+        user.projects.build(title: 'Project')
+        expect(user.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded)
+      end
+
+      specify do
+        user = User.new
+        user.projects.build(title: 'Project')
+        expect(user.projects).to match([have_attributes(title: 'Project')])
+      end
     end
 
     context do
@@ -130,8 +159,14 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project', value: nil)]) }
+
+      specify do
+        user = User.new
+        user.projects.build(title: 'Project')
+        expect(user.projects)
+          .to be_a(Granite::Form::Model::Associations::Collection::Embedded)
+          .and match([have_attributes(title: 'Project', value: nil)])
+      end
     end
   end
 end

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

@@ -15,6 +15,7 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
       embeds_one :author
     end
   end
+
   let(:book) { Book.new }
 
   specify { expect(book.author).to be_nil }
@@ -27,14 +28,14 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
         attribute :title
         embeds_one :author,
-          read: lambda { |reflection, object|
-            value = object.instance_variable_get("@_value_#{reflection.name}")
-            JSON.parse(value) if value.present?
-          },
-          write: lambda { |reflection, object, value|
-            value = value.to_json if value
-            object.instance_variable_set("@_value_#{reflection.name}", value)
-          }
+                   read: lambda { |reflection, object|
+                     value = object.instance_variable_get("@_value_#{reflection.name}")
+                     JSON.parse(value) if value.present?
+                   },
+                   write: lambda { |reflection, object, value|
+                     value = value.to_json if value
+                     object.instance_variable_set("@_value_#{reflection.name}", value)
+                   }
       end
     end
 
@@ -53,12 +54,15 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
   describe '#author=' do
     let(:author) { Author.new name: 'Author' }
+
     specify { expect { book.author = author }.to change { book.author }.from(nil).to(author) }
     specify { expect { book.author = 'string' }.to raise_error Granite::Form::AssociationTypeMismatch }
 
     context do
       let(:other) { Author.new name: 'Other' }
+
       before { book.author = other }
+
       specify { expect { book.author = author }.to change { book.author }.from(other).to(author) }
       specify { expect { book.author = nil }.to change { book.author }.from(other).to(nil) }
     end
@@ -66,6 +70,7 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
   describe '#build_author' do
     let(:author) { Author.new name: 'Author' }
+
     specify { expect(book.build_author(name: 'Author')).to eq(author) }
     specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
   end
@@ -104,7 +109,12 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
       specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
       specify { expect(Book.new.author).to be_nil }
       specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to be_a(Book::Author) }
-      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to have_attributes(name: 'Author', age: nil) }
+
+      specify do
+        book = Book.new
+        book.build_author(name: 'Author')
+        expect(book.author).to have_attributes(name: 'Author', age: nil)
+      end
     end
   end
 end