granite-form 0.5.0 → 0.6.0

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,6 +103,7 @@ 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) }
@@ -112,11 +117,12 @@ describe Granite::Form::Model::Attributes::Base do
       '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"', # rubocop:disable Style/DateTime
+      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

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

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

@@ -18,6 +18,7 @@ describe Granite::Form::Model::Primary do
 
     context do
       let(:object) { model.new(name: 'Hello') }
+
       specify { expect(object).not_to eq(object.clone.tap { |o| o.update(name: 'World') }) }
       specify { expect(object).not_to eql(object.clone.tap { |o| o.update(name: 'World') }) }
     end
@@ -43,6 +44,7 @@ describe Granite::Form::Model::Primary do
 
     context do
       let(:object) { model.new(name: 'Hello') }
+
       specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
       specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
     end
@@ -63,20 +65,33 @@ describe Granite::Form::Model::Primary do
     specify { expect(model.new.primary_attribute).to be_nil }
     specify { expect(model.new(name: 'Hello')).not_to eq(model.new(name: 'Hello')) }
     specify { expect(model.new(name: 'Hello')).not_to eql(model.new(name: 'Hello')) }
-    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eq(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
-    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eql(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
+
+    specify do
+      expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eq(model.new(name: 'Hello').tap do |o|
+                                                                        o.id = 2
+                                                                      end)
+    end
+
+    specify do
+      expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eql(model.new(name: 'Hello').tap do |o|
+                                                                         o.id = 2
+                                                                       end)
+    end
+
     specify { expect(model.new(id: 1).id).to be_nil }
     specify { expect(model.new.tap { |o| o.assign_attributes(id: 1) }.id).to be_nil }
     specify { expect(model.new.tap { |o| o.id = 1 }.id).to eq(1) }
 
     context do
       let(:object) { model.new(name: 'Hello').tap { |o| o.id = 1 } }
+
       specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
       specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
     end
 
     context do
       let(:object) { model.new(name: 'Hello') }
+
       specify { expect(object).to eq(object) }
       specify { expect(object).to eql(object) }
     end

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

@@ -11,12 +11,16 @@ describe Granite::Form::Model::Representation do
         include Granite::Form::Model::Representation
 
         attribute :author, Object
+        attribute :foo_container, Object
         alias_attribute :a, :author
         represents :rate, of: :a
+        represents :foos, of: :foo_container
         alias_attribute :r, :rate
       end
     end
+
     let(:author) { Author.new(rate: '42') }
+    let(:foos) { %w[foo bar] }
 
     specify { expect(Post.reflect_on_attribute(:rate).reference).to eq('author') }
 
@@ -30,8 +34,13 @@ describe Granite::Form::Model::Representation do
     specify { expect(Post.new.rate).to be_nil }
     specify { expect(Post.new.rate_before_type_cast).to be_nil }
 
+    if ActiveModel.version >= Gem::Version.new('7.0.0')
+      specify { expect { Post.new(foo_container: FooContainer.new, foos: foos) }.not_to raise_exception }
+    end
+
     context 'ActionController::Parameters' do
-      let(:params) { instance_double('ActionController::Parameters', to_unsafe_hash: {rate: '33', author: author}) }
+      let(:params) { instance_double('ActionController::Parameters', to_unsafe_hash: { rate: '33', author: author }) }
+
       specify { expect { Post.new(params) }.not_to raise_error }
     end
 
@@ -64,6 +73,7 @@ describe Granite::Form::Model::Representation do
           represents :name, of: :a
         end
       end
+
       let!(:author) { Author.create!(name: 42) }
 
       specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
@@ -129,13 +139,13 @@ describe Granite::Form::Model::Representation do
     if ActiveModel.version >= Gem::Version.new('6.1.0')
       specify do
         expect { post.validate }.to change { post.errors.details }
-          .to('author.user.email': [{error: 'is invalid'}], name: [{error: :blank}])
+          .to('author.user.email': [{ error: 'is invalid' }], name: [{ error: :blank }])
       end
     end
 
     context 'when using symbol in error message of represented model' do
       before do
-        Author.validates :name, inclusion: {in: ['Author'], message: :invalid_name, allow_blank: true}
+        Author.validates :name, inclusion: { in: ['Author'], message: :invalid_name, allow_blank: true }
         post.author.name = 'Not Author'
       end
 

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

@@ -9,14 +9,14 @@ describe Granite::Form::Model::Scopes do
 
       class << self
         def except_first
-          scope[1..-1]
+          scope[1..]
         end
 
         def no_mars
           scope.delete_if { |i| i.name == 'Mars' }
         end
 
-      private
+        private
 
         def hidden_method() end
       end
@@ -45,7 +45,12 @@ describe Granite::Form::Model::Scopes do
       let(:scope) { model.scope([model.new(name: 'Hello'), model.new(name: 'World'), model.new(name: 'Mars')]) }
 
       specify { expect(scope).to be_instance_of model.scope_class }
-      specify { expect { model.scope([model.new(name: 'Hello'), {}]) }.to raise_error Granite::Form::AssociationTypeMismatch }
+
+      specify do
+        expect do
+          model.scope([model.new(name: 'Hello'), {}])
+        end.to raise_error Granite::Form::AssociationTypeMismatch
+      end
 
       context 'scopes' do
         specify { expect(scope.except_first).to be_instance_of model.scope_class }

data/spec/granite/form/model/validations/associated_spec.rb

@@ -33,13 +33,16 @@ describe Granite::Form::Model::Validations::AssociatedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: {name: 'name'} }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: { name: 'name' } }
+
     it { is_expected.to be_valid }
   end
 
   context do
     subject(:instance) { Main.instantiate name: 'hello', validated_one: {} }
+
     it { is_expected.not_to be_valid }
+
     specify do
       expect { instance.validate }.to change { instance.errors.messages }
         .to(validated_one: ['is invalid'])
@@ -47,23 +50,28 @@ describe Granite::Form::Model::Validations::AssociatedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {name: 'name'} }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { name: 'name' } }
+
     it { is_expected.to be_valid }
   end
 
   context do
     subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {} }
+
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}] }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }] }
+
     it { is_expected.to be_valid }
   end
 
   context do
     subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}] }
+
     it { is_expected.not_to be_valid }
+
     specify do
       expect { instance.validate }.to change { instance.errors.messages }
         .to('validated_many.0.name': ["can't be blank"], validated_many: ['is invalid'])
@@ -71,18 +79,22 @@ describe Granite::Form::Model::Validations::AssociatedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{name: 'name'}] }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ name: 'name' }] }
+
     it { is_expected.to be_valid }
   end
 
   context do
     subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{}] }
+
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}], validated_one: {} }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }], validated_one: {} }
+
     it { is_expected.not_to be_valid }
+
     specify do
       expect { instance.validate }.to change { instance.errors.messages }
         .to(validated_one: ['is invalid'])
@@ -90,8 +102,10 @@ describe Granite::Form::Model::Validations::AssociatedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: {name: 'name'} }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: { name: 'name' } }
+
     it { is_expected.not_to be_valid }
+
     specify do
       expect { instance.validate }.to change { instance.errors.messages }
         .to('validated_many.0.name': ["can't be blank"], validated_many: ['is invalid'])