puppet 8.3.1-universal-darwin → 8.5.0-universal-darwin

data/lib/puppet/graph/simple_graph.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/external/dot'
 require_relative '../../puppet/relationship'
 require 'set'
@@ -124,7 +125,7 @@ class Puppet::Graph::SimpleGraph
       when :children then
         if frame[:children].length > 0 then
           child = frame[:children].shift
-          if ! s[:index][child] then
+          if !s[:index][child] then
             # Never seen, need to recurse.
             frame[:step] = :after_recursion
             frame[:child] = child
@@ -143,7 +144,7 @@ class Puppet::Graph::SimpleGraph
             end
             s[:scc] << this_scc
           end
-          recur.pop               # done with this node, finally.
+          recur.pop # done with this node, finally.
         end
 
       when :after_recursion then
@@ -170,7 +171,7 @@ class Puppet::Graph::SimpleGraph
 
     # we usually have a disconnected graph, must walk all possible roots
     vertices.each do |vertex|
-      if ! state[:index][vertex] then
+      if !state[:index][vertex] then
         tarjan vertex, state
       end
     end
@@ -198,20 +199,20 @@ class Puppet::Graph::SimpleGraph
   # through the graph first, which are more likely to be interesting to the
   # user.  I think; it would be interesting to verify that. --daniel 2011-01-23
   def paths_in_cycle(cycle, max_paths = 1)
-    #TRANSLATORS "negative or zero" refers to the count of paths
+    # TRANSLATORS "negative or zero" refers to the count of paths
     raise ArgumentError, _("negative or zero max_paths") if max_paths < 1
 
     # Calculate our filtered outbound vertex lists...
     adj = {}
     cycle.each do |vertex|
-      adj[vertex] = adjacent(vertex).select{|s| cycle.member? s}
+      adj[vertex] = adjacent(vertex).select { |s| cycle.member? s }
     end
 
     found = []
 
     # frame struct is vertex, [path]
     stack = [[cycle.first, []]]
-    while frame = stack.shift do #rubocop:disable Lint/AssignmentInCondition
+    while frame = stack.shift do # rubocop:disable Lint/AssignmentInCondition
       if frame[1].member?(frame[0]) then
         found << frame[1] + [frame[0]]
         break if found.length >= max_paths
@@ -235,14 +236,14 @@ class Puppet::Graph::SimpleGraph
 
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
-      message += paths.map{ |path| '(' + path.join(' => ') + ')'}.join('\n') + '\n'
+      message += paths.map { |path| '(' + path.join(' => ') + ')' }.join('\n') + '\n'
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
       message += _("Cycle graph written to %{filename}.") % { filename: filename }
     else
-      #TRANSLATORS '--graph' refers to a command line option and OmniGraffle and GraphViz are program names and should not be translated
+      # TRANSLATORS '--graph' refers to a command line option and OmniGraffle and GraphViz are program names and should not be translated
       message += _("Try the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz")
     end
     Puppet.err(message)
@@ -279,9 +280,10 @@ class Puppet::Graph::SimpleGraph
   # Remove a vertex from the graph.
   def remove_vertex!(v)
     return unless vertex?(v)
+
     @upstream_from.clear
     @downstream_from.clear
-    (@in_to[v].values+@out_from[v].values).flatten.each { |e| remove_edge!(e) }
+    (@in_to[v].values + @out_from[v].values).flatten.each { |e| remove_edge!(e) }
     @in_to.delete(v)
     @out_from.delete(v)
   end
@@ -298,8 +300,9 @@ class Puppet::Graph::SimpleGraph
 
   # Add a new edge.  The graph user has to create the edge instance,
   # since they have to specify what kind of edge it is.
-  def add_edge(e,*a)
-    return add_relationship(e,*a) unless a.empty?
+  def add_edge(e, *a)
+    return add_relationship(e, *a) unless a.empty?
+
     e = Puppet::Relationship.from_data_hash(e) if e.is_a?(Hash)
     @upstream_from.clear
     @downstream_from.clear
@@ -331,15 +334,15 @@ class Puppet::Graph::SimpleGraph
   end
 
   def each_edge
-    @in_to.each { |t,ns| ns.each { |s,es| es.each { |e| yield e }}}
+    @in_to.each { |_t, ns| ns.each { |_s, es| es.each { |e| yield e } } }
   end
 
   # Remove an edge from our graph.
   def remove_edge!(e)
-    if edge?(e.source,e.target)
+    if edge?(e.source, e.target)
       @upstream_from.clear
       @downstream_from.clear
-      @in_to   [e.target].delete e.source if (@in_to   [e.target][e.source] -= [e]).empty?
+      @in_to[e.target].delete e.source if (@in_to[e.target][e.source] -= [e]).empty?
       @out_from[e.source].delete e.target if (@out_from[e.source][e.target] -= [e]).empty?
     end
   end
@@ -348,6 +351,7 @@ class Puppet::Graph::SimpleGraph
   def adjacent(v, options = {})
     ns = (options[:direction] == :in) ? @in_to[v] : @out_from[v]
     return [] unless ns
+
     (options[:type] == :edges) ? ns.values.flatten : ns.keys
   end
 
@@ -361,6 +365,7 @@ class Puppet::Graph::SimpleGraph
     until stack.empty?
       node = stack.shift
       next if seen.member? node
+
       connected = adjacent(node, :direction => direction)
       connected.each do |target|
         yield node, target
@@ -373,7 +378,7 @@ class Puppet::Graph::SimpleGraph
   # A different way of walking a tree, and a much faster way than the
   # one that comes with GRATR.
   def tree_from_vertex(start, direction = :out)
-    predecessor={}
+    predecessor = {}
     walk(start, direction) do |parent, child|
       predecessor[child] = parent
     end
@@ -382,6 +387,7 @@ class Puppet::Graph::SimpleGraph
 
   def downstream_from_vertex(v)
     return @downstream_from[v] if @downstream_from[v]
+
     result = @downstream_from[v] = {}
     @out_from[v].keys.each do |node|
       result[node] = 1
@@ -396,6 +402,7 @@ class Puppet::Graph::SimpleGraph
 
   def upstream_from_vertex(v)
     return @upstream_from[v] if @upstream_from[v]
+
     result = @upstream_from[v] = {}
     @in_to[v].keys.each do |node|
       result[node] = 1
@@ -421,14 +428,14 @@ class Puppet::Graph::SimpleGraph
   # This implementation is not particularly efficient; it's used in testing where clarity
   #   is more important than last-mile efficiency.
   #
-  def path_between(f,t)
-    if f==t
+  def path_between(f, t)
+    if f == t
       []
     elsif direct_dependents_of(f).include?(t)
-      [edges_between(f,t)]
+      [edges_between(f, t)]
     elsif dependents(f).include?(t)
       m = (dependents(f) & direct_dependencies_of(t)).first
-      path_between(f,m) + path_between(m,t)
+      path_between(f, m) + path_between(m, t)
     else
       nil
     end
@@ -441,25 +448,25 @@ class Puppet::Graph::SimpleGraph
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
   def to_dot_graph(params = {})
-    params['name'] ||= self.class.name.tr(':','_')
+    params['name'] ||= self.class.name.tr(':', '_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.ref
-      params = {'name'     => stringify(name),
-        'fontsize' => fontsize,
-        'label'    => name}
+      params = { 'name' => stringify(name),
+                 'fontsize' => fontsize,
+                 'label' => name }
       v_label = v.ref
-      params.merge!(v_label) if v_label and v_label.kind_of? Hash
+      params.merge!(v_label) if v_label and v_label.is_a? Hash
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
-      params = {'from'     => stringify(e.source.ref),
-        'to'       => stringify(e.target.ref),
-        'fontsize' => fontsize }
+      params = { 'from' => stringify(e.source.ref),
+                 'to' => stringify(e.target.ref),
+                 'fontsize' => fontsize }
       e_label = e.ref
-      params.merge!(e_label) if e_label and e_label.kind_of? Hash
+      params.merge!(e_label) if e_label and e_label.is_a? Hash
       graph << edge_klass.new(params)
     end
     graph
@@ -470,7 +477,7 @@ class Puppet::Graph::SimpleGraph
   end
 
   # Output the dot format as a string
-  def to_dot(params={}) to_dot_graph(params).to_s; end
+  def to_dot(params = {}) to_dot_graph(params).to_s; end
 
   # Produce the graph files if requested.
   def write_graph(name)
@@ -507,26 +514,26 @@ class Puppet::Graph::SimpleGraph
   def to_data_hash
     hash = { 'edges' => edges.map(&:to_data_hash) }
     hash['vertices'] = if self.class.use_new_yaml_format
-      vertices
-    else
-      # Represented in YAML using the old (version 2.6) format.
-      result = {}
-      vertices.each do |vertex|
-        adjacencies = {}
-        [:in, :out].each do |direction|
-          direction_hash = {}
-          adjacencies[direction.to_s] = direction_hash
-          adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
-            other_vertex = direction == :in ? edge.source : edge.target
-            (direction_hash[other_vertex.to_s] ||= []) << edge
-          end
-          direction_hash.each_pair { |key, edges| direction_hash[key] = edges.uniq.map(&:to_data_hash) }
-        end
-        vname = vertex.to_s
-        result[vname] = { 'adjacencies' => adjacencies, 'vertex' => vname }
-      end
-      result
-    end
+                         vertices
+                       else
+                         # Represented in YAML using the old (version 2.6) format.
+                         result = {}
+                         vertices.each do |vertex|
+                           adjacencies = {}
+                           [:in, :out].each do |direction|
+                             direction_hash = {}
+                             adjacencies[direction.to_s] = direction_hash
+                             adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
+                               other_vertex = direction == :in ? edge.source : edge.target
+                               (direction_hash[other_vertex.to_s] ||= []) << edge
+                             end
+                             direction_hash.each_pair { |key, edges| direction_hash[key] = edges.uniq.map(&:to_data_hash) }
+                           end
+                           vname = vertex.to_s
+                           result[vname] = { 'adjacencies' => adjacencies, 'vertex' => vname }
+                         end
+                         result
+                       end
     hash
   end
 

data/lib/puppet/graph.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Graph
   require_relative 'graph/prioritizer'
   require_relative 'graph/sequential_prioritizer'

data/lib/puppet/http/client.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The HTTP client provides methods for making `GET`, `POST`, etc requests to
 # HTTP(S) servers. It also provides methods for resolving Puppetserver REST
 # service endpoints using SRV records and settings (such as `server_list`,
@@ -85,7 +86,6 @@
 #
 # @api public
 class Puppet::HTTP::Client
-
   attr_reader :pool
 
   # Create a new http client instance. Use `Puppet.runtime[:http]` to get
@@ -154,18 +154,18 @@ class Puppet::HTTP::Client
       end
     end
   rescue Net::OpenTimeout => e
-    raise_error(_("Request to %{uri} timed out connect operation after %{elapsed} seconds") % {uri: uri, elapsed: elapsed(start)}, e, connected)
+    raise_error(_("Request to %{uri} timed out connect operation after %{elapsed} seconds") % { uri: uri, elapsed: elapsed(start) }, e, connected)
   rescue Net::ReadTimeout => e
-    raise_error(_("Request to %{uri} timed out read operation after %{elapsed} seconds") % {uri: uri, elapsed: elapsed(start)}, e, connected)
+    raise_error(_("Request to %{uri} timed out read operation after %{elapsed} seconds") % { uri: uri, elapsed: elapsed(start) }, e, connected)
   rescue EOFError => e
-    raise_error(_("Request to %{uri} interrupted after %{elapsed} seconds") % {uri: uri, elapsed: elapsed(start)}, e, connected)
+    raise_error(_("Request to %{uri} interrupted after %{elapsed} seconds") % { uri: uri, elapsed: elapsed(start) }, e, connected)
   rescue Puppet::SSL::SSLError
     raise
   rescue Puppet::HTTP::HTTPError
     raise
   rescue => e
     raise_error(_("Request to %{uri} failed after %{elapsed} seconds: %{message}") %
-                {uri: uri, elapsed: elapsed(start), message: e.message}, e, connected)
+                { uri: uri, elapsed: elapsed(start), message: e.message }, e, connected)
   end
 
   # These options apply to all HTTP request methods
@@ -237,6 +237,7 @@ class Puppet::HTTP::Client
   # @api public
   def put(url, body, headers: {}, params: {}, options: {})
     raise ArgumentError, "'put' requires a string 'body' argument" unless body.is_a?(String)
+
     url = encode_query(url, params)
 
     request = Net::HTTP::Put.new(url, @default_headers.merge(headers))
@@ -265,6 +266,7 @@ class Puppet::HTTP::Client
   # @api public
   def post(url, body, headers: {}, params: {}, options: {}, &block)
     raise ArgumentError, "'post' requires a string 'body' argument" unless body.is_a?(String)
+
     url = encode_query(url, params)
 
     request = Net::HTTP::Post.new(url, @default_headers.merge(headers))
@@ -469,6 +471,7 @@ class Puppet::HTTP::Client
   def resolve_ssl_context(ssl_context, include_system_store)
     if ssl_context
       raise Puppet::HTTP::HTTPError, "The ssl_context and include_system_store parameters are mutually exclusive" if include_system_store
+
       ssl_context
     elsif include_system_store
       system_ssl_context

data/lib/puppet/http/dns.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require 'resolv'
 
 module Puppet::HTTP
   class DNS
-
     class CacheEntry
       attr_reader :records, :ttl, :resolution_time
 
@@ -49,9 +49,9 @@ module Puppet::HTTP
       Puppet.debug "Searching for SRV records for domain: #{domain}"
 
       case service_name
-        when :puppet then service = '_x-puppet'
-        when :file   then service = '_x-puppet-fileserver'
-        else              service = "_x-puppet-#{service_name}"
+      when :puppet then service = '_x-puppet'
+      when :file   then service = '_x-puppet-fileserver'
+      else              service = "_x-puppet-#{service_name}"
       end
       record_name = "#{service}._tcp.#{domain}"
 
@@ -72,7 +72,7 @@ module Puppet::HTTP
         each_srv_record(domain, :puppet, &block)
       else
         each_priority(records) do |recs|
-          while next_rr = recs.delete(find_weighted_server(recs)) #rubocop:disable Lint/AssignmentInCondition
+          while next_rr = recs.delete(find_weighted_server(recs)) # rubocop:disable Lint/AssignmentInCondition
             Puppet.debug "Yielding next server of #{next_rr.target}:#{next_rr.port}"
             yield next_rr.target.to_s, next_rr.port
           end
@@ -98,7 +98,7 @@ module Puppet::HTTP
       # We generate a random number 5, and iterate through the records, adding
       # the current record's weight to the accumulator until the weight of the
       # current record plus previous records is greater than the random number.
-      total_weight = records.inject(0) { |sum,record|
+      total_weight = records.inject(0) { |sum, record|
         sum + weight(record)
       }
       current_weight = 0
@@ -146,10 +146,9 @@ module Puppet::HTTP
     # @yields [[Resolv::DNS::Resource::IN::SRV]] a group of records of
     #         the same priority
     def each_priority(records)
-      pri_hash = records.inject({}) do |groups, element|
+      pri_hash = records.each_with_object({}) do |element, groups|
         groups[element.priority] ||= []
         groups[element.priority] << element
-        groups
       end
 
       pri_hash.keys.sort.each do |key|

data/lib/puppet/http/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::HTTP
   # A base class for puppet http errors
   # @api public
@@ -35,7 +36,7 @@ module Puppet::HTTP
   # @api public
   class TooManyRedirects < HTTPError
     def initialize(addr)
-      super(_("Too many HTTP redirections for %{addr}") % { addr: addr})
+      super(_("Too many HTTP redirections for %{addr}") % { addr: addr })
     end
   end
 
@@ -43,7 +44,7 @@ module Puppet::HTTP
   # @api public
   class TooManyRetryAfters < HTTPError
     def initialize(addr)
-      super(_("Too many HTTP retries for %{addr}") % { addr: addr})
+      super(_("Too many HTTP retries for %{addr}") % { addr: addr })
     end
   end
 end

data/lib/puppet/http/external_client.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Adapts an external http_client_class to the HTTP client API. The former
 # is typically registered by puppetserver and only implements a subset of
 # the Puppet::Network::HTTP::Connection methods. As a result, only the
@@ -7,7 +8,6 @@
 #
 # @api private
 class Puppet::HTTP::ExternalClient < Puppet::HTTP::Client
-
   # Create an external http client.
   #
   # @param [Class] http_client_class The class to create to handle the request
@@ -40,6 +40,7 @@ class Puppet::HTTP::ExternalClient < Puppet::HTTP::Client
   # @api private
   def post(url, body, headers: {}, params: {}, options: {}, &block)
     raise ArgumentError.new("'post' requires a string 'body' argument") unless body.is_a?(String)
+
     url = encode_query(url, params)
 
     options[:use_ssl] = url.scheme == 'https'
@@ -85,5 +86,4 @@ class Puppet::HTTP::ExternalClient < Puppet::HTTP::Client
   def delete(url, headers: {}, params: {}, options: {})
     raise NotImplementedError
   end
-
 end

data/lib/puppet/http/factory.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/ssl/openssl_loader'
 require 'net/http'
 require_relative '../../puppet/http'
@@ -16,7 +17,7 @@ class Puppet::HTTP::Factory
 
   def initialize
     # PUP-1411, make sure that openssl is initialized before we try to connect
-    if ! @@openssl_initialized
+    if !@@openssl_initialized
       OpenSSL::SSL::SSLContext.new
       @@openssl_initialized = true
     end

data/lib/puppet/http/pool.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # A pool for persistent `Net::HTTP` connections. Connections are
 # stored in the pool indexed by their {Site}.
 # Connections are borrowed from the pool, yielded to the caller, and
@@ -71,13 +72,13 @@ class Puppet::HTTP::Pool
     end
   end
 
-
   # Safely close a persistent connection.
   # Don't try to close a connection that's already closed.
   #
   # @api private
   def close_connection(site, http)
     return false unless http.started?
+
     Puppet.debug("Closing connection for #{site}")
     http.finish
     true

data/lib/puppet/http/pool_entry.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # An entry in the peristent HTTP pool that references the connection and
 # an expiration time for the connection.
 #

data/lib/puppet/http/proxy.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'uri'
 require_relative '../../puppet/ssl/openssl_loader'
 
@@ -17,7 +18,7 @@ module Puppet::HTTP::Proxy
 
   def self.http_proxy_env
     # Returns a URI object if proxy is set, or nil
-    proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"]
+    proxy_env = ENV.fetch("http_proxy", nil) || ENV.fetch("HTTP_PROXY", nil)
     begin
       return URI.parse(proxy_env) if proxy_env
     rescue URI::InvalidURIError
@@ -52,8 +53,8 @@ module Puppet::HTTP::Proxy
       host, port = d.split(':')
       host = Regexp.escape(host).gsub('\*', '.*')
 
-      #If this no_proxy entry specifies a port, we want to match it against
-      #the destination port.  Otherwise just match hosts.
+      # If this no_proxy entry specifies a port, we want to match it against
+      # the destination port.  Otherwise just match hosts.
       if port
         no_proxy_regex  = %r(#{host}:#{port}$)
         dest_string     = "#{dest.host}:#{dest.port}"
@@ -123,7 +124,7 @@ module Puppet::HTTP::Proxy
   end
 
   def self.no_proxy
-    no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
+    no_proxy_env = ENV.fetch("no_proxy", nil) || ENV.fetch("NO_PROXY", nil)
 
     if no_proxy_env
       return no_proxy_env

data/lib/puppet/http/redirector.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Handle HTTP redirects
 #
 # @api private
@@ -77,6 +78,6 @@ class Puppet::HTTP::Redirector
 
     URI.parse(location)
   rescue URI::InvalidURIError => e
-    raise Puppet::HTTP::ProtocolError.new(_("Location URI is invalid: %{detail}") % { detail: e.message}, e)
+    raise Puppet::HTTP::ProtocolError.new(_("Location URI is invalid: %{detail}") % { detail: e.message }, e)
   end
 end

data/lib/puppet/http/resolver/server_list.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 # Use the server_list setting to resolve a service. This resolver is only used
 # if server_list is set either on the command line or in the configuration file.
 #
 # @api public
 class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
-
   # Create a server list resolver.
   #
   # @param [Puppet::HTTP::Client] client
@@ -16,7 +16,7 @@ class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
   #   used to resolve. If a service is not included in this array, this resolver
   #   will return nil.
   #
-  def initialize(client, server_list_setting:, default_port:, services: )
+  def initialize(client, server_list_setting:, default_port:, services:)
     @client = client
     @server_list_setting = server_list_setting
     @default_port = default_port
@@ -71,10 +71,10 @@ class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
         end
       rescue Puppet::HTTP::HTTPError => detail
         if index < @server_list_setting.value.length - 1
-          Puppet.warning(_("Unable to connect to server from server_list setting: %{detail}") % {detail: detail} +
+          Puppet.warning(_("Unable to connect to server from server_list setting: %{detail}") % { detail: detail } +
                              ' ' + _("Trying with next server from server_list."))
         else
-          Puppet.log_exception(detail, _("Unable to connect to server from server_list setting: %{detail}") % {detail: detail})
+          Puppet.log_exception(detail, _("Unable to connect to server from server_list setting: %{detail}") % { detail: detail })
         end
       end
     end

data/lib/puppet/http/resolver/settings.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 # Resolve a service using settings. This is the default resolver if none of the
 # other resolvers find a functional connection.
 #
 # @api public
 class Puppet::HTTP::Resolver::Settings < Puppet::HTTP::Resolver
-
   # Resolve a service using the default server and port settings for this service.
   #
   # @param [Puppet::HTTP::Session] session

data/lib/puppet/http/resolver/srv.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 # Resolve a service using DNS SRV records.
 #
 # @api public
 class Puppet::HTTP::Resolver::SRV < Puppet::HTTP::Resolver
-
   # Create an DNS SRV resolver.
   #
   # @param [Puppet::HTTP::Client] client

data/lib/puppet/http/resolver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Resolver base class. Each resolver represents a different strategy for
 # resolving a service name into a list of candidate servers and ports.
 #

data/lib/puppet/http/response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Represents the response returned from the server from an HTTP request.
 #
 # @api abstract

data/lib/puppet/http/response_converter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::HTTP::ResponseConverter
   module_function
 
@@ -8,7 +9,7 @@ module Puppet::HTTP::ResponseConverter
 
     # Copied from Net::HTTPResponse because it is private there.
     clazz = Net::HTTPResponse::CODE_TO_OBJ[str_code] or
-      Net::HTTPResponse::CODE_CLASS_TO_OBJ[str_code[0,1]] or
+      Net::HTTPResponse::CODE_CLASS_TO_OBJ[str_code[0, 1]] or
       Net::HTTPUnknownResponse
     result = clazz.new(nil, str_code, nil)
     result.body = response.body
@@ -16,10 +17,9 @@ module Puppet::HTTP::ResponseConverter
     # an instance of Net::HttpResponse from outside of the library and have
     # the body be readable, unless you do stupid things like this.
     result.instance_variable_set(:@read, true)
-    response.each_header do |k,v|
+    response.each_header do |k, v|
       result[k] = v
     end
     result
   end
 end
-

data/lib/puppet/http/response_net_http.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 # Adapts Net::HTTPResponse to Puppet::HTTP::Response
 #
 # @api public
 class Puppet::HTTP::ResponseNetHTTP < Puppet::HTTP::Response
-
   # Create a response associated with the URL.
   #
   # @param [URI] url

data/lib/puppet/http/retry_after_handler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'date'
 require 'time'
 
@@ -6,7 +7,6 @@ require 'time'
 #
 # @api private
 class Puppet::HTTP::RetryAfterHandler
-
   # Create a handler to allow the system to sleep between HTTP requests
   #
   # @param [Integer] retry_limit number of retries allowed