granite-form 0.4.0 → 0.6.0

data/spec/granite/form/model/associations_spec.rb

@@ -34,9 +34,18 @@ describe Granite::Form::Model::Associations do
 
     describe '#reflect_on_association' do
       specify { expect(Nobody.reflect_on_association(:blabla)).to be_nil }
-      specify { expect(Admin.reflect_on_association('projects')).to be_a Granite::Form::Model::Associations::Reflections::EmbedsMany }
+
+      specify do
+        expect(Admin.reflect_on_association('projects'))
+          .to be_a Granite::Form::Model::Associations::Reflections::EmbedsMany
+      end
+
       specify { expect(Admin.reflect_on_association('own_projects').name).to eq(:admin_projects) }
-      specify { expect(Manager.reflect_on_association(:managed_project)).to be_a Granite::Form::Model::Associations::Reflections::EmbedsOne }
+
+      specify do
+        expect(Manager.reflect_on_association(:managed_project))
+          .to be_a Granite::Form::Model::Associations::Reflections::EmbedsOne
+      end
     end
   end
 
@@ -47,7 +56,8 @@ describe Granite::Form::Model::Associations do
           include Granite::Form::Model::Associations
 
           embeds_one :author, class_name: 'Borogoves'
-        end.reflect_on_association(:author).data_source end.to raise_error NameError
+        end.reflect_on_association(:author).data_source
+      end.to raise_error NameError
     end
 
     specify do
@@ -58,7 +68,8 @@ describe Granite::Form::Model::Associations do
           embeds_many :projects, class_name: 'Borogoves' do
             attribute :title
           end
-        end.reflect_on_association(:projects).data_source end.to raise_error NameError
+        end.reflect_on_association(:projects).data_source
+      end.to raise_error NameError
     end
   end
 
@@ -108,7 +119,9 @@ describe Granite::Form::Model::Associations do
     specify { expect(user.profile).to be_nil }
 
     describe '.inspect' do
-      specify { expect(User.inspect).to eq('User(profile: EmbedsOne(Profile), projects: EmbedsMany(Project), login: Object)') }
+      specify do
+        expect(User.inspect).to eq('User(profile: EmbedsOne(Profile), projects: EmbedsMany(Project), login: Object)')
+      end
     end
 
     describe '.association_names' do
@@ -118,9 +131,10 @@ describe Granite::Form::Model::Associations do
     describe '#inspect' do
       let(:profile) { Profile.new first_name: 'Name' }
       let(:project) { Project.new title: 'Project' }
+
       specify do
         expect(User.new(login: 'Login', profile: profile, projects: [project]).inspect)
-          .to eq('#<User profile: #<EmbedsOne #<Profile first_name: "Name", last_name: nil>>, projects: #<EmbedsMany [#<Project author: #<EmbedsOne nil>, title: "P...]>, login: "Login">')
+          .to eq('#<User profile: #<EmbedsOne #<Profile first_name: "Name", last_name: nil>>, projects: #<EmbedsMany [#<Project author: #<EmbedsOne nil>, title: "P...]>, login: "Login">') # rubocop:disable Layout/LineLength
       end
     end
 
@@ -137,7 +151,8 @@ describe Granite::Form::Model::Associations do
       specify { expect(User.new(projects: [project])).not_to eql(User.new) }
 
       context do
-        before { User.send(:include, Granite::Form::Model::Primary) }
+        before { User.include Granite::Form::Model::Primary }
+
         let(:user) { User.new(projects: [project]) }
 
         specify { expect(user).to eq(user.clone.tap { |b| b.projects(author: project) }) }
@@ -161,13 +176,17 @@ describe Granite::Form::Model::Associations do
     end
 
     describe '#instantiate' do
-      before { User.send(:include, Granite::Form::Model::Persistence) }
+      before do
+        User.include Granite::Form::Model::Persistence
+        project.build_author(name: 'Author')
+      end
+
       let(:profile) { Profile.new first_name: 'Name' }
       let(:project) { Project.new title: 'Project' }
       let(:user) { User.new(profile: profile, projects: [project]) }
-      before { project.build_author(name: 'Author') }
 
       specify { expect(User.instantiate(JSON.parse(user.to_json))).to eq(user) }
+
       specify do
         expect(User.instantiate(JSON.parse(user.to_json))
         .tap { |u| u.projects.first.author.name = 'Other' }).not_to eq(user)

data/spec/granite/form/model/attributes/attribute_spec.rb

@@ -5,12 +5,16 @@ describe Granite::Form::Model::Attributes::Attribute do
 
   def attribute(*args)
     options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Attribute, :field, {type: Object}.merge(options))
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Attribute, :field,
+                        { type: Object }.merge(options))
     Dummy.new.attribute(:field)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
+    let(:field) do
+      normalizer = ->(v) { v ? v.strip : v }
+      attribute(type: String, normalizer: normalizer, default: :world, enum: %w[hello 42 world])
+    end
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq('world') }
     specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
@@ -36,7 +40,11 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
 
     context ':readonly' do
-      specify { expect(attribute(readonly: true, default: :world).tap { |r| r.write('string') }.read_before_type_cast).to eq(:world) }
+      specify do
+        attr = attribute(readonly: true, default: :world)
+        attr.write('string')
+        expect(attr.read_before_type_cast).to eq(:world)
+      end
     end
   end
 
@@ -58,11 +66,22 @@ describe Granite::Form::Model::Attributes::Attribute do
   describe '#normalize' do
     specify { expect(attribute.normalize(' hello ')).to eq(' hello ') }
     specify { expect(attribute(normalizer: ->(v) { v.strip }).normalize(' hello ')).to eq('hello') }
-    specify { expect(attribute(normalizer: [->(v) { v.strip }, ->(v) { v.first(4) }]).normalize(' hello ')).to eq('hell') }
-    specify { expect(attribute(normalizer: [->(v) { v.first(4) }, ->(v) { v.strip }]).normalize(' hello ')).to eq('hel') }
+
+    specify do
+      normalizers = [->(v) { v.strip }, ->(v) { v.first(4) }]
+      attr = attribute(normalizer: normalizers)
+      expect(attr.normalize(' hello ')).to eq('hell')
+    end
+
+    specify do
+      normalizers = [->(v) { v.first(4) }, ->(v) { v.strip }]
+      attr = attribute(normalizer: normalizers)
+      expect(attr.normalize(' hello ')).to eq('hel')
+    end
 
     context do
       before { allow_any_instance_of(Dummy).to receive_messages(value: 'value') }
+
       let(:other) { 'other' }
 
       specify { expect(attribute(normalizer: ->(_v) { value }).normalize(' hello ')).to eq('value') }
@@ -89,12 +108,14 @@ describe Granite::Form::Model::Attributes::Attribute do
       specify { expect(attribute(normalizer: :strip).normalize(' hello ')).to eq('hello') }
       specify { expect(attribute(normalizer: %i[strip trim]).normalize(' hello ')).to eq('he') }
       specify { expect(attribute(normalizer: %i[trim strip]).normalize(' hello ')).to eq('h') }
-      specify { expect(attribute(normalizer: [:strip, {trim: {length: 4}}]).normalize(' hello ')).to eq('hell') }
-      specify { expect(attribute(normalizer: {strip: {}, trim: {length: 4}}).normalize(' hello ')).to eq('hell') }
+      specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }]).normalize(' hello ')).to eq('hell') }
+      specify { expect(attribute(normalizer: { strip: {}, trim: { length: 4 } }).normalize(' hello ')).to eq('hell') }
+
       specify do
-        expect(attribute(normalizer: [:strip, {trim: {length: 4}}, ->(v) { v.last(2) }])
+        expect(attribute(normalizer: [:strip, { trim: { length: 4 } }, ->(v) { v.last(2) }])
         .normalize(' hello ')).to eq('ll')
       end
+
       specify { expect(attribute(normalizer: :reset).normalize('')).to eq(nil) }
       specify { expect(attribute(normalizer: %i[strip reset]).normalize('   ')).to eq(nil) }
       specify { expect(attribute(normalizer: :reset, default: '!!!').normalize(nil)).to eq('!!!') }
@@ -103,10 +124,11 @@ describe Granite::Form::Model::Attributes::Attribute do
       context do
         let(:length) { 3 }
 
-        specify { expect(attribute(normalizer: [:strip, {trim: {length: 4}}]).normalize(' hello ')).to eq('hel') }
-        specify { expect(attribute(normalizer: {strip: {}, trim: {length: 4}}).normalize(' hello ')).to eq('hel') }
+        specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }]).normalize(' hello ')).to eq('hel') }
+        specify { expect(attribute(normalizer: { strip: {}, trim: { length: 4 } }).normalize(' hello ')).to eq('hel') }
+
         specify do
-          expect(attribute(normalizer: [:strip, {trim: {length: 4}}, ->(v) { v.last(2) }])
+          expect(attribute(normalizer: [:strip, { trim: { length: 4 } }, ->(v) { v.last(2) }])
           .normalize(' hello ')).to eq('el')
         end
       end

data/spec/granite/form/model/attributes/base_spec.rb

@@ -7,12 +7,16 @@ describe Granite::Form::Model::Attributes::Base do
 
   def attribute(*args)
     options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field, options.reverse_merge(type: Object))
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field,
+                        options.reverse_merge(type: Object))
     model.attribute(:field)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
+    let(:field) do
+      normalizer = ->(v) { v ? v.strip : v }
+      attribute(type: String, normalizer: normalizer, default: :world, enum: %w[hello 42 world])
+    end
     let(:object) { Object.new }
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to be_nil }
@@ -99,8 +103,28 @@ describe Granite::Form::Model::Attributes::Base do
 
   describe '#type_definition' do
     subject { attr.type_definition }
+
     let(:attr) { attribute(type: String) }
 
     it { is_expected.to have_attributes(type: String, reflection: subject.reflection, owner: model) }
   end
+
+  describe '#inspect_attribute' do
+    let(:field) { attribute(type: type) }
+    let(:object) { Object.new }
+
+    {
+      'hello' => 'field: "hello"',
+      123 => 'field: 123',
+      Date.new(2023, 6, 20) => 'field: "2023-06-20"',
+      DateTime.new(2023, 6, 20, 12, 30) => 'field: "2023-06-20 12:30:00"',
+      Time.new(2023, 6, 20, 12, 30) => 'field: "2023-06-20 12:30:00"'
+    }.each do |input, expected_output|
+      context "attribute type is #{input.class}" do
+        let(:type) { input.class }
+
+        specify { expect(field.tap { |r| r.write(input) }.inspect_attribute).to eq(expected_output) }
+      end
+    end
+  end
 end

data/spec/granite/form/model/attributes/reflections/attribute_spec.rb

@@ -10,6 +10,7 @@ describe Granite::Form::Model::Attributes::Reflections::Attribute do
 
     specify { expect(described_class.build(Class.new, Target, :field, String).type).to eq(String) }
     specify { expect(described_class.build(Class.new, Target, :field) {}.defaultizer).to be_a(Proc) }
+
     specify do
       described_class.build(Class.new, Target, :field)
 

data/spec/granite/form/model/attributes/reflections/base_spec.rb

@@ -12,6 +12,7 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
       described_class.build(Class.new, Target, :field)
       expect(Target).not_to be_method_defined(:field)
     end
+
     specify { expect(described_class.build(Class.new, Target, :field).name).to eq('field') }
   end
 

data/spec/granite/form/model/attributes/reflections/represents/build_type_definition_spec.rb

@@ -4,7 +4,8 @@ require 'spec_helper'
 
 describe Granite::Form::Model::Attributes::Reflections::Represents::BuildTypeDefinition do
   def build_type_definition(name = :name, **options)
-    @reflection = Granite::Form::Model::Attributes::Reflections::Represents.new(name, options.reverse_merge(of: :author))
+    @reflection = Granite::Form::Model::Attributes::Reflections::Represents.new(name,
+                                                                                options.reverse_merge(of: :author))
     described_class.new(owner, @reflection).call
   end
 
@@ -102,6 +103,7 @@ describe Granite::Form::Model::Attributes::Reflections::Represents::BuildTypeDef
     it { expect(build_type_definition(:status)).to have_type(Integer) }
     it { expect(build_type_definition(:full_name)).to have_type(String) }
     it { expect(build_type_definition(:unknown_attribute)).to have_type(Object) }
+
     it do
       attribute = build_type_definition(:related_ids)
       expect(attribute).to be_a(Granite::Form::Types::Collection)

data/spec/granite/form/model/attributes/reflections/represents_spec.rb

@@ -23,7 +23,7 @@ describe Granite::Form::Model::Attributes::Reflections::Represents do
     end
 
     let(:instance) { Target.new attributes }
-    let(:attributes) { {subject: Author.new} }
+    let(:attributes) { { subject: Author.new } }
     let!(:reflection) { build_reflection }
 
     it { expect(reflection.reference).to eq('author') }
@@ -53,7 +53,7 @@ describe Granite::Form::Model::Attributes::Reflections::Represents do
       context 'when validate_reference is false' do
         let(:reflection) { build_reflection(validate_reference: false) }
 
-        it { expect { instance.validate }.not_to change { instance.errors.messages } }
+        it { expect { instance.validate }.not_to(change { instance.errors.messages }) }
       end
     end
   end

data/spec/granite/form/model/attributes/represents_spec.rb

@@ -23,9 +23,9 @@ describe Granite::Form::Model::Attributes::Represents do
   describe '#initialize' do
     before { Author.attribute :name, String, default: 'Default Name' }
 
-    let(:attributes) { {foo: 'bar'} }
+    let(:attributes) { { foo: 'bar' } }
 
-    it { expect { Model.new(attributes) }.to_not change { attributes } }
+    it { expect { Model.new(attributes) }.not_to(change { attributes }) }
 
     it { expect(attribute.read).to eq('Default Name') }
     it { expect(attribute.read_before_type_cast).to eq('Default Name') }

data/spec/granite/form/model/attributes_spec.rb

@@ -37,28 +37,33 @@ describe Granite::Form::Model::Attributes do
   describe '.inspect' do
     specify { expect(stub_model.inspect).to match(/#<Class:0x\w+>\(no attributes\)/) }
     specify { expect(stub_model(:user).inspect).to eq('User(no attributes)') }
+
     specify do
       expect(stub_model do
                include Granite::Form::Model::Primary
                primary :count, Integer
                attribute :object, Object
-             end.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/) end
+             end.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/)
+    end
+
     specify do
       expect(stub_model(:user) do
                include Granite::Form::Model::Primary
                primary :count, Integer
                attribute :object, Object
-             end.inspect).to match('User(*count: Integer, object: Object)') end
+             end.inspect).to match('User(*count: Integer, object: Object)')
+    end
   end
 
   describe '#==' do
+    subject { model.new name: 'hello', count: 42 }
+
     let(:model) do
       stub_model do
         attribute :name, String
         attribute :count, Float, default: 0
       end
     end
-    subject { model.new name: 'hello', count: 42 }
 
     it { is_expected.not_to eq(nil) }
     it { is_expected.not_to eq('hello') }
@@ -79,6 +84,7 @@ describe Granite::Form::Model::Attributes do
 
   describe '#attribute' do
     let(:instance) { model.new }
+
     specify { expect(instance.attribute(:full_name).reflection.name).to eq('full_name') }
     specify { expect(instance.attribute('full_name').reflection.name).to eq('full_name') }
     specify { expect(instance.attribute(:name).reflection.name).to eq('full_name') }
@@ -108,10 +114,12 @@ describe Granite::Form::Model::Attributes do
 
   describe '#attributes' do
     specify { expect(stub_model.new.attributes).to eq({}) }
+
     specify do
       expect(model.new(name: 'Name').attributes)
         .to match('id' => nil, 'full_name' => 'Name', 'author' => nil, 'projects' => nil)
     end
+
     specify do
       expect(model.new(name: 'Name').attributes(false))
         .to match('id' => nil, 'full_name' => 'Name')
@@ -119,13 +127,16 @@ describe Granite::Form::Model::Attributes do
   end
 
   describe '#assign_attributes' do
-    let(:attributes) { {id: 42, full_name: 'Name', missed: 'value'} }
     subject { model.new }
 
+    let(:attributes) { { id: 42, full_name: 'Name', missed: 'value' } }
+
     specify { expect { subject.assign_attributes(attributes) }.to change { subject.id }.to(42) }
     specify { expect { subject.assign_attributes(attributes) }.to change { subject.full_name }.to('Name') }
 
     context 'features stack and assign order' do
+      subject { model.new }
+
       let(:model) do
         stub_model do
           attr_reader :logger
@@ -147,7 +158,6 @@ describe Granite::Form::Model::Attributes do
           log(:plain2)
         end
       end
-      subject { model.new }
 
       specify do
         expect { subject.assign_attributes(plain1: 'value', plain2: 'value') }
@@ -176,18 +186,22 @@ describe Granite::Form::Model::Attributes do
             log(:assoc_plain)
 
             def assign_attributes(attrs)
-              super attrs.merge(attrs.extract!('plain2'))
+              super(attrs.merge(attrs.extract!('plain2')))
             end
           end
         end
 
         specify do
-          expect { subject.assign_attributes(assoc_plain: 'value', assoc_attributes: {}, plain1: 'value', plain2: 'value') }
+          expect do
+            subject.assign_attributes(assoc_plain: 'value', assoc_attributes: {}, plain1: 'value', plain2: 'value')
+          end
             .to change { subject.logger }.to(%i[plain1 assoc_attributes assoc_plain plain2])
         end
 
         specify do
-          expect { subject.assign_attributes(plain1: 'value', plain2: 'value', assoc_plain: 'value', assoc_attributes: {}) }
+          expect do
+            subject.assign_attributes(plain1: 'value', plain2: 'value', assoc_plain: 'value', assoc_attributes: {})
+          end
             .to change { subject.logger }.to(%i[plain1 assoc_attributes assoc_plain plain2])
         end
       end
@@ -212,7 +226,7 @@ describe Granite::Form::Model::Attributes do
 
     let(:author) { Author.new }
     let(:model) { Model.new(attributes) }
-    let(:attributes) { {author: author, name: 'Author Name', full_name: nil, age: 25} }
+    let(:attributes) { { author: author, name: 'Author Name', full_name: nil, age: 25 } }
 
     it { expect { model.sync_attributes }.to change(author, :name).to('Author Name') }
 
@@ -226,21 +240,27 @@ describe Granite::Form::Model::Attributes do
   describe '#inspect' do
     specify { expect(stub_model.new.inspect).to match(/#<#<Class:0x\w+> \(no attributes\)>/) }
     specify { expect(stub_model(:user).new.inspect).to match(/#<User \(no attributes\)>/) }
+
     specify do
       expect(stub_model do
                include Granite::Form::Model::Primary
                primary :count, Integer
                attribute :object, Object
-             end.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/) end
+             end.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/)
+    end
+
     specify do
       expect(stub_model(:user) do
                include Granite::Form::Model::Primary
                primary :count, Integer
                attribute :object, Object
-             end.new.inspect).to match(/#<User \*count: nil, object: nil>/) end
+             end.new.inspect).to match(/#<User \*count: nil, object: nil>/)
+    end
   end
 
   context 'attributes integration' do
+    subject { model.new('world') }
+
     let(:model) do
       stub_class do
         include Granite::Form::Util
@@ -257,9 +277,10 @@ describe Granite::Form::Model::Attributes do
         attribute :enum_with_default, Integer, enum: [1, 2, 3], default: '2'
         attribute :foo, Boolean, default: false
         collection :array, Integer, enum: [1, 2, 3], default: [2], normalizer: ->(v) { v.uniq }
-        dictionary :dict, Integer, keys: %w[from to], enum: [1, 2, 3], default: {from: 1}, normalizer: proc { |v|
+        dictionary :dict, Integer, keys: %w[from to], enum: [1, 2, 3], default: { from: 1 }, normalizer: proc { |v|
           next v if v[:from].nil? || v[:to].nil? || v[:from] <= v[:to]
-          {from: v[:to], to: v[:from]}.with_indifferent_access
+
+          { from: v[:to], to: v[:from] }.with_indifferent_access
         }
 
         def initialize(name = nil)
@@ -269,21 +290,19 @@ describe Granite::Form::Model::Attributes do
       end
     end
 
-    subject { model.new('world') }
-
-    its(:enum_values) { should == [1, 2, 3] }
-    its(:string_default) { should == 'world' }
-    its(:count_default) { should == '10' }
-    its(:name) { should == 'world' }
-    its(:hello) { should eq(nil) }
-    its(:hello?) { should eq(false) }
-    its(:count) { should == 10 }
-    its(:count_before_type_cast) { should == '10' }
-    its(:count_came_from_user?) { should eq(false) }
-    its(:count?) { should eq(true) }
-    its(:calc) { should == 5 }
-    its(:enum?) { should eq(false) }
-    its(:enum_with_default?) { should eq(true) }
+    its(:enum_values) { is_expected.to eq [1, 2, 3] }
+    its(:string_default) { is_expected.to eq 'world' }
+    its(:count_default) { is_expected.to eq '10' }
+    its(:name) { is_expected.to eq 'world' }
+    its(:hello) { is_expected.to eq(nil) }
+    its(:hello?) { is_expected.to eq(false) }
+    its(:count) { is_expected.to eq 10 }
+    its(:count_before_type_cast) { is_expected.to eq '10' }
+    its(:count_came_from_user?) { is_expected.to eq(false) }
+    its(:count?) { is_expected.to eq(true) }
+    its(:calc) { is_expected.to eq 5 }
+    its(:enum?) { is_expected.to eq(false) }
+    its(:enum_with_default?) { is_expected.to eq(true) }
     specify { expect { subject.hello = 'worlds' }.to change { subject.hello }.from(nil).to('worlds') }
     specify { expect { subject.count = 20 }.to change { subject.count }.from(10).to(20) }
     specify { expect { subject.calc = 15 }.to change { subject.calc }.from(5).to(15) }
@@ -294,22 +313,27 @@ describe Granite::Form::Model::Attributes do
         subject.enum = 3
         expect(subject.enum).to eq(3)
       end
+
       specify do
         subject.enum = '3'
         expect(subject.enum).to eq(3)
       end
+
       specify do
         subject.enum = 10
         expect(subject.enum).to eq(nil)
       end
+
       specify do
         subject.enum = 'hello'
         expect(subject.enum).to eq(nil)
       end
+
       specify do
         subject.enum_with_default = 3
         expect(subject.enum_with_default).to eq(3)
       end
+
       specify do
         subject.enum_with_default = 10
         expect(subject.enum_with_default).to be_nil
@@ -349,21 +373,37 @@ describe Granite::Form::Model::Attributes do
 
       specify do
         expect(subject).to have_attributes(
-          dict: {from: 1},
-          dict_before_type_cast: {from: 1},
+          dict: { from: 1 },
+          dict_before_type_cast: { from: 1 },
           dict?: true,
-          dict_default: {from: 1},
+          dict_default: { from: 1 },
           dict_values: [1, 2, 3]
         )
       end
 
-      specify { with_assigned_value(nil).to have_attributes(dict: {'from' => 1}, dict_before_type_cast: {from: 1}) }
+      specify { with_assigned_value(nil).to have_attributes(dict: { 'from' => 1 }, dict_before_type_cast: { from: 1 }) }
       specify { with_assigned_value([nil]).to have_attributes(dict: {}, dict_before_type_cast: [nil]) }
       specify { with_assigned_value(1).to have_attributes(dict: {}, dict_before_type_cast: 1) }
-      specify { with_assigned_value(from: 1, to: 2).to have_attributes(dict: {'from' => 1, 'to' => 2}, dict_before_type_cast: {from: 1, to: 2}) }
-      specify { with_assigned_value(from: 2, to: 4).to have_attributes(dict: {'from' => 2, 'to' => nil}, dict_before_type_cast: {from: 2, to: 4}) }
-      specify { with_assigned_value(from: '1', to: '2').to have_attributes(dict: {'from' => 1, 'to' => 2}, dict_before_type_cast: {from: '1', to: '2'}) }
-      specify { with_assigned_value(from: 3, to: 1).to have_attributes(dict: {'from' => 1, 'to' => 3}, dict_before_type_cast: {from: 3, to: 1}) }
+
+      specify do
+        with_assigned_value(from: 1, to: 2)
+          .to have_attributes(dict: { 'from' => 1, 'to' => 2 }, dict_before_type_cast: { from: 1, to: 2 })
+      end
+
+      specify do
+        with_assigned_value(from: 2, to: 4)
+          .to have_attributes(dict: { 'from' => 2, 'to' => nil }, dict_before_type_cast: { from: 2, to: 4 })
+      end
+
+      specify do
+        with_assigned_value(from: '1', to: '2')
+          .to have_attributes(dict: { 'from' => 1, 'to' => 2 }, dict_before_type_cast: { from: '1', to: '2' })
+      end
+
+      specify do
+        with_assigned_value(from: 3, to: 1)
+          .to have_attributes(dict: { 'from' => 1, 'to' => 3 }, dict_before_type_cast: { from: 3, to: 1 })
+      end
     end
 
     context 'attribute caching' do

data/spec/granite/form/model/dirty_spec.rb

@@ -45,16 +45,19 @@ describe Granite::Form::Model::Dirty do
     .tap { |m| m.update(author_id: author.id) }.changes)
       .to eq('author_id' => [other_author.id, author.id])
   end
+
   specify do
     expect(Model.instantiate(author_id: other_author.id)
     .tap { |m| m.update(author: author) }.changes)
       .to eq('author_id' => [other_author.id, author.id])
   end
+
   specify do
     expect(Model.instantiate(author_ids: [other_author.id])
     .tap { |m| m.update(author_ids: [author.id]) }.changes)
       .to eq('author_ids' => [[other_author.id], [author.id]])
   end
+
   specify do
     expect(Model.instantiate(author_ids: [other_author.id])
     .tap { |m| m.update(authors: [author]) }.changes)

data/spec/granite/form/model/persistence_spec.rb

@@ -19,7 +19,7 @@ describe Granite::Form::Model::Persistence do
     context do
       subject(:instance) { model.instantiate(name: 'Hello', foo: 'Bar') }
 
-      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
     end
   end
 
@@ -28,17 +28,27 @@ describe Granite::Form::Model::Persistence do
       subject(:instances) { model.instantiate_collection(name: 'Hello', foo: 'Bar') }
 
       specify { expect(subject).to be_a Array }
-      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+
+      specify do
+        expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys)
+      end
     end
 
     context do
+      subject(:instances) { model.instantiate_collection([{ name: 'Hello', foo: 'Bar' }, { name: 'World' }]) }
+
       before { model.send(:include, Granite::Form::Model::Scopes) }
-      subject(:instances) { model.instantiate_collection([{name: 'Hello', foo: 'Bar'}, {name: 'World'}]) }
 
       specify { expect(subject).to be_a Granite::Form::Model::Scopes::ScopeProxy }
       specify { expect(subject.count).to eq(2) }
-      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
-      specify { expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({name: 'World'}.stringify_keys) }
+
+      specify do
+        expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys)
+      end
+
+      specify do
+        expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({ name: 'World' }.stringify_keys)
+      end
     end
   end
 end