active_data 1.0.0 → 1.1.0

data/spec/lib/active_data/model/attributes_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes do
@@ -34,24 +33,26 @@ describe ActiveData::Model::Attributes do
   end
 
   describe '.attribute_names' do
-    specify { expect(stub_model.attribute_names).to eq([])  }
+    specify { expect(stub_model.attribute_names).to eq([]) }
     specify { expect(model.attribute_names).to eq(%w[id full_name t author projects]) }
-    specify { expect(model.attribute_names(false)).to eq(%w[id full_name t])  }
+    specify { expect(model.attribute_names(false)).to eq(%w[id full_name t]) }
   end
 
   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 { expect(stub_model {
-      include ActiveData::Model::Primary
-      primary :count, Integer
-      attribute :object, Object
-    }.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/) }
-    specify { expect(stub_model(:user) {
-      include ActiveData::Model::Primary
-      primary :count, Integer
-      attribute :object, Object
-    }.inspect).to match('User(*count: Integer, object: Object)') }
+    specify do
+      expect(stub_model do
+               include ActiveData::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/) end
+    specify do
+      expect(stub_model(:user) do
+               include ActiveData::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.inspect).to match('User(*count: Integer, object: Object)') end
   end
 
   describe '#==' do
@@ -98,9 +99,9 @@ describe ActiveData::Model::Attributes do
   end
 
   describe '#attribute_names' do
-    specify { expect(stub_model.new.attribute_names).to eq([])  }
+    specify { expect(stub_model.new.attribute_names).to eq([]) }
     specify { expect(model.new.attribute_names).to eq(%w[id full_name t author projects]) }
-    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name t])  }
+    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name t]) }
   end
 
   describe '#attribute_present?' do
@@ -110,34 +111,108 @@ describe ActiveData::Model::Attributes do
   end
 
   describe '#attributes' do
-    specify { expect(stub_model.new.attributes).to eq({})  }
-    specify { expect(model.new(name: 'Name').attributes)
-      .to match({'id' => nil, 'full_name' => 'Name', 't' => {}, 'author' => nil, 'projects' => nil})  }
-    specify { expect(model.new(name: 'Name').attributes(false))
-      .to match({'id' => nil, 'full_name' => 'Name', 't' => {}})  }
+    specify { expect(stub_model.new.attributes).to eq({}) }
+    specify do
+      expect(model.new(name: 'Name').attributes)
+        .to match('id' => nil, 'full_name' => 'Name', 't' => {}, 'author' => nil, 'projects' => nil)
+    end
+    specify do
+      expect(model.new(name: 'Name').attributes(false))
+        .to match('id' => nil, 'full_name' => 'Name', 't' => {})
+    end
   end
 
   describe '#assign_attributes' do
-    let(:attributes) { { id: 42, full_name: 'Name', missed: 'value' } }
+    let(:attributes) { {id: 42, full_name: 'Name', missed: 'value'} }
     subject { model.new }
 
     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
+      let(:model) do
+        stub_model do
+          attr_reader :logger
+
+          def self.log(a)
+            define_method("#{a}=") do |*args|
+              log(a)
+              super(*args)
+            end
+          end
+
+          def log(o)
+            (@logger ||= []).push(o)
+          end
+
+          attribute :plain1, String
+          attribute :plain2, String
+          log(:plain1)
+          log(:plain2)
+        end
+      end
+      subject { model.new }
+
+      specify do
+        expect { subject.assign_attributes(plain1: 'value', plain2: 'value') }
+          .to change { subject.logger }.to(%i[plain1 plain2])
+      end
+
+      specify do
+        expect { subject.assign_attributes(plain2: 'value', plain1: 'value') }
+          .to change { subject.logger }.to(%i[plain2 plain1])
+      end
+
+      context do
+        before do
+          model.class_eval do
+            include ActiveData::Model::Representation
+            include ActiveData::Model::Associations
+
+            embeds_one :assoc do
+              attribute :assoc_plain, String
+            end
+            accepts_nested_attributes_for :assoc
+
+            represents :assoc_plain, of: :assoc
+
+            log(:assoc_attributes)
+            log(:assoc_plain)
+
+            def assign_attributes(attrs)
+              super attrs.merge(attrs.extract!('plain2'))
+            end
+          end
+        end
+
+        specify do
+          expect { subject.assign_attributes(assoc_plain: 'value', assoc_attributes: {}, plain1: 'value', plain2: 'value') }
+            .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: {}) }
+            .to change { subject.logger }.to(%i[plain1 assoc_attributes assoc_plain plain2])
+        end
+      end
+    end
   end
 
   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 { expect(stub_model {
-      include ActiveData::Model::Primary
-      primary :count, Integer
-      attribute :object, Object
-    }.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/) }
-    specify { expect(stub_model(:user) {
-      include ActiveData::Model::Primary
-      primary :count, Integer
-      attribute :object, Object
-    }.new.inspect).to match(/#<User \*count: nil, object: nil>/) }
+    specify do
+      expect(stub_model do
+               include ActiveData::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/) end
+    specify do
+      expect(stub_model(:user) do
+               include ActiveData::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.new.inspect).to match(/#<User \*count: nil, object: nil>/) end
   end
 
   context 'attributes integration' do
@@ -149,7 +224,7 @@ describe ActiveData::Model::Attributes do
 
         attribute :id, Integer
         attribute :hello, Object
-        attribute :string, String, default: ->(record){ record.name }
+        attribute :string, String, default: ->(record) { record.name }
         attribute :count, Integer, default: '10'
         attribute(:calc, Integer) { 2 + 3 }
         attribute :enum, Integer, enum: [1, 2, 3]
@@ -157,7 +232,7 @@ describe ActiveData::Model::Attributes do
         attribute :foo, Boolean, default: false
         collection :array, Integer, enum: [1, 2, 3], default: 7
 
-        def initialize name = nil
+        def initialize(name = nil)
           super()
           @name = name
         end
@@ -183,19 +258,49 @@ describe ActiveData::Model::Attributes do
     specify { expect { subject.calc = 15 }.to change { subject.calc }.from(5).to(15) }
 
     context 'enums' do
-      specify { subject.enum = 3; expect(subject.enum).to eq(3) }
-      specify { subject.enum = '3'; expect(subject.enum).to eq(3) }
-      specify { subject.enum = 10; expect(subject.enum).to eq(nil) }
-      specify { subject.enum = 'hello'; expect(subject.enum).to eq(nil) }
-      specify { subject.enum_with_default = 3; expect(subject.enum_with_default).to eq(3) }
-      specify { subject.enum_with_default = 10; expect(subject.enum_with_default).to be_nil }
+      specify 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
+      end
     end
 
     context 'array' do
-      specify { subject.array = [2, 4]; expect(subject.array).to eq([2, nil]) }
-      specify { subject.array = [2, 4]; expect(subject.array?).to eq(true) }
-      specify { subject.array = [2, 4]; expect(subject.array_values).to eq([1, 2, 3]) }
-      specify { subject.array = [2, 4]; expect(subject.array_default).to eq(7) }
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array).to eq([2, nil])
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array?).to eq(true)
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array_values).to eq([1, 2, 3])
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array_default).to eq(7)
+      end
     end
 
     context 'attribute caching' do
@@ -233,10 +338,10 @@ describe ActiveData::Model::Attributes do
     specify { expect(ancestor._attributes.keys).to eq(['foo']) }
     specify { expect(ancestor.instance_methods).to include :foo, :foo= }
     specify { expect(ancestor.instance_methods).not_to include :bar, :bar=, :baz, :baz= }
-    specify { expect(descendant1._attributes.keys).to eq(['foo', 'bar']) }
+    specify { expect(descendant1._attributes.keys).to eq(%w[foo bar]) }
     specify { expect(descendant1.instance_methods).to include :foo, :foo=, :bar, :bar= }
     specify { expect(descendant1.instance_methods).not_to include :baz, :baz= }
-    specify { expect(descendant2._attributes.keys).to eq(['foo', 'baz', 'moo']) }
+    specify { expect(descendant2._attributes.keys).to eq(%w[foo baz moo]) }
     specify { expect(descendant2.instance_methods).to include :foo, :foo=, :baz, :baz=, :moo, :moo= }
     specify { expect(descendant2.instance_methods).not_to include :bar, :bar= }
   end

data/spec/lib/active_data/model/callbacks_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Callbacks do
@@ -7,7 +6,7 @@ describe ActiveData::Model::Callbacks do
       include ActiveData::Model::Callbacks
       attribute :actions, Array, default: []
 
-      def append action
+      def append(action)
         self.actions = actions + [action]
       end
 
@@ -23,7 +22,7 @@ describe ActiveData::Model::Callbacks do
     end
 
     specify { expect(User.new.actions).to eq([:after_initialize]) }
-    specify { expect(User.create.actions).to eq([:after_initialize, :create]) }
+    specify { expect(User.create.actions).to eq(%i[after_initialize create]) }
   end
 
   describe '.before_save, .after_save' do
@@ -32,33 +31,33 @@ describe ActiveData::Model::Callbacks do
       User.after_save { append :after_save }
     end
 
-    specify { expect(User.create.actions).to eq([:before_save, :create, :after_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:before_save, :create, :after_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_save, :create, :after_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:before_save, :create, :after_save, :before_save, :update, :after_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_save, :create, :after_save, :before_save, :update, :after_save]) }
+    specify { expect(User.create.actions).to eq(%i[before_save create after_save]) }
+    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_save create after_save]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_save create after_save before_save update after_save]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save before_save update after_save]) }
 
     specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:before_save, :create, :after_save, :before_save]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_save create after_save before_save]) }
   end
 
   describe '.around_save' do
     before do
-      User.around_save do |user, block|
+      User.around_save do |_, block|
         append :before_around_save
         block.call
         append :after_around_save
       end
     end
 
-    specify { expect(User.create.actions).to eq([:before_around_save, :create, :after_around_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:before_around_save, :create, :after_around_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_around_save, :create, :after_around_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :update, :after_around_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :update, :after_around_save]) }
+    specify { expect(User.create.actions).to eq(%i[before_around_save create after_around_save]) }
+    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_save create after_around_save]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
 
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_around_save, :after_around_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :after_around_save]) }
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save after_around_save]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save create after_around_save before_around_save after_around_save]) }
   end
 
   describe '.before_create, .after_create' do
@@ -67,31 +66,31 @@ describe ActiveData::Model::Callbacks do
       User.after_create { append :after_create }
     end
 
-    specify { expect(User.create.actions).to eq([:before_create, :create, :after_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:before_create, :create, :after_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_create, :create, :after_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:before_create, :create, :after_create, :update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_create, :create, :after_create, :update]) }
+    specify { expect(User.create.actions).to eq(%i[before_create create after_create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_create create after_create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_create create after_create update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create update]) }
 
     specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_create]) }
   end
 
   describe '.around_create' do
     before do
-      User.around_create do |user, block|
+      User.around_create do |_, block|
         append :before_around_create
         block.call
         append :after_around_create
       end
     end
 
-    specify { expect(User.create.actions).to eq([:before_around_create, :create, :after_around_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:before_around_create, :create, :after_around_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_around_create, :create, :after_around_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:before_around_create, :create, :after_around_create, :update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_around_create, :create, :after_around_create, :update]) }
+    specify { expect(User.create.actions).to eq(%i[before_around_create create after_around_create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_create create after_around_create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_create create after_around_create update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create update]) }
 
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_around_create, :after_around_create]) }
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_create after_around_create]) }
   end
 
   describe '.before_update, .after_update' do
@@ -103,15 +102,15 @@ describe ActiveData::Model::Callbacks do
     specify { expect(User.create.actions).to eq([:create]) }
     specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
     specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:create, :before_update, :update, :after_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:create, :before_update, :update, :after_update]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_update update after_update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_update update after_update]) }
 
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:create, :before_update]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_update]) }
   end
 
   describe '.around_update' do
     before do
-      User.around_update do |user, block|
+      User.around_update do |_, block|
         append :before_around_update
         block.call
         append :after_around_update
@@ -121,10 +120,10 @@ describe ActiveData::Model::Callbacks do
     specify { expect(User.create.actions).to eq([:create]) }
     specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
     specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq([:create, :before_around_update, :update, :after_around_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:create, :before_around_update, :update, :after_around_update]) }
+    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_around_update update after_around_update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_around_update update after_around_update]) }
 
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:create, :before_around_update, :after_around_update]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_around_update after_around_update]) }
   end
 
   describe '.before_validation, .after_validation,
@@ -138,7 +137,7 @@ describe ActiveData::Model::Callbacks do
 
       User.before_save { append :before_save }
       User.after_save { append :after_save }
-      User.around_save do |user, block|
+      User.around_save do |_, block|
         append :before_around_save
         block.call
         append :after_around_save
@@ -146,7 +145,7 @@ describe ActiveData::Model::Callbacks do
 
       User.before_create { append :before_create }
       User.after_create { append :after_create }
-      User.around_create do |user, block|
+      User.around_create do |_, block|
         append :before_around_create
         block.call
         append :after_around_create
@@ -154,7 +153,7 @@ describe ActiveData::Model::Callbacks do
 
       User.before_update { append :before_update }
       User.after_update { append :after_update }
-      User.around_update do |user, block|
+      User.around_update do |_, block|
         append :before_around_update
         block.call
         append :after_around_update
@@ -162,32 +161,32 @@ describe ActiveData::Model::Callbacks do
 
       User.before_destroy { append :before_destroy }
       User.after_destroy { append :after_destroy }
-      User.around_destroy do |user, block|
+      User.around_destroy do |_, block|
         append :before_around_destroy
         block.call
         append :after_around_destroy
       end
     end
 
-    specify { expect(User.create.tap(&:save).destroy.actions).to eq([
-      :before_validation, :after_validation,
-      :before_save, :before_around_save,
-      :before_create, :before_around_create,
-      :create,
-      :after_around_create, :after_create,
-      :after_around_save, :after_save,
-
-      :before_validation, :after_validation,
-      :before_save, :before_around_save,
-      :before_update, :before_around_update,
-      :update,
-      :after_around_update, :after_update,
-      :after_around_save, :after_save,
-
-      :before_destroy, :before_around_destroy,
-      :destroy,
-      :after_around_destroy, :after_destroy
-    ]) }
+    specify do
+      expect(User.create.tap(&:save).destroy.actions).to eq(%i[
+        before_validation after_validation
+        before_save before_around_save
+        before_create before_around_create
+        create
+        after_around_create after_create
+        after_around_save after_save
+        before_validation after_validation
+        before_save before_around_save
+        before_update before_around_update
+        update
+        after_around_update after_update
+        after_around_save after_save
+        before_destroy before_around_destroy
+        destroy
+        after_around_destroy after_destroy
+      ])
+    end
   end
 
   describe '.before_destroy, .after_destroy' do
@@ -196,27 +195,27 @@ describe ActiveData::Model::Callbacks do
       User.after_destroy { append :after_destroy }
     end
 
-    specify { expect(User.new.destroy.actions).to eq([:before_destroy, :destroy, :after_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq([:create, :before_destroy, :destroy, :after_destroy]) }
+    specify { expect(User.new.destroy.actions).to eq(%i[before_destroy destroy after_destroy]) }
+    specify { expect(User.create.destroy.actions).to eq(%i[create before_destroy destroy after_destroy]) }
 
     specify { expect(User.new.destroy { false }.actions).to eq([:before_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq([:create, :before_destroy]) }
+    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_destroy]) }
   end
 
   describe '.around_destroy' do
     before do
-      User.around_destroy do |user, block|
+      User.around_destroy do |_, block|
         append :before_around_destroy
         block.call
         append :after_around_destroy
       end
     end
 
-    specify { expect(User.new.destroy.actions).to eq([:before_around_destroy, :destroy, :after_around_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq([:create, :before_around_destroy, :destroy, :after_around_destroy]) }
+    specify { expect(User.new.destroy.actions).to eq(%i[before_around_destroy destroy after_around_destroy]) }
+    specify { expect(User.create.destroy.actions).to eq(%i[create before_around_destroy destroy after_around_destroy]) }
 
-    specify { expect(User.new.destroy { false }.actions).to eq([:before_around_destroy, :after_around_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq([:create, :before_around_destroy, :after_around_destroy]) }
+    specify { expect(User.new.destroy { false }.actions).to eq(%i[before_around_destroy after_around_destroy]) }
+    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_around_destroy after_around_destroy]) }
   end
 
   context 'unsavable, undestroyable' do
@@ -229,7 +228,7 @@ describe ActiveData::Model::Callbacks do
 
         validates :validated, presence: true
 
-        def append action
+        def append(action)
           self.actions = actions + [action]
         end
       end
@@ -292,14 +291,14 @@ describe ActiveData::Model::Callbacks do
 
     specify do
       user.save { true }
-      expect(user.actions).to eq([:before_validation, :after_validation])
+      expect(user.actions).to eq(%i[before_validation after_validation])
     end
 
     specify do
       begin
         user.save! { true }
       rescue ActiveData::ValidationError
-        expect(user.actions).to eq([:before_validation, :after_validation])
+        expect(user.actions).to eq(%i[before_validation after_validation])
       end
     end
 

data/spec/lib/active_data/model/conventions_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Conventions do

data/spec/lib/active_data/model/dirty_spec.rb

@@ -1,9 +1,8 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Dirty do
   before do
-    stub_class(:author, ActiveRecord::Base) { }
+    stub_class(:author, ActiveRecord::Base) {}
     stub_model :premodel do
       include ActiveData::Model::Persistence
       include ActiveData::Model::Localization
@@ -20,7 +19,7 @@ describe ActiveData::Model::Dirty do
       embeds_one :something do
         attribute :value, String
       end
-      represents :name, of: :author
+      attribute :name, String
       alias_attribute :n, :name
       collection :numbers, Integer
       localized :title, String
@@ -38,21 +37,31 @@ describe ActiveData::Model::Dirty do
   specify { expect(Model.new(authors: [author]).changes).to eq('author_ids' => [[], [author.id]]) }
   specify { expect(Model.new(author_ids: [author.id]).changes).to eq('author_ids' => [[], [author.id]]) }
 
-  specify { expect(Model.new(author: author, name: 'Name2').changes)
-    .to eq('author_id' => [nil, author.id], 'name' => ['Name', 'Name2']) }
+  specify do
+    expect(Model.new(author: author, name: 'Name2').changes)
+      .to eq('author_id' => [nil, author.id], 'name' => [nil, 'Name2'])
+  end
 
-  specify { expect(Model.instantiate(author_id: other_author.id)
+  specify do
+    expect(Model.instantiate(author_id: other_author.id)
     .tap { |m| m.update(author_id: author.id) }.changes)
-    .to eq('author_id' => [other_author.id, author.id]) }
-  specify { expect(Model.instantiate(author_id: other_author.id)
+      .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]) }
-  specify { expect(Model.instantiate(author_ids: [other_author.id])
+      .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]]) }
-  specify { expect(Model.instantiate(author_ids: [other_author.id])
+      .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)
-    .to eq('author_ids' => [[other_author.id], [author.id]]) }
+      .to eq('author_ids' => [[other_author.id], [author.id]])
+  end
 
   specify { expect(Model.new(a: 'blabla').changes).to eq('age' => [33, nil]) }
   specify { expect(Model.new(a: '42').changes).to eq('age' => [33, 42]) }