puppet 8.5.0-x86-mingw32 → 8.6.0-x86-mingw32

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
 

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

@@ -32,14 +32,14 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
   def self.provider_command
     # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
-    self.cmd.map { |c| which(c) }.find { |c| c != nil }
+    cmd.map { |c| which(c) }.find { |c| !c.nil? }
   end
 
   def self.cmd
     if Puppet::Util::Platform.windows?
       ["pip.exe"]
     else
-      ["pip", "pip-python", "pip2", "pip-2"]
+      %w[pip pip-python pip2 pip-2]
     end
   end
 
@@ -65,7 +65,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   def self.instances(target_command = nil)
     if target_command
       command = target_command
-      self.validate_command(command)
+      validate_command(command)
     else
       command = provider_command
     end
@@ -74,7 +74,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     return packages unless command
 
     command_options = ['freeze']
-    command_version = self.pip_version(command)
+    command_version = pip_version(command)
     if compare_pip_versions(command_version, '8.1.0') >= 0
       command_options << '--all'
     end
@@ -101,9 +101,12 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   # Parse lines of output from `pip freeze`, which are structured as:
   # _package_==_version_ or _package_===_version_
+  # or _package_ @ someURL@_version_
   def self.parse(line)
     if line.chomp =~ /^([^=]+)===?([^=]+)$/
-      { :ensure => $2, :name => $1, :provider => name }
+      { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
+    elsif line.chomp =~ /^([^@]+) @ [^@]+@(.+)$/
+      { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
     end
   end
 
@@ -116,7 +119,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     self.class.instances(command).each do |pkg|
       return pkg.properties if @resource[:name].casecmp(pkg.name).zero?
     end
-    return nil
+    nil
   end
 
   # Return latest version available for current package
@@ -133,12 +136,10 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   end
 
   def self.compare_pip_versions(x, y)
-    begin
-      Puppet::Util::Package::Version::Pip.compare(x, y)
-    rescue PIP_VERSION::ValidationFailure => ex
-      Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
-      Puppet::Util::Package.versioncmp(x, y)
-    end
+    Puppet::Util::Package::Version::Pip.compare(x, y)
+  rescue PIP_VERSION::ValidationFailure => ex
+    Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
+    Puppet::Util::Package.versioncmp(x, y)
   end
 
   # Use pip CLI to look up versions from PyPI repositories,
@@ -166,12 +167,12 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     execpipe command_and_options do |process|
       process.collect do |line|
         # PIP OUTPUT: Could not find a version that satisfies the requirement example==versionplease (from versions: 1.2.3, 4.5.6)
-        if line =~ /from versions: (.+)\)/
-          versionList = $1.split(', ').sort do |x, y|
-            self.class.compare_pip_versions(x, y)
-          end
-          return versionList
+        next unless line =~ /from versions: (.+)\)/
+
+        versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+          self.class.compare_pip_versions(x, y)
         end
+        return versionList
       end
     end
     []
@@ -182,17 +183,17 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     self.class.validate_command(command)
 
     Dir.mktmpdir("puppet_pip") do |dir|
-      command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}", '-d', "#{dir}", '-v']
+      command_and_options = [self.class.quote(command), 'install', (@resource[:name]).to_s, '-d', dir.to_s, '-v']
       command_and_options << install_options if @resource[:install_options]
       execpipe command_and_options do |process|
         process.collect do |line|
           # PIP OUTPUT: Using version 0.10.1 (newest of versions: 1.2.3, 4.5.6)
-          if line =~ /Using version .+? \(newest of versions: (.+?)\)/
-            versionList = $1.split(', ').sort do |x, y|
-              self.class.compare_pip_versions(x, y)
-            end
-            return versionList
+          next unless line =~ /Using version .+? \(newest of versions: (.+?)\)/
+
+          versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+            self.class.compare_pip_versions(x, y)
           end
+          return versionList
         end
       end
       return []
@@ -216,7 +217,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   def get_install_command_options
     should = @resource[:ensure]
-    command_options = %w{install -q}
+    command_options = %w[install -q]
     command_options += install_options if @resource[:install_options]
 
     if @resource[:source]

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

@@ -53,7 +53,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
         { :status => 'known' }
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[0..0] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[0..0] }
       end
     ).merge(
       case flags[1..1]
@@ -63,7 +63,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
         {}
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[1..1] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[1..1] }
       end
     )
   end
@@ -93,7 +93,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     when /known/
       { :status => 'known' }
     else
-      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: self.name, state: state }
+      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: name, state: state }
     end
   end
 
@@ -103,17 +103,17 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     (case line.chomp
      # FMRI                                                                         IFO
      # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
-     when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
-       { :publisher => $1, :name => $2, :ensure => $3 }.merge ifo_flag($4)
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(...)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge ifo_flag(Regexp.last_match(4))
 
      # FMRI                                                             STATE      UFOXI
      # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
-     when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
-       { :publisher => $1, :name => $2, :ensure => $3 }.merge pkg_state($4).merge(ufoxi_flag($5))
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge pkg_state(Regexp.last_match(4)).merge(ufoxi_flag(Regexp.last_match(5)))
 
      else
-       raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: self.name, parse_line: line }
-     end).merge({ :provider => self.name })
+       raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: name, parse_line: line }
+     end).merge({ :provider => name })
   end
 
   def hold
@@ -223,7 +223,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   def install(nofail = false)
     name = @resource[:name]
     should = @resource[:ensure]
-    is = self.query
+    is = query
     if is[:ensure].to_sym == :absent
       command = 'install'
     else
@@ -237,12 +237,12 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     unless should.is_a? Symbol
       name += "@#{should}"
     end
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       tries = 1
       # pkg install exits with code 7 when the image is currently in use by another process and cannot be modified
       r = exec_cmd(command(:pkg), command, *args, name)
-      while r[:exit] == 7 do
+      while r[:exit] == 7
         if tries > 4
           raise Puppet::Error, _("Pkg could not install %{name} after %{tries} tries. Aborting run") % { name: name, tries: tries }
         end
@@ -252,7 +252,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
         r = exec_cmd(command(:pkg), command, *args, name)
       end
     ensure
-      self.hold if @resource[:mark] == :hold
+      hold if @resource[:mark] == :hold
     end
     return r if nofail
     raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] } if r[:exit] != 0
@@ -267,11 +267,11 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       cmd << '-r'
     end
     cmd << @resource[:name]
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       pkg cmd
     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/pkgdmg.rb

@@ -77,7 +77,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     end
 
     unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file"))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file")
     end
 
     require 'open-uri' # Dead code; this is never used. The File.open call 20-ish lines south of here used to be Kernel.open but changed in '09. -NF
@@ -85,19 +85,19 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     tmpdir = Dir.mktmpdir
     ext = /(\.dmg|\.pkg)$/i.match(source)[0]
     begin
-      if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+      if %r{\A[A-Za-z][A-Za-z0-9+\-.]*://} =~ cached_source
         cached_source = File.join(tmpdir, "#{name}#{ext}")
         args = ["-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source]
         if http_proxy_host and http_proxy_port
           args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
-        elsif http_proxy_host and not http_proxy_port
+        elsif http_proxy_host and !http_proxy_port
           args << "--proxy" << http_proxy_host
         end
         begin
           curl(*args)
-          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(' ')})"
         rescue Puppet::ExecutionFailure
-          Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
+          Puppet.debug "curl #{args.join(' ')} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source
         end
       end
@@ -107,7 +107,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         File.open(cached_source) do |dmg|
           xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
           hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
-          raise Puppet::Error.new(_("No disk entities returned by mount at %{path}") % { path: dmg.path }) unless hdiutil_info.has_key?("system-entities")
+          raise Puppet::Error, _("No disk entities returned by mount at %{path}") % { path: dmg.path } unless hdiutil_info.has_key?("system-entities")
 
           mounts = hdiutil_info["system-entities"].filter_map { |entity|
             entity["mount-point"]
@@ -137,21 +137,21 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def query
     if Puppet::FileSystem.exist?("/var/db/.puppet_pkgdmg_installed_#{@resource[:name]}")
       Puppet.debug "/var/db/.puppet_pkgdmg_installed_#{@resource[:name]} found"
-      return { :name => @resource[:name], :ensure => :present }
+      { :name => @resource[:name], :ensure => :present }
     else
-      return nil
+      nil
     end
   end
 
   def install
     source = @resource[:source]
     unless source
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package source."))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package source.")
     end
 
     name = @resource[:name]
     unless name
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package name."))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package name.")
     end
 
     self.class.installpkgdmg(source, name)