puppet 8.2.0-x64-mingw32 → 8.4.0-x64-mingw32

data/lib/puppet/reference/indirection.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/indirector/indirection'
 require_relative '../../puppet/util/checksums'
 require_relative '../../puppet/file_serving/content'
 require_relative '../../puppet/file_serving/metadata'
 
 reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirection types and their terminus classes" do
-  text = String.new
+  text = ''.dup
   Puppet::Indirector::Indirection.instances.sort_by(&:to_s).each do |indirection|
     ind = Puppet::Indirector::Indirection.instance(indirection)
     name = indirection.to_s.capitalize
@@ -28,45 +29,45 @@ reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirect
   text
 end
 
-reference.header = <<HEADER
-
-## About Indirection
-
-Puppet's indirector support pluggable backends (termini) for a variety of key-value stores (indirections).
-Each indirection type corresponds to a particular Ruby class (the "Indirected Class" below) and values are instances of that class.
-Each instance's key is available from its `name` method.
-The termini can be local (e.g., on-disk files) or remote (e.g., using a REST interface to talk to a puppet master).
-
-An indirector has five methods, which are mapped into HTTP verbs for the REST interface:
-
-* `find(key)` - get a single value (mapped to GET or POST with a singular endpoint)
-* `search(key)` - get a list of matching values (mapped to GET with a plural endpoint)
-* `head(key)` - return true if the key exists (mapped to HEAD)
-* `destroy(key)` - remove the key and value (mapped to DELETE)
-* `save(instance)` - write the instance to the store, using the instance's name as the key (mapped to PUT)
-
-These methods are available via the `indirection` class method on the indirected classes.  For example:
-
-    node = Puppet::Node.indirection.find('foo.example.com')
-
-At startup, each indirection is configured with a terminus.
-In most cases, this is the default terminus defined by the indirected class, but it can be overridden by the application or face, or overridden with the `route_file` configuration.
-The available termini differ for each indirection, and are listed below.
-
-Indirections can also have a cache, represented by a second terminus.
-This is a write-through cache: modifications are written both to the cache and to the primary terminus.
-Values fetched from the terminus are written to the cache.
-
-### Interaction with REST
-
-REST endpoints have the form `/{prefix}/{version}/{indirection}/{key}?environment={environment}`, where the indirection can be singular or plural, following normal English spelling rules.
-On the server side, REST responses are generated from the locally-configured endpoints.
-
-### Indirections and Termini
-
-Below is the list of all indirections, their associated terminus classes, and how you select between them.
-
-In general, the appropriate terminus class is selected by the application for you (e.g., `puppet agent` would always use the `rest`
-terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have `terminus setting` documentation listed with them.
-
+reference.header = <<~HEADER
+  
+  ## About Indirection
+  
+  Puppet's indirector support pluggable backends (termini) for a variety of key-value stores (indirections).
+  Each indirection type corresponds to a particular Ruby class (the "Indirected Class" below) and values are instances of that class.
+  Each instance's key is available from its `name` method.
+  The termini can be local (e.g., on-disk files) or remote (e.g., using a REST interface to talk to a puppet master).
+  
+  An indirector has five methods, which are mapped into HTTP verbs for the REST interface:
+  
+  * `find(key)` - get a single value (mapped to GET or POST with a singular endpoint)
+  * `search(key)` - get a list of matching values (mapped to GET with a plural endpoint)
+  * `head(key)` - return true if the key exists (mapped to HEAD)
+  * `destroy(key)` - remove the key and value (mapped to DELETE)
+  * `save(instance)` - write the instance to the store, using the instance's name as the key (mapped to PUT)
+  
+  These methods are available via the `indirection` class method on the indirected classes.  For example:
+  
+      node = Puppet::Node.indirection.find('foo.example.com')
+  
+  At startup, each indirection is configured with a terminus.
+  In most cases, this is the default terminus defined by the indirected class, but it can be overridden by the application or face, or overridden with the `route_file` configuration.
+  The available termini differ for each indirection, and are listed below.
+  
+  Indirections can also have a cache, represented by a second terminus.
+  This is a write-through cache: modifications are written both to the cache and to the primary terminus.
+  Values fetched from the terminus are written to the cache.
+  
+  ### Interaction with REST
+  
+  REST endpoints have the form `/{prefix}/{version}/{indirection}/{key}?environment={environment}`, where the indirection can be singular or plural, following normal English spelling rules.
+  On the server side, REST responses are generated from the locally-configured endpoints.
+  
+  ### Indirections and Termini
+  
+  Below is the list of all indirections, their associated terminus classes, and how you select between them.
+  
+  In general, the appropriate terminus class is selected by the application for you (e.g., `puppet agent` would always use the `rest`
+  terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have `terminus setting` documentation listed with them.
+  
 HEADER

data/lib/puppet/reference/metaparameter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
   str = %{
 

data/lib/puppet/reference/providers.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
   types = []
   Puppet::Type.loadall
   Puppet::Type.eachtype do |klass|
     next unless klass && klass.providers.length > 0
+
     types << klass
   end
   types.sort! { |a,b| a.name.to_s <=> b.name.to_s }

data/lib/puppet/reference/report.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/reports'
 
 report = Puppet::Util::Reference.newreference :report, :doc => "All available transaction reports" do

data/lib/puppet/reference/type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
   types = {}
   Puppet::Type.loadall
@@ -6,6 +7,7 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
   Puppet::Type.eachtype { |type|
     next if type.name == :component
     next if type.name == :whit
+
     types[type.name] = type
   }
 
@@ -51,7 +53,6 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
   }
 
   types.sort_by(&:to_s).each { |name,type|
-
     str << "
 
 ----------------
@@ -86,11 +87,11 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
       tmp = doc
       tmp = scrub(tmp)
 
-      docs[sname]  = tmp
+      docs[sname] = tmp
     }
 
     str << markdown_header("Parameters", 4) + "\n"
-    type.parameters.sort_by(&:to_s).each { |type_name, param|
+    type.parameters.sort_by(&:to_s).each { |type_name, _param|
       docs[type_name] = scrub(type.paramdoc(type_name))
     }
 

data/lib/puppet/relationship.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # subscriptions are permanent associations determining how different
 # objects react to an event
 
@@ -6,7 +7,6 @@
 # It used to be a subclass of GRATR::Edge, but that class has weird hash
 # overrides that dramatically slow down the graphing.
 class Puppet::Relationship
-
   # FormatSupport for serialization methods
   include Puppet::Network::FormatSupport
   include Puppet::Util::PsychSupport
@@ -27,8 +27,9 @@ class Puppet::Relationship
   end
 
   def event=(event)
-    #TRANSLATORS 'NONE' should not be translated
+    # TRANSLATORS 'NONE' should not be translated
     raise ArgumentError, _("You must pass a callback for non-NONE events") if event != :NONE and ! callback
+
     @event = event
   end
 

data/lib/puppet/reports/http.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet'
 require_relative '../../puppet/network/http_pool'
 require 'uri'
 
 Puppet::Reports.register_report(:http) do
-
   desc <<-DESC
     Send reports via HTTP or HTTPS. This report processor submits reports as
     POST requests to the address in the `reporturl` setting. When a HTTPS URL

data/lib/puppet/reports/log.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/reports'
 
 Puppet::Reports.register_report(:log) do

data/lib/puppet/reports/store.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet'
 require 'fileutils'
 require_relative '../../puppet/util'
@@ -37,7 +38,7 @@ Puppet::Reports.register_report(:store) do
         fh.print to_yaml
       end
     rescue => detail
-       Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
+      Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
     end
 
     # Only testing cares about the return value
@@ -53,6 +54,7 @@ Puppet::Reports.register_report(:store) do
     if Puppet::FileSystem.exist?(dir)
       Dir.entries(dir).each do |file|
         next if ['.','..'].include?(file)
+
         file = File.join(dir, file)
         Puppet::FileSystem.unlink(file) if File.file?(file)
       end

data/lib/puppet/reports.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../puppet/util/instance_loader'
 
 # This class is an implementation of a simple mechanism for loading and returning reports.
@@ -56,10 +57,10 @@ class Puppet::Reports
     name = name.intern
 
     mod = genmodule(name,
-                    :extend    => Puppet::Util::Docs,
-                    :hash      => instance_hash(:report),
+                    :extend => Puppet::Util::Docs,
+                    :hash => instance_hash(:report),
                     :overwrite => true,
-                    :block     => block)
+                    :block => block)
 
     mod.useyaml = true if options[:useyaml]
 
@@ -71,7 +72,7 @@ class Puppet::Reports
   # Collects the docs for all reports.
   # @api private
   def self.reportdocs
-    docs = String.new
+    docs = ''.dup
 
     # Use this method so they all get loaded
     instance_loader(:report).loadall(Puppet.lookup(:current_environment))

data/lib/puppet/resource/catalog.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/node'
 require_relative '../../puppet/indirector'
 require_relative '../../puppet/transaction'
@@ -199,13 +200,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     existing = @resource_table[newref]
     if existing
       return if existing == resource
+
       resource_declaration = Puppet::Util::Errors.error_location(resource.file, resource.line)
       msg = if resource_declaration.empty?
-              #TRANSLATORS 'alias' should not be translated
+              # TRANSLATORS 'alias' should not be translated
               _("Cannot alias %{resource} to %{key}; resource %{newref} already declared") %
                   { resource: ref, key: key.inspect, newref: newref.inspect }
             else
-              #TRANSLATORS 'alias' should not be translated
+              # TRANSLATORS 'alias' should not be translated
               _("Cannot alias %{resource} to %{key} at %{resource_declaration}; resource %{newref} already declared") %
                   { resource: ref, key: key.inspect, resource_declaration: resource_declaration, newref: newref.inspect }
             end
@@ -290,6 +292,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     unless klass
       raise ArgumentError, _("Unknown resource type %{type}") % { type: type }
     end
+
     resource = klass.new(options)
     return unless resource
 
@@ -377,7 +380,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     type_name = type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type) ? type.name : type
     type_name, title = Puppet::Resource.type_and_title(type_name, title)
     type = type_name if type.is_a?(String)
-    title_key   = [type_name, title.to_s]
+    title_key = [type_name, title.to_s]
     result = @resource_table[title_key]
     if result.nil?
       # an instance has to be created in order to construct the unique key used when
@@ -476,16 +479,16 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     end
 
     {
-      'tags'      => tags.to_a,
-      'name'      => name,
-      'version'   => version,
-      'code_id'   => code_id,
+      'tags' => tags.to_a,
+      'name' => name,
+      'version' => version,
+      'code_id' => code_id,
       'catalog_uuid' => catalog_uuid,
       'catalog_format' => catalog_format,
-      'environment'  => environment.to_s,
+      'environment' => environment.to_s,
       'resources' => @resources.map { |v| @resource_table[v].to_data_hash },
-      'edges'     => edges.map { |e| e.to_data_hash },
-      'classes'   => classes,
+      'edges' => edges.map { |e| e.to_data_hash },
+      'classes' => classes,
     }.merge(metadata_hash.empty? ?
       {} : {'metadata' => metadata_hash}).merge(recursive_metadata_hash.empty? ?
         {} : {'recursive_metadata' => recursive_metadata_hash})
@@ -539,6 +542,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     Puppet::FileSystem.open(resourcefile.value, resourcefile.mode.to_i(8), "w:UTF-8") do |f|
       to_print = resources.map do |resource|
         next unless resource.managed?
+
         "#{resource.ref.downcase}"
       end.compact
       f.puts to_print.join("\n")

data/lib/puppet/resource/status.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require 'time'
 require_relative '../../puppet/network/format_support'
 require_relative '../../puppet/util/psych_support'
 
 module Puppet
   class Resource
-
     # This class represents the result of evaluating a given resource. It
     # contains file and line information about the source, events generated
     # while evaluating the resource, timing information, and the status of the

data/lib/puppet/resource/type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/parser'
 require_relative '../../puppet/util/warnings'
 require_relative '../../puppet/util/errors'
@@ -16,9 +17,9 @@ class Puppet::Resource::Type
 
   # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
-      :hostclass => "class",
-      :node => "node",
-      :definition => "defined_type"
+    :hostclass => "class",
+    :node => "node",
+    :definition => "defined_type"
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
@@ -60,7 +61,6 @@ class Puppet::Resource::Type
 
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
-
     static_parent = evaluate_parent_type(resource)
     scope = static_parent || resource.scope
 
@@ -94,6 +94,7 @@ class Puppet::Resource::Type
     [:code, :doc, :line, :file, :parent].each do |param|
       value = options[param]
       next unless value
+
       send(param.to_s + '=', value)
     end
 
@@ -117,6 +118,7 @@ class Puppet::Resource::Type
   def merge(other)
     fail _("%{name} is not a class; cannot add code to it") % { name: name } unless type == :hostclass
     fail _("%{name} is not a class; cannot add code from it") % { name: other.name } unless other.type == :hostclass
+
     if name == "" && Puppet.settings[:freeze_main]
       # It is ok to merge definitions into main even if freeze is on (definitions are nodes, classes, defines, functions, and types)
       unless other.code.is_definitions_only?
@@ -153,14 +155,14 @@ class Puppet::Resource::Type
   # values.
   def ensure_in_catalog(scope, parameters=nil)
     resource_type =
-    case type
-    when :definition
-      raise ArgumentError, _('Cannot create resources for defined resource types')
-    when :hostclass
-      :class
-    when :node
-      :node
-    end
+      case type
+      when :definition
+        raise ArgumentError, _('Cannot create resources for defined resource types')
+      when :hostclass
+        :class
+      when :node
+        :node
+      end
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
@@ -258,11 +260,13 @@ class Puppet::Resource::Type
   def inject_external_parameters(resource, scope)
     # Only lookup parameters for host classes
     return unless type == :hostclass
+
     parameters = resource.parameters
     arguments.each do |param_name, default|
       sym_name = param_name.to_sym
       param = parameters[sym_name]
       next unless param.nil? || param.value.nil?
+
       catch(:no_such_key) do
         bound_value = Puppet::Pops::Lookup.search_and_merge("#{name}::#{param_name}", Puppet::Pops::Lookup::Invocation.new(scope), nil)
         # Assign bound value but don't let an undef trump a default expression
@@ -274,12 +278,15 @@ class Puppet::Resource::Type
 
   def assign_defaults(resource, param_scope, scope)
     return unless resource.is_a?(Puppet::Parser::Resource)
+
     parameters = resource.parameters
     arguments.each do |param_name, default|
       next if default.nil?
+
       name = param_name.to_sym
       param = parameters[name]
       next unless param.nil? || param.value.nil?
+
       value = exceptwrap { param_scope.evaluate3x(param_name, default, scope) }
       resource[name] = value
       param_scope[param_name] = value
@@ -299,11 +306,11 @@ class Puppet::Resource::Type
     # recreated as a Sensitive in order to perform correct type checking.
     sensitives = Set.new(resource.sensitive_parameters)
     validate_resource_hash(resource,
-      Hash[resource.parameters.map do |name, value|
-        value_to_validate = sensitives.include?(name) ? Puppet::Pops::Types::PSensitiveType::Sensitive.new(value.value) : value.value
-        [name.to_s, value_to_validate]
-      end
-    ])
+                           Hash[resource.parameters.map do |name, value|
+                             value_to_validate = sensitives.include?(name) ? Puppet::Pops::Types::PSensitiveType::Sensitive.new(value.value) : value.value
+                             [name.to_s, value_to_validate]
+                           end
+                         ])
   end
 
   # Check whether a given argument is valid.
@@ -331,6 +338,7 @@ class Puppet::Resource::Type
     @argument_types = {}
     @parameter_struct = nil
     return unless name_to_type_hash
+
     name_to_type_hash.each do |name, t|
       # catch internal errors
       unless @arguments.include?(name)
@@ -339,6 +347,7 @@ class Puppet::Resource::Type
       unless t.is_a? Puppet::Pops::Types::PAnyType
         raise Puppet::DevError, _("Parameter '%{name}' is given a type that is not a Puppet Type, got %{class_name}") % { name: name, class_name: t.class }
       end
+
       @argument_types[name] = t
     end
   end
@@ -358,6 +367,7 @@ class Puppet::Resource::Type
     klass = parent_type(resource.scope)
     parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name) if klass
     return unless klass && parent_resource
+
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
@@ -405,7 +415,7 @@ class Puppet::Resource::Type
   def create_params_struct
     arg_types = argument_types
     type_factory = Puppet::Pops::Types::TypeFactory
-    members = { type_factory.optional(type_factory.string(NAME)) =>  type_factory.any }
+    members = { type_factory.optional(type_factory.string(NAME)) => type_factory.any }
 
     Puppet::Type.eachmetaparam do |name|
       # TODO: Once meta parameters are typed, this should change to reflect that type

data/lib/puppet/resource/type_collection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/parser/type_loader'
 require_relative '../../puppet/util/file_watcher'
 require_relative '../../puppet/util/warnings'
@@ -73,6 +74,7 @@ class Puppet::Resource::TypeCollection
   def handle_hostclass_merge(instance)
     # Only main class (named '') can be merged (for purpose of merging top-scopes).
     return instance unless instance.name == ''
+
     if instance.type == :hostclass && (other = @hostclasses[instance.name]) && other.type == :hostclass
       other.merge(instance)
       # throw is used to signal merge - avoids dupe checks and adding it to hostclasses
@@ -219,12 +221,14 @@ class Puppet::Resource::TypeCollection
   def dupe_check(instance, hash)
     dupe = hash[instance.name]
     return unless dupe
+
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 
   def dupe_check_singleton(instance, set)
     return if set.empty?
+
     message = yield set[0]
     instance.fail Puppet::ParseError, message
   end

data/lib/puppet/resource.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../puppet'
 require_relative '../puppet/util/tagging'
 require_relative '../puppet/parameter'
@@ -37,7 +38,7 @@ class Puppet::Resource
   CLASS_STRING = 'class'
   DEFINED_TYPE_STRING = 'defined_type'
   COMPILABLE_TYPE_STRING = 'compilable_type'
-  UNKNOWN_TYPE_STRING  = 'unknown'
+  UNKNOWN_TYPE_STRING = 'unknown'
 
   PCORE_TYPE_KEY = '__ptype'
   VALUE_KEY = 'value'
@@ -51,8 +52,10 @@ class Puppet::Resource
   def initialize_from_hash(data)
     type = data['type']
     raise ArgumentError, _('No resource type provided in serialized data') unless type
+
     title = data['title']
     raise ArgumentError, _('No resource title provided in serialized data') unless title
+
     @type, @title = self.class.type_and_title(type, title)
 
     params = data['parameters']
@@ -125,14 +128,17 @@ class Puppet::Resource
     end
 
     unless params.empty?
-      data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, {
-        :rich_data => Puppet.lookup(:rich_data),
-        :symbol_as_string => true,
-        :local_reference => false,
-        :type_by_reference => true,
-        :message_prefix => ref,
-        :semantic => self
-      })
+      data['parameters'] =
+        Puppet::Pops::Serialization::ToDataConverter
+          .convert(params,
+                   {
+                     :rich_data => Puppet.lookup(:rich_data),
+                     :symbol_as_string => true,
+                     :local_reference => false,
+                     :type_by_reference => true,
+                     :message_prefix => ref,
+                     :semantic => self
+                   })
     end
 
     data['sensitive_parameters'] = sensitive_parameters.map(&:to_s) unless sensitive_parameters.empty?
@@ -184,6 +190,7 @@ class Puppet::Resource
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
+
     true
   end
 
@@ -291,7 +298,7 @@ class Puppet::Resource
       @sensitive_parameters.replace(type.sensitive_parameters)
     else
       if type.is_a?(Hash)
-        #TRANSLATORS 'Puppet::Resource.new' should not be translated
+        # TRANSLATORS 'Puppet::Resource.new' should not be translated
         raise ArgumentError, _("Puppet::Resource.new does not take a hash as the first argument.") + ' ' +
           _("Did you mean (%{type}, %{title}) ?") %
               { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
@@ -321,6 +328,7 @@ class Puppet::Resource
       # Set things like environment, strictness first.
       attributes.each do |attr, value|
         next if attr == :parameters
+
         send(attr.to_s + "=", value)
       end
 
@@ -439,7 +447,7 @@ class Puppet::Resource
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
+    if attr.first != :ensure && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
@@ -474,7 +482,7 @@ class Puppet::Resource
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
+    if attr.first != :ensure && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
@@ -505,7 +513,7 @@ class Puppet::Resource
     elsif self.catalog && self.catalog.catalog_format >= 2
       typeklass = Puppet::Type.type(:component)
     else
-      typeklass =  Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+      typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
     end
 
     raise(Puppet::Error, "Resource type '#{self.type}' was not found") unless typeklass
@@ -521,7 +529,7 @@ class Puppet::Resource
   end
 
   def missing_arguments
-    resource_type.arguments.select do |param, default|
+    resource_type.arguments.select do |param, _default|
       the_param = parameters[param.to_sym]
       the_param.nil? || the_param.value.nil? || the_param.value == :undef
     end
@@ -574,7 +582,6 @@ class Puppet::Resource
     [type, title]
   end
 
-
   def self.extract_type_and_title(argtype, argtitle)
     if (argtype.nil? || argtype == :component || argtype == :whit) &&
           argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [ $1,                 $2            ]
@@ -582,7 +589,7 @@ class Puppet::Resource
           argtype =~ /^([^\[\]]+)\[(.+)\]$/m                   then [ $1,                 $2            ]
     elsif argtitle                                             then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
-    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect }
+    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect } # rubocop:disable Lint/ElseLayout
     end
   end
   private_class_method :extract_type_and_title
@@ -590,6 +597,7 @@ class Puppet::Resource
   def self.munge_type_name(value)
     return :main if value == :main
     return TYPE_CLASS if value == '' || value.nil? || value.to_s.casecmp('component') == 0
+
     Puppet::Pops::Types::TypeFormatter.singleton.capitalize_segments(value.to_s)
   end
   private_class_method :munge_type_name

data/lib/puppet/runtime.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../puppet/http'
 require_relative '../puppet/facter_impl'
 require 'singleton'

data/lib/puppet/scheduler/job.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Scheduler
   class Job
     attr_reader :run_interval