define instance methods in module body

Author: esebastian

lib/value_object.rb

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