puppet 8.5.1 → 8.6.0

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

@@ -45,10 +45,10 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
 
   # Note: self:: is required here to keep these constants in the context of what will
   # eventually become this Puppet::Type::Package::ProviderDpkg class.
-  self::DPKG_QUERY_FORMAT_STRING = %Q{'${Status} ${Package} ${Version}\\n'}
-  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::DPKG_QUERY_FORMAT_STRING = "'${Status} ${Package} ${Version}\\n'"
+  self::DPKG_QUERY_PROVIDES_FORMAT_STRING = "'${Status} ${Package} ${Version} [${Provides}]\\n'"
+  self::FIELDS_REGEX = /^'?(\S+) +(\S+) +(\S+) (\S+) (\S*)$/
+  self::FIELDS_REGEX_WITH_PROVIDES = /^'?(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$/
   self::FIELDS = [:desired, :error, :status, :name, :ensure]
 
   def self.defaultto_allow_virtual
@@ -69,11 +69,11 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
         hash[field] = value
       end
 
-      hash[:provider] = self.name
+      hash[:provider] = name
 
       if hash[:status] == 'not-installed'
         hash[:ensure] = :purged
-      elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
+      elsif %w[config-files half-installed unpacked half-configured].include?(hash[:status])
         hash[:ensure] = :absent
       end
       hash[:mark] = hash[:desired] == 'hold' ? :hold : :none
@@ -81,7 +81,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
       Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
     end
 
-    return hash
+    hash
   end
 
   public
@@ -101,16 +101,16 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     args << '-i' << file
 
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       dpkg(*args)
     ensure
-      self.hold if @resource[:mark] == :hold
+      hold if @resource[:mark] == :hold
     end
   end
 
   def update
-    self.install
+    install
   end
 
   # Return the version from the package.
@@ -159,9 +159,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     hash ||= { :ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok' }
 
     if hash[:error] != "ok"
-      raise Puppet::Error.new(
-        "Package #{hash[:name]}, version #{hash[:ensure]} is in error state: #{hash[:error]}"
-      )
+      raise Puppet::Error, "Package #{hash[:name]}, version #{hash[:ensure]} is in error state: #{hash[:error]}"
     end
 
     hash

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

@@ -24,7 +24,7 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   # Install a package using 'apt-get'.  This function needs to support
   # installing a specific version.
   def install
-    self.run_preseed if @resource[:responsefile]
+    run_preseed if @resource[:responsefile]
     should = @resource.should(:ensure)
 
     str = @resource[:name]
@@ -35,15 +35,15 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
       # Add the package version
       str += "=#{should}"
     end
-    cmd = %w{-b -q -y}
+    cmd = %w[-b -q -y]
 
     cmd << :install << str
 
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       finkcmd(cmd)
     ensure
-      self.hold if @resource[:mark] == :hold
+      hold if @resource[:mark] == :hold
     end
   end
 
@@ -52,10 +52,10 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
     output = aptcache :policy, @resource[:name]
 
     if output =~ /Candidate:\s+(\S+)\s/
-      return $1
+      Regexp.last_match(1)
     else
-      self.err _("Could not find latest version")
-      return nil
+      err _("Could not find latest version")
+      nil
     end
   end
 
@@ -65,34 +65,34 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   def run_preseed
     response = @resource[:responsefile]
     if response && Puppet::FileSystem.exist?(response)
-      self.info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
+      info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
 
       preseed response
     else
-      self.info _("No responsefile specified or non existent, not preseeding anything")
+      info _("No responsefile specified or non existent, not preseeding anything")
     end
   end
 
   def update
-    self.install
+    install
   end
 
   def uninstall
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       finkcmd "-y", "-q", :remove, @model[:name]
     rescue StandardError, LoadError => e
-      self.hold if self.properties[:mark] == :hold
+      hold if properties[:mark] == :hold
       raise e
     end
   end
 
   def purge
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       aptget '-y', '-q', 'remove', '--purge', @resource[:name]
     rescue StandardError, LoadError => e
-      self.hold if self.properties[:mark] == :hold
+      hold if properties[:mark] == :hold
       raise e
     end
   end

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

@@ -18,7 +18,7 @@ Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
   end
 
   def install
-    if @resource[:source] =~ /\/$/
+    if @resource[:source] =~ %r{/$}
       if @resource[:source] =~ /^(ftp|https?):/
         Puppet::Util.withenv :PACKAGESITE => @resource[:source] do
           pkgadd "-r", @resource[:name]

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

@@ -126,9 +126,9 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
 
     if options[:justme]
-      return list.shift
+      list.shift
     else
-      return list
+      list
     end
   end
 
@@ -140,8 +140,8 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     # so we don't need to check for them
 
     if desc =~ /^(\S+)\s+\((.+)\)/
-      gem_name = $1
-      versions = $2.sub('default: ', '').split(/,\s*/)
+      gem_name = Regexp.last_match(1)
+      versions = Regexp.last_match(2).sub('default: ', '').split(/,\s*/)
       {
         :name => gem_name,
         :ensure => versions.map { |v| v.split[0] },
@@ -168,12 +168,10 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
       end
 
       return is.any? do |version|
-        begin
-          should_range.include?(GEM_VERSION.parse(version))
-        rescue GEM_VERSION::ValidationFailure
-          Puppet.debug("Cannot parse #{version} as a ruby gem version")
-          false
-        end
+        should_range.include?(GEM_VERSION.parse(version))
+      rescue GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{version} as a ruby gem version")
+        false
       end
     end
 
@@ -211,7 +209,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
 
     if Puppet::Util::Platform.windows?
-      command_options << "-v" << %Q["#{should}"] if useversion && !should.is_a?(Symbol)
+      command_options << "-v" << %Q("#{should}") if useversion && !should.is_a?(Symbol)
     elsif useversion && !should.is_a?(Symbol)
       command_options << "-v" << should
     end
@@ -238,14 +236,14 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
         command_options << uri.path
       when 'puppet'
         # we don't support puppet:// URLs (yet)
-        raise Puppet::Error.new(_("puppet:// URLs are not supported as gem sources"))
+        raise Puppet::Error, _("puppet:// URLs are not supported as gem sources")
       else
         # check whether it's an absolute file path to help Windows out
         if Puppet::Util.absolute_path?(source)
           command_options << source
         else
           # interpret it as a gem repository
-          command_options << "--source" << "#{source}" << resource[:name]
+          command_options << "--source" << source.to_s << resource[:name]
         end
       end
     else
@@ -284,7 +282,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
   end
 
   def update
-    self.install(false)
+    install(false)
   end
 
   def install_options

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

@@ -44,7 +44,7 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
       fields.zip(match.captures) { |field, value|
         hash[field] = value
       }
-      hash[:provider] = self.name
+      hash[:provider] = name
       return hash
     end
     nil
@@ -76,7 +76,7 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
     result = self.class.parse_installed_query_line(execute([command(:port), "-q", :installed, @resource[:name]], :failonfail => false, :combine => false))
     return {} if result.nil?
 
-    return result
+    result
   end
 
   def latest

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

@@ -81,7 +81,7 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     # switch back to the metaprogrammed stuff, and just parse all of the output
     # in Ruby... but we'd be doing an awful lot of unnecessary work.
     showres_command = "/usr/sbin/nimclient -o showres -a resource=#{source} |/usr/bin/grep -p -E "
-    if (version_specified)
+    if version_specified
       version = @resource.should(:ensure)
       showres_command << "'#{Regexp.escape(pkg)}( |-)#{Regexp.escape(version)}'"
     else
@@ -90,13 +90,13 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     end
     output = Puppet::Util::Execution.execute(showres_command)
 
-    if (version_specified)
+    if version_specified
       package_type = determine_package_type(output, pkg, version)
     else
       package_type, version = determine_latest_version(output, pkg)
     end
 
-    if (package_type == nil)
+    if package_type.nil?
 
       errmsg = if version_specified
                  _("Unable to find package '%{package}' with version '%{version}' on lpp_source '%{source}'") %
@@ -112,10 +112,10 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     # to add that value to our installation command.  However, if there is only
     # one version of the package available, `version` will be set to `nil`, and
     # we don't need to add the version string to the command.
-    if (version)
+    if version
       # Now we know if the package type is RPM or not, and we can adjust our
       # `pkg` string for passing to the install command accordingly.
-      if (package_type == :rpm)
+      if package_type == :rpm
         # RPMs expect a hyphen between the package name and the version number
         version_separator = "-"
       else
@@ -202,7 +202,7 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
   # leading or trailing whitespace (including newlines) from the resulting
   # strings and then returns them as an array.
   def split_into_paragraphs(showres_output)
-    showres_output.split(/^\s*$/).map { |p| p.strip! }
+    showres_output.split(/^\s*$/).map(&:strip!)
   end
 
   def parse_showres_header_line(line)
@@ -269,19 +269,19 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
       return nil
     end
 
-    if (packages[package_name].count == 1)
+    if packages[package_name].count == 1
       version = packages[package_name].keys[0]
-      return packages[package_name][version], nil
+      [packages[package_name][version], nil]
     else
       versions = packages[package_name].keys
       latest_version = (versions.sort { |a, b| Puppet::Util::Package.versioncmp(b, a) })[0]
-      return packages[package_name][latest_version], latest_version
+      [packages[package_name][latest_version], latest_version]
     end
   end
 
   def determine_package_type(showres_output, package_name, version)
     packages = parse_showres_output(showres_output)
-    unless (packages.has_key?(package_name) and packages[package_name].has_key?(version))
+    unless packages.has_key?(package_name) and packages[package_name].has_key?(version)
       return nil
     end
 

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

@@ -30,7 +30,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     begin
       execpipe(listcmd) do |process|
         # our regex for matching pkg_info output
-        regex = /^(.*)-(\d[^-]*)[-]?([\w-]*)(.*)$/
+        regex = /^(.*)-(\d[^-]*)-?([\w-]*)(.*)$/
         fields = [:name, :ensure, :flavor]
         hash = {}
 
@@ -42,7 +42,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
               hash[field] = value
             }
 
-            hash[:provider] = self.name
+            hash[:provider] = name
 
             packages << new(hash)
             hash = {}
@@ -56,9 +56,9 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
         }
       end
 
-      return packages
+      packages
     rescue Puppet::ExecutionFailure
-      return nil
+      nil
     end
   end
 
@@ -89,35 +89,35 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
       return version
     else
       # Remove all fuzzy matches first.
-      output = output.split.select { |p| p =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*)/ }.join
+      output = output.split.select { |p| p =~ /^#{resource[:name]}-(\d[^-]*)-?(\w*)/ }.join
       debug "pkg_info -Q for #{resource[:name]}: #{output}"
     end
 
-    if output =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*) \(installed\)$/
+    if output =~ /^#{resource[:name]}-(\d[^-]*)-?(\w*) \(installed\)$/
       debug "Package is already the latest available"
-      return version
+      version
     else
-      match = /^(.*)-(\d[^-]*)[-]?(\w*)$/.match(output)
+      match = /^(.*)-(\d[^-]*)-?(\w*)$/.match(output)
       debug "Latest available for #{resource[:name]}: #{match[2]}"
 
       if version.to_sym == :absent || version.to_sym == :purged
         return match[2]
       end
 
-      vcmp = version.split('.').map { |s| s.to_i } <=> match[2].split('.').map { |s| s.to_i }
+      vcmp = version.split('.').map(&:to_i) <=> match[2].split('.').map(&:to_i)
       if vcmp > 0
         # The locally installed package may actually be newer than what a mirror
         # has. Log it at debug, but ignore it otherwise.
         debug "Package #{resource[:name]} #{version} newer then available #{match[2]}"
-        return version
+        version
       else
-        return match[2]
+        match[2]
       end
     end
   end
 
   def update
-    self.install(true)
+    install(true)
   end
 
   def parse_pkgconf
@@ -201,19 +201,19 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   def get_version
     execpipe([command(:pkginfo), "-I", @resource[:name]]) do |process|
       # our regex for matching pkg_info output
-      regex = /^(.*)-(\d[^-]*)[-]?(\w*)(.*)$/
+      regex = /^(.*)-(\d[^-]*)-?(\w*)(.*)$/
       master_version = 0
       version = -1
 
       process.each_line do |line|
         match = regex.match(line.split[0])
-        if match
-          # now we return the first version, unless ensure is latest
-          version = match.captures[1]
-          return version unless @resource[:ensure] == "latest"
+        next unless match
 
-          master_version = version unless master_version > version
-        end
+        # now we return the first version, unless ensure is latest
+        version = match.captures[1]
+        return version unless @resource[:ensure] == "latest"
+
+        master_version = version unless master_version > version
       end
 
       return master_version unless master_version == 0
@@ -222,15 +222,15 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
       raise Puppet::Error, _("%{version} is not available for this package") % { version: version }
     end
   rescue Puppet::ExecutionFailure
-    return nil
+    nil
   end
 
   def query
     # Search for the version info
     if pkginfo(@resource[:name]) =~ /Information for (inst:)?#{@resource[:name]}-(\S+)/
-      return { :ensure => $2 }
+      { :ensure => Regexp.last_match(2) }
     else
-      return nil
+      nil
     end
   end
 

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

@@ -13,7 +13,7 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
   def self.instances
     packages = []
     execpipe("#{command(:opkg)} list-installed") do |process|
-      regex = %r{^(\S+) - (\S+)}
+      regex = /^(\S+) - (\S+)/
       fields = [:name, :ensure]
       hash = {}
 
@@ -21,7 +21,7 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
         match = regex.match(line)
         if match
           fields.zip(match.captures) { |field, value| hash[field] = value }
-          hash[:provider] = self.name
+          hash[:provider] = name
           packages << new(hash)
           hash = {}
         else
@@ -31,7 +31,7 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
     end
     packages
   rescue Puppet::ExecutionFailure
-    return nil
+    nil
   end
 
   def latest
@@ -57,19 +57,19 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
   end
 
   def update
-    self.install
+    install
   end
 
   def query
     # list out our specific package
     output = opkg('list-installed', @resource[:name])
     if output =~ /^(\S+) - (\S+)/
-      return { :ensure => $2 }
+      return { :ensure => Regexp.last_match(2) }
     end
 
     nil
   rescue Puppet::ExecutionFailure
-    return {
+    {
       :ensure => :purged,
       :status => 'missing',
       :name => @resource[:name],

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

@@ -25,15 +25,14 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   has_feature :uninstall_options
   has_feature :upgradeable
   has_feature :virtual_packages
+  has_feature :purgeable
 
   # Checks if a given name is a group
   def self.group?(name)
-    begin
-      !pacman("-Sg", name).empty?
-    rescue Puppet::ExecutionFailure
-      # pacman returns an expected non-zero exit code when the name is not a group
-      false
-    end
+    !pacman("-Sg", name).empty?
+  rescue Puppet::ExecutionFailure
+    # pacman returns an expected non-zero exit code when the name is not a group
+    false
   end
 
   # Install a package using 'pacman', or 'yaourt' if available.
@@ -46,7 +45,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       install_from_repo
     end
 
-    unless self.query
+    unless query
       fail(_("Could not find package '%{name}'") % { name: @resource[:name] })
     end
   end
@@ -74,24 +73,22 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # returns a hash package => version of installed packages
   def self.get_installed_packages
-    begin
-      packages = {}
-      execpipe([command(:pacman), "-Q"]) do |pipe|
-        # pacman -Q output is 'packagename version-rel'
-        regex = %r{^(\S+)\s(\S+)}
-        pipe.each_line do |line|
-          match = regex.match(line)
-          if match
-            packages[match.captures[0]] = match.captures[1]
-          else
-            warning(_("Failed to match line '%{line}'") % { line: line })
-          end
+    packages = {}
+    execpipe([command(:pacman), "-Q"]) do |pipe|
+      # pacman -Q output is 'packagename version-rel'
+      regex = /^(\S+)\s(\S+)/
+      pipe.each_line do |line|
+        match = regex.match(line)
+        if match
+          packages[match.captures[0]] = match.captures[1]
+        else
+          warning(_("Failed to match line '%{line}'") % { line: line })
         end
       end
-      packages
-    rescue Puppet::ExecutionFailure
-      fail(_("Error getting installed packages"))
     end
+    packages
+  rescue Puppet::ExecutionFailure
+    fail(_("Error getting installed packages"))
   end
 
   # returns a hash of group => version of installed groups
@@ -129,7 +126,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   # should always result in the newest release.
   def update
     # Install in pacman can be used for update, too
-    self.install
+    install
   end
 
   # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
@@ -137,7 +134,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     resource_name = @resource[:name]
 
     # If target is a group, construct the group version
-    return pacman("-Sp", "--print-format", "%n %v", resource_name).lines.map { |line| line.chomp }.sort.join(', ') if self.class.group?(resource_name)
+    return pacman("-Sp", "--print-format", "%n %v", resource_name).lines.map(&:chomp).sort.join(', ') if self.class.group?(resource_name)
 
     # Start by querying with pacman first
     # If that fails, retry using yaourt against the AUR
@@ -145,7 +142,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     begin
       if pacman_check
         output = pacman "-Sp", "--print-format", "%v", resource_name
-        return output.chomp
+        output.chomp
       else
         output = yaourt "-Qma", resource_name
         output.split("\n").each do |line|
@@ -195,16 +192,27 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # Removes a package from the system.
   def uninstall
+    remove_package(false)
+  end
+
+  def purge
+    remove_package(true)
+  end
+
+  private
+
+  def remove_package(purge_configs = false)
     resource_name = @resource[:name]
 
     is_group = self.class.group?(resource_name)
 
     fail(_("Refusing to uninstall package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if is_group && !@resource.allow_virtual?
 
-    cmd = %w{--noconfirm --noprogressbar}
+    cmd = %w[--noconfirm --noprogressbar]
     cmd += uninstall_options if @resource[:uninstall_options]
     cmd << "-R"
     cmd << '-s' if is_group
+    cmd << '--nosave' if purge_configs
     cmd << resource_name
 
     if self.class.yaourt?
@@ -214,8 +222,6 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     end
   end
 
-  private
-
   def install_options
     join_options(@resource[:install_options])
   end
@@ -252,7 +258,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     # Refuse to install if not allowing virtual packages and the resource is a group
     fail(_("Refusing to install package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if self.class.group?(resource_name) && !@resource.allow_virtual?
 
-    cmd = %w{--noconfirm --needed --noprogressbar}
+    cmd = %w[--noconfirm --needed --noprogressbar]
     cmd += install_options if @resource[:install_options]
     cmd << "-S" << resource_name