Module: ValueObject

Defined in:
lib/value_object.rb

Defined Under Namespace

Classes: FieldWithoutValue, NotDeclaredFields, NotImplementedInvariant, ViolatedInvariant, WrongNumberOfArguments

Instance Method Summary collapse

Instance Method Details

#fields(*names) ⇒ Object

Raises:



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/value_object.rb', line 2

def fields(*names)
  raise NotDeclaredFields.new() if names.empty?()

  attr_reader(*names)

  define_method(:check_invariants) do
  end

  define_method(:check_fields_are_initialized) do |values|
    fields_number = names.length
    arguments_number = values.length

    raise WrongNumberOfArguments.new(fields_number, arguments_number) unless fields_number == arguments_number

    uninitialized_fields = names.zip(values).select { |name, value| value.nil? }
    uninitialized_fields_names = uninitialized_fields.map { |field| field.first }
    
    raise FieldWithoutValue.new(uninitialized_fields_names) unless uninitialized_fields.empty?
  end
  private(:check_fields_are_initialized)

  define_method(:initialize) do |*values|
    check_fields_are_initialized values

    names.zip(values) do |name, value|
      instance_variable_set(:"@#{name}", value)
    end
    check_invariants()
  end

  define_method(:values) do
    names.map { |field| send(field) }
  end
  protected(:values)

  define_method(:eql?) do |other|
    self.class == other.class && values == other.values
  end

  define_method(:==) do |other|
    eql?(other)
  end

  define_method(:hash) do
    self.class.hash ^ values.hash
  end
end

#invariants(*predicate_symbols) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/value_object.rb', line 50

def invariants(*predicate_symbols)
  define_method(:check_invariants) do
    predicate_symbols.each do |predicate_symbol|
      valid = invariant_holds?(predicate_symbol)
      raise ViolatedInvariant.new(predicate_symbol, self.values) unless valid
    end
  end

  define_method(:invariant_holds?) do |predicate_symbol|
    begin
      valid = send(predicate_symbol)
    rescue
      raise NotImplementedInvariant.new(predicate_symbol)
    end
  end
  private(:invariant_holds?)
end