active_data 1.0.0 → 1.1.0

data/spec/lib/active_data/model/attributes/attribute_spec.rb

@@ -5,12 +5,12 @@ describe ActiveData::Model::Attributes::Attribute do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Attribute, :field, {type: Object}.merge(options))
+    Dummy.add_attribute(ActiveData::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: ['hello', '42', 'world']) }
+    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq('world') }
     specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
@@ -26,7 +26,7 @@ describe ActiveData::Model::Attributes::Attribute do
   end
 
   describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:field) { attribute(type: String, normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
     specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
@@ -54,6 +54,7 @@ describe ActiveData::Model::Attributes::Attribute do
     specify { expect(attribute.defaultize(nil)).to be_nil }
     specify { expect(attribute(default: 'hello').defaultize(nil)).to eq('hello') }
     specify { expect(attribute(default: 'hello').defaultize('world')).to eq('world') }
+    specify { expect(attribute(default: false, type: Boolean).defaultize(nil)).to eq(false) }
   end
 
   describe '#typecast' do
@@ -68,7 +69,7 @@ describe ActiveData::Model::Attributes::Attribute do
     specify { expect(attribute.enum).to eq([].to_set) }
     specify { expect(attribute(enum: []).enum).to eq([].to_set) }
     specify { expect(attribute(enum: 'hello').enum).to eq(['hello'].to_set) }
-    specify { expect(attribute(enum: ['hello', 'world']).enum).to eq(['hello', 'world'].to_set) }
+    specify { expect(attribute(enum: %w[hello world]).enum).to eq(%w[hello world].to_set) }
     specify { expect(attribute(enum: [1..5]).enum).to eq([1..5].to_set) }
     specify { expect(attribute(enum: 1..5).enum).to eq((1..5).to_a.to_set) }
     specify { expect(attribute(enum: -> { 1..5 }).enum).to eq((1..5).to_a.to_set) }
@@ -97,21 +98,19 @@ describe ActiveData::Model::Attributes::Attribute 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') }
-      specify { expect(attribute(normalizer: ->(v, object) { object.value }).normalize(' hello ')).to eq('value') }
-      specify { expect(attribute(normalizer: ->(v, object) { other }).normalize(' hello ')).to eq('other') }
+      specify { expect(attribute(normalizer: ->(_v) { value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(_v, object) { object.value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(_v, _object) { other }).normalize(' hello ')).to eq('other') }
     end
 
     context 'integration' do
       before do
         allow(ActiveData).to receive_messages(config: ActiveData::Config.send(:new))
-        ActiveData.normalizer(:strip) do |value|
-          value.strip
-        end
-        ActiveData.normalizer(:trim) do |value, options, attribute|
+        ActiveData.normalizer(:strip) { |value, _, _| value.strip }
+        ActiveData.normalizer(:trim) do |value, options, _attribute|
           value.first(length || options[:length] || 2)
         end
-        ActiveData.normalizer(:reset) do |value, options, attribute|
+        ActiveData.normalizer(:reset) do |value, _options, attribute|
           empty = value.respond_to?(:empty?) ? value.empty? : value.nil?
           empty ? attribute.default : value
         end
@@ -120,24 +119,28 @@ describe ActiveData::Model::Attributes::Attribute do
       let(:length) { nil }
 
       specify { expect(attribute(normalizer: :strip).normalize(' hello ')).to eq('hello') }
-      specify { expect(attribute(normalizer: [:strip, :trim]).normalize(' hello ')).to eq('he') }
-      specify { expect(attribute(normalizer: [: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 } }, ->(v) { v.last(2) }])
-        .normalize(' hello ')).to eq('ll') }
+      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 do
+        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: [:strip, :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('!!!') }
       specify { expect(attribute(normalizer: :reset, default: '!!!').normalize('')).to eq('!!!') }
 
       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 } }, ->(v) { v.last(2) }])
-          .normalize(' hello ')).to eq('el') }
+        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) }])
+          .normalize(' hello ')).to eq('el')
+        end
       end
     end
   end

data/spec/lib/active_data/model/attributes/base_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes::Base do
@@ -6,12 +5,12 @@ describe ActiveData::Model::Attributes::Base do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Base, :field, options)
+    Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Base, :field, options)
     Dummy.new.attribute(:field)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v){ v ? v.strip : v }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
     let(:object) { Object.new }
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to be_nil }
@@ -25,7 +24,7 @@ describe ActiveData::Model::Attributes::Base do
   end
 
   describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:field) { attribute(type: String, normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
     let(:object) { Object.new }
 
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to be_nil }
@@ -52,7 +51,7 @@ describe ActiveData::Model::Attributes::Base do
     specify { expect(field.tap { |r| r.write([]) }).not_to be_value_present }
     specify { expect(field.tap { |r| r.write([42]) }).to be_value_present }
     specify { expect(field.tap { |r| r.write({}) }).not_to be_value_present }
-    specify { expect(field.tap { |r| r.write({hello: 42}) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(hello: 42) }).to be_value_present }
   end
 
   describe '#query' do
@@ -69,7 +68,7 @@ describe ActiveData::Model::Attributes::Base do
     specify { expect(field.tap { |r| r.write([]) }.query).to be(false) }
     specify { expect(field.tap { |r| r.write([42]) }.query).to be(true) }
     specify { expect(field.tap { |r| r.write({}) }.query).to be(false) }
-    specify { expect(field.tap { |r| r.write({hello: 42}) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(hello: 42) }.query).to be(true) }
   end
 
   describe '#readonly?' do

data/spec/lib/active_data/model/attributes/collection_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes::Collection do
@@ -6,12 +5,12 @@ describe ActiveData::Model::Attributes::Collection do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Collection, :field, options)
+    Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Collection, :field, options)
     Dummy.new.attribute(:field)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v){ v.uniq }, default: :world, enum: ['hello', '42']) }
+    let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world, enum: %w[hello 42]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
     specify { expect(field.tap { |r| r.write([nil]) }.read).to eq([nil]) }
@@ -20,11 +19,11 @@ describe ActiveData::Model::Attributes::Collection do
     specify { expect(field.tap { |r| r.write([43]) }.read).to eq([nil]) }
     specify { expect(field.tap { |r| r.write([43, 44]) }.read).to eq([nil]) }
     specify { expect(field.tap { |r| r.write(['']) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read).to eq(['hello', '42']) }
+    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read).to eq(%w[hello 42]) }
     specify { expect(field.tap { |r| r.write(['hello', false]) }.read).to eq(['hello', nil]) }
 
     context do
-      let(:field) { attribute(type: String, normalizer: ->(v){ v.uniq }, default: :world) }
+      let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world) }
 
       specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
       specify { expect(field.tap { |r| r.write([nil, nil]) }.read).to eq(['world']) }
@@ -35,7 +34,7 @@ describe ActiveData::Model::Attributes::Collection do
   end
 
   describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
     specify { expect(field.tap { |r| r.write([nil]) }.read_before_type_cast).to eq([:world]) }
@@ -51,7 +50,7 @@ describe ActiveData::Model::Attributes::Collection do
       let(:field) { attribute(type: String, default: :world) }
 
       specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
-      specify { expect(field.tap { |r| r.write([nil, nil]) }.read_before_type_cast).to eq([:world, :world]) }
+      specify { expect(field.tap { |r| r.write([nil, nil]) }.read_before_type_cast).to eq(%i[world world]) }
       specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq(['hello']) }
       specify { expect(field.tap { |r| r.write([42]) }.read_before_type_cast).to eq([42]) }
       specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
@@ -65,7 +64,7 @@ describe ActiveData::Model::Attributes::Collection do
       end
     end
 
-    specify { expect(Post.new(tags: ['hello', 42]).tags).to eq(['hello', '42']) }
+    specify { expect(Post.new(tags: ['hello', 42]).tags).to eq(%w[hello 42]) }
     specify { expect(Post.new(tags: ['hello', 42]).tags_before_type_cast).to eq(['hello', 42]) }
     specify { expect(Post.new.tags?).to eq(false) }
     specify { expect(Post.new(tags: ['hello', 42]).tags?).to eq(true) }

data/spec/lib/active_data/model/attributes/dictionary_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes::Dictionary do
@@ -6,33 +5,39 @@ describe ActiveData::Model::Attributes::Dictionary do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Dictionary, :field, options)
+    Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Dictionary, :field, options)
     Dummy.new.attribute(:field)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v){ v.delete_if { |_, v| v == nil } },
-      default: :world, enum: ['hello', '42']) }
+    let(:field) do
+      attribute(type: String,
+      normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
+      default: :world, enum: %w[hello 42])
+    end
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
     specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({a: nil}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({a: ''}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({a: 1}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({a: 42}) }.read).to eq({'a' => '42'}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', b: '42'}) }.read).to eq({'a' => 'hello', 'b' => '42'}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', b: '1'}) }.read).to eq({'a' => 'hello'}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', x: '42'}) }.read).to eq({'a' => 'hello', 'x' => '42'}) }
+    specify { expect(field.tap { |r| r.write(a: nil) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write(a: '') }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write(a: 42) }.read).to eq('a' => '42') }
+    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read).to eq('a' => 'hello', 'b' => '42') }
+    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read).to eq('a' => 'hello') }
+    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read).to eq('a' => 'hello', 'x' => '42') }
 
     context do
-      let(:field) { attribute(type: String, normalizer: ->(v){ v.delete_if { |_, v| v == nil } },
-        default: :world) }
+      let(:field) do
+        attribute(type: String,
+        normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
+        default: :world)
+      end
 
       specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
       specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({a: 1}) }.read).to eq({'a' => '1'}) }
-      specify { expect(field.tap { |r| r.write({a: nil, b: nil}) }.read).to eq({'a' => 'world', 'b' => 'world'}) }
-      specify { expect(field.tap { |r| r.write({a: ''}) }.read).to eq({'a' => ''}) }
+      specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq('a' => '1') }
+      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read).to eq('a' => 'world', 'b' => 'world') }
+      specify { expect(field.tap { |r| r.write(a: '') }.read).to eq('a' => '') }
     end
 
     context 'with :keys' do
@@ -40,32 +45,32 @@ describe ActiveData::Model::Attributes::Dictionary do
 
       specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
       specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({a: 1, 'b' => 2, c: 3, 'd' => 4}) }.read).to eq({'a' => '1', 'b' => '2'}) }
-      specify { expect(field.tap { |r| r.write({a: 1, c: 3, 'd' => 4}) }.read).to eq({'a' => '1'}) }
+      specify { expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read).to eq('a' => '1', 'b' => '2') }
+      specify { expect(field.tap { |r| r.write(a: 1, c: 3, 'd' => 4) }.read).to eq('a' => '1') }
     end
   end
 
   describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
     specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write({a: 1}) }.read_before_type_cast).to eq({'a' => 1}) }
-    specify { expect(field.tap { |r| r.write({a: nil}) }.read_before_type_cast).to eq({'a' => :world}) }
-    specify { expect(field.tap { |r| r.write({a: ''}) }.read_before_type_cast).to eq({'a' => ''}) }
-    specify { expect(field.tap { |r| r.write({a: 42}) }.read_before_type_cast).to eq({'a' => 42}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', b: '42'}) }.read_before_type_cast).to eq({'a' => 'hello', 'b' => '42'}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', b: '1'}) }.read_before_type_cast).to eq({'a' => 'hello', 'b' => '1'}) }
-    specify { expect(field.tap { |r| r.write({a: 'hello', x: '42'}) }.read_before_type_cast).to eq({'a' => 'hello', 'x' => '42'}) }
+    specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
+    specify { expect(field.tap { |r| r.write(a: nil) }.read_before_type_cast).to eq('a' => :world) }
+    specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
+    specify { expect(field.tap { |r| r.write(a: 42) }.read_before_type_cast).to eq('a' => 42) }
+    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '42') }
+    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '1') }
+    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read_before_type_cast).to eq('a' => 'hello', 'x' => '42') }
 
     context do
       let(:field) { attribute(type: String, default: :world) }
 
       specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
       specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({a: 1}) }.read_before_type_cast).to eq({'a' => 1}) }
-      specify { expect(field.tap { |r| r.write({a: nil, b: nil}) }.read_before_type_cast).to eq({'a' => :world, 'b' => :world}) }
-      specify { expect(field.tap { |r| r.write({a: ''}) }.read_before_type_cast).to eq({'a' => ''}) }
+      specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
+      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read_before_type_cast).to eq('a' => :world, 'b' => :world) }
+      specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
     end
 
     context 'with :keys' do
@@ -73,8 +78,10 @@ describe ActiveData::Model::Attributes::Dictionary do
 
       specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
       specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({a: 1, 'b' => 2, c: 3, 'd' => 4}) }.read_before_type_cast)
-        .to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}) }
+      specify do
+        expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read_before_type_cast)
+          .to eq('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4)
+      end
     end
   end
 
@@ -85,8 +92,8 @@ describe ActiveData::Model::Attributes::Dictionary do
       end
     end
 
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options).to eq({'a' => 'hello', 'b' => '42'}) }
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options_before_type_cast).to eq({'a' => 'hello', 'b' => 42}) }
+    specify { expect(Post.new(options: {a: 'hello', b: 42}).options).to eq('a' => 'hello', 'b' => '42') }
+    specify { expect(Post.new(options: {a: 'hello', b: 42}).options_before_type_cast).to eq('a' => 'hello', 'b' => 42) }
     specify { expect(Post.new.options?).to eq(false) }
     specify { expect(Post.new(options: {a: 'hello', b: 42}).options?).to eq(true) }
   end

data/spec/lib/active_data/model/attributes/localized_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes::Localized do
@@ -6,51 +5,51 @@ describe ActiveData::Model::Attributes::Localized do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Localized, :field, options)
+    Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Localized, :field, options)
     described_class.new('field', Dummy.new)
   end
 
   describe '#read' do
-    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read).to eq({ 'en' => 'hello' }) }
-    specify { expect(field.tap { |r| r.write({ en: 42 }) }.read).to eq({ 'en' => '42' }) }
-    specify { expect(field.tap { |r| r.write({ en: 43 }) }.read).to eq({ 'en' => nil }) }
-    specify { expect(field.tap { |r| r.write({ en: '' }) }.read).to eq({ 'en' => nil }) }
-    specify { expect(field.tap { |r| r.write({ en: nil }) }.read).to eq({ 'en' => nil }) }
-    specify { expect(field.tap { |r| r.write({ en: 'hello', ru: 42 }) }.read).to eq({ 'en' => 'hello', 'ru' => '42' }) }
+    specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
+    specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
+    specify { expect(field.tap { |r| r.write(en: 43) }.read).to eq('en' => nil) }
+    specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => nil) }
+    specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => nil) }
+    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read).to eq('en' => 'hello', 'ru' => '42') }
 
     context do
       let(:field) { attribute(type: String, default: :world) }
 
       specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read).to eq({ 'en' => 'hello' }) }
-      specify { expect(field.tap { |r| r.write({ en: 42 }) }.read).to eq({ 'en' => '42' }) }
-      specify { expect(field.tap { |r| r.write({ en: '' }) }.read).to eq({ 'en' => '' }) }
-      specify { expect(field.tap { |r| r.write({ en: nil }) }.read).to eq({ 'en' => 'world' }) }
+      specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
+      specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
+      specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => '') }
+      specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => 'world') }
     end
   end
 
   describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
 
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read_before_type_cast).to eq({ 'en' => 'hello' }) }
-    specify { expect(field.tap { |r| r.write({ en: 42 }) }.read_before_type_cast).to eq({ 'en' => 42 }) }
-    specify { expect(field.tap { |r| r.write({ en: 43 }) }.read_before_type_cast).to eq({ 'en' => 43 }) }
-    specify { expect(field.tap { |r| r.write({ en: '' }) }.read_before_type_cast).to eq({ 'en' => '' }) }
-    specify { expect(field.tap { |r| r.write({ en: nil }) }.read_before_type_cast).to eq({ 'en' => :world }) }
-    specify { expect(field.tap { |r| r.write({ en: 'hello', ru: 42 }) }.read_before_type_cast).to eq({ 'en' => 'hello', 'ru' => 42 }) }
+    specify { expect(field.tap { |r| r.write(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
+    specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
+    specify { expect(field.tap { |r| r.write(en: 43) }.read_before_type_cast).to eq('en' => 43) }
+    specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
+    specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
+    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read_before_type_cast).to eq('en' => 'hello', 'ru' => 42) }
 
     context do
       let(:field) { attribute(type: String, default: :world) }
 
       specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read_before_type_cast).to eq({ 'en' => 'hello' }) }
-      specify { expect(field.tap { |r| r.write({ en: 42 }) }.read_before_type_cast).to eq({ 'en' => 42 }) }
-      specify { expect(field.tap { |r| r.write({ en: '' }) }.read_before_type_cast).to eq({ 'en' => '' }) }
-      specify { expect(field.tap { |r| r.write({ en: nil }) }.read_before_type_cast).to eq({ 'en' => :world }) }
+      specify { expect(field.tap { |r| r.write(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
+      specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
+      specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
+      specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
     end
   end
 
@@ -63,7 +62,7 @@ describe ActiveData::Model::Attributes::Localized do
         localized :name, type: String
       end
     end
-    let(:translations) { { en: 'Hello', ru: 'Привет' } }
+    let(:translations) { {en: 'Hello', ru: 'Привет'} }
     before { I18n.locale = :en }
 
     describe '#name_translations' do
@@ -74,7 +73,7 @@ describe ActiveData::Model::Attributes::Localized do
 
     describe '#name' do
       subject { klass.new name: 'Hello' }
-      its(:name_translations) { should == { 'en' => 'Hello' } }
+      its(:name_translations) { should == {'en' => 'Hello'} }
       its(:name) { should == 'Hello' }
     end
 
@@ -85,14 +84,14 @@ describe ActiveData::Model::Attributes::Localized do
     end
 
     context 'fallbacks' do
-      subject { klass.new name_translations: { ru: 'Привет' } }
+      subject { klass.new name_translations: {ru: 'Привет'} }
       context do
         its(:name) { should be_nil }
       end
 
       context do
         before do
-          require "i18n/backend/fallbacks"
+          require 'i18n/backend/fallbacks'
           I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
           I18n.fallbacks.map(en: :ru)
         end

data/spec/lib/active_data/model/attributes/reflections/attribute_spec.rb

@@ -40,7 +40,7 @@ describe ActiveData::Model::Attributes::Reflections::Attribute do
   describe '#defaultizer' do
     specify { expect(reflection.defaultizer).to be_nil }
     specify { expect(reflection(default: 42).defaultizer).to eq(42) }
-    specify { expect(reflection(default: ->{ }).defaultizer).to be_a Proc }
+    specify { expect(reflection(default: -> {}).defaultizer).to be_a Proc }
   end
 
   describe '#typecaster' do
@@ -58,15 +58,15 @@ describe ActiveData::Model::Attributes::Reflections::Attribute do
   describe '#enumerizer' do
     specify { expect(reflection.enumerizer).to be_nil }
     specify { expect(reflection(enum: 42).enumerizer).to eq(42) }
-    specify { expect(reflection(enum: ->{ }).enumerizer).to be_a Proc }
+    specify { expect(reflection(enum: -> {}).enumerizer).to be_a Proc }
     specify { expect(reflection(in: 42).enumerizer).to eq(42) }
-    specify { expect(reflection(in: ->{ }).enumerizer).to be_a Proc }
-    specify { expect(reflection(enum: 42, in: ->{ }).enumerizer).to eq(42) }
+    specify { expect(reflection(in: -> {}).enumerizer).to be_a Proc }
+    specify { expect(reflection(enum: 42, in: -> {}).enumerizer).to eq(42) }
   end
 
   describe '#normalizers' do
     specify { expect(reflection.normalizers).to eq([]) }
-    specify { expect(reflection(normalizer: ->{}).normalizers).to be_a Array }
-    specify { expect(reflection(normalizer: ->{}).normalizers.first).to be_a Proc }
+    specify { expect(reflection(normalizer: -> {}).normalizers).to be_a Array }
+    specify { expect(reflection(normalizer: -> {}).normalizers.first).to be_a Proc }
   end
 end

data/spec/lib/active_data/model/attributes/represents_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes::Represents do
@@ -6,7 +5,7 @@ describe ActiveData::Model::Attributes::Represents do
 
   def attribute(*args)
     options = args.extract_options!
-    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Represents, :full_name, options.reverse_merge(of: :subject))
+    Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Represents, :full_name, options.reverse_merge(of: :subject))
     Dummy.new.attribute(:full_name)
   end
 
@@ -16,6 +15,13 @@ describe ActiveData::Model::Attributes::Represents do
     end
   end
 
+  describe '#new' do
+    before { attribute(:full_name) }
+    let(:attributes) { {foo: 'bar'} }
+
+    specify { expect { Dummy.new(attributes) }.to_not change { attributes } }
+  end
+
   describe '#write' do
     subject { Subject.new }
     before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
@@ -27,7 +33,7 @@ describe ActiveData::Model::Attributes::Represents do
   describe '#read' do
     subject { Subject.new(full_name: :hello) }
     before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
-    let(:field) { attribute(normalizer: ->(v){ v && v.is_a?(String) ? v.strip : v }, default: :world, enum: ['hello', '42', 'world', :world]) }
+    let(:field) { attribute(normalizer: ->(v) { v && v.is_a?(String) ? v.strip : v }, default: :world, enum: ['hello', '42', 'world', :world]) }
 
     specify { expect(field.read).to eq('hello') }
     specify { expect(field.tap { |r| r.write(nil) }.read).to eq(:world) }
@@ -54,7 +60,7 @@ describe ActiveData::Model::Attributes::Represents do
   describe '#read_before_type_cast' do
     subject { Subject.new(full_name: :hello) }
     before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
-    let(:field) { attribute(normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:field) { attribute(normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
 
     specify { expect(field.read_before_type_cast).to eq(:hello) }
     specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
@@ -76,78 +82,4 @@ describe ActiveData::Model::Attributes::Represents do
       specify { expect { sleep(0.01) }.not_to change { field.read_before_type_cast } }
     end
   end
-
-  context 'integration' do
-    before do
-      stub_model(:author) do
-        attribute :rate, Integer
-      end
-
-      stub_model(:post) do
-        attribute :author, Object
-        alias_attribute :a, :author
-        represents :rate, of: :a
-        alias_attribute :r, :rate
-      end
-    end
-    let(:author) { Author.new(rate: '42') }
-
-    specify { expect(Post.reflect_on_attribute(:rate).reference).to eq('author') }
-
-    specify { expect(Post.new(author: author).rate).to eq(42) }
-    specify { expect(Post.new(author: author).rate_before_type_cast).to eq('42') }
-    specify { expect(Post.new(rate: '33', author: author).rate).to eq(33) }
-    specify { expect(Post.new(rate: '33', author: author).author.rate).to eq(33) }
-    specify { expect(Post.new(r: '33', author: author).rate).to eq(33) }
-    specify { expect(Post.new(r: '33', author: author).author.rate).to eq(33) }
-    specify { expect(Post.new(author: author).rate?).to eq(true) }
-    specify { expect(Post.new(rate: nil, author: author).rate?).to eq(false) }
-
-    specify { expect(Post.new.rate).to be_nil }
-    specify { expect(Post.new.rate_before_type_cast).to be_nil }
-    specify { expect { Post.new(rate: '33') }.to raise_error(NoMethodError) }
-
-    context do
-      before do
-        stub_class(:author, ActiveRecord::Base)
-
-        stub_model(:post) do
-          include ActiveData::Model::Associations
-
-          references_one :author
-          alias_association :a, :author
-          represents :name, of: :a
-        end
-      end
-      let!(:author) { Author.create!(name: 42) }
-
-      specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
-
-      specify { expect(Post.new(name: '33', author: author).name).to eq('33') }
-      specify { expect(Post.new(name: '33', author: author).author.name).to eq('33') }
-    end
-
-    context 'multiple attributes in a single represents definition' do
-      before do
-        stub_model(:author) do
-          attribute :first_name, String
-          attribute :last_name, String
-        end
-
-        stub_model(:post) do
-          attribute :author, Object
-          represents :first_name, :last_name, of: :author
-        end
-      end
-
-      let(:author) { Author.new(first_name: 'John', last_name: 'Doe') }
-      let(:post) { Post.new }
-
-      specify do
-        expect { post.update(author: author) }
-          .to change { post.first_name }.to('John')
-          .and change { post.last_name }.to('Doe')
-      end
-    end
-  end
 end