Converter 1.0.1.0 → 1.0.2.0

data/lib/Converter.rb

@@ -6,17 +6,22 @@ module Converter
   end
 
   # Create new Target_Type instance according to Conversion definition
-  # @param [source] The instance to copy from
-  # @param [target_type] to target type to create instance of
+  # @param [Any Class] source instance to copy from
+  # @param [class] target_type the result type
   # @return instance of target_type with data from source
-  def self.convert(source, target_type)
+  def self.convert(source, target_type, hash = {})
     # Create new target instance
-    target = target_type.new
+    if(converted_target = hash[source])
+      return converted_target
+    end
+
+    # Create new target instance
+    hash[source] = target = target_type.new
 
     # Gets source Conversion definition
     conversion_properties = source.class.class_eval { @attribute_converter}
 
-    # update each accessor on the target according to the conversion definition
+    # update each accessor on the target according to the attr_converters
     source.instance_variables.each do |var|
       var_name = var.to_s.delete('@').to_sym
 
@@ -25,7 +30,12 @@ module Converter
         target_property_name = convert_property.target_property_name.to_s.concat('=').to_sym
 
         # Convert from one type to another (by default doesn't do anything)
-        target_value = convert_property.convert_block.call(source.send(var_name))
+        if convert_property.convert_block.parameters.count == 1
+          target_value = convert_property.convert_block.call(source.send(var_name))
+        else
+          target_value = convert_property.convert_block.call(source.send(var_name), hash)
+        end
+
         target.send(target_property_name, target_value)
       end
     end
@@ -33,9 +43,18 @@ module Converter
     target
   end
 
-  def self.convertBack(target, source_type)
+  # Create new source_type instance according to attr_converters
+  # @param [Any Class] target instance to copy from
+  # @param [class] source_type the result type
+  # @return instance of source_type with data from source
+  def self.convert_back(target, source_type, hash = {})
     # Create new target instance
-    source = source_type.new
+    if(converted_source = hash[target])
+      return converted_source
+    end
+
+    # Create new source instance
+    hash[target] = source = source_type.new
 
     # Gets source Conversion definition
     conversion_properties = source.class.class_eval { @attribute_converter }
@@ -49,7 +68,12 @@ module Converter
         target_property_name = convert_property.target_property_name
 
         # Convert from one type to another (by default doesn't do anything)
-        source_value = convert_property.convert_back_block.call(target.send(target_property_name))
+        if convert_property.convert_back_block.parameters.count == 1
+          source_value = convert_property.convert_back_block.call(target.send(target_property_name))
+        else
+          source_value = convert_property.convert_back_block.call(target.send(target_property_name), hash)
+        end
+
         source.send(var_name, source_value)
       end
     end
@@ -59,15 +83,30 @@ module Converter
 
   # This module add class extension of attr_converter
   module ClassConverter
-    def attr_converter(symbol, attr_another_name = nil, convert_bock = nil, convert_back_block = nil)
+    # Create an attr_accessor and map this attribute as convertable ,
+    # this means that this attribute will be converted when calling to Convert/
+    # @param [symbol] symbol attribute name
+    # @param [symbol] another_name the name of the converted attribute(on the target)
+    # @param [block] convert_block block that convert the source data type to the target data type
+    # @param [block] convert_back_block block that convert the target data type to the source data type
+    def attr_converter(symbol, attr_another_name = nil, convert_block = nil, convert_back_block = nil)
       # Set default values for nil arguments
       attr_another_name ||= symbol
-      convert_bock ||= lambda { |v| v }
-      convert_back_block ||= lambda { |v| v }
       @attribute_converter ||= {}
+      
+      if convert_block.class == Symbol
+        source_type = convert_block.to_s
+        target_type = convert_back_block.to_s
+        convert_block = lambda { |s,h| Converter.convert(s, eval(target_type), h)}
+        convert_back_block = lambda { |t,h| Converter.convert_back(t, eval(source_type), h)}
+      else
+        convert_block ||= lambda { |source, hash| source }
+        convert_back_block ||= lambda { |target, hash| target }
+      end
+
 
       # Create new ConversionMetadata
-      @attribute_converter[symbol] =ConversionMetadata.new(symbol, attr_another_name, convert_bock, convert_back_block)
+      @attribute_converter[symbol] =ConversionMetadata.new(symbol, attr_another_name, convert_block, convert_back_block)
       attr_accessor symbol
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Converter
 version: !ruby/object:Gem::Version
-  version: 1.0.1.0
+  version: 1.0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-07-20 00:00:00.000000000 Z
 dependencies: []
-description: Add attr_converter attribute creator that aps attributes to another object
+description: Add attr_converter to maps attributes to another object
 email: shukyc19@gmail.com
 executables: []
 extensions: []