puppet 0.25.5 → 2.6.0

data/lib/puppet/util/docs.rb

@@ -1,116 +1,114 @@
 # Some simple methods for helping manage automatic documentation generation.
 module Puppet::Util::Docs
-    # Specify the actual doc string.
-    def desc(str)
-        @doc = str
+  # Specify the actual doc string.
+  def desc(str)
+    @doc = str
+  end
+
+  # Add a new autodoc block.  We have to define these as class methods,
+  # rather than just sticking them in a hash, because otherwise they're
+  # too difficult to do inheritance with.
+  def dochook(name, &block)
+    method = "dochook_#{name}"
+
+    meta_def method, &block
+  end
+
+  attr_writer :doc
+
+  # Generate the full doc string.
+  def doc
+    extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
+      self.send(m)
+    }.join("  ")
+
+    if @doc
+      @doc + extra
+    else
+      extra
     end
-
-    # Add a new autodoc block.  We have to define these as class methods,
-    # rather than just sticking them in a hash, because otherwise they're
-    # too difficult to do inheritance with.
-    def dochook(name, &block)
-        method = "dochook_" + name.to_s
-
-        meta_def method, &block
+  end
+
+  # Build a table
+  def doctable(headers, data)
+    str = "\n\n"
+
+    lengths = []
+    # Figure out the longest field for all columns
+    data.each do |name, values|
+      [name, values].flatten.each_with_index do |value, i|
+        lengths[i] ||= 0
+        lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
+      end
     end
 
-    attr_writer :doc
-
-    # Generate the full doc string.
-    def doc
-        extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
-            self.send(m)
-        }.join("  ")
-
-        if defined? @doc and @doc
-            @doc + extra
-        else
-            extra
-        end
+    # The headers could also be longest
+    headers.each_with_index do |value, i|
+      lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
     end
 
-    # Build a table
-    def doctable(headers, data)
-        str = "\n\n"
-
-        lengths = []
-        # Figure out the longest field for all columns
-        data.each do |name, values|
-            [name, values].flatten.each_with_index do |value, i|
-                lengths[i] ||= 0
-                lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
-            end
-        end
-
-        # The headers could also be longest
-        headers.each_with_index do |value, i|
-            lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
-        end
-
-        # Add the top header row
-        str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
+    # Add the top header row
+    str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
 
-        # And the header names
-        str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" ") + "\n"
+    # And the header names
+    str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" ") + "\n"
 
-        # And the second header row
-        str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
+    # And the second header row
+    str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
 
-        # Now each data row
-        data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
-            str += [name, rows].flatten.zip(lengths).collect do |value, length|
-                pad(value, length)
-            end.join(" ") + "\n"
-        end
-
-        # And the bottom line row
-        str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
-
-        str + "\n"
-    end
-
-    attr_reader :nodoc
-    def nodoc?
-        nodoc
+    # Now each data row
+    data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
+      str += [name, rows].flatten.zip(lengths).collect do |value, length|
+        pad(value, length)
+      end.join(" ") + "\n"
     end
 
-    # Pad a field with spaces
-    def pad(value, length)
-        value.to_s + (" " * (length - value.to_s.length))
+    # And the bottom line row
+    str += lengths.collect { |num| "=" * num }.join(" ") + "\n"
+
+    str + "\n"
+  end
+
+  attr_reader :nodoc
+  def nodoc?
+    nodoc
+  end
+
+  # Pad a field with spaces
+  def pad(value, length)
+    value.to_s + (" " * (length - value.to_s.length))
+  end
+
+  # Handle the inline indentation in the docs.
+  def scrub(text)
+    # Stupid markdown
+    #text = text.gsub("<%=", "&lt;%=")
+    # For text with no carriage returns, there's nothing to do.
+    return text if text !~ /\n/
+    indent = nil
+
+    # If we can match an indentation, then just remove that same level of
+    # indent from every line.  However, ignore any indentation on the
+    # first line, since that can be inconsistent.
+    text = text.lstrip
+    text.gsub!(/^([\t]+)/) { |s| " "*8*s.length; } # Expand leading tabs
+    # Find first non-empty line after the first line:
+    line2start = (text =~ /(\n?\s*\n)/)
+    line2start += $1.length
+    if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
+      indent = Regexp.quote($1)
+      begin
+        return text.gsub(/^#{indent}/,'')
+      rescue => detail
+        puts detail.backtrace
+        puts detail
+      end
+    else
+      return text
     end
 
-    # Handle the inline indentation in the docs.
-    def scrub(text)
-        # Stupid markdown
-        #text = text.gsub("<%=", "&lt;%=")
-        # For text with no carriage returns, there's nothing to do.
-        if text !~ /\n/
-            return text
-        end
-        indent = nil
-
-        # If we can match an indentation, then just remove that same level of
-        # indent from every line.  However, ignore any indentation on the
-        # first line, since that can be inconsistent.
-        text = text.lstrip()
-        text.gsub!(/^([\t]+)/) { |s| " "*8*s.length(); } # Expand leading tabs
-        # Find first non-empty line after the first line:
-        line2start = (text =~ /(\n?\s*\n)/)
-        line2start += $1.length
-        if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
-            indent = Regexp.quote($1)
-            begin
-                return text.gsub(/^#{indent}/,'')
-            rescue => detail
-                puts detail.backtrace
-                puts detail
-            end
-        else
-            return text
-        end
-
-    end
+  end
 
-    module_function :scrub
+  module_function :scrub
 end
 

data/lib/puppet/util/errors.rb

@@ -1,54 +1,63 @@
 # Some helper methods for throwing errors.
 module Puppet::Util::Errors
-    # Throw a dev error.
-    def devfail(msg)
-        self.fail(Puppet::DevError, msg)
+  # Throw a dev error.
+  def devfail(msg)
+    self.fail(Puppet::DevError, msg)
+  end
+
+  # Add line and file info if available and appropriate.
+  def adderrorcontext(error, other = nil)
+    error.line ||= self.line if self.respond_to?(:line) and self.line
+    error.file ||= self.file if self.respond_to?(:file) and self.file
+
+    error.set_backtrace other.backtrace if other and other.respond_to?(:backtrace)
+
+    error
+  end
+
+  def error_context
+    if file and line
+      " at #{file}:#{line}"
+    elsif line
+      " at line #{line}"
+    elsif file
+      " in #{file}"
+    else
+      ""
     end
-
-    # Add line and file info if available and appropriate.
-    def adderrorcontext(error, other = nil)
-        error.line ||= self.line if self.respond_to?(:line) and self.line
-        error.file ||= self.file if self.respond_to?(:file) and self.file
-
-        if other and other.respond_to?(:backtrace)
-            error.set_backtrace other.backtrace
-        end
-
-        return error
+  end
+
+  # Wrap a call in such a way that we always throw the right exception and keep
+  # as much context as possible.
+  def exceptwrap(options = {})
+    options[:type] ||= Puppet::DevError
+    begin
+      return yield
+    rescue Puppet::Error => detail
+      raise adderrorcontext(detail)
+    rescue => detail
+      message = options[:message] || "#{self.class} failed with error #{detail.class}: #{detail}"
+
+      error = options[:type].new(message)
+      # We can't use self.fail here because it always expects strings,
+      # not exceptions.
+      raise adderrorcontext(error, detail)
     end
 
-    # Wrap a call in such a way that we always throw the right exception and keep
-    # as much context as possible.
-    def exceptwrap(options = {})
-        options[:type] ||= Puppet::DevError
-        begin
-            return yield
-        rescue Puppet::Error => detail
-            raise adderrorcontext(detail)
-        rescue => detail
-            message = options[:message] || "%s failed with error %s: %s" %
-                    [self.class, detail.class, detail.to_s]
-
-            error = options[:type].new(message)
-            # We can't use self.fail here because it always expects strings,
-            # not exceptions.
-            raise adderrorcontext(error, detail)
-        end
-
-        return retval
-    end
+    retval
+  end
 
-    # Throw an error, defaulting to a Puppet::Error.
-    def fail(*args)
-        if args[0].is_a?(Class)
-            type = args.shift
-        else
-            type = Puppet::Error
-        end
+  # Throw an error, defaulting to a Puppet::Error.
+  def fail(*args)
+    if args[0].is_a?(Class)
+      type = args.shift
+    else
+      type = Puppet::Error
+    end
 
-        error = adderrorcontext(type.new(args.join(" ")))
+    error = adderrorcontext(type.new(args.join(" ")))
 
-        raise error
-    end
+    raise error
+  end
 end
 

data/lib/puppet/util/execution.rb

@@ -1,21 +1,21 @@
 module Puppet::Util::Execution
-    module_function
+  module_function
 
-    # Run some code with a specific environment.  Resets the environment back to
-    # what it was at the end of the code.
-    def withenv(hash)
-        oldvals = {}
-        hash.each do |name, val|
-            name = name.to_s
-            oldvals[name] = ENV[name]
-            ENV[name] = val
-        end
+  # Run some code with a specific environment.  Resets the environment back to
+  # what it was at the end of the code.
+  def withenv(hash)
+    oldvals = {}
+    hash.each do |name, val|
+      name = name.to_s
+      oldvals[name] = ENV[name]
+      ENV[name] = val
+    end
 
-        yield
-    ensure
-        oldvals.each do |name, val|
-            ENV[name] = val
-        end
+    yield
+  ensure
+    oldvals.each do |name, val|
+      ENV[name] = val
     end
+  end
 end
 

data/lib/puppet/util/feature.rb

@@ -2,93 +2,83 @@
 #  Copyright (c) 2006. All rights reserved.
 
 class Puppet::Util::Feature
-    attr_reader :path
+  attr_reader :path
 
-    # Create a new feature test.  You have to pass the feature name,
-    # and it must be unique.  You can either provide a block that
-    # will get executed immediately to determine if the feature
-    # is present, or you can pass an option to determine it.
-    # Currently, the only supported option is 'libs' (must be
-    # passed as a symbol), which will make sure that each lib loads
-    # successfully.
-    def add(name, options = {})
-        method = name.to_s + "?"
-        if self.class.respond_to?(method)
-            raise ArgumentError, "Feature %s is already defined" % name
-        end
+  # Create a new feature test.  You have to pass the feature name,
+  # and it must be unique.  You can either provide a block that
+  # will get executed immediately to determine if the feature
+  # is present, or you can pass an option to determine it.
+  # Currently, the only supported option is 'libs' (must be
+  # passed as a symbol), which will make sure that each lib loads
+  # successfully.
+  def add(name, options = {})
+    method = name.to_s + "?"
+    raise ArgumentError, "Feature #{name} is already defined" if self.class.respond_to?(method)
 
-        if block_given?
-            begin
-                result = yield
-            rescue => detail
-                warn "Failed to load feature test for %s: %s" % [name, detail]
-                result = false
-            end
-            @results[name] = result
-        end
-
-        meta_def(method) do
-            unless @results.include?(name)
-                @results[name] = test(name, options)
-            end
-            @results[name]
-        end
+    if block_given?
+      begin
+        result = yield
+      rescue Exception => detail
+        warn "Failed to load feature test for #{name}: #{detail}"
+        result = false
+      end
+      @results[name] = result
     end
 
-    # Create a new feature collection.
-    def initialize(path)
-        @path = path
-        @results = {}
-        @loader = Puppet::Util::Autoload.new(self, @path)
+    meta_def(method) do
+      @results[name] = test(name, options) unless @results.include?(name)
+      @results[name]
     end
+  end
 
-    def load
-        @loader.loadall
-    end
+  # Create a new feature collection.
+  def initialize(path)
+    @path = path
+    @results = {}
+    @loader = Puppet::Util::Autoload.new(self, @path)
+  end
 
-    def method_missing(method, *args)
-        return super unless method.to_s =~ /\?$/
+  def load
+    @loader.loadall
+  end
 
-        feature = method.to_s.sub(/\?$/, '')
-        @loader.load(feature)
+  def method_missing(method, *args)
+    return super unless method.to_s =~ /\?$/
 
-        if respond_to?(method)
-            return self.send(method)
-        else
-            return false
-        end
-    end
+    feature = method.to_s.sub(/\?$/, '')
+    @loader.load(feature)
 
-    # Actually test whether the feature is present.  We only want to test when
-    # someone asks for the feature, so we don't unnecessarily load
-    # files.
-    def test(name, options)
-        return true unless ary = options[:libs]
-        ary = [ary] unless ary.is_a?(Array)
+    respond_to?(method) && self.send(method)
+  end
 
-        ary.each do |lib|
-            return false unless load_library(lib, name)
-        end
+  # Actually test whether the feature is present.  We only want to test when
+  # someone asks for the feature, so we don't unnecessarily load
+  # files.
+  def test(name, options)
+    return true unless ary = options[:libs]
+    ary = [ary] unless ary.is_a?(Array)
 
-        # We loaded all of the required libraries
-        return true
+    ary.each do |lib|
+      return false unless load_library(lib, name)
     end
 
-    private
+    # We loaded all of the required libraries
+    true
+  end
+
+  private
 
-    def load_library(lib, name)
-        unless lib.is_a?(String)
-            raise ArgumentError, "Libraries must be passed as strings not %s" % lib.class
-        end
+  def load_library(lib, name)
+    raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
 
-        begin
-            require lib
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception
-            Puppet.debug "Failed to load library '%s' for feature '%s'" % [lib, name]
-            return false
-        end
-        return true
+    begin
+      require lib
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception
+      Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
+      return false
     end
+    true
+  end
 end