puppet 8.4.0 → 8.5.1

data/lib/puppet/pal/compiler.rb

@@ -25,8 +25,8 @@ module Pal
     #
     def call_function(function_name, *args, &block)
       # TRANSLATORS: do not translate variable name strings in these assertions
-      Pal::assert_non_empty_string(function_name, 'function_name', false)
-      Pal::assert_type(Pal::T_ANY_ARRAY, args, 'args', false)
+      Pal.assert_non_empty_string(function_name, 'function_name', false)
+      Pal.assert_type(Pal::T_ANY_ARRAY, args, 'args', false)
       internal_evaluator.evaluator.external_call_function(function_name, args, topscope, &block)
     end
 
@@ -193,7 +193,7 @@ module Pal
     def create(data_type, *arguments)
       t = data_type.is_a?(String) ? type(data_type) : data_type
       unless t.is_a?(Puppet::Pops::Types::PAnyType)
-        raise ArgumentError, _("Given data_type value is not a data type, got '%{type}'") % {type: t.class}
+        raise ArgumentError, _("Given data_type value is not a data type, got '%{type}'") % { type: t.class }
       end
 
       call_function('new', t, *arguments)
@@ -213,7 +213,7 @@ module Pal
       if filter_regex.nil?
         loader.discover(kind, error_collector)
       else
-        loader.discover(kind, error_collector) {|f| f.name =~ filter_regex }
+        loader.discover(kind, error_collector) { |f| f.name =~ filter_regex }
       end
     end
 

data/lib/puppet/pal/function_signature.rb

@@ -27,11 +27,11 @@ module Pal
     # @return [Boolean] true if the function can be called with given args + block, and false otherwise
     # @api public
     #
-    def callable_with?(args, callable=nil)
+    def callable_with?(args, callable = nil)
       signatures = @func.dispatcher.to_type
       callables = signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
 
-      return true if callables.any? {|t| t.callable_with?(args) }
+      return true if callables.any? { |t| t.callable_with?(args) }
       return false unless block_given?
 
       args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(callable.nil? ? args : args + [callable])

data/lib/puppet/pal/pal_impl.rb

@@ -58,12 +58,12 @@ module Pal
   #
   def self.with_script_compiler(
     configured_by_env: false,
-      manifest_file:     nil,
-      code_string:       nil,
-      facts:             {},
-      variables:         {},
-      set_local_facts:   true,
-      &block
+    manifest_file:     nil,
+    code_string:       nil,
+    facts:             {},
+    variables:         {},
+    set_local_facts:   true,
+    &block
   )
     # TRANSLATORS: do not translate variable name strings in these assertions
     assert_mutually_exclusive(manifest_file, code_string, 'manifest_file', 'code_string')
@@ -79,13 +79,11 @@ module Pal
 
       # Use the manifest setting
       manifest_file = Puppet[:manifest]
-    else
+    elsif manifest_file.nil? && code_string.nil?
       # An "undef" code_string is the only way to override Puppet[:manifest] & Puppet[:code] settings since an
       # empty string is taken as Puppet[:code] not being set.
       #
-      if manifest_file.nil? && code_string.nil?
-        code_string = 'undef'
-      end
+      code_string = 'undef'
     end
 
     previous_tasks_value = Puppet[:tasks]
@@ -165,12 +163,12 @@ module Pal
   #
   def self.with_catalog_compiler(
     configured_by_env: false,
-      manifest_file:     nil,
-      code_string:       nil,
-      facts:             {},
-      variables:         {},
-      target_variables:  {},
-      &block
+    manifest_file:     nil,
+    code_string:       nil,
+    facts:             {},
+    variables:         {},
+    target_variables:  {},
+    &block
   )
     # TRANSLATORS: do not translate variable name strings in these assertions
     assert_mutually_exclusive(manifest_file, code_string, 'manifest_file', 'code_string')
@@ -186,13 +184,11 @@ module Pal
 
       # Use the manifest setting
       manifest_file = Puppet[:manifest]
-    else
+    elsif manifest_file.nil? && code_string.nil?
       # An "undef" code_string is the only way to override Puppet[:manifest] & Puppet[:code] settings since an
       # empty string is taken as Puppet[:code] not being set.
       #
-      if manifest_file.nil? && code_string.nil?
-        code_string = 'undef'
-      end
+      code_string = 'undef'
     end
 
     # We need to make sure to set these back when we're done
@@ -232,12 +228,11 @@ module Pal
   # @yieldparam [Puppet::Pal] context, a context that responds to Puppet::Pal methods
   #
   def self.in_tmp_environment(env_name,
-      modulepath:    [],
-      settings_hash: {},
-      facts:         nil,
-      variables:     {},
-      &block
-  )
+                              modulepath:    [],
+                              settings_hash: {},
+                              facts:         nil,
+                              variables:     {},
+                              &block)
     assert_non_empty_string(env_name, _("temporary environment name"))
     # TRANSLATORS: do not translate variable name string in these assertions
     assert_optionally_empty_array(modulepath, 'modulepath')
@@ -280,16 +275,15 @@ module Pal
   #
   # @api public
   def self.in_environment(env_name,
-      modulepath: nil,
-      pre_modulepath: [],
-      post_modulepath: [],
-      settings_hash: {},
-      env_dir:       nil,
-      envpath:       nil,
-      facts:         nil,
-      variables:     {},
-      &block
-  )
+                          modulepath: nil,
+                          pre_modulepath: [],
+                          post_modulepath: [],
+                          settings_hash: {},
+                          env_dir:       nil,
+                          envpath:       nil,
+                          facts:         nil,
+                          variables:     {},
+                          &block)
     # TRANSLATORS terms in the assertions below are names of terms in code
     assert_non_empty_string(env_name, 'env_name')
     assert_optionally_empty_array(modulepath, 'modulepath', true)
@@ -385,7 +379,7 @@ module Pal
     end
 
     rich_data_t = Puppet::Pops::Types::TypeFactory.rich_data
-    variables.each_pair do |k,v|
+    variables.each_pair do |k, v|
       unless k =~ Puppet::Pops::Patterns::VAR_NAME
         raise ArgumentError, _("Given variable '%{varname}' has illegal name") % { varname: k }
       end
@@ -448,7 +442,7 @@ module Pal
     node.environment = apply_environment
 
     # TRANSLATORS, the string "For puppet PAL" is not user facing
-    Puppet.override({:current_environment => apply_environment}, "For puppet PAL") do
+    Puppet.override({ :current_environment => apply_environment }, "For puppet PAL") do
       begin
         node.sanitize()
         compiler = create_internal_compiler(internal_compiler_class, node)
@@ -482,7 +476,7 @@ module Pal
         # TODO: The compiler instances should be available under non PAL use as well!
         # TRANSLATORS: Do not translate, symbolic name
         Puppet.override(overrides, "PAL::with_#{internal_compiler_class}_compiler") do
-          compiler.compile do | _compiler_yield |
+          compiler.compile do |_compiler_yield|
             # In case the variables passed to the compiler are PCore types defined in modules, they
             # need to be deserialized and added from within the this scope, so that loaders are
             # available during deserizlization.
@@ -560,17 +554,18 @@ module Pal
   T_BOOLEAN = Puppet::Pops::Types::PBooleanType::DEFAULT
 
   T_GENERIC_TASK_HASH = Puppet::Pops::Types::TypeFactory.hash_kv(
-    Puppet::Pops::Types::TypeFactory.pattern(/\A[a-z][a-z0-9_]*\z/), Puppet::Pops::Types::TypeFactory.data)
+    Puppet::Pops::Types::TypeFactory.pattern(/\A[a-z][a-z0-9_]*\z/), Puppet::Pops::Types::TypeFactory.data
+  )
 
-  def self.assert_type(type, value, what, allow_nil=false)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(nil, type, value, allow_nil) { _('Puppet Pal: %{what}') % {what: what} }
+  def self.assert_type(type, value, what, allow_nil = false)
+    Puppet::Pops::Types::TypeAsserter.assert_instance_of(nil, type, value, allow_nil) { _('Puppet Pal: %{what}') % { what: what } }
   end
 
-  def self.assert_non_empty_string(s, what, allow_nil=false)
+  def self.assert_non_empty_string(s, what, allow_nil = false)
     assert_type(T_STRING, s, what, allow_nil)
   end
 
-  def self.assert_optionally_empty_array(a, what, allow_nil=false)
+  def self.assert_optionally_empty_array(a, what, allow_nil = false)
     assert_type(T_STRING_ARRAY, a, what, allow_nil)
   end
   private_class_method :assert_optionally_empty_array

data/lib/puppet/pal/plan_signature.rb

@@ -51,7 +51,7 @@ module Pal
       return true if errors.empty?
 
       if block_given?
-        yield errors.map {|e| e.format }.join("\n")
+        yield errors.map { |e| e.format }.join("\n")
       end
       false
     end

data/lib/puppet/pal/task_signature.rb

@@ -31,13 +31,13 @@ module Pal
       if block_given?
         tm = Puppet::Pops::Types::TypeMismatchDescriber.singleton
         error = if params.nil?
-                  tm.describe_mismatch('', params_type, 
+                  tm.describe_mismatch('', params_type,
                                        Puppet::Pops::Types::TypeCalculator
                                          .infer_set(args_hash))
                 else
                   tm.describe_struct_signature(params_type, args_hash)
                     .flatten
-                    .map {|e| e.format }
+                    .map { |e| e.format }
                     .join("\n")
                 end
         yield "Task #{@task.name}:\n#{error}"

data/lib/puppet/parameter/path.rb

@@ -26,11 +26,11 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # @return [Array<String>] the given paths
   #
   def validate_path(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
+    if paths.is_a?(Array) and !self.class.arrays? then
       fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
     end
 
-    fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? {|path| absolute_path?(path)}
+    fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? { |path| absolute_path?(path) }
 
     paths
   end
@@ -52,7 +52,7 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # @return [String, Array<String>] the given paths
   # @raise [Puppet::Error] if the given paths does not comply with the on/many paths rule.
   def unsafe_munge(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
+    if paths.is_a?(Array) and !self.class.arrays? then
       fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
     end
 

data/lib/puppet/parameter/value.rb

@@ -78,7 +78,7 @@ class Puppet::Parameter::Value
   #
   def convert(value)
     case value
-    when Symbol, ''             # can't intern an empty string
+    when Symbol, '' # can't intern an empty string
       value
     when String
       value.intern

data/lib/puppet/parameter/value_collection.rb

@@ -36,7 +36,7 @@ class Puppet::Parameter::ValueCollection
         @doc << "Valid values are "
         @doc << @strings.collect do |value|
           aliases = value.aliases
-          if aliases && ! aliases.empty?
+          if aliases && !aliases.empty?
             "`#{value.name}` (also called `#{aliases.join(", ")}`)"
           else
             "`#{value.name}`"
@@ -138,7 +138,7 @@ class Puppet::Parameter::ValueCollection
       message = _("Property option :call is deprecated and no longer used.")
       message += ' ' + _("Please remove it.")
       Puppet.deprecation_warning(message)
-      options = options.reject { |k,_v| k == :call }
+      options = options.reject { |k, _v| k == :call }
     end
 
     value = Puppet::Parameter::Value.new(name)
@@ -154,8 +154,8 @@ class Puppet::Parameter::ValueCollection
       devfail "Cannot use :call value ':none' in combination with a block for property '#{self.class.name}'" if call_opt == :none
       value.block = block
       value.method ||= "set_#{value.name}" if !value.regex?
-    else
-      devfail "Cannot use :call value ':instead' without a block for property '#{self.class.name}'" if call_opt == :instead
+    elsif call_opt == :instead
+      devfail "Cannot use :call value ':instead' without a block for property '#{self.class.name}'"
     end
     value
   end
@@ -184,7 +184,7 @@ class Puppet::Parameter::ValueCollection
   def validate(value)
     return if empty?
 
-    unless @values.detect {|_name, v| v.match?(value)}
+    unless @values.detect { |_name, v| v.match?(value) }
       str = _("Invalid value %{value}.") % { value: value.inspect }
       str += " " + _("Valid values are %{value_list}.") % { value_list: values.join(", ") } unless values.empty?
       str += " " + _("Valid values match %{pattern}.") % { pattern: regexes.join(", ") } unless regexes.empty?

data/lib/puppet/parameter.rb

@@ -72,7 +72,7 @@ class Puppet::Parameter
     # @overload defaultto(value)
     #   Defines the default value with a literal value
     #   @param value [Object] the literal value to use as the default value
-    # @overload defaultto({|| ... })
+    # @overload defaultto({ ... })
     #   Defines that the default value is produced by the given block. The given block
     #   should produce the default value.
     # @raise [Puppet::DevError] if value is nil, and no block is given.
@@ -164,7 +164,7 @@ class Puppet::Parameter
       @value_collection = ValueCollection.new
     end
 
-    # @overload munge {|| ... }
+    # @overload munge { ... }
     # Defines an optional method used to convert the parameter value from DSL/string form to an internal form.
     # If a munge method is not defined, the DSL/string value is used as is.
     # @note This adds a method with the name `unsafe_munge` in the created parameter class. Later this method is
@@ -180,7 +180,7 @@ class Puppet::Parameter
       define_method(:unsafe_munge, &block)
     end
 
-    # @overload unmunge {|| ... }
+    # @overload unmunge { ... }
     # Defines an optional method used to convert the parameter value from internal form to DSL/string form.
     # If an `unmunge` method is not defined, the internal form is used.
     # @see munge
@@ -240,7 +240,7 @@ class Puppet::Parameter
       @required
     end
 
-    # @overload validate {|| ... }
+    # @overload validate { ... }
     # Defines an optional method that is used to validate the parameter's DSL/string value.
     # Validation should raise appropriate exceptions, the return value of the given block is ignored.
     # The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with

data/lib/puppet/parser/abstract_compiler.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Puppet::Parser::AbstractCompiler
-  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an 
+  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an
   # error if the specific compiler does not support catalog operations.
   #
   def catalog

data/lib/puppet/parser/ast/hostclass.rb

@@ -23,7 +23,7 @@ class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
     return all_types
   end
 
-  def code()
+  def code
     @context[:code]
   end
 end

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -129,7 +129,7 @@ class Puppet::Parser::AST::PopsBridge
       when Puppet::Pops::Model::Program
         is_definition?(o.body)
       when Puppet::Pops::Model::BlockExpression
-        o.statements.all {|s| is_definition?(s) }
+        o.statements.all { |s| is_definition?(s) }
       when Puppet::Pops::Model::Definition
         true
       else
@@ -152,7 +152,7 @@ class Puppet::Parser::AST::PopsBridge
       return result unless definition.parameters.size > 0
 
       # No need to do anything if there are no typed parameters
-      typed_parameters = definition.parameters.select {|p| p.type_expr }
+      typed_parameters = definition.parameters.select { |p| p.type_expr }
       return result if typed_parameters.empty?
 
       # If there are typed parameters, they need to be evaluated to produce the corresponding type
@@ -178,7 +178,7 @@ class Puppet::Parser::AST::PopsBridge
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug {_("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")}
+        Puppet.debug { _("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.") }
         nil
       end
       scope
@@ -187,7 +187,7 @@ class Puppet::Parser::AST::PopsBridge
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname, expr_class = Expression)
       args = {
-        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
+        :arguments => o.parameters.collect { |p| instantiate_Parameter(p) },
         :argument_types => create_type_map(o),
         :module_name => modname
       }
@@ -227,7 +227,7 @@ class Puppet::Parser::AST::PopsBridge
       end
     end
 
-    def code()
+    def code
       Expression.new(:value => @value)
     end
 

data/lib/puppet/parser/ast/resource.rb

@@ -61,6 +61,6 @@ class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
           resource
         end
       end
-    end.flatten.reject { |resource| resource.nil? }
+    end.flatten.compact
   end
 end

data/lib/puppet/parser/ast/resourceparam.rb

@@ -20,7 +20,7 @@ class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
     return Puppet::Parser::Resource::Param.new(
       :name => @param,
       :value => value.nil? ? :undef : value,
-      :source => scope.source, 
+      :source => scope.source,
       :line => self.line,
       :file => self.file,
       :add => self.add

data/lib/puppet/parser/catalog_compiler.rb

@@ -42,7 +42,7 @@ class Puppet::Parser::CatalogCompiler < Puppet::Parser::Compiler
   end
 
   # Evaluates added constructs that are lazily evaluated until all of them have been evaluated.
-  # 
+  #
   def evaluate_additions
     evaluate_generators
     finish

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -39,5 +39,3 @@ class Puppet::Parser::Compiler
     end
   end
 end
-
-

data/lib/puppet/parser/compiler.rb

@@ -33,7 +33,7 @@ class Puppet::Parser::Compiler
       raise(Puppet::Error, errmsg.join(' '))
     end
 
-    new(node, :code_id => code_id).compile {|resulting_catalog| resulting_catalog.to_resource }
+    new(node, :code_id => code_id).compile { |resulting_catalog| resulting_catalog.to_resource }
   rescue Puppet::ParseErrorWithIssue => detail
     detail.node = node.name
     Puppet.log_exception(detail)
@@ -116,13 +116,13 @@ class Puppet::Parser::Compiler
   def_delegator :@catalog, :classes, :classlist
 
   def with_context_overrides(description = '', &block)
-    Puppet.override( @context_overrides , description, &block)
+    Puppet.override(@context_overrides, description, &block)
   end
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
-    Puppet.override( @context_overrides , _("For compiling %{node}") % { node: node.name }) do
+    Puppet.override(@context_overrides, _("For compiling %{node}") % { node: node.name }) do
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
@@ -164,7 +164,7 @@ class Puppet::Parser::Compiler
   end
 
   # Constructs the overrides for the context
-  def context_overrides()
+  def context_overrides
     {
       :current_environment => environment,
       :global_scope => @topscope, # 4x placeholder for new global scope
@@ -186,12 +186,12 @@ class Puppet::Parser::Compiler
   # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
     if @node.classes.is_a? Hash
-      classes_with_params, classes_without_params = @node.classes.partition {|_name,params| params and !params.empty?}
+      classes_with_params, classes_without_params = @node.classes.partition { |_name, params| params and !params.empty? }
 
       # The results from Hash#partition are arrays of pairs rather than hashes,
       # so we have to convert to the forms evaluate_classes expects (Hash, and
       # Array of class names)
-      classes_with_params = Hash[classes_with_params]
+      classes_with_params = classes_with_params.to_h
       classes_without_params.map!(&:first)
     else
       classes_with_params = {}
@@ -240,7 +240,7 @@ class Puppet::Parser::Compiler
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
-    if classes.class == Hash
+    if classes.instance_of?(Hash)
       class_parameters = classes
       classes = classes.keys
     end
@@ -350,11 +350,11 @@ class Puppet::Parser::Compiler
           rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
             # needs to be handled specifically as the error has the file/line/position where this
             # occurred rather than the resource
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, {:detail => detail.message}, detail)
+            fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, { :detail => detail.message }, detail)
           rescue Puppet::Error => e
             # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
             # call stack instead
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, {:detail => e.message}, e.original || e)
+            fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, { :detail => e.message }, e.original || e)
           end
         end
         !urs.empty?
@@ -531,7 +531,7 @@ class Puppet::Parser::Compiler
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
-    Puppet.override( @context_overrides , _("For initializing compiler")) do
+    Puppet.override(@context_overrides, _("For initializing compiler")) do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = environment.known_resource_types.version
       @loaders.pre_load
@@ -543,7 +543,7 @@ class Puppet::Parser::Compiler
     @resources = []
 
     # Make sure any external node classes are in our class list
-    if @node.classes.class == Hash
+    if @node.classes.instance_of?(Hash)
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -20,7 +20,7 @@ class E4ParserAdapter
   end
 
   def parse(string = nil)
-    self.string= string if string
+    self.string = string if string
     parser = Pops::Parser::EvaluatingParser.singleton
     model =
       if @use == :string

data/lib/puppet/parser/files.rb

@@ -40,7 +40,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_file(file, environment)
-    find_in_module(file, environment) do |mod,module_file|
+    find_in_module(file, environment) do |mod, module_file|
       mod.file(module_file)
     end
   end
@@ -61,7 +61,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_template(template, environment)
-    find_in_module(template, environment) do |mod,template_file|
+    find_in_module(template, environment) do |mod, template_file|
       mod.template(template_file)
     end
   end

data/lib/puppet/parser/functions/assert_type.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Puppet::Parser::Functions::newfunction(
+Puppet::Parser::Functions.newfunction(
   :assert_type,
   :type => :rvalue,
   :arity => -3,
@@ -9,52 +9,52 @@ Puppet::Parser::Functions::newfunction(
     [data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
     otherwise either raises an error or executes an optional two-parameter
     [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
-    
+
     The function takes two mandatory arguments, in this order:
-    
+
     1. The expected data type.
     2. A value to compare against the expected data type.
-    
+
     **Example**: Using `assert_type`
-    
+
     ~~~ puppet
     $raw_username = 'Amy Berry'
-    
+
     # Assert that $raw_username is a non-empty string and assign it to $valid_username.
     $valid_username = assert_type(String[1], $raw_username)
-    
+
     # $valid_username contains "Amy Berry".
     # If $raw_username was an empty string or a different data type, the Puppet run would
     # fail with an "Expected type does not match actual" error.
     ~~~
-    
+
     You can use an optional lambda to provide enhanced feedback. The lambda takes two
     mandatory parameters, in this order:
-    
+
     1. The expected data type as described in the function's first argument.
     2. The actual data type of the value.
-    
+
     **Example**: Using `assert_type` with a warning and default value
-    
+
     ~~~ puppet
     $raw_username = 'Amy Berry'
-    
+
     # Assert that $raw_username is a non-empty string and assign it to $valid_username.
     # If it isn't, output a warning describing the problem and use a default value.
     $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
       warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
       'anonymous'
     }
-    
+
     # $valid_username contains "Amy Berry".
     # If $raw_username was an empty string, the Puppet run would set $valid_username to
     # "anonymous" and output a warning: "The username should be 'String[1, default]', not
     # 'String[0, 0]'. Using 'anonymous'."
     ~~~
-    
+
     For more information about data types, see the
     [documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
-    
+
     - Since 4.0.0
   DOC
 ) do |_args|