puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

data/lib/puppet/functions/filter.rb

@@ -94,16 +94,16 @@ Puppet::Functions.create_function(:filter) do
   end
 
   def filter_Hash_1(hash)
-    result = hash.select {|x, y| yield([x, y]) }
+    result = hash.select { |x, y| yield([x, y]) }
     # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
+    result = result.to_h unless result.is_a? Hash
     result
   end
 
   def filter_Hash_2(hash)
-    result = hash.select {|x, y| yield(x, y) }
+    result = hash.select { |x, y| yield(x, y) }
     # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
+    result = result.to_h unless result.is_a? Hash
     result
   end
 
@@ -123,8 +123,7 @@ Puppet::Functions.create_function(:filter) do
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     if enum.hash_style?
       result = {}
-      enum.each {| k, v| result[k] = v if yield(k, v) }
-      result
+      enum.each { |k, v| result[k] = v if yield(k, v) }
     else
       result = []
       begin
@@ -133,7 +132,7 @@ Puppet::Functions.create_function(:filter) do
         end
       rescue StopIteration
       end
-      result
     end
+    result
   end
 end

data/lib/puppet/functions/get.rb

@@ -133,7 +133,7 @@ Puppet::Functions.create_function(:get, Puppet::Functions::InternalFunction) do
     # like '0.1' the wanted result is `[0,1]`, not `["0", 1]`. The workaround here is to
     # prefix the navigation with `"x."` thus giving split_key a first segment that is a string.
     # The fake segment is then dropped.
-    segments = split_key("x." + navigation) {|_err| _("Syntax error in dotted-navigation string")}
+    segments = split_key("x." + navigation) { |_err| _("Syntax error in dotted-navigation string") }
     segments.shift
 
     begin

data/lib/puppet/functions/getvar.rb

@@ -58,7 +58,7 @@ Puppet::Functions.create_function(:getvar, Puppet::Functions::InternalFunction)
     optional_block_param 'Callable', :block
   end
 
-  def invalid_variable_error(navigation, default_value=nil, &block)
+  def invalid_variable_error(navigation, default_value = nil, &block)
     _("The given string does not start with a valid variable name")
   end
 
@@ -69,10 +69,10 @@ Puppet::Functions.create_function(:getvar, Puppet::Functions::InternalFunction)
     matches = navigation.match(/^((::)?(\w+::)*\w+)(.*)\z/)
     navigation = matches[4]
     if navigation[0] == '.'
-      navigation = navigation[1..-1]
+      navigation = navigation[1..]
     else
       unless navigation.empty?
-        raise ArgumentError, _("First character after var name in get string must be a '.' - got %{char}") % {char: navigation[0]}
+        raise ArgumentError, _("First character after var name in get string must be a '.' - got %{char}") % { char: navigation[0] }
       end
     end
     get_from_var_name(scope, matches[1], navigation, default_value, &block)
@@ -82,7 +82,7 @@ Puppet::Functions.create_function(:getvar, Puppet::Functions::InternalFunction)
   #
   def get_from_var_name(scope, var_string, navigation, default_value = nil, &block)
     catch(:undefined_variable) do
-      return call_function_with_scope(scope,'get', scope.lookupvar(var_string), navigation, default_value, &block)
+      return call_function_with_scope(scope, 'get', scope.lookupvar(var_string), navigation, default_value, &block)
     end
     default_value
   end

data/lib/puppet/functions/group_by.rb

@@ -49,8 +49,8 @@ Puppet::Functions.create_function(:group_by) do
       yield(k, v)
     end
 
-    grouped.each_with_object({}) do |(k, v), hsh|
-      hsh[k] = v.map { |item| item[1] }
+    grouped.transform_values do |v|
+      v.map { |item| item[1] }
     end.freeze
   end
 

data/lib/puppet/functions/include.rb

@@ -42,11 +42,12 @@ Puppet::Functions.create_function(:include, Puppet::Functions::InternalFunction)
     if Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'include'})
+        { :operation => 'include' }
+      )
     end
 
     classes = scope.transform_and_assert_classnames(classes.flatten)
-    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    result = classes.map { |name| Puppet::Pops::Types::TypeFactory.host_class(name) }
     scope.compiler.evaluate_classes(classes, scope, false)
 
     # Result is an Array[Class, 1, n] which allows chaining other operations

data/lib/puppet/functions/index.rb

@@ -40,7 +40,7 @@
 # Note that the lambda gets the value and not an array with `[key, value]` as in other
 # iterative functions.
 #
-# Using a lambda that accepts two values works the same way, it simply gets the index/key 
+# Using a lambda that accepts two values works the same way, it simply gets the index/key
 # as the first parameter, and the value as the second.
 #
 # @example Using the `index` function with an Array and a two-parameter lambda

data/lib/puppet/functions/join.rb

@@ -30,7 +30,7 @@
 # be made.
 #
 # @example Joining the result of a reverse_each converted to an array
-# 
+#
 # ```puppet
 # [1,2,3].reverse_each.convert_to(Array).join(', ')
 # # would result in: "3, 2, 1"

data/lib/puppet/functions/lookup.rb

@@ -186,7 +186,7 @@ Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction)
     optional_block_param 'BlockType',                     :block
   end
 
-  def lookup_1(scope, name, value_type=nil, merge=nil)
+  def lookup_1(scope, name, value_type = nil, merge = nil)
     do_lookup(scope, name, value_type, nil, false, {}, {}, merge)
   end
 
@@ -194,7 +194,7 @@ Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction)
     do_lookup(scope, name, value_type, default_value, true, {}, {}, merge)
   end
 
-  def lookup_3(scope, name, value_type=nil, merge=nil, &block)
+  def lookup_3(scope, name, value_type = nil, merge = nil, &block)
     do_lookup(scope, name, value_type, nil, false, {}, {}, merge, &block)
   end
 

data/lib/puppet/functions/lstrip.rb

@@ -49,7 +49,7 @@ Puppet::Functions.create_function(:lstrip) do
   end
 
   def on_iterable(a)
-    a.map {|x| do_lstrip(x) }
+    a.map { |x| do_lstrip(x) }
   end
 
   def do_lstrip(x)

data/lib/puppet/functions/map.rb

@@ -92,7 +92,7 @@ Puppet::Functions.create_function(:map) do
   def map_Hash_1(hash)
     result = []
     begin
-      hash.each {|x, y| result << yield([x, y]) }
+      hash.each { |x, y| result << yield([x, y]) }
     rescue StopIteration
     end
     result
@@ -101,7 +101,7 @@ Puppet::Functions.create_function(:map) do
   def map_Hash_2(hash)
     result = []
     begin
-      hash.each {|x, y| result << yield(x, y) }
+      hash.each { |x, y| result << yield(x, y) }
     rescue StopIteration
     end
     result

data/lib/puppet/functions/match.rb

@@ -74,7 +74,7 @@ Puppet::Functions.create_function(:match) do
   # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
   #
   def enumerable_match(array, pattern)
-    array.map {|s| match(s, pattern) }
+    array.map { |s| match(s, pattern) }
   end
 
   protected
@@ -99,7 +99,7 @@ Puppet::Functions.create_function(:match) do
   def match_PVariantType(var_t, s)
     # Find first matching type (or error out if one of the variants is not acceptable)
     result = nil
-    var_t.types.find {|t| result = match(s, t) }
+    var_t.types.find { |t| result = match(s, t) }
     result
   end
 
@@ -113,14 +113,14 @@ Puppet::Functions.create_function(:match) do
     # Since we want the actual match result (not just a boolean), an iteration over
     # Pattern's regular expressions is needed. (They are of PRegexpType)
     result = nil
-    pattern_t.patterns.find {|pattern| result = match(s, pattern) }
+    pattern_t.patterns.find { |pattern| result = match(s, pattern) }
     result
   end
 
   # Returns the first matching entry
   def match_Array(array, s)
     result = nil
-    array.flatten.find {|entry| result = match(s, entry) }
+    array.flatten.find { |entry| result = match(s, entry) }
     result
   end
 

data/lib/puppet/functions/max.rb

@@ -145,7 +145,7 @@ Puppet::Functions.create_function(:max) do
   def on_string(*args)
     assert_arg_count(args)
 
-    args.max do|a,b|
+    args.max do |a, b|
       if a.to_s =~ %r{\A^-?\d+([._eE]\d+)?\z} && b.to_s =~ %r{\A-?\d+([._eE]\d+)?\z}
         Puppet.warn_once('deprecations', 'max_function_numeric_coerce_string',
                          _("The max() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
@@ -173,7 +173,7 @@ Puppet::Functions.create_function(:max) do
   end
 
   def on_any_with_block(*args, &block)
-    args.max {|x,y| block.call(x,y) }
+    args.max { |x, y| block.call(x, y) }
   end
 
   def on_single_numeric_array(array, &block)

data/lib/puppet/functions/min.rb

@@ -144,7 +144,7 @@ Puppet::Functions.create_function(:min) do
   def on_string(*args)
     assert_arg_count(args)
 
-    args.min do|a,b|
+    args.min do |a, b|
       if a.to_s =~ %r{\A^-?\d+([._eE]\d+)?\z} && b.to_s =~ %r{\A-?\d+([._eE]\d+)?\z}
         Puppet.warn_once('deprecations', 'min_function_numeric_coerce_string',
                          _("The min() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
@@ -172,7 +172,7 @@ Puppet::Functions.create_function(:min) do
   end
 
   def on_any_with_block(*args, &block)
-    args.min {|x,y| block.call(x,y) }
+    args.min { |x, y| block.call(x, y) }
   end
 
   def on_single_numeric_array(array, &block)

data/lib/puppet/functions/next.rb

@@ -2,7 +2,7 @@
 
 # Makes iteration continue with the next value, optionally with a given value for this iteration.
 # If a value is not given it defaults to `undef`
-# 
+#
 # @example Using the `next()` function
 #
 # ```puppet

data/lib/puppet/functions/require.rb

@@ -50,14 +50,15 @@ Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction)
     if Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'require'})
+        { :operation => 'require' }
+      )
     end
 
     # Make call patterns uniform and protected against nested arrays, also make
     # names absolute if so desired.
     classes = scope.transform_and_assert_classnames(classes.flatten)
 
-    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    result = classes.map { |name| Puppet::Pops::Types::TypeFactory.host_class(name) }
 
     # This is the same as calling the include function (but faster) since it again
     # would otherwise need to perform the optional absolute name transformation

data/lib/puppet/functions/rstrip.rb

@@ -49,7 +49,7 @@ Puppet::Functions.create_function(:rstrip) do
   end
 
   def on_iterable(a)
-    a.map {|x| do_rstrip(x) }
+    a.map { |x| do_rstrip(x) }
   end
 
   def do_rstrip(x)

data/lib/puppet/functions/slice.rb

@@ -120,7 +120,7 @@ Puppet::Functions.create_function(:slice) do
 
     unless serving_size == 1 || serving_size == slice_size
       raise ArgumentError, _("slice(): block must define one parameter, or the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; %{parameter_names}") %
-          { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
+                           { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
     end
     serving_size
   end

data/lib/puppet/functions/strftime.rb

@@ -178,7 +178,7 @@
 # ```
 #
 # - Since 4.8.0
-# 
+#
 Puppet::Functions.create_function(:strftime) do
   dispatch :format_timespan do
     param 'Timespan', :time_object

data/lib/puppet/functions/strip.rb

@@ -49,7 +49,7 @@ Puppet::Functions.create_function(:strip) do
   end
 
   def on_iterable(a)
-    a.map {|x| do_strip(x) }
+    a.map { |x| do_strip(x) }
   end
 
   def do_strip(x)

data/lib/puppet/functions/tree_each.rb

@@ -171,12 +171,12 @@ Puppet::Functions.create_function(:tree_each) do
   end
 
   def tree_Enumerable1(enum, options = {}, &block)
-    iterator(enum, options).each {|_, v| yield(v) }
+    iterator(enum, options).each { |_, v| yield(v) }
     enum
   end
 
   def tree_Enumerable2(enum, options = {}, &block)
-    iterator(enum, options).each {|path, v| yield(path, v) }
+    iterator(enum, options).each { |path, v| yield(path, v) }
     enum
   end
 

data/lib/puppet/functions/unique.rb

@@ -58,7 +58,7 @@
 # ['aBc', 'AbC', 'bbb'].unique |$x| { String($x,'%d') }
 #
 # # will produce {[a] => [10], [b, c, d, e] => [11, 12, 100]}
-# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } } 
+# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } }
 # ```
 #
 # Note that for `Hash` the result is slightly different than for the other data types. For those the result contains the
@@ -66,7 +66,7 @@
 # equality lambda (or the default value equality if no lambda was given). This makes the `unique` function more versatile for hashes
 # in general, while requiring that the simple computation of "hash's unique set of values" is performed as `$hsh.map |$k, $v| { $v }.unique`.
 # (A unique set of hash keys is in general meaningless (since they are unique by definition) - although if processed with a different
-# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted). 
+# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted).
 # If the more advanced clustering is wanted for one of the other data types, simply transform it into a `Hash` as shown in the
 # following example.
 #
@@ -111,20 +111,20 @@ Puppet::Functions.create_function(:unique) do
   end
 
   def unique_hash(hash, &block)
-    block = lambda {|v| v } unless block_given?
-    result = Hash.new {|h, k| h[k] = {:keys =>[], :values =>[]} }
-    hash.each_pair do |k,v|
-      rc = result[ block.call(v) ]
+    block = ->(v) { v } unless block_given?
+    result = Hash.new { |h, k| h[k] = { :keys => [], :values => [] } }
+    hash.each_pair do |k, v|
+      rc = result[block.call(v)]
       rc[:keys] << k
       rc[:values] << v
     end
     # reduce the set of possibly duplicated value entries
     inverted = {}
-    result.each_pair {|_k,v| inverted[v[:keys]] = v[:values].uniq }
+    result.each_pair { |_k, v| inverted[v[:keys]] = v[:values].uniq }
     inverted
   end
 
-  def unique_array(array,&block)
+  def unique_array(array, &block)
     array.uniq(&block)
   end
 

data/lib/puppet/functions/upcase.rb

@@ -76,12 +76,12 @@ Puppet::Functions.create_function(:upcase) do
   end
 
   def on_array(a)
-    a.map {|x| do_upcase(x) }
+    a.map { |x| do_upcase(x) }
   end
 
   def on_hash(h)
     result = {}
-    h.each_pair {|k,v| result[do_upcase(k)] = do_upcase(v) }
+    h.each_pair { |k, v| result[do_upcase(k)] = do_upcase(v) }
     result
   end
 

data/lib/puppet/functions.rb

@@ -192,7 +192,7 @@ module Puppet::Functions
       loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
       create_loaded_function(func_name, loader, function_base, &block)
     rescue StandardError => e
-      raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % {function_name: func_name, message: e.message}
+      raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % { function_name: func_name, message: e.message }
     end
   end
 
@@ -279,9 +279,9 @@ module Puppet::Functions
 
   # @api private
   def self.min_max_param(method)
-    result = {:req => 0, :opt => 0, :rest => 0 }
+    result = { :req => 0, :opt => 0, :rest => 0 }
     # count per parameter kind, and get array of names
-    names = method.parameters.map { |p| result[p[0]] += 1 ; p[1].to_s }
+    names = method.parameters.map { |p| result[p[0]] += 1; p[1].to_s }
     from = result[:req]
     to = result[:rest] > 0 ? :default : from + result[:opt]
     [from, to, names]
@@ -547,7 +547,7 @@ module Puppet::Functions
         if repeat
           @weaving << -@names.size()
         else
-          @weaving << @names.size()-1
+          @weaving << @names.size() - 1
         end
       else
         raise ArgumentError, _("Parameter 'type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
@@ -635,20 +635,20 @@ module Puppet::Functions
         rb_location = rb_location.gsub(/:in.*$/, '')
         # Create a meaningful location for parse errors - show both what went wrong with the parsing
         # and in which ruby file it was found.
-        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" +
-          "Called from <%{ruby_file_location}>") % {
-            assignment_string: assignment_string,
-            message: e.message,
-            ruby_file_location: rb_location
-          }
+        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" \
+                               "Called from <%{ruby_file_location}>") % {
+                                 assignment_string: assignment_string,
+                                 message: e.message,
+                                 ruby_file_location: rb_location
+                               }
       end
-      unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
+      unless result.body.is_a?(Puppet::Pops::Model::TypeAlias)
         rb_location = rb_location.gsub(/:in.*$/, '')
-        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n"+
-        "Called from <%{ruby_file_location}>") % {
-          assignment_string: assignment_string,
-          ruby_file_location: rb_location
-        }
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n" \
+                               "Called from <%{ruby_file_location}>") % {
+                                 assignment_string: assignment_string,
+                                 ruby_file_location: rb_location
+                               }
       end
       @local_types << result.body
     end
@@ -797,7 +797,7 @@ module Puppet::Functions
       end
       # Names of parameters, up to 5 are optimized and use frozen version
       # Note that (0..count-1) produces expected empty array for count == 0, 0-n for count >= 1
-      names = count <= 5 ? PARAM_NAMES[count] : (0..count-1).map {|n| "p#{n}" }
+      names = count <= 5 ? PARAM_NAMES[count] : (0..count - 1).map { |n| "p#{n}" }
       [from, to, names]
     end
   end
@@ -857,7 +857,7 @@ module Puppet::Functions
     def inject(injection_name)
       @injections << injection_name
       # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size()-1]
+      @weaving << [@injections.size() - 1]
     end
   end
 end

data/lib/puppet/generate/models/type/property.rb

@@ -61,7 +61,7 @@ module Puppet
             enum    = strings.empty? ? nil : "Enum[#{strings.join(', ')}]"
             pattern = regexes.empty? ? nil : "Pattern[#{regexes.join(', ')}]"
             boolean = strings.include?('\'true\'') || strings.include?('\'false\'') ? 'Boolean' : nil
-            variant = [boolean, enum, pattern].reject { |t| t.nil? }
+            variant = [boolean, enum, pattern].compact
             return variant[0] if variant.size == 1
 
             "Variant[#{variant.join(', ')}]"

data/lib/puppet/generate/models/type/type.rb

@@ -40,7 +40,7 @@ module Puppet
               Property.new(type.paramclass(name))
             end
             sc = Puppet::Pops::Types::StringConverter.singleton
-            @title_patterns = Hash[type.title_patterns.map do |mapping|
+            @title_patterns = type.title_patterns.to_h do |mapping|
               [
                 sc.convert(mapping[0], '%p'),
                 sc.convert(mapping[1].map do |names|
@@ -50,7 +50,7 @@ module Puppet
                   names[0].to_s
                 end, '%p')
               ]
-            end]
+            end
             @isomorphic = type.isomorphic?
             # continue to emit capability as false when rendering the ERB
             # template, so that pcore modules generated prior to puppet7 can be

data/lib/puppet/generate/type.rb

@@ -49,7 +49,7 @@ module Puppet
         # @return [Boolean] Returns true if the output is up-to-date or false if not.
         def up_to_date?(outputdir)
           f = effective_output_path(outputdir)
-          Puppet::FileSystem::exist?(f) && (Puppet::FileSystem::stat(@path) <=> Puppet::FileSystem::stat(f)) <= 0
+          Puppet::FileSystem.exist?(f) && (Puppet::FileSystem.stat(@path) <=> Puppet::FileSystem.stat(f)) <= 0
         end
 
         # Gets the filename of the output file.
@@ -155,8 +155,8 @@ module Puppet
       def self.generate(inputs, outputdir = nil, force = false)
         # remove files for non existing inputs
         unless outputdir.nil?
-          filenames_to_keep = inputs.map {|i| i.output_name }
-          existing_files = Puppet::FileSystem.children(outputdir).map {|f| Puppet::FileSystem.basename(f) }
+          filenames_to_keep = inputs.map { |i| i.output_name }
+          existing_files = Puppet::FileSystem.children(outputdir).map { |f| Puppet::FileSystem.basename(f) }
           files_to_remove = existing_files - filenames_to_keep
           files_to_remove.each do |f|
             Puppet::FileSystem.unlink(File.join(outputdir, f))

data/lib/puppet/graph/rb_tree_map.rb

@@ -300,15 +300,15 @@ class Puppet::Graph::RbTreeMap
 
   def delete_recursive(node, key)
     if (key <=> node.key) == -1
-      node.move_red_left if ( !isred(node.left) && !isred(node.left.left) )
+      node.move_red_left if (!isred(node.left) && !isred(node.left.left))
       node.left, result = delete_recursive(node.left, key)
     else
       node.rotate_right if isred(node.left)
-      if ( ( (key <=> node.key) == 0) && node.right.nil? )
+      if (((key <=> node.key) == 0) && node.right.nil?)
         return nil, node.value
       end
 
-      if ( !isred(node.right) && !isred(node.right.left) )
+      if (!isred(node.right) && !isred(node.right.left))
         node.move_red_right
       end
       if (key <=> node.key) == 0
@@ -329,7 +329,7 @@ class Puppet::Graph::RbTreeMap
       return nil, node.value
     end
 
-    if ( !isred(node.left) && !isred(node.left.left) )
+    if (!isred(node.left) && !isred(node.left.left))
       node.move_red_left
     end
     node.left, result = delete_min_recursive(node.left)
@@ -343,7 +343,7 @@ class Puppet::Graph::RbTreeMap
     end
     return nil, node.value if node.right.nil?
 
-    if ( !isred(node.right) && !isred(node.right.left) )
+    if (!isred(node.right) && !isred(node.right.left))
       node.move_red_right
     end
     node.right, result = delete_max_recursive(node.right)

data/lib/puppet/graph/relationship_graph.rb

@@ -43,7 +43,7 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     end
   end
 
-  def add_relationship(f, t, label=nil)
+  def add_relationship(f, t, label = nil)
     super(f, t, label)
     @ready.delete(@prioritizer.priority_of(t))
   end
@@ -99,12 +99,12 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
   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 {}
-    graph_cycle_handler = options[:graph_cycle_handler] || lambda { [] }
+    continue_while = options[:while] || -> { true }
+    pre_process = options[:pre_process] || ->(resource) {}
+    overly_deferred_resource_handler = options[:overly_deferred_resource_handler] || ->(resource) {}
+    canceled_resource_handler = options[:canceled_resource_handler] || ->(resource) {}
+    teardown = options[:teardown] || -> {}
+    graph_cycle_handler = options[:graph_cycle_handler] || -> { [] }
 
     cycles = report_cycles_in_graph
     if cycles
@@ -171,7 +171,7 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
 
   def build_autorelation_dependencies(catalog)
     vertices.each do |vertex|
-      [:require,:subscribe].each do |rel_type|
+      [: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)
@@ -191,7 +191,7 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
         end
       end
 
-      [:before,:notify].each do |rel_type|
+      [: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)
@@ -245,8 +245,8 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     #   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 }
+    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)
@@ -265,19 +265,19 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     #
     containers.each { |x|
       contents = catalog.adjacent(x, :direction => :out)
-      add_edge(admissible[x],completed[x]) if contents.empty? # (0)
+      add_edge(admissible[x], completed[x]) if contents.empty? # (0)
       contents.each { |v|
-        add_edge(admissible[x],admissible[v],Default_label) # (1)
+        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)
+      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)
+      adjacent(x, :direction => :out, :type => :edges).each { |e|
+        add_edge(completed[x], admissible[e.target], e.label)
         remove_edge! e
       }
     }