puppet 8.3.1-x64-mingw32 → 8.5.0-x64-mingw32

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?
@@ -151,16 +153,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
@@ -173,7 +175,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)
@@ -194,7 +196,7 @@ class Puppet::Resource::Type
 
   def name
     if type == :node && name_is_regex?
-      "__node_regexp__#{@name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')}"
+      "__node_regexp__#{@name.source.downcase.gsub(/[^-\w:.]/, '').sub(/^\.+/, '')}"
     else
       @name
     end
@@ -208,7 +210,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.
@@ -230,12 +232,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(self.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
@@ -249,7 +251,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
@@ -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,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.
@@ -331,6 +337,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 +346,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 +366,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 +414,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
@@ -81,11 +83,11 @@ class Puppet::Resource::TypeCollection
   end
 
   # Replaces the known settings with a new instance (that must be named 'settings').
-  # This is primarily needed for testing purposes. Also see PUP-5954 as it makes 
+  # This is primarily needed for testing purposes. Also see PUP-5954 as it makes
   # it illegal to merge classes other than the '' (main) class. Prior to this change
   # settings where always merged rather than being defined from scratch for many testing scenarios
   # not having a complete side effect free setup for compilation.
-  # 
+  #
   def replace_settings(instance)
     @hostclasses['settings'] = instance
   end
@@ -190,11 +192,11 @@ class Puppet::Resource::TypeCollection
     @environment.lock.synchronize do
       @lock.synchronize do
         # Name is always absolute, but may start with :: which must be removed
-        fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
+        fqname = (name[0, 2] == COLON_COLON ? name[2..] : name)
 
         result = send(type, fqname)
         unless result
-          if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
+          if @notfound[fqname] && Puppet[:ignoremissingtypes]
             # do not try to autoload if we already tried and it wasn't conclusive
             # as this is a time consuming operation. Warn the user.
             # Check first if debugging is on since the call to debug_once is expensive
@@ -204,7 +206,7 @@ class Puppet::Resource::TypeCollection
           else
             fqname = munge_name(fqname)
             result = loader.try_load_fqname(type, fqname)
-            @notfound[ fqname ] = result.nil?
+            @notfound[fqname] = result.nil?
           end
         end
         result
@@ -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?
@@ -141,7 +147,7 @@ class Puppet::Resource
 
   def self.value_to_json_data(value)
     if value.is_a?(Array)
-      value.map{|v| value_to_json_data(v) }
+      value.map { |v| value_to_json_data(v) }
     elsif value.is_a?(Hash)
       result = {}
       value.each_pair { |k, v| result[value_to_json_data(k)] = value_to_json_data(v) }
@@ -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
 
@@ -213,15 +220,15 @@ class Puppet::Resource
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
-    parameters.each { |p,v| yield p, v }
+    parameters.each { |p, v| yield p, v }
   end
 
   def include?(parameter)
-    super || parameters.keys.include?( parameter_name(parameter) )
+    super || parameters.keys.include?(parameter_name(parameter))
   end
 
   %w{exported virtual strict}.each do |m|
-    define_method(m+"?") do
+    define_method(m + "?") do
       self.send(m)
     end
   end
@@ -275,9 +282,10 @@ class Puppet::Resource
       @title = src.title
 
       src.to_hash.each do |p, v|
-        if v.is_a?(Puppet::Resource)
+        case v
+        when Puppet::Resource
           v = v.copy_as_resource
-        elsif v.is_a?(Array)
+        when Array
           # flatten resource references arrays
           v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
           v = v.collect do |av|
@@ -291,10 +299,10 @@ 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 }
+                             _("Did you mean (%{type}, %{title}) ?") %
+                             { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
       end
 
       # In order to avoid an expensive search of 'known_resource_types" and
@@ -321,6 +329,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
 
@@ -436,18 +445,20 @@ class Puppet::Resource
   def to_hierayaml
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+    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
 
+    # rubocop:disable Lint/FormatParameterMismatch
     attributes = attr.collect { |k|
       v = parameters[k]
       "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
+    # rubocop:enable Lint/FormatParameterMismatch
 
     "  %s:\n%s" % [self.title, attributes]
   end
@@ -462,7 +473,7 @@ class Puppet::Resource
 
     res = {}
     res['ensure'] = value if value
-    res.merge!(Hash[params.sort])
+    res.merge!(params.sort.to_h)
 
     return { h['title'] => res }
   end
@@ -471,20 +482,22 @@ class Puppet::Resource
   def to_manifest
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+    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
 
+    # rubocop:disable Lint/FormatParameterMismatch
     attributes = attr.collect { |k|
       v = parameters[k]
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
+    # rubocop:enable Lint/FormatParameterMismatch
 
-    escaped = self.title.gsub(/'/,"\\\\'")
+    escaped = self.title.gsub(/'/, "\\\\'")
     "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes]
   end
 
@@ -495,8 +508,8 @@ class Puppet::Resource
   # Convert our resource to a RAL resource instance. Creates component
   # instances for resource types that are not of a compilable_type kind. In case
   # the resource doesn’t exist and it’s compilable_type kind, raise an error.
-  # There are certain cases where a resource won't be in a catalog, such as 
-  # when we create a resource directly by using Puppet::Resource.new(...), so we 
+  # There are certain cases where a resource won't be in a catalog, such as
+  # when we create a resource directly by using Puppet::Resource.new(...), so we
   # must check its kind before deciding whether the catalog format is of an older
   # version or not.
   def to_ral
@@ -505,7 +518,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
@@ -517,11 +530,11 @@ class Puppet::Resource
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
-    [ type, title ].join('/')
+    [type, title].join('/')
   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,15 +587,14 @@ 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            ]
+       argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [$1, $2]
     elsif argtitle.nil? && argtype.is_a?(String) &&
-          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 }
+          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 } # rubocop:disable Lint/ElseLayout
     end
   end
   private_class_method :extract_type_and_title
@@ -590,6 +602,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
@@ -632,9 +645,9 @@ class Puppet::Resource
     type = resource_type
     if type.respond_to?(:title_patterns) && !type.title_patterns.nil?
       type.title_patterns.each do |regexp, symbols_and_lambdas|
-        captures = regexp.match(title.to_s)  
+        captures = regexp.match(title.to_s)
         if captures
-          symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
+          symbols_and_lambdas.zip(captures[1..]).each do |symbol_and_lambda, capture|
             symbol, proc = symbol_and_lambda
             # Many types pass "identity" as the proc; we might as well give
             # them a shortcut to delivering that without the extra cost.

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

data/lib/puppet/scheduler/scheduler.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 module Puppet::Scheduler
   class Scheduler
-    def initialize(timer=Puppet::Scheduler::Timer.new)
+    def initialize(timer = Puppet::Scheduler::Timer.new)
       @timer = timer
     end
 

data/lib/puppet/scheduler/splay_job.rb

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

data/lib/puppet/scheduler/timer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Scheduler
   class Timer
     def wait_for(seconds)

data/lib/puppet/scheduler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Scheduler
   require_relative 'scheduler/job'
   require_relative 'scheduler/splay_job'
@@ -7,7 +8,7 @@ module Puppet::Scheduler
 
   module_function
 
-  def create_job(interval, splay=false, splay_limit=0, &block)
+  def create_job(interval, splay = false, splay_limit = 0, &block)
     if splay
       Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
     else

data/lib/puppet/settings/alias_setting.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Puppet::Settings::AliasSetting
   attr_reader :name, :alias_name
 

data/lib/puppet/settings/array_setting.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
 
+class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
   def type
     :array
   end

data/lib/puppet/settings/autosign_setting.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/settings/base_setting'
 
 # A specialization of the file setting to allow boolean values.
@@ -8,7 +9,6 @@ require_relative '../../puppet/settings/base_setting'
 #
 # @api private
 class Puppet::Settings::AutosignSetting < Puppet::Settings::FileSetting
-
   def munge(value)
     if ['true', true].include? value
       true

data/lib/puppet/settings/base_setting.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'set'
 require_relative '../../puppet/settings/errors'
 
@@ -35,14 +36,15 @@ class Puppet::Settings::BaseSetting
   # @param value [Symbol] One of {HOOK_TYPES}
   def call_hook=(value)
     if value.nil?
-      #TRANSLATORS ':%{name}', ':call_hook', and ':on_write_only' should not be translated
+      # TRANSLATORS ':%{name}', ':call_hook', and ':on_write_only' should not be translated
       Puppet.warning _("Setting :%{name} :call_hook is nil, defaulting to :on_write_only") % { name: name }
       value = :on_write_only
     end
     unless HOOK_TYPES.include?(value)
-      #TRANSLATORS 'call_hook' is a Puppet option name and should not be translated
+      # TRANSLATORS 'call_hook' is a Puppet option name and should not be translated
       raise ArgumentError, _("Invalid option %{value} for call_hook") % { value: value }
     end
+
     @call_hook = value
   end
 
@@ -94,12 +96,12 @@ class Puppet::Settings::BaseSetting
     # other warnings
     @name = args[:name] if args.include? :name
 
-    #set the default value for call_hook
+    # set the default value for call_hook
     @call_hook = :on_write_only if args[:hook] and not args[:call_hook]
     @has_hook = false
 
     if args[:call_hook] and not args[:hook]
-      #TRANSLATORS ':call_hook' and ':hook' are specific setting names and should not be translated
+      # TRANSLATORS ':call_hook' and ':hook' are specific setting names and should not be translated
       raise ArgumentError, _("Cannot reference :call_hook for :%{name} if no :hook is defined") % { name: @name }
     end
 
@@ -107,7 +109,7 @@ class Puppet::Settings::BaseSetting
       method = param.to_s + "="
       unless self.respond_to? method
         raise ArgumentError, _("%{class_name} (setting '%{setting}') does not accept %{parameter}") %
-            { class_name: self.class, setting: args[:name], parameter: param }
+                             { class_name: self.class, setting: args[:name], parameter: param }
       end
 
       self.send(method, value)
@@ -128,6 +130,7 @@ class Puppet::Settings::BaseSetting
   # short name for the element
   def short=(value)
     raise ArgumentError, _("Short names can only be one character.") if value.to_s.length != 1
+
     @short = value.to_s
   end
 
@@ -142,6 +145,7 @@ class Puppet::Settings::BaseSetting
       default_value = @default
     end
     return default_value unless check_application_defaults_first
+
     return @settings.value(name, :application_defaults, true) || default_value
   end
 
@@ -195,9 +199,9 @@ class Puppet::Settings::BaseSetting
 
   def deprecated=(deprecation)
     unless [:completely, :allowed_on_commandline].include?(deprecation)
-      #TRANSLATORS 'deprecated' is a Puppet setting and ':completely' and ':allowed_on_commandline' are possible values and should not be translated
+      # TRANSLATORS 'deprecated' is a Puppet setting and ':completely' and ':allowed_on_commandline' are possible values and should not be translated
       raise ArgumentError, _("Unsupported deprecated value '%{deprecation}'.") % { deprecation: deprecation } +
-          ' ' + _("Supported values for deprecated are ':completely' or ':allowed_on_commandline'")
+                           ' ' + _("Supported values for deprecated are ':completely' or ':allowed_on_commandline'")
     end
     @deprecated = deprecation
   end