2 files changed, 66 insertions, 17 deletions

diff --git a/lib/puppet/network/format.rb b/lib/puppet/network/format.rb
index 7c678568d..832697836 100644
--- a/lib/puppet/network/format.rb
+++ b/lib/puppet/network/format.rb
@@ -23,5 +23,42 @@ class Puppet::Network::Format
         end
 
         instance_eval(&block) if block_given?
+
+        @intern_method = "from_%s" % name
+        @render_method = "to_%s" % name
+        @intern_multiple_method = "from_multiple_%s" % name
+        @render_multiple_method = "to_multiple_%s" % name
+    end
+
+    def intern(klass, text)
+        return klass.send(intern_method, text) if klass.respond_to?(intern_method)
+        raise NotImplementedError
+    end
+
+    def intern_multiple(klass, text)
+        return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
+        raise NotImplementedError
+    end
+
+    def render(instance)
+        return instance.send(render_method) if instance.respond_to?(render_method)
+        raise NotImplementedError
     end
+
+    def render_multiple(instances)
+        # This method implicitly assumes that all instances are of the same type.
+        return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
+        raise NotImplementedError
+    end
+
+    def supported?(klass)
+        klass.respond_to?(intern_method) and
+            klass.respond_to?(intern_multiple_method) and
+            klass.respond_to?(render_multiple_method) and
+            klass.instance_methods.include?(render_method)
+    end
+
+    private
+
+    attr_reader :intern_method, :render_method, :intern_multiple_method, :render_multiple_method
 end
diff --git a/lib/puppet/network/format_handler.rb b/lib/puppet/network/format_handler.rb
index 7e540708d..e42cc4c46 100644
--- a/lib/puppet/network/format_handler.rb
+++ b/lib/puppet/network/format_handler.rb
@@ -1,3 +1,4 @@
+require 'yaml'
 require 'puppet/network'
 require 'puppet/network/format'
 
@@ -23,31 +24,34 @@ module Puppet::Network::FormatHandler
         @formats[name]
     end
 
+    # Provide a list of all formats.
+    def self.formats
+        @formats.keys
+    end
+
     # Return a format capable of handling the provided mime type.
     def self.mime(mimetype)
         @formats.values.find { |format| format.mime == mimetype }
     end
 
     module ClassMethods
+        def format_handler
+            Puppet::Network::FormatHandler
+        end
+
         def convert_from(format, data)
             raise ArgumentError, "Format %s not supported" % format unless support_format?(format)
-            send("from_%s" % format, data)
+            format_handler.format(format).intern(self, data)
         end
 
         def convert_from_multiple(format, data)
-            if respond_to?("from_multiple_%s" % format)
-                send("from_multiple_%s" % format, data)
-            else
-                convert_from(format, data)
-            end
+            raise ArgumentError, "Format %s not supported" % format unless support_format?(format)
+            format_handler.format(format).intern_multiple(self, data)
         end
 
         def render_multiple(format, instances)
-            if respond_to?("to_multiple_%s" % format)
-                send("to_multiple_%s" % format, instances)
-            else
-                instances.send("to_%s" % format)
-            end
+            raise ArgumentError, "Format %s not supported" % format unless support_format?(format)
+            format_handler.format(format).render_multiple(instances)
         end
 
         def default_format
@@ -55,15 +59,19 @@ module Puppet::Network::FormatHandler
         end
 
         def support_format?(name)
-            respond_to?("from_%s" % name) and instance_methods.include?("to_%s" % name)
+            Puppet::Network::FormatHandler.format(name).supported?(self)
         end
 
         def supported_formats
-            instance = instance_methods.collect { |m| m =~ /^to_(.+)$/ and $1 }.compact
-            klass = methods.collect { |m| m =~ /^from_(.+)$/ and $1 }.compact
+            format_handler.formats.collect { |f| format_handler.format(f) }.find_all { |f| f.supported?(self) }.collect { |f| f.name }
+        end
 
-            # Return the intersection of the two lists.
-            return instance & klass
+        def from_marshal(text)
+            Marshal.load(text)
+        end
+
+        def from_yaml(text)
+            YAML.load(text)
         end
     end
 
@@ -75,12 +83,16 @@ module Puppet::Network::FormatHandler
                 format = self.class.default_format
             end
 
-            send("to_%s" % format)
+            Puppet::Network::FormatHandler.format(format).render(self)
         end
 
         def support_format?(name)
             self.class.support_format?(name)
         end
+
+        def to_marshal(instance)
+            Marshal.dump(instance)
+        end
     end
 end