Merge pull request #2 from esebastian/include-module

Use the module with 'include' instead of 'extend'

Author: ZeroLiv-e

.gitignore

@@ -1 +1,6 @@
-*.gem
+## build artifacts
+*.gem
+
+## environment normalisation
+/.bundle/
+/vendor/bundle

README.md

@@ -16,7 +16,7 @@ A simple module to provide value objects semantics to a class.
 require 'value_object'
 
 class Point
-  extend ValueObject
+  include ValueObject
   fields :x, :y
 end
 
@@ -39,7 +39,7 @@ point.x = 3
 require 'value_object'
 
 class Point
-  extend ValueObject
+  include ValueObject
   fields :x, :y
 end
 
@@ -71,7 +71,7 @@ a_point.eql?(a_different_point)
 require 'value_object'
 
 class Point
-  extend ValueObject
+  include ValueObject
   fields :x, :y
 end
 
@@ -99,7 +99,7 @@ You can declare invariants to restrict field values on initialization
 require 'value_object'
 
 class Point
-  extend ValueObject
+  include ValueObject
   fields :x, :y
   invariants :x_less_than_y, :inside_first_quadrant
 

lib/exceptions.rb

@@ -24,7 +24,7 @@ def initialize(fields)
   end
 
   class WrongNumberOfArguments < Exception
-    def initialize fields_number, arguments_number
+    def initialize(fields_number, arguments_number)
       super "Declared #{fields_number} fields but passing #{arguments_number}"
     end
   end

lib/value_object.rb

@@ -1,89 +1,108 @@
 require 'exceptions'
 
 module ValueObject
-  def fields(*names)
-    raise NotDeclaredFields.new() if names.empty?()
 
-    attr_reader(*names)
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
 
-    define_method(:initialize) do |*values|
-      check_fields_are_initialized(values)
-      set_instance_variables(values)
-      check_invariants()
-    end
+  def initialize(*values)
+    @values = values
+    check_fields_are_initialized
+    set_instance_variables
+    check_invariants
+  end
 
-    define_method(:eql?) do |other|
-      self.class == other.class && values == other.values
-    end
+  def eql?(other)
+    self.class == other.class && values == other.values
+  end
 
-    define_method(:==) do |other|
-      eql?(other)
-    end
+  def ==(other)
+    eql?(other)
+  end
 
-    define_method(:hash) do
-      self.class.hash ^ values.hash
-    end
+  def hash
+    self.class.hash ^ values.hash
+  end
 
-    define_method(:values) do
-      names.map { |field| send(field) }
-    end
-    protected(:values)
+  protected
 
-    define_method(:check_invariants) do
-    end
-    private(:check_invariants)
+  def values
+    @values
+  end
 
-    define_method(:check_fields_are_initialized) do |values|
-      raise WrongNumberOfArguments.new(names.length, values.length) unless arguments_number_is_right?(values)
-      raise FieldWithoutValue.new(uninitialized_fields_names(values)) unless all_fields_initialized?(values)
-    end
-    private(:check_fields_are_initialized)
+  private
+
+  def names
+    self.class.field_names
+  end
+
+  def predicates
+    self.class.predicate_symbols
+  end
 
-    define_method(:arguments_number_is_right?) do |values|
-      fields_number = names.length
-      arguments_number = values.length
-      values.length == names.length
+  def check_fields_are_initialized
+    raise WrongNumberOfArguments.new(names.length, values.length) unless arguments_number_is_right?
+    raise FieldWithoutValue.new(uninitialized_field_names) unless all_fields_initialized?
+  end
+
+  def set_instance_variables
+    names.zip(values) do |name, value|
+      instance_variable_set(:"@#{name}", value)
     end
-    private(:arguments_number_is_right?)
+  end
+
+  def arguments_number_is_right?
+    values.length == names.length
+  end
+
+  def uninitialized_fields
+    names.zip(values).select { |name, value| value.nil? }
+  end
+
+  def all_fields_initialized?
+    uninitialized_fields.empty?
+  end
+
+  def uninitialized_field_names
+    uninitialized_fields.map { |field| field.first }
+  end
+
+  def check_invariants
+    return if predicates.nil?
 
-    define_method(:uninitialized_fields) do |values|
-      names.zip(values).select { |name, value| value.nil? }
+    predicates.each do |predicate|
+      valid = invariant_holds?(predicate)
+      raise ViolatedInvariant.new(predicate, values) unless valid
     end
-    private(:uninitialized_fields)
+  end
 
-    define_method(:all_fields_initialized?) do |values|
-      uninitialized_fields(values).empty?
+  def invariant_holds?(predicate_symbol)
+    begin
+      valid = send(predicate_symbol)
+    rescue
+      raise NotImplementedInvariant.new(predicate_symbol)
     end
-    private(:all_fields_initialized?)
+  end
 
-    define_method(:uninitialized_fields_names) do |values|
-      uninitialized_fields(values).map { |field| field.first }
+  module ClassMethods
+    def field_names
+      @field_names
     end
-    private(:uninitialized_fields_names)
 
-    define_method(:set_instance_variables) do |values|
-      names.zip(values) do |name, value|
-        instance_variable_set(:"@#{name}", value)
-      end
+    def predicate_symbols
+      @predicate_symbols
     end
-    private(:set_instance_variables)
-  end
 
-  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
+    def fields(*names)
+      raise NotDeclaredFields.new if names.empty?
+
+      attr_reader(*names)
+      @field_names = names
     end
 
-    define_method(:invariant_holds?) do |predicate_symbol|
-      begin
-        valid = send(predicate_symbol)
-      rescue
-        raise NotImplementedInvariant.new(predicate_symbol)
-      end
+    def invariants(*predicate_symbols)
+      @predicate_symbols = predicate_symbols
     end
-    private(:invariant_holds?)
   end
 end

spec/value_object_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
-require "./lib/value_object"
+require './lib/value_object'
 
 describe "ValueObject" do
 
   describe "standard behavior" do
     class Point
-      extend ValueObject
+      include ValueObject
       fields :x, :y
     end
 
@@ -38,80 +38,81 @@ class Point
   describe "restrictions" do
     describe "on declaration" do
       it "must at least have one field" do
-        expect do
-          class DummyWithNoFieldsUsingFieldsMethod
-            extend ValueObject
+        expect {
+          class Point
+            include ValueObject
             fields
           end
-        end.to raise_error(ValueObject::NotDeclaredFields)
+        }.to raise_error(ValueObject::NotDeclaredFields)
       end
     end
 
     describe "on initialization" do
       it "must not have any field initialized to nil" do
-        class DummyWithDeclaredFieldsWithoutValue
-          extend ValueObject
+        class Point
+          include ValueObject
           fields :x, :y
         end
 
-        expect{
-          DummyWithDeclaredFieldsWithoutValue.new 1, nil
-          }.to raise_error(ValueObject::FieldWithoutValue, "Declared fields [:y] must have value")
-        
+        expect {
+          Point.new 1, nil
+        }.to raise_error(ValueObject::FieldWithoutValue, "Declared fields [:y] must have value")
+
       end
-      
+
       it "must have number of values equal to number of fields" do
         class Point
-          extend ValueObject
+          include ValueObject
           fields :x, :y
         end
- 
-        expect{
+
+        expect {
           Point.new(1)
-          }.to raise_error(ValueObject::WrongNumberOfArguments)
-        
+        }.to raise_error(ValueObject::WrongNumberOfArguments)
 
-        expect{ Point.new(1, 2, 3) }.to raise_error(ValueObject::WrongNumberOfArguments, "Declared 2 fields but passing 3")
+        expect {
+          Point.new(1, 2, 3) 
+        }.to raise_error(ValueObject::WrongNumberOfArguments, "Declared 2 fields but passing 3")
       end
     end
   end
 
   describe "forcing invariants" do
     it "forces declared invariants" do
       class Point
-        extend ValueObject
+        include ValueObject
         fields :x, :y
         invariants :x_less_than_y, :inside_first_quadrant
 
         private
-        def inside_first_quadrant
-          x > 0 && y > 0
-        end
-
         def x_less_than_y
           x < y
         end
+
+        def inside_first_quadrant
+          x > 0 && y > 0
+        end
       end
 
-      expect{ Point.new(-5, 3) }.to raise_error(
-        ValueObject::ViolatedInvariant, "Fields values [-5, 3] violate invariant: inside_first_quadrant"
-      )
+      expect {
+        Point.new(6, 3)
+      }.to raise_error(ValueObject::ViolatedInvariant, "Fields values [6, 3] violate invariant: x_less_than_y")
 
-      expect{ Point.new(6, 3) }.to raise_error(
-        ValueObject::ViolatedInvariant, "Fields values [6, 3] violate invariant: x_less_than_y"
-      )
+      expect {
+        Point.new(-5, 3)
+      }.to raise_error(ValueObject::ViolatedInvariant, "Fields values [-5, 3] violate invariant: inside_first_quadrant")
     end
 
     it "raises an exception when a declared invariant has not been implemented" do
-      class PairOfIntegers
-        extend ValueObject
+      class Point
+        include ValueObject
         fields :x, :y
         invariants :integers
       end
 
-      expect{ PairOfIntegers.new(5, 2) }.to raise_error(
-        ValueObject::NotImplementedInvariant, "Invariant integers needs to be implemented"
-      )
+      expect {
+        Point.new(5, 2)
+      }.to raise_error(ValueObject::NotImplementedInvariant, "Invariant integers needs to be implemented")
     end
   end
 end