openvox 7.37.1 → 8.19.0

data/lib/puppet/reports.rb

@@ -1,3 +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.
@@ -55,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]
 
@@ -70,13 +72,13 @@ class Puppet::Reports
   # Collects the docs for all reports.
   # @api private
   def self.reportdocs
-    docs = ""
+    docs = ''.dup
 
     # Use this method so they all get loaded
     instance_loader(:report).loadall(Puppet.lookup(:current_environment))
     loaded_instances(:report).sort_by(&:to_s).each do |name|
-      mod = self.report(name)
-      docs << "#{name}\n#{"-" * name.to_s.length}\n"
+      mod = report(name)
+      docs << "#{name}\n#{'-' * name.to_s.length}\n"
 
       docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
     end

data/lib/puppet/resource/catalog.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/node'
 require_relative '../../puppet/indirector'
 require_relative '../../puppet/transaction'
@@ -83,15 +85,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Returns [typename, title] when given a String with "Type[title]".
   # Returns [nil, nil] if '[' ']' not detected.
   #
-  def title_key_for_ref( ref )
+  def title_key_for_ref(ref)
     s = ref.index('[')
     e = ref.rindex(']')
     if s && e && e > s
-      a = [ref[0, s], ref[s+1, e-s-1]]
+      a = [ref[0, s], ref[s + 1, e - s - 1]]
     else
       a = [nil, nil]
     end
-    return a
+    a
   end
 
   def add_resource_before(other, *resources)
@@ -100,7 +102,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       idx = @resources.index(other_title_key)
       if idx.nil?
         raise ArgumentError, _("Cannot add resource %{resource_1} before %{resource_2} because %{resource_2} is not yet in the catalog") %
-            { resource_1: resource.ref, resource_2: other.ref }
+                             { resource_1: resource.ref, resource_2: other.ref }
       end
       add_one_resource(resource, idx)
     end
@@ -115,9 +117,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       idx = @resources.index(other_title_key)
       if idx.nil?
         raise ArgumentError, _("Cannot add resource %{resource_1} after %{resource_2} because %{resource_2} is not yet in the catalog") %
-            { resource_1: resource.ref, resource_2: other.ref }
+                             { resource_1: resource.ref, resource_2: other.ref }
       end
-      add_one_resource(resource, idx+1)
+      add_one_resource(resource, idx + 1)
     end
   end
 
@@ -134,7 +136,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     adjacent(resource, :direction => :in)[0]
   end
 
-  def add_one_resource(resource, idx=-1)
+  def add_one_resource(resource, idx = -1)
     title_key = title_key_for_ref(resource.ref)
     if @resource_table[title_key]
       fail_on_duplicate_type_and_title(resource, title_key)
@@ -165,7 +167,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     # The alias setting logic checks, and does not error if the alias is set to an already set alias
     # for the same resource (i.e. it is ok if alias == title
     explicit_aliases = [resource[:alias]].flatten.compact
-    explicit_aliases.each {| given_alias | self.alias(resource, given_alias) }
+    explicit_aliases.each { |given_alias| self.alias(resource, given_alias) }
 
     # Skip creating uniqueness key alias and checking collisions for non-isomorphic resources.
     return unless resource.respond_to?(:isomorphic?) and resource.isomorphic?
@@ -182,7 +184,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   def alias(resource, key)
     ref = resource.ref
     ref =~ /^(.+)\[/
-    class_name = $1 || resource.class.name
+    class_name = ::Regexp.last_match(1) || resource.class.name
 
     newref = [class_name, key].flatten
 
@@ -198,15 +200,16 @@ 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 }
+                { 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 }
+                { resource: ref, key: key.inspect, resource_declaration: resource_declaration, newref: newref.inspect }
             end
       msg += Puppet::Util::Errors.error_location_with_space(existing.file, existing.line)
       raise ArgumentError, msg
@@ -269,7 +272,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   def clear(remove_resources = true)
     super()
     # We have to do this so that the resources clean themselves up.
-    @resource_table.values.each { |resource| resource.remove } if remove_resources
+    @resource_table.values.each(&:remove) if remove_resources
     @resource_table.clear
     @resources = []
 
@@ -289,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
 
@@ -300,7 +304,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   def finalize
     make_default_resources
 
-    @resource_table.values.each { |resource| resource.finish }
+    @resource_table.values.each(&:finish)
 
     write_graph(:resources)
   end
@@ -376,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
@@ -391,7 +395,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   def resource_refs
-    resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
+    resource_keys.filter_map { |type, name| name.is_a?(String) ? "#{type}[#{name}]" : nil }
   end
 
   def resource_keys
@@ -407,7 +411,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   def self.from_data_hash(data)
     result = new(data['name'], Puppet::Node::Environment::NONE)
 
-    result.tag(*data['tags']) if data['tags'] 
+    result.tag(*data['tags']) if data['tags']
     result.version = data['version'] if data['version']
     result.code_id = data['code_id'] if data['code_id']
     result.catalog_uuid = data['catalog_uuid'] if data['catalog_uuid']
@@ -431,14 +435,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
         source = result.resource(edge.source)
         unless source
           raise ArgumentError, _("Could not intern from data: Could not find relationship source %{source} for %{target}") %
-              { source: edge.source.inspect, target: edge.target.to_s }
+                               { source: edge.source.inspect, target: edge.target.to_s }
         end
         edge.source = source
 
         target = result.resource(edge.target)
         unless target
           raise ArgumentError, _("Could not intern from data: Could not find relationship target %{target} for %{source}") %
-              { target: edge.target.inspect, source: edge.source.to_s }
+                               { target: edge.target.inspect, source: edge.source.to_s }
         end
         edge.target = target
 
@@ -448,16 +452,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
     result.add_class(*data['classes']) if data['classes']
 
-    result.metadata = data['metadata'].inject({}) { |h, (k, v)| h[k] = Puppet::FileServing::Metadata.from_data_hash(v); h } if data['metadata']
+    result.metadata = data['metadata'].transform_values { |v| Puppet::FileServing::Metadata.from_data_hash(v); } if data['metadata']
 
     recursive_metadata = data['recursive_metadata']
     if recursive_metadata
-      result.recursive_metadata = recursive_metadata.inject({}) do |h, (title, source_to_meta_hash)|
-        h[title] = source_to_meta_hash.inject({}) do |inner_h, (source, metas)|
-          inner_h[source] = metas.map {|meta| Puppet::FileServing::Metadata.from_data_hash(meta)}
-          inner_h
+      result.recursive_metadata = recursive_metadata.transform_values do |source_to_meta_hash|
+        source_to_meta_hash.transform_values do |metas|
+          metas.map { |meta| Puppet::FileServing::Metadata.from_data_hash(meta) }
         end
-        h
       end
     end
 
@@ -465,29 +467,27 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   def to_data_hash
-    metadata_hash = metadata.inject({}) { |h, (k, v)| h[k] = v.to_data_hash; h }
-    recursive_metadata_hash = recursive_metadata.inject({}) do |h, (title, source_to_meta_hash)|
-      h[title] = source_to_meta_hash.inject({}) do |inner_h, (source, metas)|
-        inner_h[source] = metas.map {|meta| meta.to_data_hash}
-        inner_h
+    metadata_hash = metadata.transform_values(&:to_data_hash)
+    recursive_metadata_hash = recursive_metadata.transform_values do |source_to_meta_hash|
+      source_to_meta_hash.transform_values do |metas|
+        metas.map(&:to_data_hash)
       end
-      h
     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(&:to_data_hash),
+      'classes' => classes,
     }.merge(metadata_hash.empty? ?
-      {} : {'metadata' => metadata_hash}).merge(recursive_metadata_hash.empty? ?
-        {} : {'recursive_metadata' => recursive_metadata_hash})
+      {} : { 'metadata' => metadata_hash }).merge(recursive_metadata_hash.empty? ?
+        {} : { 'recursive_metadata' => recursive_metadata_hash })
   end
 
   # Convert our catalog into a RAL catalog.
@@ -508,7 +508,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     # environment set in the catalog (if it is set)
     # See PUP-3755
     if environment_instance
-      Puppet.override({:current_environment => environment_instance}) do
+      Puppet.override({ :current_environment => environment_instance }) do
         to_catalog :to_resource, &block
       end
     else
@@ -536,10 +536,11 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     # https://puppet.com/docs/puppet/latest/configuration.html#resourcefile
     resourcefile = Puppet.settings.setting(:resourcefile)
     Puppet::FileSystem.open(resourcefile.value, resourcefile.mode.to_i(8), "w:UTF-8") do |f|
-      to_print = resources.map do |resource|
+      to_print = resources.filter_map do |resource|
         next unless resource.managed?
-        "#{resource.ref.downcase}"
-      end.compact
+
+        resource.ref.downcase.to_s
+      end
       f.puts to_print.join("\n")
     end
   rescue => detail
@@ -589,14 +590,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # This pretty much just converts all of the resources from one class to another, using
   # a conversion method.
   def to_catalog(convert)
-    result = self.class.new(self.name, self.environment_instance)
+    result = self.class.new(name, environment_instance)
 
-    result.version = self.version
-    result.code_id = self.code_id
-    result.catalog_uuid = self.catalog_uuid
-    result.catalog_format = self.catalog_format
-    result.metadata = self.metadata
-    result.recursive_metadata = self.recursive_metadata
+    result.version = version
+    result.code_id = code_id
+    result.catalog_uuid = catalog_uuid
+    result.catalog_format = catalog_format
+    result.metadata = metadata
+    result.recursive_metadata = recursive_metadata
 
     map = {}
     resources.each do |resource|
@@ -642,7 +643,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
     map.clear
 
-    result.add_class(*self.classes)
+    result.add_class(*classes)
     result.merge_tags_from(self)
 
     result

data/lib/puppet/resource/status.rb

@@ -1,10 +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
@@ -101,7 +102,7 @@ module Puppet
       end
 
       def self.from_data_hash(data)
-        obj = self.allocate
+        obj = allocate
         obj.initialize_from_hash(data)
         obj
       end
@@ -109,7 +110,7 @@ module Puppet
       # Provide a boolean method for each of the states.
       STATES.each do |attr|
         define_method("#{attr}?") do
-          !! send(attr)
+          !!send(attr)
         end
       end
 
@@ -120,9 +121,10 @@ module Puppet
 
       def add_event(event)
         @events << event
-        if event.status == 'failure'
+        case event.status
+        when 'failure'
           self.failed = true
-        elsif event.status == 'success'
+        when 'success'
           @change_count += 1
           @changed = true
         end
@@ -214,13 +216,13 @@ module Puppet
           'tags' => @tags.to_a,
           'time' => @time.iso8601(9),
           'failed' => @failed,
-          'failed_to_restart' => self.failed_to_restart?,
+          'failed_to_restart' => failed_to_restart?,
           'changed' => @changed,
           'out_of_sync' => @out_of_sync,
           'skipped' => @skipped,
           'change_count' => @change_count,
           'out_of_sync_count' => @out_of_sync_count,
-          'events' => @events.map { |event| event.to_data_hash },
+          'events' => @events.map(&:to_data_hash),
           'corrective_change' => @corrective_change,
         }
       end

data/lib/puppet/resource/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/parser'
 require_relative '../../puppet/util/warnings'
 require_relative '../../puppet/util/errors'
@@ -15,22 +17,32 @@ 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
 
-  NAME = 'name'.freeze
-  TITLE = 'title'.freeze
-  MODULE_NAME = 'module_name'.freeze
-  CALLER_MODULE_NAME = 'caller_module_name'.freeze
-  PARAMETERS = 'parameters'.freeze
-  KIND = 'kind'.freeze
-  NODES = 'nodes'.freeze
-  DOUBLE_COLON = '::'.freeze
+  NAME = 'name'
+  TITLE = 'title'
+  MODULE_NAME = 'module_name'
+  CALLER_MODULE_NAME = 'caller_module_name'
+  PARAMETERS = 'parameters'
+  KIND = 'kind'
+  NODES = 'nodes'
+  DOUBLE_COLON = '::'
   EMPTY_ARRAY = [].freeze
 
+  LOOKAROUND_OPERATORS = {
+    "(" => 'LP',
+    "?" => "QU",
+    "<" => "LT",
+    ">" => "GT",
+    "!" => "EX",
+    "=" => "EQ",
+    ")" => 'RP'
+  }.freeze
+
   attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection, :override
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
@@ -45,7 +57,7 @@ class Puppet::Resource::Type
   attr_reader :type
 
   RESOURCE_KINDS.each do |t|
-    define_method("#{t}?") { self.type == t }
+    define_method("#{t}?") { type == t }
   end
 
   # Are we a child of the passed class?  Do a recursive search up our
@@ -54,12 +66,11 @@ class Puppet::Resource::Type
     return true if override
     return false unless parent
 
-    return(klass == parent_type ? true : parent_type.child_of?(klass))
+    (klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
   # 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
 
@@ -93,6 +104,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
 
@@ -116,6 +128,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?
@@ -137,7 +150,7 @@ class Puppet::Resource::Type
     # This might just be an empty, stub class.
     return unless other.code
 
-    unless self.code
+    unless code
       self.code = other.code
       return
     end
@@ -150,16 +163,16 @@ class Puppet::Resource::Type
   # classes and nodes.  No parameters are be supplied--if this is a
   # parameterized class, then all parameters take on their default
   # values.
-  def ensure_in_catalog(scope, parameters=nil)
+  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
@@ -172,7 +185,7 @@ class Puppet::Resource::Type
       resource = scope.catalog.resource(resource_type, name)
       return resource unless resource.nil?
     elsif parameters.is_a?(Hash)
-      parameters = parameters.map {|k, v| Puppet::Parser::Resource::Param.new(:name => k, :value => v, :source => self)}
+      parameters = parameters.map { |k, v| Puppet::Parser::Resource::Param.new(:name => k, :value => v, :source => self) }
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self, :parameters => parameters)
     instantiate_resource(scope, resource)
@@ -186,14 +199,18 @@ class Puppet::Resource::Type
       parent_type(scope).ensure_in_catalog(scope)
     end
 
-    if ['Class', 'Node'].include? resource.type
+    if %w[Class Node].include? resource.type
       scope.catalog.merge_tags_from(resource)
     end
   end
 
   def name
     if type == :node && name_is_regex?
-      "__node_regexp__#{@name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')}"
+      # Normalize lookarround regex patthern
+      internal_name = @name.source.downcase.gsub(/\(\?[^)]*\)/) do |str|
+        str.gsub(/./) { |ch| LOOKAROUND_OPERATORS[ch] || ch }
+      end
+      "__node_regexp__#{internal_name.gsub(/[^-\w:.]/, '').sub(/^\.+/, '')}"
     else
       @name
     end
@@ -207,7 +224,7 @@ class Puppet::Resource::Type
     return nil unless parent
 
     @parent_type ||= scope.environment.known_resource_types.send("find_#{type}", parent) ||
-      fail(Puppet::ParseError, _("Could not find parent resource type '%{parent}' of type %{parent_type} in %{env}") % { parent: parent, parent_type: type, env: scope.environment })
+                     fail(Puppet::ParseError, _("Could not find parent resource type '%{parent}' of type %{parent_type} in %{env}") % { parent: parent, parent_type: type, env: scope.environment })
   end
 
   # Validate and set any arguments passed by the resource as variables in the scope.
@@ -229,12 +246,12 @@ class Puppet::Resource::Type
 
     if @type == :hostclass
       scope[TITLE] = resource.title.to_s.downcase
-      scope[NAME] =  resource.name.to_s.downcase
+      scope[NAME] = resource.name.to_s.downcase
     else
       scope[TITLE] = resource.title
-      scope[NAME] =  resource.name
+      scope[NAME] = resource.name
     end
-    scope.class_set(self.name,scope) if hostclass? || node?
+    scope.class_set(name, scope) if hostclass? || node?
 
     param_hash = scope.with_parameter_scope(resource.to_s, arguments.keys) do |param_scope|
       # Assign directly to the parameter scope to avoid scope parameter validation at this point. It
@@ -248,7 +265,7 @@ class Puppet::Resource::Type
     validate_resource_hash(resource, param_hash)
 
     # Assign parameter values to current scope
-    param_hash.each { |param, value| exceptwrap { scope[param] = value }}
+    param_hash.each { |param, value| exceptwrap { scope[param] = value } }
   end
 
   # Lookup and inject parameters from external scope
@@ -257,11 +274,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
@@ -273,12 +292,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
@@ -298,11 +320,10 @@ 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
-    ])
+                           resource.parameters.to_h 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.
@@ -330,6 +351,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)
@@ -338,6 +360,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
@@ -357,6 +380,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
@@ -366,7 +390,7 @@ class Puppet::Resource::Type
     ary = fullname.split(DOUBLE_COLON)
     n = ary.pop || ""
     ns = ary.join(DOUBLE_COLON)
-    return ns, n
+    [ns, n]
   end
 
   def parent_scope(scope, klass)
@@ -391,9 +415,9 @@ class Puppet::Resource::Type
     return unless Puppet::Type.metaparamclass(param)
 
     if default
-      warnonce _("%{param} is a metaparam; this value will inherit to all contained resources in the %{name} definition") % { param: param, name: self.name }
+      warnonce _("%{param} is a metaparam; this value will inherit to all contained resources in the %{name} definition") % { param: param, name: name }
     else
-      raise Puppet::ParseError, _("%{param} is a metaparameter; please choose another parameter name in the %{name} definition") % { param: param, name: self.name }
+      raise Puppet::ParseError, _("%{param} is a metaparameter; please choose another parameter name in the %{name} definition") % { param: param, name: name }
     end
   end
 
@@ -404,7 +428,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