# class Puppet::Network::Format

A simple class for modeling encoding formats for moving instances around the network.

### Attributes

extension[RW]
intern_method[RW]
intern_multiple_method[RW]
mime[R]
name[R]
render_method[RW]
render_multiple_method[RW]
required_methods[RW]
weight[RW]

### Public Class Methods

new(name, options = {}, &block) click to toggle source

    # File lib/puppet/network/format.rb, line 21
    def initialize(name, options = {}, &block)
      @name = name.to_s.downcase.intern

      @options = options

      # This must be done early the values can be used to set required_methods
      define_method_names

      method_list = {
        :intern_method => "from_#{name}",
        :intern_multiple_method => "from_multiple_#{name}",
        :render_multiple_method => "to_multiple_#{name}",
        :render_method => "to_#{name}"
      }

      init_attribute(:mime, "text/#{name}")
      init_attribute(:weight, 5)
      init_attribute(:required_methods, method_list.keys)
      init_attribute(:extension, name.to_s)

      method_list.each do |method, value|
        init_attribute(method, value)
      end

      raise ArgumentError, "Unsupported option(s) #{@options.keys}" unless @options.empty?

      @options = nil

      instance_eval(&block) if block_given?
    end

### Public Instance Methods

init_attribute(name, default) click to toggle source

    # File lib/puppet/network/format.rb, line 12
    def init_attribute(name, default)
      if value = @options[name]
        @options.delete(name)
      else
        value = default
      end
      self.send(name.to_s + "=", value)
    end

intern(klass, text) click to toggle source

    # File lib/puppet/network/format.rb, line 52
    def intern(klass, text)
      return klass.send(intern_method, text) if klass.respond_to?(intern_method)
      raise NotImplementedError, "#{klass} does not respond to #{intern_method}; can not intern instances from #{mime}"
    end

intern_multiple(klass, text) click to toggle source

    # File lib/puppet/network/format.rb, line 57
    def intern_multiple(klass, text)
      return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
      raise NotImplementedError, "#{klass} does not respond to #{intern_multiple_method}; can not intern multiple instances from #{mime}"
    end

mime=(mime) click to toggle source

    # File lib/puppet/network/format.rb, line 62
    def mime=(mime)
      @mime = mime.to_s.downcase
    end

render(instance) click to toggle source

    # File lib/puppet/network/format.rb, line 66
    def render(instance)
      return instance.send(render_method) if instance.respond_to?(render_method)
      raise NotImplementedError, "#{instance.class} does not respond to #{render_method}; can not render instances to #{mime}"
    end

render_multiple(instances) click to toggle source

    # File lib/puppet/network/format.rb, line 71
    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, "#{instances[0].class} does not respond to #{render_multiple_method}; can not intern multiple instances to #{mime}"
    end

required_methods_present?(klass) click to toggle source

    # File lib/puppet/network/format.rb, line 77
    def required_methods_present?(klass)
      [:intern_method, :intern_multiple_method, :render_multiple_method].each do |name|
        return false unless required_method_present?(name, klass, :class)
      end

      return false unless required_method_present?(:render_method, klass, :instance)

      true
    end

supported?(klass) click to toggle source

    # File lib/puppet/network/format.rb, line 87
    def supported?(klass)
      suitable? and required_methods_present?(klass)
    end

to_s() click to toggle source

    # File lib/puppet/network/format.rb, line 91
    def to_s
      "Puppet::Network::Format[#{name}]"
    end