puppet 8.5.1-x86-mingw32 → 8.7.0-x86-mingw32

data/lib/puppet/module_tool/metadata.rb

@@ -58,7 +58,7 @@ module Puppet::ModuleTool
       merge_dependencies(data) if data['dependencies']
 
       @data.merge!(data)
-      return self
+      self
     end
 
     # Validates the name and version_requirement for a dependency, then creates
@@ -102,7 +102,11 @@ module Puppet::ModuleTool
       data = @data.dup.merge('dependencies' => dependencies)
 
       contents = data.keys.map do |k|
-        value = (Puppet::Util::Json.dump(data[k], :pretty => true) rescue data[k].to_json)
+        value = begin
+          Puppet::Util::Json.dump(data[k], :pretty => true)
+        rescue
+          data[k].to_json
+        end
         %Q("#{k}": #{value})
       end
 
@@ -121,7 +125,7 @@ module Puppet::ModuleTool
     # Do basic validation and parsing of the name parameter.
     def process_name(data)
       validate_name(data['name'])
-      author, @module_name = data['name'].split(/[-\/]/, 2)
+      author, @module_name = data['name'].split(%r{[-/]}, 2)
 
       data['author'] ||= author if @data['author'] == DEFAULTS['author']
     end
@@ -139,7 +143,7 @@ module Puppet::ModuleTool
     # GitHub, we can predict sensible defaults for both project_page and
     # issues_url.
     def process_source(data)
-      if data['source'] =~ %r[://]
+      if data['source'] =~ %r{://}
         source_uri = URI.parse(data['source'])
       else
         source_uri = URI.parse("http://#{data['source']}")
@@ -149,10 +153,10 @@ module Puppet::ModuleTool
         source_uri.scheme = 'https'
         source_uri.path.sub!(/\.git$/, '')
         data['project_page'] ||= @data['project_page'] || source_uri.to_s
-        data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
+        data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(%r{/*$}, '') + '/issues'
       end
     rescue URI::Error
-      return
+      nil
     end
 
     # Validates and parses the dependencies.
@@ -167,9 +171,9 @@ module Puppet::ModuleTool
 
     # Validates that the given module name is both namespaced and well-formed.
     def validate_name(name)
-      return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
+      return if name =~ %r{\A[a-z0-9]+[-/][a-z][a-z0-9_]*\Z}i
 
-      namespace, modname = name.split(/[-\/]/, 2)
+      namespace, modname = name.split(%r{[-/]}, 2)
       modname = :namespace_missing if namespace == ''
 
       err = case modname

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -13,7 +13,8 @@ module Puppet::ModuleTool::Shared
       @installed[mod_name] << mod
       d = @local["#{mod_name}@#{mod.version}"]
       (mod.dependencies || []).each do |hash|
-        name, conditions = hash['name'], hash['version_requirement']
+        name = hash['name']
+        conditions = hash['version_requirement']
         name = name.tr('/', '-')
         d[name] = conditions
         @conditions[name] << {
@@ -37,7 +38,11 @@ module Puppet::ModuleTool::Shared
       mod_name, releases = pair
       mod_name = mod_name.tr('/', '-')
       releases.each do |rel|
-        semver = SemanticPuppet::Version.parse(rel['version']) rescue SemanticPuppet::Version::MIN
+        semver = begin
+          SemanticPuppet::Version.parse(rel['version'])
+        rescue
+          SemanticPuppet::Version::MIN
+        end
         @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
         @versions[mod_name].sort_by! { |a| a[:semver] }
         @urls["#{mod_name}@#{rel['version']}"] = rel['file']
@@ -55,14 +60,14 @@ module Puppet::ModuleTool::Shared
       return :latest
     end
 
-    return :best
+    :best
   end
 
   def annotated_version(mod, versions)
     if versions.empty?
-      return implicit_version(mod)
+      implicit_version(mod)
     else
-      return "#{implicit_version(mod)}: #{versions.last}"
+      "#{implicit_version(mod)}: #{versions.last}"
     end
   end
 
@@ -78,10 +83,16 @@ module Puppet::ModuleTool::Shared
       }
 
       if forced?
-        range = Puppet::Module.parse_range(@version) rescue Puppet::Module.parse_range('>= 0.0.0')
+        range = begin
+          Puppet::Module.parse_range(@version)
+        rescue
+          Puppet::Module.parse_range('>= 0.0.0')
+        end
       else
         range = (@conditions[mod]).map do |r|
-          Puppet::Module.parse_range(r[:dependency]) rescue Puppet::Module.parse_range('>= 0.0.0')
+          Puppet::Module.parse_range(r[:dependency])
+        rescue
+          Puppet::Module.parse_range('>= 0.0.0')
         end.inject(&:&)
       end
 
@@ -89,7 +100,7 @@ module Puppet::ModuleTool::Shared
         next if range === seen[mod][:semver]
 
         req_module   = @module_name
-        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        req_versions = @versions[@module_name.to_s].map { |v| v[:semver] }
         raise InvalidDependencyCycleError,
               :module_name => mod,
               :source => (source + [{ :name => mod, :version => source.last[:dependency] }]),
@@ -110,14 +121,14 @@ module Puppet::ModuleTool::Shared
         @conditions.each { |_, conds| conds.delete_if { |c| c[:module] == mod } }
       end
 
-      versions = @versions["#{mod}"].select { |h| range === h[:semver] }
+      versions = @versions[mod.to_s].select { |h| range === h[:semver] }
       valid_versions = versions.select { |x| x[:semver].special == '' }
       valid_versions = versions if valid_versions.empty?
 
       version = valid_versions.last
       unless version
         req_module   = @module_name
-        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        req_versions = @versions[@module_name.to_s].map { |v| v[:semver] }
         raise NoVersionsSatisfyError,
               :requested_name => req_module,
               :requested_version => @version || annotated_version(req_module, req_versions),
@@ -135,7 +146,11 @@ module Puppet::ModuleTool::Shared
         :action => action,
         :previous_version => @installed[mod].empty? ? nil : @installed[mod].first.version,
         :file => @urls["#{mod}@#{version[:vstring]}"],
-        :path => action == :install ? @options[:target_dir] : (@installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath),
+        :path => if action == :install
+                   @options[:target_dir]
+                 else
+                   @installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath
+                 end,
         :dependencies => []
       }
     end
@@ -143,7 +158,7 @@ module Puppet::ModuleTool::Shared
       deps = @remote["#{mod[:module]}@#{mod[:version][:vstring]}"].sort_by(&:first)
       mod[:dependencies] = resolve_constraints(deps, source + [{ :name => mod[:module], :version => mod[:version][:vstring] }], seen, :install)
     end unless @ignore_dependencies
-    return dependencies
+    dependencies
   end
 
   def download_tarballs(graph, default_path, forge)

data/lib/puppet/module_tool/tar/mini.rb

@@ -44,9 +44,9 @@ class Puppet::ModuleTool::Tar::Mini
 
   private
 
-  EXECUTABLE = 0755
-  NOT_EXECUTABLE = 0644
-  USER_EXECUTE = 0100
+  EXECUTABLE = 0o755
+  NOT_EXECUTABLE = 0o644
+  USER_EXECUTE = 0o100
 
   def set_dir_mode!(stats)
     if stats.key?(:mode)

data/lib/puppet/module_tool.rb

@@ -13,7 +13,7 @@ module Puppet
 
     # Directory and names that should not be checksummed.
     ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
-    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+    FULL_MODULE_NAME_PATTERN = %r{\A([^-/|.]+)[-|/](.+)\z}
     REPOSITORY_URL = Puppet.settings[:module_repository]
 
     # Is this a directory that shouldn't be checksummed?
@@ -35,7 +35,7 @@ module Puppet
     def self.username_and_modname_from(full_module_name)
       matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
       if matcher
-        return matcher.captures
+        matcher.captures
       else
         raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
       end
@@ -87,7 +87,7 @@ module Puppet
         str << branch
       end
 
-      return str
+      str
     end
 
     def self.build_tree(mods, dir)
@@ -102,7 +102,7 @@ module Puppet
         mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
         mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
 
-        deps = (mod[:dependencies] || [])
+        deps = mod[:dependencies] || []
         deps.sort_by! { |a| a[:name] }
         build_tree(deps, dir)
       end

data/lib/puppet/network/client_request.rb

@@ -7,7 +7,7 @@ module Puppet::Network # :nodoc:
     attr_accessor :name, :ip, :authenticated, :handler, :method
 
     def authenticated?
-      self.authenticated
+      authenticated
     end
 
     # A common way of talking about the full call.  Individual servers
@@ -20,11 +20,13 @@ module Puppet::Network # :nodoc:
     end
 
     def initialize(name, ip, authenticated)
-      @name, @ip, @authenticated = name, ip, authenticated
+      @name = name
+      @ip = ip
+      @authenticated = authenticated
     end
 
     def to_s
-      "#{self.name}(#{self.ip})"
+      "#{name}(#{ip})"
     end
   end
 end

data/lib/puppet/network/format.rb

@@ -14,7 +14,7 @@ class Puppet::Network::Format
     value = @options.delete(name)
     value = default if value.nil?
 
-    self.send(name.to_s + "=", value)
+    send(name.to_s + "=", value)
   end
 
   def initialize(name, options = {}, &block)
@@ -111,6 +111,6 @@ class Puppet::Network::Format
 
     method = send(name)
 
-    return(type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
+    (type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
   end
 end

data/lib/puppet/network/format_support.rb

@@ -68,7 +68,7 @@ module Puppet::Network::FormatSupport
     end
 
     def friendly_name
-      if self.respond_to? :indirection
+      if respond_to? :indirection
         indirection.name
       else
         self

data/lib/puppet/network/formats.rb

@@ -222,7 +222,7 @@ Puppet::Network::FormatHandler.create(:flat,
           a["#{i}.#{el_k}"] = el_v
         end
       else
-        a["#{i}"] = el
+        a[i.to_s] = el
       end
     end
     a

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

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

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

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

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

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

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

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

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

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

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

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