granite-form 0.4.0 → 0.6.0

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'])

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

@@ -34,13 +34,16 @@ describe Granite::Form::Model::Validations::NestedValidator 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.name': ["can't be blank"])
@@ -48,23 +51,28 @@ describe Granite::Form::Model::Validations::NestedValidator 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"])
@@ -72,18 +80,22 @@ describe Granite::Form::Model::Validations::NestedValidator 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.name': ["can't be blank"])
@@ -91,26 +103,30 @@ describe Granite::Form::Model::Validations::NestedValidator do
   end
 
   context 'accepts nested attributes for one' do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: { id: 1, name: 'name' } }
+
     before { Main.accepts_nested_attributes_for :validated_one, allow_destroy: true }
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: {id: 1, name: 'name'} }
 
     specify do
-      instance.validated_one_attributes = {id: 1, name: '', _destroy: true}
-      is_expected.to be_valid
+      instance.validated_one_attributes = { id: 1, name: '', _destroy: true }
+      expect(subject).to be_valid
     end
   end
 
   context 'accepts nested attributes for many' do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ id: 1, name: 'name' }] }
+
     before { Main.accepts_nested_attributes_for :validated_many, allow_destroy: true }
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{id: 1, name: 'name'}] }
 
     specify do
-      instance.validated_many_attributes = [{id: 1, name: '', _destroy: true}]
-      is_expected.to be_valid
+      instance.validated_many_attributes = [{ id: 1, name: '', _destroy: true }]
+      expect(subject).to be_valid
     end
   end
 
   context 'object field is invalid and referenced object does not include AutosaveAssociation' do
+    subject(:instance) { Main.instantiate name: 'hello', object: object }
+
     before do
       stub_model(:validated_object) do
         attribute :title, String
@@ -125,8 +141,6 @@ describe Granite::Form::Model::Validations::NestedValidator do
       end
     end
 
-    subject(:instance) { Main.instantiate name: 'hello', object: object }
-
     context 'nested object is valid' do
       let(:object) { ValidatedObject.new(title: 'Mr.') }
 
@@ -190,8 +204,10 @@ describe Granite::Form::Model::Validations::NestedValidator 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"])

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

@@ -29,7 +29,7 @@ describe Granite::Form::Model::Validations do
     end
 
     context 'when attribute has different validations' do
-      let(:add_validations) { model.validates :name, length: {maximum: 100} }
+      let(:add_validations) { model.validates :name, length: { maximum: 100 } }
 
       it { is_expected.to be_falsey }
     end

data/spec/granite/form/model_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Granite::Form::Model do
   let(:model) { stub_model }
+
   specify { expect { model.blablabla }.to raise_error NoMethodError }
 
   context 'Fault tolerance' do

data/spec/granite/form/types/collection_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 RSpec.describe Granite::Form::Types::Collection do
   subject(:type) { described_class.new(subtype_definition) }
+
   let(:element_type) { Dummy }
   let(:subtype_definition) { Granite::Form::Types::Object.new(element_type, reflection, nil) }
   let(:reflection) { Granite::Form::Model::Attributes::Reflections::Base.new(:field) }
@@ -16,7 +17,7 @@ RSpec.describe Granite::Form::Types::Collection do
     context 'with Hash collection' do
       let(:element_type) { Hash }
 
-      specify { expect(subject.prepare([{key: 'value'}])).to eq([{key: 'value'}]) }
+      specify { expect(subject.prepare([{ key: 'value' }])).to eq([{ key: 'value' }]) }
     end
   end
 end

data/spec/granite/form/types/date_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Granite::Form::Types::Date do
     specify { expect(typecast('2013-06-13')).to eq(date) }
     specify { expect(typecast('2013-55-55')).to be_nil }
     specify { expect(typecast('blablabla')).to be_nil }
-    specify { expect(typecast(DateTime.new(2013, 6, 13, 23, 13))).to eq(date) } # rubocop:disable Style/DateTime
+    specify { expect(typecast(DateTime.new(2013, 6, 13, 23, 13))).to eq(date) }
     specify { expect(typecast(Time.new(2013, 6, 13, 23, 13))).to eq(date) }
     specify { expect(typecast(Date.new(2013, 6, 13))).to eq(date) }
   end

data/spec/granite/form/types/date_time_spec.rb

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 RSpec.describe Granite::Form::Types::DateTime do
-  # rubocop:disable Style/DateTime
   describe 'typecasting' do
     include_context 'type setup', 'DateTime'
     let(:datetime) { DateTime.new(2013, 6, 13, 23, 13) }
@@ -16,5 +15,4 @@ RSpec.describe Granite::Form::Types::DateTime do
     specify { expect(typecast(Time.utc(2013, 6, 13, 23, 13).utc)).to eq(datetime) }
     specify { expect(typecast(DateTime.new(2013, 6, 13, 23, 13))).to eq(datetime) }
   end
-  # rubocop:enable Style/DateTime
 end

data/spec/granite/form/types/dictionary_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Granite::Form::Types::Dictionary do
   subject(:type) { described_class.new(subtype_definition) }
+
   let(:element_type) { Dummy }
   let(:subtype_definition) { Granite::Form::Types::Object.new(element_type, reflection, nil) }
   let(:reflection) { build_reflection }

data/spec/granite/form/types/has_subtype_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Granite::Form::Types::HasSubtype do
   subject(:type) { described_class.new(subtype_definition) }
+
   let(:subtype_definition) { Granite::Form::Types::Object.new(Dummy, reflection, nil) }
   let(:reflection) { Granite::Form::Model::Attributes::Reflections::Base.new(:field) }
   let(:dummy_object) { Dummy.new }
@@ -12,9 +13,13 @@ describe Granite::Form::Types::HasSubtype do
 
   describe '#build_duplicate' do
     subject { type.build_duplicate(new_reflection, new_model) }
+
     let(:new_model) { double('new_model') }
     let(:new_reflection) { double('new_reflection') }
 
-    it { is_expected.to have_attributes(subtype_definition: have_attributes(type: Dummy, reflection: new_reflection, owner: new_model)) }
+    it {
+      expect(subject).to have_attributes(subtype_definition: have_attributes(type: Dummy, reflection: new_reflection,
+                                                                             owner: new_model))
+    }
   end
 end

data/spec/granite/form/types/hash_with_action_controller_parameters_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Granite::Form::Types::HashWithActionControllerParameters do
       Class.new(ActionController::Base)
     end
 
-    let(:to_h) { {'x' => {'foo' => 'bar'}, 'y' => 2} }
+    let(:to_h) { { 'x' => { 'foo' => 'bar' }, 'y' => 2 } }
     let(:parameters) { ActionController::Parameters.new(to_h) }
 
     specify { expect(typecast(nil)).to be_nil }

data/spec/granite/form/types/object_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 RSpec.describe Granite::Form::Types::Object do
   subject(:type) { build_type(reflection: reflection) }
+
   let(:model) { Model.new }
   let(:reflection) { build_reflection }
 
@@ -25,6 +26,7 @@ RSpec.describe Granite::Form::Types::Object do
 
   describe '#build_duplicate' do
     subject { type.build_duplicate(new_reflection, new_model) }
+
     let(:new_model) { double('new_model') }
     let(:new_reflection) { Granite::Form::Model::Attributes::Reflections::Base.new(:new_field) }
 

data/spec/granite/form/types/time_spec.rb

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 RSpec.describe Granite::Form::Types::Time do
-  # rubocop:disable Style/DateTime
   describe 'typecasting' do
     include_context 'type setup', 'Time'
 
@@ -27,5 +26,4 @@ RSpec.describe Granite::Form::Types::Time do
       specify { expect(typecast(Time.new(2013, 6, 13, 23, 13))).to eq(Time.new(2013, 6, 13, 23, 13)) }
     end
   end
-  # rubocop:enable Style/DateTime
 end

data/spec/granite/form/util_spec.rb

@@ -21,6 +21,7 @@ RSpec.describe Granite::Form::Util do
 
   describe '#evaluate' do
     subject { dummy.evaluate(target) }
+
     let(:target) { 'Peter' }
 
     it { is_expected.to eq('Peter') }
@@ -56,6 +57,7 @@ RSpec.describe Granite::Form::Util do
 
   describe '#evaluate_if_proc' do
     subject { dummy.evaluate(target) }
+
     let(:target) { 'Peter' }
 
     it { is_expected.to eq('Peter') }
@@ -77,7 +79,8 @@ RSpec.describe Granite::Form::Util do
 
   describe '#conditions_satisfied?' do
     subject { dummy.conditions_satisfied?(**conditions) }
-    let(:conditions) { {if: -> { name == 'John' }} }
+
+    let(:conditions) { { if: -> { name == 'John' } } }
 
     it { is_expected.to be_truthy }
 
@@ -88,7 +91,7 @@ RSpec.describe Granite::Form::Util do
     end
 
     context 'when unless condition is passed' do
-      let(:conditions) { {unless: :name} }
+      let(:conditions) { { unless: :name } }
 
       it { is_expected.to be_falsey }
     end
@@ -100,7 +103,7 @@ RSpec.describe Granite::Form::Util do
     end
 
     context 'when both if & unless are passed' do
-      let(:conditions) { {if: :name, unless: :name} }
+      let(:conditions) { { if: :name, unless: :name } }
 
       it { expect { subject }.to raise_error(ArgumentError) }
     end

data/spec/support/active_record.rb

@@ -20,4 +20,17 @@ ActiveRecord::Schema.define do
     t.column :related_ids, :integer, array: true
     t.column :data, :text
   end
+
+  if ActiveModel.version >= Gem::Version.new('7.0.0')
+    create_enum 'foo', %w[foo bar baz]
+
+    create_table :foo_containers, force: :cascade do |t|
+      t.enum :foos, enum_type: 'foo', array: true
+    end
+  end
+end
+
+if ActiveModel.version >= Gem::Version.new('7.0.0')
+  class FooContainer < ActiveRecord::Base
+  end
 end