puppet 0.25.5 → 2.6.0

data/lib/puppet/util/graph.rb

@@ -6,27 +6,25 @@ require 'puppet/simple_graph'
 
 # A module that handles the small amount of graph stuff in Puppet.
 module Puppet::Util::Graph
-    # Make a graph where each of our children gets converted to
-    # the receiving end of an edge.  Call the same thing on all
-    # of our children, optionally using a block
-    def to_graph(graph = nil, &block)
-        # Allow our calling function to send in a graph, so that we
-        # can call this recursively with one graph.
-        graph ||= Puppet::SimpleGraph.new
+  # Make a graph where each of our children gets converted to
+  # the receiving end of an edge.  Call the same thing on all
+  # of our children, optionally using a block
+  def to_graph(graph = nil, &block)
+    # Allow our calling function to send in a graph, so that we
+    # can call this recursively with one graph.
+    graph ||= Puppet::SimpleGraph.new
 
-        self.each do |child|
-            unless block_given? and ! yield(child)
-                graph.add_edge(self, child)
+    self.each do |child|
+      unless block_given? and ! yield(child)
+        graph.add_edge(self, child)
 
-                if child.respond_to?(:to_graph)
-                    child.to_graph(graph, &block)
-                end
-            end
-        end
+        child.to_graph(graph, &block) if child.respond_to?(:to_graph)
+      end
+    end
 
-        # Do a topsort, which will throw an exception if the graph is cyclic.
+    # Do a topsort, which will throw an exception if the graph is cyclic.
 
-        graph
-    end
+    graph
+  end
 end
 

data/lib/puppet/util/inifile.rb

@@ -11,207 +11,193 @@
 require 'puppet/util/filetype'
 
 module Puppet::Util::IniConfig
-    # A section in a .ini file
-    class Section
-        attr_reader :name, :file
-
-        def initialize(name, file)
-            @name = name
-            @file = file
-            @dirty = false
-            @entries = []
-        end
-
-        # Has this section been modified since it's been read in
-        # or written back to disk
-        def dirty?
-            @dirty
-        end
+  # A section in a .ini file
+  class Section
+    attr_reader :name, :file
+
+    def initialize(name, file)
+      @name = name
+      @file = file
+      @dirty = false
+      @entries = []
+    end
 
-        # Should only be used internally
-        def mark_clean
-            @dirty = false
-        end
+    # Has this section been modified since it's been read in
+    # or written back to disk
+    def dirty?
+      @dirty
+    end
 
-        # Add a line of text (e.g., a comment) Such lines
-        # will be written back out in exactly the same
-        # place they were read in
-        def add_line(line)
-            @entries << line
-        end
+    # Should only be used internally
+    def mark_clean
+      @dirty = false
+    end
 
-        # Set the entry 'key=value'. If no entry with the
-        # given key exists, one is appended to teh end of the section
-        def []=(key, value)
-            entry = find_entry(key)
-            @dirty = true
-            if entry.nil?
-                @entries << [key, value]
-            else
-                entry[1] = value
-            end
-        end
+    # Add a line of text (e.g., a comment) Such lines
+    # will be written back out in exactly the same
+    # place they were read in
+    def add_line(line)
+      @entries << line
+    end
 
-        # Return the value associated with KEY. If no such entry
-        # exists, return nil
-        def [](key)
-            entry = find_entry(key)
-            if entry.nil?
-                return nil
-            end
-            return entry[1]
-        end
+    # Set the entry 'key=value'. If no entry with the
+    # given key exists, one is appended to teh end of the section
+    def []=(key, value)
+      entry = find_entry(key)
+      @dirty = true
+      if entry.nil?
+        @entries << [key, value]
+      else
+        entry[1] = value
+      end
+    end
 
-        # Format the section as text in the way it should be
-        # written to file
-        def format
-            text = "[#{name}]\n"
-            @entries.each do |entry|
-                if entry.is_a?(Array)
-                    key, value = entry
-                    unless value.nil?
-                        text << "#{key}=#{value}\n"
-                    end
-                else
-                    text << entry
-                end
-            end
-            return text
-        end
+    # Return the value associated with KEY. If no such entry
+    # exists, return nil
+    def [](key)
+      entry = find_entry(key)
+      return(entry.nil? ? nil : entry[1])
+    end
 
-        private
-        def find_entry(key)
-            @entries.each do |entry|
-                if entry.is_a?(Array) && entry[0] == key
-                    return entry
-                end
-            end
-            return nil
-        end
+    # Format the section as text in the way it should be
+    # written to file
+    def format
+      text = "[#{name}]\n"
+      @entries.each do |entry|
+        if entry.is_a?(Array)
+          key, value = entry
+          text << "#{key}=#{value}\n" unless value.nil?
+        else
+          text << entry
+        end
+      end
+      text
+    end
 
+    private
+    def find_entry(key)
+      @entries.each do |entry|
+        return entry if entry.is_a?(Array) && entry[0] == key
+      end
+      nil
     end
 
-    # A logical .ini-file that can be spread across several physical
-    # files. For each physical file, call #read with the filename
-    class File
-        def initialize
-            @files = {}
-        end
+  end
 
-        # Add the contents of the file with name FILE to the
-        # already existing sections
-        def read(file)
-            text = Puppet::Util::FileType.filetype(:flat).new(file).read
-            if text.nil?
-                raise "Could not find #{file}"
-            end
-
-            section = nil   # The name of the current section
-            optname = nil   # The name of the last option in section
-            line = 0
-            @files[file] = []
-            text.each_line do |l|
-                line += 1
-                if l.strip.empty? || "#;".include?(l[0,1]) ||
-                        (l.split(nil, 2)[0].downcase == "rem" &&
-                         l[0,1].downcase == "r")
-                    # Whitespace or comment
-                    if section.nil?
-                        @files[file] << l
-                    else
-                        section.add_line(l)
-                    end
-                elsif " \t\r\n\f".include?(l[0,1]) && section && optname
-                    # continuation line
-                    section[optname] += "\n" + l.chomp
-                elsif l =~ /^\[([^\]]+)\]/
-                    # section heading
-                    section.mark_clean unless section.nil?
-                    section = add_section($1, file)
-                    optname = nil
-                elsif l =~ /^\s*([^\s=]+)\s*\=(.*)$/
-                    # We allow space around the keys, but not the values
-                    # For the values, we don't know if space is significant
-                    if section.nil?
-                        raise "#{file}:#{line}:Key/value pair outside of a section for key #{$1}"
-                    else
-                        section[$1] = $2
-                        optname = $1
-                    end
-                else
-                    raise "#{file}:#{line}: Can't parse '#{l.chomp}'"
-                end
-            end
-            section.mark_clean unless section.nil?
-        end
+  # A logical .ini-file that can be spread across several physical
+  # files. For each physical file, call #read with the filename
+  class File
+    def initialize
+      @files = {}
+    end
 
-        # Store all modifications made to sections in this file back
-        # to the physical files. If no modifications were made to
-        # a physical file, nothing is written
-        def store
-            @files.each do |file, lines|
-                text = ""
-                dirty = false
-                lines.each do |l|
-                    if l.is_a?(Section)
-                        dirty ||= l.dirty?
-                        text << l.format
-                        l.mark_clean
-                    else
-                        text << l
-                    end
-                end
-                if dirty
-                    Puppet::Util::FileType.filetype(:flat).new(file).write(text)
-                    return file
-                end
-            end
-        end
+    # Add the contents of the file with name FILE to the
+    # already existing sections
+    def read(file)
+      text = Puppet::Util::FileType.filetype(:flat).new(file).read
+      raise "Could not find #{file}" if text.nil?
+
+      section = nil   # The name of the current section
+      optname = nil   # The name of the last option in section
+      line = 0
+      @files[file] = []
+      text.each_line do |l|
+        line += 1
+        if l.strip.empty? || "#;".include?(l[0,1]) ||
+            (l.split(nil, 2)[0].downcase == "rem" && l[0,1].downcase == "r")
+          # Whitespace or comment
+          if section.nil?
+            @files[file] << l
+          else
+            section.add_line(l)
+          end
+        elsif " \t\r\n\f".include?(l[0,1]) && section && optname
+          # continuation line
+          section[optname] += "\n#{l.chomp}"
+        elsif l =~ /^\[([^\]]+)\]/
+          # section heading
+          section.mark_clean unless section.nil?
+          section = add_section($1, file)
+          optname = nil
+        elsif l =~ /^\s*([^\s=]+)\s*\=(.*)$/
+          # We allow space around the keys, but not the values
+          # For the values, we don't know if space is significant
+          if section.nil?
+            raise "#{file}:#{line}:Key/value pair outside of a section for key #{$1}"
+          else
+            section[$1] = $2
+            optname = $1
+          end
+        else
+          raise "#{file}:#{line}: Can't parse '#{l.chomp}'"
+        end
+      end
+      section.mark_clean unless section.nil?
+    end
 
-        # Execute BLOCK, passing each section in this file
-        # as an argument
-        def each_section(&block)
-            @files.each do |file, list|
-                list.each do |entry|
-                    if entry.is_a?(Section)
-                        yield(entry)
-                    end
-                end
-            end
-        end
+    # Store all modifications made to sections in this file back
+    # to the physical files. If no modifications were made to
+    # a physical file, nothing is written
+    def store
+      @files.each do |file, lines|
+        text = ""
+        dirty = false
+        lines.each do |l|
+          if l.is_a?(Section)
+            dirty ||= l.dirty?
+            text << l.format
+            l.mark_clean
+          else
+            text << l
+          end
+        end
+        if dirty
+          Puppet::Util::FileType.filetype(:flat).new(file).write(text)
+          return file
+        end
+      end
+    end
 
-        # Execute BLOCK, passing each file constituting this inifile
-        # as an argument
-        def each_file(&block)
-            @files.keys.each do |file|
-                yield(file)
-            end
+    # Execute BLOCK, passing each section in this file
+    # as an argument
+    def each_section(&block)
+      @files.each do |file, list|
+        list.each do |entry|
+          yield(entry) if entry.is_a?(Section)
         end
+      end
+    end
 
-        # Return the Section with the given name or nil
-        def [](name)
-            name = name.to_s
-            each_section do |section|
-                return section if section.name == name
-            end
-            return nil
-        end
+    # Execute BLOCK, passing each file constituting this inifile
+    # as an argument
+    def each_file(&block)
+      @files.keys.each do |file|
+        yield(file)
+      end
+    end
 
-        # Return true if the file contains a section with name NAME
-        def include?(name)
-            return ! self[name].nil?
-        end
+    # Return the Section with the given name or nil
+    def [](name)
+      name = name.to_s
+      each_section do |section|
+        return section if section.name == name
+      end
+      nil
+    end
 
-        # Add a section to be stored in FILE when store is called
-        def add_section(name, file)
-            if include?(name)
-                raise "A section with name #{name} already exists"
-            end
-            result = Section.new(name, file)
-            @files[file] ||= []
-            @files[file] << result
-            return result
-        end
+    # Return true if the file contains a section with name NAME
+    def include?(name)
+      ! self[name].nil?
+    end
+
+    # Add a section to be stored in FILE when store is called
+    def add_section(name, file)
+      raise "A section with name #{name} already exists" if include?(name)
+      result = Section.new(name, file)
+      @files[file] ||= []
+      @files[file] << result
+      result
     end
+  end
 end
 

data/lib/puppet/util/inline_docs.rb

@@ -0,0 +1,26 @@
+module Puppet::Util::InlineDocs
+  def self.included(klass)
+    klass.send(:include, InstanceMethods)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    attr_accessor :use_docs
+    def associates_doc
+      self.use_docs = true
+    end
+  end
+
+  module InstanceMethods
+    attr_writer :doc
+
+    def doc
+      @doc ||= ""
+    end
+
+    # don't fetch lexer comment by default
+    def use_docs
+      self.class.use_docs
+    end
+  end
+end

data/lib/puppet/util/instance_loader.rb

@@ -4,78 +4,78 @@ require 'puppet/util'
 # A module that can easily autoload things for us.  Uses an instance
 # of Puppet::Util::Autoload
 module Puppet::Util::InstanceLoader
-    include Puppet::Util
+  include Puppet::Util
 
-    # Are we instance-loading this type?
-    def instance_loading?(type)
-        defined?(@autoloaders) and @autoloaders.include?(symbolize(type))
-    end
-
-    # Define a new type of autoloading.
-    def instance_load(type, path, options = {})
-        @autoloaders ||= {}
-        @instances ||= {}
-        type = symbolize(type)
-        @instances[type] = {}
-        @autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
+  # Are we instance-loading this type?
+  def instance_loading?(type)
+    defined?(@autoloaders) and @autoloaders.include?(symbolize(type))
+  end
 
-        # Now define our new simple methods
-        unless respond_to?(type)
-            meta_def(type) do |name|
-                loaded_instance(type, name)
-            end
-        end
-    end
+  # Define a new type of autoloading.
+  def instance_load(type, path, options = {})
+    @autoloaders ||= {}
+    @instances ||= {}
+    type = symbolize(type)
+    @instances[type] = {}
+    @autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
 
-    # Return a list of the names of all instances
-    def loaded_instances(type)
-        @instances[type].keys
+    # Now define our new simple methods
+    unless respond_to?(type)
+      meta_def(type) do |name|
+        loaded_instance(type, name)
+      end
     end
+  end
 
-    # Collect the docs for all of our instances.
-    def instance_docs(type)
-        docs = ""
+  # Return a list of the names of all instances
+  def loaded_instances(type)
+    @instances[type].keys
+  end
 
-        # Load all instances.
-        instance_loader(type).loadall
+  # Collect the docs for all of our instances.
+  def instance_docs(type)
+    docs = ""
 
-        # Use this method so they all get loaded
-        loaded_instances(type).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
-            mod = self.loaded_instance(name)
-            docs += "%s\n%s\n" % [name, "-" * name.to_s.length]
+    # Load all instances.
+    instance_loader(type).loadall
 
-            docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
-        end
+    # Use this method so they all get loaded
+    loaded_instances(type).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+      mod = self.loaded_instance(name)
+      docs += "#{name}\n#{"-" * name.to_s.length}\n"
 
-        docs
+      docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
     end
 
-    # Return the instance hash for our type.
-    def instance_hash(type)
-        @instances[symbolize(type)]
-    end
+    docs
+  end
 
-    # Return the Autoload object for a given type.
-    def instance_loader(type)
-        @autoloaders[symbolize(type)]
-    end
+  # Return the instance hash for our type.
+  def instance_hash(type)
+    @instances[symbolize(type)]
+  end
+
+  # Return the Autoload object for a given type.
+  def instance_loader(type)
+    @autoloaders[symbolize(type)]
+  end
 
-    # Retrieve an alread-loaded instance, or attempt to load our instance.
-    def loaded_instance(type, name)
-        name = symbolize(name)
-        return nil unless instances = instance_hash(type)
+  # Retrieve an alread-loaded instance, or attempt to load our instance.
+  def loaded_instance(type, name)
+    name = symbolize(name)
+    return nil unless instances = instance_hash(type)
+    unless instances.include? name
+      if instance_loader(type).load(name)
         unless instances.include? name
-            if instance_loader(type).load(name)
-                unless instances.include? name
-                    Puppet.warning(
-                        "Loaded %s file for %s but %s was not defined" % [type, name, type]
-                    )
-                    return nil
-                end
-            else
-                return nil
-            end
+          Puppet.warning(
+            "Loaded #{type} file for #{name} but #{type} was not defined"
+          )
+          return nil
         end
-        instances[name]
+      else
+        return nil
+      end
     end
+    instances[name]
+  end
 end