Merge pull request #3 from tinkerbox/feature/optional_validation_and_serialization

Optional Validation and Serialization

Author: tbsmatt

README.md

@@ -55,7 +55,7 @@ address.errors.to_h # => {}
 
 ### Serialization with ActiveRecord
 
-The value object class can be used as the coder for the `serialize` method:
+For columns of `json` type, the value object class can be used as the coder for the `serialize` method:
 
 ```ruby
 class Customer < ActiveRecord::Base
@@ -69,6 +69,14 @@ customer.reload
 customer.home_address # => #<AddressValue:0x00ba9876543210 @street="123 Big Street", @postcode="12345", @city="Metropolis">
 ```
 
+For columns of `string` or `text` type, wrap the value object class in a `JsonCoder`:
+
+```ruby
+class Customer < ActiveRecord::Base
+  serialize :home_address, ValueObjects::ActiveRecord::JsonCoder.new(AddressValue)
+end
+```
+
 ### Validation with ActiveRecord
 
 By default, validating the record does not automatically validate the value object.
@@ -112,6 +120,26 @@ customer.home_address # => #<AddressValue:0x00ba9876503210 @street="321 Main St"
 
 This is functionally similar to what `accepts_nested_attributes_for` does for associations.
 
+Also, `value_object` will use the `JsonCoder` automatically if it detects that the column type is `string` or `text`.
+
+Additional options may be passed in to customize validation:
+
+```ruby
+class Customer < ActiveRecord::Base
+  include ValueObjects::ActiveRecord
+  value_object :home_address, AddressValue, allow_nil: true
+end
+```
+
+Or, to skip validation entirely:
+
+```ruby
+class Customer < ActiveRecord::Base
+  include ValueObjects::ActiveRecord
+  value_object :home_address, AddressValue, no_validation: true
+end
+```
+
 ### Value object collections
 
 Serialization and validation of value object collections are also supported.

lib/value_objects/active_record.rb

@@ -7,15 +7,40 @@ def self.included(base)
       base.extend self
     end
 
-    def value_object(attribute, value_class)
-      serialize(attribute, value_class)
-      validates_with(::ValueObjects::ValidValidator, attributes: [attribute])
+    def value_object(attribute, value_class, options = {})
+      coder =
+        case column_for_attribute(attribute).type
+        when :string, :text
+          JsonCoder.new(value_class)
+        else
+          value_class
+        end
+      serialize(attribute, coder)
+      validates_with(::ValueObjects::ValidValidator, options.merge(attributes: [attribute])) unless options[:no_validation]
       setter = :"#{attribute}="
       define_method("#{attribute}_attributes=") do |attributes|
         send(setter, value_class.new(attributes))
       end
     end
 
+    class JsonCoder
+
+      EMPTY_ARRAY = [].freeze
+
+      def initialize(value_class)
+        @value_class = value_class
+      end
+
+      def load(value)
+        @value_class.load(JSON.load(value) || EMPTY_ARRAY) if value
+      end
+
+      def dump(value)
+        value.to_json if value
+      end
+
+    end
+
   end
 
 end

lib/value_objects/value.rb

@@ -17,11 +17,11 @@ def to_hash
     class << self
 
       def load(value)
-        new(JSON.load(value)) if value
+        new(value) if value
       end
 
       def dump(value)
-        value.to_json if value
+        value.to_hash if value
       end
 
       def i18n_scope
@@ -55,11 +55,11 @@ def new(attributes)
         end
 
         def load(values)
-          values.blank? ? [] : JSON.load(values).map { |value| @value_class.new(value) } if values
+          (values.blank? ? [] : values.map { |value| @value_class.new(value) }) if values
         end
 
         def dump(values)
-          values.to_json if values
+          values.map(&:to_hash) if values
         end
 
       end

spec/value_objects/active_record_spec.rb

@@ -4,8 +4,10 @@
     self.verbose = false
 
     create_table :test_records do |t|
-      t.string :value
-      t.string :values
+      t.string :value, default: ''
+      t.string :value1
+      t.string :values, default: ''
+      t.string :values1
     end
 
   end
@@ -24,36 +26,81 @@ class TestRecord < ActiveRecord::Base
 
     include ValueObjects::ActiveRecord
 
-    value_object :value, FooBarValue
-    value_object :values, FooBarValue::Collection
+    value_object :value, FooBarValue, allow_nil: true
+    value_object :value1, FooBarValue, no_validation: true
+    value_object :values, FooBarValue::Collection, allow_nil: true
+    value_object :values1, FooBarValue::Collection, no_validation: true
 
   end
 
   describe 'serialization' do
 
-    let(:value) { FooBarValue.new(foo: '123', bar: 'abc') }
-    let(:values) { [FooBarValue.new(foo: 'abc', bar: '123'), FooBarValue.new(foo: 'cba', bar: 321)] }
-    let(:record) { TestRecord.create!(value: value, values: values).reload }
+    context 'with non-nil values' do
 
-    it 'serializes the value object' do
-      aggregate_failures do
-        expect(record.read_attribute_before_type_cast(:value)).to eq('{"foo":"123","bar":"abc"}')
-        expect(record.read_attribute_before_type_cast(:values)).to eq('[{"foo":"abc","bar":"123"},{"foo":"cba","bar":321}]')
+      let(:value) { FooBarValue.new(foo: '123', bar: 'abc') }
+      let(:values) { [FooBarValue.new(foo: 'abc', bar: '123'), FooBarValue.new(foo: 'cba', bar: 321)] }
+      let(:record) { TestRecord.create!(value: value, values: values).reload }
+
+      it 'serializes the value object' do
+        aggregate_failures do
+          expect(record.read_attribute_before_type_cast(:value)).to eq('{"foo":"123","bar":"abc"}')
+          expect(record.read_attribute_before_type_cast(:values)).to eq('[{"foo":"abc","bar":"123"},{"foo":"cba","bar":321}]')
+        end
+      end
+
+      it 'deserializes the value object' do
+        aggregate_failures do
+          expect(record.read_attribute(:value)).to eq(value)
+          expect(record.read_attribute(:values)).to eq(values)
+        end
       end
+
     end
 
-    it 'deserializes the value object' do
-      aggregate_failures do
-        expect(record.read_attribute(:value)).to eq(value)
-        expect(record.read_attribute(:values)).to eq(values)
+    context 'with nil values' do
+
+      let(:value) { nil }
+      let(:values) { nil }
+      let(:record) { TestRecord.create!(value: value, values: values).reload }
+
+      it 'serializes the value object' do
+        aggregate_failures do
+          expect(record.read_attribute_before_type_cast(:value)).to eq(nil)
+          expect(record.read_attribute_before_type_cast(:values)).to eq(nil)
+        end
       end
+
+      it 'deserializes the value object' do
+        aggregate_failures do
+          expect(record.read_attribute(:value)).to eq(value)
+          expect(record.read_attribute(:values)).to eq(values)
+        end
+      end
+
+    end
+
+    context 'with blank values' do
+
+      let(:value) { FooBarValue.new }
+      let(:values) { [] }
+      let(:record) { TestRecord.new.tap { |r| r.save!(validate: false) }.reload }
+
+      it 'deserializes the value object' do
+        aggregate_failures do
+          expect(record.read_attribute_before_type_cast(:value)).to eq('')
+          expect(record.read_attribute_before_type_cast(:values)).to eq('')
+          expect(record.read_attribute(:value)).to eq(value)
+          expect(record.read_attribute(:values)).to eq(values)
+        end
+      end
+
     end
 
   end
 
   describe 'validation' do
 
-    let(:record) { TestRecord.new(value: value, values: values).tap(&:valid?) }
+    let(:record) { TestRecord.new(value: value, value1: value, values: values, values1: values).tap(&:valid?) }
 
     context 'with valid values' do
 

spec/value_objects/value_spec.rb

@@ -56,15 +56,15 @@ class Collection < Collection
 
     context 'with empty value' do
 
-      let(:value) { TestValue.load('') }
+      let(:value) { TestValue.load({}) }
 
       it { expect(value).to eq(TestValue.new) }
 
     end
 
     context 'with non-empty value' do
 
-      let(:value) { TestValue.load('{"foo":321,"bar":"cba"}') }
+      let(:value) { TestValue.load('foo' => 321, 'bar' => 'cba') }
 
       it { expect(value).to eq(TestValue.new(foo: 321, bar: 'cba')) }
 
@@ -86,15 +86,15 @@ class Collection < Collection
 
       let(:value) { TestValue.dump(TestValue.new) }
 
-      it { expect(value).to eq('{"foo":null,"bar":null}') }
+      it { expect(value).to eq(foo: nil, bar: nil) }
 
     end
 
     context 'with non-empty value' do
 
       let(:value) { TestValue.dump(TestValue.new(foo: 321, bar: 'cba')) }
 
-      it { expect(value).to eq('{"foo":321,"bar":"cba"}') }
+      it { expect(value).to eq(foo: 321, bar: 'cba') }
 
     end
 
@@ -146,15 +146,15 @@ class Collection < Collection
 
     context 'with empty value' do
 
-      let(:value) { TestValue::Collection.load('') }
+      let(:value) { TestValue::Collection.load([]) }
 
       it { expect(value).to eq([]) }
 
     end
 
     context 'with non-empty value' do
 
-      let(:value) { TestValue::Collection.load('[{"foo":321,"bar":"cba"},{"foo":"abc","bar":123}]') }
+      let(:value) { TestValue::Collection.load([{ 'foo' => 321, 'bar' => 'cba' }, { 'foo' => 'abc', 'bar' => 123 }]) }
 
       it { expect(value).to eq([TestValue.new(foo: 321, bar: 'cba'), TestValue.new(foo: 'abc', bar: 123)]) }
 
@@ -176,15 +176,15 @@ class Collection < Collection
 
       let(:values) { TestValue::Collection.dump([]) }
 
-      it { expect(values).to eq('[]') }
+      it { expect(values).to eq([]) }
 
     end
 
     context 'with non-empty array' do
 
       let(:values) { TestValue::Collection.dump([TestValue.new(foo: 123, bar: 'abc'), TestValue.new(foo: 'cba', bar: 321)]) }
 
-      it { expect(values).to eq('[{"foo":123,"bar":"abc"},{"foo":"cba","bar":321}]') }
+      it { expect(values).to eq([{ foo: 123, bar: 'abc' }, { foo: 'cba', bar: 321 }]) }
 
     end