puppet 8.4.0-x64-mingw32 → 8.5.1-x64-mingw32

data/lib/puppet/network/format_handler.rb

@@ -18,9 +18,9 @@ module Puppet::Network::FormatHandler
     instance
   end
 
-  def self.create_serialized_formats(name,options = {},&block)
+  def self.create_serialized_formats(name, options = {}, &block)
     ["application/x-#{name}", "application/#{name}", "text/x-#{name}", "text/#{name}"].each { |mime_type|
-      create name, {:mime => mime_type}.update(options), &block
+      create name, { :mime => mime_type }.update(options), &block
     }
   end
 
@@ -66,7 +66,7 @@ module Puppet::Network::FormatHandler
     end
 
     if out.nil?
-      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % {format: format}
+      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % { format: format }
     end
 
     out.name
@@ -86,13 +86,13 @@ module Puppet::Network::FormatHandler
   def self.most_suitable_formats_for(accepted, supported)
     accepted.collect do |format|
       format.to_s.sub(/;q=.*$/, '')
-    end.collect do |format|
+    end.filter_map do |format|
       if format == ALL_MEDIA_TYPES
         supported.first
       else
         format_to_canonical_name_or_nil(format)
       end
-    end.compact.find_all do |format|
+    end.find_all do |format|
       supported.include?(format)
     end.collect do |format|
       format_for(format)

data/lib/puppet/network/format_support.rb

@@ -138,4 +138,3 @@ module Puppet::Network::FormatSupport
   # If the method exists it will be called from to_msgpack and other serialization methods.
   # @return [Hash]
 end
-

data/lib/puppet/network/formats.rb

@@ -159,11 +159,11 @@ Puppet::Network::FormatHandler.create(:console,
     # Simple hash to table
     if datum.is_a?(Hash) && datum.keys.all? { |x| x.is_a?(String) || x.is_a?(Numeric) }
       output = ''.dup
-      column_a = datum.empty? ? 2 : datum.map{ |k,_v| k.to_s.length }.max + 2
-      datum.sort_by { |k,_v| k.to_s } .each do |key, value|
+      column_a = datum.empty? ? 2 : datum.map { |k, _v| k.to_s.length }.max + 2
+      datum.sort_by { |k, _v| k.to_s }.each do |key, value|
         output << key.to_s.ljust(column_a)
         output << json.render(value)
-          .chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
+                      .chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
         output << "\n"
       end
       return output
@@ -193,11 +193,12 @@ Puppet::Network::FormatHandler.create(:flat,
                                       :weight => 0) do
   def flatten_hash(hash)
     hash.each_with_object({}) do |(k, v), h|
-      if v.is_a? Hash
+      case v
+      when Hash
         flatten_hash(v).map do |h_k, h_v|
           h["#{k}.#{h_k}"] = h_v
         end
-      elsif v.is_a? Array
+      when Array
         v.each_with_index do |el, i|
           if el.is_a? Hash
             flatten_hash(el).map do |el_k, el_v|
@@ -214,7 +215,7 @@ Puppet::Network::FormatHandler.create(:flat,
   end
 
   def flatten_array(array)
-    a={}
+    a = {}
     array.each_with_index do |el, i|
       if el.is_a? Hash
         flatten_hash(el).map do |el_k, el_v|
@@ -240,10 +241,11 @@ Puppet::Network::FormatHandler.create(:flat,
     return datum if datum.is_a?(String) || datum.is_a?(Numeric)
 
     # Simple hash
-    if datum.is_a?(Hash)
+    case datum
+    when Hash
       data = flatten_hash(datum)
       return construct_output(data)
-    elsif datum.is_a?(Array)
+    when Array
       data = flatten_array(datum)
       return construct_output(data)
     end
@@ -257,13 +259,13 @@ end
 
 Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.puppet.rich+json', charset: Encoding::UTF_8, weight: 30) do
   def intern(klass, text)
-    Puppet.override({:rich_data => true}) do
+    Puppet.override({ :rich_data => true }) do
       data_to_instance(klass, Puppet::Util::Json.load(text))
     end
   end
 
   def intern_multiple(klass, text)
-    Puppet.override({:rich_data => true}) do
+    Puppet.override({ :rich_data => true }) do
       Puppet::Util::Json.load(text).collect do |data|
         data_to_instance(klass, data)
       end
@@ -271,19 +273,19 @@ Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.pu
   end
 
   def render(instance)
-    Puppet.override({:rich_data => true}) do
+    Puppet.override({ :rich_data => true }) do
       instance.to_json
     end
   end
 
   def render_multiple(instances)
-    Puppet.override({:rich_data => true}) do
+    Puppet.override({ :rich_data => true }) do
       Puppet::Util::Json.dump(instances)
     end
   end
 
   def data_to_instance(klass, data)
-    Puppet.override({:rich_data => true}) do
+    Puppet.override({ :rich_data => true }) do
       return data if data.is_a?(klass)
 
       klass.from_data_hash(data)

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

@@ -57,13 +57,14 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
   def uri2indirection(http_method, uri, params)
     # the first field is always nil because of the leading slash,
-    indirection_type, version, indirection_name, key = uri.split("/", 5)[1..-1]
+    indirection_type, version, indirection_name, key = uri.split("/", 5)[1..]
     url_prefix = "/#{indirection_type}/#{version}"
     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 })
+        _("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,24 +74,28 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     # 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 })
+        _("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
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
         _("Could not find indirection '%{indirection_name}'") % { indirection_name: indirection_name },
-        Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
+        Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND
+      )
     end
 
     if !environment
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("An environment parameter must be specified"))
+        _("An environment parameter must be specified")
+      )
     end
 
-    if ! Puppet::Node::Environment.valid_name?(environment)
+    if !Puppet::Node::Environment.valid_name?(environment)
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment })
+        _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment }
+      )
     end
 
     configured_environment = Puppet.lookup(:environments).get(environment)
@@ -101,14 +106,16 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
     if configured_environment.nil? && indirection.terminus.require_environment?
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        _("Could not find environment '%{environment}'") % { environment: environment })
+        _("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 })
+        _("No request key specified in %{uri}") % { uri: uri }
+      )
     end
 
     [indirection, method, key, params]
@@ -194,7 +201,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
         true
       rescue Puppet::Network::FormatHandler::FormatError => err
         msg = _("Failed to serialize %{model} for '%{key}': %{detail}") %
-        {model: model, key: key, detail: err}
+              { model: model, key: key, detail: err }
         if Puppet[:allow_pson_serialization]
           Puppet.warning(msg)
         else
@@ -208,7 +215,8 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
     raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
       _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats.map(&:mime).join(', ') },
-      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT
+    )
   end
 
   # Return an array of response formatters that the client accepts and
@@ -232,24 +240,28 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
         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 })
+          _("The request body is invalid: %{message}") % { message: e.message }
+        )
       end
     end
 
     # TRANSLATORS "mime-type" is a keyword and should not be translated
     raise Puppet::Network::HTTP::Error::HTTPUnsupportedMediaTypeError.new(
       _("Client sent a mime-type (%{header}) that doesn't correspond to a format we support") % { header: request.headers['content-type'] },
-      Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE)
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE
+    )
   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]
+      _("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 })
+        _("No support for plurality %{indirection} for %{http_method} operations") % { indirection: plurality(indirection), http_method: http_method }
+      )
     end
 
     method

data/lib/puppet/network/http/api/master/v3/environments.rb

@@ -2,4 +2,3 @@
 
 require_relative '../../../../../../puppet/network/http/api/master'
 require_relative '../../../../../../puppet/network/http/api/server/v3/environments'
-

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

@@ -2,4 +2,3 @@
 
 require_relative '../../../../../puppet/network/http/api/master'
 require_relative '../../../../../puppet/network/http/api/server/v3'
-

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

@@ -21,7 +21,7 @@ module Puppet
                     Puppet::Util::Json
                       .dump({
                               "search_paths" => @env_loader.search_paths,
-                              "environments" => Hash[@env_loader.list.collect do |env|
+                              "environments" => @env_loader.list.to_h do |env|
                                 [env.name, {
                                   "settings" => {
                                     "modulepath" => env.full_modulepath,
@@ -30,7 +30,7 @@ module Puppet
                                     "config_version" => env.config_version || '',
                                   }
                                 }]
-                              end]
+                              end
                             })
                   )
               end
@@ -52,4 +52,3 @@ module Puppet
     end
   end
 end
-

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

@@ -20,17 +20,17 @@ module Puppet
             end
 
             INDIRECTED = Puppet::Network::HTTP::Route
-                .path(/.*/)
-                .any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new } )
+                         .path(/.*/)
+                         .any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new })
 
             ENVIRONMENTS = Puppet::Network::HTTP::Route
-                .path(%r{^/environments$})
-                .get(wrap { Environments.new(Puppet.lookup(:environments)) } )
+                           .path(%r{^/environments$})
+                           .get(wrap { Environments.new(Puppet.lookup(:environments)) })
 
             def self.routes
               Puppet::Network::HTTP::Route.path(%r{v3})
-                  .any
-                  .chain(ENVIRONMENTS, INDIRECTED)
+                                          .any
+                                          .chain(ENVIRONMENTS, INDIRECTED)
             end
           end
         end

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

@@ -15,14 +15,14 @@ class Puppet::Network::HTTP::API
     Puppet::Network::HTTP::Route
       .path(/.*/)
       .any(lambda do |_req, _res|
-        raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Error: Invalid URL - Puppet expects requests that conform to the " +
-                                                                      "/puppet and /puppet-ca APIs.\n\n" +
-                                                                      "Note that Puppet 3 agents aren't compatible with this version; if you're " +
-                                                                      "running Puppet 3, you must either upgrade your agents to match the server " +
-                                                                      "or point them to a server running Puppet 3.\n\n" +
-                                                                      "Server Info:\n" +
-                                                                      "  Puppet version: #{Puppet.version}\n" +
-                                                                      "  Supported /puppet API versions: #{Puppet::Network::HTTP::SERVER_URL_VERSIONS}\n",
+        raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Error: Invalid URL - Puppet expects requests that conform to the " \
+                                                                  "/puppet and /puppet-ca APIs.\n\n" \
+                                                                  "Note that Puppet 3 agents aren't compatible with this version; if you're " \
+                                                                  "running Puppet 3, you must either upgrade your agents to match the server " \
+                                                                  "or point them to a server running Puppet 3.\n\n" \
+                                                                  "Server Info:\n" \
+                                                                  "  Puppet version: #{Puppet.version}\n" \
+                                                                  "  Supported /puppet API versions: #{Puppet::Network::HTTP::SERVER_URL_VERSIONS}\n",
                                                                   Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
       end)
   end
@@ -30,9 +30,9 @@ class Puppet::Network::HTTP::API
   def self.server_routes
     server_prefix = Regexp.new("^#{Puppet::Network::HTTP::SERVER_URL_PREFIX}/")
     Puppet::Network::HTTP::Route.path(server_prefix)
-      .any
-      .chain(Puppet::Network::HTTP::API::Server::V3.routes,
-             Puppet::Network::HTTP::API.not_found)
+                                .any
+                                .chain(Puppet::Network::HTTP::API::Server::V3.routes,
+                                       Puppet::Network::HTTP::API.not_found)
   end
 
   def self.master_routes

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

@@ -3,7 +3,7 @@
 require_relative '../../../puppet/http'
 
 # This will be raised if too many redirects happen for a given HTTP request
-class Puppet::Network::HTTP::RedirectionLimitExceededException < Puppet::Error ; end
+class Puppet::Network::HTTP::RedirectionLimitExceededException < Puppet::Error; end
 
 # This class provides simple methods for issuing various types of HTTP
 # requests.  It's interface is intended to mirror Ruby's Net::HTTP
@@ -140,7 +140,7 @@ class Puppet::Network::HTTP::Connection
   # @param headers [Hash{String => String}]
   # @!macro common_options
   # @api public
-  def delete(path, headers = {'Depth' => 'Infinity'}, options = {})
+  def delete(path, headers = { 'Depth' => 'Infinity' }, options = {})
     headers ||= {}
     options[:ssl_context] ||= resolve_ssl_context
     options[:redirect_limit] ||= @redirect_limit
@@ -266,7 +266,7 @@ class Puppet::Network::HTTP::Connection
 
   def normalize_path(path)
     if path[0] == '/'
-      path[1..-1]
+      path[1..]
     else
       path
     end

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

@@ -15,7 +15,7 @@ module Puppet::Network::HTTP::Error
     end
 
     def to_json
-      Puppet::Util::Json.dump({:message => message, :issue_kind => @issue_kind})
+      Puppet::Util::Json.dump({ :message => message, :issue_kind => @issue_kind })
     end
   end
 
@@ -69,7 +69,7 @@ module Puppet::Network::HTTP::Error
     end
 
     def to_json
-      Puppet::Util::Json.dump({:message => message, :issue_kind => @issue_kind})
+      Puppet::Util::Json.dump({ :message => message, :issue_kind => @issue_kind })
     end
   end
 end

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

@@ -19,9 +19,9 @@ module Puppet::Network::HTTP::Handler
     # There's got to be a simpler way to do this, right?
     dupes = {}
     routes.each { |r| dupes[r.path_matcher] = (dupes[r.path_matcher] || 0) + 1 }
-    dupes = dupes.collect { |pm, count| pm if count > 1 }.compact
+    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 { |rgx| rgx.inspect }.join(', ') }
     end
 
     @routes = routes
@@ -112,7 +112,8 @@ module Puppet::Network::HTTP::Handler
     else
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
         _("No route for %{request} %{path}") % { request: request.method, path: request.path },
-        HANDLER_NOT_FOUND)
+        HANDLER_NOT_FOUND
+      )
     end
   end
 
@@ -170,10 +171,9 @@ module Puppet::Network::HTTP::Handler
   end
 
   def decode_params(params)
-    params.select { |key, _| allowed_parameter?(key) }.inject({}) do |result, ary|
+    params.select { |key, _| allowed_parameter?(key) }.each_with_object({}) do |ary, result|
       param, value = ary
       result[param.to_sym] = parse_parameter_value(param, value)
-      result
     end
   end
 

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

@@ -30,7 +30,7 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
   def formatter
     header = headers['content-type']
     if header
-      header.gsub!(/\s*;.*$/,'') # strip any charset
+      header.gsub!(/\s*;.*$/, '') # strip any charset
       format = Puppet::Network::FormatHandler.mime(header)
 
       return format if valid_network_format?(format)
@@ -38,12 +38,14 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
       # TRANSLATORS "mime-type" is a keyword and should not be translated
       raise Puppet::Network::HTTP::Error::HTTPUnsupportedMediaTypeError.new(
         _("Client sent a mime-type (%{header}) that doesn't correspond to a format we support") % { header: headers['content-type'] },
-        Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE)
+        Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE
+      )
     end
 
     raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
       _("No Content-Type header was received, it isn't possible to unserialize the request"),
-      Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
+      Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD
+    )
   end
 
   def response_formatters_for(supported_formats, default_accepted_formats = nil)
@@ -55,7 +57,8 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
 
     formats = Puppet::Network::FormatHandler.most_suitable_formats_for(
       accepted_formats.split(/\s*,\s*/),
-      supported_formats)
+      supported_formats
+    )
 
     formats.find_all do |format|
       # we are only passed supported_formats that are suitable
@@ -67,7 +70,8 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
 
     raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
       _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: accepted_formats },
-      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT
+    )
   end
 
   private

data/lib/puppet/network/http_pool.rb

@@ -36,12 +36,11 @@ module Puppet::Network::HttpPool
 
     if verify_peer
       verifier = Puppet::SSL::Verifier.new(host, nil)
-      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
     else
       ssl = Puppet::SSL::SSLProvider.new
       verifier = Puppet::SSL::Verifier.new(host, ssl.create_insecure_context)
-      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
     end
+    http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
   end
 
   # Retrieve a connection for the given host and port.

data/lib/puppet/node/environment.rb

@@ -195,8 +195,8 @@ class Puppet::Node::Environment
     paths_set        = configured_path && resolved_path
     munging_possible = paths_set && configured_path != resolved_path
     munging_desired  = munging_possible &&
-                         Puppet[:report_configured_environmentpath] &&
-                         filepath.to_s.start_with?(resolved_path)
+                       Puppet[:report_configured_environmentpath] &&
+                       filepath.to_s.start_with?(resolved_path)
 
     if munging_desired
       File.join(configured_path, filepath.delete_prefix(resolved_path))
@@ -359,27 +359,27 @@ class Puppet::Node::Environment
 
           warn_about_mistaken_path(path, name)
           if not seen_modules[name]
-            module_references << {:name => name, :path => File.join(path, name)}
+            module_references << { :name => name, :path => File.join(path, name) }
             seen_modules[name] = true
           end
         end
       end
 
-      @modules = module_references.collect do |reference|
+      @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
-      end.compact
+      end
     end
     @modules
   end
 
   # @api private
   def modules_by_name
-    @modules_by_name ||= Hash[modules.map { |mod| [mod.name, mod] }]
+    @modules_by_name ||= modules.to_h { |mod| [mod.name, mod] }
   end
   private :modules_by_name
 
@@ -539,10 +539,10 @@ class Puppet::Node::Environment
   end
 
   def ==(other)
-    return true if other.kind_of?(Puppet::Node::Environment) &&
-      self.name == other.name &&
-      self.full_modulepath == other.full_modulepath &&
-      self.manifest == other.manifest
+    return true if other.is_a?(Puppet::Node::Environment) &&
+                   self.name == other.name &&
+                   self.full_modulepath == other.full_modulepath &&
+                   self.manifest == other.manifest
   end
 
   alias eql? ==
@@ -552,9 +552,9 @@ class Puppet::Node::Environment
   end
 
   # not private so it can be called in tests
-  def self.extralibs()
+  def self.extralibs
     if ENV['PUPPETLIB']
-      split_path(ENV['PUPPETLIB'])
+      split_path(ENV.fetch('PUPPETLIB', nil))
     else
       []
     end
@@ -597,7 +597,7 @@ class Puppet::Node::Environment
       elsif File.directory?(file)
         # JRuby does not properly perform Dir.glob operations with wildcards, (see PUP-11788 and https://github.com/jruby/jruby/issues/7836).
         # We sort the results because Dir.glob order is inconsistent in Ruby < 3 (see PUP-10115).
-        parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*')).glob.select {|globbed_file| globbed_file.end_with?('.pp')}.sort.map do | file_to_parse |
+        parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*')).glob.select { |globbed_file| globbed_file.end_with?('.pp') }.sort.map do |file_to_parse|
           parser.file = file_to_parse
           parser.parse
         end

data/lib/puppet/node/facts.rb

@@ -17,7 +17,7 @@ class Puppet::Node::Facts
 
   # We want to expire any cached nodes if the facts are saved.
   module NodeExpirer
-    def save(instance, key = nil, options={})
+    def save(instance, key = nil, options = {})
       Puppet::Node.indirection.expire(instance.name, options)
       super
     end
@@ -138,16 +138,14 @@ class Puppet::Node::Facts
   end
 
   def sanitize_fact(fact)
-    if fact.is_a? Hash then
+    case fact
+    when Hash
       ret = {}
-      fact.each_pair { |k,v| ret[sanitize_fact k]=sanitize_fact v }
+      fact.each_pair { |k, v| ret[sanitize_fact k] = sanitize_fact v }
       ret
-    elsif fact.is_a? Array then
+    when Array
       fact.collect { |i| sanitize_fact i }
-    elsif fact.is_a? Numeric \
-      or fact.is_a? TrueClass \
-      or fact.is_a? FalseClass \
-      or fact.is_a? String
+    when Numeric, TrueClass, FalseClass, String
       fact
     else
       result = fact.to_s

data/lib/puppet/node.rb

@@ -60,9 +60,7 @@ class Puppet::Node
   end
 
   def environment
-    if @environment
-      @environment
-    else
+    unless @environment
       env = parameters[ENVIRONMENT]
       if env
         self.environment = env
@@ -76,8 +74,8 @@ class Puppet::Node
         self.environment = Puppet.lookup(:environments).get!(Puppet[:environment])
       end
 
-      @environment
     end
+    @environment
   end
 
   def environment=(env)
@@ -176,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" => self.environment.name.to_s })
 
     # Merge the server facts into the parameters for the node
     merge(facts)
@@ -230,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