puppet 0.25.5 → 2.6.0

data/lib/puppet/network/client/report.rb

@@ -1,30 +1,26 @@
 class Puppet::Network::Client::Report < Puppet::Network::Client
-    @handler = Puppet::Network::Handler.handler(:report)
+  @handler = Puppet::Network::Handler.handler(:report)
 
-    def initialize(hash = {})
-        if hash.include?(:Report)
-            hash[:Report] = self.class.handler.new
-        end
+  def initialize(hash = {})
+    hash[:Report] = self.class.handler.new if hash.include?(:Report)
 
-        super(hash)
-    end
-
-    # Send our report.  We get the transaction report and convert it to YAML
-    # as appropriate.
-    def report(transreport)
-        report = YAML.dump(transreport)
+    super(hash)
+  end
 
-        unless self.local
-            report = CGI.escape(report)
-        end
+  # Send our report.  We get the transaction report and convert it to YAML
+  # as appropriate.
+  def report(transreport)
+    report = YAML.dump(transreport)
 
-        # Now send the report
-        file = nil
-        benchmark(:info, "Sent transaction report") do
-            file = @driver.report(report)
-        end
+    report = CGI.escape(report) unless self.local
 
-        file
+    # Now send the report
+    file = nil
+    benchmark(:info, "Sent transaction report") do
+      file = @driver.report(report)
     end
+
+    file
+  end
 end
 

data/lib/puppet/network/client/runner.rb

@@ -1,12 +1,10 @@
 class Puppet::Network::Client::Runner < Puppet::Network::Client::ProxyClient
-    self.mkmethods
+  self.mkmethods
 
-    def initialize(hash = {})
-        if hash.include?(:Runner)
-            hash[:Runner] = self.class.handler.new()
-        end
+  def initialize(hash = {})
+    hash[:Runner] = self.class.handler.new if hash.include?(:Runner)
 
-        super(hash)
-    end
+    super(hash)
+  end
 end
 

data/lib/puppet/network/client/status.rb

@@ -1,4 +1,4 @@
 class Puppet::Network::Client::Status < Puppet::Network::Client::ProxyClient
-    self.mkmethods
+  self.mkmethods
 end
 

data/lib/puppet/network/client_request.rb

@@ -1,31 +1,29 @@
 module Puppet::Network # :nodoc:
-    # A struct-like class for passing around a client request.  It's mostly
-    # just used for validation and authorization.
-    class ClientRequest
-        attr_accessor :name, :ip, :authenticated, :handler, :method
+  # A struct-like class for passing around a client request.  It's mostly
+  # just used for validation and authorization.
+  class ClientRequest
+    attr_accessor :name, :ip, :authenticated, :handler, :method
 
-        def authenticated?
-            self.authenticated
-        end
+    def authenticated?
+      self.authenticated
+    end
 
-        # A common way of talking about the full call.  Individual servers
-        # are responsible for setting the values correctly, but this common
-        # format makes it possible to check rights.
-        def call
-            unless handler and method
-                raise ArgumentError, "Request is not set up; cannot build call"
-            end
+    # A common way of talking about the full call.  Individual servers
+    # are responsible for setting the values correctly, but this common
+    # format makes it possible to check rights.
+    def call
+      raise ArgumentError, "Request is not set up; cannot build call" unless handler and method
 
-            [handler, method].join(".")
-        end
+      [handler, method].join(".")
+    end
 
-        def initialize(name, ip, authenticated)
-            @name, @ip, @authenticated = name, ip, authenticated
-        end
+    def initialize(name, ip, authenticated)
+      @name, @ip, @authenticated = name, ip, authenticated
+    end
 
-        def to_s
-            "%s(%s)" % [self.name, self.ip]
-        end
+    def to_s
+      "#{self.name}(#{self.ip})"
     end
+  end
 end
 

data/lib/puppet/network/format.rb

@@ -4,110 +4,108 @@ require 'puppet/provider/confiner'
 # A simple class for modeling encoding formats for moving
 # instances around the network.
 class Puppet::Network::Format
-    include Puppet::Provider::Confiner
-
-    attr_reader :name, :mime
-    attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods
-
-    def init_attribute(name, default)
-        if value = @options[name]
-            @options.delete(name)
-        else
-            value = default
-        end
-        self.send(name.to_s + "=", value)
-    end
-
-    def initialize(name, options = {}, &block)
-        @name = name.to_s.downcase.intern
+  include Puppet::Provider::Confiner
 
-        @options = options
+  attr_reader :name, :mime
+  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension
 
-        # This must be done early the values can be used to set required_methods
-        define_method_names()
+  def init_attribute(name, default)
+    if value = @options[name]
+      @options.delete(name)
+    else
+      value = default
+    end
+    self.send(name.to_s + "=", value)
+  end
 
-        method_list = {
-            :intern_method => "from_%s" % name,
-            :intern_multiple_method => "from_multiple_%s" % name,
-            :render_multiple_method => "to_multiple_%s" % name,
-            :render_method => "to_%s" % name
-        }
+  def initialize(name, options = {}, &block)
+    @name = name.to_s.downcase.intern
 
-        init_attribute(:mime, "text/%s" % name)
-        init_attribute(:weight, 5)
-        init_attribute(:required_methods, method_list.keys)
+    @options = options
 
-        method_list.each do |method, value|
-            init_attribute(method, value)
-        end
+    # This must be done early the values can be used to set required_methods
+    define_method_names
 
-        unless @options.empty?
-            raise ArgumentError, "Unsupported option(s) %s" % @options.keys
-        end
+    method_list = {
+      :intern_method => "from_#{name}",
+      :intern_multiple_method => "from_multiple_#{name}",
+      :render_multiple_method => "to_multiple_#{name}",
+      :render_method => "to_#{name}"
+    }
 
-        @options = nil
+    init_attribute(:mime, "text/#{name}")
+    init_attribute(:weight, 5)
+    init_attribute(:required_methods, method_list.keys)
+    init_attribute(:extension, name.to_s)
 
-        instance_eval(&block) if block_given?
+    method_list.each do |method, value|
+      init_attribute(method, value)
     end
 
-    def intern(klass, text)
-        return klass.send(intern_method, text) if klass.respond_to?(intern_method)
-        raise NotImplementedError, "%s does not respond to %s; can not intern instances from %s" % [klass, intern_method, mime]
-    end
+    raise ArgumentError, "Unsupported option(s) #{@options.keys}" unless @options.empty?
 
-    def intern_multiple(klass, text)
-        return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
-        raise NotImplementedError, "%s does not respond to %s; can not intern multiple instances from %s" % [klass, intern_multiple_method, mime]
-    end
+    @options = nil
 
-    def mime=(mime)
-        @mime = mime.to_s.downcase
-    end
+    instance_eval(&block) if block_given?
+  end
 
-    def render(instance)
-        return instance.send(render_method) if instance.respond_to?(render_method)
-        raise NotImplementedError, "%s does not respond to %s; can not render instances to %s" % [instance.class, render_method, mime]
-    end
+  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
 
-    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, "%s does not respond to %s; can not intern multiple instances to %s" % [instances[0].class, render_multiple_method, mime]
-    end
+  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
 
-    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
+  def mime=(mime)
+    @mime = mime.to_s.downcase
+  end
 
-        return false unless required_method_present?(:render_method, klass, :instance)
+  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
 
-        return true
-    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, "#{instances[0].class} does not respond to #{render_multiple_method}; can not intern multiple instances to #{mime}"
+  end
 
-    def supported?(klass)
-        suitable? and required_methods_present?(klass)
+  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
 
-    def to_s
-        "Puppet::Network::Format[%s]" % name
-    end
+    return false unless required_method_present?(:render_method, klass, :instance)
 
-    private
+    true
+  end
 
-    def define_method_names
-        @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 supported?(klass)
+    suitable? and required_methods_present?(klass)
+  end
 
-    def required_method_present?(name, klass, type)
-        return true unless required_methods.include?(name)
+  def to_s
+    "Puppet::Network::Format[#{name}]"
+  end
 
-        method = send(name)
+  private
 
-        return klass.respond_to?(method) if type == :class
-        return klass.instance_methods.include?(method)
-    end
+  def define_method_names
+    @intern_method = "from_#{name}"
+    @render_method = "to_#{name}"
+    @intern_multiple_method = "from_multiple_#{name}"
+    @render_multiple_method = "to_multiple_#{name}"
+  end
+
+  def required_method_present?(name, klass, type)
+    return true unless required_methods.include?(name)
+
+    method = send(name)
+
+    return(type == :class ? klass.respond_to?(method) : klass.instance_methods.include?(method))
+  end
 end

data/lib/puppet/network/format_handler.rb

@@ -3,168 +3,173 @@ require 'puppet/network'
 require 'puppet/network/format'
 
 module Puppet::Network::FormatHandler
-    class FormatError < Puppet::Error; end
+  class FormatError < Puppet::Error; end
+
+  class FormatProtector
+    attr_reader :format
+
+    def protect(method, args)
+        Puppet::Network::FormatHandler.format(format).send(method, *args)
+    rescue => details
+        direction = method.to_s.include?("intern") ? "from" : "to"
+        error = FormatError.new("Could not #{method} #{direction} #{format}: #{details}")
+        error.set_backtrace(details.backtrace)
+        raise error
+    end
 
-    class FormatProtector
-        attr_reader :format
+    def initialize(format)
+      @format = format
+    end
 
-        def protect(method, args)
-            begin
-                Puppet::Network::FormatHandler.format(format).send(method, *args)
-            rescue => details
-                direction = method.to_s.include?("intern") ? "from" : "to"
-                error = FormatError.new("Could not %s %s %s: %s" % [method, direction, format, details])
-                error.set_backtrace(details.backtrace)
-                raise error
-            end
-        end
+    [:intern, :intern_multiple, :render, :render_multiple, :mime].each do |method|
+      define_method(method) do |*args|
+        protect(method, args)
+      end
+    end
+  end
 
-        def initialize(format)
-            @format = format
-        end
+  @formats = {}
+  def self.create(*args, &block)
+    instance = Puppet::Network::Format.new(*args)
+    instance.instance_eval(&block) if block_given?
 
-        [:intern, :intern_multiple, :render, :render_multiple, :mime].each do |method|
-            define_method(method) do |*args|
-                protect(method, args)
-            end
-        end
-    end
+    @formats[instance.name] = instance
+    instance
+  end
 
-    @formats = {}
-    def self.create(*args, &block)
-        instance = Puppet::Network::Format.new(*args)
-        instance.instance_eval(&block) if block_given?
+  def self.extended(klass)
+    klass.extend(ClassMethods)
 
-        @formats[instance.name] = instance
-        instance
-    end
+    # LAK:NOTE This won't work in 1.9 ('send' won't be able to send
+    # private methods, but I don't know how else to do it.
+    klass.send(:include, InstanceMethods)
+  end
 
-    def self.extended(klass)
-        klass.extend(ClassMethods)
+  def self.format(name)
+    @formats[name.to_s.downcase.intern]
+  end
 
-        # LAK:NOTE This won't work in 1.9 ('send' won't be able to send
-        # private methods, but I don't know how else to do it.
-        klass.send(:include, InstanceMethods)
-    end
-
-    def self.format(name)
-        @formats[name.to_s.downcase.intern]
+  def self.format_by_extension(ext)
+    @formats.each do |name, format|
+      return format if format.extension == ext
     end
-
-    # Provide a list of all formats.
-    def self.formats
-        @formats.keys
+    nil
+  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)
+    mimetype = mimetype.to_s.downcase
+    @formats.values.find { |format| format.mime == mimetype }
+  end
+
+  # Use a delegator to make sure any exceptions generated by our formats are
+  # handled intelligently.
+  def self.protected_format(name)
+    name = format_to_canonical_name(name)
+    @format_protectors ||= {}
+    @format_protectors[name] ||= FormatProtector.new(name)
+    @format_protectors[name]
+  end
+
+  # Return a format name given:
+  #  * a format name
+  #  * a mime-type
+  #  * a format instance
+  def self.format_to_canonical_name(format)
+    case format
+    when Puppet::Network::Format
+      out = format
+    when %r{\w+/\w+}
+      out = mime(format)
+    else
+      out = format(format)
     end
+    raise ArgumentError, "No format match the given format name or mime-type (#{format})" if out.nil?
+    out.name
+  end
 
-    # Return a format capable of handling the provided mime type.
-    def self.mime(mimetype)
-        mimetype = mimetype.to_s.downcase
-        @formats.values.find { |format| format.mime == mimetype }
+  module ClassMethods
+    def format_handler
+      Puppet::Network::FormatHandler
     end
 
-    # Use a delegator to make sure any exceptions generated by our formats are
-    # handled intelligently.
-    def self.protected_format(name)
-        name = format_to_canonical_name(name)
-        @format_protectors ||= {}
-        @format_protectors[name] ||= FormatProtector.new(name)
-        @format_protectors[name]
+    def convert_from(format, data)
+      format_handler.protected_format(format).intern(self, data)
     end
 
-    # Return a format name given:
-    #  * a format name
-    #  * a mime-type
-    #  * a format instance
-    def self.format_to_canonical_name(format)
-        case format
-        when Puppet::Network::Format
-            out = format
-        when %r{\w+/\w+}
-            out = mime(format)
-        else
-            out = format(format)
-        end
-        raise ArgumentError, "No format match the given format name or mime-type (%s)" % format if out.nil?
-        out.name
+    def convert_from_multiple(format, data)
+      format_handler.protected_format(format).intern_multiple(self, data)
     end
 
-    module ClassMethods
-        def format_handler
-            Puppet::Network::FormatHandler
-        end
-
-        def convert_from(format, data)
-            format_handler.protected_format(format).intern(self, data)
-        end
+    def render_multiple(format, instances)
+      format_handler.protected_format(format).render_multiple(instances)
+    end
 
-        def convert_from_multiple(format, data)
-            format_handler.protected_format(format).intern_multiple(self, data)
-        end
+    def default_format
+      supported_formats[0]
+    end
 
-        def render_multiple(format, instances)
-            format_handler.protected_format(format).render_multiple(instances)
-        end
+    def support_format?(name)
+      Puppet::Network::FormatHandler.format(name).supported?(self)
+    end
 
-        def default_format
-            supported_formats[0]
-        end
+    def supported_formats
+      result = format_handler.formats.collect { |f| format_handler.format(f) }.find_all { |f| f.supported?(self) }.collect { |f| f.name }.sort do |a, b|
+        # It's an inverse sort -- higher weight formats go first.
+        format_handler.format(b).weight <=> format_handler.format(a).weight
+      end
 
-        def support_format?(name)
-            Puppet::Network::FormatHandler.format(name).supported?(self)
-        end
+      result = put_preferred_format_first(result)
 
-        def supported_formats
-            result = format_handler.formats.collect { |f| format_handler.format(f) }.find_all { |f| f.supported?(self) }.collect { |f| f.name }.sort do |a, b|
-                # It's an inverse sort -- higher weight formats go first.
-                format_handler.format(b).weight <=> format_handler.format(a).weight
-            end
+      Puppet.debug "#{friendly_name} supports formats: #{result.map{ |f| f.to_s }.sort.join(' ')}; using #{result.first}"
 
-            result = put_preferred_format_first(result)
+      result
+    end
 
-            Puppet.debug "#{friendly_name} supports formats: #{result.map{ |f| f.to_s }.sort.join(' ')}; using #{result.first}"
+    private
 
-            result
-        end
+    def friendly_name
+      if self.respond_to? :indirection
+        indirection.name
+      else
+        self
+      end
+    end
 
-        private
+    def put_preferred_format_first(list)
+      preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
+      if list.include?(preferred_format)
+        list.delete(preferred_format)
+        list.unshift(preferred_format)
+      else
+        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
+      end
+      list
+    end
+  end
 
-        def friendly_name
-            if self.respond_to? :indirection
-                indirection.name
-            else
-                self
-            end
-        end
+  module InstanceMethods
+    def render(format = nil)
+      format ||= self.class.default_format
 
-        def put_preferred_format_first(list)
-            preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
-            if list.include?(preferred_format)
-                list.delete(preferred_format)
-                list.unshift(preferred_format)
-            else
-                Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
-            end
-            list
-        end
+      Puppet::Network::FormatHandler.protected_format(format).render(self)
     end
 
-    module InstanceMethods
-        def render(format = nil)
-            format ||= self.class.default_format
-
-            Puppet::Network::FormatHandler.protected_format(format).render(self)
-        end
+    def mime(format = nil)
+      format ||= self.class.default_format
+
+      Puppet::Network::FormatHandler.protected_format(format).mime
+    end
 
-        def mime(format = nil)
-            format ||= self.class.default_format
-
-            Puppet::Network::FormatHandler.protected_format(format).mime
-        end
-
-        def support_format?(name)
-            self.class.support_format?(name)
-        end
+    def support_format?(name)
+      self.class.support_format?(name)
     end
+  end
 end
 
 require 'puppet/network/formats'