openvox 7.37.1 → 8.19.0

data/lib/puppet/network/formats.rb

@@ -1,13 +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
 
@@ -82,11 +84,13 @@ 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
 Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  confine :feature => :pson
+
   def intern(klass, text)
     data_to_instance(klass, PSON.parse(text))
   end
@@ -110,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
@@ -133,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
@@ -140,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)
@@ -153,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 = ''
-      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
@@ -166,7 +171,7 @@ Puppet::Network::FormatHandler.create(:console,
 
     # Print one item per line for arrays
     if datum.is_a? Array
-      output = ''
+      output = ''.dup
       datum.each do |item|
         output << item.to_s
         output << "\n"
@@ -184,16 +189,16 @@ 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
+      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|
@@ -210,21 +215,21 @@ 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|
           a["#{i}.#{el_k}"] = el_v
         end
       else
-        a["#{i}"] = el
+        a[i.to_s] = el
       end
     end
     a
   end
 
   def construct_output(data)
-    output = ''
+    output = ''.dup
     data.each do |key, value|
       output << "#{key}=#{value}"
       output << "\n"
@@ -234,31 +239,33 @@ 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)
+    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
     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
+    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
@@ -266,20 +273,21 @@ 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)
     end
   end
@@ -297,6 +305,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,7 +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 = {
@@ -35,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?
@@ -56,13 +57,12 @@ 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 })
+      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
@@ -71,25 +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)
+        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)
@@ -99,15 +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]
@@ -188,26 +184,25 @@ 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
 
     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
@@ -230,32 +225,30 @@ 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
 
-    #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)
+      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]
+    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 })
-      end
+    method = METHOD_MAP[http_method][plurality(indirection)]
+    unless 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/indirection_type.rb

@@ -1,5 +1,6 @@
-class Puppet::Network::HTTP::API::IndirectionType
+# frozen_string_literal: true
 
+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,3 +1,4 @@
+# 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,3 +1,4 @@
+# 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,3 +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,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../../../../puppet/util/json'
 
 module Puppet
@@ -7,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" => @env_loader.list.to_h do |env|
+                                [env.name, {
+                                  "settings" => {
+                                    "modulepath" => env.full_modulepath,
+                                    "manifest" => env.manifest,
+                                    "environment_timeout" => timeout(env),
+                                    "config_version" => env.config_version || '',
+                                  }
+                                }]
+                              end
+                            })
+                  )
               end
 
               private
@@ -45,4 +52,3 @@ module Puppet
     end
   end
 end
-

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'v3/environments'
 require_relative '../../../../../puppet/network/http/api/indirected_routes'
 
@@ -7,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(/v3/)
+                                          .any
+                                          .chain(ENVIRONMENTS, INDIRECTED)
             end
           end
         end

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

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

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

@@ -1,36 +1,38 @@
+# 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|
-        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::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",
                                                                   Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
       end)
   end
 
   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,7 +1,9 @@
+# frozen_string_literal: true
+
 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
@@ -138,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
@@ -243,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
@@ -264,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

@@ -1,9 +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)
@@ -13,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
 
@@ -67,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