diff --git a/.rubocop.yml b/.rubocop.yml
index e7c696dba..0813e2e4c 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,533 +1,532 @@
 AllCops:
   Include:
     - 'lib/**/*.rb'
     - 'ext/**/*.rb'
   Exclude:
     - '**/*.erb'
     - 'acceptance/**/*'
     - 'autotest/**/*'
     - 'spec/**/*'
     - 'tasks/**/*'
     - 'lib/puppet/vendor/**/*'
     - 'lib/puppet/parser/parser.rb'
     - 'lib/puppet/pops/parser/eparser.rb'
     - 'lib/puppet/external/nagios/parser.rb'
 
 Lint/ConditionPosition:
   Enabled: true
 
 Lint/ElseLayout:
   Enabled: true
 
 Lint/UnreachableCode:
   Enabled: true
 
 Lint/UselessComparison:
   Enabled: true
 
 # MAYBE useful - no return inside ensure block.
 Lint/EnsureReturn:
   Enabled: false
 
 # MAYBE useful - errors when rescue {} happens.
 Lint/HandleExceptions:
   Enabled: false
 
 # MAYBE useful - catches while 1
 Lint/LiteralInCondition:
   Enabled: false
 
-# MAYBE useful - but too many instances
 Lint/ShadowingOuterLocalVariable:
-  Enabled: false
+  Enabled: true
 
 # Can catch complicated strings.
 Lint/LiteralInInterpolation:
   Enabled: true
 
 
 # DISABLED really useless. Detects return as last statement.
 Style/RedundantReturn:
   Enabled: false
 
 # DISABLED since the instances do not seem to indicate any specific errors.
 Lint/AmbiguousOperator:
   Enabled: false
 
 # DISABLED since for all the checked, we are basically checking nil
 # TODO: Change the checking so that if the variable being assigned to has
 # a value ALREADY, then raise an error.
 Lint/AssignmentInCondition:
   Enabled: false
 
 # DISABLED - not useful
 Style/SpaceBeforeComment:
   Enabled: false
 
 # DISABLED - not useful
 Style/HashSyntax:
   Enabled: false
 
 # USES: as shortcut for non nil&valid checking a = x() and a.empty?
 # DISABLED - not useful
 Style/AndOr:
   Enabled: false
 
 # DISABLED - not useful
 Style/RedundantSelf:
   Enabled: false
 
 # DISABLED - not useful
 Metrics/MethodLength:
   Enabled: false
 
 # DISABLED - not useful
 Style/WhileUntilModifier:
   Enabled: false
 
 # DISABLED - the offender is just haskell envy
 Lint/AmbiguousRegexpLiteral:
   Enabled: false
 
 # DISABLED
 Lint/Eval:
   Enabled: false
 # DISABLED
 Lint/BlockAlignment:
   Enabled: false
 
 # DISABLED
 Lint/DefEndAlignment:
   Enabled: false
 
 # DISABLED
 Lint/EndAlignment:
   Enabled: false
 
 # DISABLED
 Lint/DeprecatedClassMethods:
   Enabled: false
 
 # DISABLED
 Lint/Loop:
   Enabled: false
 
 # DISABLED
 Lint/ParenthesesAsGroupedExpression:
   Enabled: false
 
 Lint/RescueException:
   Enabled: false
 
 Lint/StringConversionInInterpolation:
   Enabled: false
 
 Lint/UnusedBlockArgument:
   Enabled: false
 
 Lint/UnusedMethodArgument:
   Enabled: false
 
 # DISABLED - TODO
 Lint/UselessAccessModifier:
   Enabled: false
 
 # DISABLED - TODO
 Lint/UselessAssignment:
   Enabled: false
 
 # DISABLED - TODO
 Lint/Void:
   Enabled: false
 
 Style/AccessModifierIndentation:
   Enabled: false
 
 Style/AccessorMethodName:
   Enabled: false
 
 Style/Alias:
   Enabled: false
 
 Style/AlignArray:
   Enabled: false
 
 Style/AlignHash:
   Enabled: false
 
 Style/AlignParameters:
   Enabled: false
 
 Metrics/BlockNesting:
   Enabled: false
 
 Style/AsciiComments:
   Enabled: false
 
 Style/Attr:
   Enabled: false
 
 Style/Blocks:
   Enabled: false
 
 Style/BracesAroundHashParameters:
   Enabled: false
 
 Style/CaseEquality:
   Enabled: false
 
 Style/CaseIndentation:
   Enabled: false
 
 Style/CharacterLiteral:
   Enabled: false
 
 Style/ClassAndModuleCamelCase:
   Enabled: false
 
 Style/ClassAndModuleChildren:
   Enabled: false
 
 Style/ClassCheck:
   Enabled: false
 
 Metrics/ClassLength:
   Enabled: false
 
 Style/ClassMethods:
   Enabled: false
 
 Style/ClassVars:
   Enabled: false
 
 Style/WhenThen:
   Enabled: false
 
 
 # DISABLED - not useful
 Style/WordArray:
   Enabled: false
 
 Style/UnneededPercentQ:
   Enabled: false
 
 Style/Tab:
   Enabled: false
 
 Style/SpaceBeforeSemicolon:
   Enabled: false
 
 Style/TrailingBlankLines:
   Enabled: false
 
 Style/SpaceInsideBlockBraces:
   Enabled: false
 
 Style/SpaceInsideBrackets:
   Enabled: false
 
 Style/SpaceInsideHashLiteralBraces:
   Enabled: false
 
 Style/SpaceInsideParens:
   Enabled: false
 
 Style/LeadingCommentSpace:
   Enabled: false
 
 Style/SingleSpaceBeforeFirstArg:
   Enabled: false
 
 Style/SpaceAfterColon:
   Enabled: false
 
 Style/SpaceAfterComma:
   Enabled: false
 
 Style/SpaceAfterControlKeyword:
   Enabled: false
 
 Style/SpaceAfterMethodName:
   Enabled: false
 
 Style/SpaceAfterNot:
   Enabled: false
 
 Style/SpaceAfterSemicolon:
   Enabled: false
 
 Style/SpaceAroundEqualsInParameterDefault:
   Enabled: false
 
 Style/SpaceAroundOperators:
   Enabled: false
 
 Style/SpaceBeforeBlockBraces:
   Enabled: false
 
 Style/SpaceBeforeComma:
   Enabled: false
 
 
 Style/CollectionMethods:
   Enabled: false
 
 Style/CommentIndentation:
   Enabled: false
 
 Style/ColonMethodCall:
   Enabled: false
 
 Style/CommentAnnotation:
   Enabled: false
 
 Metrics/CyclomaticComplexity:
   Enabled: false
 
 Style/ConstantName:
   Enabled: false
 
 Style/Documentation:
   Enabled: false
 
 Style/DefWithParentheses:
   Enabled: false
 
 Style/DeprecatedHashMethods:
   Enabled: false
 
 Style/DotPosition:
   Enabled: false
 
 # DISABLED - used for converting to bool
 Style/DoubleNegation:
   Enabled: false
 
 Style/EachWithObject:
   Enabled: false
 
 Style/EmptyLineBetweenDefs:
   Enabled: false
 
 Style/IndentArray:
   Enabled: false
 
 Style/IndentHash:
   Enabled: false
 
 Style/IndentationConsistency:
   Enabled: false
 
 Style/IndentationWidth:
   Enabled: false
 
 Style/EmptyLines:
   Enabled: false
 
 Style/EmptyLinesAroundAccessModifier:
   Enabled: false
 
 Style/EmptyLinesAroundBody:
   Enabled: false
 
 Style/EmptyLiteral:
   Enabled: false
 
 Metrics/LineLength:
   Enabled: false
 
 Style/MethodCallParentheses:
   Enabled: false
 
 Style/MethodDefParentheses:
   Enabled: false
 
 Style/LineEndConcatenation:
   Enabled: false
 
 Style/TrailingWhitespace:
   Enabled: false
 
 Style/StringLiterals:
   Enabled: false
 
 Style/TrailingComma:
   Enabled: false
 
 Style/GlobalVars:
   Enabled: false
 
 Style/GuardClause:
   Enabled: false
 
 Style/IfUnlessModifier:
   Enabled: false
 
 Style/MultilineIfThen:
   Enabled: false
 
 Style/NegatedIf:
   Enabled: false
 
 Style/NegatedWhile:
   Enabled: false
 
 Style/Next:
   Enabled: false
 
 Style/SingleLineBlockParams:
   Enabled: false
 
 Style/SingleLineMethods:
   Enabled: false
 
 Style/SpecialGlobalVars:
   Enabled: false
 
 
 Style/TrivialAccessors:
   Enabled: false
 
 Style/UnlessElse:
   Enabled: false
 
 Style/UnneededPercentX:
   Enabled: false
 
 Style/VariableInterpolation:
   Enabled: false
 
 Style/VariableName:
   Enabled: false
 
 Style/WhileUntilDo:
   Enabled: false
 
 Style/EvenOdd:
   Enabled: false
 
 Style/FileName:
   Enabled: false
 
 Style/For:
   Enabled: false
 
 Style/Lambda:
   Enabled: false
 
 Style/MethodName:
   Enabled: false
 
 Style/MultilineTernaryOperator:
   Enabled: false
 
 Style/NestedTernaryOperator:
   Enabled: false
 
 Style/NilComparison:
   Enabled: false
 
 Style/FormatString:
   Enabled: false
 
 Style/MultilineBlockChain:
   Enabled: false
 
 Style/Semicolon:
   Enabled: false
 
 Style/SignalException:
   Enabled: false
 
 Style/NonNilCheck:
   Enabled: false
 
 Style/Not:
   Enabled: false
 
 Style/NumericLiterals:
   Enabled: false
 
 Style/OneLineConditional:
   Enabled: false
 
 Style/OpMethod:
   Enabled: false
 
 Style/ParenthesesAroundCondition:
   Enabled: false
 
 Style/PercentLiteralDelimiters:
   Enabled: false
 
 Style/PerlBackrefs:
   Enabled: false
 
 Style/PredicateName:
   Enabled: false
 
 Style/RedundantException:
   Enabled: false
 
 Style/SelfAssignment:
   Enabled: false
 
 Style/Proc:
   Enabled: false
 
 Style/RaiseArgs:
   Enabled: false
 
 Style/RedundantBegin:
   Enabled: false
 
 Style/RescueModifier:
   Enabled: false
 
 Style/RegexpLiteral:
   Enabled: false
 
 Lint/UnderscorePrefixedVariableName:
   Enabled: false
 
 Metrics/ParameterLists:
   Enabled: false
 
 Lint/RequireParentheses:
   Enabled: false
 
 Lint/SpaceBeforeFirstArg:
   Enabled: false
 
 Style/ModuleFunction:
   Enabled: false
 
 Lint/Debugger:
   Enabled: false
 
 Style/IfWithSemicolon:
   Enabled: false
 
 Style/Encoding:
   Enabled: false
 
 Metrics/PerceivedComplexity:
   Enabled: false
 
 Style/SymbolProc:
   Enabled: false
 
 Style/SpaceInsideRangeLiteral:
   Enabled: false
 
 Style/InfiniteLoop:
   Enabled: false
 
 Style/BarePercentLiterals:
   Enabled: false
 
 Style/PercentQLiterals:
   Enabled: false
 
 Style/MultilineBlockLayout:
   Enabled: false
diff --git a/ext/nagios/check_puppet.rb b/ext/nagios/check_puppet.rb
index 36d8fa79c..a7570f868 100755
--- a/ext/nagios/check_puppet.rb
+++ b/ext/nagios/check_puppet.rb
@@ -1,123 +1,123 @@
 #!/usr/bin/env ruby
 
 require 'optparse'
 require 'sys/proctable'
 include Sys
 
 class CheckPuppet
 
   VERSION = '0.1'
   script_name = File.basename($0)
 
   # default options
   OPTIONS = {
     :statefile => "/var/lib/puppet/state/state.yaml",
     :process   => "puppetd",
     :interval  => 30,
   }
 
-  o = OptionParser.new do |o|
+  OptionParser.new do |o|
     o.set_summary_indent('  ')
     o.banner =    "Usage: #{script_name} [OPTIONS]"
     o.define_head "The check_puppet Nagios plug-in checks that specified Puppet process is running and the state file is no older than specified interval."
       o.separator   ""
       o.separator   "Mandatory arguments to long options are mandatory for short options too."
 
 
         o.on(
           "-s", "--statefile=statefile", String, "The state file",
 
     "Default: #{OPTIONS[:statefile]}") { |op| OPTIONS[:statefile] = op }
 
       o.on(
         "-p", "--process=processname", String, "The process to check",
 
     "Default: #{OPTIONS[:process]}")   { |op| OPTIONS[:process] = op }
 
       o.on(
         "-i", "--interval=value", Integer,
 
     "Default: #{OPTIONS[:interval]} minutes")  { |op| OPTIONS[:interval] = op }
 
     o.separator ""
     o.on_tail("-h", "--help", "Show this help message.") do
       puts o
       exit
     end
 
     o.parse!(ARGV)
   end
 
   def check_proc
 
     unless ProcTable.ps.find { |p| p.name == OPTIONS[:process]}
       @proc = 2
     else
       @proc = 0
     end
 
   end
 
   def check_state
 
     # Set variables
     curt = Time.now
     intv = OPTIONS[:interval] * 60
 
     # Check file time
     begin
       @modt = File.mtime("#{OPTIONS[:statefile]}")
     rescue
       @file = 3
     end
 
     diff = (curt - @modt).to_i
 
     if diff > intv
       @file = 2
     else
       @file = 0
     end
 
   end
 
   def output_status
 
     case @file
     when 0
       state = "state file status okay updated on " + @modt.strftime("%m/%d/%Y at %H:%M:%S")
     when 2
       state = "state fille is not up to date and is older than #{OPTIONS[:interval]} minutes"
     when 3
       state = "state file status unknown"
     end
 
     case @proc
     when 0
       process = "process #{OPTIONS[:process]} is running"
     when 2
       process = "process #{OPTIONS[:process]} is not running"
     end
 
     case
     when (@proc == 2 or @file == 2)
       status = "CRITICAL"
       exitcode = 2
     when (@proc == 0 and @file == 0)
       status = "OK"
       exitcode = 0
     else
       status = "UNKNOWN"
       exitcode = 3
     end
 
     puts "PUPPET #{status}: #{process}, #{state}"
     exit(exitcode)
   end
 end
 
 cp = CheckPuppet.new
 cp.check_proc
 cp.check_state
 cp.output_status
 
diff --git a/lib/puppet/application/face_base.rb b/lib/puppet/application/face_base.rb
index c6e4a2828..e767805c7 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,250 +1,250 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   option("--debug", "-d") do |arg|
     set_log_level(:debug => true)
   end
 
   option("--verbose", "-v") do |_|
     set_log_level(:verbose => true)
   end
 
   option("--render-as FORMAT") do |format|
     self.render_as = format.to_sym
   end
 
   attr_accessor :face, :action, :type, :arguments, :render_as
 
   def render_as=(format)
     if format == :json then
       @render_as = Puppet::Network::FormatHandler.format(:pson)
     else
       @render_as = Puppet::Network::FormatHandler.format(format)
     end
     @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
   end
 
   def render(result, args_and_options)
     hook = action.when_rendering(render_as.name)
 
     if hook
       # when defining when_rendering on your action you can optionally
       # include arguments and options
       if hook.arity > 1
         result = hook.call(result, *args_and_options)
       else
         result = hook.call(result)
       end
     end
 
     render_as.render(result)
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
     @type = Puppet::Util::ConstantInflector.constant2file(self.class.name.to_s.sub(/.+:/, '')).to_sym
     @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
     action_name = nil
     index       = -1
     until action_name or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             # ... But, the mandatory argument will not be the next item if an = is
             # employed in the long form of the option. --jeffmccune 2012-09-18
             index += 1 unless item =~ /^--#{option.name}=/
           end
         elsif option = find_application_argument(item) then
           index += 1 if (option[:argument] and not option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
         # Stash away the requested action name for later, and try to fetch the
         # action object it represents; if this is an invalid action name that
         # will be nil, and handled later.
         action_name = item.to_sym
         @action = Puppet::Face.find_action(@face.name, action_name)
         @face   = @action.face if @action
       end
     end
 
     if @action.nil?
       if @action = @face.get_default_action() then
         @is_default_action = true
       else
         face   = @face.name
         action = action_name.nil? ? 'default' : "'#{action_name}'"
         msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
 
         Puppet.err(msg)
         Puppet::Util::Log.force_flushqueue()
 
         exit false
       end
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
-    @action.options.each do |option|
-      option = @action.get_option(option) # make it the object.
-      self.class.option(*option.optparse) # ...and make the CLI parse it.
+    @action.options.each do |o|
+      o = @action.get_option(o) # make it the object.
+      self.class.option(*o.optparse) # ...and make the CLI parse it.
     end
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
   def find_application_argument(item)
     self.class.option_parser_commands.each do |options, function|
       options.each do |option|
         next unless option =~ /^-/
         pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         next unless pattern.match(item)
         return {
           :argument => option =~ /[ =]/,
           :optional => option =~ /[ =]\[/
         }
       end
     end
     return nil                  # not found
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
 
     # If we don't have a rendering format, set one early.
     self.render_as ||= (@action.render_as || :console)
   end
 
 
   def main
     status = false
 
     # Call the method associated with the provided action (e.g., 'find').
     unless @action
       puts Puppet::Face[:help, :current].help(@face.name)
       raise "#{face} does not respond to action #{arguments.first}"
     end
 
     # We need to do arity checking here because this is generic code
     # calling generic methods – that have argument defaulting.  We need to
     # make sure we don't accidentally pass the options as the first
     # argument to a method that takes one argument.  eg:
     #
     #   puppet facts find
     #   => options => {}
     #      @arguments => [{}]
     #   => @face.send :bar, {}
     #
     #   def face.bar(argument, options = {})
     #   => bar({}, {})  # oops!  we thought the options were the
     #                   # positional argument!!
     #
     # We could also fix this by making it mandatory to pass the options on
     # every call, but that would make the Ruby API much more annoying to
     # work with; having the defaulting is a much nicer convention to have.
     #
     # We could also pass the arguments implicitly, by having a magic
     # 'options' method that was visible in the scope of the action, which
     # returned the right stuff.
     #
     # That sounds attractive, but adds complications to all sorts of
     # things, especially when you think about how to pass options when you
     # are writing Ruby code that calls multiple faces.  Especially if
     # faces are involved in that. ;)
     #
     # --daniel 2011-04-27
     if (arity = @action.positional_arg_count) > 0
       unless (count = arguments.length) == arity then
         s = arity == 2 ? '' : 's'
         raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
       end
     end
 
     result = @face.send(@action.name, *arguments)
     puts render(result, arguments) unless result.nil?
     status = true
 
   # We need an easy way for the action to set a specific exit code, so we
   # rescue SystemExit here; This allows each action to set the desired exit
   # code by simply calling Kernel::exit.  eg:
   #
   #   exit(2)
   #
   # --kelsey 2012-02-14
   rescue SystemExit => detail
     status = detail.status
 
   rescue => detail
     Puppet.log_exception(detail)
     Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
 
   ensure
     exit status
   end
 end
diff --git a/lib/puppet/external/nagios/base.rb b/lib/puppet/external/nagios/base.rb
index 06f6987ab..14c7a558f 100644
--- a/lib/puppet/external/nagios/base.rb
+++ b/lib/puppet/external/nagios/base.rb
@@ -1,472 +1,472 @@
 # The base class for all of our Nagios object types.  Everything else
 # is mostly just data.
 class Nagios::Base
 
   class UnknownNagiosType < RuntimeError # When an unknown type is asked for by name.
   end
 
   include Enumerable
 
   class << self
     attr_accessor :parameters, :derivatives, :ocs, :name, :att
     attr_accessor :ldapbase
 
     attr_writer :namevar
 
     attr_reader :superior
   end
 
   # Attach one class to another.
   def self.attach(hash)
     @attach ||= {}
     hash.each do |n, v| @attach[n] = v end
   end
 
   # Convert a parameter to camelcase
   def self.camelcase(param)
     param.gsub(/_./) do |match|
       match.sub(/_/,'').capitalize
     end
   end
 
   # Uncamelcase a parameter.
   def self.decamelcase(param)
     param.gsub(/[A-Z]/) do |match|
       "_#{match.downcase}"
     end
   end
 
   # Create a new instance of a given class.
   def self.create(name, args = {})
     name = name.intern if name.is_a? String
 
     if @types.include?(name)
       @types[name].new(args)
     else
       raise UnknownNagiosType, "Unknown type #{name}"
     end
   end
 
   # Yield each type in turn.
   def self.eachtype
     @types.each do |name, type|
       yield [name, type]
     end
   end
 
   # Create a mapping.
   def self.map(hash)
     @map ||= {}
     hash.each do |n, v| @map[n] = v end
   end
 
   # Return a mapping (or nil) for a param
   def self.mapping(name)
     name = name.intern if name.is_a? String
     if defined?(@map)
       @map[name]
     else
       nil
     end
   end
 
   # Return the namevar for the canonical name.
   def self.namevar
     if defined?(@namevar)
       return @namevar
     else
       if parameter?(:name)
         return :name
       elsif tmp = (self.name.to_s + "_name").intern and parameter?(tmp)
         @namevar = tmp
         return @namevar
       else
         raise "Type #{self.name} has no name var"
       end
     end
   end
 
   # Create a new type.
   def self.newtype(name, &block)
     name = name.intern if name.is_a? String
 
     @types ||= {}
 
     # Create the class, with the correct name.
     t = Class.new(self)
     t.name = name
 
     # Everyone gets this.  There should probably be a better way, and I
     # should probably hack the attribute system to look things up based on
     # this "use" setting, but, eh.
     t.parameters = [:use]
 
     const_set(name.to_s.capitalize,t)
 
     # Evaluate the passed block.  This should usually define all of the work.
     t.class_eval(&block)
 
     @types[name] = t
   end
 
   # Define both the normal case and camelcase method for a parameter
   def self.paramattr(name)
     camel = camelcase(name)
     param = name
 
     [name, camel].each do |method|
       define_method(method) do
         @parameters[param]
       end
 
       define_method(method.to_s + "=") do |value|
         @parameters[param] = value
       end
     end
 
   end
 
   # Is the specified name a valid parameter?
   def self.parameter?(name)
     name = name.intern if name.is_a? String
     @parameters.include?(name)
   end
 
   # Manually set the namevar
   def self.setnamevar(name)
     name = name.intern if name.is_a? String
     @namevar = name
   end
 
   # Set the valid parameters for this class
   def self.setparameters(*array)
     @parameters += array
   end
 
   # Set the superior ldap object class.  Seems silly to include this
   # in this class, but, eh.
   def self.setsuperior(name)
     @superior = name
   end
 
   # Parameters to suppress in output.
   def self.suppress(name)
     @suppress ||= []
     @suppress << name
   end
 
   # Whether a given parameter is suppressed.
   def self.suppress?(name)
     defined?(@suppress) and @suppress.include?(name)
   end
 
   # Return our name as the string.
   def self.to_s
     self.name.to_s
   end
 
   # Return a type by name.
   def self.type(name)
     name = name.intern if name.is_a? String
 
     @types[name]
   end
 
   # Convenience methods.
   def [](param)
     send(param)
   end
 
   # Convenience methods.
   def []=(param,value)
     send(param.to_s + "=", value)
   end
 
   # Iterate across all ofour set parameters.
   def each
     @parameters.each { |param,value|
       yield(param,value)
     }
   end
 
   # Initialize our object, optionally with a list of parameters.
   def initialize(args = {})
     @parameters = {}
 
     args.each { |param,value|
       self[param] = value
     }
     if @namevar == :_naginator_name
       self['_naginator_name'] = self['name']
     end
   end
 
   # Handle parameters like attributes.
   def method_missing(mname, *args)
     pname = mname.to_s
     pname.sub!(/=/, '')
 
     if self.class.parameter?(pname)
       if pname =~ /A-Z/
         pname = self.class.decamelcase(pname)
       end
       self.class.paramattr(pname)
 
       # Now access the parameters directly, to make it at least less
       # likely we'll end up in an infinite recursion.
       if mname.to_s =~ /=$/
         @parameters[pname] = args.first
       else
         return @parameters[mname]
       end
     else
       super
     end
   end
 
   # Retrieve our name, through a bit of redirection.
   def name
     send(self.class.namevar)
   end
 
   # This is probably a bad idea.
   def name=(value)
     unless self.class.namevar.to_s == "name"
       send(self.class.namevar.to_s + "=", value)
     end
   end
 
   def namevar
     (self.type + "_name").intern
   end
 
   def parammap(param)
     unless defined?(@map)
       map = {
         self.namevar => "cn"
       }
       map.update(self.class.map) if self.class.map
     end
     if map.include?(param)
       return map[param]
     else
       return "nagios-" + param.id2name.gsub(/_/,'-')
     end
   end
 
   def parent
     unless defined?(self.class.attached)
       puts "Duh, you called parent on an unattached class"
       return
     end
 
     klass,param = self.class.attached
     unless @parameters.include?(param)
       puts "Huh, no attachment param"
       return
     end
     klass[@parameters[param]]
   end
 
   # okay, this sucks
   # how do i get my list of ocs?
   def to_ldif
     str = self.dn + "\n"
     ocs = Array.new
     if self.class.ocs
       # i'm storing an array, so i have to flatten it and stuff
       kocs = self.class.ocs
       ocs.push(*kocs)
     end
     ocs.push "top"
     oc = self.class.to_s
     oc.sub!(/Nagios/,'nagios')
     oc.sub!(/::/,'')
     ocs.push oc
-    ocs.each { |oc|
-      str += "objectclass: #{oc}\n"
+    ocs.each { |objclass|
+      str += "objectclass: #{objclass}\n"
     }
     @parameters.each { |name,value|
       next if self.class.suppress.include?(name)
       ldapname = self.parammap(name)
       str += ldapname + ": #{value}\n"
     }
     str += "\n"
   end
 
   def to_s
     str = "define #{self.type} {\n"
 
     @parameters.keys.sort.each { |param|
       value = @parameters[param]
       str += %{\t%-30s %s\n} % [ param,
         if value.is_a? Array
           value.join(",").sub(';', '\;')
         else
           value.to_s.sub(';', '\;')
         end
         ]
     }
 
     str += "}\n"
 
     str
   end
 
   # The type of object we are.
   def type
     self.class.name
   end
 
   # object types
   newtype :host do
     setparameters :host_name, :alias, :display_name, :address, :parents,
       :hostgroups, :check_command, :initial_state, :max_check_attempts,
       :check_interval, :retry_interval, :active_checks_enabled,
       :passive_checks_enabled, :check_period, :obsess_over_host,
       :check_freshness, :freshness_threshold, :event_handler,
       :event_handler_enabled, :low_flap_threshold, :high_flap_threshold,
       :flap_detection_enabled, :flap_detection_options,
       :failure_prediction_enabled, :process_perf_data,
       :retain_status_information, :retain_nonstatus_information, :contacts,
       :contact_groups, :notification_interval, :first_notification_delay,
       :notification_period, :notification_options, :notifications_enabled,
       :stalking_options, :notes, :notes_url, :action_url, :icon_image,
       :icon_image_alt, :vrml_image, :statusmap_image, "2d_coords".intern,
       "3d_coords".intern,
       :register, :use,
       :realm, :poller_tag, :business_impact
 
     setsuperior "person"
     map :address => "ipHostNumber"
   end
 
   newtype :hostgroup do
     setparameters :hostgroup_name, :alias, :members, :hostgroup_members, :notes,
       :notes_url, :action_url,
       :register, :use,
       :realm
   end
 
   newtype :service do
     attach :host => :host_name
     setparameters :host_name, :hostgroup_name, :service_description,
       :display_name, :servicegroups, :is_volatile, :check_command,
       :initial_state, :max_check_attempts, :check_interval, :retry_interval,
       :normal_check_interval, :retry_check_interval, :active_checks_enabled,
       :passive_checks_enabled, :parallelize_check, :check_period,
       :obsess_over_service, :check_freshness, :freshness_threshold,
       :event_handler, :event_handler_enabled, :low_flap_threshold,
       :high_flap_threshold, :flap_detection_enabled,:flap_detection_options,
       :process_perf_data, :failure_prediction_enabled, :retain_status_information,
       :retain_nonstatus_information, :notification_interval,
       :first_notification_delay, :notification_period, :notification_options,
       :notifications_enabled, :contacts, :contact_groups, :stalking_options,
       :notes, :notes_url, :action_url, :icon_image, :icon_image_alt,
       :register, :use,
       :_naginator_name,
       :poller_tag, :business_impact
 
     suppress :host_name
 
     setnamevar :_naginator_name
   end
 
   newtype :servicegroup do
     setparameters :servicegroup_name, :alias, :members, :servicegroup_members,
       :notes, :notes_url, :action_url,
       :register, :use
   end
 
   newtype :contact do
     setparameters :contact_name, :alias, :contactgroups,
       :host_notifications_enabled, :service_notifications_enabled,
       :host_notification_period, :service_notification_period,
       :host_notification_options, :service_notification_options,
       :host_notification_commands, :service_notification_commands,
       :email, :pager, :address1, :address2, :address3, :address4,
       :address5, :address6, :can_submit_commands, :retain_status_information,
       :retain_nonstatus_information,
       :register, :use
 
     setsuperior "person"
   end
 
   newtype :contactgroup do
     setparameters :contactgroup_name, :alias, :members, :contactgroup_members,
       :register, :use
   end
 
   # TODO - We should support generic time periods here eg "day 1 - 15"
   newtype :timeperiod do
     setparameters :timeperiod_name, :alias, :sunday, :monday, :tuesday,
       :wednesday, :thursday, :friday, :saturday, :exclude,
       :register, :use
   end
 
   newtype :command do
     setparameters :command_name, :command_line,
     :poller_tag
   end
 
   newtype :servicedependency do
     setparameters :dependent_host_name, :dependent_hostgroup_name,
       :dependent_service_description, :host_name, :hostgroup_name,
       :service_description, :inherits_parent, :execution_failure_criteria,
       :notification_failure_criteria, :dependency_period,
       :register, :use,
       :_naginator_name
 
     setnamevar :_naginator_name
   end
 
   newtype :serviceescalation do
     setparameters :host_name, :hostgroup_name, :servicegroup_name,
       :service_description, :contacts, :contact_groups,
       :first_notification, :last_notification, :notification_interval,
       :escalation_period, :escalation_options,
       :register, :use,
       :_naginator_name
 
     setnamevar :_naginator_name
   end
 
   newtype :hostdependency do
     setparameters :dependent_host_name, :dependent_hostgroup_name, :host_name,
       :hostgroup_name, :inherits_parent, :execution_failure_criteria,
       :notification_failure_criteria, :dependency_period,
       :register, :use,
       :_naginator_name
 
     setnamevar :_naginator_name
   end
 
   newtype :hostescalation do
     setparameters :host_name, :hostgroup_name, :contacts, :contact_groups,
       :first_notification, :last_notification, :notification_interval,
       :escalation_period, :escalation_options,
       :register, :use,
       :_naginator_name
 
     setnamevar :_naginator_name
   end
 
   newtype :hostextinfo do
     setparameters :host_name, :notes, :notes_url, :icon_image, :icon_image_alt,
       :vrml_image, :statusmap_image, "2d_coords".intern, "3d_coords".intern,
       :register, :use
 
     setnamevar :host_name
   end
 
   newtype :serviceextinfo do
 
     setparameters :host_name, :service_description, :notes, :notes_url,
       :action_url, :icon_image, :icon_image_alt,
       :register, :use,
       :_naginator_name
 
     setnamevar :_naginator_name
   end
 
 end
diff --git a/lib/puppet/file_bucket/dipper.rb b/lib/puppet/file_bucket/dipper.rb
index b627ce02d..e521b0a2e 100644
--- a/lib/puppet/file_bucket/dipper.rb
+++ b/lib/puppet/file_bucket/dipper.rb
@@ -1,119 +1,118 @@
 require 'pathname'
 require 'puppet/file_bucket'
 require 'puppet/file_bucket/file'
 require 'puppet/indirector/request'
 
 class Puppet::FileBucket::Dipper
   include Puppet::Util::Checksums
   # This is a transitional implementation that uses REST
   # to access remote filebucket files.
 
   attr_accessor :name
 
   # Creates a bucket client
   def initialize(hash = {})
     # Emulate the XMLRPC client
     server      = hash[:Server]
     port        = hash[:Port] || Puppet[:masterport]
     environment = Puppet[:environment]
 
     if hash.include?(:Path)
       @local_path = hash[:Path]
       @rest_path  = nil
     else
       @local_path = nil
       @rest_path = "https://#{server}:#{port}/#{environment}/file_bucket_file/"
     end
     @checksum_type = Puppet[:digest_algorithm].to_sym
     @digest = method(@checksum_type)
   end
 
   def local?
     !! @local_path
   end
 
   # Backs up a file to the file bucket
   def backup(file)
     file_handle = Puppet::FileSystem.pathname(file)
     raise(ArgumentError, "File #{file} does not exist") unless Puppet::FileSystem.exist?(file_handle)
     begin
       file_bucket_file = Puppet::FileBucket::File.new(file_handle, :bucket_path => @local_path)
       files_original_path = absolutize_path(file)
       dest_path = "#{@rest_path}#{file_bucket_file.name}/#{files_original_path}"
       file_bucket_path = "#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"
 
       # Make a HEAD request for the file so that we don't waste time
       # uploading it if it already exists in the bucket.
       unless Puppet::FileBucket::File.indirection.head(file_bucket_path)
         Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
       end
 
       return file_bucket_file.checksum_data
     rescue => detail
       message = "Could not back up #{file}: #{detail}"
       Puppet.log_exception(detail, message)
       raise Puppet::Error, message, detail.backtrace
     end
   end
 
   # Retrieves a file by sum.
   def getfile(sum)
     get_bucket_file(sum).to_s
   end
 
   # Retrieves a FileBucket::File by sum.
   def get_bucket_file(sum)
     source_path = "#{@rest_path}#{@checksum_type}/#{sum}"
     file_bucket_file = Puppet::FileBucket::File.indirection.find(source_path, :bucket_path => @local_path)
 
     raise Puppet::Error, "File not found" unless file_bucket_file
     file_bucket_file
   end
 
   # Restores the file
   def restore(file, sum)
     restore = true
     file_handle = Puppet::FileSystem.pathname(file)
     if Puppet::FileSystem.exist?(file_handle)
       cursum = Puppet::FileBucket::File.new(file_handle).checksum_data()
 
       # if the checksum has changed...
       # this might be extra effort
       if cursum == sum
         restore = false
       end
     end
 
     if restore
       if newcontents = get_bucket_file(sum)
         newsum = newcontents.checksum_data
         changed = nil
         if Puppet::FileSystem.exist?(file_handle) and ! Puppet::FileSystem.writable?(file_handle)
           changed = Puppet::FileSystem.stat(file_handle).mode
           ::File.chmod(changed | 0200, file)
         end
         ::File.open(file, ::File::WRONLY|::File::TRUNC|::File::CREAT) { |of|
           of.binmode
-          source_stream = newcontents.stream do |source_stream|
+          newcontents.stream do |source_stream|
             FileUtils.copy_stream(source_stream, of)
           end
-          #of.print(newcontents)
         }
         ::File.chmod(changed, file) if changed
       else
         Puppet.err "Could not find file with checksum #{sum}"
         return nil
       end
       return newsum
     else
       return nil
     end
   end
 
   private
   def absolutize_path( path )
     Pathname.new(path).realpath
   end
 
 end
 
diff --git a/lib/puppet/file_serving/mount/pluginfacts.rb b/lib/puppet/file_serving/mount/pluginfacts.rb
index 5ba8f7146..eec00d087 100644
--- a/lib/puppet/file_serving/mount/pluginfacts.rb
+++ b/lib/puppet/file_serving/mount/pluginfacts.rb
@@ -1,35 +1,35 @@
 require 'puppet/file_serving/mount'
 
 # Find files in the modules' pluginfacts directories.
 # This is a very strange mount because it merges
 # many directories into one.
 class Puppet::FileServing::Mount::PluginFacts < Puppet::FileServing::Mount
   # Return an instance of the appropriate class.
   def find(relative_path, request)
-    return nil unless mod = request.environment.modules.find { |mod|  mod.pluginfact(relative_path) }
+    return nil unless mod = request.environment.modules.find { |m|  m.pluginfact(relative_path) }
 
     path = mod.pluginfact(relative_path)
 
     path
   end
 
   def search(relative_path, request)
     # We currently only support one kind of search on plugins - return
     # them all.
     Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
     paths = request.environment.modules.find_all { |mod| mod.pluginfacts? }.collect { |mod| mod.plugin_fact_directory }
     if paths.empty?
       # If the modulepath is valid then we still need to return a valid root
       # directory for the search, but make sure nothing inside it is
       # returned.
       request.options[:recurse] = false
       request.environment.modulepath.empty? ? nil : request.environment.modulepath
     else
       paths
     end
   end
 
   def valid?
     true
   end
 end
diff --git a/lib/puppet/file_serving/mount/plugins.rb b/lib/puppet/file_serving/mount/plugins.rb
index 1e5dcefdd..60eb003c0 100644
--- a/lib/puppet/file_serving/mount/plugins.rb
+++ b/lib/puppet/file_serving/mount/plugins.rb
@@ -1,35 +1,35 @@
 require 'puppet/file_serving/mount'
 
 # Find files in the modules' plugins directories.
 # This is a very strange mount because it merges
 # many directories into one.
 class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
   # Return an instance of the appropriate class.
   def find(relative_path, request)
-    return nil unless mod = request.environment.modules.find { |mod|  mod.plugin(relative_path) }
+    return nil unless mod = request.environment.modules.find { |m|  m.plugin(relative_path) }
 
     path = mod.plugin(relative_path)
 
     path
   end
 
   def search(relative_path, request)
     # We currently only support one kind of search on plugins - return
     # them all.
     Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
     paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
     if paths.empty?
       # If the modulepath is valid then we still need to return a valid root
       # directory for the search, but make sure nothing inside it is
       # returned.
       request.options[:recurse] = false
       request.environment.modulepath.empty? ? nil : request.environment.modulepath
     else
       paths
     end
   end
 
   def valid?
     true
   end
 end
diff --git a/lib/puppet/graph/relationship_graph.rb b/lib/puppet/graph/relationship_graph.rb
index 3860a5e4c..83ee3ab65 100644
--- a/lib/puppet/graph/relationship_graph.rb
+++ b/lib/puppet/graph/relationship_graph.rb
@@ -1,274 +1,274 @@
 # The relationship graph is the final form of a puppet catalog in
 # which all dependency edges are explicitly in the graph. This form of the
 # catalog is used to traverse the graph in the order in which resources are
 # managed.
 #
 # @api private
 class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
   attr_reader :blockers
 
   def initialize(prioritizer)
     super()
 
     @prioritizer = prioritizer
 
     @ready = Puppet::Graph::RbTreeMap.new
     @generated = {}
     @done = {}
     @blockers = {}
     @providerless_types = []
   end
 
   def populate_from(catalog)
     add_all_resources_as_vertices(catalog)
     build_manual_dependencies
     build_autorelation_dependencies(catalog)
 
     write_graph(:relationships) if catalog.host_config?
 
     replace_containers_with_anchors(catalog)
 
     write_graph(:expanded_relationships) if catalog.host_config?
   end
 
   def add_vertex(vertex, priority = nil)
     super(vertex)
 
     if priority
       @prioritizer.record_priority_for(vertex, priority)
     else
       @prioritizer.generate_priority_for(vertex)
     end
   end
 
   def add_relationship(f, t, label=nil)
     super(f, t, label)
     @ready.delete(@prioritizer.priority_of(t))
   end
 
   def remove_vertex!(vertex)
     super
     @prioritizer.forget(vertex)
   end
 
   def resource_priority(resource)
     @prioritizer.priority_of(resource)
   end
 
   # Enqueue the initial set of resources, those with no dependencies.
   def enqueue_roots
     vertices.each do |v|
       @blockers[v] = direct_dependencies_of(v).length
       enqueue(v) if @blockers[v] == 0
     end
   end
 
   # Decrement the blocker count for the resource by 1. If the number of
   # blockers is unknown, count them and THEN decrement by 1.
   def unblock(resource)
     @blockers[resource] ||= direct_dependencies_of(resource).select { |r2| !@done[r2] }.length
     if @blockers[resource] > 0
       @blockers[resource] -= 1
     else
       resource.warning "appears to have a negative number of dependencies"
     end
     @blockers[resource] <= 0
   end
 
   def clear_blockers
     @blockers.clear
   end
 
   def enqueue(*resources)
     resources.each do |resource|
       @ready[@prioritizer.priority_of(resource)] = resource
     end
   end
 
   def finish(resource)
     direct_dependents_of(resource).each do |v|
       enqueue(v) if unblock(v)
     end
     @done[resource] = true
   end
 
   def next_resource
     @ready.delete_min
   end
 
   def traverse(options = {}, &block)
     continue_while = options[:while] || lambda { true }
     pre_process = options[:pre_process] || lambda { |resource| }
     overly_deferred_resource_handler = options[:overly_deferred_resource_handler] || lambda { |resource| }
     canceled_resource_handler = options[:canceled_resource_handler] || lambda { |resource| }
     teardown = options[:teardown] || lambda {}
 
     report_cycles_in_graph
 
     enqueue_roots
 
     deferred_resources = []
 
     while continue_while.call() && (resource = next_resource)
       if resource.suitable?
         made_progress = true
 
         pre_process.call(resource)
 
         yield resource
 
         finish(resource)
       else
         deferred_resources << resource
       end
 
       if @ready.empty? and deferred_resources.any?
         if made_progress
           enqueue(*deferred_resources)
         else
-          deferred_resources.each do |resource|
-            overly_deferred_resource_handler.call(resource)
-            finish(resource)
+          deferred_resources.each do |res|
+            overly_deferred_resource_handler.call(res)
+            finish(res)
           end
         end
 
         made_progress = false
         deferred_resources = []
       end
     end
 
     if !continue_while.call()
       while (resource = next_resource)
         canceled_resource_handler.call(resource)
         finish(resource)
       end
     end
 
     teardown.call()
   end
 
   private
 
   def add_all_resources_as_vertices(catalog)
     catalog.resources.each do |vertex|
       add_vertex(vertex)
     end
   end
 
   def build_manual_dependencies
     vertices.each do |vertex|
       vertex.builddepends.each do |edge|
         add_edge(edge)
       end
     end
   end
 
   def build_autorelation_dependencies(catalog)
     vertices.each do |vertex|
       [:require,:subscribe].each do |rel_type|
         vertex.send("auto#{rel_type}".to_sym, catalog).each do |edge|
           # don't let automatic relationships conflict with manual ones.
           next if edge?(edge.source, edge.target)
 
           if edge?(edge.target, edge.source)
             vertex.debug "Skipping automatic relationship with #{edge.source}"
           else
             vertex.debug "Adding auto#{rel_type} relationship with #{edge.source}"
             if rel_type == :require
               edge.event = :NONE
             else
               edge.callback = :refresh
               edge.event = :ALL_EVENTS
             end
             add_edge(edge)
           end
         end
       end
 
       [:before,:notify].each do |rel_type|
         vertex.send("auto#{rel_type}".to_sym, catalog).each do |edge|
           # don't let automatic relationships conflict with manual ones.
           next if edge?(edge.target, edge.source)
 
           if edge?(edge.source, edge.target)
             vertex.debug "Skipping automatic relationship with #{edge.target}"
           else
             vertex.debug "Adding auto#{rel_type} relationship with #{edge.target}"
             if rel_type == :before
               edge.event = :NONE
             else
               edge.callback = :refresh
               edge.event = :ALL_EVENTS
             end
             add_edge(edge)
           end
         end
       end
     end
   end
 
   # Impose our container information on another graph by using it
   # to replace any container vertices X with a pair of vertices
   # { admissible_X and completed_X } such that
   #
   #    0) completed_X depends on admissible_X
   #    1) contents of X each depend on admissible_X
   #    2) completed_X depends on each on the contents of X
   #    3) everything which depended on X depends on completed_X
   #    4) admissible_X depends on everything X depended on
   #    5) the containers and their edges must be removed
   #
   # Note that this requires attention to the possible case of containers
   # which contain or depend on other containers, but has the advantage
   # that the number of new edges created scales linearly with the number
   # of contained vertices regardless of how containers are related;
   # alternatives such as replacing container-edges with content-edges
   # scale as the product of the number of external dependencies, which is
   # to say geometrically in the case of nested / chained containers.
   #
   Default_label = { :callback => :refresh, :event => :ALL_EVENTS }
   def replace_containers_with_anchors(catalog)
     stage_class      = Puppet::Type.type(:stage)
     whit_class       = Puppet::Type.type(:whit)
     component_class  = Puppet::Type.type(:component)
     containers = catalog.resources.find_all { |v| (v.is_a?(component_class) or v.is_a?(stage_class)) and vertex?(v) }
     #
     # These two hashes comprise the aforementioned attention to the possible
     #   case of containers that contain / depend on other containers; they map
     #   containers to their sentinels but pass other vertices through.  Thus we
     #   can "do the right thing" for references to other vertices that may or
     #   may not be containers.
     #
     admissible = Hash.new { |h,k| k }
     completed  = Hash.new { |h,k| k }
     containers.each { |x|
       admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => catalog)
       completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => catalog)
       priority = @prioritizer.priority_of(x)
       add_vertex(admissible[x], priority)
       add_vertex(completed[x], priority)
     }
     #
     # Implement the six requirements listed above
     #
     containers.each { |x|
       contents = catalog.adjacent(x, :direction => :out)
       add_edge(admissible[x],completed[x]) if contents.empty? # (0)
       contents.each { |v|
         add_edge(admissible[x],admissible[v],Default_label) # (1)
         add_edge(completed[v], completed[x], Default_label) # (2)
       }
       # (3) & (5)
       adjacent(x,:direction => :in,:type => :edges).each { |e|
         add_edge(completed[e.source],admissible[x],e.label)
         remove_edge! e
       }
       # (4) & (5)
       adjacent(x,:direction => :out,:type => :edges).each { |e|
         add_edge(completed[x],admissible[e.target],e.label)
         remove_edge! e
       }
     }
     containers.each { |x| remove_vertex! x } # (5)
   end
 end
diff --git a/lib/puppet/indirector/catalog/static_compiler.rb b/lib/puppet/indirector/catalog/static_compiler.rb
index 8841bfd22..ff95d30dd 100644
--- a/lib/puppet/indirector/catalog/static_compiler.rb
+++ b/lib/puppet/indirector/catalog/static_compiler.rb
@@ -1,213 +1,213 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/compiler'
 
 class Puppet::Resource::Catalog::StaticCompiler < Puppet::Resource::Catalog::Compiler
 
   desc %q{Compiles catalogs on demand using the optional static compiler. This
     functions similarly to the normal compiler, but it replaces puppet:/// file
     URLs with explicit metadata and file content hashes, expecting puppet agent
     to fetch the exact specified content from the filebucket. This guarantees
     that a given catalog will always result in the same file states. It also
     decreases catalog application time and fileserver load, at the cost of
     increased compilation time.
 
     This terminus works today, but cannot be used without additional
     configuration. Specifically:
 
     * You must create a special filebucket resource --- with the title `puppet`
       and the `path` attribute set to `false` --- in site.pp or somewhere else
       where it will be added to every node's catalog. Using `puppet` as the title
       is mandatory; the static compiler treats this title as magical.
 
           filebucket { puppet:
             path => false,
           }
 
     * You must set `catalog_terminus = static_compiler` in the puppet
       master's puppet.conf.
     * The puppet master's auth.conf must allow authenticated nodes to access the
       `file_bucket_file` endpoint. This is enabled by default (see the
       `path /file` rule), but if you have made your auth.conf more restrictive,
       you may need to re-enable it.)
     * If you are using multiple puppet masters, you must configure load balancer
       affinity for agent nodes. This is because puppet masters other than the one
       that compiled a given catalog may not have stored the required file contents
       in their filebuckets.}
 
   def find(request)
     return nil unless catalog = super
 
     raise "Did not get catalog back" unless catalog.is_a?(model)
 
     catalog.resources.find_all { |res| res.type == "File" }.each do |resource|
       next unless source = resource[:source]
       next unless source =~ /^puppet:/
 
       file = resource.to_ral
 
       if file.recurse?
         add_children(request.key, catalog, resource, file)
       else
         find_and_replace_metadata(request.key, resource, file)
       end
     end
 
     catalog
   end
 
   # Take a resource with a fileserver based file source remove the source
   # parameter, and insert the file metadata into the resource.
   #
   # This method acts to do the fileserver metadata retrieval in advance, while
   # the file source is local and doesn't require an HTTP request. It retrieves
   # the file metadata for a given file resource, removes the source parameter
   # from the resource, inserts the metadata into the file resource, and uploads
   # the file contents of the source to the file bucket.
   #
   # @param host [String] The host name of the node requesting this catalog
   # @param resource [Puppet::Resource] The resource to replace the metadata in
   # @param file [Puppet::Type::File] The file RAL associated with the resource
   def find_and_replace_metadata(host, resource, file)
     # We remove URL info from it, so it forces a local copy
     # rather than routing through the network.
     # Weird, but true.
     newsource = file[:source][0].sub("puppet:///", "")
     file[:source][0] = newsource
 
     raise "Could not get metadata for #{resource[:source]}" unless metadata = file.parameter(:source).metadata
 
     replace_metadata(host, resource, metadata)
   end
 
   # Rewrite a given file resource with the metadata from a fileserver based file
   #
   # This performs the actual metadata rewrite for the given file resource and
   # uploads the content of the source file to the filebucket.
   #
   # @param host [String] The host name of the node requesting this catalog
   # @param resource [Puppet::Resource] The resource to add the metadata to
   # @param metadata [Puppet::FileServing::Metadata] The metadata of the given fileserver based file
   def replace_metadata(host, resource, metadata)
     [:mode, :owner, :group].each do |param|
       resource[param] ||= metadata.send(param)
     end
 
     resource[:ensure] = metadata.ftype
     if metadata.ftype == "file"
       unless resource[:content]
         resource[:content] = metadata.checksum
         resource[:checksum] = metadata.checksum_type
       end
     end
 
     store_content(resource) if resource[:ensure] == "file"
     old_source = resource.delete(:source)
     Puppet.info "Metadata for #{resource} in catalog for '#{host}' added from '#{old_source}'"
   end
 
   # Generate children resources for a recursive file and add them to the catalog.
   #
   # @param host [String] The host name of the node requesting this catalog
   # @param catalog [Puppet::Resource::Catalog]
   # @param resource [Puppet::Resource]
   # @param file [Puppet::Type::File] The file RAL associated with the resource
   def add_children(host, catalog, resource, file)
     file = resource.to_ral
 
     children = get_child_resources(host, catalog, resource, file)
 
     remove_existing_resources(children, catalog)
 
     children.each do |name, res|
       catalog.add_resource res
       catalog.add_edge(resource, res)
     end
   end
 
   # Given a recursive file resource, recursively generate its children resources
   #
   # @param host [String] The host name of the node requesting this catalog
   # @param catalog [Puppet::Resource::Catalog]
   # @param resource [Puppet::Resource]
   # @param file [Puppet::Type::File] The file RAL associated with the resource
   #
   # @return [Array<Puppet::Resource>] The recursively generated File resources for the given resource
   def get_child_resources(host, catalog, resource, file)
     sourceselect = file[:sourceselect]
     children = {}
 
     source = resource[:source]
 
     # This is largely a copy of recurse_remote in File
-    total = file[:source].collect do |source|
-      next unless result = file.perform_recursion(source)
+    total = file[:source].collect do |src|
+      next unless result = file.perform_recursion(src)
       return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
-      result.each { |data| data.source = "#{source}/#{data.relative_path}" }
+      result.each { |data| data.source = "#{src}/#{data.relative_path}" }
       break result if result and ! result.empty? and sourceselect == :first
       result
     end.flatten.compact
 
     # This only happens if we have sourceselect == :all
     unless sourceselect == :first
       found = []
       total.reject! do |data|
         result = found.include?(data.relative_path)
         found << data.relative_path unless found.include?(data.relative_path)
         result
       end
     end
 
     total.each do |meta|
       # This is the top-level parent directory
       if meta.relative_path == "."
         replace_metadata(host, resource, meta)
         next
       end
       children[meta.relative_path] ||= Puppet::Resource.new(:file, File.join(file[:path], meta.relative_path))
 
       # I think this is safe since it's a URL, not an actual file
       children[meta.relative_path][:source] = source + "/" + meta.relative_path
       resource.each do |param, value|
         # These should never be passed to our children.
         unless [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].include? param
           children[meta.relative_path][param] = value
         end
       end
       replace_metadata(host, children[meta.relative_path], meta)
     end
 
     children
   end
 
   # Remove any file resources in the catalog that will be duplicated by the
   # given file resources.
   #
   # @param children [Array<Puppet::Resource>]
   # @param catalog [Puppet::Resource::Catalog]
   def remove_existing_resources(children, catalog)
     existing_names = catalog.resources.collect { |r| r.to_s }
     both = (existing_names & children.keys).inject({}) { |hash, name| hash[name] = true; hash }
     both.each { |name| children.delete(name) }
   end
 
   # Retrieve the source of a file resource using a fileserver based source and
   # upload it to the filebucket.
   #
   # @param resource [Puppet::Resource]
   def store_content(resource)
     @summer ||= Puppet::Util::Checksums
 
     type = @summer.sumtype(resource[:content])
     sum = @summer.sumdata(resource[:content])
 
     if Puppet::FileBucket::File.indirection.find("#{type}/#{sum}")
       Puppet.info "Content for '#{resource[:source]}' already exists"
     else
       Puppet.info "Storing content for source '#{resource[:source]}'"
       content = Puppet::FileServing::Content.indirection.find(resource[:source])
       file = Puppet::FileBucket::File.new(content.content)
       Puppet::FileBucket::File.indirection.save(file)
     end
   end
 end
diff --git a/lib/puppet/indirector/rest.rb b/lib/puppet/indirector/rest.rb
index 464f68ab1..979577957 100644
--- a/lib/puppet/indirector/rest.rb
+++ b/lib/puppet/indirector/rest.rb
@@ -1,248 +1,248 @@
 require 'net/http'
 require 'uri'
 
 require 'puppet/network/http'
 require 'puppet/network/http_pool'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   include Puppet::Network::HTTP::Compression.module
 
   class << self
     attr_reader :server_setting, :port_setting
   end
 
   # Specify the setting that we should use to get the server name.
   def self.use_server_setting(setting)
     @server_setting = setting
   end
 
   # Specify the setting that we should use to get the port.
   def self.use_port_setting(setting)
     @port_setting = setting
   end
 
   # Specify the service to use when doing SRV record lookup
   def self.use_srv_service(service)
     @srv_service = service
   end
 
   def self.srv_service
     @srv_service || :puppet
   end
 
   def self.server
     Puppet.settings[server_setting || :server]
   end
 
   def self.port
     Puppet.settings[port_setting || :masterport].to_i
   end
 
   # Provide appropriate headers.
   def headers
     add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
   end
 
   def add_profiling_header(headers)
     if (Puppet[:profile])
       headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
     end
     headers
   end
 
   def network(request)
     Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
                                             request.port || self.class.port)
   end
 
   def http_get(request, path, headers = nil, *args)
     http_request(:get, request, path, add_profiling_header(headers), *args)
   end
 
   def http_post(request, path, data, headers = nil, *args)
     http_request(:post, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_head(request, path, headers = nil, *args)
     http_request(:head, request, path, add_profiling_header(headers), *args)
   end
 
   def http_delete(request, path, headers = nil, *args)
     http_request(:delete, request, path, add_profiling_header(headers), *args)
   end
 
   def http_put(request, path, data, headers = nil, *args)
     http_request(:put, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_request(method, request, *args)
     conn = network(request)
     conn.send(method, *args)
   end
 
   def find(request)
     uri, body = Puppet::Network::HTTP::API::V1.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
-    response = do_request(request) do |request|
+    response = do_request(request) do |req|
       # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
       # http://redmine.ruby-lang.org/issues/show/3991
       if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-        http_post(request, uri, body, headers)
+        http_post(req, uri, body, headers)
       else
-        http_get(request, uri_with_query_string, headers)
+        http_get(req, uri_with_query_string, headers)
       end
     end
 
     if is_http_200?(response)
       content_type, body = parse_response(response)
       result = deserialize_find(content_type, body)
       result.name = request.key if result.respond_to?(:name=)
       result
 
     elsif is_http_404?(response)
       return nil unless request.options[:fail_on_404]
 
       # 404 can get special treatment as the indirector API can not produce a meaningful
       # reason to why something is not found - it may not be the thing the user is
       # expecting to find that is missing, but something else (like the environment).
       # While this way of handling the issue is not perfect, there is at least an error
       # that makes a user aware of the reason for the failure.
       #
       content_type, body = parse_response(response)
       msg = "Find #{elide(uri_with_query_string, 100)} resulted in 404 with the message: #{body}"
       raise Puppet::Error, msg
     else
       nil
     end
   end
 
   def head(request)
-    response = do_request(request) do |request|
-      http_head(request, Puppet::Network::HTTP::API::V1.request_to_uri(request), headers)
+    response = do_request(request) do |req|
+      http_head(req, Puppet::Network::HTTP::API::V1.request_to_uri(req), headers)
     end
 
     if is_http_200?(response)
       true
     else
       false
     end
   end
 
   def search(request)
-    response = do_request(request) do |request|
-      http_get(request, Puppet::Network::HTTP::API::V1.request_to_uri(request), headers)
+    response = do_request(request) do |req|
+      http_get(req, Puppet::Network::HTTP::API::V1.request_to_uri(req), headers)
     end
 
     if is_http_200?(response)
       content_type, body = parse_response(response)
       deserialize_search(content_type, body) || []
     else
       []
     end
   end
 
   def destroy(request)
     raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
 
-    response = do_request(request) do |request|
-      http_delete(request, Puppet::Network::HTTP::API::V1.request_to_uri(request), headers)
+    response = do_request(request) do |req|
+      http_delete(req, Puppet::Network::HTTP::API::V1.request_to_uri(req), headers)
     end
 
     if is_http_200?(response)
       content_type, body = parse_response(response)
       deserialize_destroy(content_type, body)
     else
       nil
     end
   end
 
   def save(request)
     raise ArgumentError, "PUT does not accept options" unless request.options.empty?
 
-    response = do_request(request) do |request|
-      http_put(request, Puppet::Network::HTTP::API::V1.request_to_uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    response = do_request(request) do |req|
+      http_put(req, Puppet::Network::HTTP::API::V1.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
     end
 
     if is_http_200?(response)
       content_type, body = parse_response(response)
       deserialize_save(content_type, body)
     else
       nil
     end
   end
 
   # Encapsulate call to request.do_request with the arguments from this class
   # Then yield to the code block that was called in
   # We certainly could have retained the full request.do_request(...) { |r| ... }
   # but this makes the code much cleaner and we only then actually make the call
   # to request.do_request from here, thus if we change what we pass or how we
   # get it, we only need to change it here.
   def do_request(request)
-    request.do_request(self.class.srv_service, self.class.server, self.class.port) { |request| yield(request) }
+    request.do_request(self.class.srv_service, self.class.server, self.class.port) { |req| yield(req) }
   end
 
   def validate_key(request)
     # Validation happens on the remote end
   end
 
   private
 
   def is_http_200?(response)
     case response.code
     when "404"
       false
     when /^2/
       true
     else
       # Raise the http error if we didn't get a 'success' of some kind.
       raise convert_to_http_error(response)
     end
   end
 
   def is_http_404?(response)
     response.code == "404"
   end
 
   def convert_to_http_error(response)
     message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
     Net::HTTPError.new(message, response)
   end
 
   # Returns the content_type, stripping any appended charset, and the
   # body, decompressed if necessary (content-encoding is checked inside
   # uncompress_body)
   def parse_response(response)
     if response['content-type']
       [ response['content-type'].gsub(/\s*;.*$/,''),
         body = uncompress_body(response) ]
     else
       raise "No content type in http response; cannot parse"
     end
   end
 
   def deserialize_find(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_search(content_type, body)
     model.convert_from_multiple(content_type, body)
   end
 
   def deserialize_destroy(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_save(content_type, body)
     nil
   end
 
   def elide(string, length)
     if Puppet::Util::Log.level == :debug || string.length <= length
       string
     else
       string[0, length - 3] + "..."
     end
   end
 end
diff --git a/lib/puppet/interface/face_collection.rb b/lib/puppet/interface/face_collection.rb
index 0c95f50b3..ae11e7e46 100644
--- a/lib/puppet/interface/face_collection.rb
+++ b/lib/puppet/interface/face_collection.rb
@@ -1,125 +1,125 @@
 module Puppet::Interface::FaceCollection
   @faces = Hash.new { |hash, key| hash[key] = {} }
 
   @loader = Puppet::Util::Autoload.new(:application, 'puppet/face')
 
   def self.faces
     unless @loaded
       @loaded = true
       names = @loader.files_to_load.map {|fn| ::File.basename(fn, '.rb')}.uniq
       names.each {|name| self[name, :current]}
     end
     @faces.keys.select {|name| @faces[name].length > 0 }
   end
 
   def self.[](name, version)
     name = underscorize(name)
     get_face(name, version) or load_face(name, version)
   end
 
   def self.get_action_for_face(name, action_name, version)
     name = underscorize(name)
 
     # If the version they request specifically doesn't exist, don't search
     # elsewhere.  Usually this will start from :current and all...
     return nil unless face = self[name, version]
     unless action = face.get_action(action_name)
       # ...we need to search for it bound to an o{lder,ther} version.  Since
       # we load all actions when the face is first references, this will be in
       # memory in the known set of versions of the face.
-      (@faces[name].keys - [ :current ]).sort.reverse.each do |version|
-        break if action = @faces[name][version].get_action(action_name)
+      (@faces[name].keys - [ :current ]).sort.reverse.each do |vers|
+        break if action = @faces[name][vers].get_action(action_name)
       end
     end
 
     return action
   end
 
   # get face from memory, without loading.
   def self.get_face(name, pattern)
     return nil unless @faces.has_key? name
     return @faces[name][:current] if pattern == :current
 
     versions = @faces[name].keys - [ :current ]
     found    = SemVer.find_matching(pattern, versions)
     return @faces[name][found]
   end
 
   # try to load the face, and return it.
   def self.load_face(name, version)
     # We always load the current version file; the common case is that we have
     # the expected version and any compatibility versions in the same file,
     # the default.  Which means that this is almost always the case.
     #
     # We use require to avoid executing the code multiple times, like any
     # other Ruby library that we might want to use.  --daniel 2011-04-06
     if safely_require name then
       # If we wanted :current, we need to index to find that; direct version
       # requests just work as they go. --daniel 2011-04-06
       if version == :current then
         # We need to find current out of this.  This is the largest version
         # number that doesn't have a dedicated on-disk file present; those
         # represent "experimental" versions of faces, which we don't fully
         # support yet.
         #
         # We walk the versions from highest to lowest and take the first version
         # that is not defined in an explicitly versioned file on disk as the
         # current version.
         #
         # This constrains us to only ship experimental versions with *one*
         # version in the file, not multiple, but given you can't reliably load
         # them except by side-effect when you ignore that rule this seems safe
         # enough...
         #
         # Given those constraints, and that we are not going to ship a versioned
         # interface that is not :current in this release, we are going to leave
         # these thoughts in place, and just punt on the actual versioning.
         #
         # When we upgrade the core to support multiple versions we can solve the
         # problems then; as lazy as possible.
         #
         # We do support multiple versions in the same file, though, so we sort
         # versions here and return the last item in that set.
         #
         # --daniel 2011-04-06
         latest_ver = @faces[name].keys.sort.last
         @faces[name][:current] = @faces[name][latest_ver]
       end
     end
 
     unless version == :current or get_face(name, version)
       # Try an obsolete version of the face, if needed, to see if that helps?
       safely_require name, version
     end
 
     return get_face(name, version)
   end
 
   def self.safely_require(name, version = nil)
     path = @loader.expand(version ? ::File.join(version.to_s, name.to_s) : name)
     require path
     true
 
   rescue LoadError => e
     raise unless e.message =~ %r{-- #{path}$}
     # ...guess we didn't find the file; return a much better problem.
     nil
   rescue SyntaxError => e
     raise unless e.message =~ %r{#{path}\.rb:\d+: }
     Puppet.err "Failed to load face #{name}:\n#{e}"
     # ...but we just carry on after complaining.
     nil
   end
 
   def self.register(face)
     @faces[underscorize(face.name)][face.version] = face
   end
 
   def self.underscorize(name)
     unless name.to_s =~ /^[-_a-z][-_a-z0-9]*$/i then
       raise ArgumentError, "#{name.inspect} (#{name.class}) is not a valid face name"
     end
 
     name.to_s.downcase.split(/[-_]/).join('_').to_sym
   end
 end
diff --git a/lib/puppet/module_tool/applications/installer.rb b/lib/puppet/module_tool/applications/installer.rb
index 92aa6c02d..7ce533073 100644
--- a/lib/puppet/module_tool/applications/installer.rb
+++ b/lib/puppet/module_tool/applications/installer.rb
@@ -1,353 +1,353 @@
 require 'open-uri'
 require 'pathname'
 require 'fileutils'
 require 'tmpdir'
 
 require 'puppet/forge'
 require 'puppet/module_tool'
 require 'puppet/module_tool/shared_behaviors'
 require 'puppet/module_tool/install_directory'
 require 'puppet/module_tool/local_tarball'
 require 'puppet/module_tool/installed_modules'
 
 module Puppet::ModuleTool
   module Applications
     class Installer < Application
 
       include Puppet::ModuleTool::Errors
       include Puppet::Forge::Errors
 
       def initialize(name, install_dir, options = {})
         super(options)
 
         @action              = :install
         @environment         = options[:environment_instance]
         @ignore_dependencies = forced? || options[:ignore_dependencies]
         @name                = name
         @install_dir         = install_dir
 
         Puppet::Forge::Cache.clean
 
         @local_tarball = Puppet::FileSystem.exist?(name)
 
         if @local_tarball
           release = local_tarball_source.release
           @name = release.name
           options[:version] = release.version.to_s
           Semantic::Dependency.add_source(local_tarball_source)
 
           # If we're operating on a local tarball and ignoring dependencies, we
           # don't need to search any additional sources.  This will cut down on
           # unnecessary network traffic.
           unless @ignore_dependencies
             Semantic::Dependency.add_source(installed_modules_source)
             Semantic::Dependency.add_source(module_repository)
           end
 
         else
           Semantic::Dependency.add_source(installed_modules_source) unless forced?
           Semantic::Dependency.add_source(module_repository)
         end
       end
 
       def run
         name = @name.tr('/', '-')
         version = options[:version] || '>= 0.0.0'
 
         results = { :action => :install, :module_name => name, :module_version => version }
 
         begin
-          if mod = installed_modules[name]
+          if installed_module = installed_modules[name]
             unless forced?
-              if Semantic::VersionRange.parse(version).include? mod.version
+              if Semantic::VersionRange.parse(version).include? installed_module.version
                 results[:result] = :noop
-                results[:version] = mod.version
+                results[:version] = installed_module.version
                 return results
               else
                 changes = Checksummer.run(installed_modules[name].mod.path) rescue []
                 raise AlreadyInstalledError,
                   :module_name       => name,
                   :installed_version => installed_modules[name].version,
                   :requested_version => options[:version] || :latest,
                   :local_changes     => changes
               end
             end
           end
 
           @install_dir.prepare(name, options[:version] || 'latest')
           results[:install_dir] = @install_dir.target
 
           unless @local_tarball && @ignore_dependencies
             Puppet.notice "Downloading from #{module_repository.host} ..."
           end
 
           if @ignore_dependencies
             graph = build_single_module_graph(name, version)
           else
             graph = build_dependency_graph(name, version)
           end
 
           unless forced?
             add_module_name_constraints_to_graph(graph)
           end
 
           installed_modules.each do |mod, release|
             mod = mod.tr('/', '-')
             next if mod == name
 
             version = release.version
 
             unless forced?
               # Since upgrading already installed modules can be troublesome,
               # we'll place constraints on the graph for each installed module,
               # locking it to upgrades within the same major version.
               ">=#{version} #{version.major}.x".tap do |range|
                 graph.add_constraint('installed', mod, range) do |node|
                   Semantic::VersionRange.parse(range).include? node.version
                 end
               end
 
               release.mod.dependencies.each do |dep|
                 dep_name = dep['name'].tr('/', '-')
 
                 dep['version_requirement'].tap do |range|
                   graph.add_constraint("#{mod} constraint", dep_name, range) do |node|
                     Semantic::VersionRange.parse(range).include? node.version
                   end
                 end
               end
             end
           end
 
           # Ensure that there is at least one candidate release available
           # for the target package.
           if graph.dependencies[name].empty?
             raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host, :requested_version => options[:version] || :latest)
           end
 
           begin
             Puppet.info "Resolving dependencies ..."
             releases = Semantic::Dependency.resolve(graph)
           rescue Semantic::Dependency::UnsatisfiableGraph
             raise NoVersionsSatisfyError, results.merge(:requested_name => name)
           end
 
           unless forced?
             # Check for module name conflicts.
             releases.each do |rel|
-              if mod = installed_modules_source.by_name[rel.name.split('-').last]
-                next if mod.has_metadata? && mod.forge_name.tr('/', '-') == rel.name
+              if installed_module = installed_modules_source.by_name[rel.name.split('-').last]
+                next if installed_module.has_metadata? && installed_module.forge_name.tr('/', '-') == rel.name
 
                 if rel.name != name
                   dependency = {
                     :name => rel.name,
                     :version => rel.version
                   }
                 end
 
                 raise InstallConflictError,
                   :requested_module  => name,
                   :requested_version => options[:version] || 'latest',
                   :dependency        => dependency,
-                  :directory         => mod.path,
-                  :metadata          => mod.metadata
+                  :directory         => installed_module.path,
+                  :metadata          => installed_module.metadata
               end
             end
           end
 
           Puppet.info "Preparing to install ..."
           releases.each { |release| release.prepare }
 
           Puppet.notice 'Installing -- do not interrupt ...'
           releases.each do |release|
             installed = installed_modules[release.name]
             if forced? || installed.nil?
               release.install(Pathname.new(results[:install_dir]))
             else
               release.install(Pathname.new(installed.mod.modulepath))
             end
           end
 
           results[:result] = :success
           results[:installed_modules] = releases
           results[:graph] = [ build_install_graph(releases.first, releases) ]
 
         rescue ModuleToolError, ForgeError => err
           results[:error] = {
             :oneline   => err.message,
             :multiline => err.multiline,
           }
         ensure
           results[:result] ||= :failure
         end
 
         results
       end
 
       private
 
       def module_repository
         @repo ||= Puppet::Forge.new
       end
 
       def local_tarball_source
         @tarball_source ||= begin
           Puppet::ModuleTool::LocalTarball.new(@name)
         rescue Puppet::Module::Error => e
           raise InvalidModuleError.new(@name, :action => @action, :error  => e)
         end
       end
 
       def installed_modules_source
         @installed ||= Puppet::ModuleTool::InstalledModules.new(@environment)
       end
 
       def installed_modules
         installed_modules_source.modules
       end
 
       def build_single_module_graph(name, version)
         range = Semantic::VersionRange.parse(version)
         graph = Semantic::Dependency::Graph.new(name => range)
         releases = Semantic::Dependency.fetch_releases(name)
         releases.each { |release| release.dependencies.clear }
         graph << releases
       end
 
       def build_dependency_graph(name, version)
         Semantic::Dependency.query(name => version)
       end
 
       def build_install_graph(release, installed, graphed = [])
         graphed << release
         dependencies = release.dependencies.values.map do |deps|
           dep = (deps & installed).first
           unless dep.nil? || graphed.include?(dep)
             build_install_graph(dep, installed, graphed)
           end
         end
 
         previous = installed_modules[release.name]
         previous = previous.version if previous
         return {
           :release          => release,
           :name             => release.name,
           :path             => release.install_dir.to_s,
           :dependencies     => dependencies.compact,
           :version          => release.version,
           :previous_version => previous,
           :action           => (previous.nil? || previous == release.version || forced? ? :install : :upgrade),
         }
       end
 
       include Puppet::ModuleTool::Shared
 
       # Return a Pathname object representing the path to the module
       # release package in the `Puppet.settings[:module_working_dir]`.
       def get_release_packages
         get_local_constraints
 
         if !forced? && @installed.include?(@module_name)
           raise AlreadyInstalledError,
             :module_name       => @module_name,
             :installed_version => @installed[@module_name].first.version,
             :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
             :local_changes     => Puppet::ModuleTool::Applications::Checksummer.run(@installed[@module_name].first.path)
         end
 
         if @ignore_dependencies && @source == :filesystem
           @urls   = {}
           @remote = { "#{@module_name}@#{@version}" => { } }
           @versions = {
             @module_name => [
               { :vstring => @version, :semver => SemVer.new(@version) }
             ]
           }
         else
           get_remote_constraints(@forge)
         end
 
         @graph = resolve_constraints({ @module_name => @version })
         @graph.first[:tarball] = @filename if @source == :filesystem
         resolve_install_conflicts(@graph) unless forced?
 
         # This clean call means we never "cache" the module we're installing, but this
         # is desired since module authors can easily rerelease modules different content but the same
         # version number, meaning someone with the old content cached will be very confused as to why
         # they can't get new content.
         # Long term we should just get rid of this caching behavior and cleanup downloaded modules after they install
         # but for now this is a quick fix to disable caching
         Puppet::Forge::Cache.clean
         download_tarballs(@graph, @graph.last[:path], @forge)
       end
 
       #
       # Resolve installation conflicts by checking if the requested module
       # or one of its dependencies conflicts with an installed module.
       #
       # Conflicts occur under the following conditions:
       #
       # When installing 'puppetlabs-foo' and an existing directory in the
       # target install path contains a 'foo' directory and we cannot determine
       # the "full name" of the installed module.
       #
       # When installing 'puppetlabs-foo' and 'pete-foo' is already installed.
       # This is considered a conflict because 'puppetlabs-foo' and 'pete-foo'
       # install into the same directory 'foo'.
       #
       def resolve_install_conflicts(graph, is_dependency = false)
         Puppet.debug("Resolving conflicts for #{graph.map {|n| n[:module]}.join(',')}")
 
         graph.each do |release|
           @environment.modules_by_path[options[:target_dir]].each do |mod|
             if mod.has_metadata?
               metadata = {
                 :name    => mod.forge_name.gsub('/', '-'),
                 :version => mod.version
               }
               next if release[:module] == metadata[:name]
             else
               metadata = nil
             end
 
             if release[:module] =~ /-#{mod.name}$/
               dependency_info = {
                 :name    => release[:module],
                 :version => release[:version][:vstring]
               }
               dependency = is_dependency ? dependency_info : nil
               all_versions = @versions["#{@module_name}"].sort_by { |h| h[:semver] }
               versions = all_versions.select { |x| x[:semver].special == '' }
               versions = all_versions if versions.empty?
               latest_version = versions.last[:vstring]
 
               raise InstallConflictError,
                 :requested_module  => @module_name,
                 :requested_version => @version || "latest: v#{latest_version}",
                 :dependency        => dependency,
                 :directory         => mod.path,
                 :metadata          => metadata
             end
           end
 
           deps = release[:dependencies]
           if deps && !deps.empty?
             resolve_install_conflicts(deps, true)
           end
         end
       end
 
       #
       # Check if a file is a vaild module package.
       # ---
       # FIXME: Checking for a valid module package should be more robust and
       # use the actual metadata contained in the package. 03132012 - Hightower
       # +++
       #
       def is_module_package?(name)
         filename = File.expand_path(name)
         filename =~ /.tar.gz$/
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool/applications/upgrader.rb b/lib/puppet/module_tool/applications/upgrader.rb
index d901f86a8..d1c4a9532 100644
--- a/lib/puppet/module_tool/applications/upgrader.rb
+++ b/lib/puppet/module_tool/applications/upgrader.rb
@@ -1,279 +1,279 @@
 require 'pathname'
 
 require 'puppet/forge'
 require 'puppet/module_tool'
 require 'puppet/module_tool/shared_behaviors'
 require 'puppet/module_tool/install_directory'
 require 'puppet/module_tool/installed_modules'
 
 module Puppet::ModuleTool
   module Applications
     class Upgrader < Application
 
       include Puppet::ModuleTool::Errors
 
       def initialize(name, options)
         super(options)
 
         @action              = :upgrade
         @environment         = options[:environment_instance]
         @name                = name
         @ignore_changes      = forced? || options[:ignore_changes]
         @ignore_dependencies = forced? || options[:ignore_dependencies]
 
         Semantic::Dependency.add_source(installed_modules_source)
         Semantic::Dependency.add_source(module_repository)
       end
 
       def run
         name = @name.tr('/', '-')
         version = options[:version] || '>= 0.0.0'
 
         results = {
           :action => :upgrade,
           :requested_version => options[:version] || :latest,
         }
 
         begin
           all_modules = @environment.modules_by_path.values.flatten
           matching_modules = all_modules.select do |x|
             x.forge_name && x.forge_name.tr('/', '-') == name
           end
 
           if matching_modules.empty?
             raise NotInstalledError, results.merge(:module_name => name)
           elsif matching_modules.length > 1
             raise MultipleInstalledError, results.merge(:module_name => name, :installed_modules => matching_modules)
           end
 
           installed_release = installed_modules[name]
 
           # `priority` is an attribute of a `Semantic::Dependency::Source`,
           # which is delegated through `ModuleRelease` instances for the sake of
           # comparison (sorting). By default, the `InstalledModules` source has
           # a priority of 10 (making it the most preferable source, so that
           # already installed versions of modules are selected in preference to
           # modules from e.g. the Forge). Since we are specifically looking to
           # upgrade this module, we don't want the installed version of this
           # module to be chosen in preference to those with higher versions.
           #
           # This implementation is suboptimal, and since we can expect this sort
           # of behavior to be reasonably common in Semantic, we should probably
           # see about implementing a `ModuleRelease#override_priority` method
           # (or something similar).
           def installed_release.priority
             0
           end
 
           mod = installed_release.mod
           results[:installed_version] = Semantic::Version.parse(mod.version)
           dir = Pathname.new(mod.modulepath)
 
           vstring = mod.version ? "v#{mod.version}" : '???'
           Puppet.notice "Found '#{name}' (#{colorize(:cyan, vstring)}) in #{dir} ..."
           unless @ignore_changes
             changes = Checksummer.run(mod.path) rescue []
             if mod.has_metadata? && !changes.empty?
               raise LocalChangesError,
                 :action            => :upgrade,
                 :module_name       => name,
                 :requested_version => results[:requested_version],
                 :installed_version => mod.version
             end
           end
 
           Puppet::Forge::Cache.clean
 
           # Ensure that there is at least one candidate release available
           # for the target package.
           available_versions = module_repository.fetch(name)
           if available_versions.empty?
             raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host)
           elsif results[:requested_version] != :latest
             requested = Semantic::VersionRange.parse(results[:requested_version])
             unless available_versions.any? {|m| requested.include? m.version}
               raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host)
             end
           end
 
           Puppet.notice "Downloading from #{module_repository.host} ..."
           if @ignore_dependencies
             graph = build_single_module_graph(name, version)
           else
             graph = build_dependency_graph(name, version)
           end
 
           unless forced?
             add_module_name_constraints_to_graph(graph)
           end
 
-          installed_modules.each do |mod, release|
-            mod = mod.tr('/', '-')
-            next if mod == name
+          installed_modules.each do |installed_module, release|
+            installed_module = installed_module.tr('/', '-')
+            next if installed_module == name
 
             version = release.version
 
             unless forced?
               # Since upgrading already installed modules can be troublesome,
               # we'll place constraints on the graph for each installed
               # module, locking it to upgrades within the same major version.
               ">=#{version} #{version.major}.x".tap do |range|
-                graph.add_constraint('installed', mod, range) do |node|
+                graph.add_constraint('installed', installed_module, range) do |node|
                   Semantic::VersionRange.parse(range).include? node.version
                 end
               end
 
               release.mod.dependencies.each do |dep|
                 dep_name = dep['name'].tr('/', '-')
 
                 dep['version_requirement'].tap do |range|
-                  graph.add_constraint("#{mod} constraint", dep_name, range) do |node|
+                  graph.add_constraint("#{installed_module} constraint", dep_name, range) do |node|
                     Semantic::VersionRange.parse(range).include? node.version
                   end
                 end
               end
             end
           end
 
           begin
             Puppet.info "Resolving dependencies ..."
             releases = Semantic::Dependency.resolve(graph)
           rescue Semantic::Dependency::UnsatisfiableGraph
             raise NoVersionsSatisfyError, results.merge(:requested_name => name)
           end
 
           releases.each do |rel|
             if mod = installed_modules_source.by_name[rel.name.split('-').last]
               next if mod.has_metadata? && mod.forge_name.tr('/', '-') == rel.name
 
               if rel.name != name
                 dependency = {
                   :name => rel.name,
                   :version => rel.version
                 }
               end
 
               raise InstallConflictError,
                 :requested_module  => name,
                 :requested_version => options[:version] || 'latest',
                 :dependency        => dependency,
                 :directory         => mod.path,
                 :metadata          => mod.metadata
             end
           end
 
           child = releases.find { |x| x.name == name }
 
           unless forced?
             if child.version == results[:installed_version]
               versions = graph.dependencies[name].map { |r| r.version }
               newer_versions = versions.select { |v| v > results[:installed_version] }
 
               raise VersionAlreadyInstalledError,
                 :module_name       => name,
                 :requested_version => results[:requested_version],
                 :installed_version => results[:installed_version],
                 :newer_versions    => newer_versions,
                 :possible_culprits => installed_modules_source.fetched.reject { |x| x == name }
             elsif child.version < results[:installed_version]
               raise DowngradingUnsupportedError,
                 :module_name       => name,
                 :requested_version => results[:requested_version],
                 :installed_version => results[:installed_version]
             end
           end
 
           Puppet.info "Preparing to upgrade ..."
           releases.each { |release| release.prepare }
 
           Puppet.notice 'Upgrading -- do not interrupt ...'
           releases.each do |release|
             if installed = installed_modules[release.name]
               release.install(Pathname.new(installed.mod.modulepath))
             else
               release.install(dir)
             end
           end
 
           results[:result] = :success
           results[:base_dir] = releases.first.install_dir
           results[:affected_modules] = releases
           results[:graph] = [ build_install_graph(releases.first, releases) ]
 
         rescue VersionAlreadyInstalledError => e
           results[:result] = (e.newer_versions.empty? ? :noop : :failure)
           results[:error] = { :oneline => e.message, :multiline => e.multiline }
         rescue => e
           results[:error] = {
             :oneline   => e.message,
             :multiline => e.respond_to?(:multiline) ? e.multiline : [e.to_s, e.backtrace].join("\n")
           }
         ensure
           results[:result] ||= :failure
         end
 
         results
       end
 
       private
       def module_repository
         @repo ||= Puppet::Forge.new
       end
 
       def installed_modules_source
         @installed ||= Puppet::ModuleTool::InstalledModules.new(@environment)
       end
 
       def installed_modules
         installed_modules_source.modules
       end
 
       def build_single_module_graph(name, version)
         range = Semantic::VersionRange.parse(version)
         graph = Semantic::Dependency::Graph.new(name => range)
         releases = Semantic::Dependency.fetch_releases(name)
         releases.each { |release| release.dependencies.clear }
         graph << releases
       end
 
       def build_dependency_graph(name, version)
         Semantic::Dependency.query(name => version)
       end
 
       def build_install_graph(release, installed, graphed = [])
         previous = installed_modules[release.name]
         previous = previous.version if previous
 
         action = :upgrade
         unless previous && previous != release.version
           action = :install
         end
 
         graphed << release
 
         dependencies = release.dependencies.values.map do |deps|
           dep = (deps & installed).first
           if dep == installed_modules[dep.name]
             next
           end
 
           if dep && !graphed.include?(dep)
             build_install_graph(dep, installed, graphed)
           end
         end.compact
 
         return {
           :release          => release,
           :name             => release.name,
           :path             => release.install_dir,
           :dependencies     => dependencies.compact,
           :version          => release.version,
           :previous_version => previous,
           :action           => action,
         }
       end
 
       include Puppet::ModuleTool::Shared
     end
   end
 end
diff --git a/lib/puppet/module_tool/contents_description.rb b/lib/puppet/module_tool/contents_description.rb
index 7fd6505f4..ca67930d8 100644
--- a/lib/puppet/module_tool/contents_description.rb
+++ b/lib/puppet/module_tool/contents_description.rb
@@ -1,84 +1,84 @@
 require 'puppet/module_tool'
 
 module Puppet::ModuleTool
 
   # = ContentsDescription
   #
   # This class populates +Metadata+'s Puppet type information.
   class ContentsDescription
 
     # Instantiate object for string +module_path+.
     def initialize(module_path)
       @module_path = module_path
     end
 
     # Update +Metadata+'s Puppet type information.
     def annotate(metadata)
       metadata.types.replace data.clone
     end
 
     # Return types for this module. Result is an array of hashes, each of which
     # describes a Puppet type. The type description hash structure is:
     # * :name => Name of this Puppet type.
     # * :doc => Documentation for this type.
     # * :properties => Array of hashes representing the type's properties, each
     #   containing :name and :doc.
     # * :parameters => Array of hashes representing the type's parameters, each
     #   containing :name and :doc.
     # * :providers => Array of hashes representing the types providers, each
     #   containing :name and :doc.
     # TODO Write a TypeDescription to encapsulate these structures and logic?
     def data
       unless @data
         @data = []
         type_names = []
         for module_filename in Dir[File.join(@module_path, "lib/puppet/type/*.rb")]
           require module_filename
           type_name = File.basename(module_filename, ".rb")
           type_names << type_name
 
           for provider_filename in Dir[File.join(@module_path, "lib/puppet/provider/#{type_name}/*.rb")]
             require provider_filename
           end
         end
 
-        type_names.each do |type_name|
-          if type = Puppet::Type.type(type_name.to_sym)
-            type_hash = {:name => type_name, :doc => type.doc}
+        type_names.each do |name|
+          if type = Puppet::Type.type(name.to_sym)
+            type_hash = {:name => name, :doc => type.doc}
             type_hash[:properties] = attr_doc(type, :property)
             type_hash[:parameters] = attr_doc(type, :param)
             if type.providers.size > 0
               type_hash[:providers] = provider_doc(type)
             end
             @data << type_hash
           else
-            Puppet.warning "Could not find/load type: #{type_name}"
+            Puppet.warning "Could not find/load type: #{name}"
           end
         end
       end
       @data
     end
 
     # Return an array of hashes representing this +type+'s attrs of +kind+
     # (e.g. :param or :property), each containing :name and :doc.
     def attr_doc(type, kind)
       [].tap do |attrs|
         type.allattrs.each do |name|
           if type.attrtype(name) == kind && name != :provider
             attrs.push(:name => name, :doc => type.attrclass(name).doc)
           end
         end
       end
     end
 
     # Return an array of hashes representing this +type+'s providers, each
     # containing :name and :doc.
     def provider_doc(type)
       [].tap do |providers|
         type.providers.sort.each do |prov|
           providers.push(:name => prov, :doc => type.provider(prov).doc)
         end
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool/installed_modules.rb b/lib/puppet/module_tool/installed_modules.rb
index de9421132..8042f09b8 100644
--- a/lib/puppet/module_tool/installed_modules.rb
+++ b/lib/puppet/module_tool/installed_modules.rb
@@ -1,98 +1,98 @@
 require 'pathname'
 
 require 'puppet/forge'
 require 'puppet/module_tool'
 
 module Puppet::ModuleTool
   class InstalledModules < Semantic::Dependency::Source
     attr_reader :modules, :by_name
 
     def priority
       10
     end
 
     def initialize(env)
       @env = env
       modules = env.modules_by_path
 
       @fetched = []
       @modules = {}
       @by_name = {}
       env.modulepath.each do |path|
         modules[path].each do |mod|
           @by_name[mod.name] = mod
           next unless mod.has_metadata?
           release = ModuleRelease.new(self, mod)
           @modules[release.name] ||= release
         end
       end
 
       @modules.freeze
     end
 
     # Fetches {ModuleRelease} entries for each release of the named module.
     #
     # @param name [String] the module name to look up
     # @return [Array<Semantic::Dependency::ModuleRelease>] a list of releases for
     #         the given name
     # @see Semantic::Dependency::Source#fetch
     def fetch(name)
       name = name.tr('/', '-')
 
       if @modules.key? name
         @fetched << name
         [ @modules[name] ]
       else
         [ ]
       end
     end
 
     def fetched
       @fetched
     end
 
     class ModuleRelease < Semantic::Dependency::ModuleRelease
       attr_reader :mod, :metadata
 
       def initialize(source, mod)
         @mod = mod
         @metadata = mod.metadata
         name = mod.forge_name.tr('/', '-')
         begin
           version = Semantic::Version.parse(mod.version)
         rescue Semantic::Version::ValidationFailure => e
           Puppet.warning "#{mod.name} (#{mod.path}) has an invalid version number (#{mod.version}). The version has been set to 0.0.0. If you are the maintainer for this module, please update the metadata.json with a valid Semantic Version (http://semver.org)."
           version = Semantic::Version.parse("0.0.0")
         end
         release = "#{name}@#{version}"
 
         super(source, name, version, {})
 
         if mod.dependencies
-          mod.dependencies.each do |dep|
-            results = Puppet::ModuleTool.parse_module_dependency(release, dep)
+          mod.dependencies.each do |dependency|
+            results = Puppet::ModuleTool.parse_module_dependency(release, dependency)
             dep_name, parsed_range, range = results
 
-            dep.tap do |dep|
+            dependency.tap do |dep|
               add_constraint('initialize', dep_name, range.to_s) do |node|
                 parsed_range === node.version
               end
             end
           end
         end
       end
 
       def install_dir
         Pathname.new(@mod.path).dirname
       end
 
       def install(dir)
         # If we're already installed, there's no need for us to faff about.
       end
 
       def prepare
         # We're already installed; what preparation remains?
       end
     end
   end
 end
diff --git a/lib/puppet/network/auth_config_parser.rb b/lib/puppet/network/auth_config_parser.rb
index cb7199ee3..01a17ae11 100644
--- a/lib/puppet/network/auth_config_parser.rb
+++ b/lib/puppet/network/auth_config_parser.rb
@@ -1,84 +1,84 @@
 require 'puppet/network/rights'
 
 module Puppet::Network
 class AuthConfigParser
 
   def self.new_from_file(file)
     self.new(File.read(file))
   end
 
   def initialize(string)
     @string = string
   end
 
   def parse
     Puppet::Network::AuthConfig.new(parse_rights)
   end
 
   def parse_rights
     rights = Puppet::Network::Rights.new
     right = nil
     count = 1
     @string.each_line { |line|
       case line.chomp
       when /^\s*#/, /^\s*$/
         # skip comments and blank lines
       when /^path\s+((?:~\s+)?[^ ]+)\s*$/ # "path /path" or "path ~ regex"
         name = $1.chomp
         right = rights.newright(name, count, @file)
       when /^\s*(allow(?:_ip)?|deny(?:_ip)?|method|environment|auth(?:enticated)?)\s+(.+?)(\s*#.*)?$/
         if right.nil?
           raise Puppet::ConfigurationError, "Missing or invalid 'path' before right directive at line #{count} of #{@file}"
         end
         parse_right_directive(right, $1, $2, count)
       else
         raise Puppet::ConfigurationError, "Invalid line #{count}: #{line}"
       end
       count += 1
     }
 
     # Verify each of the rights are valid.
     # We let the check raise an error, so that it can raise an error
     # pointing to the specific problem.
-    rights.each { |name, right|
-      right.valid?
+    rights.each { |name, r|
+      r.valid?
     }
     rights
   end
 
   def parse_right_directive(right, var, value, count)
     value.strip!
     case var
     when "allow"
       modify_right(right, :allow, value, "allowing %s access", count)
     when "deny"
       modify_right(right, :deny, value, "denying %s access", count)
     when "allow_ip"
       modify_right(right, :allow_ip, value, "allowing IP %s access", count)
     when "deny_ip"
       modify_right(right, :deny_ip, value, "denying IP %s access", count)
     when "method"
       modify_right(right, :restrict_method, value, "allowing 'method' %s", count)
     when "environment"
       modify_right(right, :restrict_environment, value, "adding environment %s", count)
     when /auth(?:enticated)?/
       modify_right(right, :restrict_authenticated, value, "adding authentication %s", count)
     else
       raise Puppet::ConfigurationError,
         "Invalid argument '#{var}' at line #{count}"
     end
   end
 
   def modify_right(right, method, value, msg, count)
     value.split(/\s*,\s*/).each do |val|
       begin
         val.strip!
         right.info msg % val
         right.send(method, val)
       rescue Puppet::AuthStoreError => detail
         raise Puppet::ConfigurationError, "#{detail} at line #{count} of #{@file}", detail.backtrace
       end
     end
   end
 end
 end
diff --git a/lib/puppet/network/format_handler.rb b/lib/puppet/network/format_handler.rb
index d341b4335..9667ee4e5 100644
--- a/lib/puppet/network/format_handler.rb
+++ b/lib/puppet/network/format_handler.rb
@@ -1,105 +1,105 @@
 require 'yaml'
 require 'puppet/network'
 require 'puppet/network/format'
 
 module Puppet::Network::FormatHandler
   class FormatError < Puppet::Error; end
 
   ALL_MEDIA_TYPES = '*/*'.freeze
 
   @formats = {}
 
   def self.create(*args, &block)
     instance = Puppet::Network::Format.new(*args, &block)
 
     @formats[instance.name] = instance
     instance
   end
 
   def self.create_serialized_formats(name,options = {},&block)
     ["application/x-#{name}", "application/#{name}", "text/x-#{name}", "text/#{name}"].each { |mime_type|
       create name, {:mime => mime_type}.update(options), &block
     }
   end
 
   def self.format(name)
     @formats[name.to_s.downcase.intern]
   end
 
   def self.format_for(name)
     name = format_to_canonical_name(name)
     format(name)
   end
 
   def self.format_by_extension(ext)
     @formats.each do |name, format|
       return format if format.extension == ext
     end
     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
 
   # 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
 
   # Determine which of the accepted formats should be used given what is supported.
   #
   # @param accepted [Array<String, Symbol>] the accepted formats in a form a
   #   that generally conforms to an HTTP Accept header. Any quality specifiers
   #   are ignored and instead the formats are simply in strict preference order
   #   (most preferred is first)
   # @param supported [Array<Symbol>] the names of the supported formats (the
   #   most preferred format is first)
   # @return [Puppet::Network::Format, nil] the most suitable format
   # @api private
   def self.most_suitable_format_for(accepted, supported)
-    format_name = accepted.collect do |accepted|
-      accepted.to_s.sub(/;q=.*$/, '')
-    end.collect do |accepted|
-      if accepted == ALL_MEDIA_TYPES
+    format_name = accepted.collect do |format|
+      format.to_s.sub(/;q=.*$/, '')
+    end.collect do |format|
+      if format == ALL_MEDIA_TYPES
         supported.first
       else
-        format_to_canonical_name_or_nil(accepted)
+        format_to_canonical_name_or_nil(format)
       end
-    end.find do |accepted|
-      supported.include?(accepted)
+    end.find do |format|
+      supported.include?(format)
     end
 
     if format_name
       format_for(format_name)
     end
   end
 
   # @api private
   def self.format_to_canonical_name_or_nil(format)
     format_to_canonical_name(format)
   rescue ArgumentError
     nil
   end
 end
 
 require 'puppet/network/formats'
diff --git a/lib/puppet/network/http/handler.rb b/lib/puppet/network/http/handler.rb
index e26973e76..7851c3aae 100644
--- a/lib/puppet/network/http/handler.rb
+++ b/lib/puppet/network/http/handler.rb
@@ -1,179 +1,179 @@
 module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http'
 require 'puppet/network/http/api/v1'
 require 'puppet/network/rights'
 require 'puppet/util/profiler'
 require 'puppet/util/profiler/aggregate'
 require 'resolv'
 
 module Puppet::Network::HTTP::Handler
   include Puppet::Network::HTTP::Issues
 
   # These shouldn't be allowed to be set by clients
   # in the query string, for security reasons.
   DISALLOWED_KEYS = ["node", "ip"]
 
   def register(routes)
     # There's got to be a simpler way to do this, right?
     dupes = {}
     routes.each { |r| dupes[r.path_matcher] = (dupes[r.path_matcher] || 0) + 1 }
     dupes = dupes.collect { |pm, count| pm if count > 1 }.compact
     if dupes.count > 0
       raise ArgumentError, "Given multiple routes with identical path regexes: #{dupes.map{ |rgx| rgx.inspect }.join(', ')}"
     end
 
     @routes = routes
     Puppet.debug("Routes Registered:")
     @routes.each do |route|
       Puppet.debug(route.inspect)
     end
   end
 
   # Retrieve all headers from the http request, as a hash with the header names
   # (lower-cased) as the keys
   def headers(request)
     raise NotImplementedError
   end
 
   def format_to_mime(format)
     format.is_a?(Puppet::Network::Format) ? format.mime : format
   end
 
   # handle an HTTP request
   def process(request, response)
     new_response = Puppet::Network::HTTP::Response.new(self, response)
 
     request_headers = headers(request)
     request_params = params(request)
     request_method = http_method(request)
     request_path = path(request)
 
     new_request = Puppet::Network::HTTP::Request.new(request_headers, request_params, request_method, request_path, request_path, client_cert(request), body(request))
 
     response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] = Puppet.version
 
     profiler = configure_profiler(request_headers, request_params)
 
     Puppet::Util::Profiler.profile("Processed request #{request_method} #{request_path}", [:http, request_method, request_path]) do
-      if route = @routes.find { |route| route.matches?(new_request) }
+      if route = @routes.find { |r| r.matches?(new_request) }
         route.process(new_request, new_response)
       else
         raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No route for #{new_request.method} #{new_request.path}", HANDLER_NOT_FOUND)
       end
     end
 
   rescue Puppet::Network::HTTP::Error::HTTPError => e
     Puppet.info(e.message)
     new_response.respond_with(e.status, "application/json", e.to_json)
   rescue StandardError => e
     http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
     Puppet.err(http_e.message)
     new_response.respond_with(http_e.status, "application/json", http_e.to_json)
   ensure
     if profiler
       remove_profiler(profiler)
     end
     cleanup(request)
   end
 
   # Set the response up, with the body and status.
   def set_response(response, body, status = 200)
     raise NotImplementedError
   end
 
   # Set the specified format as the content type of the response.
   def set_content_type(response, format)
     raise NotImplementedError
   end
 
   # resolve node name from peer's ip address
   # this is used when the request is unauthenticated
   def resolve_node(result)
     begin
       return Resolv.getname(result[:ip])
     rescue => detail
       Puppet.err "Could not resolve #{result[:ip]}: #{detail}"
     end
     result[:ip]
   end
 
   private
 
   # methods to be overridden by the including web server class
 
   def http_method(request)
     raise NotImplementedError
   end
 
   def path(request)
     raise NotImplementedError
   end
 
   def request_key(request)
     raise NotImplementedError
   end
 
   def body(request)
     raise NotImplementedError
   end
 
   def params(request)
     raise NotImplementedError
   end
 
   def client_cert(request)
     raise NotImplementedError
   end
 
   def cleanup(request)
     # By default, there is nothing to cleanup.
   end
 
   def decode_params(params)
     params.select { |key, _| allowed_parameter?(key) }.inject({}) do |result, ary|
       param, value = ary
       result[param.to_sym] = parse_parameter_value(param, value)
       result
     end
   end
 
   def allowed_parameter?(name)
     not (name.nil? || name.empty? || DISALLOWED_KEYS.include?(name))
   end
 
   def parse_parameter_value(param, value)
     if value.is_a?(Array)
       value.collect { |v| parse_primitive_parameter_value(v) }
     else
       parse_primitive_parameter_value(value)
     end
   end
 
   def parse_primitive_parameter_value(value)
     case value
     when "true"
       true
     when "false"
       false
     when /^\d+$/
       Integer(value)
     when /^\d+\.\d+$/
       value.to_f
     else
       value
     end
   end
 
   def configure_profiler(request_headers, request_params)
     if (request_headers.has_key?(Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase) or Puppet[:profile])
       Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:debug), request_params.object_id))
     end
   end
 
   def remove_profiler(profiler)
     profiler.shutdown
     Puppet::Util::Profiler.remove_profiler(profiler)
   end
 end
diff --git a/lib/puppet/network/resolver.rb b/lib/puppet/network/resolver.rb
index 98554eb8b..54e27f9e5 100644
--- a/lib/puppet/network/resolver.rb
+++ b/lib/puppet/network/resolver.rb
@@ -1,86 +1,86 @@
 require 'resolv'
 module Puppet::Network; end
 
 module Puppet::Network::Resolver
   # Iterate through the list of servers that service this hostname
   # and yield each server/port since SRV records have ports in them
   # It will override whatever masterport setting is already set.
   def self.each_srv_record(domain, service_name = :puppet, &block)
     if (domain.nil? or domain.empty?)
       Puppet.debug "Domain not known; skipping SRV lookup"
       return
     end
 
     Puppet.debug "Searching for SRV records for domain: #{domain}"
 
     case service_name
       when :puppet then service = '_x-puppet'
       when :ca     then service = '_x-puppet-ca'
       when :report then service = '_x-puppet-report'
       when :file   then service = '_x-puppet-fileserver'
       else              service = "_x-puppet-#{service_name.to_s}"
     end
     srv_record = "#{service}._tcp.#{domain}"
 
     resolver = Resolv::DNS.new
     records = resolver.getresources(srv_record, Resolv::DNS::Resource::IN::SRV)
     Puppet.debug "Found #{records.size} SRV records for: #{srv_record}"
 
     if records.size == 0 && service_name != :puppet
       # Try the generic :puppet service if no SRV records were found
       # for the specific service.
       each_srv_record(domain, :puppet, &block)
     else
-      each_priority(records) do |priority, records|
-        while next_rr = records.delete(find_weighted_server(records))
+      each_priority(records) do |priority, recs|
+        while next_rr = recs.delete(find_weighted_server(recs))
           Puppet.debug "Yielding next server of #{next_rr.target.to_s}:#{next_rr.port}"
           yield next_rr.target.to_s, next_rr.port
         end
       end
     end
   end
 
   private
 
   def self.each_priority(records)
     pri_hash = records.inject({}) do |groups, element|
       groups[element.priority] ||= []
       groups[element.priority] << element
       groups
     end
 
     pri_hash.keys.sort.each do |key|
       yield key, pri_hash[key]
     end
   end
 
   def self.find_weighted_server(records)
     return nil if records.nil? || records.empty?
     return records.first if records.size == 1
 
     # Calculate the sum of all weights in the list of resource records,
     # This is used to then select hosts until the weight exceeds what
     # random number we selected.  For example, if we have weights of 1 8 and 3:
     #
     # |-|---|--------|
     #        ^
     # We generate a random number 5, and iterate through the records, adding
     # the current record's weight to the accumulator until the weight of the
     # current record plus previous records is greater than the random number.
 
     total_weight = records.inject(0) { |sum,record|
       sum + weight(record)
     }
     current_weight = 0
     chosen_weight  = 1 + Kernel.rand(total_weight)
 
     records.each do |record|
       current_weight += weight(record)
       return record if current_weight >= chosen_weight
     end
   end
 
   def self.weight(record)
     record.weight == 0 ? 1 : record.weight * 10
   end
 end
diff --git a/lib/puppet/network/rights.rb b/lib/puppet/network/rights.rb
index d7275babf..bfd25aca0 100644
--- a/lib/puppet/network/rights.rb
+++ b/lib/puppet/network/rights.rb
@@ -1,219 +1,219 @@
 require 'puppet/network/authstore'
 require 'puppet/error'
 
 module Puppet::Network
 
 # this exception is thrown when a request is not authenticated
 class AuthorizationError < Puppet::Error; end
 
 # Rights class manages a list of ACLs for paths.
 class Rights
   # Check that name is allowed or not
   def allowed?(name, *args)
     !is_forbidden_and_why?(name, :node => args[0], :ip => args[1])
   end
 
   def is_request_forbidden_and_why?(method, path, params)
     methods_to_check = if method == :head
                          # :head is ok if either :find or :save is ok.
                          [:find, :save]
                        else
                          [method]
                        end
-    authorization_failure_exceptions = methods_to_check.map do |method|
-      is_forbidden_and_why?(path, params.merge({:method => method}))
+    authorization_failure_exceptions = methods_to_check.map do |m|
+      is_forbidden_and_why?(path, params.merge({:method => m}))
     end
     if authorization_failure_exceptions.include? nil
       # One of the methods we checked is ok, therefore this request is ok.
       nil
     else
       # Just need to return any of the failure exceptions.
       authorization_failure_exceptions.first
     end
   end
 
   def is_forbidden_and_why?(name, args = {})
     res = :nomatch
     right = @rights.find do |acl|
       found = false
       # an acl can return :dunno, which means "I'm not qualified to answer your question,
       # please ask someone else". This is used when for instance an acl matches, but not for the
       # current rest method, where we might think some other acl might be more specific.
       if match = acl.match?(name)
         args[:match] = match
         if (res = acl.allowed?(args[:node], args[:ip], args)) != :dunno
           # return early if we're allowed
           return nil if res
           # we matched, select this acl
           found = true
         end
       end
       found
     end
 
     # if we end up here, then that means we either didn't match or failed, in any
     # case will return an error to the outside world
     host_description = args[:node] ? "#{args[:node]}(#{args[:ip]})" : args[:ip]
 
     msg = "#{host_description} access to #{name} [#{args[:method]}]"
 
     if args[:authenticated]
       msg += " authenticated "
     end
 
     if right
       msg += " at #{right.file}:#{right.line}"
     end
 
     AuthorizationError.new("Forbidden request: #{msg}")
   end
 
   def initialize
     @rights = []
   end
 
   def [](name)
     @rights.find { |acl| acl == name }
   end
 
   def empty?
     @rights.empty?
   end
 
   def include?(name)
     @rights.include?(name)
   end
 
   def each
     @rights.each { |r| yield r.name,r }
   end
 
   # Define a new right to which access can be provided.
   def newright(name, line=nil, file=nil)
     add_right( Right.new(name, line, file) )
   end
 
   private
 
   def add_right(right)
     @rights << right
     right
   end
 
   # Retrieve a right by name.
   def right(name)
     self[name]
   end
 
   # A right.
   class Right < Puppet::Network::AuthStore
     attr_accessor :name, :key
     # Overriding Object#methods sucks for debugging. If we're in here in the
     # future, it would be nice to rename Right#methods
     attr_accessor :methods, :environment, :authentication
     attr_accessor :line, :file
 
     ALL = [:save, :destroy, :find, :search]
 
     Puppet::Util.logmethods(self, true)
 
     def initialize(name, line, file)
       @methods = []
       @environment = []
       @authentication = true # defaults to authenticated
       @name = name
       @line = line || 0
       @file = file
       @methods = ALL
 
       case name
       when /^\//
         @key = Regexp.new("^" + Regexp.escape(name))
       when /^~/ # this is a regex
         @name = name.gsub(/^~\s+/,'')
         @key = Regexp.new(@name)
       else
         raise ArgumentError, "Unknown right type '#{name}'"
       end
 
       super()
     end
 
     def to_s
       "access[#{@name}]"
     end
 
     # There's no real check to do at this point
     def valid?
       true
     end
 
     # does this right is allowed for this triplet?
     # if this right is too restrictive (ie we don't match this access method)
     # then return :dunno so that upper layers have a chance to try another right
     # tailored to the given method
     def allowed?(name, ip, args = {})
       if not @methods.include?(args[:method])
         return :dunno
       elsif @environment.size > 0 and not @environment.include?(args[:environment])
         return :dunno
       elsif (@authentication and not args[:authenticated])
         return :dunno
       end
 
       begin
         # make sure any capture are replaced if needed
         interpolate(args[:match]) if args[:match]
         res = super(name,ip)
       ensure
         reset_interpolation
       end
       res
     end
 
     # restrict this right to some method only
     def restrict_method(m)
       m = m.intern if m.is_a?(String)
 
       raise ArgumentError, "'#{m}' is not an allowed value for method directive" unless ALL.include?(m)
 
       # if we were allowing all methods, then starts from scratch
       if @methods === ALL
         @methods = []
       end
 
       raise ArgumentError, "'#{m}' is already in the '#{name}' ACL" if @methods.include?(m)
 
       @methods << m
     end
 
     def restrict_environment(environment)
       env = Puppet.lookup(:environments).get(environment)
       raise ArgumentError, "'#{env}' is already in the '#{name}' ACL" if @environment.include?(env)
 
       @environment << env
     end
 
     def restrict_authenticated(authentication)
       case authentication
       when "yes", "on", "true", true
         authentication = true
       when "no", "off", "false", false, "all" ,"any", :all, :any
         authentication = false
       else
         raise ArgumentError, "'#{name}' incorrect authenticated value: #{authentication}"
       end
       @authentication = authentication
     end
 
     def match?(key)
       # otherwise match with the regex
       self.key.match(key)
     end
 
     def ==(name)
       self.name == name.gsub(/^~\s+/,'')
     end
   end
 end
 end
diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index 77907ffd9..c52b06664 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -1,572 +1,572 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
 # The Parameter class is the implementation of a resource's attributes of _parameter_ kind.
 # The Parameter class is also the base class for {Puppet::Property}, and is used to describe meta-parameters
 # (parameters that apply to all resource types).
 # A Parameter (in contrast to a Property) has a single value where a property has both a current and a wanted value.
 # The Parameter class methods are used to configure and create an instance of Parameter that represents
 # one particular attribute data type; its valid value(s), and conversion to/from internal form.
 #
 # The intention is that a new parameter is created by using the DSL method {Puppet::Type.newparam}, or
 # {Puppet::Type.newmetaparam} if the parameter should be applicable to all resource types.
 #
 # A Parameter that does not specify and valid values (via {newvalues}) accepts any value.
 #
 # @see Puppet::Type
 # @see Puppet::Property
 # @api public
 #
 class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
 
   require 'puppet/parameter/value_collection'
 
   class << self
     include Puppet::Util
     include Puppet::Util::Docs
 
     # @return [Symbol] The parameter name as given when it was created.
     attr_reader :name
 
     # @return [Object] The default value of the parameter as determined by the {defaultto} method, or nil if no
     #  default has been set.
     attr_reader :default
 
     # @comment This somewhat odd documentation construct is because the getter and setter are not
     #  orthogonal; the setter uses varargs and this confuses yard. To overcome the problem both the
     #  getter and the setter are documented here. If this issues is fixed, a todo will be displayed
     #  for the setter method, and the setter documentation can be moved there.
     #  Since the attribute is actually RW it should  perhaps instead just be implemented as a setter
     #  and a getter method (and no attr_xxx declaration).
     #
     # @!attribute [rw] required_features
     # @return [Array<Symbol>] The names of the _provider features_ required for this parameter to work.
     #   the returned names are always all lower case symbols.
     # @overload required_features
     #   Returns the required _provider features_ as an array of lower case symbols
     # @overload required_features=(*args)
     #   @param *args [Symbol] one or more names of required provider features
     #   Sets the required_provider_features_ from one or more values, or array. The given arguments
     #   are flattened, and internalized.
     # @api public
     # @dsl type
     #
     attr_reader :required_features
 
     # @return [Puppet::Parameter::ValueCollection] The set of valid values (or an empty set that accepts any value).
     # @api private
     #
     attr_reader :value_collection
 
     # @return [Boolean] Flag indicating whether this parameter is a meta-parameter or not.
     attr_accessor :metaparam
 
     # Defines how the `default` value of a parameter is computed.
     # The computation of the parameter's default value is defined by providing a value or a block.
     # A default of `nil` can not be used.
     # @overload defaultto(value)
     #   Defines the default value with a literal value
     #   @param value [Object] the literal value to use as the default value
     # @overload defaultto({|| ... })
     #   Defines that the default value is produced by the given block. The given block
     #   should produce the default value.
     # @raise [Puppet::DevError] if value is nil, and no block is given.
     # @return [void]
     # @see Parameter.default
     # @dsl type
     # @api public
     #
     def defaultto(value = nil, &block)
       if block
         define_method(:default, &block)
       else
         if value.nil?
           raise Puppet::DevError,
             "Either a default value or block must be provided"
         end
         define_method(:default) do value end
       end
     end
 
     # Produces a documentation string.
     # If an enumeration of _valid values_ has been defined, it is appended to the documentation
     # for this parameter specified with the {desc} method.
     # @return [String] Returns a documentation string.
     # @api public
     #
     def doc
       @doc ||= ""
 
       unless defined?(@addeddocvals)
         @doc = Puppet::Util::Docs.scrub(@doc)
         if vals = value_collection.doc
           @doc << "\n\n#{vals}"
         end
 
-        if f = self.required_features
-          @doc << "\n\nRequires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
+        if features = self.required_features
+          @doc << "\n\nRequires features #{features.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
       end
 
       @doc
     end
 
     # Removes the `default` method if defined.
     # Has no effect if the default method is not defined.
     # This method is intended to be used in a DSL scenario where a parameter inherits from a parameter
     # with a default value that is not wanted in the derived parameter (otherwise, simply do not define
     # a default value method).
     #
     # @return [void]
     # @see desc
     # @api public
     # @dsl type
     #
     def nodefault
       undef_method :default if public_method_defined? :default
     end
 
     # Sets the documentation for this parameter.
     # @param str [String] The documentation string to set
     # @return [String] the given `str` parameter
     # @see doc
     # @dsl type
     # @api public
     #
     def desc(str)
       @doc = str
     end
 
     # Initializes the instance variables.
     # Clears the internal value collection (set of allowed values).
     # @return [void]
     # @api private
     #
     def initvars
       @value_collection = ValueCollection.new
     end
 
     # @overload munge {|| ... }
     # Defines an optional method used to convert the parameter value from DSL/string form to an internal form.
     # If a munge method is not defined, the DSL/string value is used as is.
     # @note This adds a method with the name `unsafe_munge` in the created parameter class. Later this method is
     #   called in a context where exceptions will be rescued and handled.
     # @dsl type
     # @api public
     #
     def munge(&block)
       # I need to wrap the unsafe version in begin/rescue parameterments,
       # but if I directly call the block then it gets bound to the
       # class's context, not the instance's, thus the two methods,
       # instead of just one.
       define_method(:unsafe_munge, &block)
     end
 
     # @overload unmunge {|| ... }
     # Defines an optional method used to convert the parameter value to DSL/string form from an internal form.
     # If an `unmunge` method is not defined, the internal form is used.
     # @see munge
     # @note This adds a method with the name `unmunge` in the created parameter class.
     # @dsl type
     # @api public
     #
     def unmunge(&block)
       define_method(:unmunge, &block)
     end
 
     # Sets a marker indicating that this parameter is the _namevar_ (unique identifier) of the type
     # where the parameter is contained.
     # This also makes the parameter a required value. The marker can not be unset once it has been set.
     # @return [void]
     # @dsl type
     # @api public
     #
     def isnamevar
       @isnamevar = true
       @required = true
     end
 
     # @return [Boolean] Returns whether this parameter is the _namevar_ or not.
     # @api public
     #
     def isnamevar?
       @isnamevar
     end
 
     # Sets a marker indicating that this parameter is required.
     # Once set, it is not possible to make a parameter optional.
     # @return [void]
     # @dsl type
     # @api public
     #
     def isrequired
       @required = true
     end
 
     # @comment This method is not picked up by yard as it has a different signature than
     #   expected for an attribute (varargs). Instead, this method is documented as an overload
     #   of the attribute required_features. (Not ideal, but better than nothing).
     # @todo If this text appears in documentation - see comment in source and makes corrections - it means
     #   that an issue in yardoc has been fixed.
     #
     def required_features=(*args)
       @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
     end
 
     # Returns whether this parameter is required or not.
     # A parameter is required if a call has been made to the DSL method {isrequired}.
     # @return [Boolean] Returns whether this parameter is required or not.
     # @api public
     #
     def required?
       @required
     end
 
     # @overload validate {|| ... }
     # Defines an optional method that is used to validate the parameter's DSL/string value.
     # Validation should raise appropriate exceptions, the return value of the given block is ignored.
     # The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with
     # the message as an argument.
     # To validate the munged value instead, just munge the value (`munge(value)`).
     #
     # @return [void]
     # @dsl type
     # @api public
     #
     def validate(&block)
       define_method(:unsafe_validate, &block)
     end
 
     # Defines valid values for the parameter (enumeration or regular expressions).
     # The set of valid values for the parameter can be limited to a (mix of) literal values and
     # regular expression patterns.
     # @note Each call to this method adds to the set of valid values
     # @param names [Symbol, Regexp] The set of valid literal values and/or patterns for the parameter.
     # @return [void]
     # @dsl type
     # @api public
     #
     def newvalues(*names)
       @value_collection.newvalues(*names)
     end
 
     # Makes the given `name` an alias for the given `other` name.
     # Or said differently, the valid value `other` can now also be referred to via the given `name`.
     # Aliasing may affect how the parameter's value is serialized/stored (it may store the `other` value
     # instead of the alias).
     # @api public
     # @dsl type
     #
     def aliasvalue(name, other)
       @value_collection.aliasvalue(name, other)
     end
   end
 
   # Creates instance (proxy) methods that delegates to a class method with the same name.
   # @api private
   #
   def self.proxymethods(*values)
     values.each { |val|
       define_method(val) do
         self.class.send(val)
       end
     }
   end
 
   # @!method required?
   #   (see required?)
   # @!method isnamevar?
   #   (see isnamevar?)
   #
   proxymethods("required?", "isnamevar?")
 
   # @return [Puppet::Resource] A reference to the resource this parameter is an attribute of (the _associated resource_).
   attr_accessor :resource
 
   # @comment LAK 2007-05-09: Keep the @parent around for backward compatibility.
   # @return [Puppet::Parameter] A reference to the parameter's parent kept for backwards compatibility.
   # @api private
   #
   attr_accessor :parent
 
   # Returns a string representation of the resource's containment path in
   # the catalog.
   # @return [String]
   def path
     @path ||= '/' + pathbuilder.join('/')
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def line
     resource.line
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def file
     resource.file
   end
 
   # @return [Integer] Returns the result of calling the same method on the associated resource.
   def version
     resource.version
   end
 
 
   # Initializes the parameter with a required resource reference and optional attribute settings.
   # The option `:resource` must be specified or an exception is raised. Any additional options passed
   # are used to initialize the attributes of this parameter by treating each key in the `options` hash as
   # the name of the attribute to set, and the value as the value to set.
   # @param options [Hash{Symbol => Object]] Options, where `resource` is required
   # @option options [Puppet::Resource] :resource The resource this parameter holds a value for. Required.
   # @raise [Puppet::DevError] If resource is not specified in the options hash.
   # @api public
   # @note A parameter should be created via the DSL method {Puppet::Type::newparam}
   #
   def initialize(options = {})
     options = symbolize_options(options)
     if resource = options[:resource]
       self.resource = resource
       options.delete(:resource)
     else
       raise Puppet::DevError, "No resource set for #{self.class.name}"
     end
 
     set_options(options)
   end
 
   # Writes the given `msg` to the log with the loglevel indicated by the associated resource's
   # `loglevel` parameter.
   # @todo is loglevel a metaparameter? it is looked up with `resource[:loglevel]`
   # @return [void]
   # @api public
   def log(msg)
     send_log(resource[:loglevel], msg)
   end
 
   # @return [Boolean] Returns whether this parameter is a meta-parameter or not.
   def metaparam?
     self.class.metaparam
   end
 
   # @!attribute [r] name
   # @return [Symbol] The parameter's name as given when it was created.
   # @note Since a Parameter defines the name at the class level, each Parameter class must be
   #  unique within a type's inheritance chain.
   # @comment each parameter class must define the name method, and parameter
   #   instances do not change that name this implicitly means that a given
   #   object can only have one parameter instance of a given parameter
   #   class
   def name
     self.class.name
   end
 
   # @return [Boolean] Returns true if this parameter, the associated resource, or overall puppet mode is `noop`.
   # @todo How is noop mode set for a parameter? Is this of value in DSL to inhibit a parameter?
   #
   def noop
     @noop ||= false
     tmp = @noop || self.resource.noop || Puppet[:noop] || false
     #debug "noop is #{tmp}"
     tmp
   end
 
   # Returns an array of strings representing the containment heirarchy
   # (types/classes) that make up the path to the resource from the root
   # of the catalog.  This is mostly used for logging purposes.
   #
   # @api private
   def pathbuilder
     if @resource
       return [@resource.pathbuilder, self.name]
     else
       return [self.name]
     end
   end
 
   # This is the default implementation of `munge` that simply produces the value (if it is valid).
   # The DSL method {munge} should be used to define an overriding method if munging is required.
   #
   # @api private
   #
   def unsafe_munge(value)
     self.class.value_collection.munge(value)
   end
 
   # Unmunges the value by transforming it from internal form to DSL form.
   # This is the default implementation of `unmunge` that simply returns the value without processing.
   # The DSL method {unmunge} should be used to define an overriding method if required.
   # @return [Object] the unmunged value
   #
   def unmunge(value)
     value
   end
 
   # Munges the value to internal form.
   # This implementation of `munge` provides exception handling around the specified munging of this parameter.
   # @note This method should not be overridden. Use the DSL method {munge} to define a munging method
   #   if required.
   # @param value [Object] the DSL value to munge
   # @return [Object] the munged (internal) value
   #
   def munge(value)
     begin
       ret = unsafe_munge(value)
     rescue Puppet::Error => detail
       Puppet.debug "Reraising #{detail}"
       raise
     rescue => detail
       raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
     end
     ret
   end
 
   # This is the default implementation of `validate` that may be overridden by the DSL method {validate}.
   # If no valid values have been defined, the given value is accepted, else it is validated against
   # the literal values (enumerator) and/or patterns defined by calling {newvalues}.
   #
   # @param value [Object] the value to check for validity
   # @raise [ArgumentError] if the value is not valid
   # @return [void]
   # @api private
   #
   def unsafe_validate(value)
     self.class.value_collection.validate(value)
   end
 
   # Performs validation of the given value against the rules defined by this parameter.
   # @return [void]
   # @todo Better description of when the various exceptions are raised.ArgumentError is rescued and
   #   changed into Puppet::Error.
   # @raise [ArgumentError, TypeError, Puppet::DevError, Puppet::Error] under various conditions
   # A protected validation method that only ever raises useful exceptions.
   # @api public
   #
   def validate(value)
     begin
       unsafe_validate(value)
     rescue ArgumentError => detail
       self.fail Puppet::Error, detail.to_s, detail
     rescue Puppet::Error, TypeError
       raise
     rescue => detail
       raise Puppet::DevError, "Validate method failed for class #{self.name}: #{detail}", detail.backtrace
     end
   end
 
   # Sets the associated resource to nil.
   # @todo Why - what is the intent/purpose of this?
   # @return [nil]
   #
   def remove
     @resource = nil
   end
 
   # @return [Object] Gets the value of this parameter after performing any specified unmunging.
   def value
     unmunge(@value) unless @value.nil?
   end
 
   # Sets the given value as the value of this parameter.
   # @todo This original comment _"All of the checking should possibly be
   #   late-binding (e.g., users might not exist when the value is assigned
   #   but might when it is asked for)."_ does not seem to be correct, the implementation
   #   calls both validate and munge on the given value, so no late binding.
   #
   # The given value is validated and then munged (if munging has been specified). The result is store
   # as the value of this arameter.
   # @return [Object] The given `value` after munging.
   # @raise (see #validate)
   #
   def value=(value)
     validate(value)
 
     @value = munge(value)
   end
 
   # @return [Puppet::Provider] Returns the provider of the associated resource.
   # @todo The original comment says = _"Retrieve the resource's provider.
   #   Some types don't have providers, in which case we return the resource object itself."_
   #   This does not seem to be true, the default implementation that sets this value may be
   #   {Puppet::Type.provider=} which always gets either the name of a provider or an instance of one.
   #
   def provider
     @resource.provider
   end
 
   # @return [Array<Symbol>] Returns an array of the associated resource's symbolic tags (including the parameter itself).
   # Returns an array of the associated resource's symbolic tags (including the parameter itself).
   # At a minimun, the array contains the name of the parameter. If the associated resource
   # has tags, these tags are also included in the array.
   # @todo The original comment says = _"The properties need to return tags so that logs correctly
   #   collect them."_ what if anything of that is of interest to document. Should tags and their relationship
   #   to logs be described. This is a more general concept.
   #
   def tags
     unless defined?(@tags)
       @tags = []
       # This might not be true in testing
       @tags = @resource.tags if @resource.respond_to? :tags
       @tags << self.name.to_s
     end
     @tags
   end
 
   # @return [String] The name of the parameter in string form.
   def to_s
     name.to_s
   end
 
   # Produces a String with the value formatted for display to a human.
   # When the parameter value is a:
   #
   # * **single valued parameter value** the result is produced on the
   #   form `'value'` where _value_ is the string form of the parameter's value.
   #
   # * **Array** the list of values is enclosed in `[]`, and
   #   each produced value is separated by a comma.
   #
   # * **Hash** value is output with keys in sorted order enclosed in `{}` with each entry formatted
   #   on the form `'k' => v` where
   #   `k` is the key in string form and _v_ is the value of the key. Entries are comma separated.
   #
   # For both Array and Hash this method is called recursively to format contained values.
   # @note this method does not protect against infinite structures.
   #
   # @return [String] The formatted value in string form.
   #
   def self.format_value_for_display(value)
     if value.is_a? Array
-      formatted_values = value.collect {|value| format_value_for_display(value)}.join(', ')
+      formatted_values = value.collect {|v| format_value_for_display(v)}.join(', ')
       "[#{formatted_values}]"
     elsif value.is_a? Hash
       # Sorting the hash keys for display is largely for having stable
       # output to test against, but also helps when scanning for hash
       # keys, since they will be in ASCIIbetical order.
       hash = value.keys.sort {|a,b| a.to_s <=> b.to_s}.collect do |k|
         "'#{k}' => #{format_value_for_display(value[k])}"
       end.join(', ')
 
       "{#{hash}}"
     else
       "'#{value}'"
     end
   end
 
   # @comment Document post_compile_hook here as it does not exist anywhere (called from type if implemented)
   # @!method post_compile()
   # @since 3.4.0
   # @api public
   #   @abstract A subclass may implement this - it is not implemented in the Parameter class
   #   This method may be implemented by a parameter in order to perform actions during compilation
   #   after all resources have been added to the catalog.
   #   @see Puppet::Type#finish
   #   @see Puppet::Parser::Compiler#finish
 end
 
 require 'puppet/parameter/path'
diff --git a/lib/puppet/pops/evaluator/access_operator.rb b/lib/puppet/pops/evaluator/access_operator.rb
index c05b2b2b2..a95e7897d 100644
--- a/lib/puppet/pops/evaluator/access_operator.rb
+++ b/lib/puppet/pops/evaluator/access_operator.rb
@@ -1,588 +1,588 @@
 # AccessOperator handles operator []
 # This operator is part of evaluation.
 #
 class Puppet::Pops::Evaluator::AccessOperator
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
 
   Issues = Puppet::Pops::Issues
   TYPEFACTORY = Puppet::Pops::Types::TypeFactory
   EMPTY_STRING = ''.freeze
 
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
   # @param access_expression [Puppet::Pops::Model::AccessExpression] the semantic object being evaluated
   # @return [void]
   #
   def initialize(access_expression)
     @@access_visitor ||= Puppet::Pops::Visitor.new(self, "access", 2, nil)
     @semantic = access_expression
   end
 
   def access (o, scope, *keys)
     @@access_visitor.visit_this_2(self, o, scope, keys)
   end
 
   protected
 
   def access_Object(o, scope, keys)
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
     when 0
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
       k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
       # if k1 is outside, a length of 1 always produces an empty string
       if k1 < 0
         EMPTY_STRING
       else
         o[ k1, k2 ]
       end
     when 2
       k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       k2 = coerce_numeric(keys[1], @semantic.keys, scope)
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       o[ k1, k2 ]
     else
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
   end
 
   # Parameterizes a PRegexp Type with a pattern string or r ruby egexp
   #
   def access_PRegexpType(o, scope, keys)
     keys.flatten!
     unless keys.size == 1
       blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
     Puppet::Pops::Types::TypeFactory.regexp(*keys)
   end
 
   # Evaluates <ary>[] with 1 or 2 arguments. One argument is an index lookup, two arguments is a slice from/to.
   #
   def access_Array(o, scope, keys)
     keys.flatten!
     case keys.size
     when 0
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
-      k = coerce_numeric(keys[0], @semantic.keys[0], scope)
-      unless k.is_a?(Integer)
-        bad_access_key_type(o, 0, k, Integer)
+      key = coerce_numeric(keys[0], @semantic.keys[0], scope)
+      unless key.is_a?(Integer)
+        bad_access_key_type(o, 0, key, Integer)
       end
-      o[k]
+      o[key]
     when 2
       # A slice [from, to] with support for -1 to mean start, or end respectively.
       k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
       k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
 
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       # Help confused Ruby do the right thing (it truncates to the right, but negative index + length can never overlap
       # the available range.
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       # Help ruby always return empty array when asking for a sub array
       result = o[ k1, k2 ]
       result.nil? ? [] : result
     else
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
   end
 
 
   # Evaluates <hsh>[] with support for one or more arguments. If more than one argument is used, the result
   # is an array with each lookup.
   # @note
   #   Does not flatten its keys to enable looking up with a structure
   #
   def access_Hash(o, scope, keys)
     # Look up key in hash, if key is nil, try alternate form (:undef) before giving up.
     # This is done because the hash may have been produced by 3x logic and may thus contain :undef.
     result = keys.collect do |k|
       o.fetch(k) { |key| key.nil? ? o[:undef] : nil }
     end
     case result.size
     when 0
       fail(Puppet::Pops::Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       result.pop
     else
       # remove nil elements and return
       result.compact!
       result
     end
   end
 
   def access_PEnumType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String)
     Puppet::Pops::Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     Puppet::Pops::Types::TypeFactory.variant(*keys)
   end
 
   def access_PTupleType(o, scope, keys)
     keys.flatten!
     if TYPEFACTORY.is_range_parameter?(keys[-2]) && TYPEFACTORY.is_range_parameter?(keys[-1])
       size_type = TYPEFACTORY.range(keys[-2], keys[-1])
       keys = keys[0, keys.size - 2]
     elsif TYPEFACTORY.is_range_parameter?(keys[-1])
       size_type = TYPEFACTORY.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
     assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
     # set size type, or nil for default (exactly 1)
     t.size_type = size_type
     t
   end
 
   def access_PCallableType(o, scope, keys)
     TYPEFACTORY.callable(*keys)
   end
 
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
     TYPEFACTORY.struct(keys[0])
   end
 
   def access_PStringType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(0, keys[0])
     when 2
       size_t = collection_size_t(0, keys[0], keys[1])
     else
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     string_t = Puppet::Pops::Types::TypeFactory.string()
     string_t.size_type = size_t
     string_t
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
   # @param keys [Array<Object>] the evaluated keys
   # @param o [Object] evaluated LHS reported as :base_type
   # @param min [Integer] the minimum number of keys (typically 1)
   # @param max [Numeric] the maximum number of keys (use same as min, specific number, or Float::INFINITY)
   # @param allowed_classes [Class] a variable number of classes that each key must be an instance of (any)
   # @api private
   #
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || Float::INFINITY)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
         bad_type_specialization_key_type(o, i, k, *allowed_classes)
       end
     end
   end
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
     fail(Puppet::Pops::Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
       :left_value => lhs,
       :actual => bad_key_type_name(actual),
       :expected_classes => expected_classes
     })
   end
 
   def bad_key_type_name(actual)
     case actual
     when nil
       'Undef'
     when :default
       'Default'
     else
       Puppet::Pops::Types::TypeCalculator.generalize!(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
     end
   end
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
     label_provider = Puppet::Pops::Model::ModelLabelProvider.new()
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
     fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
       :type => type,
       :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
     })
   end
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
     Puppet::Pops::Types::TypeFactory.pattern(*keys)
   end
 
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::POptionalType.new()
       result.optional_type = keys[0]
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
   end
 
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::PType.new()
       result.type = keys[0]
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
   def access_PRuntimeType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 2, 2, String, String)
     # create runtime type based on runtime and name of class, (not inference of key's type)
     Puppet::Pops::Types::TypeFactory.runtime(*keys)
   end
 
   def access_PIntegerType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
       fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
     end
     ranged_integer = Puppet::Pops::Types::PIntegerType.new()
     from, to = keys
     ranged_integer.from = from == :default ? nil : from
     ranged_integer.to = to == :default ? nil : to
     ranged_integer
   end
 
   def access_PFloatType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
       fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
     end
     ranged_float = Puppet::Pops::Types::PFloatType.new()
     from, to = keys
     ranged_float.from = from == :default || from.nil? ? nil : Float(from)
     ranged_float.to = to == :default || to.nil? ? nil : Float(to)
     ranged_float
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
   # With 3 or 4 arguments, these are used to create a size constraint.
   # It is not possible to create a collection of Hash types directly.
   #
   def access_PHashType(o, scope, keys)
     keys.flatten!
     keys[0,2].each_with_index do |k, index|
       unless k.is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
     case keys.size
     when 2
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       result
     when 3
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       size_t = collection_size_t(1, keys[2])
       result
     when 4
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       size_t = collection_size_t(1, keys[2], keys[3])
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
     result.size_type = size_t if size_t
     result
   end
 
   # CollectionType is parameterized with a range
   def access_PCollectionType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(1, keys[0])
     when 2
       size_t = collection_size_t(1, keys[0], keys[1])
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
     end
     result = Puppet::Pops::Types::PCollectionType.new()
     result.size_type = size_t
     result
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
   #
   def access_PArrayType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = nil
     when 2
       size_t = collection_size_t(1, keys[1])
     when 3
       size_t = collection_size_t(1, keys[1], keys[2])
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
     unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
     end
     result = Puppet::Pops::Types::PArrayType.new()
     result.element_type = keys[0]
     result.size_type = size_t
     result
   end
 
   # Produces an PIntegerType (range) given one or two keys.
   def collection_size_t(start_index, *keys)
     if keys.size == 1 && keys[0].is_a?(Puppet::Pops::Types::PIntegerType)
       keys[0].copy
     else
       keys.each_with_index do |x, index|
         fail(Puppet::Pops::Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
           {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
       end
       ranged_integer = Puppet::Pops::Types::PIntegerType.new()
       from, to = keys
       ranged_integer.from = from == :default ? nil : from
       ranged_integer.to = to == :default ? nil : to
       ranged_integer
     end
   end
 
   # A Puppet::Resource represents either just a type (no title), or is a fully qualified type/title.
   #
   def access_Resource(o, scope, keys)
     # To access a Puppet::Resource as if it was a PResourceType, simply infer it, and take the type of
     # the parameterized meta type (i.e. Type[Resource[the_resource_type, the_resource_title]])
     t = Puppet::Pops::Types::TypeCalculator.infer(o).type
     # must map "undefined title" from resource to nil
     t.title = nil if t.title == EMPTY_STRING
     access(t, scope, *keys)
   end
 
   # A Resource can create a new more specific Resource type, and/or an array of resource types
   # If the given type has title set, it can not be specified further.
   # @example
   #   Resource[File]               # => File
   #   Resource[File, 'foo']        # => File[foo]
   #   Resource[File. 'foo', 'bar'] # => [File[foo], File[bar]]
   #   File['foo', 'bar']           # => [File[foo], File[bar]]
   #   File['foo']['bar']           # => Value of the 'bar' parameter in the File['foo'] resource
   #   Resource[File]['foo', 'bar'] # => [File[Foo], File[bar]]
   #   Resource[File, 'foo', 'bar'] # => [File[foo], File[bar]]
   #   Resource[File, 'foo']['bar'] # => Value of the 'bar' parameter in the File['foo'] resource
   #
   def access_PResourceType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
 
     if keys.size == 0
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
         :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
 
     # Must know which concrete resource type to operate on in all cases.
     # It is not allowed to specify the type in an array arg - e.g. Resource[[File, 'foo']]
     # type_name is LHS type_name if set, else the first given arg
     type_name = o.type_name || keys.shift
     type_name = case type_name
     when Puppet::Pops::Types::PResourceType
       type_name.type_name
     when String
       type_name.downcase
     else
       # blame given left expression if it defined the type, else the first given key expression
       blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
       fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
     end
 
     # type name must conform
     if type_name !~ Puppet::Pops::Patterns::CLASSREF
       fail(Puppet::Pops::Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
     keys_orig_size = keys.size
 
     keys.flatten!
     keys.compact!
 
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
     if !o.title.nil?
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
         fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
       end
 
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
           fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
             {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
       end
       return result_type_array ? result : result.pop
     end
 
 
     keys = [:no_title] if keys.size < 1 # if there was only a type_name and it was consumed
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         index = keys_orig_size != keys.size ? i+1 : i
         fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
           :type => o,
           :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
         })
       end
 
       rtype = Puppet::Pops::Types::PResourceType.new()
       rtype.type_name = type_name
       rtype.title = (t == :no_title ? nil : t)
       rtype
     end
     # returns single type if request was for a single entity, else an array of types (possibly empty)
     return result_type_array ? result : result.pop
   end
 
   def access_PHostClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys_orig_size = keys.size
 
     if keys_orig_size == 0
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
         :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
 
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
 
     keys.flatten!
     keys.compact!
 
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
     if o.class_name.nil?
       # The type argument may be a Resource Type - the Puppet Language allows a reference such as
       # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
       # does not have a title. This should probably be deprecated.
       #
       result = keys.each_with_index.map do |c, i|
         name = if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
                  # type_name is already downcase. Don't waste time trying to downcase again
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
                else
                  fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
                end
 
         if name =~ Puppet::Pops::Patterns::NAME
           ctype = Puppet::Pops::Types::PHostClassType.new()
           # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
           ctype.class_name = name.sub(/^::/, EMPTY_STRING)
           ctype
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
         end
       end
     else
       # lookup class resource and return one or more parameter values
       resource = find_resource(scope, 'class', o.class_name)
       if resource
         result = keys.map do |k|
           if is_parameter_of_resource?(scope, resource, k)
             get_resource_parameter_value(scope, resource, k)
           else
             fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
               {:type_name => 'Class', :title => o.class_name, :param_name=>k})
           end
         end
       else
         fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
       end
     end
 
     # returns single type as type, else an array of types
     return result_type_array ? result : result.pop
   end
 end
diff --git a/lib/puppet/pops/evaluator/callable_mismatch_describer.rb b/lib/puppet/pops/evaluator/callable_mismatch_describer.rb
index c1d9c3896..b4394134a 100644
--- a/lib/puppet/pops/evaluator/callable_mismatch_describer.rb
+++ b/lib/puppet/pops/evaluator/callable_mismatch_describer.rb
@@ -1,175 +1,175 @@
 # @api private
 module Puppet::Pops::Evaluator::CallableMismatchDescriber
   # Produces a string with the difference between the given arguments and support signature(s).
   #
   # @param name [String] The name of the callable to describe
   # @param args_type [Puppet::Pops::Types::Tuple] The tuple of argument types.
   # @param supported_signatures [Array<Puppet::Pops::Types::Callable>] The available signatures that were available for calling.
   #
   # @api private
   def self.diff_string(name, args_type, supported_signatures)
     result = [ ]
     if supported_signatures.size == 1
       signature = supported_signatures[0]
       params_type  = signature.type.param_types
       block_type   = signature.type.block_type
       params_names = signature.parameter_names
       result << "expected:\n  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
     else
       result << "expected one of:\n"
-      result << supported_signatures.map do |signature|
-        params_type = signature.type.param_types
-        "  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
+      result << supported_signatures.map do |sig|
+        params_type = sig.type.param_types
+        "  #{name}(#{signature_string(sig)}) - #{arg_count_string(sig.type)}"
       end.join("\n")
     end
 
     result << "\nactual:\n  #{name}(#{arg_types_string(args_type)}) - #{arg_count_string(args_type)}"
 
     result.join('')
   end
 
   private
 
   # Produces a string for the signature(s)
   #
   # @api private
   def self.signature_string(signature)
     param_types  = signature.type.param_types
     block_type   = signature.type.block_type
     param_names = signature.parameter_names
 
     from, to = param_types.size_range
     if from == 0 && to == 0
       # No parameters function
       return ''
     end
 
     required_count = from
     # there may be more names than there are types, and count needs to be subtracted from the count
     # to make it correct for the last named element
     adjust = max(0, param_names.size() -1)
     last_range = [max(0, (from - adjust)), (to - adjust)]
 
     types =
     case param_types
     when Puppet::Pops::Types::PTupleType
       param_types.types
     when Puppet::Pops::Types::PArrayType
       [ param_types.element_type ]
     end
     tc = Puppet::Pops::Types::TypeCalculator
 
     # join type with names (types are always present, names are optional)
     # separate entries with comma
     #
     result =
     if param_names.empty?
       types.each_with_index.map {|t, index| tc.string(t) + opt_value_indicator(index, required_count, 0) }
     else
       limit = param_names.size
       result = param_names.each_with_index.map do |name, index|
         [tc.string(types[index] || types[-1]), name].join(' ') + opt_value_indicator(index, required_count, limit)
       end
     end.join(', ')
 
     # Add {from, to} for the last type
     # This works for both Array and Tuple since it describes the allowed count of the "last" type element
     # for both. It does not show anything when the range is {1,1}.
     #
     result += range_string(last_range)
 
     # If there is a block, include it with its own optional count {0,1}
     case signature.type.block_type
     when Puppet::Pops::Types::POptionalType
       result << ', ' unless result == ''
       result << "#{tc.string(signature.type.block_type.optional_type)} #{signature.block_name} {0,1}"
     when Puppet::Pops::Types::PCallableType
       result << ', ' unless result == ''
       result << "#{tc.string(signature.type.block_type)} #{signature.block_name}"
     when NilClass
       # nothing
     end
     result
   end
 
   # Why oh why Ruby do you not have a standard Math.max ?
   # @api private
   def self.max(a, b)
     a >= b ? a : b
   end
 
   # @api private
   def self.opt_value_indicator(index, required_count, limit)
     count = index + 1
     (count > required_count && count < limit) ? '?' : ''
   end
 
   # @api private
   def self.arg_count_string(args_type)
     if args_type.is_a?(Puppet::Pops::Types::PCallableType)
       size_range = args_type.param_types.size_range # regular parameters
       adjust_range=
       case args_type.block_type
       when Puppet::Pops::Types::POptionalType
         size_range[1] += 1
       when Puppet::Pops::Types::PCallableType
         size_range[0] += 1
         size_range[1] += 1
       when NilClass
         # nothing
       else
         raise ArgumentError, "Internal Error, only nil, Callable, and Optional[Callable] supported by Callable block type"
       end
     else
       size_range = args_type.size_range
     end
     "arg count #{range_string(size_range, false)}"
   end
 
   # @api private
   def self.arg_types_string(args_type)
     types =
     case args_type
     when Puppet::Pops::Types::PTupleType
       last_range = args_type.repeat_last_range
       args_type.types
     when Puppet::Pops::Types::PArrayType
       last_range = args_type.size_range
       [ args_type.element_type ]
     end
     # stringify generalized versions or it will display Integer[10,10] for "10", String['the content'] etc.
     # note that type must be copied since generalize is a mutating operation
     tc = Puppet::Pops::Types::TypeCalculator
     result = types.map { |t| tc.string(tc.generalize!(t.copy)) }.join(', ')
 
     # Add {from, to} for the last type
     # This works for both Array and Tuple since it describes the allowed count of the "last" type element
     # for both. It does not show anything when the range is {1,1}.
     #
     result += range_string(last_range)
     result
   end
 
   # Formats a range into a string of the form: `{from, to}`
   #
   # The following cases are optimized:
   #
   #   * from and to are equal => `{from}`
   #   * from and to are both and 1 and squelch_one == true => `''`
   #   * from is 0 and to is 1 => `'?'`
   #   * to is Float::INFINITY => `{from, }`
   #
   # @api private
   def self.range_string(size_range, squelch_one = true)
     from, to = size_range
     if from == to
       (squelch_one && from == 1) ? '' : "{#{from}}"
     elsif to == Float::INFINITY
       "{#{from},}"
     elsif from == 0 && to == 1
       '?'
     else
       "{#{from},#{to}}"
     end
   end
 end
diff --git a/lib/puppet/pops/evaluator/closure.rb b/lib/puppet/pops/evaluator/closure.rb
index 7decc5a4c..7ab5a6e04 100644
--- a/lib/puppet/pops/evaluator/closure.rb
+++ b/lib/puppet/pops/evaluator/closure.rb
@@ -1,230 +1,230 @@
 # A Closure represents logic bound to a particular scope.
 # As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
 # safe to return and later use this closure.
 #
 # The 3x scope is essentially a named scope with an additional internal local/ephemeral nested scope state.
 # In 3x there is no way to directly refer to the nested scopes, instead, the named scope must be in a particular
 # state. Specifically, closures that require a local/ephemeral scope to exist at a later point will fail.
 # It is safe to call a closure (even with 3x scope) from the very same place it was defined, but not
 # returning it and expecting the closure to reference the scope's state at the point it was created.
 #
 # Note that this class is a CallableSignature, and the methods defined there should be used
 # as the API for obtaining information in a callable-implementation agnostic way.
 #
 class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignature
   attr_reader :evaluator
   attr_reader :model
   attr_reader :enclosing_scope
 
   def initialize(evaluator, model, scope)
     @evaluator = evaluator
     @model = model
     @enclosing_scope = scope
   end
 
   # marker method checked with respond_to :puppet_lambda
   # @api private
   # @deprecated Use the type system to query if an object is of Callable type, then use its signatures method for info
   def puppet_lambda()
     true
   end
 
   # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
     variable_bindings = combine_values_with_parameters(args)
 
     tc = Puppet::Pops::Types::TypeCalculator
-    final_args = tc.infer_set(parameters.inject([]) do |final_args, param|
+    final_args = tc.infer_set(parameters.inject([]) do |tmp_args, param|
       if param.captures_rest
-        final_args.concat(variable_bindings[param.name])
+        tmp_args.concat(variable_bindings[param.name])
       else
-        final_args << variable_bindings[param.name]
+        tmp_args << variable_bindings[param.name]
       end
     end)
 
     if tc.callable?(type, final_args)
       @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
     else
       raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
     end
   end
 
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
       if args_hash.size > parameters.size
         raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}"
       end
 
       # associate values with parameters
       scope_hash = {}
       parameters.each do |p|
         name = p.name
         if (arg_value = args_hash[name]).nil?
           # only set result of default expr if it is defined (it is otherwise not possible to differentiate
           # between explicit undef and no default expression
           unless p.value.nil?
             scope_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope)
           end
         else
           scope_hash[name] = arg_value
         end
       end
 
       missing = parameters.select { |p| !scope_hash.include?(p.name) }
       if missing.any?
         raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.collect(&:name).join(" ,")}"
       end
 
       tc = Puppet::Pops::Types::TypeCalculator
       final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
       if !tc.callable?(type, final_args)
         raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
       end
     else
       scope_hash = args_hash
     end
 
     @evaluator.evaluate_block_with_bindings(@enclosing_scope, scope_hash, @model.body)
   end
 
   def parameters
     @model.parameters
   end
 
   # Returns the number of parameters (required and optional)
   # @return [Integer] the total number of accepted parameters
   def parameter_count
     # yes, this is duplication of code, but it saves a method call
     @model.parameters.size
   end
 
   # @api public
   def parameter_names
     @model.parameters.collect(&:name)
   end
 
   # @api public
   def type
     @callable ||= create_callable_type
   end
 
   # @api public
   def last_captures_rest?
     last = @model.parameters[-1]
     last && last.captures_rest
   end
 
   # @api public
   def block_name
     # TODO: Lambda's does not support blocks yet. This is a placeholder
     'unsupported_block'
   end
 
   private
 
   def combine_values_with_parameters(args)
     variable_bindings = {}
 
     parameters.each_with_index do |parameter, index|
       param_captures     = parameter.captures_rest
       default_expression = parameter.value
 
       if index >= args.size
         if default_expression
           # not given, has default
           value = @evaluator.evaluate(default_expression, @enclosing_scope)
           if param_captures && !value.is_a?(Array)
             # correct non array default value
             value = [value]
           end
         else
           # not given, does not have default
           if param_captures
             # default for captures rest is an empty array
             value = []
           else
             @evaluator.fail(Puppet::Pops::Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
           end
         end
       else
         given_argument = args[index]
         if param_captures
           # get excess arguments
           value = args[(parameter_count-1)..-1]
           # If the input was a single nil, or undef, and there is a default, use the default
           # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
           #
           if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
             value = @evaluator.evaluate(default_expression, @enclosing_scope)
             # and ensure it is an array
             value = [value] unless value.is_a?(Array)
           end
         else
           value = given_argument
         end
       end
 
       variable_bindings[parameter.name] = value
     end
 
     variable_bindings
   end
 
   def create_callable_type()
     types = []
     range = [0, 0]
     in_optional_parameters = false
     parameters.each do |param|
       type = if param.type_expr
                @evaluator.evaluate(param.type_expr, @enclosing_scope)
              else
                Puppet::Pops::Types::TypeFactory.any()
              end
 
       if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)
         # An array on a slurp parameter is how a size range is defined for a
         # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
         # created can't have the array in that position or else type checking
         # will require the parameters to be arrays, which isn't what is
         # intended. The array type contains the intended information and needs
         # to be unpacked.
         param_range = type.size_range
         type = type.element_type
       elsif param.captures_rest && !type.is_a?(Puppet::Pops::Types::PArrayType)
         param_range = ANY_NUMBER_RANGE
       elsif param.value
         param_range = OPTIONAL_SINGLE_RANGE
       else
         param_range = REQUIRED_SINGLE_RANGE
       end
 
       types << type
 
       if param_range[0] == 0
         in_optional_parameters = true
       elsif param_range[0] != 0 && in_optional_parameters
         @evaluator.fail(Puppet::Pops::Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
       end
 
       range[0] += param_range[0]
       range[1] += param_range[1]
     end
 
     if range[1] == Float::INFINITY
       range[1] = :default
     end
 
     Puppet::Pops::Types::TypeFactory.callable(*(types + range))
   end
 
   # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
   def signatures
     [ self ]
   end
 
   ANY_NUMBER_RANGE = [0, Float::INFINITY]
   OPTIONAL_SINGLE_RANGE = [0, 1]
   REQUIRED_SINGLE_RANGE = [1, 1]
 end
diff --git a/lib/puppet/pops/evaluator/relationship_operator.rb b/lib/puppet/pops/evaluator/relationship_operator.rb
index 1731870af..8282d37a7 100644
--- a/lib/puppet/pops/evaluator/relationship_operator.rb
+++ b/lib/puppet/pops/evaluator/relationship_operator.rb
@@ -1,161 +1,161 @@
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
 # relationships between the left and right hand side's references to resources.
 #
 # This is separate class since a second level of evaluation is required that transforms string in left or right hand
 # to type references. The task of "making a relationship" is delegated to the "runtime support" class that is included.
 # This is done to separate the concerns of the new evaluator from the 3x runtime; messy logic goes into the runtime support
 # module. Later when more is cleaned up this can be simplified further.
 #
 class Puppet::Pops::Evaluator::RelationshipOperator
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
 
   Issues = Puppet::Pops::Issues
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
     def initialize operand
       @operand = operand
     end
   end
 
   class NotCatalogTypeError < RuntimeError
     attr_reader :type
     def initialize type
       @type = type
     end
   end
 
   def initialize
     @type_transformer_visitor = Puppet::Pops::Visitor.new(self, "transform", 1, 1)
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
     @type_parser = Puppet::Pops::Types::TypeParser.new()
 
     tf = Puppet::Pops::Types::TypeFactory
     @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
   end
 
   def transform(o, scope)
     @type_transformer_visitor.visit_this_1(self, o, scope)
   end
 
   # Catch all non transformable objects
   # @api private
   def transform_Object(o, scope)
     raise IllegalRelationshipOperandError.new(o)
   end
 
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
     assert_catalog_type(@type_parser.parse(o), scope)
   end
 
   # A qualified name is short hand for a class with this name
   # @api private
   def transform_QualifiedName(o, scope)
     Puppet::Pops::Types::TypeFactory.host_class(o.value)
   end
 
   # Types are what they are, just check the type
   # @api private
   def transform_PAnyType(o, scope)
     assert_catalog_type(o, scope)
   end
 
   # This transforms a 3x Collector (the result of evaluating a 3x AST::Collection).
   # It is passed through verbatim since it is evaluated late by the compiler. At the point
   # where the relationship is evaluated, it is simply recorded with the compiler for later evaluation.
   # If one of the sides of the relationship is a Collector it is evaluated before the actual
   # relationship is formed. (All of this happens at a later point in time.
   #
   def transform_Collector(o, scope)
     o
   end
 
   def transform_AbstractCollector(o, scope)
     o
   end
 
   # Array content needs to be transformed
   def transform_Array(o, scope)
     o.map{|x| transform(x, scope) }
   end
 
   # Asserts (and returns) the type if it is a PCatalogEntryType
   # (A PCatalogEntryType is the base class of PHostClassType, and PResourceType).
   #
   def assert_catalog_type(o, scope)
     unless @type_calculator.assignable?(@catalog_type, o)
       raise NotCatalogTypeError.new(o)
     end
     # TODO must check if this is an abstract PResourceType (i.e. without a type_name) - which should fail ?
     # e.g. File -> File (and other similar constructs) - maybe the catalog protects against this since references
     # may be to future objects...
     o
   end
 
   RELATIONSHIP_OPERATORS = [:'->', :'~>', :'<-', :'<~']
   REVERSE_OPERATORS      = [:'<-', :'<~']
   RELATION_TYPE = {
     :'->' => :relationship,
     :'<-' => :relationship,
     :'~>' => :subscription,
     :'<~' => :subscription
   }
 
   # Evaluate a relationship.
   # TODO: The error reporting is not fine grained since evaluation has already taken place
   # There is no references to the original source expressions at this point, only the overall
   # relationship expression. (e.g.. the expression may be ['string', func_call(), etc.] -> func_call())
   # To implement this, the general evaluator needs to be able to track each evaluation result and associate
   # it with a corresponding expression. This structure should then be passed to the relationship operator.
   #
   def evaluate (left_right_evaluated, relationship_expression, scope)
     # assert operator (should have been validated, but this logic makes assumptions which would
     # screw things up royally). Better safe than sorry.
     unless RELATIONSHIP_OPERATORS.include?(relationship_expression.operator)
       fail(Issues::UNSUPPORTED_OPERATOR, relationship_expression, {:operator => relationship_expression.operator})
     end
 
     begin
       # Turn each side into an array of types (this also asserts their type)
       # (note wrap in array first if value is not already an array)
       #
       # TODO: Later when objects are Puppet Runtime Objects and know their type, it will be more efficient to check/infer
       # the type first since a chained operation then does not have to visit each element again. This is not meaningful now
       # since inference needs to visit each object each time, and this is what the transformation does anyway).
       #
       # real is [left, right], and both the left and right may be a single value or an array. In each case all content
       # should be flattened, and then transformed to a type. left or right may also be a value that is transformed
       # into an array, and thus the resulting left and right must be flattened individually
       # Once flattened, the operands should be sets (to remove duplicate entries)
       #
-      real = left_right_evaluated.collect {|x| [x].flatten.collect {|x| transform(x, scope) }}
+      real = left_right_evaluated.collect {|x| [x].flatten.collect {|y| transform(y, scope) }}
       real[0].flatten!
       real[1].flatten!
       real[0].uniq!
       real[1].uniq!
 
       # reverse order if operator is Right to Left
       source, target = reverse_operator?(relationship_expression) ? real.reverse : real
 
       # Add the relationships to the catalog
       source.each {|s| target.each {|t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) }}
 
       # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
       real.slice(1)
     rescue NotCatalogTypeError => e
       fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e
       fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
     end
   end
 
   def reverse_operator?(o)
     REVERSE_OPERATORS.include?(o.operator)
   end
 end
diff --git a/lib/puppet/pops/loader/dependency_loader.rb b/lib/puppet/pops/loader/dependency_loader.rb
index dbeda418f..79525d2cc 100644
--- a/lib/puppet/pops/loader/dependency_loader.rb
+++ b/lib/puppet/pops/loader/dependency_loader.rb
@@ -1,60 +1,60 @@
 # =DependencyLoader
 # This loader provides visibility into a set of other loaders. It is used as a child of a ModuleLoader (or other
 # loader) to make its direct dependencies visible for loading from contexts that have access to this dependency loader.
 # Access is typically given to logic that resides inside of the module, but not to those that just depend on the module.
 #
 # It is instantiated with a name, and with a set of dependency_loaders.
 #
 # @api private
 #
 class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
 
   # An index of module_name to module loader used to speed up lookup of qualified names
   attr_reader :index
 
   # Creates a DependencyLoader for one parent loader
   #
   # @param parent_loader [Puppet::Pops::Loader] typically a module loader for the root
   # @param name [String] the name of the dependency-loader (used for debugging and tracing only)
   # @param dependency_loaders [Array<Puppet::Pops::Loader>] array of loaders for modules this module depends on
   #
   def initialize(parent_loader, name, dependency_loaders)
     super parent_loader, name
     @dependency_loaders = dependency_loaders
   end
 
   # Finds name in a loader this loader depends on / can see
   #
   def find(typed_name)
     if typed_name.qualified
-      if loader = index()[typed_name.name_parts[0]]
-        loader.load_typed(typed_name)
+      if l = index()[typed_name.name_parts[0]]
+        l.load_typed(typed_name)
       else
         # no module entered as dependency with name matching first segment of wanted name
         nil
       end
     else
       # a non name-spaced name, have to search since it can be anywhere.
       # (Note: superclass caches the result in this loader as it would have to repeat this search for every
       # lookup otherwise).
       loaded = @dependency_loaders.reduce(nil) do |previous, loader|
         break previous if !previous.nil?
         loader.load_typed(typed_name)
       end
       if loaded
         promote_entry(loaded)
       end
       loaded
     end
   end
 
   def to_s()
     "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
   end
 
   private
 
   def index()
     @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
   end
 end
diff --git a/lib/puppet/provider/group/aix.rb b/lib/puppet/provider/group/aix.rb
index 1722748d0..c16b9e496 100644
--- a/lib/puppet/provider/group/aix.rb
+++ b/lib/puppet/provider/group/aix.rb
@@ -1,141 +1,141 @@
 #
 # Group Puppet provider for AIX. It uses standard commands to manage groups:
 #  mkgroup, rmgroup, lsgroup, chgroup
 #
 # Author::    Hector Rivas Gandara <keymon@gmail.com>
 #
 require 'puppet/provider/aixobject'
 
 Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
   desc "Group management for AIX."
 
   # This will the default provider for this platform
   defaultfor :operatingsystem => :aix
   confine :operatingsystem => :aix
 
   # Provider features
   has_features :manages_aix_lam
   has_features :manages_members
 
   # Commands that manage the element
   commands :list      => "/usr/sbin/lsgroup"
   commands :add       => "/usr/bin/mkgroup"
   commands :delete    => "/usr/sbin/rmgroup"
   commands :modify    => "/usr/bin/chgroup"
 
   # Group attributes to ignore
   def self.attribute_ignore
     []
   end
 
   # AIX attributes to properties mapping.
   #
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
   #  :puppet_prop   Puppet propertie name
   #  :to            Method to adapt puppet property to aix command value. Optional.
   #  :from          Method to adapt aix command value to puppet property. Optional
   self.attribute_mapping = [
     #:name => :name,
     {:aix_attr => :id,       :puppet_prop => :gid },
     {:aix_attr => :users,    :puppet_prop => :members,
       :from => :users_from_attr},
     {:aix_attr => :attributes, :puppet_prop => :attributes},
   ]
 
   #--------------
   # Command definition
 
   # Return the IA module arguments based on the resource param ia_load_module
   def get_ia_module_args
     if @resource[:ia_load_module]
       ["-R", @resource[:ia_load_module].to_s]
     else
       []
     end
   end
 
   def lscmd(value=@resource[:name])
     [self.class.command(:list)] +
       self.get_ia_module_args +
       [ value]
   end
 
   def lsallcmd()
     lscmd("ALL")
   end
 
   def addcmd(extra_attrs = [])
     # Here we use the @resource.to_hash to get the list of provided parameters
     # Puppet does not call to self.<parameter>= method if it does not exists.
     #
     # It gets an extra list of arguments to add to the user.
     [self.class.command(:add) ] +
       self.get_ia_module_args +
       self.hash2args(@resource.to_hash) +
       extra_attrs + [@resource[:name]]
   end
 
   def modifycmd(hash = property_hash)
     args = self.hash2args(hash)
     return nil if args.empty?
 
     [self.class.command(:modify)] +
       self.get_ia_module_args +
       args + [@resource[:name]]
   end
 
   def deletecmd
     [self.class.command(:delete)] +
       self.get_ia_module_args +
       [@resource[:name]]
   end
 
 
   #--------------
   # Overwrite get_arguments to add the attributes arguments
   def get_arguments(key, value, mapping, objectinfo)
     # In the case of attributes, return a list of key=vlaue
     if key == :attributes
       raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
         unless value and value.is_a? Hash
       return value.select { |k,v| true }.map { |pair| pair.join("=") }
     end
     super(key, value, mapping, objectinfo)
   end
 
   def filter_attributes(hash)
     # Return only not managed attributtes.
     hash.select {
         |k,v| !self.class.attribute_mapping_from.include?(k) and
                 !self.class.attribute_ignore.include?(k)
       }.inject({}) {
-        |hash, array| hash[array[0]] = array[1]; hash
+        |h, array| h[array[0]] = array[1]; h
       }
   end
 
   def attributes
     filter_attributes(getosinfo(false))
   end
 
   def attributes=(attr_hash)
     #self.class.validate(param, value)
     param = :attributes
     cmd = modifycmd({param => filter_attributes(attr_hash)})
     if cmd
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail
         raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
       end
     end
   end
 
   # Force convert users it a list.
   def users_from_attr(value)
     (value.is_a? String) ? value.split(',') : value
   end
 
 
 end
diff --git a/lib/puppet/provider/package/pkgin.rb b/lib/puppet/provider/package/pkgin.rb
index 5cdb858d5..c3bdc62c7 100644
--- a/lib/puppet/provider/package/pkgin.rb
+++ b/lib/puppet/provider/package/pkgin.rb
@@ -1,87 +1,87 @@
 require "puppet/provider/package"
 
 Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package do
   desc "Package management using pkgin, a binary package manager for pkgsrc."
 
   commands :pkgin => "pkgin"
 
   defaultfor :operatingsystem => [ :dragonfly , :smartos ]
 
   has_feature :installable, :uninstallable, :upgradeable, :versionable
 
   def self.parse_pkgin_line(package)
 
     # e.g.
     #   vim-7.2.446 =        Vim editor (vi clone) without GUI
     match, name, version, status = *package.match(/(\S+)-(\S+)(?: (=|>|<))?\s+.+$/)
     if match
       {
         :name     => name,
         :status   => status,
         :ensure   => version
       }
     end
   end
 
   def self.prefetch(packages)
     super
     # Withouth -f, no fresh pkg_summary files are downloaded
     pkgin("-yf", :update)
   end
 
   def self.instances
     pkgin(:list).split("\n").map do |package|
       new(parse_pkgin_line(package))
     end
   end
 
   def query
     packages = parse_pkgsearch_line
 
     if packages.empty?
       if @resource[:ensure] == :absent
         notice "declared as absent but unavailable #{@resource.file}:#{resource.line}"
         return false
       else
         @resource.fail "No candidate to be installed"
       end
     end
 
     packages.first.update( :ensure => :absent )
   end
 
   def parse_pkgsearch_line
     packages = pkgin(:search, resource[:name]).split("\n")
 
     return [] if packages.length == 1
 
     # Remove the last three lines of help text.
     packages.slice!(-4, 4)
 
     pkglist = packages.map{ |line| self.class.parse_pkgin_line(line) }
     pkglist.select{ |package| resource[:name] == package[:name] }
   end
 
   def install
     if String === @resource[:ensure]
       pkgin("-y", :install, "#{resource[:name]}-#{resource[:ensure]}")
     else
       pkgin("-y", :install, resource[:name])
     end
   end
 
   def uninstall
     pkgin("-y", :remove, resource[:name])
   end
 
   def latest
-    package = parse_pkgsearch_line.detect{ |package| package[:status] == '<' }
+    package = parse_pkgsearch_line.detect{ |p| p[:status] == '<' }
     return properties[:ensure] if not package
     return package[:ensure]
   end
 
   def update
     pkgin("-y", :install, resource[:name])
   end
 
 end
diff --git a/lib/puppet/provider/service/upstart.rb b/lib/puppet/provider/service/upstart.rb
index 548341a89..191b04774 100644
--- a/lib/puppet/provider/service/upstart.rb
+++ b/lib/puppet/provider/service/upstart.rb
@@ -1,361 +1,361 @@
 require 'semver'
 
 Puppet::Type.type(:service).provide :upstart, :parent => :debian do
   START_ON = /^\s*start\s+on/
   COMMENTED_START_ON = /^\s*#+\s*start\s+on/
   MANUAL   = /^\s*manual\s*$/
 
   desc "Ubuntu service management with `upstart`.
 
   This provider manages `upstart` jobs on Ubuntu. For `upstart` documentation,
   see <http://upstart.ubuntu.com/>.
   "
 
   confine :any => [
     Facter.value(:operatingsystem) == 'Ubuntu',
     (Facter.value(:osfamily) == 'RedHat' and Facter.value(:operatingsystemrelease) =~ /^6\./),
     Facter.value(:operatingsystem) == 'Amazon',
     Facter.value(:operatingsystem) == 'LinuxMint',
   ]
 
   defaultfor :operatingsystem => :ubuntu
 
   commands :start   => "/sbin/start",
            :stop    => "/sbin/stop",
            :restart => "/sbin/restart",
            :status_exec  => "/sbin/status",
            :initctl => "/sbin/initctl"
 
   # upstart developer haven't implemented initctl enable/disable yet:
   # http://www.linuxplanet.com/linuxplanet/tutorials/7033/2/
   has_feature :enableable
 
   def self.instances
     self.get_services(self.excludes) # Take exclude list from init provider
   end
 
   def self.excludes
     excludes = super
     if Facter.value(:osfamily) == 'RedHat'
       # Puppet cannot deal with services that have instances, so we have to
       # ignore these services using instances on redhat based systems.
       excludes += %w[serial tty]
     end
 
     excludes
   end
 
 
   def self.get_services(exclude=[])
     instances = []
     execpipe("#{command(:initctl)} list") { |process|
       process.each_line { |line|
         # needs special handling of services such as network-interface:
         # initctl list:
         # network-interface (lo) start/running
         # network-interface (eth0) start/running
         # network-interface-security start/running
         name = \
           if matcher = line.match(/^(network-interface)\s\(([^\)]+)\)/)
             "#{matcher[1]} INTERFACE=#{matcher[2]}"
           elsif matcher = line.match(/^(network-interface-security)\s\(([^\)]+)\)/)
             "#{matcher[1]} JOB=#{matcher[2]}"
           else
             line.split.first
           end
         instances << new(:name => name)
       }
     }
     instances.reject { |instance| exclude.include?(instance.name) }
   end
 
   def self.defpath
     ["/etc/init", "/etc/init.d"]
   end
 
   def upstart_version
     @upstart_version ||= initctl("--version").match(/initctl \(upstart ([^\)]*)\)/)[1]
   end
 
   # Where is our override script?
   def overscript
     @overscript ||= initscript.gsub(/\.conf$/,".override")
   end
 
   def search(name)
     # Search prefers .conf as that is what upstart uses
     [".conf", "", ".sh"].each do |suffix|
       paths.each do |path|
         service_name = name.match(/^(\S+)/)[1]
         fqname = File.join(path, service_name + suffix)
         if Puppet::FileSystem.exist?(fqname)
           return fqname
         end
 
         self.debug("Could not find #{name}#{suffix} in #{path}")
       end
     end
 
     raise Puppet::Error, "Could not find init script or upstart conf file for '#{name}'"
   end
 
   def enabled?
     return super if not is_upstart?
 
     script_contents = read_script_from(initscript)
     if version_is_pre_0_6_7
       enabled_pre_0_6_7?(script_contents)
     elsif version_is_pre_0_9_0
       enabled_pre_0_9_0?(script_contents)
     elsif version_is_post_0_9_0
       enabled_post_0_9_0?(script_contents, read_override_file)
     end
   end
 
   def enable
     return super if not is_upstart?
 
     script_text = read_script_from(initscript)
     if version_is_pre_0_9_0
       enable_pre_0_9_0(script_text)
     else
       enable_post_0_9_0(script_text, read_override_file)
     end
   end
 
   def disable
     return super if not is_upstart?
 
     script_text = read_script_from(initscript)
     if version_is_pre_0_6_7
       disable_pre_0_6_7(script_text)
     elsif version_is_pre_0_9_0
       disable_pre_0_9_0(script_text)
     elsif version_is_post_0_9_0
       disable_post_0_9_0(read_override_file)
     end
   end
 
   def startcmd
     is_upstart? ? [command(:start), @resource[:name]] : super
   end
 
   def stopcmd
     is_upstart? ? [command(:stop),  @resource[:name]] : super
   end
 
   def restartcmd
     is_upstart? ? (@resource[:hasrestart] == :true) && [command(:restart), @resource[:name]] : super
   end
 
   def statuscmd
     is_upstart? ? nil : super #this is because upstart is broken with its return codes
   end
 
   def status
     if (@resource[:hasstatus] == :false) ||
         @resource[:status] ||
         ! is_upstart?
       return super
     end
 
     output = status_exec(@resource[:name].split)
     if output =~ /start\//
       return :running
     else
       return :stopped
     end
   end
 
 private
   def is_upstart?(script = initscript)
     Puppet::FileSystem.exist?(script) && script.match(/\/etc\/init\/\S+\.conf/)
   end
 
   def version_is_pre_0_6_7
     Puppet::Util::Package.versioncmp(upstart_version, "0.6.7") == -1
   end
 
   def version_is_pre_0_9_0
     Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") == -1
   end
 
   def version_is_post_0_9_0
     Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") >= 0
   end
 
   def enabled_pre_0_6_7?(script_text)
     # Upstart version < 0.6.7 means no manual stanza.
     if script_text.match(START_ON)
       return :true
     else
       return :false
     end
   end
 
   def enabled_pre_0_9_0?(script_text)
     # Upstart version < 0.9.0 means no override files
     # So we check to see if an uncommented start on or manual stanza is the last one in the file
     # The last one in the file wins.
     enabled = :false
     script_text.each_line do |line|
       if line.match(START_ON)
         enabled = :true
       elsif line.match(MANUAL)
         enabled = :false
       end
     end
     enabled
   end
 
   def enabled_post_0_9_0?(script_text, over_text)
     # This version has manual stanzas and override files
     # So we check to see if an uncommented start on or manual stanza is the last one in the
     # conf file and any override files. The last one in the file wins.
     enabled = :false
 
     script_text.each_line do |line|
       if line.match(START_ON)
         enabled = :true
       elsif line.match(MANUAL)
         enabled = :false
       end
     end
     over_text.each_line do |line|
       if line.match(START_ON)
         enabled = :true
       elsif line.match(MANUAL)
         enabled = :false
       end
     end if over_text
     enabled
   end
 
   def enable_pre_0_9_0(text)
     # We also need to remove any manual stanzas to ensure that it is enabled
     text = remove_manual_from(text)
 
     if enabled_pre_0_9_0?(text) == :false
       enabled_script =
         if text.match(COMMENTED_START_ON)
           uncomment_start_block_in(text)
         else
           add_default_start_to(text)
         end
     else
       enabled_script = text
     end
 
     write_script_to(initscript, enabled_script)
   end
 
   def enable_post_0_9_0(script_text, over_text)
     over_text = remove_manual_from(over_text)
 
     if enabled_post_0_9_0?(script_text, over_text) == :false
       if script_text.match(START_ON)
         over_text << extract_start_on_block_from(script_text)
       else
         over_text << "\nstart on runlevel [2,3,4,5]"
       end
     end
 
     write_script_to(overscript, over_text)
   end
 
   def disable_pre_0_6_7(script_text)
     disabled_script = comment_start_block_in(script_text)
     write_script_to(initscript, disabled_script)
   end
 
   def disable_pre_0_9_0(script_text)
     write_script_to(initscript, ensure_disabled_with_manual(script_text))
   end
 
   def disable_post_0_9_0(over_text)
     write_script_to(overscript, ensure_disabled_with_manual(over_text))
   end
 
   def read_override_file
     if Puppet::FileSystem.exist?(overscript)
       read_script_from(overscript)
     else
       ""
     end
   end
 
   def uncomment(line)
     line.gsub(/^(\s*)#+/, '\1')
   end
 
   def remove_trailing_comments_from_commented_line_of(line)
     line.gsub(/^(\s*#+\s*[^#]*).*/, '\1')
   end
 
   def remove_trailing_comments_from(line)
     line.gsub(/^(\s*[^#]*).*/, '\1')
   end
 
   def unbalanced_parens_on(line)
     line.count('(') - line.count(')')
   end
 
   def remove_manual_from(text)
     text.gsub(MANUAL, "")
   end
 
   def comment_start_block_in(text)
     parens = 0
     text.lines.map do |line|
       if line.match(START_ON) || parens > 0
         # If there are more opening parens than closing parens, we need to comment out a multiline 'start on' stanza
         parens += unbalanced_parens_on(remove_trailing_comments_from(line))
         "#" + line
       else
         line
       end
     end.join('')
   end
 
   def uncomment_start_block_in(text)
     parens = 0
     text.lines.map do |line|
       if line.match(COMMENTED_START_ON) || parens > 0
         parens += unbalanced_parens_on(remove_trailing_comments_from_commented_line_of(line))
         uncomment(line)
       else
         line
       end
     end.join('')
   end
 
   def extract_start_on_block_from(text)
     parens = 0
     text.lines.map do |line|
       if line.match(START_ON) || parens > 0
         parens += unbalanced_parens_on(remove_trailing_comments_from(line))
         line
       end
     end.join('')
   end
 
   def add_default_start_to(text)
     text + "\nstart on runlevel [2,3,4,5]"
   end
 
   def ensure_disabled_with_manual(text)
     remove_manual_from(text) + "\nmanual"
   end
 
   def read_script_from(filename)
     File.open(filename) do |file|
       file.read
     end
   end
 
   def write_script_to(file, text)
-    Puppet::Util.replace_file(file, 0644) do |file|
-      file.write(text)
+    Puppet::Util.replace_file(file, 0644) do |f|
+      f.write(text)
     end
   end
 end
diff --git a/lib/puppet/provider/user/aix.rb b/lib/puppet/provider/user/aix.rb
index e75763a0d..2114971b5 100644
--- a/lib/puppet/provider/user/aix.rb
+++ b/lib/puppet/provider/user/aix.rb
@@ -1,369 +1,369 @@
 #
 # User Puppet provider for AIX. It uses standard commands to manage users:
 #  mkuser, rmuser, lsuser, chuser
 #
 # Notes:
 # - AIX users can have expiry date defined with minute granularity,
 #   but puppet does not allow it. There is a ticket open for that (#5431)
 # - AIX maximum password age is in WEEKs, not days
 #
 # See  http://docs.puppetlabs.com/guides/provider_development.html
 # for more information
 #
 # Author::    Hector Rivas Gandara <keymon@gmail.com>
 #
 require 'puppet/provider/aixobject'
 require 'tempfile'
 require 'date'
 
 Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   desc "User management for AIX."
 
   # This will the default provider for this platform
   defaultfor :operatingsystem => :aix
   confine :operatingsystem => :aix
 
   # Commands that manage the element
   commands :list      => "/usr/sbin/lsuser"
   commands :add       => "/usr/bin/mkuser"
   commands :delete    => "/usr/sbin/rmuser"
   commands :modify    => "/usr/bin/chuser"
 
   commands :lsgroup   => "/usr/sbin/lsgroup"
   commands :chpasswd  => "/bin/chpasswd"
 
   # Provider features
   has_features :manages_aix_lam
   has_features :manages_homedir, :manages_passwords, :manages_shell
   has_features :manages_expiry,  :manages_password_age
 
   # Attribute verification (TODO)
   #verify :gid, "GID must be a string or int of a valid group" do |value|
   #  value.is_a? String || value.is_a? Integer
   #end
   #
   #verify :groups, "Groups must be comma-separated" do |value|
   #  value !~ /\s/
   #end
 
   # User attributes to ignore from AIX output.
   def self.attribute_ignore
     ["name"]
   end
 
   # AIX attributes to properties mapping.
   #
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
   #  :puppet_prop   Puppet propertie name
   #  :to            Method to adapt puppet property to aix command value. Optional.
   #  :from          Method to adapt aix command value to puppet property. Optional
   self.attribute_mapping = [
     {:aix_attr => :pgrp,       :puppet_prop => :gid,
                                 :to => :gid_to_attr,
                                 :from => :gid_from_attr },
     {:aix_attr => :id,         :puppet_prop => :uid},
     {:aix_attr => :groups,     :puppet_prop => :groups},
     {:aix_attr => :home,       :puppet_prop => :home},
     {:aix_attr => :shell,      :puppet_prop => :shell},
     {:aix_attr => :expires,    :puppet_prop => :expiry,
                                 :to => :expiry_to_attr,
                                 :from => :expiry_from_attr },
     {:aix_attr => :maxage,     :puppet_prop => :password_max_age},
     {:aix_attr => :minage,     :puppet_prop => :password_min_age},
     {:aix_attr => :attributes, :puppet_prop => :attributes},
     { :aix_attr => :gecos,      :puppet_prop => :comment },
   ]
 
   #--------------
   # Command definition
 
   # Return the IA module arguments based on the resource param ia_load_module
   def get_ia_module_args
     if @resource[:ia_load_module]
       ["-R", @resource[:ia_load_module].to_s]
     else
       []
     end
   end
 
   # List groups and Ids
   def lsgroupscmd(value=@resource[:name])
     [command(:lsgroup)] +
       self.get_ia_module_args +
       ["-a", "id", value]
   end
 
   def lscmd(value=@resource[:name])
     [self.class.command(:list), "-c"] + self.get_ia_module_args + [ value]
   end
 
   def lsallcmd()
     lscmd("ALL")
   end
 
   def addcmd(extra_attrs = [])
     # Here we use the @resource.to_hash to get the list of provided parameters
     # Puppet does not call to self.<parameter>= method if it does not exists.
     #
     # It gets an extra list of arguments to add to the user.
     [self.class.command(:add)] + self.get_ia_module_args +
       self.hash2args(@resource.to_hash) +
       extra_attrs + [@resource[:name]]
   end
 
   # Get modify command. Set translate=false if no mapping must be used.
   # Needed for special properties like "attributes"
   def modifycmd(hash = property_hash)
     args = self.hash2args(hash)
     return nil if args.empty?
 
     [self.class.command(:modify)] + self.get_ia_module_args +
       args + [@resource[:name]]
   end
 
   def deletecmd
     [self.class.command(:delete)] + self.get_ia_module_args + [@resource[:name]]
   end
 
   #--------------
   # We overwrite the create function to change the password after creation.
   def create
     super
     # Reset the password if needed
     self.password = @resource[:password] if @resource[:password]
   end
 
 
   def get_arguments(key, value, mapping, objectinfo)
     # In the case of attributes, return a list of key=vlaue
     if key == :attributes
       raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
         unless value and value.is_a? Hash
       return value.map { |k,v| k.to_s.strip + "=" + v.to_s.strip}
     end
 
     super(key, value, mapping, objectinfo)
   end
 
   # Get the groupname from its id
   def groupname_by_id(gid)
     groupname=nil
     execute(lsgroupscmd("ALL")).each_line { |entry|
       attrs = self.parse_attr_list(entry, nil)
       if attrs and attrs.include? :id and gid == attrs[:id].to_i
         groupname = entry.split(" ")[0]
       end
     }
     groupname
   end
 
   # Get the groupname from its id
   def groupid_by_name(groupname)
     attrs = self.parse_attr_list(execute(lsgroupscmd(groupname)).split("\n")[0], nil)
     attrs ? attrs[:id].to_i : nil
   end
 
   # Check that a group exists and is valid
   def verify_group(value)
     if value.is_a? Integer or value.is_a? Fixnum
       groupname = groupname_by_id(value)
       raise ArgumentError, "AIX group must be a valid existing group" unless groupname
     else
       raise ArgumentError, "AIX group must be a valid existing group" unless groupid_by_name(value)
       groupname = value
     end
     groupname
   end
 
   # The user's primary group.  Can be specified numerically or by name.
   def gid_to_attr(value)
     verify_group(value)
   end
 
   # Get the group gid from its name
   def gid_from_attr(value)
     groupid_by_name(value)
   end
 
   # The expiry date for this user. Must be provided in
   # a zero padded YYYY-MM-DD HH:MM format
   def expiry_to_attr(value)
     # For chuser the expires parameter is a 10-character string in the MMDDhhmmyy format
     # that is,"%m%d%H%M%y"
     newdate = '0'
     if value.is_a? String and value!="0000-00-00"
       d = DateTime.parse(value, "%Y-%m-%d %H:%M")
       newdate = d.strftime("%m%d%H%M%y")
     end
     newdate
   end
 
   def expiry_from_attr(value)
     if value =~ /(..)(..)(..)(..)(..)/
       #d= DateTime.parse("20#{$5}-#{$1}-#{$2} #{$3}:#{$4}")
       #expiry_date = d.strftime("%Y-%m-%d %H:%M")
       #expiry_date = d.strftime("%Y-%m-%d")
       expiry_date = "20#{$5}-#{$1}-#{$2}"
     else
       Puppet.warn("Could not convert AIX expires date '#{value}' on #{@resource.class.name}[#{@resource.name}]") \
         unless value == '0'
       expiry_date = :absent
     end
     expiry_date
   end
 
   def open_security_passwd
     # helper method for tests
     File.open("/etc/security/passwd", 'r')
   end
 
   #--------------------------------
   # Getter and Setter
   # When the provider is initialized, create getter/setter methods for each
   # property our resource type supports.
   # If setter or getter already defined it will not be overwritten
 
   #- **password**
   #    The user's password, in whatever encrypted format the local machine
   #    requires. Be sure to enclose any value that includes a dollar sign ($)
   #    in single quotes (').  Requires features manages_passwords.
   #
   # Retrieve the password parsing directly the /etc/security/passwd
   def password
     password = :absent
     user = @resource[:name]
     f = open_security_passwd
     # Skip to the user
     f.each_line { |l| break if l  =~ /^#{user}:\s*$/ }
     if ! f.eof?
       f.each_line { |l|
         # If there is a new user stanza, stop
         break if l  =~ /^\S*:\s*$/
         # If the password= entry is found, return it, stripping trailing space
         if l  =~ /^\s*password\s*=\s*(\S*)\s*$/
           password = $1; break;
         end
       }
     end
     f.close()
     return password
   end
 
   def password=(value)
     user = @resource[:name]
 
     # Puppet execute does not support strings as input, only files.
     tmpfile = Tempfile.new('puppet_#{user}_pw')
     tmpfile << "#{user}:#{value}\n"
     tmpfile.close()
 
     # Options '-e', '-c', use encrypted password and clear flags
     # Must receive "user:enc_password" as input
     # command, arguments = {:failonfail => true, :combine => true}
     # Fix for bugs #11200 and #10915
     cmd = [self.class.command(:chpasswd), get_ia_module_args, '-e', '-c', user].flatten
     begin
       output = execute(cmd, {:failonfail => false, :combine => true, :stdinfile => tmpfile.path })
       # chpasswd can return 1, even on success (at least on AIX 6.1); empty output indicates success
       if output != ""
         raise Puppet::ExecutionFailure, "chpasswd said #{output}"
       end
     rescue Puppet::ExecutionFailure  => detail
       raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
     ensure
       tmpfile.delete()
     end
   end
 
   def managed_attribute_keys(hash)
     managed_attributes ||= @resource.original_parameters[:attributes] || hash.keys.map{|k| k.to_s}
     managed_attributes.map {|attr| key, value = attr.split("="); key.strip.to_sym}
   end
 
   def should_include?(key, managed_keys)
     !self.class.attribute_mapping_from.include?(key) and
             !self.class.attribute_ignore.include?(key) and
             managed_keys.include?(key)
   end
 
   def filter_attributes(hash)
     # Return only managed attributtes.
     managed_keys = managed_attribute_keys(hash)
     results = hash.select {
         |k,v| should_include?(k, managed_keys)
       }.inject({}) {
-        |hash, array| hash[array[0]] = array[1]; hash
+        |h, array| h[array[0]] = array[1]; h
       }
     results
   end
 
   def attributes
     filter_attributes(getosinfo(false))
   end
 
   def attributes=(attr_hash)
     #self.class.validate(param, value)
     param = :attributes
     cmd = modifycmd({param => filter_attributes(attr_hash)})
     if cmd
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail
         raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
       end
     end
   end
 
   # UNSUPPORTED
   #- **profile_membership**
   #    Whether specified roles should be treated as the only roles
   #    of which the user is a member or whether they should merely
   #    be treated as the minimum membership list.  Valid values are
   #    `inclusive`, `minimum`.
   # UNSUPPORTED
   #- **profiles**
   #    The profiles the user has.  Multiple profiles should be
   #    specified as an array.  Requires features manages_solaris_rbac.
   # UNSUPPORTED
   #- **project**
   #    The name of the project associated with a user  Requires features
   #    manages_solaris_rbac.
   # UNSUPPORTED
   #- **role_membership**
   #    Whether specified roles should be treated as the only roles
   #    of which the user is a member or whether they should merely
   #    be treated as the minimum membership list.  Valid values are
   #    `inclusive`, `minimum`.
   # UNSUPPORTED
   #- **roles**
   #    The roles the user has.  Multiple roles should be
   #    specified as an array.  Requires features manages_solaris_rbac.
   # UNSUPPORTED
   #- **key_membership**
   #    Whether specified key value pairs should be treated as the only
   #    attributes
   #    of the user or whether they should merely
   #    be treated as the minimum list.  Valid values are `inclusive`,
   #    `minimum`.
   # UNSUPPORTED
   #- **keys**
   #    Specify user attributes in an array of keyvalue pairs  Requires features
   #    manages_solaris_rbac.
   # UNSUPPORTED
   #- **allowdupe**
   #  Whether to allow duplicate UIDs.  Valid values are `true`, `false`.
   # UNSUPPORTED
   #- **auths**
   #    The auths the user has.  Multiple auths should be
   #    specified as an array.  Requires features manages_solaris_rbac.
   # UNSUPPORTED
   #- **auth_membership**
   #    Whether specified auths should be treated as the only auths
   #    of which the user is a member or whether they should merely
   #    be treated as the minimum membership list.  Valid values are
   #    `inclusive`, `minimum`.
   # UNSUPPORTED
 
 end
diff --git a/lib/puppet/reference/type.rb b/lib/puppet/reference/type.rb
index 73db98c4e..9ab0a9a0f 100644
--- a/lib/puppet/reference/type.rb
+++ b/lib/puppet/reference/type.rb
@@ -1,115 +1,114 @@
 Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :component
     next if type.name == :whit
     types[type.name] = type
   }
 
   str = %{
 
 ## Resource Types
 
 - The *namevar* is the parameter used to uniquely identify a type instance.
   This is the parameter that gets assigned when a string is provided before
   the colon in a type declaration.  In general, only developers will need to
   worry about which parameter is the `namevar`.
 
   In the following code:
 
       file { "/etc/passwd":
         owner => "root",
         group => "root",
         mode  => "0644"
       }
 
   `/etc/passwd` is considered the title of the file object (used for things like
   dependency handling), and because `path` is the namevar for `file`, that
   string is assigned to the `path` parameter.
 
 - *Parameters* determine the specific configuration of the instance.  They either
   directly modify the system (internally, these are called properties) or they affect
   how the instance behaves (e.g., adding a search path for `exec` instances or determining recursion on `file` instances).
 
 - *Providers* provide low-level functionality for a given resource type.  This is
   usually in the form of calling out to external commands.
 
   When required binaries are specified for providers, fully qualifed paths
   indicate that the binary must exist at that specific path and unqualified
   binaries indicate that Puppet will search for the binary using the shell
   path.
 
 - *Features* are abilities that some providers might not support.  You can use the list
   of supported features to determine how a given provider can be used.
 
   Resource types define features they can use, and providers can be tested to see
   which features they provide.
 
     }
 
     types.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |name,type|
 
       str << "
 
 ----------------
 
 "
 
   str << markdown_header(name, 3)
   str << scrub(type.doc) + "\n\n"
 
   # Handle the feature docs.
   if featuredocs = type.featuredocs
     str << markdown_header("Features", 4)
     str << featuredocs
     end
 
     docs = {}
     type.validproperties.sort { |a,b|
       a.to_s <=> b.to_s
     }.reject { |sname|
       property = type.propertybyname(sname)
       property.nodoc
     }.each { |sname|
       property = type.propertybyname(sname)
 
       raise "Could not retrieve property #{sname} on type #{type.name}" unless property
 
       doc = nil
       unless doc = property.doc
         $stderr.puts "No docs for #{type}[#{sname}]"
         next
       end
       doc = doc.dup
       tmp = doc
       tmp = scrub(tmp)
 
       docs[sname]  = tmp
     }
 
     str << markdown_header("Parameters", 4) + "\n"
     type.parameters.sort { |a,b|
       a.to_s <=> b.to_s
-    }.each { |name,param|
-      #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
-      docs[name] = scrub(type.paramdoc(name))
+    }.each { |type_name, param|
+      docs[type_name] = scrub(type.paramdoc(type_name))
     }
 
     additional_key_attributes = type.key_attributes - [:name]
     docs.sort { |a, b|
       a[0].to_s <=> b[0].to_s
-    }.each { |name, doc|
-      if additional_key_attributes.include?(name)
+    }.each { |type_name, doc|
+      if additional_key_attributes.include?(type_name)
         doc = "(**Namevar:** If omitted, this parameter's value defaults to the resource's title.)\n\n" + doc
       end
-      str << markdown_definitionlist(name, doc)
+      str << markdown_definitionlist(type_name, doc)
     }
     str << "\n"
   }
 
   str
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 5d46807ca..97a1fb93d 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,183 +1,183 @@
 require 'puppet/parser/type_loader'
 require 'puppet/util/file_watcher'
 require 'puppet/util/warnings'
 
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
   include Puppet::Util::Warnings
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
     @notfound.clear
   end
 
   def initialize(env)
     @environment = env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
     @notfound = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
   end
 
   def import_ast(ast, modname)
     ast.instantiate(modname).each do |instance|
       add(instance)
     end
   end
 
   def inspect
     "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
   end
 
   def <<(thing)
     add(thing)
     self
   end
 
   def add(instance)
     if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
       other.merge(instance)
       return other
     end
     method = "add_#{instance.type}"
     send(method, instance)
     instance.resource_type_collection = self
     instance
   end
 
   def add_hostclass(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
     @hostclasses[instance.name] = instance
     instance
   end
 
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end
 
   def add_node(instance)
     dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
     @node_list << instance
     @nodes[instance.name] = instance
     instance
   end
 
   def loader
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
 
   def node(name)
     name = munge_name(name)
 
     if node = @nodes[name]
       return node
     end
 
-    @node_list.each do |node|
-      next unless node.name_is_regex?
-      return node if node.match(name)
+    @node_list.each do |n|
+      next unless n.name_is_regex?
+      return n if n.match(name)
     end
     nil
   end
 
   def node_exists?(name)
     @nodes[munge_name(name)]
   end
 
   def nodes?
     @nodes.length > 0
   end
 
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
     @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
   def find_node(name)
     @nodes[munge_name(name)]
   end
 
   def find_hostclass(name)
     find_or_load(name, :hostclass)
   end
 
   def find_definition(name)
     find_or_load(name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def parse_failed?
     @parse_failed
   end
 
   def version
     if !defined?(@version)
       if environment.config_version.nil? || environment.config_version == ""
         @version = Time.now.to_i
       else
         @version = Puppet::Util::Execution.execute([environment.config_version]).strip
       end
     end
 
     @version
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Execution of config_version command `#{environment.config_version}` failed: #{e.message}", e.backtrace
   end
 
   private
 
   COLON_COLON = "::".freeze
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
   def find_or_load(name, type)
     # Name is always absolute, but may start with :: which must be removed
     fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
 
     result = send(type, fqname)
     unless result
       if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
         # do not try to autoload if we already tried and it wasn't conclusive
         # as this is a time consuming operation. Warn the user.
         # Check first if debugging is on since the call to debug_once is expensive
         if Puppet[:debug]
           debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
         end
       else
         result = loader.try_load_fqname(type, fqname)
         @notfound[ fqname ] = result.nil?
       end
     end
     result
   end
 
   def munge_name(name)
     name.to_s.downcase
   end
 
   def dupe_check(instance, hash)
     return unless dupe = hash[instance.name]
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 end
diff --git a/lib/puppet/settings.rb b/lib/puppet/settings.rb
index 46be3c07c..fae03e340 100644
--- a/lib/puppet/settings.rb
+++ b/lib/puppet/settings.rb
@@ -1,1461 +1,1461 @@
 require 'puppet'
 require 'getoptlong'
 require 'puppet/util/watched_file'
 require 'puppet/util/command_line/puppet_option_parser'
 require 'forwardable'
 
 # The class for handling configuration files.
 class Puppet::Settings
   extend Forwardable
   include Enumerable
 
   require 'puppet/settings/errors'
   require 'puppet/settings/base_setting'
   require 'puppet/settings/string_setting'
   require 'puppet/settings/enum_setting'
   require 'puppet/settings/array_setting'
   require 'puppet/settings/file_setting'
   require 'puppet/settings/directory_setting'
   require 'puppet/settings/file_or_directory_setting'
   require 'puppet/settings/path_setting'
   require 'puppet/settings/boolean_setting'
   require 'puppet/settings/terminus_setting'
   require 'puppet/settings/duration_setting'
   require 'puppet/settings/ttl_setting'
   require 'puppet/settings/priority_setting'
   require 'puppet/settings/autosign_setting'
   require 'puppet/settings/config_file'
   require 'puppet/settings/value_translator'
   require 'puppet/settings/environment_conf'
 
   # local reference for convenience
   PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
 
   attr_accessor :files
   attr_reader :timer
 
   # These are the settings that every app is required to specify; there are
   # reasonable defaults defined in application.rb.
   REQUIRED_APP_SETTINGS = [:logdir, :confdir, :vardir]
 
   # The acceptable sections of the puppet.conf configuration file.
   ALLOWED_SECTION_NAMES = ['main', 'master', 'agent', 'user'].freeze
 
   # This method is intended for puppet internal use only; it is a convenience method that
   # returns reasonable application default settings values for a given run_mode.
   def self.app_defaults_for_run_mode(run_mode)
     {
         :name     => run_mode.to_s,
         :run_mode => run_mode.name,
         :confdir  => run_mode.conf_dir,
         :vardir   => run_mode.var_dir,
         :rundir   => run_mode.run_dir,
         :logdir   => run_mode.log_dir,
     }
   end
 
   def self.default_certname()
     hostname = hostname_fact
     domain = domain_fact
     if domain and domain != ""
       fqdn = [hostname, domain].join(".")
     else
       fqdn = hostname
     end
     fqdn.to_s.gsub(/\.$/, '')
   end
 
   def self.hostname_fact()
     Facter.value :hostname
   end
 
   def self.domain_fact()
     Facter.value :domain
   end
 
   def self.default_config_file_name
     "puppet.conf"
   end
 
   # Create a new collection of config settings.
   def initialize
     @config = {}
     @shortnames = {}
 
     @created = []
 
     # Keep track of set values.
     @value_sets = {
       :cli => Values.new(:cli, @config),
       :memory => Values.new(:memory, @config),
       :application_defaults => Values.new(:application_defaults, @config),
       :overridden_defaults => Values.new(:overridden_defaults, @config),
     }
     @configuration_file = nil
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
     @values = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
 
     @hooks_to_call_on_application_initialization = []
     @deprecated_setting_names = []
     @deprecated_settings_that_have_been_configured = []
 
     @translate = Puppet::Settings::ValueTranslator.new
     @config_file_parser = Puppet::Settings::ConfigFile.new(@translate)
   end
 
   # @param name [Symbol] The name of the setting to fetch
   # @return [Puppet::Settings::BaseSetting] The setting object
   def setting(name)
     @config[name]
   end
 
   # Retrieve a config value
   # @param param [Symbol] the name of the setting
   # @return [Object] the value of the setting
   # @api private
   def [](param)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Accessing '#{param}' as a setting is deprecated.")
     end
     value(param)
   end
 
   # Set a config value.  This doesn't set the defaults, it sets the value itself.
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new value of the setting
   # @api private
   def []=(param, value)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Modifying '#{param}' as a setting is deprecated.")
     end
     @value_sets[:memory].set(param, value)
     unsafe_flush_cache
   end
 
   # Create a new default value for the given setting. The default overrides are
   # higher precedence than the defaults given in defaults.rb, but lower
   # precedence than any other values for the setting. This allows one setting
   # `a` to change the default of setting `b`, but still allow a user to provide
   # a value for setting `b`.
   #
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new default value for the setting
   # @api private
   def override_default(param, value)
     @value_sets[:overridden_defaults].set(param, value)
     unsafe_flush_cache
   end
 
   # Generate the list of valid arguments, in a format that GetoptLong can
   # understand, and add them to the passed option list.
   def addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       setting.getopt_args.each { |args| options << args }
     }
 
     options
   end
 
   # Generate the list of valid arguments, in a format that OptionParser can
   # understand, and add them to the passed option list.
   def optparse_addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       options << setting.optparse_args
     }
 
     options
   end
 
   # Is our setting a boolean setting?
   def boolean?(param)
     param = param.to_sym
     @config.include?(param) and @config[param].kind_of?(BooleanSetting)
   end
 
   # Remove all set values, potentially skipping cli values.
   def clear
     unsafe_clear
   end
 
   # Remove all set values, potentially skipping cli values.
   def unsafe_clear(clear_cli = true, clear_application_defaults = false)
     if clear_application_defaults
       @value_sets[:application_defaults] = Values.new(:application_defaults, @config)
       @app_defaults_initialized = false
     end
 
     if clear_cli
       @value_sets[:cli] = Values.new(:cli, @config)
 
       # Only clear the 'used' values if we were explicitly asked to clear out
       #  :cli values; otherwise, it may be just a config file reparse,
       #  and we want to retain this cli values.
       @used = []
     end
 
     @value_sets[:memory] = Values.new(:memory, @config)
     @value_sets[:overridden_defaults] = Values.new(:overridden_defaults, @config)
 
     @deprecated_settings_that_have_been_configured.clear
     @values.clear
     @cache.clear
   end
   private :unsafe_clear
 
   # Clears all cached settings for a particular environment to ensure
   # that changes to environment.conf are reflected in the settings if
   # the environment timeout has expired.
   #
   # param [String, Symbol] environment the  name of environment to clear settings for
   #
   # @api private
   def clear_environment_settings(environment)
 
     if environment.nil?
       return
     end
 
     @cache[environment.to_sym].clear
     @values[environment.to_sym] = {}
   end
 
   # Clear @cache, @used and the Environment.
   #
   # Whenever an object is returned by Settings, a copy is stored in @cache.
   # As long as Setting attributes that determine the content of returned
   # objects remain unchanged, Settings can keep returning objects from @cache
   # without re-fetching or re-generating them.
   #
   # Whenever a Settings attribute changes, such as @values or @preferred_run_mode,
   # this method must be called to clear out the caches so that updated
   # objects will be returned.
   def flush_cache
     unsafe_flush_cache
   end
 
   def unsafe_flush_cache
     clearused
   end
   private :unsafe_flush_cache
 
   def clearused
     @cache.clear
     @used = []
   end
 
   def global_defaults_initialized?()
     @global_defaults_initialized
   end
 
   def initialize_global_settings(args = [])
     raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized?
 
     # The first two phases of the lifecycle of a puppet application are:
     # 1) Parse the command line options and handle any of them that are
     #    registered, defined "global" puppet settings (mostly from defaults.rb).
     # 2) Parse the puppet config file(s).
 
     parse_global_options(args)
     parse_config_files
 
     @global_defaults_initialized = true
   end
 
   # This method is called during application bootstrapping.  It is responsible for parsing all of the
   # command line options and initializing the settings accordingly.
   #
   # It will ignore options that are not defined in the global puppet settings list, because they may
   # be valid options for the specific application that we are about to launch... however, at this point
   # in the bootstrapping lifecycle, we don't yet know what that application is.
   def parse_global_options(args)
     # Create an option parser
     option_parser = PuppetOptionParser.new
     option_parser.ignore_invalid_options = true
 
     # Add all global options to it.
     self.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
         opt, val = Puppet::Settings.clean_opt(option[0], arg)
         handlearg(opt, val)
       end
     end
 
     option_parser.on('--run_mode',
                      "The effective 'run mode' of the application: master, agent, or user.",
                      :REQUIRED) do |arg|
       Puppet.settings.preferred_run_mode = arg
     end
 
     option_parser.parse(args)
 
     # remove run_mode options from the arguments so that later parses don't think
     # it is an unknown option.
     while option_index = args.index('--run_mode') do
       args.delete_at option_index
       args.delete_at option_index
     end
     args.reject! { |arg| arg.start_with? '--run_mode=' }
   end
   private :parse_global_options
 
   # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
   # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
   # "no-" prefix on flag/boolean options).
   #
   # @param [String] opt the command line option that we are munging
   # @param [String, TrueClass, FalseClass] val the value for the setting (as determined by the OptionParser)
   def self.clean_opt(opt, val)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !val
       opt = opt.gsub(/\[no-\]/,'no-')
     end
     # otherwise remove the [no-] prefix to not confuse everybody
     opt = opt.gsub(/\[no-\]/, '')
     [opt, val]
   end
 
 
   def app_defaults_initialized?
     @app_defaults_initialized
   end
 
   def initialize_app_defaults(app_defaults)
     REQUIRED_APP_SETTINGS.each do |key|
       raise SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key)
     end
 
     app_defaults.each do |key, value|
       if key == :run_mode
         self.preferred_run_mode = value
       else
         @value_sets[:application_defaults].set(key, value)
         unsafe_flush_cache
       end
     end
     apply_metadata
     call_hooks_deferred_to_application_initialization
     issue_deprecations
 
     @app_defaults_initialized = true
   end
 
   def call_hooks_deferred_to_application_initialization(options = {})
     @hooks_to_call_on_application_initialization.each do |setting|
       begin
         setting.handle(self.value(setting.name))
       rescue InterpolationError => err
         raise InterpolationError, err, err.backtrace unless options[:ignore_interpolation_dependency_errors]
         #swallow. We're not concerned if we can't call hooks because dependencies don't exist yet
         #we'll get another chance after application defaults are initialized
       end
     end
   end
   private :call_hooks_deferred_to_application_initialization
 
   # Return a value's description.
   def description(name)
     if obj = @config[name.to_sym]
       obj.desc
     else
       nil
     end
   end
 
   def_delegator :@config, :each
 
   # Iterate over each section name.
   def eachsection
     yielded = []
     @config.each do |name, object|
       section = object.section
       unless yielded.include? section
         yield section
         yielded << section
       end
     end
   end
 
   # Return an object by name.
   def setting(param)
     param = param.to_sym
     @config[param]
   end
 
   # Handle a command-line argument.
   def handlearg(opt, value = nil)
     @cache.clear
 
     if value.is_a?(FalseClass)
       value = "false"
     elsif value.is_a?(TrueClass)
       value = "true"
     end
 
     value &&= @translate[value]
     str = opt.sub(/^--/,'')
 
     bool = true
     newstr = str.sub(/^no-/, '')
     if newstr != str
       str = newstr
       bool = false
     end
     str = str.intern
 
     if @config[str].is_a?(Puppet::Settings::BooleanSetting)
       if value == "" or value.nil?
         value = bool
       end
     end
 
     if s = @config[str]
       @deprecated_settings_that_have_been_configured << s if s.completely_deprecated?
     end
 
     @value_sets[:cli].set(str, value)
     unsafe_flush_cache
   end
 
   def include?(name)
     name = name.intern if name.is_a? String
     @config.include?(name)
   end
 
   # check to see if a short name is already defined
   def shortinclude?(short)
     short = short.intern if name.is_a? String
     @shortnames.include?(short)
   end
 
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
     env = value(:environment)
     val = value(:configprint)
     if val == "all"
       hash = {}
       each do |name, obj|
         val = value(name,env)
         val = val.inspect if val == ""
         hash[name] = val
       end
-      hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
-        puts "#{name} = #{val}"
+      hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, v|
+        puts "#{name} = #{v}"
       end
     else
       val.split(/\s*,\s*/).sort.each do |v|
         if include?(v)
           #if there is only one value, just print it for back compatibility
           if v == val
             puts value(val,env)
             break
           end
           puts "#{v} = #{value(v,env)}"
         else
           puts "invalid setting: #{v}"
           return false
         end
       end
     end
     true
   end
 
   def generate_config
     puts to_config
     true
   end
 
   def generate_manifest
     puts to_manifest
     true
   end
 
   def print_configs
     return print_config_options if value(:configprint) != ""
     return generate_config if value(:genconfig)
     generate_manifest if value(:genmanifest)
   end
 
   def print_configs?
     (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
   end
 
   # Return a given object's file metadata.
   def metadata(param)
     if obj = @config[param.to_sym] and obj.is_a?(FileSetting)
       {
         :owner => obj.owner,
         :group => obj.group,
         :mode => obj.mode
       }.delete_if { |key, value| value.nil? }
     else
       nil
     end
   end
 
   # Make a directory with the appropriate user, group, and mode
   def mkdir(default)
     obj = get_config_file_default(default)
 
     Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
       mode = obj.mode || 0750
       Dir.mkdir(obj.value, mode)
     end
   end
 
   # The currently configured run mode that is preferred for constructing the application configuration.
   def preferred_run_mode
     @preferred_run_mode_name || :user
   end
 
   # PRIVATE!  This only exists because we need a hook to validate the run mode when it's being set, and
   #  it should never, ever, ever, ever be called from outside of this file.
   # This method is also called when --run_mode MODE is used on the command line to set the default
   #
   # @param mode [String|Symbol] the name of the mode to have in effect
   # @api private
   def preferred_run_mode=(mode)
     mode = mode.to_s.downcase.intern
     raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
     @preferred_run_mode_name = mode
     # Changing the run mode has far-reaching consequences. Flush any cached
     # settings so they will be re-generated.
     flush_cache
     mode
   end
 
   # Return all of the settings associated with a given section.
   def params(section = nil)
     if section
       section = section.intern if section.is_a? String
       @config.find_all { |name, obj|
         obj.section == section
       }.collect { |name, obj|
         name
       }
     else
       @config.keys
     end
   end
 
   def parse_config(text, file = "text")
     begin
       data = @config_file_parser.parse_file(file, text, ALLOWED_SECTION_NAMES)
     rescue => detail
       Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
       return
     end
 
     # If we get here and don't have any data, we just return and don't muck with the current state of the world.
     return if data.nil?
 
     # If we get here then we have some data, so we need to clear out any
     # previous settings that may have come from config files.
     unsafe_clear(false, false)
 
     # Screen settings which have been deprecated and removed from puppet.conf
     # but are still valid on the command line and/or in environment.conf
     screen_non_puppet_conf_settings(data)
 
     # Make note of deprecated settings we will warn about later in initialization
     record_deprecations_from_puppet_conf(data)
 
     # And now we can repopulate with the values from our last parsing of the config files.
     @configuration_file = data
 
     # Determine our environment, if we have one.
     if @config[:environment]
       env = self.value(:environment).to_sym
     else
       env = "none"
     end
 
     # Call any hooks we should be calling.
     value_sets = value_sets_for(env, preferred_run_mode)
     @config.values.select(&:has_hook?).each do |setting|
       value_sets.each do |source|
         if source.include?(setting.name)
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           if setting.call_hook_on_initialize?
             @hooks_to_call_on_application_initialization << setting
           else
             setting.handle(ChainedValues.new(
               preferred_run_mode,
               env,
               value_sets,
               @config).interpolate(setting.name))
           end
           break
         end
       end
     end
 
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
     apply_metadata
   end
 
   # Parse the configuration file.  Just provides thread safety.
   def parse_config_files
     file = which_configuration_file
     if Puppet::FileSystem.exist?(file)
       begin
         text = read_file(file)
       rescue => detail
         Puppet.log_exception(detail, "Could not load #{file}: #{detail}")
         return
       end
     else
       return
     end
 
     parse_config(text, file)
   end
   private :parse_config_files
 
   def main_config_file
     if explicit_config_file?
       return self[:config]
     else
       return File.join(Puppet::Util::RunMode[:master].conf_dir, config_file_name)
     end
   end
   private :main_config_file
 
   def user_config_file
     return File.join(Puppet::Util::RunMode[:user].conf_dir, config_file_name)
   end
   private :user_config_file
 
   # This method is here to get around some life-cycle issues.  We need to be
   # able to determine the config file name before the settings / defaults are
   # fully loaded.  However, we also need to respect any overrides of this value
   # that the user may have specified on the command line.
   #
   # The easiest way to do this is to attempt to read the setting, and if we
   # catch an error (meaning that it hasn't been set yet), we'll fall back to
   # the default value.
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
     rescue SettingsError
       # This just means that the setting wasn't explicitly set on the command line, so we will ignore it and
       #  fall through to the default name.
     end
     return self.class.default_config_file_name
   end
   private :config_file_name
 
   def apply_metadata
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     if @configuration_file
       searchpath(nil, preferred_run_mode).reverse.each do |source|
         if source.type == :section && section = @configuration_file.sections[source.name]
           apply_metadata_from_section(section)
         end
       end
     end
   end
   private :apply_metadata
 
   def apply_metadata_from_section(section)
     section.settings.each do |setting|
       if setting.has_metadata? && type = @config[setting.name]
         type.set_meta(setting.meta)
       end
     end
   end
 
   SETTING_TYPES = {
       :string     => StringSetting,
       :file       => FileSetting,
       :directory  => DirectorySetting,
       :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
       :terminus   => TerminusSetting,
       :duration   => DurationSetting,
       :ttl        => TTLSetting,
       :array      => ArraySetting,
       :enum       => EnumSetting,
       :priority   => PrioritySetting,
       :autosign   => AutosignSetting,
   }
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
   #
   # See #define_settings for documentation on the legal values for the ":type" option.
   def newsetting(hash)
     klass = nil
     hash[:section] = hash[:section].to_sym if hash[:section]
 
     if type = hash[:type]
       unless klass = SETTING_TYPES[type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
     else
       # The only implicit typing we still do for settings is to fall back to "String" type if they didn't explicitly
       # specify a type.  Personally I'd like to get rid of this too, and make the "type" option mandatory... but
       # there was a little resistance to taking things quite that far for now.  --cprice 2012-03-19
       klass = StringSetting
     end
     hash[:settings] = self
     setting = klass.new(hash)
 
     setting
   end
 
   # This has to be private, because it doesn't add the settings to @config
   private :newsetting
 
   # Iterate across all of the objects in a given section.
   def persection(section)
     section = section.to_sym
     self.each { |name, obj|
       if obj.section == section
         yield obj
       end
     }
   end
 
   # Reparse our config file, if necessary.
   def reparse_config_files
     if files
       if filename = any_files_changed?
         Puppet.notice "Config file #{filename} changed; triggering re-parse of all config files."
         parse_config_files
         reuse
       end
     end
   end
 
   def files
     return @files if @files
     @files = []
     [main_config_file, user_config_file].each do |path|
       if Puppet::FileSystem.exist?(path)
         @files << Puppet::Util::WatchedFile.new(path)
       end
     end
     @files
   end
   private :files
 
   # Checks to see if any of the config files have been modified
   # @return the filename of the first file that is found to have changed, or
   #   nil if no files have changed
   def any_files_changed?
     files.each do |file|
       return file.to_str if file.changed?
     end
     nil
   end
   private :any_files_changed?
 
   def reuse
     return unless defined?(@used)
     new = @used
     @used = []
     self.use(*new)
   end
 
   class SearchPathElement < Struct.new(:name, :type); end
 
   # The order in which to search for values.
   #
   # @param environment [String,Symbol] symbolic reference to an environment name
   # @param run_mode [Symbol] symbolic reference to a Puppet run mode
   # @return [Array<SearchPathElement>]
   # @api private
   def searchpath(environment = nil, run_mode = preferred_run_mode)
     searchpath = [
       SearchPathElement.new(:memory, :values),
       SearchPathElement.new(:cli, :values),
     ]
     searchpath << SearchPathElement.new(environment.intern, :environment) if environment
     searchpath << SearchPathElement.new(run_mode, :section) if run_mode
     searchpath << SearchPathElement.new(:main, :section)
     searchpath << SearchPathElement.new(:application_defaults, :values)
     searchpath << SearchPathElement.new(:overridden_defaults, :values)
   end
 
   # Get a list of objects per section
   def sectionlist
     sectionlist = []
     self.each { |name, obj|
       section = obj.section || "puppet"
       sections[section] ||= []
       sectionlist << section unless sectionlist.include?(section)
       sections[section] << obj
     }
 
     return sectionlist, sections
   end
 
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
     if self[:user]
       user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
       @service_user_available = user.exists?
     else
       @service_user_available = false
     end
   end
 
   def service_group_available?
     return @service_group_available if defined?(@service_group_available)
 
     if self[:group]
       group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure
 
       @service_group_available = group.exists?
     else
       @service_group_available = false
     end
   end
 
   # Allow later inspection to determine if the setting was set on the
   # command line, or through some other code path.  Used for the
   # `dns_alt_names` option during cert generate. --daniel 2011-10-18
   def set_by_cli?(param)
     param = param.to_sym
     !@value_sets[:cli].lookup(param).nil?
   end
 
   def set_value(param, value, type, options = {})
     Puppet.deprecation_warning("Puppet.settings.set_value is deprecated. Use Puppet[]= instead.")
     if @value_sets[type]
       @value_sets[type].set(param, value)
       unsafe_flush_cache
     end
   end
 
   # Deprecated; use #define_settings instead
   def setdefaults(section, defs)
     Puppet.deprecation_warning("'setdefaults' is deprecated and will be removed; please call 'define_settings' instead")
     define_settings(section, defs)
   end
 
   # Define a group of settings.
   #
   # @param [Symbol] section a symbol to use for grouping multiple settings together into a conceptual unit.  This value
   #   (and the conceptual separation) is not used very often; the main place where it will have a potential impact
   #   is when code calls Settings#use method.  See docs on that method for further details, but basically that method
   #   just attempts to do any preparation that may be necessary before code attempts to leverage the value of a particular
   #   setting.  This has the most impact for file/directory settings, where #use will attempt to "ensure" those
   #   files / directories.
   # @param [Hash[Hash]] defs the settings to be defined.  This argument is a hash of hashes; each key should be a symbol,
   #   which is basically the name of the setting that you are defining.  The value should be another hash that specifies
   #   the parameters for the particular setting.  Legal values include:
   #    [:default] => not required; this is the value for the setting if no other value is specified (via cli, config file, etc.)
   #       For string settings this may include "variables", demarcated with $ or ${} which will be interpolated with values of other settings.
   #       The default value may also be a Proc that will be called only once to evaluate the default when the setting's value is retrieved.
   #    [:desc] => required; a description of the setting, used in documentation / help generation
   #    [:type] => not required, but highly encouraged!  This specifies the data type that the setting represents.  If
   #       you do not specify it, it will default to "string".  Legal values include:
   #       :string - A generic string setting
   #       :boolean - A boolean setting; values are expected to be "true" or "false"
   #       :file - A (single) file path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :directory - A (single) directory path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :path - This is intended to be used for settings whose value can contain multiple directory paths, respresented
   #           as strings separated by the system path separator (e.g. system path, module path, etc.).
   #     [:mode] => an (optional) octal value to be used as the permissions/mode for :file and :directory settings
   #     [:owner] => optional owner username/uid for :file and :directory settings
   #     [:group] => optional group name/gid for :file and :directory settings
   #
   def define_settings(section, defs)
     section = section.to_sym
     call = []
     defs.each do |name, hash|
       raise ArgumentError, "setting definition for '#{name}' is not a hash!" unless hash.is_a? Hash
 
       name = name.to_sym
       hash[:name] = name
       hash[:section] = section
       raise ArgumentError, "Setting #{name} is already defined" if @config.include?(name)
       tryconfig = newsetting(hash)
       if short = tryconfig.short
         if other = @shortnames[short]
           raise ArgumentError, "Setting #{other.name} is already using short name '#{short}'"
         end
         @shortnames[short] = tryconfig
       end
       @config[name] = tryconfig
 
       # Collect the settings that need to have their hooks called immediately.
       # We have to collect them so that we can be sure we're fully initialized before
       # the hook is called.
       if tryconfig.has_hook?
         if tryconfig.call_hook_on_define?
           call << tryconfig
         elsif tryconfig.call_hook_on_initialize?
           @hooks_to_call_on_application_initialization << tryconfig
         end
       end
 
       @deprecated_setting_names << name if tryconfig.deprecated?
     end
 
     call.each do |setting|
       setting.handle(self.value(setting.name))
     end
   end
 
   # Convert the settings we manage into a catalog full of resources that model those settings.
   def to_catalog(*sections)
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings", Puppet::Node::Environment::NONE)
     @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key|
       file = @config[key]
       next if file.value.nil?
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
       next if catalog.resource(resource.ref)
 
       Puppet.debug {"Using settings: adding file resource '#{key}': '#{resource.inspect}'"}
 
       catalog.add_resource(resource)
     end
 
     add_user_resources(catalog, sections)
     add_environment_resources(catalog, sections)
 
     catalog
   end
 
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet.run_mode.name}.  Note that this file
 is likely to have unused settings in it; any setting that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 The file format supports octothorpe-commented lines, but not partial-line comments.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
     str += "[#{preferred_run_mode}]\n"
     eachsection do |section|
       persection(section) do |obj|
         str += obj.to_config + "\n" unless obj.name == :genconfig
       end
     end
 
     return str
   end
 
   # Convert to a parseable manifest
   def to_manifest
     catalog = to_catalog
     catalog.resource_refs.collect do |ref|
       catalog.resource(ref).to_manifest
     end.join("\n\n")
   end
 
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
     sections = sections.collect { |s| s.to_sym }
     sections = sections.reject { |s| @used.include?(s) }
 
     return if sections.empty?
 
     begin
       catalog = to_catalog(*sections).to_ral
     rescue => detail
       Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
     end
 
     catalog.host_config = false
     catalog.apply do |transaction|
       if transaction.any_failed?
         report = transaction.report
         status_failures = report.resource_statuses.values.select { |r| r.failed? }
         status_fail_msg = status_failures.
           collect(&:events).
           flatten.
           select { |event| event.status == 'failure' }.
           collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
 
         raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
       end
     end
 
     sections.each { |s| @used << s }
     @used.uniq!
   end
 
   def valid?(param)
     param = param.to_sym
     @config.has_key?(param)
   end
 
   def uninterpolated_value(param, environment = nil)
     Puppet.deprecation_warning("Puppet.settings.uninterpolated_value is deprecated. Use Puppet.settings.value instead")
     param = param.to_sym
     environment &&= environment.to_sym
 
     values(environment, self.preferred_run_mode).lookup(param)
   end
 
   # Retrieve an object that can be used for looking up values of configuration
   # settings.
   #
   # @param environment [Symbol] The name of the environment in which to lookup
   # @param section [Symbol] The name of the configuration section in which to lookup
   # @return [Puppet::Settings::ChainedValues] An object to perform lookups
   # @api public
   def values(environment, section)
     @values[environment][section] ||= ChainedValues.new(
       section,
       environment,
       value_sets_for(environment, section),
       @config)
   end
 
   # Find the correct value using our search path.
   #
   # @param param [String, Symbol] The value to look up
   # @param environment [String, Symbol] The environment to check for the value
   # @param bypass_interpolation [true, false] Whether to skip interpolation
   #
   # @return [Object] The looked up value
   #
   # @raise [InterpolationError]
   def value(param, environment = nil, bypass_interpolation = false)
     param = param.to_sym
     environment &&= environment.to_sym
 
     setting = @config[param]
 
     # Short circuit to nil for undefined settings.
     return nil if setting.nil?
 
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
     if @cache[environment||"none"].has_key?(param)
       return @cache[environment||"none"][param]
     elsif bypass_interpolation
       val = values(environment, self.preferred_run_mode).lookup(param)
     else
       val = values(environment, self.preferred_run_mode).interpolate(param)
     end
 
     @cache[environment||"none"][param] = val
     val
   end
 
   ##
   # (#15337) All of the logic to determine the configuration file to use
   #   should be centralized into this method.  The simplified approach is:
   #
   # 1. If there is an explicit configuration file, use that.  (--confdir or
   #    --config)
   # 2. If we're running as a root process, use the system puppet.conf
   #    (usually /etc/puppet/puppet.conf)
   # 3. Otherwise, use the user puppet.conf (usually ~/.puppet/puppet.conf)
   #
   # @api private
   # @todo this code duplicates {Puppet::Util::RunMode#which_dir} as described
   #   in {http://projects.puppetlabs.com/issues/16637 #16637}
   def which_configuration_file
     if explicit_config_file? or Puppet.features.root? then
       return main_config_file
     else
       return user_config_file
     end
   end
 
   # This method just turns a file into a new ConfigFile::Conf instance
   # @param file [String] absolute path to the configuration file
   # @return [Puppet::Settings::ConfigFile::Conf]
   # @api private
   def parse_file(file, allowed_sections = [])
     @config_file_parser.parse_file(file, read_file(file), allowed_sections)
   end
 
   private
 
   DEPRECATION_REFS = {
     # intentionally empty. This could be repopulated if we deprecate more settings
-    # and have reference links to associate with them 
+    # and have reference links to associate with them
   }.freeze
 
   def screen_non_puppet_conf_settings(puppet_conf)
     puppet_conf.sections.values.each do |section|
       forbidden = section.settings.select { |setting| Puppet::Settings::EnvironmentConf::ENVIRONMENT_CONF_ONLY_SETTINGS.include?(setting.name) }
       raise(SettingsError, "Cannot set #{forbidden.map { |s| s.name }.join(", ")} settings in puppet.conf") if !forbidden.empty?
     end
   end
 
   # Record that we want to issue a deprecation warning later in the application
   # initialization cycle when we have settings bootstrapped to the point where
   # we can read the Puppet[:disable_warnings] setting.
   #
   # We are only recording warnings applicable to settings set in puppet.conf
   # itself.
   def record_deprecations_from_puppet_conf(puppet_conf)
     puppet_conf.sections.values.each do |section|
       section.settings.each do |conf_setting|
         if setting = self.setting(conf_setting.name)
           @deprecated_settings_that_have_been_configured << setting if setting.deprecated?
         end
       end
     end
   end
 
   def issue_deprecations
     @deprecated_settings_that_have_been_configured.each do |setting|
       issue_deprecation_warning(setting)
     end
   end
 
   def issue_deprecation_warning(setting, msg = nil)
     name = setting.name
     ref = DEPRECATION_REFS.find { |params,reference| params.include?(name) }
     ref = ref[1] if ref
     case
     when msg
       msg << " #{ref}" if ref
       Puppet.deprecation_warning(msg)
     when setting.completely_deprecated?
       Puppet.deprecation_warning("Setting #{name} is deprecated. #{ref}", "setting-#{name}")
     when setting.allowed_on_commandline?
       Puppet.deprecation_warning("Setting #{name} is deprecated in puppet.conf. #{ref}", "puppet-conf-setting-#{name}")
     end
   end
 
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
       raise ArgumentError, "Unknown default #{default}"
     end
 
     raise ArgumentError, "Default #{default} is not a file" unless obj.is_a? FileSetting
 
     obj
   end
 
   def add_environment_resources(catalog, sections)
     path = self[:environmentpath]
     envdir = path.split(File::PATH_SEPARATOR).first if path
     configured_environment = self[:environment]
     if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
       configured_environment_path = File.join(envdir, configured_environment)
       if !Puppet::FileSystem.symlink?(configured_environment_path)
         catalog.add_resource(
           Puppet::Resource.new(:file,
                                configured_environment_path,
                                :parameters => { :ensure => 'directory' })
         )
       end
     end
   end
 
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
     return unless self[:mkusers]
 
     @config.each do |name, setting|
       next unless setting.respond_to?(:owner)
       next unless sections.nil? or sections.include?(setting.section)
 
       if user = setting.owner and user != "root" and catalog.resource(:user, user).nil?
         resource = Puppet::Resource.new(:user, user, :parameters => {:ensure => :present})
         resource[:gid] = self[:group] if self[:group]
         catalog.add_resource resource
       end
       if group = setting.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
         catalog.add_resource Puppet::Resource.new(:group, group, :parameters => {:ensure => :present})
       end
     end
   end
 
   # Yield each search source in turn.
   def value_sets_for(environment, mode)
     searchpath(environment, mode).collect do |source|
       case source.type
       when :values
         @value_sets[source.name]
       when :section
         if @configuration_file && section = @configuration_file.sections[source.name]
           ValuesFromSection.new(source.name, section)
         end
       when :environment
         ValuesFromEnvironmentConf.new(source.name)
       else
         raise(Puppet::DevError, "Unknown searchpath case: #{source.type} for the #{source} settings path element.")
       end
     end.compact
   end
 
   # Read the file in.
   # @api private
   def read_file(file)
     return Puppet::FileSystem.read(file)
   end
 
   # Private method for internal test use only; allows to do a comprehensive clear of all settings between tests.
   #
   # @return nil
   def clear_everything_for_tests()
     unsafe_clear(true, true)
     @configuration_file = nil
     @global_defaults_initialized = false
     @app_defaults_initialized = false
   end
   private :clear_everything_for_tests
 
   def explicit_config_file?
     # Figure out if the user has provided an explicit configuration file.  If
     # so, return the path to the file, if not return nil.
     #
     # The easiest way to determine whether an explicit one has been specified
     #  is to simply attempt to evaluate the value of ":config".  This will
     #  obviously be successful if they've passed an explicit value for :config,
     #  but it will also result in successful interpolation if they've only
     #  passed an explicit value for :confdir.
     #
     # If they've specified neither, then the interpolation will fail and we'll
     #  get an exception.
     #
     begin
       return true if self[:config]
     rescue InterpolationError
       # This means we failed to interpolate, which means that they didn't
       #  explicitly specify either :config or :confdir... so we'll fall out to
       #  the default value.
       return false
     end
   end
   private :explicit_config_file?
 
   # Lookup configuration setting value through a chain of different value sources.
   #
   # @api public
   class ChainedValues
     ENVIRONMENT_SETTING = "environment".freeze
     ENVIRONMENT_INTERPOLATION_ALLOWED = ['config_version'].freeze
 
     # @see Puppet::Settings.values
     # @api private
     def initialize(mode, environment, value_sets, defaults)
       @mode = mode
       @environment = environment
       @value_sets = value_sets
       @defaults = defaults
     end
 
     # Lookup the uninterpolated value.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def lookup(name)
-      set = @value_sets.find do |set|
-        set.include?(name)
+      set = @value_sets.find do |value_set|
+        value_set.include?(name)
       end
       if set
         value = set.lookup(name)
         if !value.nil?
           return value
         end
       end
 
       @defaults[name].default
     end
 
     # Lookup the interpolated value. All instances of `$name` in the value will
     # be replaced by performing a lookup of `name` and substituting the text
     # for `$name` in the original value. This interpolation is only performed
     # if the looked up value is a String.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def interpolate(name)
       setting = @defaults[name]
 
       if setting
         val = lookup(name)
         # if we interpolate code, all hell breaks loose.
         if name == :code
           val
         else
           # Convert it if necessary
           begin
             val = convert(val, name)
           rescue InterpolationError => err
             # This happens because we don't have access to the param name when the
             # exception is originally raised, but we want it in the message
             raise InterpolationError, "Error converting value for param '#{name}': #{err}", err.backtrace
           end
 
           setting.munge(val)
         end
       else
         nil
       end
     end
 
     private
 
     def convert(value, setting_name)
       case value
       when nil
         nil
       when String
         failed_environment_interpolation = false
         interpolated_value = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |expression|
           varname = $2 || $1
           interpolated_expression =
           if varname != ENVIRONMENT_SETTING || ok_to_interpolate_environment(setting_name)
             if varname == ENVIRONMENT_SETTING && @environment
               @environment
             elsif varname == "run_mode"
               @mode
             elsif !(pval = interpolate(varname.to_sym)).nil?
               pval
             else
               raise InterpolationError, "Could not find value for #{expression}"
             end
           else
             failed_environment_interpolation = true
             expression
           end
           interpolated_expression
         end
         if failed_environment_interpolation
           Puppet.warning("You cannot interpolate $environment within '#{setting_name}' when using directory environments.  Its value will remain #{interpolated_value}.")
         end
         interpolated_value
       else
         value
       end
     end
 
     def ok_to_interpolate_environment(setting_name)
       ENVIRONMENT_INTERPOLATION_ALLOWED.include?(setting_name.to_s)
     end
   end
 
   class Values
     extend Forwardable
 
     attr_reader :name
 
     def initialize(name, defaults)
       @name = name
       @values = {}
       @defaults = defaults
     end
 
     def_delegator :@values, :include?
     def_delegator :@values, :[], :lookup
 
     def set(name, value)
       default = @defaults[name]
 
       if !default
         raise ArgumentError,
           "Attempt to assign a value to unknown setting #{name.inspect}"
       end
 
       if default.has_hook?
         default.handle(value)
       end
 
       @values[name] = value
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @values="#{@values}">}
     end
   end
 
   class ValuesFromSection
     attr_reader :name
 
     def initialize(name, section)
       @name = name
       @section = section
     end
 
     def include?(name)
       !@section.setting(name).nil?
     end
 
     def lookup(name)
       setting = @section.setting(name)
       if setting
         setting.value
       end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @section="#{@section}">}
     end
   end
 
   # @api private
   class ValuesFromEnvironmentConf
     def initialize(environment_name)
       @environment_name = environment_name
     end
 
     def name
       @environment_name
     end
 
     def include?(name)
       if Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name) && conf
         return true
       end
       false
     end
 
     def lookup(name)
       return nil unless Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name)
       conf.send(name) if conf
     end
 
     def conf
       @conf ||= if environments = Puppet.lookup(:environments)
                   environments.get_conf(@environment_name)
                 end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @environment_name="#{@environment_name}" @conf="#{@conf}">}
     end
   end
 end
diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb
index 2809b65cc..ddeba65d8 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,363 +1,363 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/application'
 require 'digest/sha1'
 require 'set'
 
 # the class that actually walks our resource/property tree, collects the changes,
 # and performs them
 #
 # @api private
 class Puppet::Transaction
   require 'puppet/transaction/additional_resource_generator'
   require 'puppet/transaction/event'
   require 'puppet/transaction/event_manager'
   require 'puppet/transaction/resource_harness'
   require 'puppet/resource/status'
 
   attr_accessor :catalog, :ignoreschedules, :for_network_device
 
   # The report, once generated.
   attr_reader :report
 
   # Routes and stores any events and subscriptions.
   attr_reader :event_manager
 
   # Handles most of the actual interacting with resources
   attr_reader :resource_harness
 
   attr_reader :prefetched_providers
 
   include Puppet::Util
   include Puppet::Util::Tagging
 
   def initialize(catalog, report, prioritizer)
     @catalog = catalog
 
     @report = report || Puppet::Transaction::Report.new("apply", catalog.version, catalog.environment)
 
     @prioritizer = prioritizer
 
     @report.add_times(:config_retrieval, @catalog.retrieval_duration || 0)
 
     @event_manager = Puppet::Transaction::EventManager.new(self)
 
     @resource_harness = Puppet::Transaction::ResourceHarness.new(self)
 
     @prefetched_providers = Hash.new { |h,k| h[k] = {} }
   end
 
   # Invoke the pre_run_check hook in every resource in the catalog.
   # This should (only) be called by Transaction#evaluate before applying
   # the catalog.
   #
   # @see Puppet::Transaction#evaluate
   # @see Puppet::Type#pre_run_check
   # @raise [Puppet::Error] If any pre-run checks failed.
   # @return [void]
   def perform_pre_run_checks
     prerun_errors = {}
 
     @catalog.vertices.each do |res|
       begin
         res.pre_run_check
       rescue Puppet::Error => detail
         prerun_errors[res] = detail
       end
     end
 
     unless prerun_errors.empty?
       prerun_errors.each do |res, detail|
         res.log_exception(detail)
       end
       raise Puppet::Error, "Some pre-run checks failed"
     end
   end
 
   # This method does all the actual work of running a transaction.  It
   # collects all of the changes, executes them, and responds to any
   # necessary events.
   def evaluate(&block)
     block ||= method(:eval_resource)
     generator = AdditionalResourceGenerator.new(@catalog, relationship_graph, @prioritizer)
     @catalog.vertices.each { |resource| generator.generate_additional_resources(resource) }
 
     perform_pre_run_checks
 
     Puppet.info "Applying configuration version '#{catalog.version}'" if catalog.version
 
     continue_while = lambda { !stop_processing? }
 
     post_evalable_providers = Set.new
     pre_process = lambda do |resource|
       prov_class = resource.provider.class
       post_evalable_providers << prov_class if prov_class.respond_to?(:post_resource_eval)
 
       prefetch_if_necessary(resource)
 
       # If we generated resources, we don't know what they are now
       # blocking, so we opt to recompute it, rather than try to track every
       # change that would affect the number.
       relationship_graph.clear_blockers if generator.eval_generate(resource)
     end
 
     providerless_types = []
     overly_deferred_resource_handler = lambda do |resource|
       # We don't automatically assign unsuitable providers, so if there
       # is one, it must have been selected by the user.
       return if missing_tags?(resource)
       if resource.provider
         resource.err "Provider #{resource.provider.class.name} is not functional on this host"
       else
         providerless_types << resource.type
       end
 
       resource_status(resource).failed = true
     end
 
     canceled_resource_handler = lambda do |resource|
       resource_status(resource).skipped = true
       resource.debug "Transaction canceled, skipping"
     end
 
     teardown = lambda do
       # Just once per type. No need to punish the user.
       providerless_types.uniq.each do |type|
         Puppet.err "Could not find a suitable provider for #{type}"
       end
 
       post_evalable_providers.each do |provider|
         begin
           provider.post_resource_eval
         rescue => detail
           Puppet.log_exception(detail, "post_resource_eval failed for provider #{provider}")
         end
       end
     end
 
     relationship_graph.traverse(:while => continue_while,
                                 :pre_process => pre_process,
                                 :overly_deferred_resource_handler => overly_deferred_resource_handler,
                                 :canceled_resource_handler => canceled_resource_handler,
                                 :teardown => teardown) do |resource|
       if resource.is_a?(Puppet::Type::Component)
         Puppet.warning "Somehow left a component in the relationship graph"
       else
         resource.info "Starting to evaluate the resource" if Puppet[:evaltrace] and @catalog.host_config?
         seconds = thinmark { block.call(resource) }
         resource.info "Evaluated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
       end
     end
 
     Puppet.debug "Finishing transaction #{object_id}"
   end
 
   # Wraps application run state check to flag need to interrupt processing
   def stop_processing?
     Puppet::Application.stop_requested? && catalog.host_config?
   end
 
   # Are there any failed resources in this transaction?
   def any_failed?
     report.resource_statuses.values.detect { |status| status.failed? }
   end
 
   # Find all of the changed resources.
   def changed?
     report.resource_statuses.values.find_all { |status| status.changed }.collect { |status| catalog.resource(status.resource) }
   end
 
   def relationship_graph
     catalog.relationship_graph(@prioritizer)
   end
 
   def resource_status(resource)
     report.resource_statuses[resource.to_s] || add_resource_status(Puppet::Resource::Status.new(resource))
   end
 
   # The tags we should be checking.
   def tags
     self.tags = Puppet[:tags] unless defined?(@tags)
 
     super
   end
 
   def prefetch_if_necessary(resource)
     provider_class = resource.provider.class
     return unless provider_class.respond_to?(:prefetch) and !prefetched_providers[resource.type][provider_class.name]
 
     resources = resources_by_provider(resource.type, provider_class.name)
 
     if provider_class == resource.class.defaultprovider
       providerless_resources = resources_by_provider(resource.type, nil)
       providerless_resources.values.each {|res| res.provider = provider_class.name}
       resources.merge! providerless_resources
     end
 
     prefetch(provider_class, resources)
   end
 
   private
 
   # Apply all changes for a resource
   def apply(resource, ancestor = nil)
     status = resource_harness.evaluate(resource)
     add_resource_status(status)
     event_manager.queue_events(ancestor || resource, status.events) unless status.failed?
   rescue => detail
     resource.err "Could not evaluate: #{detail}"
   end
 
   # Evaluate a single resource.
   def eval_resource(resource, ancestor = nil)
     if skip?(resource)
       resource_status(resource).skipped = true
       resource.debug("Resource is being skipped, unscheduling all events")
       event_manager.dequeue_all_events_for_resource(resource)
     else
       resource_status(resource).scheduled = true
       apply(resource, ancestor)
       event_manager.process_events(resource)
     end
   end
 
   def failed?(resource)
     s = resource_status(resource) and s.failed?
   end
 
   # Does this resource have any failed dependencies?
   def failed_dependencies?(resource)
     # First make sure there are no failed dependencies.  To do this,
     # we check for failures in any of the vertexes above us.  It's not
     # enough to check the immediate dependencies, which is why we use
     # a tree from the reversed graph.
     found_failed = false
 
 
     # When we introduced the :whit into the graph, to reduce the combinatorial
     # explosion of edges, we also ended up reporting failures for containers
     # like class and stage.  This is undesirable; while just skipping the
     # output isn't perfect, it is RC-safe. --daniel 2011-06-07
     suppress_report = (resource.class == Puppet::Type.type(:whit))
 
     relationship_graph.dependencies(resource).each do |dep|
       next unless failed?(dep)
       found_failed = true
 
       # See above. --daniel 2011-06-06
       unless suppress_report then
         resource.notice "Dependency #{dep} has failures: #{resource_status(dep).failed}"
       end
     end
 
     found_failed
   end
 
   # A general method for recursively generating new resources from a
   # resource.
   def generate_additional_resources(resource)
     return unless resource.respond_to?(:generate)
     begin
       made = resource.generate
     rescue => detail
       resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
     end
     return unless made
     made = [made] unless made.is_a?(Array)
     made.uniq.each do |res|
       begin
         res.tag(*resource.tags)
         @catalog.add_resource(res)
         res.finish
         add_conditional_directed_dependency(resource, res)
         generate_additional_resources(res)
       rescue Puppet::Resource::Catalog::DuplicateResourceError
         res.info "Duplicate generated resource; skipping"
       end
     end
   end
 
   # Should we ignore tags?
   def ignore_tags?
     ! @catalog.host_config?
   end
 
   def resources_by_provider(type_name, provider_name)
     unless @resources_by_provider
-      @resources_by_provider = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
+      @resources_by_provider = Hash.new { |h, k| h[k] = Hash.new { |h1, k1| h1[k1] = {} } }
 
       @catalog.vertices.each do |resource|
         if resource.class.attrclass(:provider)
           prov = resource.provider && resource.provider.class.name
           @resources_by_provider[resource.type][prov][resource.name] = resource
         end
       end
     end
 
     @resources_by_provider[type_name][provider_name] || {}
   end
 
   # Prefetch any providers that support it, yo.  We don't support prefetching
   # types, just providers.
   def prefetch(provider_class, resources)
     type_name = provider_class.resource_type.name
     return if @prefetched_providers[type_name][provider_class.name]
     Puppet.debug "Prefetching #{provider_class.name} resources for #{type_name}"
     begin
       provider_class.prefetch(resources)
     rescue => detail
       Puppet.log_exception(detail, "Could not prefetch #{type_name} provider '#{provider_class.name}': #{detail}")
     end
     @prefetched_providers[type_name][provider_class.name] = true
   end
 
   def add_resource_status(status)
     report.add_resource_status(status)
   end
 
   # Is the resource currently scheduled?
   def scheduled?(resource)
     self.ignoreschedules or resource_harness.scheduled?(resource)
   end
 
   # Should this resource be skipped?
   def skip?(resource)
     if missing_tags?(resource)
       resource.debug "Not tagged with #{tags.join(", ")}"
     elsif ! scheduled?(resource)
       resource.debug "Not scheduled"
     elsif failed_dependencies?(resource)
       # When we introduced the :whit into the graph, to reduce the combinatorial
       # explosion of edges, we also ended up reporting failures for containers
       # like class and stage.  This is undesirable; while just skipping the
       # output isn't perfect, it is RC-safe. --daniel 2011-06-07
       unless resource.class == Puppet::Type.type(:whit) then
         resource.warning "Skipping because of failed dependencies"
       end
     elsif resource.virtual?
       resource.debug "Skipping because virtual"
     elsif !host_and_device_resource?(resource) && resource.appliable_to_host? && for_network_device
       resource.debug "Skipping host resources because running on a device"
     elsif !host_and_device_resource?(resource) && resource.appliable_to_device? && !for_network_device
       resource.debug "Skipping device resources because running on a posix host"
     else
       return false
     end
     true
   end
 
   def host_and_device_resource?(resource)
     resource.appliable_to_host? && resource.appliable_to_device?
   end
 
   # Is this resource tagged appropriately?
   def missing_tags?(resource)
     return false if ignore_tags?
     return false if tags.empty?
 
     not resource.tagged?(*tags)
   end
 end
 
 require 'puppet/transaction/report'
 
diff --git a/lib/puppet/transaction/report.rb b/lib/puppet/transaction/report.rb
index a95b4f32b..e2e452846 100644
--- a/lib/puppet/transaction/report.rb
+++ b/lib/puppet/transaction/report.rb
@@ -1,378 +1,378 @@
 require 'puppet'
 require 'puppet/indirector'
 
 # This class is used to report what happens on a client.
 # There are two types of data in a report; _Logs_ and _Metrics_.
 #
 # * **Logs** - are the output that each change produces.
 # * **Metrics** - are all of the numerical data involved in the transaction.
 #
 # Use {Puppet::Reports} class to create a new custom report type. This class is indirectly used
 # as a source of data to report in such a registered report.
 #
 # ##Metrics
 # There are three types of metrics in each report, and each type of metric has one or more values.
 #
 # * Time: Keeps track of how long things took.
 #   * Total: Total time for the configuration run
 #   * File:
 #   * Exec:
 #   * User:
 #   * Group:
 #   * Config Retrieval: How long the configuration took to retrieve
 #   * Service:
 #   * Package:
 # * Resources: Keeps track of the following stats:
 #   * Total: The total number of resources being managed
 #   * Skipped: How many resources were skipped, because of either tagging or scheduling restrictions
 #   * Scheduled: How many resources met any scheduling restrictions
 #   * Out of Sync: How many resources were out of sync
 #   * Applied: How many resources were attempted to be fixed
 #   * Failed: How many resources were not successfully fixed
 #   * Restarted: How many resources were restarted because their dependencies changed
 #   * Failed Restarts: How many resources could not be restarted
 # * Changes: The total number of changes in the transaction.
 #
 # @api public
 class Puppet::Transaction::Report
   extend Puppet::Indirector
 
   indirects :report, :terminus_class => :processor
 
   # The version of the configuration
   # @todo Uncertain what this is?
   # @return [???] the configuration version
   attr_accessor :configuration_version
 
   # An agent generated transaction uuid, useful for connecting catalog and report
   # @return [String] uuid
   attr_accessor :transaction_uuid
 
   # The host name for which the report is generated
   # @return [String] the host name
   attr_accessor :host
 
   # The name of the environment the host is in
   # @return [String] the environment name
   attr_accessor :environment
 
   # A hash with a map from resource to status
   # @return [Hash{String => Puppet::Resource::Status}] Resource name to status.
   attr_reader :resource_statuses
 
   # A list of log messages.
   # @return [Array<Puppet::Util::Log>] logged messages
   attr_reader :logs
 
   # A hash of metric name to metric value.
   # @return [Hash<{String => Object}>] A map of metric name to value.
   # @todo Uncertain if all values are numbers - now marked as Object.
   #
   attr_reader :metrics
 
   # The time when the report data was generated.
   # @return [Time] A time object indicating when the report data was generated
   #
   attr_reader :time
 
   # The 'kind' of report is the name of operation that triggered the report to be produced.
   # Typically "apply".
   # @return [String] the kind of operation that triggered the generation of the report.
   #
   attr_reader :kind
 
   # The status of the client run is an enumeration: 'failed', 'changed' or 'unchanged'
   # @return [String] the status of the run - one of the values 'failed', 'changed', or 'unchanged'
   #
   attr_reader :status
 
   # @return [String] The Puppet version in String form.
   # @see Puppet::version()
   #
   attr_reader :puppet_version
 
   # @return [Integer] report format version number.  This value is constant for
   #    a given version of Puppet; it is incremented when a new release of Puppet
   #    changes the API for the various objects that make up a report.
   #
   attr_reader :report_format
 
   def self.from_data_hash(data)
     obj = self.allocate
     obj.initialize_from_hash(data)
     obj
   end
 
   def as_logging_destination(&block)
     Puppet::Util::Log.with_destination(self, &block)
   end
 
   # @api private
   def <<(msg)
     @logs << msg
     self
   end
 
   # @api private
   def add_times(name, value)
     @external_times[name] = value
   end
 
   # @api private
   def add_metric(name, hash)
     metric = Puppet::Util::Metric.new(name)
 
-    hash.each do |name, value|
-      metric.newvalue(name, value)
+    hash.each do |metric_name, value|
+      metric.newvalue(metric_name, value)
     end
 
     @metrics[metric.name] = metric
     metric
   end
 
   # @api private
   def add_resource_status(status)
     @resource_statuses[status.resource] = status
   end
 
   # @api private
   def compute_status(resource_metrics, change_metric)
     if (resource_metrics["failed"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
     else
       'unchanged'
     end
   end
 
   # @api private
   def prune_internal_data
     resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
   end
 
   # @api private
   def finalize_report
     prune_internal_data
 
     resource_metrics = add_metric(:resources, calculate_resource_metrics)
     add_metric(:time, calculate_time_metrics)
     change_metric = calculate_change_metric
     add_metric(:changes, {"total" => change_metric})
     add_metric(:events, calculate_event_metrics)
     @status = compute_status(resource_metrics, change_metric)
   end
 
   # @api private
   def initialize(kind, configuration_version=nil, environment=nil, transaction_uuid=nil)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:node_name_value]
     @time = Time.now
     @kind = kind
     @report_format = 4
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @transaction_uuid = transaction_uuid
     @environment = environment
     @status = 'failed' # assume failed until the report is finalized
   end
 
   # @api private
   def initialize_from_hash(data)
     @puppet_version = data['puppet_version']
     @report_format = data['report_format']
     @configuration_version = data['configuration_version']
     @transaction_uuid = data['transaction_uuid']
     @environment = data['environment']
     @status = data['status']
     @host = data['host']
     @time = data['time']
     if @time.is_a? String
       @time = Time.parse(@time)
     end
     @kind = data['kind']
 
     @metrics = {}
     data['metrics'].each do |name, hash|
       @metrics[name] = Puppet::Util::Metric.from_data_hash(hash)
     end
 
     @logs = data['logs'].map do |record|
       Puppet::Util::Log.from_data_hash(record)
     end
 
     @resource_statuses = {}
     data['resource_statuses'].map do |record|
       if record[1] == {}
         status = nil
       else
         status = Puppet::Resource::Status.from_data_hash(record[1])
       end
       @resource_statuses[record[0]] = status
     end
   end
 
   def to_data_hash
     {
       'host' => @host,
       'time' => @time.iso8601(9),
       'configuration_version' => @configuration_version,
       'transaction_uuid' => @transaction_uuid,
       'report_format' => @report_format,
       'puppet_version' => @puppet_version,
       'kind' => @kind,
       'status' => @status,
       'environment' => @environment,
 
       'logs' => @logs,
       'metrics' => @metrics,
       'resource_statuses' => @resource_statuses,
     }
   end
 
   # @return [String] the host name
   # @api public
   #
   def name
     host
   end
 
   # Provide a human readable textual summary of this report.
   # @note This is intended for debugging purposes
   # @return [String] A string with a textual summary of this report.
   # @api public
   #
   def summary
     report = raw_summary
 
     ret = ""
     report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
       ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
 
       report[key].keys.sort { |a,b|
         # sort by label
         if a == :total
           1
         elsif b == :total
           -1
         else
           report[key][a].to_s <=> report[key][b].to_s
         end
       }.each do |label|
         value = report[key][label]
         next if value == 0
         value = "%0.2f" % value if value.is_a?(Float)
         ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
       end
     end
     ret
   end
 
   # Provides a raw hash summary of this report.
   # @return [Hash<{String => Object}>] A hash with metrics key to value map
   # @api public
   #
   def raw_summary
     report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version  } }
 
     @metrics.each do |name, metric|
       key = metric.name.to_s
       report[key] = {}
-      metric.values.each do |name, label, value|
-        report[key][name.to_s] = value
+      metric.values.each do |metric_name, label, value|
+        report[key][metric_name.to_s] = value
       end
       report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
     end
     (report["time"] ||= {})["last_run"] = Time.now.tv_sec
     report
   end
 
   # Computes a single number that represents the report's status.
   # The computation is based on the contents of this report's metrics.
   # The resulting number is a bitmask where
   # individual bits represent the presence of different metrics.
   #
   # * 0x2 set if there are changes
   # * 0x4 set if there are resource failures or resources that failed to restart
   # @return [Integer] A bitmask where 0x2 is set if there are changes, and 0x4 is set of there are failures.
   # @api public
   #
   def exit_status
     status = 0
     status |= 2 if @metrics["changes"]["total"] > 0
     status |= 4 if @metrics["resources"]["failed"] > 0
     status |= 4 if @metrics["resources"]["failed_to_restart"] > 0
     status
   end
 
   # @api private
   #
   def to_yaml_properties
     super - [:@external_times]
   end
 
   def self.supported_formats
     [:pson, :yaml]
   end
 
   def self.default_format
     :pson
   end
 
   private
 
   def calculate_change_metric
     resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
   end
 
   def calculate_event_metrics
     metrics = Hash.new(0)
     %w{total failure success}.each { |m| metrics[m] = 0 }
     resource_statuses.each do |name, status|
       metrics["total"] += status.events.length
       status.events.each do |event|
         metrics[event.status] += 1
       end
     end
 
     metrics
   end
 
   def calculate_resource_metrics
     metrics = {}
     metrics["total"] = resource_statuses.length
 
     # force every resource key in the report to be present
     # even if no resources is in this given state
     Puppet::Resource::Status::STATES.each do |state|
       metrics[state.to_s] = 0
     end
 
     resource_statuses.each do |name, status|
       Puppet::Resource::Status::STATES.each do |state|
         metrics[state.to_s] += 1 if status.send(state)
       end
     end
 
     metrics
   end
 
   def calculate_time_metrics
     metrics = Hash.new(0)
     resource_statuses.each do |name, status|
       type = Puppet::Resource.new(name).type
       metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
     end
 
     @external_times.each do |name, value|
       metrics[name.to_s.downcase] = value
     end
 
     metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
 
     metrics
   end
 end
diff --git a/lib/puppet/type.rb b/lib/puppet/type.rb
index 777fefc41..c4d31eb99 100644
--- a/lib/puppet/type.rb
+++ b/lib/puppet/type.rb
@@ -1,2538 +1,2538 @@
 require 'puppet'
 require 'puppet/util/log'
 require 'puppet/util/metric'
 require 'puppet/property'
 require 'puppet/parameter'
 require 'puppet/util'
 require 'puppet/util/autoload'
 require 'puppet/metatype/manager'
 require 'puppet/util/errors'
 require 'puppet/util/logging'
 require 'puppet/util/tagging'
 
 # see the bottom of the file for the rest of the inclusions
 
 
 module Puppet
 # The base class for all Puppet types.
 #
 # A type describes:
 #--
 # * **Attributes** - properties, parameters, and meta-parameters are different types of attributes of a type.
 #   * **Properties** - these are the properties of the managed resource (attributes of the entity being managed; like
 #     a file's owner, group and mode). A property describes two states; the 'is' (current state) and the 'should' (wanted
 #     state).
 #       * **Ensurable** - a set of traits that control the lifecycle (create, remove, etc.) of a managed entity.
 #         There is a default set of operations associated with being _ensurable_, but this can be changed.
 #       * **Name/Identity** - one property is the name/identity of a resource, the _namevar_ that uniquely identifies
 #         one instance of a type from all others.
 #   * **Parameters** - additional attributes of the type (that does not directly related to an instance of the managed
 #     resource; if an operation is recursive or not, where to look for things, etc.). A Parameter (in contrast to Property)
 #     has one current value where a Property has two (current-state and wanted-state).
 #   * **Meta-Parameters** - parameters that are available across all types. A meta-parameter typically has
 #     additional semantics; like the `require` meta-parameter. A new type typically does not add new meta-parameters,
 #     but you need to be aware of their existence so you do not inadvertently shadow an existing meta-parameters.
 # * **Parent** - a type can have a super type (that it inherits from).
 # * **Validation** - If not just a basic data type, or an enumeration of symbolic values, it is possible to provide
 #     validation logic for a type, properties and parameters.
 # * **Munging** - munging/unmunging is the process of turning a value in external representation (as used
 #     by a provider) into an internal representation and vice versa. A Type supports adding custom logic for these.
 # * **Auto Requirements** - a type can specify automatic relationships to resources to ensure that if they are being
 #     managed, they will be processed before this type.
 # * **Providers** - a provider is an implementation of a type's behavior - the management of a resource in the
 #     system being managed. A provider is often platform specific and is selected at runtime based on
 #     criteria/predicates specified in the configured providers. See {Puppet::Provider} for details.
 # * **Device Support** - A type has some support for being applied to a device; i.e. something that is managed
 #     by running logic external to the device itself. There are several methods that deals with type
 #     applicability for these special cases such as {apply_to_device}.
 #
 # Additional Concepts:
 # --
 # * **Resource-type** - A _resource type_ is a term used to denote the type of a resource; internally a resource
 #     is really an instance of a Ruby class i.e. {Puppet::Resource} which defines its behavior as "resource data".
 #     Conceptually however, a resource is an instance of a subclass of Type (e.g. File), where such a class describes
 #     its interface (what can be said/what is known about a resource of this type),
 # * **Managed Entity** - This is not a term in general use, but is used here when there is a need to make
 #     a distinction between a resource (a description of what/how something should be managed), and what it is
 #     managing (a file in the file system). The term _managed entity_ is a reference to the "file in the file system"
 # * **Isomorphism** - the quality of being _isomorphic_ means that two resource instances with the same name
 #     refers to the same managed entity. Or put differently; _an isomorphic name is the identity of a resource_.
 #     As an example, `exec` resources (that executes some command) have the command (i.e. the command line string) as
 #     their name, and these resources are said to be non-isomorphic.
 #
 # @note The Type class deals with multiple concerns; some methods provide an internal DSL for convenient definition
 #   of types, other methods deal with various aspects while running; wiring up a resource (expressed in Puppet DSL)
 #   with its _resource type_ (i.e. an instance of Type) to enable validation, transformation of values
 #   (munge/unmunge), etc. Lastly, Type is also responsible for dealing with Providers; the concrete implementations
 #   of the behavior that constitutes how a particular Type behaves on a particular type of system (e.g. how
 #   commands are executed on a flavor of Linux, on Windows, etc.). This means that as you are reading through the
 #   documentation of this class, you will be switching between these concepts, as well as switching between
 #   the conceptual level "a resource is an instance of a resource-type" and the actual implementation classes
 #   (Type, Resource, Provider, and various utility and helper classes).
 #
 # @api public
 #
 #
 class Type
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
 
   # Comparing type instances.
   include Comparable
 
   # Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
   # @param other [Object] the object to compare against (produces nil, if not kind of Type}
   # @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
   #   Returns nil, if the given _other_ is not a kind of Type.
   # @see Comparable
   #
   def <=>(other)
     # We only order against other types, not arbitrary objects.
     return nil unless other.is_a? Puppet::Type
     # Our natural order is based on the reference name we use when comparing
     # against other type instances.
     self.ref <=> other.ref
   end
 
   # Code related to resource type attributes.
   class << self
     include Puppet::Util::ClassGen
     include Puppet::Util::Warnings
 
     # @return [Array<Puppet::Property>] The list of declared properties for the resource type.
     # The returned lists contains instances if Puppet::Property or its subclasses.
     attr_reader :properties
   end
 
   # Returns all the attribute names of the type in the appropriate order.
   # The {key_attributes} come first, then the {provider}, then the {properties}, and finally
   # the {parameters} and {metaparams},
   # all in the order they were specified in the respective files.
   # @return [Array<String>] all type attribute names in a defined order.
   #
   def self.allattrs
     key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
   end
 
   # Returns the class associated with the given attribute name.
   # @param name [String] the name of the attribute to obtain the class for
   # @return [Class, nil] the class for the given attribute, or nil if the name does not refer to an existing attribute
   #
   def self.attrclass(name)
     @attrclasses ||= {}
 
     # We cache the value, since this method gets called such a huge number
     # of times (as in, hundreds of thousands in a given run).
     unless @attrclasses.include?(name)
       @attrclasses[name] = case self.attrtype(name)
       when :property; @validproperties[name]
       when :meta; @@metaparamhash[name]
       when :param; @paramhash[name]
       end
     end
     @attrclasses[name]
   end
 
   # Returns the attribute type (`:property`, `;param`, `:meta`).
   # @comment What type of parameter are we dealing with? Cache the results, because
   #   this method gets called so many times.
   # @return [Symbol] a symbol describing the type of attribute (`:property`, `;param`, `:meta`)
   #
   def self.attrtype(attr)
     @attrtypes ||= {}
     unless @attrtypes.include?(attr)
       @attrtypes[attr] = case
         when @validproperties.include?(attr); :property
         when @paramhash.include?(attr); :param
         when @@metaparamhash.include?(attr); :meta
         end
     end
 
     @attrtypes[attr]
   end
 
   # Provides iteration over meta-parameters.
   # @yieldparam p [Puppet::Parameter] each meta parameter
   # @return [void]
   #
   def self.eachmetaparam
     @@metaparams.each { |p| yield p.name }
   end
 
   # Creates a new `ensure` property with configured default values or with configuration by an optional block.
   # This method is a convenience method for creating a property `ensure` with default accepted values.
   # If no block is specified, the new `ensure` property will accept the default symbolic
   # values `:present`, and `:absent` - see {Puppet::Property::Ensure}.
   # If something else is wanted, pass a block and make calls to {Puppet::Property.newvalue} from this block
   # to define each possible value. If a block is passed, the defaults are not automatically added to the set of
   # valid values.
   #
   # @note This method will be automatically called without a block if the type implements the methods
   #   specified by {ensurable?}. It is recommended to always call this method and not rely on this automatic
   #   specification to clearly state that the type is ensurable.
   #
   # @overload ensurable()
   # @overload ensurable({|| ... })
   # @yield [ ] A block evaluated in scope of the new Parameter
   # @yieldreturn [void]
   # @return [void]
   # @dsl type
   # @api public
   #
   def self.ensurable(&block)
     if block_given?
       self.newproperty(:ensure, :parent => Puppet::Property::Ensure, &block)
     else
       self.newproperty(:ensure, :parent => Puppet::Property::Ensure) do
         self.defaultvalues
       end
     end
   end
 
   # Returns true if the type implements the default behavior expected by being _ensurable_ "by default".
   # A type is _ensurable_ by default if it responds to `:exists`, `:create`, and `:destroy`.
   # If a type implements these methods and have not already specified that it is _ensurable_, it will be
   # made so with the defaults specified in {ensurable}.
   # @return [Boolean] whether the type is _ensurable_ or not.
   #
   def self.ensurable?
     # If the class has all three of these methods defined, then it's
     # ensurable.
     [:exists?, :create, :destroy].all? { |method|
       self.public_method_defined?(method)
     }
   end
 
   # @comment These `apply_to` methods are horrible.  They should really be implemented
   #   as part of the usual system of constraints that apply to a type and
   #   provider pair, but were implemented as a separate shadow system.
   #
   # @comment We should rip them out in favour of a real constraint pattern around the
   #   target device - whatever that looks like - and not have this additional
   #   magic here. --daniel 2012-03-08
   #
   # Makes this type applicable to `:device`.
   # @return [Symbol] Returns `:device`
   # @api private
   #
   def self.apply_to_device
     @apply_to = :device
   end
 
   # Makes this type applicable to `:host`.
   # @return [Symbol] Returns `:host`
   # @api private
   #
   def self.apply_to_host
     @apply_to = :host
   end
 
   # Makes this type applicable to `:both` (i.e. `:host` and `:device`).
   # @return [Symbol] Returns `:both`
   # @api private
   #
   def self.apply_to_all
     @apply_to = :both
   end
 
   # Makes this type apply to `:host` if not already applied to something else.
   # @return [Symbol] a `:device`, `:host`, or `:both` enumeration
   # @api private
   def self.apply_to
     @apply_to ||= :host
   end
 
   # Returns true if this type is applicable to the given target.
   # @param target [Symbol] should be :device, :host or :target, if anything else, :host is enforced
   # @return [Boolean] true
   # @api private
   #
   def self.can_apply_to(target)
     [ target == :device ? :device : :host, :both ].include?(apply_to)
   end
 
   # Processes the options for a named parameter.
   # @param name [String] the name of a parameter
   # @param options [Hash] a hash of options
   # @option options [Boolean] :boolean if option set to true, an access method on the form _name_? is added for the param
   # @return [void]
   #
   def self.handle_param_options(name, options)
     # If it's a boolean parameter, create a method to test the value easily
     if options[:boolean]
       define_method(name.to_s + "?") do
         val = self[name]
         if val == :true or val == true
           return true
         end
       end
     end
   end
 
   # Is the given parameter a meta-parameter?
   # @return [Boolean] true if the given parameter is a meta-parameter.
   #
   def self.metaparam?(param)
     @@metaparamhash.include?(param.intern)
   end
 
   # Returns the meta-parameter class associated with the given meta-parameter name.
   # Accepts a `nil` name, and return nil.
   # @param name [String, nil] the name of a meta-parameter
   # @return [Class,nil] the class for the given meta-parameter, or `nil` if no such meta-parameter exists, (or if
   #   the given meta-parameter name is `nil`.
   #
   def self.metaparamclass(name)
     return nil if name.nil?
     @@metaparamhash[name.intern]
   end
 
   # Returns all meta-parameter names.
   # @return [Array<String>] all meta-parameter names
   #
   def self.metaparams
     @@metaparams.collect { |param| param.name }
   end
 
   # Returns the documentation for a given meta-parameter of this type.
   # @param metaparam [Puppet::Parameter] the meta-parameter to get documentation for.
   # @return [String] the documentation associated with the given meta-parameter, or nil of no such documentation
   #   exists.
   # @raise if the given metaparam is not a meta-parameter in this type
   #
   def self.metaparamdoc(metaparam)
     @@metaparamhash[metaparam].doc
   end
 
   # Creates a new meta-parameter.
   # This creates a new meta-parameter that is added to this and all inheriting types.
   # @param name [Symbol] the name of the parameter
   # @param options [Hash] a hash with options.
   # @option options [Class<inherits Puppet::Parameter>] :parent (Puppet::Parameter) the super class of this parameter
   # @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
   #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
   #   block is evaluated.
   # @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
   # @option options [Boolean] :namevar  (false) specifies if this parameter is the namevar
   # @option options [Symbol, Array<Symbol>] :required_features  specifies required provider features by name
   # @return [Class<inherits Puppet::Parameter>] the created parameter
   # @yield [ ] a required block that is evaluated in the scope of the new meta-parameter
   # @api public
   # @dsl type
   # @todo Verify that this description is ok
   #
   def self.newmetaparam(name, options = {}, &block)
     @@metaparams ||= []
     @@metaparamhash ||= {}
     name = name.intern
 
     param = genclass(
       name,
       :parent => options[:parent] || Puppet::Parameter,
       :prefix => "MetaParam",
       :hash => @@metaparamhash,
       :array => @@metaparams,
       :attributes => options[:attributes],
       &block
     )
 
     # Grr.
     param.required_features = options[:required_features] if options[:required_features]
 
     handle_param_options(name, options)
 
     param.metaparam = true
 
     param
   end
 
   # Returns the list of parameters that comprise the composite key / "uniqueness key".
   # All parameters that return true from #isnamevar? or is named `:name` are included in the returned result.
   # @see uniqueness_key
   # @return [Array<Puppet::Parameter>] WARNING: this return type is uncertain
   def self.key_attribute_parameters
     @key_attribute_parameters ||= (
       @parameters.find_all { |param|
         param.isnamevar? or param.name == :name
       }
     )
   end
 
   # Returns cached {key_attribute_parameters} names.
   # Key attributes are properties and parameters that comprise a composite key
   # or "uniqueness key".
   # @return [Array<String>] cached key_attribute names
   #
   def self.key_attributes
     # This is a cache miss around 0.05 percent of the time. --daniel 2012-07-17
     @key_attributes_cache ||= key_attribute_parameters.collect { |p| p.name }
   end
 
   # Returns a mapping from the title string to setting of attribute value(s).
   # This default implementation provides a mapping of title to the one and only _namevar_ present
   # in the type's definition.
   # @note Advanced: some logic requires this mapping to be done differently, using a different
   #   validation/pattern, breaking up the title
   #   into several parts assigning each to an individual attribute, or even use a composite identity where
   #   all namevars are seen as part of the unique identity (such computation is done by the {#uniqueness} method.
   #   These advanced options are rarely used (only one of the built in puppet types use this, and then only
   #   a small part of the available functionality), and the support for these advanced mappings is not
   #   implemented in a straight forward way. For these reasons, this method has been marked as private).
   #
   # @raise [Puppet::DevError] if there is no title pattern and there are two or more key attributes
   # @return [Array<Array<Regexp, Array<Array <Symbol, Proc>>>>, nil] a structure with a regexp and the first key_attribute ???
   # @comment This wonderful piece of logic creates a structure used by Resource.parse_title which
   #   has the capability to assign parts of the title to one or more attributes; It looks like an implementation
   #   of a composite identity key (all parts of the key_attributes array are in the key). This can also
   #   be seen in the method uniqueness_key.
   #   The implementation in this method simply assigns the title to the one and only namevar (which is name
   #   or a variable marked as namevar).
   #   If there are multiple namevars (any in addition to :name?) then this method MUST be implemented
   #   as it raises an exception if there is more than 1. Note that in puppet, it is only File that uses this
   #   to create a different pattern for assigning to the :path attribute
   #   This requires further digging.
   #   The entire construct is somewhat strange, since resource checks if the method "title_patterns" is
   #   implemented (it seems it always is) - why take this more expensive regexp mathching route for all
   #   other types?
   # @api private
   #
   def self.title_patterns
     case key_attributes.length
     when 0; []
     when 1;
       [ [ /(.*)/m, [ [key_attributes.first] ] ] ]
     else
       raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
     end
   end
 
   # Produces a resource's _uniqueness_key_ (or composite key).
   # This key is an array of all key attributes' values. Each distinct tuple must be unique for each resource type.
   # @see key_attributes
   # @return [Object] an object that is a _uniqueness_key_ for this object
   #
   def uniqueness_key
     self.class.key_attributes.sort_by { |attribute_name| attribute_name.to_s }.map{ |attribute_name| self[attribute_name] }
   end
 
   # Creates a new parameter.
   # @param name [Symbol] the name of the parameter
   # @param options [Hash] a hash with options.
   # @option options [Class<inherits Puppet::Parameter>] :parent (Puppet::Parameter) the super class of this parameter
   # @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
   #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
   #   block is evaluated.
   # @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
   # @option options [Boolean] :namevar  (false) specifies if this parameter is the namevar
   # @option options [Symbol, Array<Symbol>] :required_features  specifies required provider features by name
   # @return [Class<inherits Puppet::Parameter>] the created parameter
   # @yield [ ] a required block that is evaluated in the scope of the new parameter
   # @api public
   # @dsl type
   #
   def self.newparam(name, options = {}, &block)
     options[:attributes] ||= {}
 
     param = genclass(
       name,
       :parent     => options[:parent] || Puppet::Parameter,
       :attributes => options[:attributes],
       :block      => block,
       :prefix     => "Parameter",
       :array      => @parameters,
       :hash       => @paramhash
     )
 
     handle_param_options(name, options)
 
     # Grr.
     param.required_features = options[:required_features] if options[:required_features]
 
     param.isnamevar if options[:namevar]
 
     param
   end
 
   # Creates a new property.
   # @param name [Symbol] the name of the property
   # @param options [Hash] a hash with options.
   # @option options [Symbol] :array_matching (:first) specifies how the current state is matched against
   #   the wanted state. Use `:first` if the property is single valued, and (`:all`) otherwise.
   # @option options [Class<inherits Puppet::Property>] :parent (Puppet::Property) the super class of this property
   # @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
   #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
   #   block is evaluated.
   # @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
   # @option options [Symbol] :retrieve the method to call on the provider (or `parent` if `provider` is not set)
   #   to retrieve the current value of this property.
   # @option options [Symbol, Array<Symbol>] :required_features  specifies required provider features by name
   # @return [Class<inherits Puppet::Property>] the created property
   # @yield [ ] a required block that is evaluated in the scope of the new property
   # @api public
   # @dsl type
   #
   def self.newproperty(name, options = {}, &block)
     name = name.intern
 
     # This is here for types that might still have the old method of defining
     # a parent class.
     unless options.is_a? Hash
       raise Puppet::DevError,
         "Options must be a hash, not #{options.inspect}"
     end
 
     raise Puppet::DevError, "Class #{self.name} already has a property named #{name}" if @validproperties.include?(name)
 
     if parent = options[:parent]
       options.delete(:parent)
     else
       parent = Puppet::Property
     end
 
     # We have to create our own, new block here because we want to define
     # an initial :retrieve method, if told to, and then eval the passed
     # block if available.
     prop = genclass(name, :parent => parent, :hash => @validproperties, :attributes => options) do
       # If they've passed a retrieve method, then override the retrieve
       # method on the class.
       if options[:retrieve]
         define_method(:retrieve) do
           provider.send(options[:retrieve])
         end
       end
 
       class_eval(&block) if block
     end
 
     # If it's the 'ensure' property, always put it first.
     if name == :ensure
       @properties.unshift prop
     else
       @properties << prop
     end
 
     prop
   end
 
   def self.paramdoc(param)
     @paramhash[param].doc
   end
 
   # @return [Array<String>] Returns the parameter names
   def self.parameters
     return [] unless defined?(@parameters)
     @parameters.collect { |klass| klass.name }
   end
 
   # @return [Puppet::Parameter] Returns the parameter class associated with the given parameter name.
   def self.paramclass(name)
     @paramhash[name]
   end
 
   # @return [Puppet::Property] Returns the property class ??? associated with the given property name
   def self.propertybyname(name)
     @validproperties[name]
   end
 
   # Returns whether or not the given name is the name of a property, parameter or meta-parameter
   # @return [Boolean] true if the given attribute name is the name of an existing property, parameter or meta-parameter
   #
   def self.validattr?(name)
     name = name.intern
     return true if name == :name
     @validattrs ||= {}
 
     unless @validattrs.include?(name)
       @validattrs[name] = !!(self.validproperty?(name) or self.validparameter?(name) or self.metaparam?(name))
     end
 
     @validattrs[name]
   end
 
   # @return [Boolean] Returns true if the given name is the name of an existing property
   def self.validproperty?(name)
     name = name.intern
     @validproperties.include?(name) && @validproperties[name]
   end
 
   # @return [Array<Symbol>, {}] Returns a list of valid property names, or an empty hash if there are none.
   # @todo An empty hash is returned if there are no defined parameters (not an empty array). This looks like
   #   a bug.
   #
   def self.validproperties
     return {} unless defined?(@parameters)
 
     @validproperties.keys
   end
 
   # @return [Boolean] Returns true if the given name is the name of an existing parameter
   def self.validparameter?(name)
     raise Puppet::DevError, "Class #{self} has not defined parameters" unless defined?(@parameters)
     !!(@paramhash.include?(name) or @@metaparamhash.include?(name))
   end
 
   # (see validattr?)
   # @note see comment in code - how should this be documented? Are some of the other query methods deprecated?
   #   (or should be).
   # @comment This is a forward-compatibility method - it's the validity interface we'll use in Puppet::Resource.
   def self.valid_parameter?(name)
     validattr?(name)
   end
 
   # @return [Boolean] Returns true if the wanted state of the resoure is that it should be absent (i.e. to be deleted).
   def deleting?
     obj = @parameters[:ensure] and obj.should == :absent
   end
 
   # Creates a new property value holder for the resource if it is valid and does not already exist
   # @return [Boolean] true if a new parameter was added, false otherwise
   def add_property_parameter(prop_name)
     if self.class.validproperty?(prop_name) && !@parameters[prop_name]
       self.newattr(prop_name)
       return true
     end
     false
   end
 
   # @return [Symbol, Boolean] Returns the name of the namevar if there is only one or false otherwise.
   # @comment This is really convoluted and part of the support for multiple namevars (?).
   #   If there is only one namevar, the produced value is naturally this namevar, but if there are several?
   #   The logic caches the name of the namevar if it is a single name, but otherwise always
   #   calls key_attributes, and then caches the first if there was only one, otherwise it returns
   #   false and caches this (which is then subsequently returned as a cache hit).
   #
   def name_var
     return @name_var_cache unless @name_var_cache.nil?
     key_attributes = self.class.key_attributes
     @name_var_cache = (key_attributes.length == 1) && key_attributes.first
   end
 
   # Gets the 'should' (wanted state) value of a parameter or property by name.
   # To explicitly get the 'is' (current state) value use `o.is(:name)`, and to explicitly get the 'should' value
   # use `o.should(:name)`
   # @param name [String] the name of the attribute to obtain the 'should' value for.
   # @return [Object] 'should'/wanted value of the given attribute
   def [](name)
     name = name.intern
     fail("Invalid parameter #{name}(#{name.inspect})") unless self.class.validattr?(name)
 
     if name == :name && nv = name_var
       name = nv
     end
 
     if obj = @parameters[name]
       # Note that if this is a property, then the value is the "should" value,
       # not the current value.
       obj.value
     else
       return nil
     end
   end
 
   # Sets the 'should' (wanted state) value of a property, or the value of a parameter.
   # @return
   # @raise [Puppet::Error] if the setting of the value fails, or if the given name is nil.
   # @raise [Puppet::ResourceError] when the parameter validation raises Puppet::Error or
   #   ArgumentError
   def []=(name,value)
     name = name.intern
 
     fail("Invalid parameter #{name}") unless self.class.validattr?(name)
 
     if name == :name && nv = name_var
       name = nv
     end
     raise Puppet::Error.new("Got nil value for #{name}") if value.nil?
 
     property = self.newattr(name)
 
     if property
       begin
         # make sure the parameter doesn't have any errors
         property.value = value
       rescue Puppet::Error, ArgumentError => detail
         error = Puppet::ResourceError.new("Parameter #{name} failed on #{ref}: #{detail}")
         adderrorcontext(error, detail)
         raise error
       end
     end
 
     nil
   end
 
   # Removes an attribute from the object; useful in testing or in cleanup
   # when an error has been encountered
   # @todo Don't know what the attr is (name or Property/Parameter?). Guessing it is a String name...
   # @todo Is it possible to delete a meta-parameter?
   # @todo What does delete mean? Is it deleted from the type or is its value state 'is'/'should' deleted?
   # @param attr [String] the attribute to delete from this object. WHAT IS THE TYPE?
   # @raise [Puppet::DecError] when an attempt is made to delete an attribute that does not exists.
   #
   def delete(attr)
     attr = attr.intern
     if @parameters.has_key?(attr)
       @parameters.delete(attr)
     else
       raise Puppet::DevError.new("Undefined attribute '#{attr}' in #{self}")
     end
   end
 
   # Iterates over the properties that were set on this resource.
   # @yieldparam property [Puppet::Property] each property
   # @return [void]
   def eachproperty
     # properties is a private method
     properties.each { |property|
       yield property
     }
   end
 
   # Return the parameters, metaparams, and properties that have a value or were set by a default. Properties are
   # included since they are a subclass of parameter.
   # @return [Array<Puppet::Parameter>] Array of parameter objects ( or subclass thereof )
   def parameters_with_value
     self.class.allattrs.collect { |attr| parameter(attr) }.compact
   end
 
   # Iterates over all parameters with value currently set.
   # @yieldparam parameter [Puppet::Parameter] or a subclass thereof
   # @return [void]
   def eachparameter
     parameters_with_value.each { |parameter| yield parameter }
   end
 
   # Creates a transaction event.
   # Called by Transaction or by a property.
   # Merges the given options with the options `:resource`, `:file`, `:line`, and `:tags`, initialized from
   # values in this object. For possible options to pass (if any ????) see {Puppet::Transaction::Event}.
   # @todo Needs a better explanation "Why should I care who is calling this method?", What do I need to know
   #   about events and how they work? Where can I read about them?
   # @param options [Hash] options merged with a fixed set of options defined by this method, passed on to {Puppet::Transaction::Event}.
   # @return [Puppet::Transaction::Event] the created event
   def event(options = {})
     Puppet::Transaction::Event.new({:resource => self, :file => file, :line => line, :tags => tags}.merge(options))
   end
 
   # @return [Object, nil] Returns the 'should' (wanted state) value for a specified property, or nil if the
   #   given attribute name is not a property (i.e. if it is a parameter, meta-parameter, or does not exist).
   def should(name)
     name = name.intern
     (prop = @parameters[name] and prop.is_a?(Puppet::Property)) ? prop.should : nil
   end
 
   # Registers an attribute to this resource type insance.
   # Requires either the attribute name or class as its argument.
   # This is a noop if the named property/parameter is not supported
   # by this resource. Otherwise, an attribute instance is created
   # and kept in this resource's parameters hash.
   # @overload newattr(name)
   #   @param name [Symbol] symbolic name of the attribute
   # @overload newattr(klass)
   #   @param klass [Class] a class supported as an attribute class, i.e. a subclass of
   #     Parameter or Property
   # @return [Object] An instance of the named Parameter or Property class associated
   #   to this resource type instance, or nil if the attribute is not supported
   #
   def newattr(name)
     if name.is_a?(Class)
       klass = name
       name = klass.name
     end
 
     unless klass = self.class.attrclass(name)
       raise Puppet::Error, "Resource type #{self.class.name} does not support parameter #{name}"
     end
 
     if provider and ! provider.class.supports_parameter?(klass)
       missing = klass.required_features.find_all { |f| ! provider.class.feature?(f) }
       debug "Provider %s does not support features %s; not managing attribute %s" % [provider.class.name, missing.join(", "), name]
       return nil
     end
 
     return @parameters[name] if @parameters.include?(name)
 
     @parameters[name] = klass.new(:resource => self)
   end
 
   # Returns a string representation of the resource's containment path in
   # the catalog.
   # @return [String]
   def path
     @path ||= '/' + pathbuilder.join('/')
   end
 
   # Returns the value of this object's parameter given by name
   # @param name [String] the name of the parameter
   # @return [Object] the value
   def parameter(name)
     @parameters[name.to_sym]
   end
 
   # Returns a shallow copy of this object's hash of attributes by name.
   # Note that his not only comprises parameters, but also properties and metaparameters.
   # Changes to the contained parameters will have an effect on the parameters of this type, but changes to
   # the returned hash does not.
   # @return [Hash{String => Object}] a new hash being a shallow copy of the parameters map name to parameter
   def parameters
     @parameters.dup
   end
 
   # @return [Boolean] Returns whether the attribute given by name has been added
   #   to this resource or not.
   def propertydefined?(name)
     name = name.intern unless name.is_a? Symbol
     @parameters.include?(name)
   end
 
   # Returns a {Puppet::Property} instance by name.
   # To return the value, use 'resource[param]'
   # @todo LAK:NOTE(20081028) Since the 'parameter' method is now a superset of this method,
   #   this one should probably go away at some point. - Does this mean it should be deprecated ?
   # @return [Puppet::Property] the property with the given name, or nil if not a property or does not exist.
   def property(name)
     (obj = @parameters[name.intern] and obj.is_a?(Puppet::Property)) ? obj : nil
   end
 
   # @todo comment says "For any parameters or properties that have defaults and have not yet been
   #   set, set them now.  This method can be handed a list of attributes,
   #   and if so it will only set defaults for those attributes."
   # @todo Needs a better explanation, and investigation about the claim an array can be passed (it is passed
   #   to self.class.attrclass to produce a class on which a check is made if it has a method class :default (does
   #   not seem to support an array...
   # @return [void]
   #
   def set_default(attr)
     return unless klass = self.class.attrclass(attr)
     return unless klass.method_defined?(:default)
     return if @parameters.include?(klass.name)
 
     return unless parameter = newattr(klass.name)
 
     if value = parameter.default and ! value.nil?
       parameter.value = value
     else
       @parameters.delete(parameter.name)
     end
   end
 
   # @todo the comment says: "Convert our object to a hash.  This just includes properties."
   # @todo this is confused, again it is the @parameters instance variable that is consulted, and
   #   each value is copied - does it contain "properties" and "parameters" or both? Does it contain
   #   meta-parameters?
   #
   # @return [Hash{ ??? => ??? }] a hash of WHAT?. The hash is a shallow copy, any changes to the
   #  objects returned in this hash will be reflected in the original resource having these attributes.
   #
   def to_hash
     rethash = {}
 
     @parameters.each do |name, obj|
       rethash[name] = obj.value
     end
 
     rethash
   end
 
   # @return [String] the name of this object's class
   # @todo Would that be "file" for the "File" resource type? of "File" or something else?
   #
   def type
     self.class.name
   end
 
   # @todo Comment says "Return a specific value for an attribute.", as opposed to what "An upspecific value"???
   # @todo is this the 'is' or the 'should' value?
   # @todo why is the return restricted to things that respond to :value? (Only non structural basic data types
   #   supported?
   #
   # @return [Object, nil] the value of the attribute having the given name, or nil if the given name is not
   #   an attribute, or the referenced attribute does not respond to `:value`.
   def value(name)
     name = name.intern
 
     (obj = @parameters[name] and obj.respond_to?(:value)) ? obj.value : nil
   end
 
   # @todo What is this used for? Needs a better explanation.
   # @return [???] the version of the catalog or 0 if there is no catalog.
   def version
     return 0 unless catalog
     catalog.version
   end
 
   # @return [Array<Puppet::Property>] Returns all of the property objects, in the order specified in the
   #   class.
   # @todo "what does the 'order specified in the class' mean? The order the properties where added in the
   #   ruby file adding a new type with new properties?
   #
   def properties
     self.class.properties.collect { |prop| @parameters[prop.name] }.compact
   end
 
   # Returns true if the type's notion of name is the identity of a resource.
   # See the overview of this class for a longer explanation of the concept _isomorphism_.
   # Defaults to true.
   #
   # @return [Boolan] true, if this type's name is isomorphic with the object
   def self.isomorphic?
     if defined?(@isomorphic)
       return @isomorphic
     else
       return true
     end
   end
 
   # @todo check that this gets documentation (it is at the class level as well as instance).
   # (see isomorphic?)
   def isomorphic?
     self.class.isomorphic?
   end
 
   # Returns true if the instance is a managed instance.
   # A 'yes' here means that the instance was created from the language, vs. being created
   # in order resolve other questions, such as finding a package in a list.
   # @note An object that is managed always stays managed, but an object that is not managed
   #   may become managed later in its lifecycle.
   # @return [Boolean] true if the object is managed
   def managed?
     # Once an object is managed, it always stays managed; but an object
     # that is listed as unmanaged might become managed later in the process,
     # so we have to check that every time
     if @managed
       return @managed
     else
       @managed = false
       properties.each { |property|
         s = property.should
         if s and ! property.class.unmanaged
           @managed = true
           break
         end
       }
       return @managed
     end
   end
 
   ###############################
   # Code related to the container behaviour.
 
   # Returns true if the search should be done in depth-first order.
   # This implementation always returns false.
   # @todo What is this used for?
   #
   # @return [Boolean] true if the search should be done in depth first order.
   #
   def depthfirst?
     false
   end
 
   # Removes this object (FROM WHERE?)
   # @todo removes if from where?
   # @return [void]
   def remove()
     # This is hackish (mmm, cut and paste), but it works for now, and it's
     # better than warnings.
     @parameters.each do |name, obj|
       obj.remove
     end
     @parameters.clear
 
     @parent = nil
 
     # Remove the reference to the provider.
     if self.provider
       @provider.clear
       @provider = nil
     end
   end
 
   ###############################
   # Code related to evaluating the resources.
 
   # Returns the ancestors - WHAT?
   # This implementation always returns an empty list.
   # @todo WHAT IS THIS ?
   # @return [Array<???>] returns a list of ancestors.
   def ancestors
     []
   end
 
   # Lifecycle method for a resource. This is called during graph creation.
   # It should perform any consistency checking of the catalog and raise a
   # Puppet::Error if the transaction should be aborted.
   #
   # It differs from the validate method, since it is called later during
   # initialization and can rely on self.catalog to have references to all
   # resources that comprise the catalog.
   #
   # @see Puppet::Transaction#add_vertex
   # @raise [Puppet::Error] If the pre-run check failed.
   # @return [void]
   # @abstract a resource type may implement this method to perform
   #   validation checks that can query the complete catalog
   def pre_run_check
   end
 
   # Flushes the provider if supported by the provider, else no action.
   # This is called by the transaction.
   # @todo What does Flushing the provider mean? Why is it interesting to know that this is
   #   called by the transaction? (It is not explained anywhere what a transaction is).
   #
   # @return [???, nil] WHAT DOES IT RETURN? GUESS IS VOID
   def flush
     self.provider.flush if self.provider and self.provider.respond_to?(:flush)
   end
 
   # Returns true if all contained objects are in sync.
   # @todo "contained in what?" in the given "in" parameter?
   #
   # @todo deal with the comment _"FIXME I don't think this is used on the type instances any more,
   #   it's really only used for testing"_
   # @return [Boolean] true if in sync, false otherwise.
   #
   def insync?(is)
     insync = true
 
     if property = @parameters[:ensure]
       unless is.include? property
         raise Puppet::DevError,
           "The is value is not in the is array for '#{property.name}'"
       end
       ensureis = is[property]
       if property.safe_insync?(ensureis) and property.should == :absent
         return true
       end
     end
 
-    properties.each { |property|
-      unless is.include? property
+    properties.each { |prop|
+      unless is.include? prop
         raise Puppet::DevError,
-          "The is value is not in the is array for '#{property.name}'"
+          "The is value is not in the is array for '#{prop.name}'"
       end
 
-      propis = is[property]
-      unless property.safe_insync?(propis)
-        property.debug("Not in sync: #{propis.inspect} vs #{property.should.inspect}")
+      propis = is[prop]
+      unless prop.safe_insync?(propis)
+        prop.debug("Not in sync: #{propis.inspect} vs #{prop.should.inspect}")
         insync = false
       #else
       #    property.debug("In sync")
       end
     }
 
     #self.debug("#{self} sync status is #{insync}")
     insync
   end
 
   # Retrieves the current value of all contained properties.
   # Parameters and meta-parameters are not included in the result.
   # @todo As oposed to all non contained properties? How is this different than any of the other
   #   methods that also "gets" properties/parameters/etc. ?
   # @return [Puppet::Resource] array of all property values (mix of types)
   # @raise [fail???] if there is a provider and it is not suitable for the host this is evaluated for.
   def retrieve
     fail "Provider #{provider.class.name} is not functional on this host" if self.provider.is_a?(Puppet::Provider) and ! provider.class.suitable?
 
     result = Puppet::Resource.new(self.class, title)
 
     # Provide the name, so we know we'll always refer to a real thing
     result[:name] = self[:name] unless self[:name] == title
 
     if ensure_prop = property(:ensure) or (self.class.validattr?(:ensure) and ensure_prop = newattr(:ensure))
       result[:ensure] = ensure_state = ensure_prop.retrieve
     else
       ensure_state = nil
     end
 
     properties.each do |property|
       next if property.name == :ensure
       if ensure_state == :absent
         result[property] = :absent
       else
         result[property] = property.retrieve
       end
     end
 
     result
   end
 
   # Retrieve the current state of the system as a Puppet::Resource. For
   # the base Puppet::Type this does the same thing as #retrieve, but
   # specific types are free to implement #retrieve as returning a hash,
   # and this will call #retrieve and convert the hash to a resource.
   # This is used when determining when syncing a resource.
   #
   # @return [Puppet::Resource] A resource representing the current state
   #   of the system.
   #
   # @api private
   def retrieve_resource
     resource = retrieve
     resource = Resource.new(self.class, title, :parameters => resource) if resource.is_a? Hash
     resource
   end
 
   # Given the hash of current properties, should this resource be treated as if it
   # currently exists on the system. May need to be overridden by types that offer up
   # more than just :absent and :present.
   def present?(current_values)
     current_values[:ensure] != :absent
   end
 
   # Returns a hash of the current properties and their values.
   # If a resource is absent, its value is the symbol `:absent`
   # @return [Hash{Puppet::Property => Object}] mapping of property instance to its value
   #
   def currentpropvalues
     # It's important to use the 'properties' method here, as it follows the order
     # in which they're defined in the class.  It also guarantees that 'ensure'
     # is the first property, which is important for skipping 'retrieve' on
     # all the properties if the resource is absent.
     ensure_state = false
     return properties.inject({}) do | prophash, property|
       if property.name == :ensure
         ensure_state = property.retrieve
         prophash[property] = ensure_state
       else
         if ensure_state == :absent
           prophash[property] = :absent
         else
           prophash[property] = property.retrieve
         end
       end
       prophash
     end
   end
 
   # Returns the `noop` run mode status of this.
   # @return [Boolean] true if running in noop mode.
   def noop?
     # If we're not a host_config, we're almost certainly part of
     # Settings, and we want to ignore 'noop'
     return false if catalog and ! catalog.host_config?
 
     if defined?(@noop)
       @noop
     else
       Puppet[:noop]
     end
   end
 
   # (see #noop?)
   def noop
     noop?
   end
 
   # Retrieves all known instances.
   # @todo Retrieves them from where? Known to whom?
   # Either requires providers or must be overridden.
   # @raise [Puppet::DevError] when there are no providers and the implementation has not overridded this method.
   def self.instances
     raise Puppet::DevError, "#{self.name} has no providers and has not overridden 'instances'" if provider_hash.empty?
 
     # Put the default provider first, then the rest of the suitable providers.
     provider_instances = {}
     providers_by_source.collect do |provider|
       self.properties.find_all do |property|
         provider.supports_parameter?(property)
       end.collect do |property|
         property.name
       end
 
       provider.instances.collect do |instance|
         # We always want to use the "first" provider instance we find, unless the resource
         # is already managed and has a different provider set
         if other = provider_instances[instance.name]
           Puppet.debug "%s %s found in both %s and %s; skipping the %s version" %
             [self.name.to_s.capitalize, instance.name, other.class.name, instance.class.name, instance.class.name]
           next
         end
         provider_instances[instance.name] = instance
 
         result = new(:name => instance.name, :provider => instance)
         properties.each { |name| result.newattr(name) }
         result
       end
     end.flatten.compact
   end
 
   # Returns a list of one suitable provider per source, with the default provider first.
   # @todo Needs better explanation; what does "source" mean in this context?
   # @return [Array<Puppet::Provider>] list of providers
   #
   def self.providers_by_source
     # Put the default provider first (can be nil), then the rest of the suitable providers.
     sources = []
     [defaultprovider, suitableprovider].flatten.uniq.collect do |provider|
       next if provider.nil?
       next if sources.include?(provider.source)
 
       sources << provider.source
       provider
     end.compact
   end
 
   # Converts a simple hash into a Resource instance.
   # @todo as opposed to a complex hash? Other raised exceptions?
   # @param [Hash{Symbol, String => Object}] hash resource attribute to value map to initialize the created resource from
   # @return [Puppet::Resource] the resource created from the hash
   # @raise [Puppet::Error] if a title is missing in the given hash
   def self.hash2resource(hash)
     hash = hash.inject({}) { |result, ary| result[ary[0].to_sym] = ary[1]; result }
 
     title = hash.delete(:title)
     title ||= hash[:name]
     title ||= hash[key_attributes.first] if key_attributes.length == 1
 
     raise Puppet::Error, "Title or name must be provided" unless title
 
     # Now create our resource.
     resource = Puppet::Resource.new(self, title)
     resource.catalog = hash.delete(:catalog)
 
     hash.each do |param, value|
       resource[param] = value
     end
     resource
   end
 
 
   # Returns an array of strings representing the containment heirarchy
   # (types/classes) that make up the path to the resource from the root
   # of the catalog.  This is mostly used for logging purposes.
   #
   # @api private
   def pathbuilder
     if p = parent
       [p.pathbuilder, self.ref].flatten
     else
       [self.ref]
     end
   end
 
   ###############################
   # Add all of the meta-parameters.
   newmetaparam(:noop) do
     desc "Whether to apply this resource in noop mode.
 
       When applying a resource in noop mode, Puppet will check whether it is in sync,
       like it does when running normally. However, if a resource attribute is not in
       the desired state (as declared in the catalog), Puppet will take no
       action, and will instead report the changes it _would_ have made. These
       simulated changes will appear in the report sent to the puppet master, or
       be shown on the console if running puppet agent or puppet apply in the
       foreground. The simulated changes will not send refresh events to any
       subscribing or notified resources, although Puppet will log that a refresh
       event _would_ have been sent.
 
       **Important note:**
       [The `noop` setting](http://docs.puppetlabs.com/references/latest/configuration.html#noop)
       allows you to globally enable or disable noop mode, but it will _not_ override
       the `noop` metaparameter on individual resources. That is, the value of the
       global `noop` setting will _only_ affect resources that do not have an explicit
       value set for their `noop` attribute."
 
     newvalues(:true, :false)
     munge do |value|
       case value
       when true, :true, "true"; @resource.noop = true
       when false, :false, "false"; @resource.noop = false
       end
     end
   end
 
   newmetaparam(:schedule) do
     desc "A schedule to govern when Puppet is allowed to manage this resource.
       The value of this metaparameter must be the `name` of a `schedule`
       resource. This means you must declare a schedule resource, then
       refer to it by name; see
       [the docs for the `schedule` type](http://docs.puppetlabs.com/references/latest/type.html#schedule)
       for more info.
 
           schedule { 'everyday':
             period => daily,
             range  => \"2-4\"
           }
 
           exec { \"/usr/bin/apt-get update\":
             schedule => 'everyday'
           }
 
       Note that you can declare the schedule resource anywhere in your
       manifests, as long as it ends up in the final compiled catalog."
   end
 
   newmetaparam(:audit) do
     desc "Marks a subset of this resource's unmanaged attributes for auditing. Accepts an
       attribute name, an array of attribute names, or `all`.
 
       Auditing a resource attribute has two effects: First, whenever a catalog
       is applied with puppet apply or puppet agent, Puppet will check whether
       that attribute of the resource has been modified, comparing its current
       value to the previous run; any change will be logged alongside any actions
       performed by Puppet while applying the catalog.
 
       Secondly, marking a resource attribute for auditing will include that
       attribute in inspection reports generated by puppet inspect; see the
       puppet inspect documentation for more details.
 
       Managed attributes for a resource can also be audited, but note that
       changes made by Puppet will be logged as additional modifications. (I.e.
       if a user manually edits a file whose contents are audited and managed,
       puppet agent's next two runs will both log an audit notice: the first run
       will log the user's edit and then revert the file to the desired state,
       and the second run will log the edit made by Puppet.)"
 
     validate do |list|
       list = Array(list).collect {|p| p.to_sym}
       unless list == [:all]
         list.each do |param|
           next if @resource.class.validattr?(param)
           fail "Cannot audit #{param}: not a valid attribute for #{resource}"
         end
       end
     end
 
     munge do |args|
       properties_to_audit(args).each do |param|
         next unless resource.class.validproperty?(param)
         resource.newattr(param)
       end
     end
 
     def all_properties
       resource.class.properties.find_all do |property|
         resource.provider.nil? or resource.provider.class.supports_parameter?(property)
       end.collect do |property|
         property.name
       end
     end
 
     def properties_to_audit(list)
       if !list.kind_of?(Array) && list.to_sym == :all
         list = all_properties
       else
         list = Array(list).collect { |p| p.to_sym }
       end
     end
   end
 
   newmetaparam(:loglevel) do
     desc "Sets the level that information will be logged.
       The log levels have the biggest impact when logs are sent to
       syslog (which is currently the default).
 
       The order of the log levels, in decreasing priority, is:
 
       * `crit`
       * `emerg`
       * `alert`
       * `err`
       * `warning`
       * `notice`
       * `info` / `verbose`
       * `debug`
       "
     defaultto :notice
 
     newvalues(*Puppet::Util::Log.levels)
     newvalues(:verbose)
 
     munge do |loglevel|
       val = super(loglevel)
       if val == :verbose
         val = :info
       end
       val
     end
   end
 
   newmetaparam(:alias) do
     desc %q{Creates an alias for the resource.  Puppet uses this internally when you
       provide a symbolic title and an explicit namevar value:
 
           file { 'sshdconfig':
             path => $operatingsystem ? {
               solaris => '/usr/local/etc/ssh/sshd_config',
               default => '/etc/ssh/sshd_config',
             },
             source => '...'
           }
 
           service { 'sshd':
             subscribe => File['sshdconfig'],
           }
 
       When you use this feature, the parser sets `sshdconfig` as the title,
       and the library sets that as an alias for the file so the dependency
       lookup in `Service['sshd']` works.  You can use this metaparameter yourself,
       but note that aliases generally only work for creating relationships; anything
       else that refers to an existing resource (such as amending or overriding
       resource attributes in an inherited class) must use the resource's exact
       title. For example, the following code will not work:
 
           file { '/etc/ssh/sshd_config':
             owner => root,
             group => root,
             alias => 'sshdconfig',
           }
 
           File['sshdconfig'] {
             mode => '0644',
           }
 
       There's no way here for the Puppet parser to know that these two stanzas
       should be affecting the same file.
 
       }
 
     munge do |aliases|
       aliases = [aliases] unless aliases.is_a?(Array)
 
       raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog
 
       aliases.each do |other|
         if obj = @resource.catalog.resource(@resource.class.name, other)
           unless obj.object_id == @resource.object_id
             self.fail("#{@resource.title} can not create alias #{other}: object already exists")
           end
           next
         end
 
         # Newschool, add it to the catalog.
         @resource.catalog.alias(@resource, other)
       end
     end
   end
 
   newmetaparam(:tag) do
     desc "Add the specified tags to the associated resource.  While all resources
       are automatically tagged with as much information as possible
       (e.g., each class and definition containing the resource), it can
       be useful to add your own tags to a given resource.
 
       Multiple tags can be specified as an array:
 
           file {'/etc/hosts':
             ensure => file,
             source => 'puppet:///modules/site/hosts',
             mode   => '0644',
             tag    => ['bootstrap', 'minimumrun', 'mediumrun'],
           }
 
       Tags are useful for things like applying a subset of a host's configuration
       with [the `tags` setting](/references/latest/configuration.html#tags)
       (e.g. `puppet agent --test --tags bootstrap`)."
 
     munge do |tags|
       tags = [tags] unless tags.is_a? Array
 
       tags.each do |tag|
         @resource.tag(tag)
       end
     end
   end
 
   # RelationshipMetaparam is an implementation supporting the meta-parameters `:require`, `:subscribe`,
   # `:notify`, and `:before`.
   #
   #
   class RelationshipMetaparam < Puppet::Parameter
     class << self
       attr_accessor :direction, :events, :callback, :subclasses
     end
 
     @subclasses = []
 
     def self.inherited(sub)
       @subclasses << sub
     end
 
     # @return [Array<Puppet::Resource>] turns attribute value(s) into list of resources
     def munge(references)
       references = [references] unless references.is_a?(Array)
       references.collect do |ref|
         if ref.is_a?(Puppet::Resource)
           ref
         else
           Puppet::Resource.new(ref)
         end
       end
     end
 
     # Checks each reference to assert that what it references exists in the catalog.
     #
     # @raise [???fail] if the referenced resource can not be found
     # @return [void]
     def validate_relationship
       @value.each do |ref|
         unless @resource.catalog.resource(ref.to_s)
           description = self.class.direction == :in ? "dependency" : "dependent"
           fail ResourceError, "Could not find #{description} #{ref} for #{resource.ref}"
         end
       end
     end
 
     # Creates edges for all relationships.
     # The `:in` relationships are specified by the event-receivers, and `:out`
     # relationships are specified by the event generator.
     # @todo references to "event-receivers" and "event generator" means in this context - are those just
     #   the resources at the two ends of the relationship?
     # This way 'source' and 'target' are consistent terms in both edges
     # and events, i.e. an event targets edges whose source matches
     # the event's source. The direction of the relationship determines
     # which resource is applied first and which resource is considered
     # to be the event generator.
     # @return [Array<Puppet::Relationship>]
     # @raise [???fail] when a reference can not be resolved
     #
     def to_edges
       @value.collect do |reference|
         reference.catalog = resource.catalog
 
         # Either of the two retrieval attempts could have returned
         # nil.
         unless related_resource = reference.resolve
           self.fail "Could not retrieve dependency '#{reference}' of #{@resource.ref}"
         end
 
         # Are we requiring them, or vice versa?  See the method docs
         # for futher info on this.
         if self.class.direction == :in
           source = related_resource
           target = @resource
         else
           source = @resource
           target = related_resource
         end
 
         if method = self.class.callback
           subargs = {
             :event => self.class.events,
             :callback => method
           }
           self.debug("subscribes to #{related_resource.ref}")
         else
           # If there's no callback, there's no point in even adding
           # a label.
           subargs = nil
           self.debug("requires #{related_resource.ref}")
         end
 
         Puppet::Relationship.new(source, target, subargs)
       end
     end
   end
 
   # @todo document this, have no clue what this does... it retuns "RelationshipMetaparam.subclasses"
   #
   def self.relationship_params
     RelationshipMetaparam.subclasses
   end
 
 
   # Note that the order in which the relationships params is defined
   # matters.  The labelled params (notify and subcribe) must be later,
   # so that if both params are used, those ones win.  It's a hackish
   # solution, but it works.
 
   newmetaparam(:require, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
     desc "One or more resources that this resource depends on, expressed as
       [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
       * The required resource(s) will be applied **before** this resource.
 
       This is one of the four relationship metaparameters, along with
       `before`, `notify`, and `subscribe`. For more context, including the
       alternate chaining arrow (`->` and `~>`) syntax, see
       [the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
   end
 
   newmetaparam(:subscribe, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :ALL_EVENTS, :callback => :refresh}) do
     desc "One or more resources that this resource depends on, expressed as
       [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
       * The subscribed resource(s) will be applied _before_ this resource.
       * If Puppet makes changes to any of the subscribed resources, it will cause
         this resource to _refresh._ (Refresh behavior varies by resource
         type: services will restart, mounts will unmount and re-mount, etc. Not
         all types can refresh.)
 
       This is one of the four relationship metaparameters, along with
       `before`, `require`, and `notify`. For more context, including the
       alternate chaining arrow (`->` and `~>`) syntax, see
       [the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
   end
 
   newmetaparam(:before, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
     desc "One or more resources that depend on this resource, expressed as
       [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
       * This resource will be applied _before_ the dependent resource(s).
 
       This is one of the four relationship metaparameters, along with
       `require`, `notify`, and `subscribe`. For more context, including the
       alternate chaining arrow (`->` and `~>`) syntax, see
       [the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
   end
 
   newmetaparam(:notify, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :ALL_EVENTS, :callback => :refresh}) do
     desc "One or more resources that depend on this resource, expressed as
       [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
       * This resource will be applied _before_ the notified resource(s).
       * If Puppet makes changes to this resource, it will cause all of the
         notified resources to _refresh._ (Refresh behavior varies by resource
         type: services will restart, mounts will unmount and re-mount, etc. Not
         all types can refresh.)
 
       This is one of the four relationship metaparameters, along with
       `before`, `require`, and `subscribe`. For more context, including the
       alternate chaining arrow (`->` and `~>`) syntax, see
       [the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
   end
 
   newmetaparam(:stage) do
     desc %{Which run stage this class should reside in.
 
       **Note: This metaparameter can only be used on classes,** and only when
       declaring them with the resource-like syntax. It cannot be used on normal
       resources or on classes declared with `include`.
 
       By default, all classes are declared in the `main` stage. To assign a class
       to a different stage, you must:
 
       * Declare the new stage as a [`stage` resource](http://docs.puppetlabs.com/references/latest/type.html#stage).
       * Declare an order relationship between the new stage and the `main` stage.
       * Use the resource-like syntax to declare the class, and set the `stage`
         metaparameter to the name of the desired stage.
 
       For example:
 
           stage { 'pre':
             before => Stage['main'],
           }
 
           class { 'apt-updates':
             stage => 'pre',
           }
     }
   end
 
   ###############################
   # All of the provider plumbing for the resource types.
   require 'puppet/provider'
   require 'puppet/util/provider_features'
 
   # Add the feature handling module.
   extend Puppet::Util::ProviderFeatures
 
   # The provider that has been selected for the instance of the resource type.
   # @return [Puppet::Provider,nil] the selected provider or nil, if none has been selected
   #
   attr_reader :provider
 
   # the Type class attribute accessors
   class << self
     # The loader of providers to use when loading providers from disk.
     # Although it looks like this attribute provides a way to operate with different loaders of
     # providers that is not the case; the attribute is written when a new type is created,
     # and should not be changed thereafter.
     # @api private
     #
     attr_accessor :providerloader
 
     # @todo Don't know if this is a name, or a reference to a Provider instance (now marked up as an instance
     #   of Provider.
     # @return [Puppet::Provider, nil] The default provider for this type, or nil if non is defines
     #
     attr_writer :defaultprovider
   end
 
   # The default provider, or the most suitable provider if no default provider was set.
   # @note a warning will be issued if no default provider has been configured and a search for the most
   #   suitable provider returns more than one equally suitable provider.
   # @return [Puppet::Provider, nil] the default or most suitable provider, or nil if no provider was found
   #
   def self.defaultprovider
     return @defaultprovider if @defaultprovider
 
     suitable = suitableprovider
 
     # Find which providers are a default for this system.
     defaults = suitable.find_all { |provider| provider.default? }
 
     # If we don't have any default we use suitable providers
     defaults = suitable if defaults.empty?
     max = defaults.collect { |provider| provider.specificity }.max
     defaults = defaults.find_all { |provider| provider.specificity == max }
 
     if defaults.length > 1
       Puppet.warning(
         "Found multiple default providers for #{self.name}: #{defaults.collect { |i| i.name.to_s }.join(", ")}; using #{defaults[0].name}"
       )
     end
 
     @defaultprovider = defaults.shift unless defaults.empty?
   end
 
   # @return [Hash{??? => Puppet::Provider}] Returns a hash of WHAT EXACTLY for the given type
   # @todo what goes into this hash?
   def self.provider_hash_by_type(type)
     @provider_hashes ||= {}
     @provider_hashes[type] ||= {}
   end
 
   # @return [Hash{ ??? => Puppet::Provider}] Returns a hash of WHAT EXACTLY for this type.
   # @see provider_hash_by_type method to get the same for some other type
   def self.provider_hash
     Puppet::Type.provider_hash_by_type(self.name)
   end
 
   # Returns the provider having the given name.
   # This will load a provider if it is not already loaded. The returned provider is the first found provider
   # having the given name, where "first found" semantics is defined by the {providerloader} in use.
   #
   # @param name [String] the name of the provider to get
   # @return [Puppet::Provider, nil] the found provider, or nil if no provider of the given name was found
   #
   def self.provider(name)
     name = name.intern
 
     # If we don't have it yet, try loading it.
     @providerloader.load(name) unless provider_hash.has_key?(name)
     provider_hash[name]
   end
 
   # Returns a list of loaded providers by name.
   # This method will not load/search for available providers.
   # @return [Array<String>] list of loaded provider names
   #
   def self.providers
     provider_hash.keys
   end
 
   # Returns true if the given name is a reference to a provider and if this is a suitable provider for
   # this type.
   # @todo How does the provider know if it is suitable for the type? Is it just suitable for the platform/
   #   environment where this method is executing?
   # @param name [String] the name of the provider for which validity is checked
   # @return [Boolean] true if the given name references a provider that is suitable
   #
   def self.validprovider?(name)
     name = name.intern
 
     (provider_hash.has_key?(name) && provider_hash[name].suitable?)
   end
 
   # Creates a new provider of a type.
   # This method must be called directly on the type that it's implementing.
   # @todo Fix Confusing Explanations!
   #   Is this a new provider of a Type (metatype), or a provider of an instance of Type (a resource), or
   #   a Provider (the implementation of a Type's behavior). CONFUSED. It calls magically named methods like
   #   "providify" ...
   # @param name [String, Symbol] the name of the WHAT? provider? type?
   # @param options [Hash{Symbol => Object}] a hash of options, used by this method, and passed on to {#genclass}, (see
   #   it for additional options to pass).
   # @option options [Puppet::Provider] :parent the parent provider (what is this?)
   # @option options [Puppet::Type] :resource_type the resource type, defaults to this type if unspecified
   # @return [Puppet::Provider] a provider ???
   # @raise [Puppet::DevError] when the parent provider could not be found.
   #
   def self.provide(name, options = {}, &block)
     name = name.intern
 
     if unprovide(name)
       Puppet.debug "Reloading #{name} #{self.name} provider"
     end
 
     parent = if pname = options[:parent]
       options.delete(:parent)
       if pname.is_a? Class
         pname
       else
         if provider = self.provider(pname)
           provider
         else
           raise Puppet::DevError,
             "Could not find parent provider #{pname} of #{name}"
         end
       end
     else
       Puppet::Provider
     end
 
     options[:resource_type] ||= self
 
     self.providify
 
     provider = genclass(
       name,
       :parent     => parent,
       :hash       => provider_hash,
       :prefix     => "Provider",
       :block      => block,
       :include    => feature_module,
       :extend     => feature_module,
       :attributes => options
     )
 
     provider
   end
 
   # Ensures there is a `:provider` parameter defined.
   # Should only be called if there are providers.
   # @return [void]
   def self.providify
     return if @paramhash.has_key? :provider
 
     newparam(:provider) do
       # We're using a hacky way to get the name of our type, since there doesn't
       # seem to be a correct way to introspect this at the time this code is run.
       # We expect that the class in which this code is executed will be something
       # like Puppet::Type::Ssh_authorized_key::ParameterProvider.
       desc <<-EOT
         The specific backend to use for this `#{self.to_s.split('::')[2].downcase}`
         resource. You will seldom need to specify this --- Puppet will usually
         discover the appropriate provider for your platform.
       EOT
 
       # This is so we can refer back to the type to get a list of
       # providers for documentation.
       class << self
         # The reference to a parent type for the parameter `:provider` used to get a list of
         # providers for documentation purposes.
         #
         attr_accessor :parenttype
       end
 
       # Provides the ability to add documentation to a provider.
       #
       def self.doc
         # Since we're mixing @doc with text from other sources, we must normalize
         # its indentation with scrub. But we don't need to manually scrub the
         # provider's doc string, since markdown_definitionlist sanitizes its inputs.
         scrub(@doc) + "Available providers are:\n\n" + parenttype.providers.sort { |a,b|
           a.to_s <=> b.to_s
         }.collect { |i|
           markdown_definitionlist( i, scrub(parenttype().provider(i).doc) )
         }.join
       end
 
       # For each resource, the provider param defaults to
       # the type's default provider
       defaultto {
         prov = @resource.class.defaultprovider
         prov.name if prov
       }
 
       validate do |provider_class|
         provider_class = provider_class[0] if provider_class.is_a? Array
         provider_class = provider_class.class.name if provider_class.is_a?(Puppet::Provider)
 
         unless @resource.class.provider(provider_class)
           raise ArgumentError, "Invalid #{@resource.class.name} provider '#{provider_class}'"
         end
       end
 
       munge do |provider|
         provider = provider[0] if provider.is_a? Array
         provider = provider.intern if provider.is_a? String
         @resource.provider = provider
 
         if provider.is_a?(Puppet::Provider)
           provider.class.name
         else
           provider
         end
       end
     end.parenttype = self
   end
 
   # @todo this needs a better explanation
   # Removes the implementation class of a given provider.
   # @return [Object] returns what {Puppet::Util::ClassGen#rmclass} returns
   def self.unprovide(name)
     if @defaultprovider and @defaultprovider.name == name
       @defaultprovider = nil
     end
 
     rmclass(name, :hash => provider_hash, :prefix => "Provider")
   end
 
   # Returns a list of suitable providers for the given type.
   # A call to this method will load all providers if not already loaded and ask each if it is
   # suitable - those that are are included in the result.
   # @note This method also does some special processing which rejects a provider named `:fake` (for testing purposes).
   # @return [Array<Puppet::Provider>] Returns an array of all suitable providers.
   #
   def self.suitableprovider
     providerloader.loadall if provider_hash.empty?
     provider_hash.find_all { |name, provider|
       provider.suitable?
     }.collect { |name, provider|
       provider
     }.reject { |p| p.name == :fake } # For testing
   end
 
   # @return [Boolean] Returns true if this is something else than a `:provider`, or if it
   #   is a provider and it is suitable, or if there is a default provider. Otherwise, false is returned.
   #
   def suitable?
     # If we don't use providers, then we consider it suitable.
     return true unless self.class.paramclass(:provider)
 
     # We have a provider and it is suitable.
     return true if provider && provider.class.suitable?
 
     # We're using the default provider and there is one.
     if !provider and self.class.defaultprovider
       self.provider = self.class.defaultprovider.name
       return true
     end
 
     # We specified an unsuitable provider, or there isn't any suitable
     # provider.
     false
   end
 
   # Sets the provider to the given provider/name.
   # @overload provider=(name)
   #   Sets the provider to the result of resolving the name to an instance of Provider.
   #   @param name [String] the name of the provider
   # @overload provider=(provider)
   #   Sets the provider to the given instances of Provider.
   #   @param provider [Puppet::Provider] the provider to set
   # @return [Puppet::Provider] the provider set
   # @raise [ArgumentError] if the provider could not be found/resolved.
   #
   def provider=(name)
     if name.is_a?(Puppet::Provider)
       @provider = name
       @provider.resource = self
     elsif klass = self.class.provider(name)
       @provider = klass.new(self)
     else
       raise ArgumentError, "Could not find #{name} provider of #{self.class.name}"
     end
   end
 
   ###############################
   # All of the relationship code.
 
   # Adds a block producing a single name (or list of names) of the given
   # resource type name to autorelate.
   #
   # The four relationship types require, before, notify, and subscribe are all
   # supported.
   #
   # Be *careful* with notify and subscribe as they may have unintended
   # consequences.
   #
   # Resources in the catalog that have the named type and a title that is
   # included in the result will be linked to the calling resource as a
   # requirement.
   #
   # @example Autorequire the files File['foo', 'bar']
   #   autorequire( 'file', {|| ['foo', 'bar'] })
   #
   # @example Autobefore the files File['foo', 'bar']
   #   autobefore( 'file', {|| ['foo', 'bar'] })
   #
   # @example Autosubscribe the files File['foo', 'bar']
   #   autosubscribe( 'file', {|| ['foo', 'bar'] })
   #
   # @example Autonotify the files File['foo', 'bar']
   #   autonotify( 'file', {|| ['foo', 'bar'] })
   #
   # @param name [String] the name of a type of which one or several resources should be autorelated e.g. "file"
   # @yield [ ] a block returning list of names of given type to auto require
   # @yieldreturn [String, Array<String>] one or several resource names for the named type
   # @return [void]
   # @dsl type
   # @api public
   #
   def self.autorequire(name, &block)
     @autorequires ||= {}
     @autorequires[name] = block
   end
 
   def self.autobefore(name, &block)
     @autobefores ||= {}
     @autobefores[name] = block
   end
 
   def self.autosubscribe(name, &block)
     @autosubscribes ||= {}
     @autosubscribes[name] = block
   end
 
   def self.autonotify(name, &block)
     @autonotifies ||= {}
     @autonotifies[name] = block
   end
 
   # Provides iteration over added auto-requirements (see {autorequire}).
   # @yieldparam type [String] the name of the type to autoriquire an instance of
   # @yieldparam block [Proc] a block producing one or several dependencies to auto require (see {autorequire}).
   # @yieldreturn [void]
   # @return [void]
   def self.eachautorequire
     @autorequires ||= {}
     @autorequires.each { |type, block|
       yield(type, block)
     }
   end
 
   # Provides iteration over added auto-requirements (see {autobefore}).
   # @yieldparam type [String] the name of the type to autoriquire an instance of
   # @yieldparam block [Proc] a block producing one or several dependencies to auto require (see {autobefore}).
   # @yieldreturn [void]
   # @return [void]
   def self.eachautobefore
     @autobefores ||= {}
     @autobefores.each { |type,block|
       yield(type, block)
     }
   end
 
   # Provides iteration over added auto-requirements (see {autosubscribe}).
   # @yieldparam type [String] the name of the type to autoriquire an instance of
   # @yieldparam block [Proc] a block producing one or several dependencies to auto require (see {autosubscribe}).
   # @yieldreturn [void]
   # @return [void]
   def self.eachautosubscribe
     @autosubscribes ||= {}
     @autosubscribes.each { |type,block|
       yield(type, block)
     }
   end
 
   # Provides iteration over added auto-requirements (see {autonotify}).
   # @yieldparam type [String] the name of the type to autoriquire an instance of
   # @yieldparam block [Proc] a block producing one or several dependencies to auto require (see {autonotify}).
   # @yieldreturn [void]
   # @return [void]
   def self.eachautonotify
     @autonotifies ||= {}
     @autonotifies.each { |type,block|
       yield(type, block)
     }
   end
 
   # Adds dependencies to the catalog from added autorelations.
   # See {autorequire} for how to add an auto-requirement.
   # @todo needs details - see the param rel_catalog, and type of this param
   # @param rel_catalog [Puppet::Resource::Catalog, nil] the catalog to
   #   add dependencies to. Defaults to the current catalog (set when the
   #   type instance was added to a catalog)
   # @raise [Puppet::DevError] if there is no catalog
   #
   def autorelation(rel_type, rel_catalog = nil)
     rel_catalog ||= catalog
     raise(Puppet::DevError, "You cannot add relationships without a catalog") unless rel_catalog
 
     reqs = []
 
     auto_rel = "eachauto#{rel_type}".to_sym
 
     self.class.send(auto_rel) { |type, block|
       # Ignore any types we can't find, although that would be a bit odd.
       next unless Puppet::Type.type(type)
 
       # Retrieve the list of names from the block.
       next unless list = self.instance_eval(&block)
       list = [list] unless list.is_a?(Array)
 
       # Collect the current prereqs
       list.each { |dep|
         # Support them passing objects directly, to save some effort.
         unless dep.is_a? Puppet::Type
           # Skip autorelation that we aren't managing
           unless dep = rel_catalog.resource(type, dep)
             next
           end
         end
 
         if [:require, :subscribe].include?(rel_type)
           reqs << Puppet::Relationship.new(dep, self)
         else
           reqs << Puppet::Relationship.new(self, dep)
         end
       }
     }
 
     reqs
   end
 
   def autorequire(rel_catalog = nil)
     autorelation(:require, rel_catalog)
   end
 
   def autobefore(rel_catalog = nil)
     autorelation(:before, rel_catalog)
   end
 
   def autosubscribe(rel_catalog = nil)
     autorelation(:subscribe, rel_catalog)
   end
 
   def autonotify(rel_catalog = nil)
     autorelation(:notify, rel_catalog)
   end
 
   # Builds the dependencies associated with this resource.
   #
   # @return [Array<Puppet::Relationship>] list of relationships to other resources
   def builddepends
     # Handle the requires
     self.class.relationship_params.collect do |klass|
       if param = @parameters[klass.name]
         param.to_edges
       end
     end.flatten.reject { |r| r.nil? }
   end
 
   # Sets the initial list of tags to associate to this resource.
   #
   # @return [void] ???
   def tags=(list)
     tag(self.class.name)
     tag(*list)
   end
 
   # @comment - these two comments were floating around here, and turned up as documentation
   #  for the attribute "title", much to my surprise and amusement. Clearly these comments
   #  are orphaned ... I think they can just be removed as what they say should be covered
   #  by the now added yardoc. <irony>(Yo! to quote some of the other actual awsome specific comments applicable
   #  to objects called from elsewhere, or not. ;-)</irony>
   #
   # @comment Types (which map to resources in the languages) are entirely composed of
   #   attribute value pairs.  Generally, Puppet calls any of these things an
   #   'attribute', but these attributes always take one of three specific
   #   forms:  parameters, metaparams, or properties.
 
   # @comment In naming methods, I have tried to consistently name the method so
   #   that it is clear whether it operates on all attributes (thus has 'attr' in
   #   the method name, or whether it operates on a specific type of attributes.
 
   # The title attribute of WHAT ???
   # @todo Figure out what this is the title attribute of (it appears on line 1926 currently).
   # @return [String] the title
   attr_writer :title
 
   # The noop attribute of WHAT ??? does WHAT???
   # @todo Figure out what this is the noop attribute of (it appears on line 1931 currently).
   # @return [???] the noop WHAT ??? (mode? if so of what, or noop for an instance of the type, or for all
   #   instances of a type, or for what???
   #
   attr_writer :noop
 
   include Enumerable
 
   # class methods dealing with Type management
 
   public
 
   # The Type class attribute accessors
   class << self
     # @return [String] the name of the resource type; e.g., "File"
     #
     attr_reader :name
 
     # @return [Boolean] true if the type should send itself a refresh event on change.
     #
     attr_accessor :self_refresh
     include Enumerable, Puppet::Util::ClassGen
     include Puppet::MetaType::Manager
 
     include Puppet::Util
     include Puppet::Util::Logging
   end
 
   # Initializes all of the variables that must be initialized for each subclass.
   # @todo Does the explanation make sense?
   # @return [void]
   def self.initvars
     # all of the instances of this class
     @objects = Hash.new
     @aliases = Hash.new
 
     @defaults = {}
 
     @parameters ||= []
 
     @validproperties = {}
     @properties = []
     @parameters = []
     @paramhash = {}
 
     @paramdoc = Hash.new { |hash,key|
       key = key.intern if key.is_a?(String)
       if hash.include?(key)
         hash[key]
       else
         "Param Documentation for #{key} not found"
       end
     }
 
     @doc ||= ""
 
   end
 
   # Returns the name of this type (if specified) or the parent type #to_s.
   # The returned name is on the form "Puppet::Type::<name>", where the first letter of name is
   # capitalized.
   # @return [String] the fully qualified name Puppet::Type::<name> where the first letter of name is captialized
   #
   def self.to_s
     if defined?(@name)
       "Puppet::Type::#{@name.to_s.capitalize}"
     else
       super
     end
   end
 
   # Creates a `validate` method that is used to validate a resource before it is operated on.
   # The validation should raise exceptions if the validation finds errors. (It is not recommended to
   # issue warnings as this typically just ends up in a logfile - you should fail if a validation fails).
   # The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with
   # the message as an argument.
   #
   # @yield [ ] a required block called with self set to the instance of a Type class representing a resource.
   # @return [void]
   # @dsl type
   # @api public
   #
   def self.validate(&block)
     define_method(:validate, &block)
   end
 
   # @return [String] The file from which this type originates from
   attr_accessor :file
 
   # @return [Integer] The line in {#file} from which this type originates from
   attr_accessor :line
 
   # @todo what does this mean "this resource" (sounds like this if for an instance of the type, not the meta Type),
   #   but not sure if this is about the catalog where the meta Type is included)
   # @return [??? TODO] The catalog that this resource is stored in.
   attr_accessor :catalog
 
   # @return [Boolean] Flag indicating if this type is exported
   attr_accessor :exported
 
   # @return [Boolean] Flag indicating if the type is virtual (it should not be).
   attr_accessor :virtual
 
   # Creates a log entry with the given message at the log level specified by the parameter `loglevel`
   # @return [void]
   #
   def log(msg)
 
     Puppet::Util::Log.create(
 
       :level => @parameters[:loglevel].value,
       :message => msg,
 
       :source => self
     )
   end
 
 
   # instance methods related to instance intrinsics
   # e.g., initialize and name
 
   public
 
   # @return [Hash] hash of parameters originally defined
   # @api private
   attr_reader :original_parameters
 
   # Creates an instance of Type from a hash or a {Puppet::Resource}.
   # @todo Unclear if this is a new Type or a new instance of a given type (the initialization ends
   #   with calling validate - which seems like validation of an instance of a given type, not a new
   #   meta type.
   #
   # @todo Explain what the Hash and Resource are. There seems to be two different types of
   #   resources; one that causes the title to be set to resource.title, and one that
   #   causes the title to be resource.ref ("for components") - what is a component?
   #
   # @overload initialize(hash)
   #   @param [Hash] hash
   #   @raise [Puppet::ResourceError] when the type validation raises
   #     Puppet::Error or ArgumentError
   # @overload initialize(resource)
   #   @param resource [Puppet:Resource]
   #   @raise [Puppet::ResourceError] when the type validation raises
   #     Puppet::Error or ArgumentError
   #
   def initialize(resource)
     resource = self.class.hash2resource(resource) unless resource.is_a?(Puppet::Resource)
 
     # The list of parameter/property instances.
     @parameters = {}
 
     # Set the title first, so any failures print correctly.
     if resource.type.to_s.downcase.to_sym == self.class.name
       self.title = resource.title
     else
       # This should only ever happen for components
       self.title = resource.ref
     end
 
     [:file, :line, :catalog, :exported, :virtual].each do |getter|
       setter = getter.to_s + "="
       if val = resource.send(getter)
         self.send(setter, val)
       end
     end
 
     @tags = resource.tags
 
     @original_parameters = resource.to_hash
 
     set_name(@original_parameters)
 
     set_default(:provider)
 
     set_parameters(@original_parameters)
 
     begin
       self.validate if self.respond_to?(:validate)
     rescue Puppet::Error, ArgumentError => detail
       error = Puppet::ResourceError.new("Validation of #{ref} failed: #{detail}")
       adderrorcontext(error, detail)
       raise error
     end
   end
 
   private
 
   # Sets the name of the resource from a hash containing a mapping of `name_var` to value.
   # Sets the value of the property/parameter appointed by the `name_var` (if it is defined). The value set is
   # given by the corresponding entry in the given hash - e.g. if name_var appoints the name `:path` the value
   # of `:path` is set to the value at the key `:path` in the given hash. As a side effect this key/value is then
   # removed from the given hash.
   #
   # @note This method mutates the given hash by removing the entry with a key equal to the value
   #   returned from name_var!
   # @param hash [Hash] a hash of what
   # @return [void]
   def set_name(hash)
     self[name_var] = hash.delete(name_var) if name_var
   end
 
   # Sets parameters from the given hash.
   # Values are set in _attribute order_ i.e. higher priority attributes before others, otherwise in
   # the order they were specified (as opposed to just setting them in the order they happen to appear in
   # when iterating over the given hash).
   #
   # Attributes that are not included in the given hash are set to their default value.
   #
   # @todo Is this description accurate? Is "ensure" an example of such a higher priority attribute?
   # @return [void]
   # @raise [Puppet::DevError] when impossible to set the value due to some problem
   # @raise [ArgumentError, TypeError, Puppet::Error] when faulty arguments have been passed
   #
   def set_parameters(hash)
     # Use the order provided by allattrs, but add in any
     # extra attributes from the resource so we get failures
     # on invalid attributes.
     no_values = []
     (self.class.allattrs + hash.keys).uniq.each do |attr|
       begin
         # Set any defaults immediately.  This is mostly done so
         # that the default provider is available for any other
         # property validation.
         if hash.has_key?(attr)
           self[attr] = hash[attr]
         else
           no_values << attr
         end
       rescue ArgumentError, Puppet::Error, TypeError
         raise
       rescue => detail
         error = Puppet::DevError.new( "Could not set #{attr} on #{self.class.name}: #{detail}")
         error.set_backtrace(detail.backtrace)
         raise error
       end
     end
     no_values.each do |attr|
       set_default(attr)
     end
   end
 
   public
 
   # Finishes any outstanding processing.
   # This method should be called as a final step in setup,
   # to allow the parameters that have associated auto-require needs to be processed.
   #
   # @todo what is the expected sequence here - who is responsible for calling this? When?
   #   Is the returned type correct?
   # @return [Array<Puppet::Parameter>] the validated list/set of attributes
   #
   def finish
     # Call post_compile hook on every parameter that implements it. This includes all subclasses
     # of parameter including, but not limited to, regular parameters, metaparameters, relationship
     # parameters, and properties.
     eachparameter do |parameter|
       parameter.post_compile if parameter.respond_to? :post_compile
     end
 
     # Make sure all of our relationships are valid.  Again, must be done
     # when the entire catalog is instantiated.
     self.class.relationship_params.collect do |klass|
       if param = @parameters[klass.name]
         param.validate_relationship
       end
     end.flatten.reject { |r| r.nil? }
   end
 
   # @comment For now, leave the 'name' method functioning like it used to.  Once 'title'
   #   works everywhere, I'll switch it.
   # Returns the resource's name
   # @todo There is a comment in source that this is not quite the same as ':title' and that a switch should
   #   be made...
   # @return [String] the name of a resource
   def name
     self[:name]
   end
 
   # Returns the parent of this in the catalog.  In case of an erroneous catalog
   # where multiple parents have been produced, the first found (non
   # deterministic) parent is returned.
   # @return [Puppet::Type, nil] the
   #   containing resource or nil if there is no catalog or no containing
   #   resource.
   def parent
     return nil unless catalog
 
     @parent ||=
       if parents = catalog.adjacent(self, :direction => :in)
         parents.shift
       else
         nil
       end
   end
 
   # Returns a reference to this as a string in "Type[name]" format.
   # @return [String] a reference to this object on the form 'Type[name]'
   #
   def ref
     # memoizing this is worthwhile ~ 3 percent of calls are the "first time
     # around" in an average run of Puppet. --daniel 2012-07-17
     @ref ||= "#{self.class.name.to_s.capitalize}[#{self.title}]"
   end
 
   # (see self_refresh)
   # @todo check that meaningful yardoc is produced - this method delegates to "self.class.self_refresh"
   # @return [Boolean] - ??? returns true when ... what?
   #
   def self_refresh?
     self.class.self_refresh
   end
 
   # Marks the object as "being purged".
   # This method is used by transactions to forbid deletion when there are dependencies.
   # @todo what does this mean; "mark that we are purging" (purging what from where). How to use/when?
   #   Is this internal API in transactions?
   # @see purging?
   def purging
     @purging = true
   end
 
   # Returns whether this resource is being purged or not.
   # This method is used by transactions to forbid deletion when there are dependencies.
   # @return [Boolean] the current "purging" state
   #
   def purging?
     if defined?(@purging)
       @purging
     else
       false
     end
   end
 
   # Returns the title of this object, or its name if title was not explicetly set.
   # If the title is not already set, it will be computed by looking up the {#name_var} and using
   # that value as the title.
   # @todo it is somewhat confusing that if the name_var is a valid parameter, it is assumed to
   #  be the name_var called :name, but if it is a property, it uses the name_var.
   #  It is further confusing as Type in some respects supports multiple namevars.
   #
   # @return [String] Returns the title of this object, or its name if title was not explicetly set.
   # @raise [??? devfail] if title is not set, and name_var can not be found.
   def title
     unless @title
       if self.class.validparameter?(name_var)
         @title = self[:name]
       elsif self.class.validproperty?(name_var)
         @title = self.should(name_var)
       else
         self.devfail "Could not find namevar #{name_var} for #{self.class.name}"
       end
     end
 
     @title
   end
 
   # Produces a reference to this in reference format.
   # @see #ref
   #
   def to_s
     self.ref
   end
 
   # Convert this resource type instance to a Puppet::Resource.
   # @return [Puppet::Resource] Returns a serializable representation of this resource
   #
   def to_resource
     resource = self.retrieve_resource
     resource.tag(*self.tags)
 
     @parameters.each do |name, param|
       # Avoid adding each instance name twice
       next if param.class.isnamevar? and param.value == self.title
 
       # We've already got property values
       next if param.is_a?(Puppet::Property)
       resource[name] = param.value
     end
 
     resource
   end
 
   # @return [Boolean] Returns whether the resource is virtual or not
   def virtual?;  !!@virtual;  end
   # @return [Boolean] Returns whether the resource is exported or not
   def exported?; !!@exported; end
 
   # @return [Boolean] Returns whether the resource is applicable to `:device`
   # Returns true if a resource of this type can be evaluated on a 'network device' kind
   # of hosts.
   # @api private
   def appliable_to_device?
     self.class.can_apply_to(:device)
   end
 
   # @return [Boolean] Returns whether the resource is applicable to `:host`
   # Returns true if a resource of this type can be evaluated on a regular generalized computer (ie not an appliance like a network device)
   # @api private
   def appliable_to_host?
     self.class.can_apply_to(:host)
   end
 end
 end
 
 require 'puppet/provider'
diff --git a/lib/puppet/util/network_device/cisco/interface.rb b/lib/puppet/util/network_device/cisco/interface.rb
index d184b9c3c..14067e4ed 100644
--- a/lib/puppet/util/network_device/cisco/interface.rb
+++ b/lib/puppet/util/network_device/cisco/interface.rb
@@ -1,82 +1,82 @@
 require 'puppet/util/network_device/cisco'
 require 'puppet/util/network_device/ipcalc'
 
 # this manages setting properties to an interface in a cisco switch or router
 class Puppet::Util::NetworkDevice::Cisco::Interface
 
   include Puppet::Util::NetworkDevice::IPCalc
   extend Puppet::Util::NetworkDevice::IPCalc
 
   attr_reader :transport, :name
 
   def initialize(name, transport)
     @name = name
     @transport = transport
   end
 
   COMMANDS = {
     # property     => order, ios command/block/array
     :description   => [1, "description %s"],
     :speed         => [2, "speed %s"],
     :duplex        => [3, "duplex %s"],
     :native_vlan   => [4, "switchport access vlan %s"],
     :encapsulation => [5, "switchport trunk encapsulation %s"],
     :mode          => [6, "switchport mode %s"],
     :allowed_trunk_vlans => [7, "switchport trunk allowed vlan %s"],
     :etherchannel  => [8, ["channel-group %s", "port group %s"]],
     :ipaddress     => [9,
       lambda do |prefix,ip,option|
         ip.ipv6? ? "ipv6 address #{ip.to_s}/#{prefix} #{option}" :
                    "ip address #{ip.to_s} #{netmask(Socket::AF_INET,prefix)}"
       end],
       :ensure        => [10, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
   }
 
   def update(is={}, should={})
     Puppet.debug("Updating interface #{name}")
     command("conf t")
     command("interface #{name}")
 
     # apply changes in a defined orders for cisco IOS devices
     [is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |property|
       # They're equal, so do nothing.
       next if is[property] == should[property]
 
       # We're deleting it
       if should[property] == :absent or should[property].nil?
         execute(property, is[property], "no ")
         next
       end
 
       # We're replacing an existing value or creating a new one
       execute(property, should[property])
     end
 
     command("exit")
     command("exit")
   end
 
   def execute(property, value, prefix='')
     case COMMANDS[property][1]
     when Array
       COMMANDS[property][1].each do |command|
         transport.command(prefix + command % value) do |out|
           break unless out =~ /^%/
         end
       end
     when String
       command(prefix + COMMANDS[property][1] % value)
     when Proc
       value = [value] unless value.is_a?(Array)
-      value.each do |value|
-        command(prefix + COMMANDS[property][1].call(*value))
+      value.each do |v|
+        command(prefix + COMMANDS[property][1].call(*v))
       end
     end
   end
 
   def command(command)
     transport.command(command) do |out|
       Puppet.err "Error while executing #{command}, device returned #{out}" if out =~ /^%/mo
     end
   end
 end
diff --git a/lib/puppet/util/network_device/transport/ssh.rb b/lib/puppet/util/network_device/transport/ssh.rb
index 1c20eb822..370457d48 100644
--- a/lib/puppet/util/network_device/transport/ssh.rb
+++ b/lib/puppet/util/network_device/transport/ssh.rb
@@ -1,122 +1,122 @@
 
 require 'puppet/util/network_device'
 require 'puppet/util/network_device/transport'
 require 'puppet/util/network_device/transport/base'
 
 # This is an adaptation/simplification of gem net-ssh-telnet, which aims to have
 # a sane interface to Net::SSH. Credits goes to net-ssh-telnet authors
 class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice::Transport::Base
 
   attr_accessor :buf, :ssh, :channel
 
   def initialize(verbose = false)
     super()
     @verbose = verbose
     unless Puppet.features.ssh?
       raise 'Connecting with ssh to a network device requires the \'net/ssh\' ruby library'
     end
   end
 
   def handles_login?
     true
   end
 
   def eof?
     !! @eof
   end
 
   def connect(&block)
     @output = []
     @channel_data = ""
 
     begin
       Puppet.debug("connecting to #{host} as #{user}")
       @ssh = Net::SSH.start(host, user, :port => port, :password => password, :timeout => timeout)
     rescue TimeoutError
       raise TimeoutError, "timed out while opening an ssh connection to the host", $!.backtrace
     rescue Net::SSH::AuthenticationFailed
       raise Puppet::Error, "SSH authentication failure connecting to #{host} as #{user}", $!.backtrace
     rescue Net::SSH::Exception
       raise Puppet::Error, "SSH connection failure to #{host}", $!.backtrace
     end
 
     @buf = ""
     @eof = false
     @channel = nil
     @ssh.open_channel do |channel|
       channel.request_pty { |ch,success| raise "failed to open pty" unless success }
 
       channel.send_channel_request("shell") do |ch, success|
         raise "failed to open ssh shell channel" unless success
 
-        ch.on_data { |ch,data| @buf << data }
-        ch.on_extended_data { |ch,type,data|  @buf << data if type == 1 }
+        ch.on_data { |_,data| @buf << data }
+        ch.on_extended_data { |_,type,data|  @buf << data if type == 1 }
         ch.on_close { @eof = true }
 
         @channel = ch
         expect(default_prompt, &block)
         # this is a little bit unorthodox, we're trying to escape
         # the ssh loop there while still having the ssh connection up
         # otherwise we wouldn't be able to return ssh stdout/stderr
         # for a given call of command.
         return
       end
 
     end
     @ssh.loop
 
   end
 
   def close
     @channel.close if @channel
     @channel = nil
     @ssh.close if @ssh
   end
 
   def expect(prompt)
     line = ''
     sock = @ssh.transport.socket
 
     while not @eof
       break if line =~ prompt and @buf == ''
       break if sock.closed?
 
       IO::select([sock], [sock], nil, nil)
 
       process_ssh
 
       # at this point we have accumulated some data in @buf
       # or the channel has been closed
       if @buf != ""
         line += @buf.gsub(/\r\n/no, "\n")
         @buf = ''
         yield line if block_given?
       elsif @eof
         # channel has been closed
         break if line =~ prompt
         if line == ''
           line = nil
           yield nil if block_given?
         end
         break
       end
     end
     Puppet.debug("ssh: expected #{line}") if @verbose
     line
   end
 
   def send(line)
     Puppet.debug("ssh: send #{line}") if @verbose
     @channel.send_data(line + "\n")
   end
 
   def process_ssh
     while @buf == "" and not eof?
       begin
         @channel.connection.process(0.1)
       rescue IOError
         @eof = true
       end
     end
   end
 end
diff --git a/lib/puppet/util/rdoc/code_objects.rb b/lib/puppet/util/rdoc/code_objects.rb
index 800b3690d..b67480e8e 100644
--- a/lib/puppet/util/rdoc/code_objects.rb
+++ b/lib/puppet/util/rdoc/code_objects.rb
@@ -1,294 +1,294 @@
 require 'rdoc/code_objects'
 
 module RDoc
 
   # This modules contains various class that are used to hold information
   # about the various Puppet language structures we found while parsing.
   #
   # Those will be mapped to their html counterparts which are defined in
   # PuppetGenerator.
 
   # PuppetTopLevel is a top level (usually a .pp/.rb file)
   module PuppetTopLevel
     attr_accessor :module_name, :global
   end
 
   # Add top level comments to a class or module
   # @api private
   module AddClassModuleComment
     def add_comment(comment, location = nil)
         super
     end
   end
 
   # PuppetModule holds a Puppet Module
   # This is mapped to an HTMLPuppetModule
   # it leverage the RDoc (ruby) module infrastructure
   class PuppetModule < NormalModule
     include AddClassModuleComment
 
     attr_accessor :facts, :plugins
 
     def initialize(name,superclass=nil)
       @facts = []
       @plugins = []
       @nodes = {}
       super(name,superclass)
     end
 
     def add_plugin(plugin)
       name = plugin.name
       type = plugin.type
       meth = AnyMethod.new("*args", name)
       meth.params = "(*args)"
       meth.visibility = :public
       meth.document_self = true
       meth.singleton = false
       meth.comment = plugin.comment
       if type == 'function'
         @function_container ||= add_module(NormalModule, "__functions__")
         @function_container.add_method(meth)
       elsif type == 'type'
         @type_container ||= add_module(NormalModule, "__types__")
         @type_container.add_method(meth)
       end
     end
 
     def add_fact(fact)
       @fact_container ||= add_module(NormalModule, "__facts__")
       confine_str = fact.confine.empty? ? '' : fact.confine.to_s
       const = Constant.new(fact.name, confine_str, fact.comment)
       @fact_container.add_constant(const)
     end
 
     # Adds a module called __nodes__ and adds nodes to it as classes
     #
     def add_node(name,superclass)
       if cls = @nodes[name]
         return cls
       end
       @node_container ||= add_module(NormalModule, "__nodes__")
       cls = @node_container.add_class(PuppetNode, name, superclass)
       @nodes[name] = cls if !@done_documenting
       cls
     end
 
     def each_fact
       @facts.each {|c| yield c}
     end
 
     def each_plugin
       @plugins.each {|c| yield c}
     end
 
     def each_node
       @nodes.each {|c| yield c}
     end
 
     def nodes
       @nodes.values
     end
   end
 
   # PuppetClass holds a puppet class
   # It is mapped to a HTMLPuppetClass for display
   # It leverages RDoc (ruby) Class
   class PuppetClass < ClassModule
     include AddClassModuleComment
 
     attr_accessor :resource_list, :requires, :childs, :realizes
 
     def initialize(name, superclass)
       super(name,superclass)
       @resource_list = []
       @requires = []
       @realizes = []
       @childs = []
     end
 
     def aref_prefix
       'puppet_class'
     end
 
     def add_resource(resource)
       add_to(@resource_list, resource)
     end
 
     def is_module?
       false
     end
 
     def superclass=(superclass)
       @superclass = superclass
     end
 
     # we're (ab)using the RDoc require system here.
     # we're adding a required Puppet class, overriding
     # the RDoc add_require method which sees ruby required files.
     def add_require(required)
       add_to(@requires, required)
     end
 
     def add_realize(realized)
       add_to(@realizes, realized)
     end
 
     def add_child(child)
       @childs << child
     end
 
     # Look up the given symbol. RDoc only looks for class1::class2.method
     # or class1::class2#method. Since our definitions are mapped to RDoc methods
     # but are written class1::class2::define we need to perform the lookup by
     # ourselves.
     def find_symbol(symbol, method=nil)
       result = super(symbol)
       if not result and symbol =~ /::/
         modules = symbol.split(/::/)
         unless modules.empty?
           module_name = modules.shift
           result = find_module_named(module_name)
           if result
             last_name = ""
             previous = nil
-            modules.each do |module_name|
+            modules.each do |mod|
               previous = result
-              last_name = module_name
-              result = result.find_module_named(module_name)
+              last_name = mod
+              result = result.find_module_named(mod)
               break unless result
             end
             unless result
               result = previous
               method = last_name
             end
           end
         end
         if result && method
           if !result.respond_to?(:find_local_symbol)
             p result.name
             p method
             fail
           end
           result = result.find_local_symbol(method)
         end
       end
       result
     end
 
   end
 
   # PuppetNode holds a puppet node
   # It is mapped to a HTMLPuppetNode for display
   # A node is just a variation of a class
   class PuppetNode < PuppetClass
     include AddClassModuleComment
 
     def initialize(name, superclass)
       super(name,superclass)
     end
 
     def is_module?
       false
     end
   end
 
   # Plugin holds a native puppet plugin (function,type...)
   # It is mapped to a HTMLPuppetPlugin for display
   class Plugin < Context
     attr_accessor :name, :type
 
     def initialize(name, type)
       super()
       @name = name
       @type = type
       @comment = ""
     end
 
     def <=>(other)
       @name <=> other.name
     end
 
     def full_name
       @name
     end
 
     def http_url(prefix)
       path = full_name.split("::")
       File.join(prefix, *path) + ".html"
     end
 
     def is_fact?
       false
     end
 
     def to_s
       res = self.class.name + ": #{@name} (#{@type})\n"
       res << @comment.to_s
       res
     end
   end
 
   # Fact holds a custom fact
   # It is mapped to a HTMLPuppetPlugin for display
   class Fact < Context
     attr_accessor :name, :confine
 
     def initialize(name, confine)
       super()
       @name = name
       @confine = confine
       @comment = ""
     end
 
     def <=>(other)
       @name <=> other.name
     end
 
     def is_fact?
       true
     end
 
     def full_name
       @name
     end
 
     def to_s
       res = self.class.name + ": #{@name}\n"
       res << @comment.to_s
       res
     end
   end
 
   # PuppetResource holds a puppet resource
   # It is mapped to a HTMLPuppetResource for display
   # A resource is defined by its "normal" form Type[title]
   class PuppetResource < CodeObject
     attr_accessor :type, :title, :params
 
     def initialize(type, title, comment, params)
       super()
       @type = type
       @title = title
       @comment = comment
       @params = params
     end
 
     def <=>(other)
       full_name <=> other.full_name
     end
 
     def full_name
       @type + "[#{@title}]"
     end
 
     def name
       full_name
     end
 
     def to_s
       res = @type + "[#{@title}]\n"
       res << @comment.to_s
       res
     end
   end
 end
diff --git a/lib/puppet/util/rdoc/generators/puppet_generator.rb b/lib/puppet/util/rdoc/generators/puppet_generator.rb
index 2ad15c264..914c57067 100644
--- a/lib/puppet/util/rdoc/generators/puppet_generator.rb
+++ b/lib/puppet/util/rdoc/generators/puppet_generator.rb
@@ -1,910 +1,910 @@
 require 'rdoc/generators/html_generator'
 require 'puppet/util/rdoc/code_objects'
 require 'digest/md5'
 
 module Generators
 
   # This module holds all the classes needed to generate the HTML documentation
   # of a bunch of puppet manifests.
   #
   # It works by traversing all the code objects defined by the Puppet RDoc::Parser
   # and produces HTML counterparts objects that in turns are used by RDoc template engine
   # to produce the final HTML.
   #
   # It is also responsible of creating the whole directory hierarchy, and various index
   # files.
   #
   # It is to be noted that the whole system is built on top of ruby RDoc. As such there
   # is an implicit mapping of puppet entities to ruby entitites:
   #
   #         Puppet    =>    Ruby
   #         ------------------------
   #         Module          Module
   #         Class           Class
   #         Definition      Method
   #         Resource
   #         Node
   #         Plugin
   #         Fact
 
   MODULE_DIR = "modules"
   NODE_DIR = "nodes"
   PLUGIN_DIR = "plugins"
 
   # We're monkey patching RDoc markup to allow
   # lowercase class1::class2::class3 crossref hyperlinking
   module MarkUp
     alias :old_markup :markup
 
     def new_markup(str, remove_para=false)
       first = @markup.nil?
       res = old_markup(str, remove_para)
       if first and not @markup.nil?
         @markup.add_special(/\b([a-z]\w+(::\w+)*)/,:CROSSREF)
         # we need to call it again, since we added a rule
         res = old_markup(str, remove_para)
       end
       res
     end
     alias :markup :new_markup
   end
 
   # This is a specialized HTMLGenerator tailored to Puppet manifests
   class PuppetGenerator < HTMLGenerator
 
     def PuppetGenerator.for(options)
       AllReferences::reset
       HtmlMethod::reset
 
       if options.all_one_file
         PuppetGeneratorInOne.new(options)
       else
         PuppetGenerator.new(options)
       end
     end
 
     def initialize(options) #:not-new:
       @options    = options
       load_html_template
     end
 
     # loads our own html template file
     def load_html_template
         require 'puppet/util/rdoc/generators/template/puppet/puppet'
         extend RDoc::Page
     rescue LoadError
         $stderr.puts "Could not find Puppet template '#{template}'"
         exit 99
     end
 
     def gen_method_index
       # we don't generate an all define index
       # as the presentation is per module/per class
     end
 
     # This is the central method, it generates the whole structures
     # along with all the indices.
     def generate_html
       super
       gen_into(@nodes)
       gen_into(@plugins)
     end
 
     ##
     # Generate:
     #  the list of modules
     #  the list of classes and definitions of a specific module
     #  the list of all classes
     #  the list of nodes
     #  the list of resources
     def build_indices
       @allfiles = []
       @nodes = []
       @plugins = []
 
       # contains all the seen modules
       @modules = {}
       @allclasses = {}
 
       # remove unknown toplevels
       # it can happen that RDoc triggers a different parser for some files (ie .c, .cc or .h)
       # in this case RDoc generates a RDoc::TopLevel which we do not support in this generator
       # So let's make sure we don't generate html for those.
       @toplevels = @toplevels.select { |tl| tl.is_a? RDoc::PuppetTopLevel }
 
       # build the modules, classes and per modules classes and define list
       @toplevels.each do |toplevel|
         next unless toplevel.document_self
         file = HtmlFile.new(toplevel, @options, FILE_DIR)
         classes = []
         methods = []
         modules = []
         nodes = []
 
         # find all classes of this toplevel
         # store modules if we find one
         toplevel.each_classmodule do |k|
           generate_class_list(classes, modules, k, toplevel, CLASS_DIR)
         end
 
         # find all defines belonging to this toplevel
         HtmlMethod.all_methods.each do |m|
           # find parent module, check this method is not already
           # defined.
           if m.context.parent.toplevel === toplevel
             methods << m
           end
         end
 
         classes.each do |k|
           @allclasses[k.index_name] = k if !@allclasses.has_key?(k.index_name)
         end
 
         # generate nodes and plugins found
         classes.each do |k|
           if k.context.is_module?
             k.context.each_node do |name,node|
               nodes << HTMLPuppetNode.new(node, toplevel, NODE_DIR, @options)
               @nodes << nodes.last
             end
             k.context.each_plugin do |plugin|
               @plugins << HTMLPuppetPlugin.new(plugin, toplevel, PLUGIN_DIR, @options)
             end
             k.context.each_fact do |fact|
               @plugins << HTMLPuppetPlugin.new(fact, toplevel, PLUGIN_DIR, @options)
             end
           end
         end
 
         @files << file
         @allfiles << { "file" => file, "modules" => modules, "classes" => classes, "methods" => methods, "nodes" => nodes }
       end
 
       # scan all classes to create the childs references
       @allclasses.values.each do |klass|
         if superklass = klass.context.superclass
           if superklass = AllReferences[superklass] and (superklass.is_a?(HTMLPuppetClass) or superklass.is_a?(HTMLPuppetNode))
             superklass.context.add_child(klass.context)
           end
         end
       end
 
       @classes = @allclasses.values
     end
 
     # produce a class/module list of HTMLPuppetModule/HTMLPuppetClass
     # based on the code object traversal.
     def generate_class_list(classes, modules, from, html_file, class_dir)
       if from.is_module? and !@modules.has_key?(from.name)
         k = HTMLPuppetModule.new(from, html_file, class_dir, @options)
         classes << k
         @modules[from.name] = k
         modules << @modules[from.name]
       elsif from.is_module?
         modules << @modules[from.name]
       elsif !from.is_module?
         k = HTMLPuppetClass.new(from, html_file, class_dir, @options)
         classes << k
       end
       from.each_classmodule do |mod|
         generate_class_list(classes, modules, mod, html_file, class_dir)
       end
     end
 
     # generate all the subdirectories, modules, classes and files
     def gen_sub_directories
         super
         File.makedirs(MODULE_DIR)
         File.makedirs(NODE_DIR)
         File.makedirs(PLUGIN_DIR)
     rescue
         $stderr.puts $ERROR_INFO.message
         exit 1
     end
 
     # generate the index of modules
     def gen_file_index
       gen_top_index(@modules.values, 'All Modules', RDoc::Page::TOP_INDEX, "fr_modules_index.html")
     end
 
     # generate a top index
     def gen_top_index(collection, title, template, filename)
       template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
       res = []
       collection.sort.each do |f|
         if f.document_self
           res << { "classlist" => CGI.escapeHTML("#{MODULE_DIR}/fr_#{f.index_name}.html"), "module" => CGI.escapeHTML("#{CLASS_DIR}/#{f.index_name}.html"),"name" => CGI.escapeHTML(f.index_name) }
         end
       end
 
       values = {
         "entries"    => res,
         'list_title' => CGI.escapeHTML(title),
         'index_url'  => main_url,
         'charset'    => @options.charset,
         'style_url'  => style_url('', @options.css),
       }
 
       File.open(filename, "w") do |f|
         template.write_html_on(f, values)
       end
     end
 
     # generate the all classes index file and the combo index
     def gen_class_index
       gen_an_index(@classes, 'All Classes', RDoc::Page::CLASS_INDEX, "fr_class_index.html")
       @allfiles.each do |file|
         unless file['file'].context.file_relative_name =~ /\.rb$/
 
           gen_composite_index(
             file,
               RDoc::Page::COMBO_INDEX,
 
               "#{MODULE_DIR}/fr_#{file["file"].context.module_name}.html")
         end
       end
     end
 
     def gen_composite_index(collection, template, filename)\
       return if Puppet::FileSystem.exist?(filename)
 
       template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
       res1 = []
       collection['classes'].sort.each do |f|
         if f.document_self
           res1 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) } unless f.context.is_module?
         end
       end
 
       res2 = []
       collection['methods'].sort.each do |f|
         res2 << { "href" => "../#{f.path}", "name" => f.index_name.sub(/\(.*\)$/,'') } if f.document_self
       end
 
       module_name = []
       res3 = []
       res4 = []
       collection['modules'].sort.each do |f|
         module_name << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) }
         unless f.facts.nil?
           f.facts.each do |fact|
             res3 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{fact.name})"].path), "name" => CGI.escapeHTML(fact.name)}
           end
         end
         unless f.plugins.nil?
           f.plugins.each do |plugin|
             res4 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{plugin.name})"].path), "name" => CGI.escapeHTML(plugin.name)}
           end
         end
       end
 
       res5 = []
       collection['nodes'].sort.each do |f|
         res5 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.name) } if f.document_self
       end
 
       values = {
         "module" => module_name,
         "classes"    => res1,
         'classes_title' => CGI.escapeHTML("Classes"),
         'defines_title' => CGI.escapeHTML("Defines"),
         'facts_title' => CGI.escapeHTML("Custom Facts"),
         'plugins_title' => CGI.escapeHTML("Plugins"),
         'nodes_title' => CGI.escapeHTML("Nodes"),
         'index_url'  => main_url,
         'charset'    => @options.charset,
         'style_url'  => style_url('', @options.css),
       }
 
       values["defines"] = res2 if res2.size>0
       values["facts"] = res3 if res3.size>0
       values["plugins"] = res4 if res4.size>0
       values["nodes"] = res5 if res5.size>0
 
       File.open(filename, "w") do |f|
         template.write_html_on(f, values)
       end
     end
 
     # returns the initial_page url
     def main_url
       main_page = @options.main_page
       ref = nil
       if main_page
         ref = AllReferences[main_page]
         if ref
           ref = ref.path
         else
           $stderr.puts "Could not find main page #{main_page}"
         end
       end
 
       unless ref
         for file in @files
           if file.document_self and file.context.global
             ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
             break
           end
         end
       end
 
       unless ref
         for file in @files
           if file.document_self and !file.context.global
             ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
             break
           end
         end
       end
 
       unless ref
         $stderr.puts "Couldn't find anything to document"
         $stderr.puts "Perhaps you've used :stopdoc: in all classes"
         exit(1)
       end
 
       ref
     end
 
   end
 
   # This module is used to generate a referenced full name list of ContextUser
   module ReferencedListBuilder
     def build_referenced_list(list)
       res = []
       list.each do |i|
         ref = AllReferences[i.name] || @context.find_symbol(i.name)
         ref = ref.viewer if ref and ref.respond_to?(:viewer)
         name = i.respond_to?(:full_name) ? i.full_name : i.name
         h_name = CGI.escapeHTML(name)
         if ref and ref.document_self
           path = url(ref.path)
           res << { "name" => h_name, "aref" => path }
         else
           res << { "name" => h_name }
         end
       end
       res
     end
   end
 
   # This module is used to hold/generate a list of puppet resources
   # this is used in HTMLPuppetClass and HTMLPuppetNode
   module ResourceContainer
     def collect_resources
       list = @context.resource_list
       @resources = list.collect {|m| HTMLPuppetResource.new(m, self, @options) }
     end
 
     def build_resource_summary_list(path_prefix='')
       collect_resources unless @resources
       resources = @resources.sort
       res = []
       resources.each do |r|
         res << {
           "name" => CGI.escapeHTML(r.name),
           "aref" => CGI.escape(path_prefix)+"\#"+CGI.escape(r.aref)
         }
       end
       res
     end
 
     def build_resource_detail_list(section)
       outer = []
       resources = @resources.sort
       resources.each do |r|
         row = {}
         if r.section == section and r.document_self
           row["name"]        = CGI.escapeHTML(r.name)
           desc = r.description.strip
           row["m_desc"]      = desc unless desc.empty?
           row["aref"]        = r.aref
           row["params"]      = r.params
           outer << row
         end
       end
       outer
     end
   end
 
   class HTMLPuppetClass < HtmlClass
     include ResourceContainer, ReferencedListBuilder
 
     def value_hash
       super
       rl = build_resource_summary_list
       @values["resources"] = rl unless rl.empty?
 
       @context.sections.each do |section|
-        secdata = @values["sections"].select { |secdata| secdata["secsequence"] == section.sequence }
+        secdata = @values["sections"].select { |s| s["secsequence"] == section.sequence }
         if secdata.size == 1
           secdata = secdata[0]
 
           rdl = build_resource_detail_list(section)
           secdata["resource_list"] = rdl unless rdl.empty?
         end
       end
 
       rl = build_require_list(@context)
       @values["requires"] = rl unless rl.empty?
 
       rl = build_realize_list(@context)
       @values["realizes"] = rl unless rl.empty?
 
       cl = build_child_list(@context)
       @values["childs"] = cl unless cl.empty?
 
       @values
     end
 
     def build_require_list(context)
       build_referenced_list(context.requires)
     end
 
     def build_realize_list(context)
       build_referenced_list(context.realizes)
     end
 
     def build_child_list(context)
       build_referenced_list(context.childs)
     end
   end
 
   class HTMLPuppetNode < ContextUser
     include ResourceContainer, ReferencedListBuilder
 
     attr_reader :path
 
     def initialize(context, html_file, prefix, options)
       super(context, options)
 
       @html_file = html_file
       @is_module = context.is_module?
       @values    = {}
 
       context.viewer = self
 
       if options.all_one_file
         @path = context.full_name
       else
         @path = http_url(context.full_name, prefix)
       end
 
       AllReferences.add("NODE(#{@context.full_name})", self)
     end
 
     def name
       @context.name
     end
 
     # return the relative file name to store this class in,
     # which is also its url
     def http_url(full_name, prefix)
       path = full_name.dup
       path.gsub!(/<<\s*(\w*)/) { "from-#$1" } if path['<<']
       File.join(prefix, path.split("::").collect { |p| Digest::MD5.hexdigest(p) }) + ".html"
     end
 
     def parent_name
       @context.parent.full_name
     end
 
     def index_name
       name
     end
 
     def write_on(f)
       value_hash
 
         template = TemplatePage.new(
           RDoc::Page::BODYINC,
             RDoc::Page::NODE_PAGE,
 
             RDoc::Page::METHOD_LIST)
       template.write_html_on(f, @values)
     end
 
     def value_hash
       class_attribute_values
       add_table_of_sections
 
       @values["charset"] = @options.charset
       @values["style_url"] = style_url(path, @options.css)
 
       d = markup(@context.comment)
       @values["description"] = d unless d.empty?
 
       ml = build_method_summary_list
       @values["methods"] = ml unless ml.empty?
 
       rl = build_resource_summary_list
       @values["resources"] = rl unless rl.empty?
 
       il = build_include_list(@context)
       @values["includes"] = il unless il.empty?
 
       rl = build_require_list(@context)
       @values["requires"] = rl unless rl.empty?
 
       rl = build_realize_list(@context)
       @values["realizes"] = rl unless rl.empty?
 
       cl = build_child_list(@context)
       @values["childs"] = cl unless cl.empty?
 
       @values["sections"] = @context.sections.map do |section|
 
         secdata = {
           "sectitle" => section.title,
           "secsequence" => section.sequence,
           "seccomment" => markup(section.comment)
         }
 
         al = build_alias_summary_list(section)
         secdata["aliases"] = al unless al.empty?
 
         co = build_constants_summary_list(section)
         secdata["constants"] = co unless co.empty?
 
         al = build_attribute_list(section)
         secdata["attributes"] = al unless al.empty?
 
         cl = build_class_list(0, @context, section)
         secdata["classlist"] = cl unless cl.empty?
 
         mdl = build_method_detail_list(section)
         secdata["method_list"] = mdl unless mdl.empty?
 
         rdl = build_resource_detail_list(section)
         secdata["resource_list"] = rdl unless rdl.empty?
 
         secdata
       end
 
       @values
     end
 
     def build_attribute_list(section)
       atts = @context.attributes.sort
       res = []
       atts.each do |att|
         next unless att.section == section
         if att.visibility == :public || att.visibility == :protected || @options.show_all
           entry = {
             "name"   => CGI.escapeHTML(att.name),
             "rw"     => att.rw,
             "a_desc" => markup(att.comment, true)
           }
           unless att.visibility == :public || att.visibility == :protected
             entry["rw"] << "-"
           end
           res << entry
         end
       end
       res
     end
 
     def class_attribute_values
       h_name = CGI.escapeHTML(name)
 
       @values["classmod"]  = "Node"
       @values["title"]     = CGI.escapeHTML("#{@values['classmod']}: #{h_name}")
 
       c = @context
       c = c.parent while c and !c.diagram
 
       @values["diagram"] = diagram_reference(c.diagram) if c && c.diagram
 
       @values["full_name"] = h_name
 
       parent_class = @context.superclass
 
       if parent_class
         @values["parent"] = CGI.escapeHTML(parent_class)
 
         if parent_name
           lookup = parent_name + "::#{parent_class}"
         else
           lookup = parent_class
         end
         lookup = "NODE(#{lookup})"
         parent_url = AllReferences[lookup] || AllReferences[parent_class]
         @values["par_url"] = aref_to(parent_url.path) if parent_url and parent_url.document_self
       end
 
       files = []
       @context.in_files.each do |f|
         res = {}
         full_path = CGI.escapeHTML(f.file_absolute_name)
 
         res["full_path"]     = full_path
         res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
 
         res["cvsurl"] = cvs_url( @options.webcvs, full_path ) if @options.webcvs
 
         files << res
       end
 
       @values['infiles'] = files
     end
 
     def build_require_list(context)
       build_referenced_list(context.requires)
     end
 
     def build_realize_list(context)
       build_referenced_list(context.realizes)
     end
 
     def build_child_list(context)
       build_referenced_list(context.childs)
     end
 
     def <=>(other)
       self.name <=> other.name
     end
   end
 
   class HTMLPuppetModule < HtmlClass
 
     def initialize(context, html_file, prefix, options)
       super(context, html_file, prefix, options)
     end
 
     def value_hash
       @values = super
 
       fl = build_facts_summary_list
       @values["facts"] = fl unless fl.empty?
 
       pl = build_plugins_summary_list
       @values["plugins"] = pl unless pl.empty?
 
       nl = build_nodes_list(0, @context)
       @values["nodelist"] = nl unless nl.empty?
 
       @values
     end
 
     def build_nodes_list(level, context)
       res = ""
       prefix = "&nbsp;&nbsp;::" * level;
 
       context.nodes.sort.each do |node|
         if node.document_self
           res <<
           prefix <<
           "Node " <<
           href(url(node.viewer.path), "link", node.full_name) <<
           "<br />\n"
         end
       end
       res
     end
 
     def build_facts_summary_list
       potentially_referenced_list(context.facts) {|fn| ["PLUGIN(#{fn})"] }
     end
 
     def build_plugins_summary_list
       potentially_referenced_list(context.plugins) {|fn| ["PLUGIN(#{fn})"] }
     end
 
     def facts
       @context.facts
     end
 
     def plugins
       @context.plugins
     end
 
   end
 
   class HTMLPuppetPlugin < ContextUser
     attr_reader :path
 
     def initialize(context, html_file, prefix, options)
       super(context, options)
 
       @html_file = html_file
       @is_module = false
       @values    = {}
 
       context.viewer = self
 
       if options.all_one_file
         @path = context.full_name
       else
         @path = http_url(context.full_name, prefix)
       end
 
       AllReferences.add("PLUGIN(#{@context.full_name})", self)
     end
 
     def name
       @context.name
     end
 
     # return the relative file name to store this class in,
     # which is also its url
     def http_url(full_name, prefix)
       path = full_name.dup
       path.gsub!(/<<\s*(\w*)/) { "from-#$1" } if path['<<']
       File.join(prefix, path.split("::")) + ".html"
     end
 
     def parent_name
       @context.parent.full_name
     end
 
     def index_name
       name
     end
 
     def write_on(f)
       value_hash
 
         template = TemplatePage.new(
           RDoc::Page::BODYINC,
             RDoc::Page::PLUGIN_PAGE,
 
             RDoc::Page::PLUGIN_LIST)
       template.write_html_on(f, @values)
     end
 
     def value_hash
       attribute_values
       add_table_of_sections
 
       @values["charset"] = @options.charset
       @values["style_url"] = style_url(path, @options.css)
 
       d = markup(@context.comment)
       @values["description"] = d unless d.empty?
 
       if context.is_fact?
         unless context.confine.empty?
           res = {}
           res["type"] = context.confine[:type]
           res["value"] = context.confine[:value]
           @values["confine"] = [res]
         end
       else
         @values["type"] = context.type
       end
 
       @values["sections"] = @context.sections.map do |section|
         secdata = {
           "sectitle" => section.title,
           "secsequence" => section.sequence,
           "seccomment" => markup(section.comment)
         }
         secdata
       end
 
       @values
     end
 
     def attribute_values
       h_name = CGI.escapeHTML(name)
 
       if @context.is_fact?
         @values["classmod"]  = "Fact"
       else
         @values["classmod"]  = "Plugin"
       end
       @values["title"]     = "#{@values['classmod']}: #{h_name}"
 
       @values["full_name"] = h_name
 
       files = []
       @context.in_files.each do |f|
         res = {}
         full_path = CGI.escapeHTML(f.file_absolute_name)
 
         res["full_path"]     = full_path
         res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
 
         res["cvsurl"] = cvs_url( @options.webcvs, full_path ) if @options.webcvs
 
         files << res
       end
 
       @values['infiles'] = files
     end
 
     def <=>(other)
       self.name <=> other.name
     end
 
   end
 
   class HTMLPuppetResource
     include MarkUp
 
     attr_reader :context
 
     @@seq = "R000000"
 
     def initialize(context, html_class, options)
       @context    = context
       @html_class = html_class
       @options    = options
       @@seq       = @@seq.succ
       @seq        = @@seq
 
       context.viewer = self
 
       AllReferences.add(name, self)
     end
 
     def as_href(from_path)
       if @options.all_one_file
         "##{path}"
       else
         HTMLGenerator.gen_url(from_path, path)
       end
     end
 
     def name
       @context.name
     end
 
     def section
       @context.section
     end
 
     def index_name
       "#{@context.name}"
     end
 
     def params
       @context.params
     end
 
     def parent_name
       if @context.parent.parent
         @context.parent.parent.full_name
       else
         nil
       end
     end
 
     def aref
       @seq
     end
 
     def path
       if @options.all_one_file
         aref
       else
         @html_class.path + "##{aref}"
       end
     end
 
     def description
       markup(@context.comment)
     end
 
     def <=>(other)
       @context <=> other.context
     end
 
     def document_self
       @context.document_self
     end
 
     def find_symbol(symbol, method=nil)
       res = @context.parent.find_symbol(symbol, method)
       res &&= res.viewer
     end
 
   end
 
   class PuppetGeneratorInOne < HTMLGeneratorInOne
     def gen_method_index
       gen_an_index(HtmlMethod.all_methods, 'Defines')
     end
   end
 
 end
diff --git a/lib/puppet/util/rdoc/parser/puppet_parser_core.rb b/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
index 9cb5d9efa..eeb26448c 100644
--- a/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
+++ b/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
@@ -1,258 +1,258 @@
 # Functionality common to both our RDoc version 1 and 2 parsers.
 module RDoc::PuppetParserCore
 
   SITE = "__site__"
 
   def self.included(base)
     base.class_eval do
       attr_accessor :input_file_name, :top_level
 
       # parser registration into RDoc
       parse_files_matching(/\.(rb)$/)
     end
   end
 
   # called with the top level file
   def initialize(top_level, file_name, body, options, stats)
     @options = options
     @stats   = stats
     @input_file_name = file_name
     @top_level = top_level
     @top_level.extend(RDoc::PuppetTopLevel)
     @progress = $stderr unless options.quiet
   end
 
   # main entry point
   def scan
     environment = Puppet.lookup(:current_environment)
     scan_top_level(@top_level, environment)
     @top_level
   end
 
   # Due to a bug in RDoc, we need to roll our own find_module_named
   # The issue is that RDoc tries harder by asking the parent for a class/module
   # of the name. But by doing so, it can mistakenly use a module of same name
   # but from which we are not descendant.
   def find_object_named(container, name)
     return container if container.name == name
     container.each_classmodule do |m|
       return m if m.name == name
     end
     nil
   end
 
   # walk down the namespace and lookup/create container as needed
   def get_class_or_module(container, name)
 
     # class ::A -> A is in the top level
     if name =~ /^::/
       container = @top_level
     end
 
     names = name.split('::')
 
     final_name = names.pop
-    names.each do |name|
+    names.each do |n|
       prev_container = container
-      container = find_object_named(container, name)
-      container ||= prev_container.add_class(RDoc::PuppetClass, name, nil)
+      container = find_object_named(container, n)
+      container ||= prev_container.add_class(RDoc::PuppetClass, n, nil)
     end
     [container, final_name]
   end
 
   # split_module tries to find if +path+ belongs to the module path
   # if it does, it returns the module name, otherwise if we are sure
   # it is part of the global manifest path, "__site__" is returned.
   # And finally if this path couldn't be mapped anywhere, nil is returned.
   def split_module(path, environment)
     # find a module
     fullpath = File.expand_path(path)
     Puppet.debug "rdoc: testing #{fullpath}"
     if fullpath =~ /(.*)\/([^\/]+)\/(?:manifests|plugins|lib)\/.+\.(rb)$/
       modpath = $1
       name = $2
       Puppet.debug "rdoc: module #{name} into #{modpath} ?"
       environment.modulepath.each do |mp|
         if File.identical?(modpath,mp)
           Puppet.debug "rdoc: found module #{name}"
           return name
         end
       end
     end
     if fullpath =~ /\.(rb)$/
       # there can be paths we don't want to scan under modules
       # imagine a ruby or manifest that would be distributed as part as a module
       # but we don't want those to be hosted under <site>
       environment.modulepath.each do |mp|
         # check that fullpath is a descendant of mp
         dirname = fullpath
         previous = dirname
         while (dirname = File.dirname(previous)) != previous
           previous = dirname
           return nil if File.identical?(dirname,mp)
         end
       end
     end
     # we are under a global manifests
     Puppet.debug "rdoc: global manifests"
     SITE
   end
 
   # create documentation for the top level +container+
   def scan_top_level(container, environment)
     # use the module README as documentation for the module
     comment = ""
     %w{README README.rdoc}.each do |rfile|
       readme = File.join(File.dirname(File.dirname(@input_file_name)), rfile)
       comment = File.open(readme,"r") { |f| f.read } if FileTest.readable?(readme)
     end
     look_for_directives_in(container, comment) unless comment.empty?
 
     # infer module name from directory
     name = split_module(@input_file_name, environment)
     if name.nil?
       # skip .pp files that are not in manifests directories as we can't guarantee they're part
       # of a module or the global configuration.
       # PUP-3638, keeping this while it should have no effect since no .pp files are now processed
       container.document_self = false
       return
     end
 
     Puppet.debug "rdoc: scanning for #{name}"
 
     container.module_name = name
     container.global=true if name == SITE
 
     container, name  = get_class_or_module(container,name)
     mod = container.add_module(RDoc::PuppetModule, name)
     mod.record_location(@top_level)
     mod.add_comment(comment, @input_file_name)
 
     if @input_file_name =~ /\.rb$/
       parse_plugins(mod)
     end
   end
 
   # create documentation for plugins
   def parse_plugins(container)
     Puppet.debug "rdoc: scanning plugin or fact"
     if @input_file_name =~ /\/facter\/[^\/]+\.rb$/
       parse_fact(container)
     else
       parse_puppet_plugin(container)
     end
   end
 
   # this is a poor man custom fact parser :-)
   def parse_fact(container)
     comments = ""
     current_fact = nil
     parsed_facts = []
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*Facter.add\(['"](.*?)['"]\)/
           current_fact = RDoc::Fact.new($1,{})
           look_for_directives_in(container, comments) unless comments.empty?
           current_fact.comment = comments
           parsed_facts << current_fact
           comments = ""
           Puppet.debug "rdoc: found custom fact #{current_fact.name}"
         elsif line =~ /^[ \t]*confine[ \t]*:(.*?)[ \t]*=>[ \t]*(.*)$/
           current_fact.confine = { :type => $1, :value => $2 } unless current_fact.nil?
         else # unknown line type
           comments =""
         end
       end
     end
     parsed_facts.each do |f|
       container.add_fact(f)
       f.record_location(@top_level)
     end
   end
 
   # this is a poor man puppet plugin parser :-)
   # it doesn't extract doc nor desc :-(
   def parse_puppet_plugin(container)
     comments = ""
     current_plugin = nil
 
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*(?:Puppet::Parser::Functions::)?newfunction[ \t]*\([ \t]*:(.*?)[ \t]*,[ \t]*:type[ \t]*=>[ \t]*(:rvalue|:lvalue)/
           current_plugin = RDoc::Plugin.new($1, "function")
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           container.add_plugin(current_plugin)
           comments = ""
           Puppet.debug "rdoc: found new function plugins #{current_plugin.name}"
         elsif line =~ /^[ \t]*Puppet::Type.newtype[ \t]*\([ \t]*:(.*?)\)/
           current_plugin = RDoc::Plugin.new($1, "type")
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           container.add_plugin(current_plugin)
           comments = ""
           Puppet.debug "rdoc: found new type plugins #{current_plugin.name}"
         elsif line =~ /module Puppet::Parser::Functions/
           # skip
         else # unknown line type
           comments =""
         end
       end
     end
   end
 
   # New instance of the appropriate PreProcess for our RDoc version.
   def create_rdoc_preprocess
     raise(NotImplementedError, "This method must be overwritten for whichever version of RDoc this parser is working with")
   end
 
   # look_for_directives_in scans the current +comment+ for RDoc directives
   def look_for_directives_in(context, comment)
     preprocess = create_rdoc_preprocess
 
     preprocess.handle(comment) do |directive, param|
       case directive
       when "stopdoc"
         context.stop_doc
         ""
       when "startdoc"
         context.start_doc
         context.force_documentation = true
         ""
       when "enddoc"
         #context.done_documenting = true
         #""
         throw :enddoc
       when "main"
         options = Options.instance
         options.main_page = param
         ""
       when "title"
         options = Options.instance
         options.title = param
         ""
       when "section"
         context.set_current_section(param, comment)
         comment.replace("") # 1.8 doesn't support #clear
         break
       else
         warn "Unrecognized directive '#{directive}'"
         break
       end
     end
     remove_private_comments(comment)
   end
 
   def remove_private_comments(comment)
     comment.gsub!(/^#--.*?^#\+\+/m, '')
     comment.sub!(/^#--.*/m, '')
   end
 end