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

data/lib/puppet/network/client_request.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Network # :nodoc:
   # A struct-like class for passing around a client request.  It's mostly
   # just used for validation and authorization.

data/lib/puppet/network/format.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/confiner'
 
 # A simple class for modeling encoding formats for moving
@@ -50,11 +51,13 @@ class Puppet::Network::Format
 
   def intern(klass, text)
     return klass.send(intern_method, text) if klass.respond_to?(intern_method)
+
     raise NotImplementedError, "#{klass} does not respond to #{intern_method}; can not intern instances from #{mime}"
   end
 
   def intern_multiple(klass, text)
     return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
+
     raise NotImplementedError, "#{klass} does not respond to #{intern_multiple_method}; can not intern multiple instances from #{mime}"
   end
 
@@ -64,12 +67,14 @@ class Puppet::Network::Format
 
   def render(instance)
     return instance.send(render_method) if instance.respond_to?(render_method)
+
     raise NotImplementedError, "#{instance.class} does not respond to #{render_method}; can not render instances to #{mime}"
   end
 
   def render_multiple(instances)
     # This method implicitly assumes that all instances are of the same type.
     return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
+
     raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") %
         { klass: instances[0].class, method: render_multiple_method, mime: mime }
   end

data/lib/puppet/network/format_handler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'yaml'
 require_relative '../../puppet/network'
 require_relative '../../puppet/network/format'
@@ -33,7 +34,7 @@ module Puppet::Network::FormatHandler
   end
 
   def self.format_by_extension(ext)
-    @formats.each do |name, format|
+    @formats.each do |_name, format|
       return format if format.extension == ext
     end
     nil

data/lib/puppet/network/format_support.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/network/format_handler'
 
 # Provides network serialization support when included
@@ -12,21 +13,21 @@ module Puppet::Network::FormatSupport
     def convert_from(format, data)
       get_format(format).intern(self, data)
     rescue => err
-      #TRANSLATORS "intern" is a function name and should not be translated
+      # TRANSLATORS "intern" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def convert_from_multiple(format, data)
       get_format(format).intern_multiple(self, data)
     rescue => err
-      #TRANSLATORS "intern_multiple" is a function name and should not be translated
+      # TRANSLATORS "intern_multiple" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def render_multiple(format, instances)
       get_format(format).render_multiple(instances)
     rescue => err
-      #TRANSLATORS "render_multiple" is a function name and should not be translated
+      # TRANSLATORS "render_multiple" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
@@ -111,7 +112,7 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).render(self)
   rescue => err
-    #TRANSLATORS "render" is a function name and should not be translated
+    # TRANSLATORS "render" is a function name and should not be translated
     raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
@@ -120,7 +121,7 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).mime
   rescue => err
-    #TRANSLATORS "mime" is a function name and should not be translated
+    # TRANSLATORS "mime" is a function name and should not be translated
     raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 

data/lib/puppet/network/formats.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/network/format_handler'
 require_relative '../../puppet/util/json'
 
 Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20, :mime => "application/x-msgpack", :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
-
   confine :feature => :msgpack
 
   def intern(klass, text)
     data = MessagePack.unpack(text)
     return data if data.is_a?(klass)
+
     klass.from_data_hash(data)
   end
 
@@ -83,7 +84,7 @@ Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :charset => Enc
 # By default, to_binary is called to render and from_binary called to intern. Note unlike
 # text-based formats (json, yaml, etc), we don't use to_data_hash for binary.
 Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1,
-                                      :required_methods => [:render_method, :intern_method]) do
+                                               :required_methods => [:render_method, :intern_method]) do
 end
 
 # PSON is deprecated
@@ -113,6 +114,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :
       data = d
     end
     return data if data.is_a?(klass)
+
     klass.from_data_hash(data)
   end
 end
@@ -136,6 +138,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:json, :mime => 'applic
   # have never supported JSON
   def data_to_instance(klass, data)
     return data if data.is_a?(klass)
+
     klass.from_data_hash(data)
   end
 end
@@ -143,9 +146,8 @@ end
 # This is really only ever going to be used for Catalogs.
 Puppet::Network::FormatHandler.create_serialized_formats(:dot, :required_methods => [:render_method])
 
-
 Puppet::Network::FormatHandler.create(:console,
-                                      :mime   => 'text/x-console-text',
+                                      :mime => 'text/x-console-text',
                                       :weight => 0) do
   def json
     @json ||= Puppet::Network::FormatHandler.format(:json)
@@ -156,12 +158,12 @@ 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 = String.new
-      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 = ''.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|
         output << key.to_s.ljust(column_a)
-        output << json.render(value).
-          chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
+        output << json.render(value)
+          .chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
         output << "\n"
       end
       return output
@@ -169,7 +171,7 @@ Puppet::Network::FormatHandler.create(:console,
 
     # Print one item per line for arrays
     if datum.is_a? Array
-      output = String.new
+      output = ''.dup
       datum.each do |item|
         output << item.to_s
         output << "\n"
@@ -187,9 +189,8 @@ Puppet::Network::FormatHandler.create(:console,
 end
 
 Puppet::Network::FormatHandler.create(:flat,
-                                      :mime   => 'text/x-flat-text',
+                                      :mime => 'text/x-flat-text',
                                       :weight => 0) do
-
   def flatten_hash(hash)
     hash.each_with_object({}) do |(k, v), h|
       if v.is_a? Hash
@@ -227,7 +228,7 @@ Puppet::Network::FormatHandler.create(:flat,
   end
 
   def construct_output(data)
-    output = String.new
+    output = ''.dup
     data.each do |key, value|
       output << "#{key}=#{value}"
       output << "\n"
@@ -237,6 +238,7 @@ Puppet::Network::FormatHandler.create(:flat,
 
   def render(datum)
     return datum if datum.is_a?(String) || datum.is_a?(Numeric)
+
     # Simple hash
     if datum.is_a?(Hash)
       data = flatten_hash(datum)
@@ -247,12 +249,12 @@ Puppet::Network::FormatHandler.create(:flat,
     end
     Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
   end
+
   def render_multiple(data)
     data.collect(&:render).join("\n")
   end
 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
@@ -283,6 +285,7 @@ Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.pu
   def data_to_instance(klass, data)
     Puppet.override({:rich_data => true}) do
       return data if data.is_a?(klass)
+
       klass.from_data_hash(data)
     end
   end
@@ -300,6 +303,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:rich_data_msgpack, mim
     Puppet.override(rich_data: true) do
       data = MessagePack.unpack(text)
       return data if data.is_a?(klass)
+
       klass.from_data_hash(data)
     end
   end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 require_relative '../../../../puppet/network/http/api/indirection_type'
 
 class Puppet::Network::HTTP::API::IndirectedRoutes
-
   # How we map http methods and the indirection name in the URI
   # to an indirection method.
   METHOD_MAP = {
@@ -207,8 +207,8 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     return formatter if formatter
 
     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)
+      _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats.map(&:mime).join(', ') },
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
   end
 
   # Return an array of response formatters that the client accepts and
@@ -236,7 +236,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       end
     end
 
-    #TRANSLATORS "mime-type" is a keyword and should not be translated
+    # 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)
@@ -246,11 +246,11 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new(
       _("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(
+    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 })
-      end
+    end
 
     method
   end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-class Puppet::Network::HTTP::API::IndirectionType
 
+class Puppet::Network::HTTP::API::IndirectionType
   INDIRECTION_TYPE_MAP = {
     "certificate" => :ca,
     "certificate_request" => :ca,

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../../../puppet/network/http/api/master'
 require_relative '../../../../../puppet/network/http/api/server/v3'
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../../puppet/network/http/api/server'
 
 Puppet::Network::HTTP::API::Master = Puppet::Network::HTTP::API::Server

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../../../../puppet/util/json'
 
 module Puppet
@@ -8,25 +9,30 @@ module Puppet
         module Server
           class V3
             class Environments
-
               def initialize(env_loader)
                 @env_loader = env_loader
               end
 
               def call(request, response)
-                response.respond_with(200, "application/json", Puppet::Util::Json.dump({
-                  "search_paths" => @env_loader.search_paths,
-                  "environments" => Hash[@env_loader.list.collect do |env|
-                    [env.name, {
-                      "settings" => {
-                        "modulepath" => env.full_modulepath,
-                        "manifest" => env.manifest,
-                        "environment_timeout" => timeout(env),
-                        "config_version" => env.config_version || '',
-                      }
-                    }]
-                  end]
-                }))
+                response
+                  .respond_with(
+                    200,
+                    "application/json",
+                    Puppet::Util::Json
+                      .dump({
+                              "search_paths" => @env_loader.search_paths,
+                              "environments" => Hash[@env_loader.list.collect do |env|
+                                [env.name, {
+                                  "settings" => {
+                                    "modulepath" => env.full_modulepath,
+                                    "manifest" => env.manifest,
+                                    "environment_timeout" => timeout(env),
+                                    "config_version" => env.config_version || '',
+                                  }
+                                }]
+                              end]
+                            })
+                  )
               end
 
               private

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'v3/environments'
 require_relative '../../../../../puppet/network/http/api/indirected_routes'
 
@@ -8,29 +9,28 @@ module Puppet
       class API
         module Server
           class V3
-
             def self.wrap(&block)
               lambda do |request, response|
-                Puppet::Network::Authorization.
-                  check_external_authorization(request.method,
-                                               request.path)
+                Puppet::Network::Authorization
+                  .check_external_authorization(request.method,
+                                                request.path)
 
                 block.call.call(request, response)
               end
             end
 
-            INDIRECTED = Puppet::Network::HTTP::Route.
-                path(/.*/).
-                any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new } )
+            INDIRECTED = Puppet::Network::HTTP::Route
+                .path(/.*/)
+                .any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new } )
 
-            ENVIRONMENTS = Puppet::Network::HTTP::Route.
-                path(%r{^/environments$}).
-                get(wrap { Environments.new(Puppet.lookup(:environments)) } )
+            ENVIRONMENTS = Puppet::Network::HTTP::Route
+                .path(%r{^/environments$})
+                .get(wrap { Environments.new(Puppet.lookup(:environments)) } )
 
             def self.routes
-              Puppet::Network::HTTP::Route.path(%r{v3}).
-                  any.
-                  chain(ENVIRONMENTS, INDIRECTED)
+              Puppet::Network::HTTP::Route.path(%r{v3})
+                  .any
+                  .chain(ENVIRONMENTS, INDIRECTED)
             end
           end
         end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet
   module Network
     module HTTP

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

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
+
 class Puppet::Network::HTTP::API
   require_relative '../../../puppet/version'
 
   def self.not_found
-    Puppet::Network::HTTP::Route.
-      path(/.*/).
-      any(lambda do |req, res|
+    Puppet::Network::HTTP::Route
+      .path(/.*/)
+      .any(lambda do |req, _res|
         raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No route for #{req.method} #{req.path}", Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
       end)
   end
 
   def self.not_found_upgrade
-    Puppet::Network::HTTP::Route.
-      path(/.*/).
-      any(lambda do |req, res|
+    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 " +
@@ -28,10 +29,10 @@ 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)
+    Puppet::Network::HTTP::Route.path(server_prefix)
+      .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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/http'
 
 # This will be raised if too many redirects happen for a given HTTP request

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/json'
 
 module Puppet::Network::HTTP::Error
   Issues = Puppet::Network::HTTP::Issues
 
-  class HTTPError < Exception
+  class HTTPError < Exception # rubocop:disable Lint/InheritException
     attr_reader :status, :issue_kind
 
     def initialize(message, status, issue_kind)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Network::HTTP
 end
 
@@ -110,8 +111,8 @@ module Puppet::Network::HTTP::Handler
       return route
     else
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-              _("No route for %{request} %{path}") % { request: request.method, path: request.path },
-              HANDLER_NOT_FOUND)
+        _("No route for %{request} %{path}") % { request: request.method, path: request.path },
+        HANDLER_NOT_FOUND)
     end
   end
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Network::HTTP::Issues
   NO_INDIRECTION_REMOTE_REQUESTS = :NO_INDIRECTION_REMOTE_REQUESTS
   HANDLER_NOT_FOUND = :HANDLER_NOT_FOUND

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 class Puppet::Network::HTTP::MemoryResponse
   attr_reader :code, :type, :body
 
   def initialize
-    @body = String.new
+    @body = ''.dup
   end
 
   def respond_with(code, type, body)

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

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
-Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :routing_path, :client_cert, :body) do
+
+# This class is effectively public API, because a Request object is passed as a
+# parameter to the current Handler subclass. Puppetserver implements its own
+# Handler
+# https://github.com/puppetlabs/puppetserver/blob/8.3.0/src/ruby/puppetserver-lib/puppet/server/network/http/handler.rb#L9
+# and the Request object is passed to its Handler#body method
+# https://github.com/puppetlabs/puppetserver/blob/8.3.0/src/ruby/puppetserver-lib/puppet/server/network/http/handler.rb#L36
+Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :routing_path, :client_cert, :body) do # rubocop:disable Lint/StructNewOverride
   def self.from_hash(hash)
     symbol_members = members.collect(&:intern)
     unknown = hash.keys - symbol_members
@@ -28,15 +35,15 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
 
       return format if valid_network_format?(format)
 
-      #TRANSLATORS "mime-type" is a keyword and should not be translated
+      # 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)
+        _("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)
     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)
+      _("No Content-Type header was received, it isn't possible to unserialize the request"),
+      Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
   end
 
   def response_formatters_for(supported_formats, default_accepted_formats = nil)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Puppet::Network::HTTP::Response
   def initialize(handler, response)
     @handler = handler

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 class Puppet::Network::HTTP::Route
-  MethodNotAllowedHandler = lambda do |req, res|
+  MethodNotAllowedHandler = lambda do |req, _res|
     raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new("method #{req.method} not allowed for route #{req.path}", Puppet::Network::HTTP::Issues::UNSUPPORTED_METHOD)
   end
 
@@ -56,7 +57,7 @@ class Puppet::Network::HTTP::Route
   end
 
   def any(*handlers)
-    @method_handlers.each do |method, registered_handlers|
+    @method_handlers.each do |method, _registered_handlers|
       @method_handlers[method] = handlers
     end
     return self
@@ -74,6 +75,7 @@ class Puppet::Network::HTTP::Route
     else
       Puppet.debug { "Did not match path (#{request.routing_path.inspect})" }
     end
+
     return false
   end
 

data/lib/puppet/network/http.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This module is used to handle puppet REST requests in puppetserver.
 module Puppet::Network::HTTP
   HEADER_ENABLE_PROFILING = "X-Puppet-Profiling"

data/lib/puppet/network/http_pool.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/network/http/connection'
 
 module Puppet::Network; end
@@ -9,12 +10,12 @@ module Puppet::Network; end
 # @deprecated Use {Puppet::HTTP::Client} instead.
 #
 module Puppet::Network::HttpPool
-
   @http_client_class = Puppet::Network::HTTP::Connection
 
   def self.http_client_class
     @http_client_class
   end
+
   def self.http_client_class=(klass)
     @http_client_class = klass
   end

data/lib/puppet/network/uri.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This module holds funtions for network URI's
 module Puppet::Network::Uri
   # Mask credentials in given URI or address as string. Resulting string will

data/lib/puppet/network.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Just a stub, so we can correctly scope other classes.
 module Puppet::Network # :nodoc:
 end