Serializing Value Objects-Ara Hacopian

SerializingValue
Objects in Rails

AraHacopian
@ahacop
SmartLogic
© 2015

“[An] argument against Active Record is the fact that
it couples the object design to the database design.
This makes it more difﬁcult to refactor either
design...”

“[An] argument against Active Record is the fact that
it couples the object design to the database design.
This makes it more difﬁcult to refactor either
design...”
-- Martin Fowler, "Patterns of Enterprise Application
Architecture", inventor of the Active Record pattern

Single
Responsibility
Principle

Single ResponsibilityPrinciple
There should never be more than one reason for a
class to change

Single ResponsibilityPrinciple
Not: All the methods that do something with a person
go into the Person model

class Person < ActiveRecord::Base
def initials
ﬁrst_name.chr + middle_name.chr + last_name.chr
end
def armenian?
if last_name.end_with?('ian')
'probably'
else
'probably not'
end
end
def weight_in_pounds
weight
end
def weight_in_kilograms
(weight * 0.453592).round
end
def weight_in_stone
end
end

"Where shouldthis method go?"
def initials
ﬁrst_name.chr + middle_name.chr + last_name.chr
end
def armenian?
if last_name.end_with?('ian')
'probably'
else
'probably not'
end
end
def weight_in_pounds
weight
end
def weight_in_kilograms
end
def weight_in_stone
end
end

has_one?
has_one :weight
end
class Weight < ActiveRecord::Base
belongs_to :person
end

Value Objects
» A small object that represents a simple value
whose equality is based on its values rather than
its identity
» Immutable
» Examples: addresses, money, names.

Identityequalityin Ruby
> a = Object.new
> b = Object.new
> a.object_id
=> 70288883508240
> b.object_id
=> 70288892808780
> a == b
=> false

IdentityequalityinActiveRecord
> george_foreman = Person.create
> george_foreman.id
=> 1
> ara = Person.create
> ara.id
=> 2
> ara == george_foreman
=> false

> george_foreman2 = Person.ﬁnd(george_foreman.id)
> george_foreman2.id
=> 1
> george_foreman2 == george_foreman
=> true

> george_foreman.object_id
=> 70288888679260
> george_foreman2.object_id
=> 70288855436880
> george_foreman.object_id == george_foreman2.object_id
=> false

> george_foreman_jr = george_foreman.dup
> george_foreman_jr.id
=> nil
> george_foreman_jr == george_foreman
=> false

> george_foreman_iii = george_foreman.clone
> george_foreman_iii.id
=> 1
> george_foreman_iii == george_foreman
=> true

def ==(comparison_object)
super ||
comparison_object.instance_of?(self.class) &&
!id.nil? &&
comparison_object.id == id
end
alias :eql? :==

ExtractWeightfrom Person
class Weight
attr_reader :pounds
def initialize(pounds)
@pounds = pounds
end
def kilograms
(pounds * 0.453592).round
end
def stone
end
end

Weightequality
> buck_fifty = Weight.new(150)
> buck_fifty.pounds
=> 150
> buck_fifty.object_id
=> 70288888679260
> buck_fifty2 = Weight.new(150)
> buck_fifty2.pounds
=> 150
> buck_fifty2.object_id
=> 70288855436880

Weightequality
> buck_fifty.pounds == buck_fifty2.pounds
=> true
> buck_fifty.object_id == buck_fifty2.object_id
=> false
> buck_fifty == buck_fifty2
=> false

Weightequality
> weights = [Weight.new(150), Weight.new(150), Weight.new(150)]
> weights.uniq.length
=> 3
> pounds_values = [150, 150, 150]
> pounds_values.uniq.length
=> 1

Weightasavalue object
class Weight
include Comparable
def <=>(other)
other.instance_of?(self.class) && pounds <=> other.pounds
end
def eql?(other)
self == other
end
def hash
@hash ||= pounds.hash
end
end

Value equalityforWeight
> buck_fifty = Weight.new(150)
> buck_fifty2 = Weight.new(150)
> buck_fifty.object_id == buck_fifty2.object_id
=> false
> buck_fifty == buck_fifty2
=> true

Value equalityforWeight
> weights = [Weight.new(150), Weight.new(150), Weight.new(150)]
> weights.uniq.length
=> 1

Nameasavalue object
class Name
attr_reader :title, :first, :middle, :last, :suffix
def initialize(title, first, middle, last, suffix)
@title, @first, @middle, @last, @suffix = title, first, middle, last, suffix
end
def initials
first.chr + middle.chr + last.chr
end
def armenian?
if last.end_with?('ian')
'probably'
else
'probably not'
end
end

Nameasavalue object
def ==(other)
other.instance_of?(self.class) &&
title == other.title &&
first == other.first &&
middle == other.middle &&
last == other.last &&
suffix == other.suffix
end
alias :eql? :==
def hash
@hash ||= title.hash ^ first.hash ^ middle.hash ^ last.hash ^ suffix.hash
end
end

3Waysto SerializeValue Objects
1.Serialize
2.Virtual Attributes
3.Composed_of

serialize :weight, Weight
end

class Weight
class << self
def dump(weight)
weight.pounds
end
def load(pounds)
new(pounds)
end
end
@pounds = pounds
end

attr_reader :pounds
def kilograms
end
def stone
end
end

class Weight
include Comparable
attr_reader :pounds
class << self
def dump(weight)
weight.pounds
end
def load(pounds)
new(pounds)
end
end
@pounds = pounds
end
def kilograms
end
def stone
end
def <=>(other)
end
def eql?(other)
self == other
end
def hash
pounds.hash
end
end

Usingthevalue objectwithActiveRecord
weight = Weight.new(150)
person = Person.create(weight: weight)

class Weight
include Comparable
attr_reader :pounds
@pounds = pounds
end
def kilograms
end
def stone
end
def <=>(other)
end
def eql?(other)
self == other
end
def hash
pounds.hash
end
end

Person < ActiveRecord::Base
def weight
@weight ||= Weight.new(weight_value)
end
def weight=(other_weight)
self.weight_value = other_weight.pounds
@weight = other_weight
end
end

def name
@name ||= Name.new(title, first_name, middle_name, last_name,
suffix)
end
def name=(other_name)
self.title = other_name.title
self.first_name = other_name.first
self.middle_name = other_name.middle
self.last_name = other_name.last
self.suffix = other_name.suffix
@name = other_name
end
end

composed_of :name,
allow_nil: true,
mapping: [
%w(title title),
%w(first_name first),
%w(middle_name middle),
%w(last_name last),
%w(suffix suffix)
]
composed_of :weight,
allow_nil: true,
mapping: %w(weight_value pounds)
end

class Name
attr_reader :title, :first, :middle, :last, :suffix
def initialize(title, first, middle, last, suffix)
@title, @first, @middle, @last, @suffix = title, first, middle, last, suffix
end
# other stuff...
end

Serializing Value Objects-Ara Hacopian

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Serializing Value Objects-Ara Hacopian (20)

More from SmartLogic (20)

Recently uploaded (20)

Serializing Value Objects-Ara Hacopian