puppet 6.4.5-x64-mingw32 → 6.5.0-x64-mingw32

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -33,7 +33,7 @@ module Runtime3Support
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
-    if except.nil? && diagnostic_producer.severity_producer[issue] == :error
+    if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()
@@ -299,10 +299,10 @@ module Runtime3Support
     # 'ruby -wc' thinks that _func is unused, because the only reference to it
     # is inside of the Kernel.eval string below. By prefixing it with the
     # underscore, we let Ruby know to not worry about whether it's unused or not.
-    if loader && func = loader.load(:function, name)
+    if loader && _func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
-        # Add stack frame when calling.
-        return Puppet::Pops::PuppetStack.stack(file || '', line, func, :call, [scope, *args], &block)
+        # Add stack frame when calling. See Puppet::Pops::PuppetStack
+        return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
     # Call via 3x API if function exists there without having been autoloaded

data/lib/puppet/pops/loader/null_loader.rb

@@ -0,0 +1,60 @@
+# The null loader is empty and delegates everything to its parent if it has one.
+#
+class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
+  attr_reader :loader_name
+
+  # Construct a NullLoader, optionally with a parent loader
+  #
+  def initialize(parent_loader=nil, loader_name = "null-loader")
+    super(loader_name)
+    @parent = parent_loader
+  end
+
+  # Has parent if one was set when constructed
+  def parent
+    @parent
+  end
+
+  def find(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.find(typed_name)
+    end
+  end
+
+  def load_typed(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.load_typed(typed_name)
+    end
+  end
+
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @parent.nil?
+      nil
+    else
+      @parent.loaded_entry(typed_name, check_dependencies)
+    end
+  end
+
+  # Has no entries on its own - always nil
+  def get_entry(typed_name)
+    nil
+  end
+
+  # Finds nothing, there are no entries
+  def find(name)
+    nil
+  end
+
+  # Cannot store anything
+  def set_entry(typed_name, value, origin = nil)
+    nil
+  end
+
+  def to_s()
+    "(NullLoader '#{loader_name}')"
+  end
+end

data/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -19,9 +19,10 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
     # When func3x turned on, assert content by parsing, when turned off continue with (legacy) undefined behavior
     if Puppet[:func3x_check]
       assertion_result = []
-      assert_code(ruby_code_string, assertion_result)
-      unless ruby_code_string.is_a?(String) && assertion_result.include?(:found_newfunction)
-        raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
+      if assert_code(ruby_code_string, assertion_result)
+        unless ruby_code_string.is_a?(String) && assertion_result.include?(:found_newfunction)
+          raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
+        end
       end
     end
 
@@ -72,8 +73,9 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
 
   def self.assert_code(code_string, result)
     ripped = Ripper.sexp(code_string)
-    return if ripped.nil?  # Let the next real parse crash and tell where and what is wrong
+    return false if ripped.nil?  # Let the next real parse crash and tell where and what is wrong
     ripped.each {|x| walk(x, result) }
+    true
   end
   private_class_method :assert_code
 

data/lib/puppet/pops/loader/task_instantiator.rb

@@ -18,10 +18,6 @@ class TaskInstantiator
     task = { 'name' => name, 'metadata' => metadata, 'files' => files }
 
     begin
-      unless metadata['parameters'].is_a?(Hash) || metadata['parameters'].nil?
-        msg = _('Failed to load metadata for task %{name}: \'parameters\' must be a hash') % { name: name }
-        raise Puppet::ParseError.new(msg, metadata_file)
-      end
       task['parameters'] = convert_types(metadata['parameters'])
 
       Types::TypeFactory.task.from_hash(task)

data/lib/puppet/pops/loaders.rb

@@ -283,7 +283,7 @@ class Loaders
         nil
       elsif File.directory?(file)
         raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints directory '#{file}'. It must be a file"
-      elsif File.exist?(file)
+      elsif File.exists?(file)
         parser.parse_file(file)
       else
         raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints '#{file}'. It does not exist"

data/lib/puppet/pops/lookup/hiera_config.rb

@@ -339,7 +339,6 @@ class HieraConfig
   def self.not_implemented(impl, method_name)
     raise NotImplementedError, "The class #{impl.class.name} should have implemented the method #{method_name}()"
   end
-  private_class_method :not_implemented
 end
 
 # @api private

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -30,7 +30,7 @@ module SubLookup
       raise yield('Syntax error') unless segments.size * 2 == count + 1
       segments.map! do |segment|
         segment.strip!
-        if segment.start_with?('"', "'")
+        if segment.start_with?('"') || segment.start_with?("'")
           segment[1..-2]
         elsif segment =~ /^(:?[+-]?[0-9]+)$/
           segment.to_i

data/lib/puppet/pops/merge_strategy.rb

@@ -173,14 +173,12 @@ module Puppet::Pops
 
     protected
 
-    class << self
-      # Returns the type used to validate the options hash
-      #
-      # @return [Types::PStructType] the puppet type
-      #
-      def options_t
-        @options_t ||=Types::TypeParser.singleton.parse("Struct[{strategy=>Optional[Pattern[/#{key}/]]}]")
-      end
+    # Returns the type used to validate the options hash
+    #
+    # @return [Types::PStructType] the puppet type
+    #
+    def self.options_t
+      @options_t ||=Types::TypeParser.singleton.parse("Struct[{strategy=>Optional[Pattern[/#{key}/]]}]")
     end
 
     # Returns the type used to validate the options hash
@@ -385,20 +383,18 @@ module Puppet::Pops
 
     protected
 
-    class << self
-      # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
-      # the setting of that option to false
-      #
-      # @return [Types::PAnyType] the puppet type used when validating the options hash
-      def options_t
-        @options_t ||= Types::TypeParser.singleton.parse('Struct[{'\
-                                                         "strategy=>Optional[Pattern[#{key}]],"\
-                                                         'knockout_prefix=>Optional[String],'\
-                                                         'merge_debug=>Optional[Boolean],'\
-                                                         'merge_hash_arrays=>Optional[Boolean],'\
-                                                         'sort_merged_arrays=>Optional[Boolean],'\
-                                                         '}]')
-      end
+    # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
+    # the setting of that option to false
+    #
+    # @return [Types::PAnyType] the puppet type used when validating the options hash
+    def self.options_t
+      @options_t ||= Types::TypeParser.singleton.parse('Struct[{'\
+          "strategy=>Optional[Pattern[#{key}]],"\
+          'knockout_prefix=>Optional[String],'\
+          'merge_debug=>Optional[Boolean],'\
+          'merge_hash_arrays=>Optional[Boolean],'\
+          'sort_merged_arrays=>Optional[Boolean],'\
+          '}]')
     end
 
     def value_t

data/lib/puppet/pops/parser/heredoc_support.rb

@@ -136,7 +136,7 @@ module HeredocSupport
       # simply leaves lines that have text in the margin untouched.
       #
       processed_lines = lines.collect {|s| s.gsub(leading_pattern, '') }
-      margin_per_line = Array.new(processed_lines.length) {|x| lines[x].length - processed_lines[x].length }
+      margin_per_line = processed_lines.length.times.map {|x| lines[x].length - processed_lines[x].length }
       lines = processed_lines
     else
       # Array with a 0 per line

data/lib/puppet/pops/parser/interpolation_support.rb

@@ -23,7 +23,7 @@ module Puppet::Pops::Parser::InterpolationSupport
     value,terminator = slurp_dqstring()
     text = value
     after = scn.pos
-    loop do
+    while true
       case terminator
       when '"'
         # simple case, there was no interpolation, return directly
@@ -63,7 +63,7 @@ module Puppet::Pops::Parser::InterpolationSupport
     value,terminator = slurp_dqstring
     text = value
     after = scn.pos
-    loop do
+    while true
       case terminator
       when '"'
         # simple case, there was no further interpolation, return directly
@@ -107,7 +107,7 @@ module Puppet::Pops::Parser::InterpolationSupport
     value,terminator = slurp_uqstring()
     text = value
     after = scn.pos
-    loop do
+    while true
       case terminator
       when ''
         # simple case, there was no interpolation, return directly
@@ -147,7 +147,7 @@ module Puppet::Pops::Parser::InterpolationSupport
     value,terminator = slurp_uqstring
     text = value
     after = scn.pos
-    loop do
+    while true
       case terminator
       when ''
         # simple case, there was no further interpolation, return directly

data/lib/puppet/pops/parser/locator.rb

@@ -90,7 +90,7 @@ class Locator
       f = Puppet::Util.path_to_uri(f).to_s
     end
     offset = ast.offset
-    URI("#{f}?line=#{line_for_offset(offset)}&pos=#{pos_on_line(offset)}")
+    URI("#{f}?line=#{line_for_offset(offset).to_s}&pos=#{pos_on_line(offset).to_s}")
   end
 
   class AbstractLocator < Locator

data/lib/puppet/pops/parser/pn_parser.rb

@@ -48,23 +48,6 @@ class PNParser
     parse_next
   end
 
-  def self.char_types
-    unless instance_variable_defined?(:@char_types)
-      @char_types = Array.new(0x80, TYPE_IDENTIFIER)
-      @char_types[0] = TYPE_END
-      [0x09, 0x0d, 0x0a, 0x20].each { |n| @char_types[n] = TYPE_WS }
-      [TOKEN_LP, TOKEN_RP, TOKEN_LB, TOKEN_RB, TOKEN_LC, TOKEN_RC].each { |n| @char_types[n] = TYPE_DELIM }
-      @char_types[0x2d] = TYPE_MINUS
-      (0x30..0x39).each { |n| @char_types[n] = TYPE_DIGIT }
-      (0x41..0x5a).each { |n| @char_types[n] = TYPE_ALPHA }
-      (0x61..0x7a).each { |n| @char_types[n] = TYPE_ALPHA }
-      @char_types[TOKEN_KEY] = TYPE_KEY_START
-      @char_types[TOKEN_STRING] = TYPE_STRING_START
-      @char_types.freeze
-    end
-    @char_types
-  end
-
   private
 
   def parse_next
@@ -145,6 +128,22 @@ class PNParser
   end
 
   # All methods below belong to the PN lexer
+  def self.char_types
+    unless instance_variable_defined?(:@char_types)
+      @char_types = Array.new(0x80, TYPE_IDENTIFIER)
+      @char_types[0] = TYPE_END
+      [0x09, 0x0d, 0x0a, 0x20].each { |n| @char_types[n] = TYPE_WS }
+      [TOKEN_LP, TOKEN_RP, TOKEN_LB, TOKEN_RB, TOKEN_LC, TOKEN_RC].each { |n| @char_types[n] = TYPE_DELIM }
+      @char_types[0x2d] = TYPE_MINUS
+      (0x30..0x39).each { |n| @char_types[n] = TYPE_DIGIT }
+      (0x41..0x5a).each { |n| @char_types[n] = TYPE_ALPHA }
+      (0x61..0x7a).each { |n| @char_types[n] = TYPE_ALPHA }
+      @char_types[TOKEN_KEY] = TYPE_KEY_START
+      @char_types[TOKEN_STRING] = TYPE_STRING_START
+      @char_types.freeze
+    end
+    @char_types
+  end
 
   def next_token
     skip_white

data/lib/puppet/pops/puppet_stack.rb

@@ -1,59 +1,57 @@
-module Puppet
-  module Pops
-    # Utility class for keeping track of the "Puppet stack", ie the file
-    # and line numbers of Puppet Code that created the current context.
-    #
-    # To use this make a call with:
-    #
-    # ```rb
-    # Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
-    # ```
-    #
-    # To get the stack call:
-    #
-    # ```rb
-    # Puppet::Pops::PuppetStack.stacktrace
-    # ```
-    #
-    # or
-    #
-    # ```rb
-    # Puppet::Pops::PuppetStack.top_of_stack
-    # ```
-    #
-    # To support testing, a given file that is an empty string, or nil
-    # as well as a nil line number are supported. Such stack frames
-    # will be represented with the text `unknown` and `0´ respectively.
-    module PuppetStack
-      @stack = Array.new
+module Puppet::Pops
+# Module for making a call such that there is an identifiable entry on
+# the ruby call stack enabling getting a puppet call stack
+# To use this make a call with:
+# ```
+# Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
+# ```
+# To get the stack call:
+# ```
+# Puppet::Pops::PuppetStack.stacktrace
+#
+# When getting a backtrace in Ruby, the puppet stack frames are
+# identified as coming from "in 'stack'" and having a ".pp" file
+# name.
+# To support testing, a given file that is an empty string, or nil
+# as well as a nil line number are supported. Such stack frames
+# will be represented with the text `unknown` and `0´ respectively.
+#
+module PuppetStack
+  # Pattern matching an entry in the ruby stack that is a puppet entry
+  PP_ENTRY_PATTERN = /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function'|`<eval>')/
 
-      def self.stack(file, line, obj, message, args, &block)
-        file = 'unknown' if (file.nil? || file == '')
-        line = 0 if line.nil?
+  # Sends a message to an obj such that it appears to come from
+  # file, line when calling stacktrace.
+  #
+  def self.stack(file, line, obj, message, args, &block)
+    file = '' if file.nil?
+    line = 0 if line.nil?
 
-        result = nil
-        @stack.unshift([file, line])
-        begin
-          if block_given?
-            result = obj.send(message, *args, &block)
-          else
-            result = obj.send(message, *args)
-          end
-        ensure
-          @stack.shift()
-        end
-        result
-      end
+    if block_given?
+      Kernel.eval("obj.send(message, *args, &block)", Kernel.binding(), file, line)
+    else
+      Kernel.eval("obj.send(message, *args)", Kernel.binding(), file, line)
+    end
+  end
 
-      def self.stacktrace
-        @stack.dup
+  def self.stacktrace
+    caller().reduce([]) do |memo, loc|
+      if loc =~ PP_ENTRY_PATTERN
+        memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
       end
+      memo
+    end
+  end
 
-      # Returns an Array with the top of the puppet stack, or an empty
-      # Array if there was no such entry.
-      def self.top_of_stack
-        @stack.first || []
+  # Returns an Array with the top of the puppet stack, or an empty Array if there was no such entry.
+  #
+  def self.top_of_stack
+    caller.each do |loc|
+      if loc =~ PP_ENTRY_PATTERN
+        return [$1.nil? ? 'unknown' : $1, $2.to_i]
       end
     end
+    []
   end
-end
+end
+end

data/lib/puppet/pops/types/p_sensitive_type.rb

@@ -22,7 +22,7 @@ class PSensitiveType < PTypeWithContainedType
     end
 
     def inspect
-      "#<#{self}>"
+      "#<#{to_s}>"
     end
   end
 

data/lib/puppet/pops/types/string_converter.rb

@@ -728,7 +728,7 @@ class StringConverter
     when :c
       char = [val].pack("U")
       char = f.alt? ? "\"#{char}\"" : char
-      Kernel.format(f.orig_fmt.tr('c','s'), char)
+      Kernel.format(f.orig_fmt.gsub('c','s'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -781,7 +781,7 @@ class StringConverter
 
     when :p
       # width & precision applied to string, not the the name of the type
-      "Binary(\"#{Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)}\")"
+      "Binary(\"#{Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)}\")"
 
     when :b
       Kernel.format(f.orig_fmt.gsub('b', substitute), val.relaxed_to_s)
@@ -817,23 +817,23 @@ class StringConverter
 
     when :c
       c_val = val.capitalize
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('c', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('c', 's'), c_val)
 
     when :C
       c_val = val.split('::').map {|s| s.capitalize }.join('::')
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('C', 's'), c_val)
 
     when :u
       c_val = val.upcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('u', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('u', 's'), c_val)
 
     when :d
       c_val = val.downcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('d', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('d', 's'), c_val)
 
     when :t  # trim
       c_val = val.strip
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('t', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('t', 's'), c_val)
 
     else
       raise FormatError.new('String', f.format, 'cCudspt')
@@ -921,7 +921,7 @@ class StringConverter
     case f.format
     when :p
       str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
-      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.tr('p', 's'), str_regexp)
+      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
     when :s
       str_regexp = PRegexpType.regexp_to_s(val)
       str_regexp = puppet_quote(str_regexp) if f.alt?
@@ -1098,10 +1098,10 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :s
-      str_val = f.alt? ? "\"#{val}\"" : val.to_s
+      str_val = f.alt? ? "\"#{val.to_s}\"" : val.to_s
       Kernel.format(f.orig_fmt, str_val)
     when :p
-      Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)
+      Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)
     else
       raise FormatError.new('Type', f.format, 'sp')
     end