puppet 5.4.0-universal-darwin → 5.5.0-universal-darwin

data/lib/puppet/parser/parser_factory.rb

@@ -16,7 +16,7 @@ module Puppet::Parser
     # EvaluatingParser to the 3x way of parsing.
     #
     def self.evaluating_parser
-      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+      unless defined?(Puppet::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
       end

data/lib/puppet/parser/resource.rb

@@ -332,7 +332,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
-      merge_tags(scope_resource)
+      merge_tags_from(scope_resource)
     end
   end
 

data/lib/puppet/parser/type_loader.rb

@@ -110,20 +110,20 @@ class Puppet::Parser::TypeLoader
     # There is currently one user in indirector/resourcetype/parser
     #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
-        begin
-          loaded_asts << parse_file(file)
-        rescue => e
-          # Resume from errors so that all parseable files may
-          # still be parsed. Mark this file as loaded so that
-          # it would not be parsed next time (handle it as if
-          # it was successfully parsed).
-          Puppet.debug("Unable to parse '#{file}': #{e.message}")
-        end
-      else
+      begin
         loaded_asts << parse_file(file)
+      rescue => e
+        # Resume from errors so that all parseable files may
+        # still be parsed. Mark this file as loaded so that
+        # it would not be parsed next time (handle it as if
+        # it was successfully parsed).
+        Puppet.debug("Unable to parse '#{file}': #{e.message}")
       end
+    else
+      loaded_asts << parse_file(file)
+    end
 
-      @loaded[file] = true
+    @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|

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

@@ -80,7 +80,7 @@ class Closure < CallableSignature
 
   def call_by_name_with_scope(scope, args_hash, enforce_parameters)
     call_by_name_internal(scope, args_hash, enforce_parameters)
-   end
+  end
 
   def call_by_name(args_hash, enforce_parameters)
     call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)

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

@@ -124,7 +124,7 @@ protected
     end
   end
 
- def query_AccessExpression(o, scope)
+  def query_AccessExpression(o, scope)
     pops_object = @@evaluator.evaluate(o, scope)
 
     # Convert to Puppet 3 style objects since that is how they are represented

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

@@ -53,8 +53,6 @@ class Puppet::Pops::Evaluator::EppEvaluator
     evaluate(parser, 'epp', scope, true, result, template_args)
   end
 
-  private
-
   def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
     template_args, template_args_set = handle_template_args(func_name, template_args)
 
@@ -104,6 +102,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
       parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
     end
   end
+  private_class_method :evaluate
 
   def self.handle_template_args(func_name, template_args)
     if template_args.nil?
@@ -117,4 +116,5 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [template_args, true]
     end
   end
+  private_class_method :handle_template_args
 end

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

@@ -89,8 +89,6 @@ module Runtime3ResourceSupport
     scope.environment.known_resource_types.find_hostclass(class_name)
   end
 
-  private
-
   def self.find_builtin_resource_type(scope, type_name)
     if type_name.include?(':')
       # Skip the search for built in types as they are always in global namespace
@@ -106,11 +104,13 @@ module Runtime3ResourceSupport
     # horrible - should be loaded by a "last loader" in 4.x loaders instead.
     Puppet::Type.type(type_name)
   end
+  private_class_method :find_builtin_resource_type
 
   def self.find_defined_resource_type(scope, type_name)
     krt = scope.environment.known_resource_types
     krt.find_definition(type_name) || krt.application(type_name)
   end
+  private_class_method :find_defined_resource_type
 
 end
 end

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

@@ -301,10 +301,13 @@ module Runtime3Support
   def call_function(name, args, o, scope, &block)
     file, line = extract_file_line(o)
     loader = Adapters::LoaderAdapter.loader_for_model_object(o, file)
-    if loader && func = loader.load(:function, name)
+    # '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)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
         # Add stack frame when calling. See Puppet::Pops::PuppetStack
-        return Kernel.eval('func.call(scope, *args, &block)', Kernel.binding, file || '', line)
+        return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
     # Call via 3x API if function exists there

data/lib/puppet/pops/functions/dispatch.rb

@@ -1,5 +1,5 @@
 module Puppet::Pops
-  module Functions
+module Functions
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #

data/lib/puppet/pops/issue_reporter.rb

@@ -86,6 +86,22 @@ class IssueReporter
     [prefix, message].join(' ')
   end
 
+  def self.warning(semantic, issue, args)
+    Puppet::Util::Log.create({
+      :level => :warning,
+      :message => issue.format(args),
+      :arguments => args,
+      :issue_code => issue.issue_code,
+      :file => semantic.file,
+      :line => semantic.line,
+      :pos => semantic.pos,
+    })
+  end
+
+  def self.error(exception_class, semantic, issue, args)
+    raise exception_class.new(issue.format(args), semantic.file, semantic.line, semantic.pos, nil, issue.issue_code, args)
+  end
+
   def self.create_exception(exception_class, emit_message, formatter, diagnostic)
     file = diagnostic.file
     file = (file.is_a?(String) && file.empty?) ? nil : file
@@ -94,7 +110,7 @@ class IssueReporter
       line = diagnostic.source_pos.line
       pos = diagnostic.source_pos.pos
     end
-    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code)
+    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code, diagnostic.arguments)
   end
   private_class_method :create_exception
 
@@ -109,6 +125,7 @@ class IssueReporter
     Puppet::Util::Log.create({
         :level => severity,
         :message => formatter.format_message(diagnostic),
+        :arguments => diagnostic.arguments,
         :issue_code => diagnostic.issue.issue_code,
         :file => file,
         :line => line,

data/lib/puppet/pops/issues.rb

@@ -49,7 +49,6 @@ module Issues
         # Evaluate the message block in the msg data's binding
         msgdata.format(hash, &message_block)
       rescue StandardError => e
-        MessageData
         raise RuntimeError, _("Error while reporting issue: %{code}. %{message}") % { code: issue_code, message: e.message }, caller
       end
     end
@@ -71,7 +70,7 @@ module Issues
 
     def format(hash, &block)
       @data = hash
-      instance_eval &block
+      instance_eval(&block)
     end
 
     # Obtains the label provider given as a key `:label` in the hash passed to #format. The label provider is
@@ -119,7 +118,7 @@ module Issues
   # @see MessageData
   # @api public
   #
-  def self.issue (issue_code, *args, &block)
+  def self.issue(issue_code, *args, &block)
     Issue.new(issue_code, *args, &block)
   end
 
@@ -741,6 +740,10 @@ module Issues
     _('Heredoc without any following lines of text')
   end
 
+  HEREDOC_EMPTY_ENDTAG = hard_issue :HEREDOC_EMPTY_ENDTAG do
+    _('Heredoc with an empty endtag')
+  end
+
   HEREDOC_MULTIPLE_AT_ESCAPES = hard_issue :HEREDOC_MULTIPLE_AT_ESCAPES, :escapes do
     _("An escape char for @() may only appear once. Got '%{escapes}'") % { escapes: escapes.join(', ') }
   end

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

@@ -29,12 +29,11 @@ class Puppet::Pops::Loader::RubyDataTypeInstantiator
     created
   end
 
-  private
-
   # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
   # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
   #
   def self.get_binding(loader_injected_arg)
     binding
   end
+  private_class_method :get_binding
 end

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

@@ -35,12 +35,11 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     created.new(nil, loader_for_function)
   end
 
-  private
-
   # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
   # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
   #
   def self.get_binding(loader_injected_arg)
     binding
   end
+  private_class_method :get_binding
 end

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

@@ -27,12 +27,12 @@ class TaskInstantiator
 
   def self.create_task(loader, name, task_source, metadata)
     if metadata.nil?
-      create_task_from_hash(loader, name, task_source, EMPTY_HASH)
+      create_task_from_hash(name, task_source, EMPTY_HASH)
     else
       json_text = loader.get_contents(metadata)
       begin
-        create_task_from_hash(loader, name, task_source, JSON.parse(json_text) || EMPTY_HASH)
-      rescue JSON::ParserError => ex
+        create_task_from_hash(name, task_source, Puppet::Util::Json.load(json_text) || EMPTY_HASH)
+      rescue Puppet::Util::Json::ParseError => ex
         raise Puppet::ParseError.new(ex.message, metadata)
       rescue Types::TypeAssertionError => ex
         # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
@@ -43,7 +43,7 @@ class TaskInstantiator
     end
   end
 
-  def self.create_task_from_hash(loader, name, task_source, hash)
+  def self.create_task_from_hash(name, task_source, hash)
     arguments = {
       'name' => name,
       'executable' => task_source
@@ -54,7 +54,7 @@ class TaskInstantiator
         value.each_pair do |k, v|
           pd = v.dup
           t = v['type']
-          pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t, loader)
+          pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
           ps[k] = pd
         end
         value = ps

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

@@ -73,7 +73,9 @@ class TypeDefinitionInstantiator
     case type_name
     when 'Object'
       # No need for an alias. The Object type itself will receive the name instead
-      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      unless type_expr.is_a?(Model::LiteralHash)
+        type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      end
       Types::PObjectType.new(name, type_expr)
     when 'TypeSet'
       # No need for an alias. The Object type itself will receive the name instead
@@ -86,6 +88,7 @@ class TypeDefinitionInstantiator
 
   # @api private
   def self.named_definition(te)
+    return 'Object' if te.is_a?(Model::LiteralHash)
     te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
   end
 

data/lib/puppet/pops/loaders.rb

@@ -15,7 +15,6 @@ class Loaders
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
-  attr_reader :implementation_registry
   attr_reader :environment
 
   def self.new(environment, for_agent = false)
@@ -55,12 +54,9 @@ class Loaders
       create_environment_loader(environment)
     end
 
-    # 3. The implementation registry maintains mappings between Puppet types and Runtime types for
-    #    the current environment
-    @implementation_registry = Types::ImplementationRegistry.new(@private_environment_loader)
-    Pcore.init(@puppet_system_loader, @implementation_registry, for_agent)
+    Pcore.init_env(@private_environment_loader)
 
-    # 4. module loaders are set up from the create_environment_loader, they register themselves
+    # 3. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Called after loader has been added to Puppet Context as :loaders so that dynamic types can
@@ -91,11 +87,21 @@ class Loaders
     loaders.find_loader(module_name)
   end
 
+  def self.static_implementation_registry
+    if !class_variable_defined?(:@@static_implementation_registry) || @@static_implementation_registry.nil?
+      ir = Types::ImplementationRegistry.new
+      Types::TypeParser.type_map.values.each { |t| ir.register_implementation(t.simple_name, t.class.name) }
+      @@static_implementation_registry = ir
+    end
+    @@static_implementation_registry
+  end
+
   def self.static_loader
     # The static loader can only be changed after a reboot
     if !class_variable_defined?(:@@static_loader) || @@static_loader.nil?
       @@static_loader = Loader::StaticLoader.new()
       @@static_loader.register_aliases
+      Pcore.init(@@static_loader, static_implementation_registry)
     end
     @@static_loader
   end
@@ -206,6 +212,11 @@ class Loaders
     end
   end
 
+  def implementation_registry
+    # Environment specific implementation registry
+    @implementation_registry ||= Types::ImplementationRegistry.new(self.class.static_implementation_registry)
+  end
+
   def static_loader
     self.class.static_loader
   end
@@ -337,7 +348,7 @@ class Loaders
     tf = Types::TypeParser.singleton
     lhs = tf.interpret(type_mapping.type_expr, loader)
     rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
-    implementation_registry.register_type_mapping(lhs, rhs, loader)
+    implementation_registry.register_type_mapping(lhs, rhs)
     nil
   end
 

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

@@ -1,3 +1,4 @@
+require 'hiera/scope'
 require_relative 'configured_data_provider'
 
 module Puppet::Pops
@@ -11,7 +12,6 @@ class GlobalDataProvider < ConfiguredDataProvider
   def unchecked_key_lookup(key, lookup_invocation, merge)
     config = config(lookup_invocation)
     if(config.version == 3)
-      require 'hiera/scope'
       # Hiera version 3 needs access to special scope variables
       scope = lookup_invocation.scope
       unless scope.is_a?(Hiera::Scope)

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

@@ -16,6 +16,8 @@ class LookupAdapter < DataAdapter
 
   HASH = 'hash'.freeze
   MERGE = 'merge'.freeze
+  CONVERT_TO = 'convert_to'.freeze
+  NEW = 'new'.freeze
 
   def self.create_adapter(compiler)
     new(compiler)
@@ -52,18 +54,65 @@ class LookupAdapter < DataAdapter
         catch(:no_such_key) { do_lookup(LookupKey::LOOKUP_OPTIONS, lookup_invocation, HASH) }
         nil
       else
+        lookup_options = lookup_lookup_options(key, lookup_invocation) || {}
+
         if merge.nil?
           # Used cached lookup_options
-          merge = lookup_merge_options(key, lookup_invocation)
+          # merge = lookup_merge_options(key, lookup_invocation)
+          merge = lookup_options[MERGE]
           lookup_invocation.report_merge_source(LOOKUP_OPTIONS) unless merge.nil?
         end
-        lookup_invocation.with(:data, key.to_s) do
-          catch(:no_such_key) { return do_lookup(key, lookup_invocation, merge) }
-          throw :no_such_key if lookup_invocation.global_only?
-          key.dig(lookup_invocation, lookup_default_in_module(key, lookup_invocation))
-        end
+        convert_result(key.to_s, lookup_options, lookup_invocation, lambda do
+          lookup_invocation.with(:data, key.to_s) do
+            catch(:no_such_key) { return do_lookup(key, lookup_invocation, merge) }
+            throw :no_such_key if lookup_invocation.global_only?
+            key.dig(lookup_invocation, lookup_default_in_module(key, lookup_invocation))
+          end
+        end)
+      end
+    end
+  end
+
+  # Performs a possible conversion of the result of calling `the_lookup` lambda
+  # The conversion takes place if there is a 'convert_to' key in the lookup_options
+  # If there is no conversion, the result of calling `the_lookup` is returned
+  # otherwise the successfully converted value.
+  # Errors are raised if the convert_to is faulty (bad type string, or if a call to
+  # new(T, <args>) fails.
+  #
+  # @param key [String] The key to lookup
+  # @param lookup_options [Hash] a hash of options
+  # @param lookup_invocation [Invocation] the lookup invocation
+  # @param the_lookup [Lambda] zero arg lambda that performs the lookup of a value
+  # @return [Object] the looked up value, or converted value if there was conversion
+  # @throw :no_such_key when the object is not found (if thrown by `the_lookup`)
+  #
+  def convert_result(key, lookup_options, lookup_invocation, the_lookup)
+    result = the_lookup.call
+    convert_to = lookup_options[CONVERT_TO]
+    return result if convert_to.nil?
+
+    convert_to = convert_to.is_a?(Array) ? convert_to : [convert_to]
+    if convert_to[0].is_a?(String)
+      begin
+        convert_to[0] = Puppet::Pops::Types::TypeParser.singleton.parse(convert_to[0])
+      rescue StandardError => e
+        raise Puppet::DataBinding::LookupError,
+          _("Invalid data type in lookup_options for key '%{key}' could not parse '%{source}', error: '%{msg}") %
+            { key: key, source: convert_to[0], msg: e.message}
       end
     end
+    begin
+      result = lookup_invocation.scope.call_function(NEW, [convert_to[0], result, *convert_to[1..-1]])
+      # TRANSLATORS 'lookup_options', 'convert_to' and args_string variable should not be translated,
+      args_string = Puppet::Pops::Types::StringConverter.singleton.convert(convert_to)
+      lookup_invocation.report_text { _("Applying convert_to lookup_option with arguments %{args}") % { args: args_string } }
+    rescue StandardError => e
+      raise Puppet::DataBinding::LookupError,
+        _("The convert_to lookup_option for key '%{key}' raised error: %{msg}") %
+          { key: key, msg: e.message}
+    end
+    result
   end
 
   def lookup_global(key, lookup_invocation, merge_strategy)