puppet 5.3.4 → 6.29.0

data/lib/puppet/functions.rb

@@ -186,8 +186,12 @@ module Puppet::Functions
     # and it will fail unless protected with an if defined? if the local
     # variable does not exist in the block's binder.
     #
-    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
-    create_loaded_function(func_name, loader, function_base, &block)
+    begin
+      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}
+    end
   end
 
   # Creates a function in, or in a local loader under the given loader.
@@ -381,6 +385,7 @@ module Puppet::Functions
     end
   end
 
+
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
@@ -474,8 +479,8 @@ module Puppet::Functions
         type = @all_callables
         name = type_and_name[0]
       when 2
-        type_string, name = type_and_name
-        type = Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+        type, name = type_and_name
+        type = Puppet::Pops::Types::TypeParser.singleton.parse(type, loader) unless type.is_a?(Puppet::Pops::Types::PAnyType)
       else
         raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
       end
@@ -513,7 +518,9 @@ module Puppet::Functions
     #
     # @api public
     def return_type(type)
-      raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class } unless type.is_a?(String)
+      unless type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
+        raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
+      end
       @return_type = type
     end
 
@@ -528,7 +535,7 @@ module Puppet::Functions
         raise ArgumentError, _("Parameter name argument must be a Symbol. Got %{name_class}") % { name_class: name.class }
       end
 
-      if type.is_a?(String)
+      if type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
         @types << type
         @names << name
         # mark what should be picked for this position when dispatching
@@ -558,7 +565,7 @@ module Puppet::Functions
       @block_name = nil
       @return_type = nil
       @argument_mismatch_hander = argument_mismatch_handler
-      self.instance_eval &block
+      self.instance_eval(&block)
       callable_t = create_callable(@types, @block_type, @return_type, @min, @max)
       @dispatcher.add(Puppet::Pops::Functions::Dispatch.new(callable_t, meth_name, @names, @max == :default, @block_name, @injections, @weaving, @argument_mismatch_hander))
     end
@@ -571,14 +578,27 @@ module Puppet::Functions
     # @api private
     def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
-        Puppet::Pops::Types::TypeParser.singleton.parse(t, loader)
+        t.is_a?(Puppet::Pops::Types::PAnyType) ? t : internal_type_parse(t, loader)
       end
       param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
-      return_type = Puppet::Pops::Types::TypeParser.singleton.parse(return_type, loader) unless return_type.nil?
+      return_type = internal_type_parse(return_type, loader) unless return_type.nil? || return_type.is_a?(Puppet::Pops::Types::PAnyType)
       Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
     end
+
+    def internal_type_parse(type_string, loader)
+      begin
+        Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+      rescue StandardError => e
+        raise ArgumentError, _("Parsing of type string '\"%{type_string}\"' failed with message: <%{message}>.\n") % {
+            type_string: type_string,
+            message: e.message
+        }
+      end
+    end
+    private :internal_type_parse
   end
 
+
   # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
   # type aliases given by the function's author.
   #
@@ -601,45 +621,41 @@ module Puppet::Functions
     # @api public
     #
     def type(assignment_string)
-      result = parser.parse_string("type #{assignment_string}", nil) # no file source :-(
+      # Get location to use in case of error - this produces ruby filename and where call to 'type' occurred
+      # but strips off the rest of the internal "where" as it is not meaningful to user.
+      #
+      rb_location = caller(1, 1).first
+      begin
+        result = parser.parse_string("type #{assignment_string}", nil)
+      rescue StandardError => e
+        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
+        }
+      end
       unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
-        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'") % { assignment_string: assignment_string }
+        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
+        }
       end
       @local_types << result.body
     end
   end
 
-  private
-
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #
   # This is a private, internal, system for creating functions. It supports
   # everything that the public function definition system supports as well as a
-  # few extra features.
-  #
-  # Injection Support
-  # ===
-  # The Function API supports injection of data and services. It is possible to
-  # make injection that takes effect when the function is loaded (for services
-  # and runtime configuration that does not change depending on how/from where
-  # in what context the function is called. It is also possible to inject and
-  # weave argument values into a call.
-  #
-  # Injection of attributes
-  # ---
-  # Injection of attributes is performed by one of the methods `attr_injected`,
-  # and `attr_injected_producer`.  The injected attributes are available via
-  # accessor method calls.
-  #
-  # @example using injected attributes
-  #   Puppet::Functions.create_function('test') do
-  #     attr_injected String, :larger, 'message_larger'
-  #     attr_injected String, :smaller, 'message_smaller'
-  #     def test(a, b)
-  #       a > b ? larger() : smaller()
-  #     end
-  #   end
+  # few extra features such as injection of well known parameters.
   #
   # @api private
   class InternalFunction < Function
@@ -663,26 +679,144 @@ module Puppet::Functions
     end
   end
 
-  # @note WARNING: This style of creating functions is not public. It is a system
-  #   under development that will be used for creating "system" functions.
-  #
+  class Function3x < InternalFunction
+
+    # Table of optimized parameter names - 0 to 5 parameters
+    PARAM_NAMES = [
+      [],
+      ['p0'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze, 'p4'.freeze].freeze,
+    ]
+
+    # Creates an anonymous Function3x class that wraps a 3x function
+    #
+    # @api private
+    def self.create_function(func_name, func_info, loader)
+      func_name = func_name.to_s
+
+      # Creates an anonymous class to represent the function
+      # The idea being that it is garbage collected when there are no more
+      # references to it.
+      #
+      # (Do not give the class the block here, as instance variables should be set first)
+      the_class = Class.new(Function3x)
+
+      unless loader.nil?
+        the_class.instance_variable_set(:'@loader', loader.private_loader)
+      end
+
+      the_class.instance_variable_set(:'@func_name', func_name)
+      the_class.instance_variable_set(:'@method3x', :"function_#{func_name}")
+
+      # Make the anonymous class appear to have the class-name <func_name>
+      # Even if this class is not bound to such a symbol in a global ruby scope and
+      # must be resolved via the loader.
+      # This also overrides any attempt to define a name method in the given block
+      # (Since it redefines it)
+      #
+      the_class.instance_eval do
+        def name
+          @func_name
+        end
+
+        def loader
+          @loader
+        end
+
+        def method3x
+          @method3x
+        end
+      end
+
+      # Add the method that is called - it simply delegates to
+      # the 3.x function by calling it via the calling scope using the @method3x symbol
+      # :"function_#{name}".
+      #
+      # When function is not an rvalue function, make sure it produces nil
+      #
+      the_class.class_eval do
+
+        # Bypasses making the  call via the dispatcher to make sure errors
+        # are reported exactly the same way as in 3x. The dispatcher is still needed as it is
+        # used to support other features than calling.
+        #
+        def call(scope, *args, &block)
+          begin
+            result = catch(:return) do
+              mapped_args = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, scope, '')
+              # this is the scope.function_xxx(...) call
+              return scope.send(self.class.method3x, mapped_args)
+            end
+            return result.value
+          rescue Puppet::Pops::Evaluator::Next => jumper
+            begin
+              throw :next, jumper.value
+            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+              raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
+            end
+          rescue Puppet::Pops::Evaluator::Return => jumper
+            begin
+              throw :return, jumper
+            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+              raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
+            end
+          end
+        end
+      end
+
+      # Create a dispatcher based on func_info
+      type, names = Puppet::Functions.any_signature(*from_to_names(func_info))
+      last_captures_rest = (type.size_range[1] == Float::INFINITY)
+
+      # The method '3x_function' here is a dummy as the dispatcher is not used for calling, only for information.
+      the_class.dispatcher.add(Puppet::Pops::Functions::Dispatch.new(type, '3x_function', names, last_captures_rest))
+      # The function class is returned as the result of the create function method
+      the_class
+    end
+
+    # Compute min and max number of arguments and a list of constructed
+    # parameter names p0 - pn (since there are no parameter names in 3x functions).
+    #
+    # @api private
+    def self.from_to_names(func_info)
+      arity = func_info[:arity]
+      if arity.nil?
+        arity = -1
+      end
+      if arity < 0
+        from = -arity - 1 # arity -1 is 0 min param, -2 is min 1 param
+        to = :default     # infinite range
+        count = -arity    # the number of named parameters
+      else
+        count = from = to = arity
+      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}" }
+      [from, to, names]
+    end
+  end
+
+
   # Injection and Weaving of parameters
   # ---
-  # It is possible to inject and weave parameters into a call. These extra
-  # parameters are not part of the parameters passed from the Puppet logic, and
-  # they can not be overridden by parameters given as arguments in the call.
-  # They are invisible to the Puppet Language.
+  # It is possible to inject and weave a set of well known parameters into a call.
+  # These extra parameters are not part of the parameters passed from the Puppet
+  # logic, and  they can not be overridden by parameters given as arguments in the
+  # call. They are invisible to the Puppet Language.
   #
   # @example using injected parameters
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
-  #       injected_param 'String', 'larger', 'message_larger'
-  #       injected_param 'String', 'smaller', 'message_smaller'
+  #       scope_param
   #     end
-  #     def test(a, b, larger, smaller)
-  #       a > b ? larger : smaller
+  #     def test(a, b, scope)
+  #       a > b ? scope['a'] : scope['b']
   #     end
   #   end
   #
@@ -690,54 +824,37 @@ module Puppet::Functions
   #
   #     test(10, 20)
   #
-  # Using injected value as default
-  # ---
-  # Default value assignment is handled by using the regular Ruby mechanism (a
-  # value is assigned to the variable).  The dispatch simply indicates that the
-  # value is optional. If the default value should be injected, it can be
-  # handled different ways depending on what is desired:
-  #
-  # * by calling the accessor method for an injected Function class attribute.
-  #   This is suitable if the value is constant across all instantiations of the
-  #   function, and across all calls.
-  # * by injecting a parameter into the call
-  #   to the left of the parameter, and then assigning that as the default value.
-  # * One of the above forms, but using an injected producer instead of a
-  #   directly injected value.
-  #
-  # @example method with injected default values
-  #   Puppet::Functions.create_function('test') do
-  #     dispatch :test do
-  #       injected_param String, 'b_default', 'b_default_value_key'
-  #       param 'Scalar', 'a'
-  #       param 'Scalar', 'b'
-  #     end
-  #     def test(b_default, a, b = b_default)
-  #       # ...
-  #     end
-  #   end
-  #
   # @api private
   class InternalDispatchBuilder < DispatcherBuilder
-    def scope_param()
-      @injections << [:scope, 'scope', '', :dispatcher_internal]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size()-1]
+    # Inject parameter for `Puppet::Parser::Scope`
+    def scope_param
+      inject(:scope)
     end
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size() -1]
+
+    # Inject parameter for `Puppet::Pal::ScriptCompiler`
+    def script_compiler_param
+      inject(:pal_script_compiler)
     end
 
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_producer_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name, :producer]
+    # Inject a parameter getting a cached hash for this function
+    def cache_param
+      inject(:cache)
+    end
+
+    # Inject parameter for `Puppet::Pal::CatalogCompiler`
+    def compiler_param
+      inject(:pal_catalog_compiler)
+    end
+
+    # Inject parameter for either `Puppet::Pal::CatalogCompiler` or `Puppet::Pal::ScriptCompiler`
+    def pal_compiler_param
+      inject(:pal_compiler)
+    end
+
+    private
+
+    def inject(injection_name)
+      @injections << injection_name
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end

data/lib/puppet/generate/type.rb

@@ -5,7 +5,7 @@ require 'puppet/generate/models/type/type'
 
 module Puppet
   module Generate
-    # Reponsible for generating type definitions in Puppet
+    # Responsible for generating type definitions in Puppet
     class Type
       # Represents an input to the type generator
       class Input
@@ -134,6 +134,9 @@ module Puppet
         inputs.sort_by! { |input| input.path }
       end
 
+      def self.bad_input?
+        @bad_input
+      end
       # Generates files for the given inputs.
       # If a file is up to date (newer than input) it is kept.
       # If a file is out of date it is regenerated.
@@ -170,6 +173,8 @@ module Puppet
         }
 
         up_to_date = true
+        @bad_input = false
+
         Puppet.notice _('Generating Puppet resource types.')
         inputs.each do |input|
           if !force && input.up_to_date?(outputdir)
@@ -187,6 +192,7 @@ module Puppet
             raise
           rescue Exception => e
             # Log the exception and move on to the next input
+            @bad_input = true
             Puppet.log_exception(e, _("Failed to load custom type '%{type_name}' from '%{input}': %{message}") % { type_name: type_name, input: input, message: e.message })
             next
           end
@@ -195,7 +201,8 @@ module Puppet
           types ||= Puppet::Type.instance_variable_get('@types')
 
           # Assume the type follows the naming convention
-          unless type = types[type_name]
+          type = types[type_name]
+          unless type
             Puppet.err _("Custom type '%{type_name}' was not defined in '%{input}'.") % { type_name: type_name, input: input }
             next
           end
@@ -204,6 +211,7 @@ module Puppet
           begin
             model = Models::Type::Type.new(type)
           rescue Exception => e
+            @bad_input = true
             # Move on to the next input
             Puppet.log_exception(e, "#{input}: #{e.message}")
             next
@@ -213,6 +221,7 @@ module Puppet
           begin
             result = model.render(templates[input.template_path])
           rescue Exception => e
+            @bad_input = true
             Puppet.log_exception(e)
             raise
           end
@@ -226,6 +235,7 @@ module Puppet
               file.write(result)
             end
           rescue Exception => e
+            @bad_input = true
             Puppet.log_exception(e, _("Failed to generate '%{effective_output_path}': %{message}") % { effective_output_path: effective_output_path, message: e.message })
             # Move on to the next input
             next

data/lib/puppet/gettext/config.rb

@@ -4,8 +4,9 @@ require 'puppet/file_system'
 module Puppet::GettextConfig
   LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
   POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
-  WINDOWS_PATH = File.absolute_path('../../../../../../../puppet/share/locale', File.dirname(__FILE__))
+  WINDOWS_PATH = File.absolute_path('../../../../../../puppet/share/locale', File.dirname(__FILE__))
 
+  # This is the only domain name that won't be a symbol, making it unique from environments.
   DEFAULT_TEXT_DOMAIN = 'default-text-domain'
 
   # Load gettext helpers and track whether they're available.
@@ -59,10 +60,12 @@ module Puppet::GettextConfig
   # Clears the translation repository for the given text domain,
   # creating it if it doesn't exist, then adds default translations
   # and switches to using this domain.
-  # @param [String] domain_name the name of the domain to create
+  # @param [String, Symbol] domain_name the name of the domain to create
   def self.reset_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
 
+    Puppet.debug { "Reset text domain to #{domain_name.inspect}" }
     FastGettext.add_text_domain(domain_name,
                                 type: :chain,
                                 chain: [],
@@ -71,6 +74,18 @@ module Puppet::GettextConfig
     FastGettext.text_domain = domain_name
   end
 
+  # @api private
+  # Resets the thread's configured text_domain to the default text domain.
+  # In Puppet Server, thread A may process a compile request that configures
+  # a domain, while thread B may invalidate that environment and delete the
+  # domain. That leaves thread A with an invalid text_domain selected.
+  # To avoid that, clear_text_domain after any processing that needs the
+  # non-default text domain.
+  def self.clear_text_domain
+    return if @gettext_disabled || !gettext_loaded?
+    FastGettext.text_domain = nil
+  end
+
   # @api private
   # Creates a default text domain containing the translations for
   # Puppet as the start of chain. When semantic_puppet gets initialized,
@@ -94,12 +109,16 @@ module Puppet::GettextConfig
 
   # @api private
   # Switches the active text domain, if the requested domain exists.
-  # @param [String] domain_name the name of the domain to switch to
+  # @param [String, Symbol] domain_name the name of the domain to switch to
   def self.use_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
 
     if FastGettext.translation_repositories.include?(domain_name)
+      Puppet.debug { "Use text domain #{domain_name.inspect}" }
       FastGettext.text_domain = domain_name
+    else
+      Puppet.debug { "Requested unknown text domain #{domain_name.inspect}" }
     end
   end
 
@@ -113,13 +132,17 @@ module Puppet::GettextConfig
 
   # @api private
   # Deletes the text domain with the given name
-  # @param [String] domain_name the name of the domain to delete
+  # @param [String, Symbol] domain_name the name of the domain to delete
   def self.delete_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
 
-    FastGettext.translation_repositories.delete(domain_name)
+    deleted = FastGettext.translation_repositories.delete(domain_name)
     if FastGettext.text_domain == domain_name
+      Puppet.debug { "Deleted current text domain #{domain_name.inspect}: #{!deleted.nil?}" }
       FastGettext.text_domain = nil
+    else
+      Puppet.debug { "Deleted text domain #{domain_name.inspect}: #{!deleted.nil?}" }
     end
   end
 
@@ -145,7 +168,7 @@ module Puppet::GettextConfig
   # Since we are currently (Nov 2017) vendoring semantic_puppet, in normal
   # flows these translations will be copied along with Puppet's.
   #
-  # @param [String] domain_name the name of the domain to add translations to
+  # @param [Symbol] domain_name the name of the domain to add translations to
   def self.copy_default_translations(domain_name)
     return if @gettext_disabled || !gettext_loaded?
 
@@ -191,7 +214,7 @@ module Puppet::GettextConfig
   end
 
   # @api private
-  # Attempt to load tranlstions for the given project.
+  # Attempt to load translations for the given project.
   # @param [String] project_name the project whose translations we want to load
   # @param [String] locale_dir the path to the directory containing translations
   # @param [Symbol] file_format translation file format to use, either :po or :mo
@@ -218,7 +241,7 @@ module Puppet::GettextConfig
   # chain for the currently selected text domain, if needed.
   # @param [String] project_name the name of the project for which to load translations
   # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format the fomat of the translations files, :po or :mo
+  # @param [Symbol] file_format the format of the translations files, :po or :mo
   def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
     return if @gettext_disabled || !gettext_loaded?
 

data/lib/puppet/gettext/module_translations.rb

@@ -11,11 +11,11 @@ module Puppet::ModuleTranslations
     modules.each do |mod|
       next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
 
-      module_name = mod.forge_name.gsub('/', '-')
+      module_name = mod.forge_name.tr('/', '-')
       if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
-        Puppet.debug "Loaded translations for #{module_name}."
+        Puppet.debug { "Loaded translations for #{module_name}." }
       elsif Puppet::GettextConfig.gettext_loaded?
-        Puppet.debug "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization."
+        Puppet.debug { "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization." }
       else
         Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
       end
@@ -31,9 +31,9 @@ module Puppet::ModuleTranslations
     Dir.glob("#{vardir}/locales/#{locale}/*.po") do |f|
       module_name = File.basename(f, ".po")
       if Puppet::GettextConfig.load_translations(module_name, File.join(vardir, "locales"), :po)
-        Puppet.debug "Loaded translations for #{module_name}."
+        Puppet.debug { "Loaded translations for #{module_name}." }
       elsif Puppet::GettextConfig.gettext_loaded?
-        Puppet.debug "Could not load translations for #{module_name}."
+        Puppet.debug { "Could not load translations for #{module_name}." }
       else
         Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
       end

data/lib/puppet/gettext/stubs.rb

@@ -1,4 +1,4 @@
-# These stub the translation methods noramlly brought in
+# These stub the translation methods normally brought in
 # by FastGettext. Used when Gettext could not be properly
 # initialized.
 def _(msg)

data/lib/puppet/graph/rb_tree_map.rb

@@ -213,8 +213,8 @@ class Puppet::Graph::RbTreeMap
           :color => @color,
         }
       }
-      h.merge!(:left => left.to_hash) if @left
-      h.merge!(:right => right.to_hash) if @right
+      h[:left] = left.to_hash if @left
+      h[:right] = right.to_hash if @right
       h
     end
 

data/lib/puppet/graph/relationship_graph.rb

@@ -104,7 +104,8 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     teardown = options[:teardown] || lambda {}
     graph_cycle_handler = options[:graph_cycle_handler] || lambda { [] }
 
-    if cycles = report_cycles_in_graph
+    cycles = report_cycles_in_graph
+    if cycles
       graph_cycle_handler.call(cycles)
     end