bolt 0.23.0 → 0.24.0

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

@@ -132,7 +132,7 @@ class HieraConfig
       if config_path.exist?
         env_context = EnvironmentContext.adapt(lookup_invocation.scope.compiler.environment)
         loaded_config = env_context.cached_file_data(config_path) do |content|
-          parsed = YAML.load(content, config_path)
+          parsed = Puppet::Util::Yaml.safe_load(content, [Symbol], config_path)
 
           # For backward compatibility, we must treat an empty file, or a yaml that doesn't
           # produce a Hash as Hiera version 3 default.

data/vendored/puppet/lib/puppet/pops/model/model_label_provider.rb

@@ -128,7 +128,10 @@ class ModelLabelProvider
       simple_name[1..-5] + "-Type"
     else
       n = o.name
-      n.nil? ? 'Anonymous Class' : n
+      if n.nil?
+        n = o.respond_to?(:_pcore_type) ? o._pcore_type.name : 'Anonymous Class'
+      end
+      n
     end
   end
 end

data/vendored/puppet/lib/puppet/pops/pcore.rb

@@ -39,39 +39,16 @@ module Pcore
             # Fully qualified name of the task
             name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
 
-            # List of implementations with requirements
-            implementations => { type => Array[Struct[name => String, path => String, Optional[requirements] => Array[String]], 1] },
-
-            # Task description
-            description => { type => Optional[String], value => undef },
-
-            # Puppet Task version
-            puppet_task_version => { type => Integer, value => 1 },
-
-            # Type, description, and sensitive property of each parameter
-            parameters => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
-
-             # Type, description, and sensitive property of each output
-            output => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
-
-            supports_noop => { type => Boolean, value => false },
-            input_method => { type => Optional[String] },
+            # List of file references referenced by metadata and their paths on disk.
+            # If there are no implementations listed in metadata, the first file is always
+            # the task executable.
+            files => { type => Array[Struct[name => String, path => String]] },
+
+            # Task metadata
+            metadata => { type => Hash[String, Any] },
+
+            # Map parameter names to their parsed data type
+            parameters => { type => Optional[Hash[Pattern[/\\A[a-z][a-z0-9_]*\\z/], Type]], value => undef },
           }
         }
       PUPPET

data/vendored/puppet/lib/puppet/pops/serialization.rb

@@ -19,6 +19,7 @@ module Serialization
 
   # Type key used for symbols
   PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
+  PCORE_TYPE_BINARY = 'Binary'.freeze
 
   # Type key used for symbols
   PCORE_TYPE_SYMBOL = 'Symbol'.freeze
@@ -34,6 +35,7 @@ end
 require_relative 'serialization/json_path'
 require_relative 'serialization/from_data_converter'
 require_relative 'serialization/to_data_converter'
+require_relative 'serialization/to_stringified_converter'
 require_relative 'serialization/serializer'
 require_relative 'serialization/deserializer'
 require_relative 'serialization/json'

data/vendored/puppet/lib/puppet/pops/serialization/from_data_converter.rb

@@ -135,6 +135,7 @@ module Serialization
             end
             hash
           else
+            # not a string
             pcore_type_hash_to_value(type, value)
           end
         end
@@ -150,7 +151,7 @@ module Serialization
     def convert(value)
       if value.is_a?(Hash)
         pcore_type = value[PCORE_TYPE_KEY]
-        if pcore_type
+        if pcore_type && (pcore_type.is_a?(String) || pcore_type.is_a?(Hash))
           @pcore_type_procs[pcore_type].call(value, pcore_type)
         else
           build({}) { value.each_pair { |key, elem| with(key) { convert(elem) }}}

data/vendored/puppet/lib/puppet/pops/serialization/to_data_converter.rb

@@ -11,10 +11,10 @@ module Serialization
     # @param value [Object] the value to convert
     # @param options {Symbol => <Boolean,String>} options hash
     # @option options [Boolean] :rich_data `true` if rich data is enabled
-    # @option options [Boolean] :local_references use local references instead of duplicating complex entries
+    # @option options [Boolean] :local_reference use local references instead of duplicating complex entries
     # @option options [Boolean] :type_by_reference `true` if Object types are converted to references rather than embedded.
     # @option options [Boolean] :symbol_as_string `true` if Symbols should be converted to strings (with type loss)
-    # @option options [String] :path_prefix String to prepend to path in warnings and errors
+    # @option options [String] :message_prefix String to prepend to in warnings and errors
     # @return [Data] the processed result. An object assignable to `Data`.
     #
     # @api public
@@ -70,7 +70,15 @@ module Serialization
 
     def to_data(value)
       if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
-        value
+        if @rich_data && value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT
+          # Transform the binary string to rich Binary
+          {
+            PCORE_TYPE_KEY => PCORE_TYPE_BINARY,
+            PCORE_VALUE_KEY => Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
+          }
+        else
+          value
+        end
       elsif :default == value
         if @rich_data
           { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }

data/vendored/puppet/lib/puppet/pops/serialization/to_stringified_converter.rb

@@ -0,0 +1,226 @@
+module Puppet::Pops
+module Serialization
+
+  # Class that can process an arbitrary object into a value that is assignable to `Data`
+  # and where contents is converted from rich data to one of:
+  # * Numeric (Integer, Float)
+  # * Boolean 
+  # * Undef (nil)
+  # * String
+  # * Array
+  # * Hash
+  # 
+  # The conversion is lossy - the result cannot be deserialized to produce the original data types.
+  # All rich values are transformed to strings..
+  # Hashes with rich keys are transformed to use string representation of such keys.
+  #
+  # @api public
+  class ToStringifiedConverter
+    include Evaluator::Runtime3Support
+
+    # Converts the given _value_ according to the given _options_ and return the result of the conversion
+    #
+    # @param value [Object] the value to convert
+    # @param options {Symbol => <Boolean,String>} options hash
+    # @option options [String] :message_prefix String to prepend to in warnings and errors
+    # @option options [String] :semantic object (AST) to pass to the issue reporter
+    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
+    #
+    # @api public
+    def self.convert(value, options = EMPTY_HASH)
+      new(options).convert(value)
+    end
+
+    # Creates a new instance of the processor
+    #
+    # @param options {Symbol => Object} options hash
+    # @option options [String] :message_prefix String to prepend to path in warnings and errors
+    # @option semantic [Object] :semantic object to pass to the issue reporter
+    def initialize(options = EMPTY_HASH)
+      @message_prefix = options[:message_prefix]
+      @semantic = options[:semantic]
+    end
+
+    # Converts the given _value_
+    #
+    # @param value [Object] the value to convert
+    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
+    #
+    # @api public
+    def convert(value)
+      @path = []
+      @values = {}
+      to_data(value)
+    end
+
+    private
+
+    def path_to_s
+      s = @message_prefix || ''
+      s << JsonPath.to_json_path(@path)[1..-1]
+      s
+    end
+
+    def to_data(value)
+      if value.is_a?(String)
+        to_string_or_binary(value)
+      elsif value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
+        value
+      elsif :default == value
+        'default'
+      elsif value.is_a?(Symbol)
+        value.to_s
+      elsif value.instance_of?(Array)
+        process(value) do
+          result = []
+          value.each_with_index do |elem, index|
+            with(index) { result << to_data(elem) }
+          end
+          result
+        end
+      elsif value.instance_of?(Hash)
+        process(value) do
+          if value.keys.all? { |key| key.is_a?(String) && key != PCORE_TYPE_KEY && key != PCORE_VALUE_KEY }
+            result = {}
+            value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
+            result
+          else
+            non_string_keyed_hash_to_data(value)
+          end
+        end
+      else
+        unknown_to_string(value)
+      end
+    end
+
+    # Turns an ASCII-8BIT encoded string into a Binary, returns US_ASCII encoded and transforms all other strings to UTF-8
+    # with replacements for non Unicode characters.
+    # If String cannot be represented as UTF-8
+    def to_string_or_binary(value)
+      encoding = value.encoding
+      if encoding == Encoding::ASCII_8BIT
+        Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
+      else
+        # Transform to UTF-8 (do not assume UTF-8 is correct) with source invalid byte
+        # sequences and UTF-8 undefined characters replaced by the default unicode uFFFD character
+        # (black diamond with question mark).
+        value.encode(Encoding::UTF_8, encoding, :invalid => :replace, :undef => :replace)
+      end
+    end
+
+    # Performs a check for endless recursion before
+    # it yields to the given block. The result of yielding is returned.
+    #
+    # @param value [Object] the value
+    # @yield The block that will produce the data for the value
+    # @return [Data] the result of yielding to the given block, or a hash denoting a reference
+    #
+    # @api private
+    def process(value, &block)
+      with_recursive_guard(value, &block)
+    end
+
+    # Pushes `key` to the end of the path and yields to the given block. The
+    # `key` is popped when the yield returns.
+    # @param key [Object] the key to push on the current path
+    # @yield The block that will produce the returned value
+    # @return [Object] the result of yielding to the given block
+    #
+    # @api private
+    def with(key)
+      @path.push(key)
+      value = yield
+      @path.pop
+      value
+    end
+
+    # @param value [Object] the value to use when checking endless recursion
+    # @yield The block that will produce the data
+    # @return [Data] the result of yielding to the given block
+    def with_recursive_guard(value)
+      id = value.object_id
+      if @recursive_lock
+        if @recursive_lock.include?(id)
+          serialization_issue(Issues::SERIALIZATION_ENDLESS_RECURSION, :type_name => value.class.name)
+        end
+        @recursive_lock[id] = true
+      else
+        @recursive_lock = { id => true }
+      end
+      v = yield
+      @recursive_lock.delete(id)
+      v
+    end
+
+    # A hash key that is non conforming
+    def unknown_key_to_string(value)
+      unknown_to_string(value)
+    end
+
+    def unknown_to_string(value)
+      if value.is_a?(Regexp)
+        return Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value)
+
+      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
+        # to_s does not differentiate between instances - if they were used as keys in a hash
+        # the stringified result would override all Sensitive keys with the last such key's value
+        # this adds object_id.
+        #
+        return "#<#{value}:#{value.object_id}>"
+
+      elsif value.is_a?(Puppet::Pops::Types::PObjectType)
+        # regular to_s on an ObjectType gives the entire definition
+        return value.name
+
+      end
+
+      # Do a to_s on anything else
+      result = value.to_s
+
+      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
+      # This can be the case if runtime objects have very simple implementation (no to_s or inspect method).
+      # They are most likely not of Binary nature. Therefore the encoding is forced and only if it errors
+      # will the result be taken as binary and encoded as base64 string.
+      if result.encoding == Encoding::ASCII_8BIT
+        begin
+          result.force_encoding(Encoding::UTF_8)
+        rescue
+          # The result cannot be represented in UTF-8, make it a binary Base64 encoded string
+          Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(result).to_s
+        end
+      end
+      result
+    end
+
+    def non_string_keyed_hash_to_data(hash)
+      result = {}
+      hash.each_pair do |key, value|
+        if key.is_a?(Symbol)
+          key = key.to_s
+        elsif !key.is_a?(String)
+          key = unknown_key_to_string(key)
+        end
+        if key == "__ptype" || key =="__pvalue"
+          key = "reserved key: #{key}"
+        end
+        with(key) { result[key] = to_data(value) }
+      end
+      result
+    end
+
+    def serialization_issue(issue, options = EMPTY_HASH)
+      semantic = @semantic
+      if semantic.nil?
+        tos = Puppet::Pops::PuppetStack.top_of_stack
+        if tos.empty?
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
+        else
+          file, line = stacktrace
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
+        end
+      end
+      optionally_fail(issue,  semantic, options)
+    end
+  end
+end
+end

data/vendored/puppet/lib/puppet/pops/types/p_object_type.rb

@@ -284,6 +284,9 @@ class PObjectType < PMetaType
     # @api public
     def initialize(name, container, init_hash)
       super(name, container, TypeAsserter.assert_instance_of(nil, TYPE_ATTRIBUTE, init_hash) { "initializer for #{self.class.label(container, name)}" })
+      if name == Serialization::PCORE_TYPE_KEY || name == Serialization::PCORE_VALUE_KEY
+        raise Puppet::ParseError, _("The attribute '%{name}' is reserved and cannot be used") % { name: name}
+      end
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final

data/vendored/puppet/lib/puppet/pops/validation/checker4_0.rb

@@ -35,7 +35,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
     @check_visitor = self.class.check_visitor
     @acceptor = diagnostics_producer
-    @file_to_namespace = {}
 
     # Use null migration checker unless given in context
     @migration_checker = (Puppet.lookup(:migration_checker) { Migration::MigrationChecker.new() })
@@ -49,6 +48,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # tree iterate the model, and call check for each element
     @path = []
     check(model)
+    internal_check_top_construct_in_module(model)
     model._pcore_all_contents(@path) { |element| check(element) }
   end
 
@@ -397,7 +397,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
 
-    internal_check_file_namespace(o, o.name, o.locator.file)
+    internal_check_file_namespace(o)
     internal_check_reserved_type_name(o, o.name)
     internal_check_future_reserved_word(o, o.name)
   end
@@ -533,75 +533,125 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
-  def internal_check_file_namespace(o, name, file)
-    return if file.nil?
+  NO_NAMESPACE = :no_namespace
+  NO_PATH = :no_path
+  BAD_MODULE_FILE = :bad_module_file
+
+  def internal_check_file_namespace(o)
+    file = o.locator.file
+    return if file.nil? || file == '' #e.g. puppet apply -e '...'
 
-    lc_file = file.downcase
+    file_namespace = namespace_for_file(file)
+    return if file_namespace == NO_NAMESPACE
 
-    file_namespace = @file_to_namespace[lc_file]
-    if file_namespace.nil?
-      return if @file_to_namespace.key?(lc_file)
-      file_namespace = @file_to_namespace[lc_file] = namespace_for_file(lc_file)
-      return if file_namespace.nil?
+    # Downcasing here because check is case-insensitive
+    if file_namespace == BAD_MODULE_FILE || !o.name.downcase.start_with?(file_namespace)
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, {:name => o.name, :file => file})
     end
+  end
+
+  def internal_check_top_construct_in_module(prog)
+    return unless prog.is_a?(Model::Program) && !prog.body.nil?
+
+    #Check that this is a module autoloaded file
+    file = prog.locator.file
+    return if file.nil?
+    return if namespace_for_file(file) == NO_NAMESPACE
 
-    if !name.downcase.start_with?(file_namespace)
-      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, {:name => name, :file => file})
+    body = prog.body
+    if(body.is_a?(Model::BlockExpression))
+      body.statements.each { |s| acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, s) unless valid_top_construct?(s) }
+    else
+      acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, body) unless valid_top_construct?(body)
     end
   end
 
-  NEVER_MATCH = '\b'.freeze
+  def valid_top_construct?(o)
+    o.is_a?(Model::Definition) && !o.is_a?(Model::NodeDefinition)
+  end
+
+  # @api private
+  class Puppet::Util::FileNamespaceAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :file_to_namespace
+  end
 
   def namespace_for_file(file)
-    path = Pathname.new(file)
+    env = Puppet.lookup(:current_environment)
+    return NO_NAMESPACE if env.nil?
 
-    return nil if path.extname != ".pp"
+    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
+      adapter.file_to_namespace ||= {}
 
-    return nil if initial_manifest?(path)
+      file_namespace = adapter.file_to_namespace[file]
+      return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
 
-    path = path.each_filename.to_a
+      path = Pathname.new(file)
 
-    # Example definition dir: manifests in this path:
-    # <modules dir>/<module name>/manifests/<module subdir>/<classfile>.pp
-    definition_dir_index = find_module_definition_dir(path)
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
 
-    # How can we get this result?
-    # If it is not an initial manifest, it must come from a module,
-    # and from the manifests dir there.  This may never get used...
-    return NEVER_MATCH if definition_dir_index.nil? || definition_dir_index == 0
+      path = path.expand_path
 
-    before_definition_dir = definition_dir_index - 1
-    after_definition_dir = definition_dir_index + 1
-    names = path[after_definition_dir .. -2] # Directories inside module
-    names.unshift(path[before_definition_dir]) # Name of the module itself
-    # Do not include name of module init file at top level of module
-    filename = path[-1]
-    if !(path.length == (after_definition_dir+1) && filename == 'init.pp')
-      names.push(filename[0 .. -4]) # Remove .pp from filename
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
+
+      #All auto-loaded files from modules come from a module search path dir
+      relative_path = get_module_relative_path(path, env.full_modulepath)
+
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
+
+      #If a file comes from a module, but isn't in the right place, always error
+      names = dir_to_names(relative_path)
+
+      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
     end
+  end
+
+  def initial_manifest?(path, manifest_setting)
+    return false if manifest_setting.nil? || manifest_setting == :no_manifest
 
-    names.join("::").freeze
+    string_path = path.to_s
+
+    string_path == manifest_setting || string_path.start_with?(manifest_setting)
   end
 
-  def initial_manifest?(path)
-    manifest_setting = Puppet[:manifest]
+  def get_module_relative_path(file_path, modulepath_directories)
+    clean_file = file_path.cleanpath
+    parent_path = modulepath_directories.find { |path_dir| is_parent_dir_of(path_dir, clean_file) }
+    return NO_PATH if parent_path.nil?
 
-    # Does this ever happen outside of tests?
-    if manifest_setting.nil?
-      return path.basename.to_s == 'site.pp'
-    end
+    file_path.relative_path_from(Pathname.new(parent_path))
+  end
+
+  def is_parent_dir_of(parent_dir, child_dir)
+    parent_dir_path = Pathname.new(parent_dir)
+    clean_parent = parent_dir_path.cleanpath
 
-    full_path = path.expand_path.to_s
-    full_path == manifest_setting || full_path.start_with?(manifest_setting)
+    return child_dir.to_s.start_with?(clean_parent.to_s)
   end
 
-  # Returns module root directory index in path for files under 'manifests',
-  # 'functions', 'types' and 'plans'
-  def find_module_definition_dir(path)
-    reverse_index = path.reverse_each.find_index do |dir|
-      dir == 'manifests' || dir == 'functions' || dir == 'types' || dir == 'plans'
+  def dir_to_names(relative_path)
+    # Downcasing here because check is case-insensitive
+    path_components = relative_path.to_s.downcase.split(File::SEPARATOR)
+
+    # Example definition dir: manifests in this path:
+    # <module name>/manifests/<module subdir>/<classfile>.pp
+    dir = path_components[1]
+
+    # How can we get this result?
+    # If it is not an initial manifest, it must come from a module,
+    # and from the manifests dir there.  This may never get used...
+    return BAD_MODULE_FILE unless dir == 'manifests' || dir == 'functions' || dir == 'types' || dir == 'plans'
+
+    names = path_components[2 .. -2] # Directories inside module
+    names.unshift(path_components[0]) # Name of the module itself
+
+    # Do not include name of module init file at top level of module
+    # e.g. <module name>/manifests/init.pp
+    filename = path_components[-1]
+    if !(path_components.length == 3 && filename == 'init.pp')
+      names.push(filename[0 .. -4]) # Remove .pp from filename
     end
-    return reverse_index.nil? ? nil : (path.length - 1) - reverse_index
+
+    names
   end
 
   RESERVED_PARAMETERS = {