puppet 8.5.0-x86-mingw32 → 8.6.0-x86-mingw32

data/lib/puppet/network/http/api/indirected_routes.rb

@@ -36,7 +36,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     indirection, method, key, params = uri2indirection(request.method, request.path, request.params)
     certificate = request.client_cert
 
-    if !indirection.allow_remote_requests?
+    unless indirection.allow_remote_requests?
       # TODO: should we tell the user we found an indirection but it doesn't
       # allow remote requests, or just pretend there's no handler at all? what
       # are the security implications for the former?
@@ -62,9 +62,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     environment = params.delete(:environment)
 
     if indirection_name !~ /^\w+$/
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("The indirection name must be purely alphanumeric, not '%{indirection_name}'") % { indirection_name: indirection_name }
-      )
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The indirection name must be purely alphanumeric, not '%{indirection_name}'") % { indirection_name: indirection_name }
     end
 
     # this also depluralizes the indirection_name if it is a search
@@ -73,29 +71,23 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     # check whether this indirection matches the prefix and version in the
     # request
     if url_prefix != IndirectionType.url_prefix_for(indirection_name)
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("Indirection '%{indirection_name}' does not match url prefix '%{url_prefix}'") % { indirection_name: indirection_name, url_prefix: url_prefix }
-      )
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("Indirection '%{indirection_name}' does not match url prefix '%{url_prefix}'") % { indirection_name: indirection_name, url_prefix: url_prefix }
     end
 
     indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
-    if !indirection
+    unless indirection
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
         _("Could not find indirection '%{indirection_name}'") % { indirection_name: indirection_name },
         Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND
       )
     end
 
-    if !environment
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("An environment parameter must be specified")
-      )
+    unless environment
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("An environment parameter must be specified")
     end
 
-    if !Puppet::Node::Environment.valid_name?(environment)
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment }
-      )
+    unless Puppet::Node::Environment.valid_name?(environment)
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment }
     end
 
     configured_environment = Puppet.lookup(:environments).get(environment)
@@ -105,17 +97,13 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     end
 
     if configured_environment.nil? && indirection.terminus.require_environment?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        _("Could not find environment '%{environment}'") % { environment: environment }
-      )
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError, _("Could not find environment '%{environment}'") % { environment: environment }
     end
 
     params.delete(:bucket_path)
 
     if key == "" or key.nil?
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("No request key specified in %{uri}") % { uri: uri }
-      )
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("No request key specified in %{uri}") % { uri: uri }
     end
 
     [indirection, method, key, params]
@@ -196,19 +184,17 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
   def first_response_formatter_for(model, request, key, &block)
     formats = accepted_response_formatters_for(model, request)
     formatter = formats.find do |format|
-      begin
-        yield format
-        true
-      rescue Puppet::Network::FormatHandler::FormatError => err
-        msg = _("Failed to serialize %{model} for '%{key}': %{detail}") %
-              { model: model, key: key, detail: err }
-        if Puppet[:allow_pson_serialization]
-          Puppet.warning(msg)
-        else
-          raise Puppet::Network::FormatHandler::FormatError.new(msg)
-        end
-        false
+      yield format
+      true
+    rescue Puppet::Network::FormatHandler::FormatError => err
+      msg = _("Failed to serialize %{model} for '%{key}': %{detail}") %
+            { model: model, key: key, detail: err }
+      if Puppet[:allow_pson_serialization]
+        Puppet.warning(msg)
+      else
+        raise Puppet::Network::FormatHandler::FormatError, msg
       end
+      false
     end
 
     return formatter if formatter
@@ -239,9 +225,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       begin
         return model_class.convert_from(formatter.name.to_s, data)
       rescue => e
-        raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-          _("The request body is invalid: %{message}") % { message: e.message }
-        )
+        raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The request body is invalid: %{message}") % { message: e.message }
       end
     end
 
@@ -253,22 +237,18 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
   end
 
   def indirection_method(http_method, indirection)
-    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new(
-      _("No support for http method %{http_method}") % { http_method: http_method }
-    ) unless METHOD_MAP[http_method]
+    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError, _("No support for http method %{http_method}") % { http_method: http_method } unless METHOD_MAP[http_method]
 
     method = METHOD_MAP[http_method][plurality(indirection)]
     unless method
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("No support for plurality %{indirection} for %{http_method} operations") % { indirection: plurality(indirection), http_method: http_method }
-      )
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("No support for plurality %{indirection} for %{http_method} operations") % { indirection: plurality(indirection), http_method: http_method }
     end
 
     method
   end
 
   def self.pluralize(indirection)
-    return(indirection == "status" ? "statuses" : indirection + "s")
+    (indirection == "status" ? "statuses" : indirection + "s")
   end
   private_class_method :pluralize
 

data/lib/puppet/network/http/api/server/v3.rb

@@ -28,7 +28,7 @@ module Puppet
                            .get(wrap { Environments.new(Puppet.lookup(:environments)) })
 
             def self.routes
-              Puppet::Network::HTTP::Route.path(%r{v3})
+              Puppet::Network::HTTP::Route.path(/v3/)
                                           .any
                                           .chain(ENVIRONMENTS, INDIRECTED)
             end

data/lib/puppet/network/http/connection.rb

@@ -245,7 +245,7 @@ class Puppet::Network::HTTP::Connection
   end
 
   def to_url(path)
-    if path =~ /^https?:\/\//
+    if path =~ %r{^https?://}
       # The old Connection class accepts a URL as the request path, and sends
       # it in "absolute-form" in the request line, e.g. GET https://puppet:8140/.
       # See https://httpwg.org/specs/rfc7230.html#absolute-form. It just so happens

data/lib/puppet/network/http/handler.rb

@@ -13,7 +13,7 @@ module Puppet::Network::HTTP::Handler
 
   # These shouldn't be allowed to be set by clients
   # in the query string, for security reasons.
-  DISALLOWED_KEYS = ["node", "ip"]
+  DISALLOWED_KEYS = %w[node ip]
 
   def register(routes)
     # There's got to be a simpler way to do this, right?
@@ -21,7 +21,7 @@ module Puppet::Network::HTTP::Handler
     routes.each { |r| dupes[r.path_matcher] = (dupes[r.path_matcher] || 0) + 1 }
     dupes = dupes.filter_map { |pm, count| pm if count > 1 }
     if dupes.count > 0
-      raise ArgumentError, _("Given multiple routes with identical path regexes: %{regexes}") % { regexes: dupes.map { |rgx| rgx.inspect }.join(', ') }
+      raise ArgumentError, _("Given multiple routes with identical path regexes: %{regexes}") % { regexes: dupes.map(&:inspect).join(', ') }
     end
 
     @routes = routes
@@ -107,14 +107,10 @@ module Puppet::Network::HTTP::Handler
 
   def find_route_or_raise(request)
     route = @routes.find { |r| r.matches?(request) }
-    if route
-      return route
-    else
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        _("No route for %{request} %{path}") % { request: request.method, path: request.path },
-        HANDLER_NOT_FOUND
-      )
-    end
+    route || raise(Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
+                     _("No route for %{request} %{path}") % { request: request.method, path: request.path },
+                     HANDLER_NOT_FOUND
+                   ))
   end
 
   def set_puppet_version_header(response)
@@ -178,7 +174,7 @@ module Puppet::Network::HTTP::Handler
   end
 
   def allowed_parameter?(name)
-    not (name.nil? || name.empty? || DISALLOWED_KEYS.include?(name))
+    !(name.nil? || name.empty? || DISALLOWED_KEYS.include?(name))
   end
 
   def parse_parameter_value(param, value)
@@ -205,7 +201,7 @@ module Puppet::Network::HTTP::Handler
   end
 
   def configure_profiler(request_headers, request_params)
-    if (request_headers.has_key?(Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase) or Puppet[:profile])
+    if request_headers.has_key?(Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase) or Puppet[:profile]
       Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:info), request_params.object_id))
     end
   end

data/lib/puppet/network/http/request.rb

@@ -78,6 +78,6 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
 
   def valid_network_format?(format)
     # YAML in network requests is not supported. See http://links.puppet.com/deprecate_yaml_on_network
-    format != nil && format.name != :yaml && format.name != :b64_zlib_yaml
+    !format.nil? && format.name != :yaml && format.name != :b64_zlib_yaml
   end
 end

data/lib/puppet/network/http/route.rb

@@ -28,39 +28,39 @@ class Puppet::Network::HTTP::Route
 
   def get(*handlers)
     @method_handlers[:GET] = handlers
-    return self
+    self
   end
 
   def head(*handlers)
     @method_handlers[:HEAD] = handlers
-    return self
+    self
   end
 
   def options(*handlers)
     @method_handlers[:OPTIONS] = handlers
-    return self
+    self
   end
 
   def post(*handlers)
     @method_handlers[:POST] = handlers
-    return self
+    self
   end
 
   def put(*handlers)
     @method_handlers[:PUT] = handlers
-    return self
+    self
   end
 
   def delete(*handlers)
     @method_handlers[:DELETE] = handlers
-    return self
+    self
   end
 
   def any(*handlers)
     @method_handlers.each do |method, _registered_handlers|
       @method_handlers[method] = handlers
     end
-    return self
+    self
   end
 
   def chain(*routes)
@@ -69,14 +69,14 @@ class Puppet::Network::HTTP::Route
   end
 
   def matches?(request)
-    Puppet.debug { "Evaluating match for #{self.inspect}" }
+    Puppet.debug { "Evaluating match for #{inspect}" }
     if match(request.routing_path)
       return true
     else
       Puppet.debug { "Did not match path (#{request.routing_path.inspect})" }
     end
 
-    return false
+    false
   end
 
   def process(request, response)

data/lib/puppet/node/environment.rb

@@ -87,10 +87,10 @@ class Puppet::Node::Environment
   #   parameters (:modulepath, :manifest, :config_version)
   # @return [Puppet::Node::Environment]
   def override_with(env_params)
-    return self.class.create(name,
-                             env_params[:modulepath] || modulepath,
-                             env_params[:manifest] || manifest,
-                             env_params[:config_version] || config_version)
+    self.class.create(name,
+                      env_params[:modulepath] || modulepath,
+                      env_params[:manifest] || manifest,
+                      env_params[:config_version] || config_version)
   end
 
   # Creates a new Puppet::Node::Environment instance, overriding :manifest,
@@ -118,7 +118,7 @@ class Puppet::Node::Environment
 
     overrides.empty? ?
       self :
-      self.override_with(overrides)
+      override_with(overrides)
   end
 
   # @param [String] name Environment name to check for valid syntax.
@@ -220,7 +220,7 @@ class Puppet::Node::Environment
   #   Puppet[:default_manifest].
   # @api private
   def conflicting_manifest_settings?
-    return false if !Puppet[:disable_per_environment_manifest]
+    return false unless Puppet[:disable_per_environment_manifest]
 
     original_manifest = configuration.raw_setting(:manifest)
     !original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
@@ -279,7 +279,7 @@ class Puppet::Node::Environment
   # @param param [String, Symbol] The environment setting to look up
   # @return [Object] The resolved setting value
   def [](param)
-    Puppet.settings.value(param, self.name)
+    Puppet.settings.value(param, name)
   end
 
   # @api public
@@ -358,7 +358,7 @@ class Puppet::Node::Environment
           next unless Puppet::Module.is_module_directory?(name, path)
 
           warn_about_mistaken_path(path, name)
-          if not seen_modules[name]
+          unless seen_modules[name]
             module_references << { :name => name, :path => File.join(path, name) }
             seen_modules[name] = true
           end
@@ -366,12 +366,10 @@ class Puppet::Node::Environment
       end
 
       @modules = module_references.filter_map do |reference|
-        begin
-          Puppet::Module.new(reference[:name], reference[:path], self)
-        rescue Puppet::Module::Error => e
-          Puppet.log_exception(e)
-          nil
-        end
+        Puppet::Module.new(reference[:name], reference[:path], self)
+      rescue Puppet::Module::Error => e
+        Puppet.log_exception(e)
+        nil
       end
     end
     @modules
@@ -499,7 +497,7 @@ class Puppet::Node::Environment
   #
   def check_for_reparse
     @lock.synchronize do
-      if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
+      if Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?
         @parsed_code = nil
         @known_resource_types = nil
       end
@@ -520,7 +518,7 @@ class Puppet::Node::Environment
 
   # @api public
   def inspect
-    %Q{<#{self.class}:#{self.object_id} @name="#{name}" @manifest="#{manifest}" @modulepath="#{full_modulepath.join(":")}" >}
+    %Q(<#{self.class}:#{object_id} @name="#{name}" @manifest="#{manifest}" @modulepath="#{full_modulepath.join(':')}" >)
   end
 
   # @return [Symbol] The `name` value, cast to a string, then cast to a symbol.
@@ -539,10 +537,10 @@ class Puppet::Node::Environment
   end
 
   def ==(other)
-    return true if other.is_a?(Puppet::Node::Environment) &&
-                   self.name == other.name &&
-                   self.full_modulepath == other.full_modulepath &&
-                   self.manifest == other.manifest
+    true if other.is_a?(Puppet::Node::Environment) &&
+            name == other.name &&
+            full_modulepath == other.full_modulepath &&
+            manifest == other.manifest
   end
 
   alias eql? ==
@@ -589,7 +587,7 @@ class Puppet::Node::Environment
       parser.string = @parsed_code
       parser.parse
     else
-      file = self.manifest
+      file = manifest
       # if the manifest file is a reference to a directory, parse and combine
       # all .pp files in that directory
       if file == NO_MANIFEST
@@ -610,7 +608,7 @@ class Puppet::Node::Environment
     end
   rescue Puppet::ParseErrorWithIssue => detail
     @known_resource_types.parse_failed = true
-    detail.environment = self.name
+    detail.environment = name
     raise
   rescue => detail
     @known_resource_types.parse_failed = true
@@ -625,7 +623,7 @@ class Puppet::Node::Environment
   #
   # @return [Puppet::Parser::AST::Hostclass]
   def empty_parse_result
-    return Puppet::Parser::AST::Hostclass.new('')
+    Puppet::Parser::AST::Hostclass.new('')
   end
 
   # A None subclass to make it easier to trace the NONE environment when debugging.

data/lib/puppet/node/facts.rb

@@ -78,7 +78,7 @@ class Puppet::Node::Facts
   end
 
   def ==(other)
-    return false unless self.name == other.name
+    return false unless name == other.name
 
     values == other.values
   end

data/lib/puppet/node.rb

@@ -48,7 +48,7 @@ class Puppet::Node
       'environment' => environment.name.to_s,
     }
     result['classes'] = classes unless classes.empty?
-    serialized_params = self.serializable_parameters
+    serialized_params = serializable_parameters
     result['parameters'] = serialized_params unless serialized_params.empty?
     result
   end
@@ -142,7 +142,7 @@ class Puppet::Node
       raise error
     end
 
-    if !@facts.nil?
+    unless @facts.nil?
       @facts.sanitize
       # facts should never modify the environment parameter
       orig_param_env = @parameters[ENVIRONMENT]
@@ -174,7 +174,7 @@ class Puppet::Node
 
   def add_server_facts(facts)
     # Append the current environment to the list of server facts
-    @server_facts = facts.merge({ "environment" => self.environment.name.to_s })
+    @server_facts = facts.merge({ "environment" => environment.name.to_s })
 
     # Merge the server facts into the parameters for the node
     merge(facts)
@@ -228,7 +228,7 @@ class Puppet::Node
     if trusted_param
       # Blows up if it is a parameter as it will be set as $trusted by the compiler as if it was a variable
       @parameters.delete('trusted')
-      unless trusted_param.is_a?(Hash) && %w{authenticated certname extensions}.all? { |key| trusted_param.has_key?(key) }
+      unless trusted_param.is_a?(Hash) && %w[authenticated certname extensions].all? { |key| trusted_param.has_key?(key) }
         # trusted is some kind of garbage, do not resurrect
         trusted_param = nil
       end
@@ -245,7 +245,7 @@ class Puppet::Node
     #
     # Note that trusted_data should be a hash, but (2) and (4) are not
     # hashes, so we to_h at the end
-    if !trusted_data
+    unless trusted_data
       trusted = Puppet.lookup(:trusted_information) do
         trusted_param || Puppet::Context::TrustedInformation.local(self)
       end

data/lib/puppet/pal/json_catalog_encoder.rb

@@ -67,7 +67,7 @@ class JsonCatalogEncoder
   # @api private
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def possibly_filtered_catalog
-    @filtered ||= (exclude_virtual ? catalog.filter { |r| r.virtual? } : catalog)
+    @filtered ||= (exclude_virtual ? catalog.filter(&:virtual?) : catalog)
   end
   private :possibly_filtered_catalog
   # rubocop:enable Naming/MemoizedInstanceVariableName

data/lib/puppet/pal/pal_impl.rb

@@ -443,64 +443,62 @@ module Pal
 
     # TRANSLATORS, the string "For puppet PAL" is not user facing
     Puppet.override({ :current_environment => apply_environment }, "For puppet PAL") do
-      begin
-        node.sanitize()
-        compiler = create_internal_compiler(internal_compiler_class, node)
-
-        case internal_compiler_class
-        when :script
-          pal_compiler = ScriptCompiler.new(compiler)
-          overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
-        when :catalog
-          pal_compiler = CatalogCompiler.new(compiler)
-          overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
-        end
+      node.sanitize()
+      compiler = create_internal_compiler(internal_compiler_class, node)
+
+      case internal_compiler_class
+      when :script
+        pal_compiler = ScriptCompiler.new(compiler)
+        overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
+      when :catalog
+        pal_compiler = CatalogCompiler.new(compiler)
+        overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
+      end
 
-        # When scripting the trusted data are always local; default is to set them anyway
-        # When compiling for a catalog, the catalog compiler does this
-        if set_local_facts
-          compiler.topscope.set_trusted(node.trusted_data)
+      # When scripting the trusted data are always local; default is to set them anyway
+      # When compiling for a catalog, the catalog compiler does this
+      if set_local_facts
+        compiler.topscope.set_trusted(node.trusted_data)
 
-          # Server facts are always about the local node's version etc.
-          compiler.topscope.set_server_facts(node.server_facts)
+        # Server facts are always about the local node's version etc.
+        compiler.topscope.set_server_facts(node.server_facts)
 
-          # Set $facts for the node running the script
-          facts_hash = node.facts.nil? ? {} : node.facts.values
-          compiler.topscope.set_facts(facts_hash)
+        # Set $facts for the node running the script
+        facts_hash = node.facts.nil? ? {} : node.facts.values
+        compiler.topscope.set_facts(facts_hash)
 
-          # create the $settings:: variables
-          compiler.topscope.merge_settings(node.environment.name, false)
-        end
+        # create the $settings:: variables
+        compiler.topscope.merge_settings(node.environment.name, false)
+      end
 
-        # Make compiler available to Puppet#lookup and injection in functions
-        # 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|
-            # 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.
-            pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
-            variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
-
-            # Merge together target variables and plan variables. This will also shadow any
-            # collisions with facts and emit a warning.
-            topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
-
-            add_variables(compiler.topscope, topscope_vars)
-            # wrap the internal compiler to prevent it from leaking in the PAL API
-            if block_given?
-              yield(pal_compiler)
-            end
+      # Make compiler available to Puppet#lookup and injection in functions
+      # 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|
+          # 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.
+          pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
+          variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
+
+          # Merge together target variables and plan variables. This will also shadow any
+          # collisions with facts and emit a warning.
+          topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
+
+          add_variables(compiler.topscope, topscope_vars)
+          # wrap the internal compiler to prevent it from leaking in the PAL API
+          if block_given?
+            yield(pal_compiler)
           end
         end
-      rescue Puppet::Error
-        # already logged and handled by the compiler, including Puppet::ParseErrorWithIssue
-        raise
-      rescue => detail
-        Puppet.log_exception(detail)
-        raise
       end
+    rescue Puppet::Error
+      # already logged and handled by the compiler, including Puppet::ParseErrorWithIssue
+      raise
+    rescue => detail
+      Puppet.log_exception(detail)
+      raise
     end
   end
   private_class_method :main

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(&:format).join("\n")
       end
       false
     end

data/lib/puppet/pal/task_signature.rb

@@ -37,7 +37,7 @@ module Pal
                 else
                   tm.describe_struct_signature(params_type, args_hash)
                     .flatten
-                    .map { |e| e.format }
+                    .map(&:format)
                     .join("\n")
                 end
         yield "Task #{@task.name}:\n#{error}"

data/lib/puppet/parameter/package_options.rb

@@ -28,6 +28,6 @@ class Puppet::Parameter::PackageOptions < Puppet::Parameter
 
   # @api private
   def quote(value)
-    value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+    value.include?(' ') ? %Q("#{value.gsub(/"/, '\"')}") : value
   end
 end

data/lib/puppet/parameter/value.rb

@@ -57,9 +57,9 @@ class Puppet::Parameter::Value
   #
   def match?(value)
     if regex?
-      return true if name =~ value.to_s
+      true if name =~ value.to_s
     else
-      return(name == convert(value) ? true : @aliases.include?(convert(value)))
+      (name == convert(value) ? true : @aliases.include?(convert(value)))
     end
   end