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

data/lib/puppet/provider/package/aix.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 require_relative '../../../puppet/util/package'
 
@@ -25,10 +26,10 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
   # AIX supports versionable packages with and without a NIM server
   has_feature :versionable
 
-  confine  'os.name' => [ :aix ]
+  confine 'os.name' => [:aix]
   defaultfor 'os.name' => :aix
 
-  attr_accessor   :latest_info
+  attr_accessor :latest_info
 
   STATE_CODE = {
     'A' => :applied,
@@ -40,15 +41,15 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
   }.freeze
 
   def self.srclistcmd(source)
-    [ command(:installp), "-L", "-d", source ]
+    [command(:installp), "-L", "-d", source]
   end
 
   def self.prefetch(packages)
     raise Puppet::Error, _("The aix provider can only be used by root") if Process.euid != 0
 
-    return unless packages.detect { |name, package| package.should(:ensure) == :latest }
+    return unless packages.detect { |_name, package| package.should(:ensure) == :latest }
 
-    sources = packages.collect { |name, package| package[:source] }.uniq.compact
+    sources = packages.collect { |_name, package| package[:source] }.uniq.compact
 
     updates = {}
     sources.each do |source|
@@ -98,7 +99,7 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
 
     pkg = @resource[:name]
 
-    pkg += " #{@resource.should(:ensure)}" if (! @resource.should(:ensure).is_a? Symbol) and useversion
+    pkg += " #{@resource.should(:ensure)}" if (!@resource.should(:ensure).is_a? Symbol) and useversion
 
     output = installp "-acgwXY", "-d", source, pkg
 
@@ -123,7 +124,7 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     end
 
     begin
-      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n,e,s|
+      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n, e, s|
         e = :absent if [:broken, :inconsistent].include?(STATE_CODE[s])
         { :name => n, :ensure => e, :status => STATE_CODE[s], :provider => self.name }
       }

data/lib/puppet/provider/package/appdmg.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Jeff McCune <mccune.jeff@gmail.com>
 # Changed to app.dmg by: Udo Waechter <root@zoide.net>
 # Mac OS X Package Installer which handles application (.app)
@@ -19,7 +20,7 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
   desc "Package management which copies application bundles to a target."
 
   confine 'os.name' => :darwin
-  confine :feature         => :cfpropertylist
+  confine :feature => :cfpropertylist
 
   commands :hdiutil => "/usr/bin/hdiutil"
   commands :curl => "/usr/bin/curl"
@@ -67,27 +68,27 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
         end
       end
 
-      open(cached_source) do |dmg|
+      File.open(cached_source) do |dmg|
         xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
-          ptable = Puppet::Util::Plist::parse_plist(xml_str)
-          # JJM Filter out all mount-paths into a single array, discard the rest.
-          mounts = ptable['system-entities'].collect { |entity|
-            entity['mount-point']
-          }.select { |mountloc|; mountloc }
-          begin
-            found_app = false
-            mounts.each do |fspath|
-              Dir.entries(fspath).select { |f|
-                f =~ /\.app$/i
-              }.each do |pkg|
-                found_app = true
-                installapp("#{fspath}/#{pkg}", name, source)
-              end
+        ptable = Puppet::Util::Plist.parse_plist(xml_str)
+        # JJM Filter out all mount-paths into a single array, discard the rest.
+        mounts = ptable['system-entities'].collect { |entity|
+          entity['mount-point']
+        }.select { |mountloc|; mountloc }
+        begin
+          found_app = false
+          mounts.each do |fspath|
+            Dir.entries(fspath).select { |f|
+              f =~ /\.app$/i
+            }.each do |pkg|
+              found_app = true
+              installapp("#{fspath}/#{pkg}", name, source)
             end
-            Puppet.debug "Unable to find .app in .appdmg. #{name} will not be installed." if !found_app
-          ensure
-            hdiutil "eject", mounts[0]
           end
+          Puppet.debug "Unable to find .app in .appdmg. #{name} will not be installed." if !found_app
+        ensure
+          hdiutil "eject", mounts[0]
+        end
       end
     ensure
       FileUtils.remove_entry_secure(tmpdir, true)
@@ -95,7 +96,7 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
   end
 
   def query
-    Puppet::FileSystem.exist?("/var/db/.puppet_appdmg_installed_#{@resource[:name]}") ? {:name => @resource[:name], :ensure => :present} : nil
+    Puppet::FileSystem.exist?("/var/db/.puppet_appdmg_installed_#{@resource[:name]}") ? { :name => @resource[:name], :ensure => :present } : nil
   end
 
   def install
@@ -107,6 +108,6 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
     unless name
       self.fail _("Mac OS X PKG DMGs must specify a package name.")
     end
-    self.class.installpkgdmg(source,name)
+    self.class.installpkgdmg(source, name)
   end
 end

data/lib/puppet/provider/package/apple.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 # OS X Packaging sucks.  We can install packages, but that's about it.
@@ -15,9 +16,9 @@ Puppet::Type.type(:package).provide :apple, :parent => Puppet::Provider::Package
   def self.instances
     instance_by_name.collect do |name|
       self.new(
-        :name     => name,
+        :name => name,
         :provider => :apple,
-        :ensure   => :installed
+        :ensure => :installed
       )
     end
   end
@@ -34,7 +35,7 @@ Puppet::Type.type(:package).provide :apple, :parent => Puppet::Provider::Package
   end
 
   def query
-    Puppet::FileSystem.exist?("/Library/Receipts/#{@resource[:name]}.pkg") ? {:name => @resource[:name], :ensure => :present} : nil
+    Puppet::FileSystem.exist?("/Library/Receipts/#{@resource[:name]}.pkg") ? { :name => @resource[:name], :ensure => :present } : nil
   end
 
   def install

data/lib/puppet/provider/package/apt.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/package/version/range'
 require_relative '../../../puppet/util/package/version/debian'
 
@@ -51,7 +52,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     hash
   end
 
-  def initialize(value={})
+  def initialize(value = {})
     super(value)
     @property_flush = {}
   end
@@ -77,6 +78,8 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   # Debian boxes, and the only thing that differs is that it can
   # install packages from remote sites.
 
+  # Double negation confuses Rubocop's Layout cops
+  # rubocop:disable Layout
   def checkforcdrom
     have_cdrom = begin
                    !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
@@ -84,10 +87,10 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
                    # This is basically pathological...
                    false
                  end
+  # rubocop:enable Layout
 
     if have_cdrom and @resource[:allowcdrom] != :true
-      raise Puppet::Error,
-        _("/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure.")
+      raise Puppet::Error, _("/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure.")
     end
   end
 
@@ -154,11 +157,13 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     cmd += install_options if @resource[:install_options]
     cmd << :install
 
+    # rubocop:disable Style/RedundantCondition
     if source
       cmd << source
     else
       cmd << str
     end
+    # rubocop:enable Style/RedundantCondition
 
     self.unhold if self.properties[:mark] == :hold
     begin
@@ -177,12 +182,11 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
       raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: version } unless
         insync?(version)
     end
-
   end
 
   # What's the latest package version available?
   def latest
-    output = aptcache :policy,  @resource[:name]
+    output = aptcache :policy, @resource[:name]
 
     if output =~ /Candidate:\s+(\S+)\s/
       return $1
@@ -234,7 +238,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
 
     return false unless is && is != :absent
 
-    #if 'should' is a range and 'is' a debian version we should check if 'should' includes 'is'
+    # if 'should' is a range and 'is' a debian version we should check if 'should' includes 'is'
     should = @resource[:ensure]
 
     return false unless is.is_a?(String) && should.is_a?(String)

data/lib/puppet/provider/package/aptitude.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg do
   desc "Package management via `aptitude`."
 

data/lib/puppet/provider/package/aptrpm.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
   # Provide sorting functionality
   include Puppet::Util::Package
@@ -11,6 +12,9 @@ Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
   commands :aptcache => "apt-cache"
   commands :rpm => "rpm"
 
+  # Mixing confine statements, control expressions, and exception handling
+  # confuses Rubocop's Layout cops, so we disable them entirely.
+  # rubocop:disable Layout
   if command('rpm')
     confine :true => begin
       rpm('-ql', 'rpm')
@@ -20,6 +24,7 @@ Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
         true
       end
   end
+  # rubocop:enable Layout
 
   # Install a package using 'apt-get'.  This function needs to support
   # installing a specific version.
@@ -43,20 +48,18 @@ Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
 
   # What's the latest package version available?
   def latest
-    output = aptcache :showpkg,  @resource[:name]
+    output = aptcache :showpkg, @resource[:name]
 
     if output =~ /Versions:\s*\n((\n|.)+)^$/
       versions = $1
-      available_versions = versions.split(/\n/).collect { |version|
+      available_versions = versions.split(/\n/).filter_map { |version|
         if version =~ /^([^\(]+)\(/
           $1
         else
           self.warning _("Could not match version '%{version}'") % { version: version }
           nil
         end
-      }.reject { |vers| vers.nil? }.sort { |a,b|
-        versioncmp(a,b)
-      }
+      }.sort { |a, b| versioncmp(a, b) }
 
       if available_versions.length == 0
         self.debug "No latest version"

data/lib/puppet/provider/package/blastwave.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Packaging using Blastwave's pkg-get program.
 Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun do
   desc "Package management using Blastwave.org's `pkg-get` command on Solaris."
@@ -16,7 +17,7 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
   def self.extended(mod)
     unless command(:pkgget) != "pkg-get"
       raise Puppet::Error,
-        _("The pkg-get command is missing; blastwave packaging unavailable")
+            _("The pkg-get command is missing; blastwave packaging unavailable")
     end
 
     unless Puppet::FileSystem.exist?("/var/pkg-get/admin")
@@ -40,13 +41,13 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
 
     output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }
 
-    list = output.split("\n").collect do |line|
+    list = output.split("\n").filter_map do |line|
       next if line =~ /^#/
       next if line =~ /^WARNING/
       next if line =~ /localrev\s+remoterev/
 
       blastsplit(line)
-    end.reject { |h| h.nil? }
+    end
 
     if hash[:justme]
       return list[0]
@@ -56,7 +57,6 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
       }
       return list
     end
-
   end
 
   # Split the different lines into hashes.
@@ -65,10 +65,10 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
       hash = {}
       hash[:name] = $1
       hash[:ensure] = if $2 == "[Not installed]"
-        :absent
-      else
-        $2
-      end
+                        :absent
+                      else
+                        $2
+                      end
       hash[:avail] = $5
 
       hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"
@@ -98,7 +98,7 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
     if hash
       hash
     else
-      {:ensure => :absent}
+      { :ensure => :absent }
     end
   end
 

data/lib/puppet/provider/package/dnf.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :dnf, :parent => :yum do
   desc "Support via `dnf`.
 
@@ -19,6 +20,10 @@ Puppet::Type.type(:package).provide :dnf, :parent => :yum do
   # never try to use RPM on a machine without it. We think this
   # has probably become obsolete with the way `commands` work, so
   # we should investigate removing it at some point.
+  #
+  # Mixing confine statements, control expressions, and exception handling
+  # confuses Rubocop's Layout cops, so we disable them entirely.
+  # rubocop:disable Layout
   if command('rpm')
     confine :true => begin
       rpm('--version')
@@ -28,11 +33,13 @@ Puppet::Type.type(:package).provide :dnf, :parent => :yum do
         true
       end
   end
+  # rubocop:enable Layout
 
   defaultfor 'os.name' => :fedora
   notdefaultfor 'os.name' => :fedora, 'os.release.major' => (19..21).to_a
   defaultfor 'os.family' => :redhat
   notdefaultfor 'os.family' => :redhat, 'os.release.major' => (4..7).to_a
+  defaultfor 'os.name' => :amazon, 'os.release.major' => ["2023"]
 
   def self.update_command
     # In DNF, update is deprecated for upgrade

data/lib/puppet/provider/package/dnfmodule.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # dnfmodule - A puppet package provider for DNF modules
 #
 # Installing a module:
@@ -8,13 +9,11 @@
 #   flavor   => 'client',  # install a specific profile
 # }
 
-
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
-
   has_feature :installable, :uninstallable, :versionable, :supports_flavors, :disableable
-  #has_feature :upgradeable
+  # has_feature :upgradeable
   # it's not (yet) feasible to make this upgradeable since module streams don't
   # always have matching version types (i.e. idm has streams DL1 and client,
   # other modules have semver streams, others have string streams... we cannot
@@ -30,6 +29,7 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     if Puppet::Util::Package.versioncmp(current_version, '3.0.1') < 0
       raise Puppet::Error, _("Modules are not supported on DNF versions lower than 3.0.1")
     end
+
     super
   end
 
@@ -39,7 +39,8 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     execute(cmd).each_line do |line|
       # select only lines with actual packages since DNF clutters the output
       next unless line =~ /\[[eix]\][, ]/
-      line.gsub!(/\[d\]/, '')  # we don't care about the default flag
+
+      line.gsub!(/\[d\]/, '') # we don't care about the default flag
 
       flavor = if line.include?('[i]')
                  line.split('[i]').first.split.last
@@ -63,8 +64,8 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
   def query
     pkg = self.class.instances.find do |package|
-            @resource[:name] == package.name
-          end
+      @resource[:name] == package.name
+    end
     pkg ? pkg.properties : nil
   end
 
@@ -94,7 +95,7 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
         # module has no default profile and no profile was requested, so just enable the stream
         # DNF versions prior to 4.2.8 do not need this workaround
         # see https://bugzilla.redhat.com/show_bug.cgi?id=1669527
-        if @resource[:flavor] == nil && e.message =~ /^(?:missing|broken) groups or modules: #{Regexp.quote(@resource[:name])}$/
+        if @resource[:flavor] == nil && e.message =~ /^(?:missing|broken) groups or modules: #{Regexp.quote(args)}$/
           enable(args)
         else
           raise
@@ -121,7 +122,7 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
   def uninstall
     execute([command(:dnf), 'module', 'remove', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
-    reset  # reset module to the default stream
+    reset # reset module to the default stream
   end
 
   def disable(args = @resource[:name])

data/lib/puppet/provider/package/dpkg.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package do
@@ -48,7 +49,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   self::DPKG_QUERY_PROVIDES_FORMAT_STRING = %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}
   self::FIELDS_REGEX = %r{^'?(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
   self::FIELDS_REGEX_WITH_PROVIDES = %r{^'?(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$}
-  self::FIELDS= [:desired, :error, :status, :name, :ensure]
+  self::FIELDS = [:desired, :error, :status, :name, :ensure]
 
   def self.defaultto_allow_virtual
     false
@@ -57,14 +58,14 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   # @param line [String] one line of dpkg-query output
   # @return [Hash,nil] a hash of FIELDS or nil if we failed to match
   # @api private
-  def self.parse_line(line, regex=self::FIELDS_REGEX)
+  def self.parse_line(line, regex = self::FIELDS_REGEX)
     hash = nil
 
     match = regex.match(line)
     if match
       hash = {}
 
-      self::FIELDS.zip(match.captures) do |field,value|
+      self::FIELDS.zip(match.captures) do |field, value|
         hash[field] = value
       end
 
@@ -90,8 +91,8 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     unless file
       raise ArgumentError, _("You cannot install dpkg packages without a source")
     end
-    args = []
 
+    args = []
 
     if @resource[:configfiles] == :keep
       args << '--force-confold'
@@ -120,7 +121,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     output = dpkg_deb "--show", source
     matches = /^(\S+)\t(\S+)$/.match(output).captures
-    warning _("source doesn't contain named package, but %{name}") % { name: matches[0] } unless matches[0].match( Regexp.escape(@resource[:name]) )
+    warning _("source doesn't contain named package, but %{name}") % { name: matches[0] } unless matches[0].match(Regexp.escape(@resource[:name]))
     matches[1]
   end
 
@@ -134,11 +135,11 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
           "-W",
           "--showformat",
           self.class::DPKG_QUERY_PROVIDES_FORMAT_STRING
-          #the regex searches for the resource[:name] in the dpkquery result in which the Provides field is also available
-          #it will search for the packages only in the brackets ex: [rubygems]
-        ).lines.find {|package| package.match(/[\[ ](#{Regexp.escape(@resource[:name])})[\],]/)}
+          # the regex searches for the resource[:name] in the dpkquery result in which the Provides field is also available
+          # it will search for the packages only in the brackets ex: [rubygems]
+        ).lines.find { |package| package.match(/[\[ ](#{Regexp.escape(@resource[:name])})[\],]/) }
         if output
-          hash = self.class.parse_line(output,self.class::FIELDS_REGEX_WITH_PROVIDES)
+          hash = self.class.parse_line(output, self.class::FIELDS_REGEX_WITH_PROVIDES)
           Puppet.info("Package #{@resource[:name]} is virtual, defaulting to #{hash[:name]}")
           @resource[:name] = hash[:name]
         end
@@ -152,10 +153,10 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
       hash = self.class.parse_line(output)
     rescue Puppet::ExecutionFailure
       # dpkg-query exits 1 if the package is not found.
-      return {:ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok'}
+      return { :ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok' }
     end
 
-    hash ||= {:ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok'}
+    hash ||= { :ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok' }
 
     if hash[:error] != "ok"
       raise Puppet::Error.new(
@@ -189,5 +190,4 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
       execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
     end
   end
-
 end

data/lib/puppet/provider/package/fink.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   # Provide sorting functionality
   include Puppet::Util::Package
@@ -48,7 +49,7 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
 
   # What's the latest package version available?
   def latest
-    output = aptcache :policy,  @resource[:name]
+    output = aptcache :policy, @resource[:name]
 
     if output =~ /Candidate:\s+(\S+)\s/
       return $1

data/lib/puppet/provider/package/freebsd.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
   desc "The specific form of package management on FreeBSD.  This is an
     extremely quirky packaging system, in that it freely mixes between
@@ -7,8 +8,8 @@ Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
     libraries."
 
   commands :pkginfo => "/usr/sbin/pkg_info",
-    :pkgadd => "/usr/sbin/pkg_add",
-    :pkgdelete => "/usr/sbin/pkg_delete"
+           :pkgadd => "/usr/sbin/pkg_add",
+           :pkgdelete => "/usr/sbin/pkg_delete"
 
   confine 'os.name' => :freebsd
 

data/lib/puppet/provider/package/gem.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/package/version/gem'
 require_relative '../../../puppet/util/package/version/range'
 require_relative '../../../puppet/provider/package_targetable'
@@ -56,9 +57,11 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
   # that contains the content of PATH but without puppet/bin dir.
   # This is used to pass a custom PATH and execute commands in a controlled environment
   def self.windows_path_without_puppet_bin
+    # rubocop:disable Naming/MemoizedInstanceVariableName
     @path ||= ENV['PATH'].split(File::PATH_SEPARATOR)
                          .reject { |dir| dir =~ /puppet\\bin$/ }
                          .join(File::PATH_SEPARATOR)
+    # rubocop:enable Naming/MemoizedInstanceVariableName
   end
 
   private_class_method :windows_path_without_puppet_bin
@@ -74,13 +77,13 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     validate_command(command)
     cmd = [command] << command_options
 
-    custom_environment = {'HOME'=>ENV['HOME']}.merge(custom_environment)
+    custom_environment = { 'HOME' => ENV.fetch('HOME', nil) }.merge(custom_environment)
 
     if Puppet::Util::Platform.windows?
       custom_environment[:PATH] = windows_path_without_puppet_bin
     end
 
-    execute(cmd, {:failonfail => true, :combine => true, :custom_environment => custom_environment})
+    execute(cmd, { :failonfail => true, :combine => true, :custom_environment => custom_environment })
   end
 
   def self.instances(target_command = nil)
@@ -116,9 +119,8 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
 
     begin
-      list = execute_gem_command(options[:command], command_options).lines.
-        map {|set| gemsplit(set) }.
-        reject {|x| x.nil? }
+      list = execute_gem_command(options[:command], command_options).lines
+                                                                    .filter_map { |set| gemsplit(set) }
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
     end
@@ -141,8 +143,8 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
       gem_name = $1
       versions = $2.sub('default: ', '').split(/,\s*/)
       {
-        :name     => gem_name,
-        :ensure   => versions.map{|v| v.split[0]},
+        :name => gem_name,
+        :ensure => versions.map { |v| v.split[0] },
         :provider => name
       }
     else
@@ -153,6 +155,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
 
   def insync?(is)
     return false unless is && is != :absent
+
     is = [is] unless is.is_a? Array
     should = @resource[:ensure]
 
@@ -209,8 +212,8 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
 
     if Puppet::Util::Platform.windows?
       command_options << "-v" << %Q["#{should}"] if useversion && !should.is_a?(Symbol)
-    else
-      command_options << "-v" << should if useversion && !should.is_a?(Symbol)
+    elsif useversion && !should.is_a?(Symbol)
+      command_options << "-v" << should
     end
 
     if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1