puppet 0.25.5 → 2.6.0

data/lib/puppet/util/pson.rb

@@ -1,4 +1,4 @@
-# A simple module to provide consistency between how we use PSON and how 
+# A simple module to provide consistency between how we use PSON and how
 # ruby expects it to be used.  Basically, we don't want to require
 # that the sender specify a class.
 #  Ruby wants everyone to provide a 'type' field, and the PSON support
@@ -6,8 +6,8 @@
 # figure out what class we're working on, we don't need that, and we don't want
 # our consumers and producers to need to know anything about our internals.
 module Puppet::Util::Pson
-    def pson_create(pson)
-        raise ArgumentError, "No data provided in pson data" unless pson['data']
-        from_pson(pson['data'])
-    end
+  def pson_create(pson)
+    raise ArgumentError, "No data provided in pson data" unless pson['data']
+    from_pson(pson['data'])
+  end
 end

data/lib/puppet/util/queue.rb

@@ -29,68 +29,68 @@ require 'puppet/util/instance_loader'
 # +client+, which will return a class-wide singleton client instance, determined by +client_class+.
 #
 # The client plugins are expected to implement an interface similar to that of Stomp::Client:
-# * <tt>new()</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
+# * <tt>new</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
 # * <tt>send_message(queue, message)</tt> should send the _message_ to the specified _queue_.
 # * <tt>subscribe(queue)</tt> _block_ subscribes to _queue_ and executes _block_ upon receiving a message.
 # * _queue_ names are simple names independent of the message broker or client library.  No "/queue/" prefixes like in Stomp::Client.
 module Puppet::Util::Queue
-    extend Puppet::Util::InstanceLoader
-    instance_load :queue_clients, 'puppet/util/queue'
+  extend Puppet::Util::InstanceLoader
+  instance_load :queue_clients, 'puppet/util/queue'
 
-    # Adds a new class/queue-type pair to the registry.  The _type_ argument is optional; if not provided,
-    # _type_ defaults to a lowercased, underscored symbol programmatically derived from the rightmost
-    # namespace of <em>klass.name</em>.
-    #
-    #   # register with default name +:you+
-    #   register_queue_type(Foo::You)
-    #
-    #   # register with explicit queue type name +:myself+
-    #   register_queue_type(Foo::Me, :myself)
-    #
-    # If the type is already registered, an exception is thrown.  No checking is performed of _klass_,
-    # however; a given class could be registered any number of times, as long as the _type_ differs with
-    # each registration.
-    def self.register_queue_type(klass, type = nil)
-        type ||= queue_type_from_class(klass)
-        raise Puppet::Error, "Queue type %s is already registered" % type.to_s if instance_hash(:queue_clients).include?(type)
-        instance_hash(:queue_clients)[type] = klass
-    end
+  # Adds a new class/queue-type pair to the registry.  The _type_ argument is optional; if not provided,
+  # _type_ defaults to a lowercased, underscored symbol programmatically derived from the rightmost
+  # namespace of <em>klass.name</em>.
+  #
+  #   # register with default name +:you+
+  #   register_queue_type(Foo::You)
+  #
+  #   # register with explicit queue type name +:myself+
+  #   register_queue_type(Foo::Me, :myself)
+  #
+  # If the type is already registered, an exception is thrown.  No checking is performed of _klass_,
+  # however; a given class could be registered any number of times, as long as the _type_ differs with
+  # each registration.
+  def self.register_queue_type(klass, type = nil)
+    type ||= queue_type_from_class(klass)
+    raise Puppet::Error, "Queue type #{type} is already registered" if instance_hash(:queue_clients).include?(type)
+    instance_hash(:queue_clients)[type] = klass
+  end
 
-    # Given a queue type symbol, returns the associated +Class+ object.  If the queue type is unknown
-    # (meaning it hasn't been registered with this module), an exception is thrown.
-    def self.queue_type_to_class(type)
-        c = loaded_instance :queue_clients, type
-        raise Puppet::Error, "Queue type %s is unknown." % type unless c
-        c
-    end
+  # Given a queue type symbol, returns the associated +Class+ object.  If the queue type is unknown
+  # (meaning it hasn't been registered with this module), an exception is thrown.
+  def self.queue_type_to_class(type)
+    c = loaded_instance :queue_clients, type
+    raise Puppet::Error, "Queue type #{type} is unknown." unless c
+    c
+  end
 
-    # Given a class object _klass_, returns the programmatic default queue type name symbol for _klass_.
-    # The algorithm is as shown in earlier examples; the last namespace segment of _klass.name_ is taken
-    # and converted from mixed case to underscore-separated lowercase, and interned.
-    #   queue_type_from_class(Foo) -> :foo
-    #   queue_type_from_class(Foo::Too) -> :too
-    #   queue_type_from_class(Foo::ForYouTwo) -> :for_you_too
-    #
-    # The implicit assumption here, consistent with Puppet's approach to plugins in general,
-    # is that all your client modules live in the same namespace, such that reduction to
-    # a flat namespace of symbols is reasonably safe.
-    def self.queue_type_from_class(klass)
-        # convert last segment of classname from studly caps to lower case with underscores, and symbolize
-        klass.name.split('::').pop.sub(/^[A-Z]/) {|c| c.downcase}.gsub(/[A-Z]/) {|c| '_' + c.downcase }.intern
-    end
+  # Given a class object _klass_, returns the programmatic default queue type name symbol for _klass_.
+  # The algorithm is as shown in earlier examples; the last namespace segment of _klass.name_ is taken
+  # and converted from mixed case to underscore-separated lowercase, and interned.
+  #   queue_type_from_class(Foo) -> :foo
+  #   queue_type_from_class(Foo::Too) -> :too
+  #   queue_type_from_class(Foo::ForYouTwo) -> :for_you_too
+  #
+  # The implicit assumption here, consistent with Puppet's approach to plugins in general,
+  # is that all your client modules live in the same namespace, such that reduction to
+  # a flat namespace of symbols is reasonably safe.
+  def self.queue_type_from_class(klass)
+    # convert last segment of classname from studly caps to lower case with underscores, and symbolize
+    klass.name.split('::').pop.sub(/^[A-Z]/) {|c| c.downcase}.gsub(/[A-Z]/) {|c| '_' + c.downcase }.intern
+  end
 
-    # The class object for the client to be used, determined by queue configuration
-    # settings.
-    # Looks to the <tt>:queue_type</tt> configuration entry in the running application for
-    # the default queue type to use.
-    def client_class
-        Puppet::Util::Queue.queue_type_to_class(Puppet[:queue_type])
-    end
+  # The class object for the client to be used, determined by queue configuration
+  # settings.
+  # Looks to the <tt>:queue_type</tt> configuration entry in the running application for
+  # the default queue type to use.
+  def client_class
+    Puppet::Util::Queue.queue_type_to_class(Puppet[:queue_type])
+  end
 
-    # Returns (instantiating as necessary) the singleton queue client instance, according to the
-    # client_class.  No arguments go to the client class constructor, meaning its up to the client class
-    # to know how to determine its queue message source (presumably through Puppet configuration data).
-    def client
-        @client ||= client_class.new
-    end
+  # Returns (instantiating as necessary) the singleton queue client instance, according to the
+  # client_class.  No arguments go to the client class constructor, meaning its up to the client class
+  # to know how to determine its queue message source (presumably through Puppet configuration data).
+  def client
+    @client ||= client_class.new
+  end
 end

data/lib/puppet/util/queue/stomp.rb

@@ -9,39 +9,39 @@ require 'uri'
 # consequently, for this client to work, <tt>Puppet[:queue_source]</tt> must use the Stomp::Client URL-like
 # syntax for identifying the Stomp message broker: <em>login:pass@host.port</em>
 class Puppet::Util::Queue::Stomp
-    attr_accessor :stomp_client
+  attr_accessor :stomp_client
 
-    def initialize
-        begin
-            uri = URI.parse(Puppet[:queue_source])
-        rescue => detail
-            raise ArgumentError, "Could not create Stomp client instance - queue source %s is invalid: %s" % [Puppet[:queue_source], detail]
-        end
-        unless uri.scheme == "stomp"
-            raise ArgumentError, "Could not create Stomp client instance - queue source %s is not a Stomp URL: %s" % [Puppet[:queue_source], detail]
-        end
-
-        begin
-            self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
-        rescue => detail
-            raise ArgumentError, "Could not create Stomp client instance with queue source %s: got internal Stomp client error %s" % [Puppet[:queue_source], detail]
-        end
+  def initialize
+    begin
+      uri = URI.parse(Puppet[:queue_source])
+    rescue => detail
+      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is invalid: #{detail}"
     end
-
-    def send_message(target, msg)
-        stomp_client.send(stompify_target(target), msg, :persistent => true)
+    unless uri.scheme == "stomp"
+      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is not a Stomp URL: #{detail}"
     end
 
-    def subscribe(target)
-        stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
-            yield(stomp_message.body)
-            stomp_client.acknowledge(stomp_message)
-        end
+    begin
+      self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
+    rescue => detail
+      raise ArgumentError, "Could not create Stomp client instance with queue source #{Puppet[:queue_source]}: got internal Stomp client error #{detail}"
     end
+  end
 
-    def stompify_target(target)
-        '/queue/' + target.to_s
+  def send_message(target, msg)
+    stomp_client.send(stompify_target(target), msg, :persistent => true)
+  end
+
+  def subscribe(target)
+    stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
+      yield(stomp_message.body)
+      stomp_client.acknowledge(stomp_message)
     end
+  end
+
+  def stompify_target(target)
+    '/queue/' + target.to_s
+  end
 
-    Puppet::Util::Queue.register_queue_type(self, :stomp)
+  Puppet::Util::Queue.register_queue_type(self, :stomp)
 end

data/lib/puppet/util/rails/cache_accumulator.rb

@@ -1,65 +1,65 @@
 require 'puppet/util'
 
 module Puppet::Util::CacheAccumulator
-    def self.included(klass)
-        klass.extend ClassMethods
-    end
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
 
-    class Base
-        attr_reader :klass, :attribute
+  class Base
+    attr_reader :klass, :attribute
 
-        def initialize(klass, attribute)
-            @klass = klass
-            @attribute = attribute
-            @find_or_create = "find_or_create_by_#{@attribute.to_s}".intern
-        end
+    def initialize(klass, attribute)
+      @klass = klass
+      @attribute = attribute
+      @find_or_create = "find_or_create_by_#{@attribute.to_s}".intern
+    end
 
-        def store
-            @store || reset
-        end
+    def store
+      @store || reset
+    end
 
-        def reset
-            @store = {}
-        end
+    def reset
+      @store = {}
+    end
 
-        def find(*keys)
-            result = nil
-            if keys.length == 1
-                result = store[keys[0]] ||= @klass.send(@find_or_create, *keys)
-            else
-                found, missing = keys.partition {|k| store.include? k}
-                result = found.length
-                result += do_multi_find(missing) if missing.length > 0
-            end
-            result
-        end
+    def find(*keys)
+      result = nil
+      if keys.length == 1
+        result = store[keys[0]] ||= @klass.send(@find_or_create, *keys)
+      else
+        found, missing = keys.partition {|k| store.include? k}
+        result = found.length
+        result += do_multi_find(missing) if missing.length > 0
+      end
+      result
+    end
 
-        def do_multi_find(keys)
-            result = 0
-            @klass.find(:all, :conditions => {@attribute => keys}).each do |obj|
-                store[obj.send(@attribute)] = obj
-                result += 1
-            end
-            result
-        end
+    def do_multi_find(keys)
+      result = 0
+      @klass.find(:all, :conditions => {@attribute => keys}).each do |obj|
+        store[obj.send(@attribute)] = obj
+        result += 1
+      end
+      result
     end
+  end
 
-    module ClassMethods
-        def accumulates(*attributes)
-            attributes.each {|attrib| install_accumulator(attrib)}
-        end
+  module ClassMethods
+    def accumulates(*attributes)
+      attributes.each {|attrib| install_accumulator(attrib)}
+    end
 
-        def accumulators
-            @accumulators ||= {}
-        end
+    def accumulators
+      @accumulators ||= {}
+    end
 
-        def install_accumulator(attribute)
-            self.accumulators[attribute] = Base.new(self, attribute)
-            module_eval %{
-                def self.accumulate_by_#{attribute.to_s}(*keys)
-                    accumulators[:#{attribute.to_s}].find(*keys)
-                end
-            }
+    def install_accumulator(attribute)
+      self.accumulators[attribute] = Base.new(self, attribute)
+      module_eval %{
+        def self.accumulate_by_#{attribute.to_s}(*keys)
+          accumulators[:#{attribute.to_s}].find(*keys)
         end
+      }
     end
+  end
 end

data/lib/puppet/util/rails/collection_merger.rb

@@ -1,17 +1,17 @@
 module Puppet::Util::CollectionMerger
-    def ar_hash_merge(db_hash, mem_hash, args)
-        (db_hash.keys | mem_hash.keys).each do |key|
-            if (db_hash[key] && mem_hash[key])
-                # in both, update value
-                args[:modify].call(db_hash[key], mem_hash[key])
-            elsif (db_hash[key])
-                # in db, not memory, delete from database
-                args[:delete].call(db_hash[key])
-            else
-                # in mem, not in db, insert into the database
-                args[:create].call(key, mem_hash[key])
-            end
-        end
+  def ar_hash_merge(db_hash, mem_hash, args)
+    (db_hash.keys | mem_hash.keys).each do |key|
+      if (db_hash[key] && mem_hash[key])
+        # in both, update value
+        args[:modify].call(db_hash[key], mem_hash[key])
+      elsif (db_hash[key])
+        # in db, not memory, delete from database
+        args[:delete].call(db_hash[key])
+      else
+        # in mem, not in db, insert into the database
+        args[:create].call(key, mem_hash[key])
+      end
     end
+  end
 end
 

data/lib/puppet/util/rails/reference_serializer.rb

@@ -1,32 +1,32 @@
 
 module Puppet::Util::ReferenceSerializer
-    def unserialize_value(val)
-        case val
-        when /^--- /
-            YAML.load(val)
-        when "true"
-            true
-        when "false"
-            false
-        else
-            val
-        end
+  def unserialize_value(val)
+    case val
+    when /^--- /
+      YAML.load(val)
+    when "true"
+      true
+    when "false"
+      false
+    else
+      val
     end
+  end
 
-    def serialize_value(val)
-        case val
-        when Puppet::Parser::Resource::Reference
-            YAML.dump(val)
-        when true, false
-            # The database does this for us, but I prefer the
-            # methods be their exact inverses.
-            # Note that this means quoted booleans get returned
-            # as actual booleans, but there doesn't appear to be
-            # a way to fix that while keeping the ability to
-            # search for parameters set to true.
-            val.to_s
-        else
-            val
-        end
+  def serialize_value(val)
+    case val
+    when Puppet::Resource
+      YAML.dump(val)
+    when true, false
+      # The database does this for us, but I prefer the
+      # methods be their exact inverses.
+      # Note that this means quoted booleans get returned
+      # as actual booleans, but there doesn't appear to be
+      # a way to fix that while keeping the ability to
+      # search for parameters set to true.
+      val.to_s
+    else
+      val
     end
+  end
 end

data/lib/puppet/util/rdoc.rb

@@ -1,88 +1,91 @@
 
 module Puppet::Util::RDoc
 
-    module_function
-
-    # launch a rdoc documenation process
-    # with the files/dir passed in +files+
-    def rdoc(outputdir, files)
-        begin
-            Puppet[:ignoreimport] = true
-
-            # then rdoc
-            require 'rdoc/rdoc'
-
-            # load our parser
-            require 'puppet/util/rdoc/parser'
-
-            r = RDoc::RDoc.new
-            RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new("puppet/util/rdoc/generators/puppet_generator.rb",
-                                                                       "PuppetGenerator".intern,
-                                                                       "puppet")
-            # specify our own format & where to output
-            options = [ "--fmt", "puppet",
-                        "--quiet",
-                        "--force-update",
-                        "--op", outputdir ]
-
-            options += files
-
-            # launch the documentation process
-            r.document(options)
-        rescue RDoc::RDocError => e
-            raise Puppet::ParseError.new("RDoc error %s" % e)
-        end
+  module_function
+
+  # launch a rdoc documenation process
+  # with the files/dir passed in +files+
+  def rdoc(outputdir, files, charset = nil)
+      Puppet[:ignoreimport] = true
+
+      # then rdoc
+      require 'rdoc/rdoc'
+
+      # load our parser
+      require 'puppet/util/rdoc/parser'
+
+      r = RDoc::RDoc.new
+
+        RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new(
+          "puppet/util/rdoc/generators/puppet_generator.rb",
+            "PuppetGenerator".intern,
+
+            "puppet")
+      # specify our own format & where to output
+      options = [ "--fmt", "puppet",
+        "--quiet",
+        "--force-update",
+        "--exclude", "/modules/[^/]*/files/.*\.pp$",
+        "--op", outputdir ]
+
+      options += [ "--charset", charset] if charset
+      options += files
+
+      # launch the documentation process
+      r.document(options)
+  rescue RDoc::RDocError => e
+      raise Puppet::ParseError.new("RDoc error #{e}")
+  end
+
+  # launch a output to console manifest doc
+  def manifestdoc(files)
+    Puppet[:ignoreimport] = true
+    files.select { |f| FileTest.file?(f) }.each do |f|
+      parser = Puppet::Parser::Parser.new(:environment => Puppet[:environment])
+      parser.file = f
+      ast = parser.parse
+      output(f, ast)
     end
-
-    # launch a output to console manifest doc
-    def manifestdoc(files)
-        Puppet[:ignoreimport] = true
-        files.select { |f| FileTest.file?(f) }.each do |f|
-            parser = Puppet::Parser::Parser.new(:environment => Puppet[:environment])
-            parser.file = f
-            ast = parser.parse
-            output(f, ast)
-        end
+  end
+
+  # Ouputs to the console the documentation
+  # of a manifest
+  def output(file, ast)
+    astobj = []
+    ast.nodes.each do |name, k|
+      astobj << k if k.file == file
     end
 
-    # Ouputs to the console the documentation
-    # of a manifest
-    def output(file, ast)
-        astobj = []
-        ast.nodes.each do |name, k|
-            astobj << k if k.file == file
-        end
-
-        ast.hostclasses.each do |name,k|
-            astobj << k if k.file == file
-        end
-
-        ast.definitions.each do |name, k|
-            astobj << k if k.file == file
-        end
-        astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
-            output_astnode_doc(k)
-        end
+    ast.hostclasses.each do |name,k|
+      astobj << k if k.file == file
     end
 
-    def output_astnode_doc(ast)
-        puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
-        if Puppet.settings[:document_all]
-            # scan each underlying resources to produce documentation
-            code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
-            code ||= ast.code
-            output_resource_doc(code) unless code.nil?
-        end
+    ast.definitions.each do |name, k|
+      astobj << k if k.file == file
+    end
+    astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
+      output_astnode_doc(k)
+    end
+  end
+
+  def output_astnode_doc(ast)
+    puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
+    if Puppet.settings[:document_all]
+      # scan each underlying resources to produce documentation
+      code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
+      code ||= ast.code
+      output_resource_doc(code) unless code.nil?
     end
+  end
 
-    def output_resource_doc(code)
-        code.sort { |a,b| a.line <=> b.line }.each do |stmt|
-            output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
+  def output_resource_doc(code)
+    code.sort { |a,b| a.line <=> b.line }.each do |stmt|
+      output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
-            if stmt.is_a?(Puppet::Parser::AST::Resource)
-                puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
-            end
-        end
+      if stmt.is_a?(Puppet::Parser::AST::Resource)
+        puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
+      end
     end
+  end
 
 end