puppet 8.5.0-universal-darwin → 8.6.0-universal-darwin

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

@@ -77,9 +77,9 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
   def latest
     package = parse_pkgsearch_line.detect { |p| p[:status] == '<' }
-    return properties[:ensure] if not package
+    return properties[:ensure] unless package
 
-    return package[:ensure]
+    package[:ensure]
   end
 
   def update

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

@@ -64,7 +64,7 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
   def self.instances
     packages = []
     begin
-      info = self.get_query
+      info = get_query
       get_version_list
 
       unless info
@@ -76,9 +76,9 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
         packages << new(hash)
       end
 
-      return packages
+      packages
     rescue Puppet::ExecutionFailure
-      return []
+      []
     end
   end
 
@@ -113,14 +113,14 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
       # just 'curl'), drop the category prefix. pkgng doesn't support version
       # pinning with the origin syntax (pkg install curl-1.2.3 is valid, but
       # pkg install www/curl-1.2.3 is not).
-      if resource[:name] =~ /\//
+      if resource[:name] =~ %r{/}
         installname = resource[:name].split('/')[1] + '-' + resource[:ensure]
       else
         installname = resource[:name] + '-' + resource[:ensure]
       end
     end
 
-    if not source # install using default repo logic
+    if !source # install using default repo logic
       args = ['install', '-qy']
     elsif source.scheme == 'urn' # install from repo named in URN
       tag = repo_tag_from_urn(source.to_s)

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

@@ -27,7 +27,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
         conf.each_line { |line| correct_wgetopts = true if line =~ /^\s*wgetopts\s*=.*(-nv|-q|--no-verbose|--quiet)/ }
       end
     end
-    if !correct_wgetopts
+    unless correct_wgetopts
       Puppet.notice _("It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf.")
     end
   end
@@ -50,11 +50,11 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
 
       # Create a second instance with the alias if it's different
       pkgalias = aliases[pkg[:name]]
-      if pkgalias and pkg[:name] != pkgalias
-        apkg = pkg.dup
-        apkg[:name] = pkgalias
-        pkginsts << new(apkg)
-      end
+      next unless pkgalias and pkg[:name] != pkgalias
+
+      apkg = pkg.dup
+      apkg[:name] = pkgalias
+      pkginsts << new(apkg)
     end
 
     pkginsts
@@ -70,7 +70,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
       next if noise?(line)
 
       if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
-        { :alias => $1, :name => $2, :avail => $3 }
+        { :alias => Regexp.last_match(1), :name => Regexp.last_match(2), :avail => Regexp.last_match(3) }
       else
         Puppet.warning _("Cannot match %{line}") % { line: line }
       end
@@ -105,11 +105,11 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
       # Single queries may have been for an alias so return the name requested
       if list.any?
         list[-1][:name] = hash[:justme]
-        return list[-1]
+        list[-1]
       end
     else
       list.reject! { |h| h[:ensure] == :absent }
-      return list
+      list
     end
   end
 
@@ -127,25 +127,25 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
   def self.pkgsplit(line)
     if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
       hash = {}
-      hash[:name] = $1
-      hash[:ensure] = if $2 == "notinst"
+      hash[:name] = Regexp.last_match(1)
+      hash[:ensure] = if Regexp.last_match(2) == "notinst"
                         :absent
                       else
-                        $2
+                        Regexp.last_match(2)
                       end
-      hash[:avail] = $3
+      hash[:avail] = Regexp.last_match(3)
 
       if hash[:avail] =~ /^SAME\s*$/
         hash[:avail] = hash[:ensure]
       end
 
       # Use the name method, so it works with subclasses.
-      hash[:provider] = self.name
+      hash[:provider] = name
 
-      return hash
+      hash
     else
       Puppet.warning _("Cannot match %{line}") % { line: line }
-      return nil
+      nil
     end
   end
 
@@ -172,11 +172,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
 
   def query
     hash = pkgsingle(@resource)
-    if hash
-      hash
-    else
-      { :ensure => :absent }
-    end
+    hash || { :ensure => :absent }
   end
 
   def update

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

@@ -27,46 +27,46 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   defaultfor 'os.family' => :gentoo
 
   def self.instances
-    result_format = self.eix_result_format
-    result_fields = self.eix_result_fields
-
-    limit = self.eix_limit
-    version_format = self.eix_version_format
-    slot_versions_format = self.eix_slot_versions_format
-    installed_versions_format = self.eix_installed_versions_format
-    installable_versions_format = self.eix_install_versions_format
+    result_format = eix_result_format
+    result_fields = eix_result_fields
+
+    limit = eix_limit
+    version_format = eix_version_format
+    slot_versions_format = eix_slot_versions_format
+    installed_versions_format = eix_installed_versions_format
+    installable_versions_format = eix_install_versions_format
     begin
       eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
-      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+      update_eix unless FileUtils.uptodate?(eix_file, %w[/usr/bin/eix /usr/portage/metadata/timestamp])
 
       search_output = nil
       Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
-        search_output = eix(*(self.eix_search_arguments + ['--installed']))
+        search_output = eix(*(eix_search_arguments + ['--installed']))
       end
 
       packages = []
       search_output.each_line do |search_result|
         match = result_format.match(search_result)
 
-        if match
-          package = {}
-          result_fields.zip(match.captures) do |field, value|
-            package[field] = value unless !value or value.empty?
-          end
-          package[:provider] = :portage
-          packages << new(package)
+        next unless match
+
+        package = {}
+        result_fields.zip(match.captures) do |field, value|
+          package[field] = value unless !value or value.empty?
         end
+        package[:provider] = :portage
+        packages << new(package)
       end
 
-      return packages
+      packages
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new(detail)
+      raise Puppet::Error, detail
     end
   end
 
   def install
     should = @resource.should(:ensure)
-    cmd = %w{}
+    cmd = %w[]
     name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
     name = qatom[:pfx] + name if qatom[:pfx]
     name = name + '-' + qatom[:pv] if qatom[:pv]
@@ -80,7 +80,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
   def uninstall
     should = @resource.should(:ensure)
-    cmd = %w{--rage-clean}
+    cmd = %w[--rage-clean]
     name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
     name = qatom[:pfx] + name if qatom[:pfx]
     name = name + '-' + qatom[:pv] if qatom[:pv]
@@ -98,17 +98,17 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def reinstall
-    self.install
+    install
   end
 
   def update
-    self.install
+    install
   end
 
   def qatom
-    output_format = self.qatom_output_format
-    result_format = self.qatom_result_format
-    result_fields = self.qatom_result_fields
+    output_format = qatom_output_format
+    result_format = qatom_result_format
+    result_fields = qatom_result_fields
     @atom ||= begin
       package_info = {}
       # do the search
@@ -119,9 +119,9 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       when true, false, Symbol
         search = @resource[:name]
       else
-        search = '=' + @resource[:name] + '-' + "#{should}"
+        search = '=' + @resource[:name] + '-' + should.to_s
       end
-      search_output = qatom_bin(*([search, '--format', output_format]))
+      search_output = qatom_bin(*[search, '--format', output_format])
       # verify if the search found anything
       match = result_format.match(search_output)
       if match
@@ -138,7 +138,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       end
       @atom = package_info
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new(detail)
+      raise Puppet::Error, detail
     end
   end
 
@@ -147,7 +147,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def qatom_result_format
-    /^\"\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\](.*)\"$/
+    /^"\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\](.*)"$/
   end
 
   def qatom_result_fields
@@ -155,9 +155,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def self.get_sets
-    @sets ||= begin
-      @sets = emerge(*(['--list-sets']))
-    end
+    @sets ||= @sets = emerge(*['--list-sets'])
   end
 
   def query
@@ -181,12 +179,12 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
       if @resource[:name] =~ /^@/
         if package_sets.include?(@resource[:name][1..].to_s)
-          return({ :name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999," })
+          return({ :name => (@resource[:name]).to_s, :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999," })
         end
       end
 
       eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
-      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+      update_eix unless FileUtils.uptodate?(eix_file, %w[/usr/bin/eix /usr/portage/metadata/timestamp])
 
       search_output = nil
       Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
@@ -197,46 +195,46 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       search_output.each_line do |search_result|
         match = result_format.match(search_result)
 
-        if match
-          package = {}
-          result_fields.zip(match.captures) do |field, value|
-            package[field] = value unless !value or value.empty?
-          end
-          # dev-lang python [3.4.5] [3.5.2] [2.7.12:2.7,3.4.5:3.4] [2.7.12:2.7,3.4.5:3.4,3.5.2:3.5] https://www.python.org/ An interpreted, interactive, object-oriented programming language
-          # version_available is what we CAN install / update to
-          # ensure is what is currently installed
-          # This DOES NOT choose to install/upgrade or not, just provides current info
-          # prefer checking versions to slots as versions are finer grained
-          search = qatom[:pv]
-          search = search + '-' + qatom[:pr] if qatom[:pr]
-          if search
-            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], search)
-            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], search)
-          elsif qatom[:slot]
-            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
-            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
-          end
+        next unless match
 
-          package[:ensure] = package[:ensure] ? package[:ensure] : :absent
-          packages << package
+        package = {}
+        result_fields.zip(match.captures) do |field, value|
+          package[field] = value unless !value or value.empty?
         end
+        # dev-lang python [3.4.5] [3.5.2] [2.7.12:2.7,3.4.5:3.4] [2.7.12:2.7,3.4.5:3.4,3.5.2:3.5] https://www.python.org/ An interpreted, interactive, object-oriented programming language
+        # version_available is what we CAN install / update to
+        # ensure is what is currently installed
+        # This DOES NOT choose to install/upgrade or not, just provides current info
+        # prefer checking versions to slots as versions are finer grained
+        search = qatom[:pv]
+        search = search + '-' + qatom[:pr] if qatom[:pr]
+        if search
+          package[:version_available] = eix_get_version_for_versions(package[:installable_versions], search)
+          package[:ensure] = eix_get_version_for_versions(package[:installed_versions], search)
+        elsif qatom[:slot]
+          package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
+          package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
+        end
+
+        package[:ensure] = package[:ensure] || :absent
+        packages << package
       end
 
       case packages.size
       when 0
-        raise Puppet::Error.new(_("No package found with the specified name [%{name}]") % { name: @resource[:name] })
+        raise Puppet::Error, _("No package found with the specified name [%{name}]") % { name: @resource[:name] }
       when 1
         @eix_result = packages[0]
       else
-        raise Puppet::Error.new(_("More than one package with the specified name [%{search_value}], please use the category parameter to disambiguate") % { search_value: search_value })
+        raise Puppet::Error, _("More than one package with the specified name [%{search_value}], please use the category parameter to disambiguate") % { search_value: search_value }
       end
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new(detail)
+      raise Puppet::Error, detail
     end
   end
 
   def latest
-    self.query[:version_available]
+    query[:version_available]
   end
 
   private
@@ -303,7 +301,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def self.eix_search_arguments
-    ['--nocolor', '--pure-packages', '--format', self.eix_search_format]
+    ['--nocolor', '--pure-packages', '--format', eix_search_format]
   end
 
   def install_options

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

@@ -8,14 +8,14 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
            :portuninstall => "/usr/local/sbin/pkg_deinstall",
            :portinfo => "/usr/sbin/pkg_info"
 
-  %w{INTERACTIVE UNAME}.each do |var|
+  %w[INTERACTIVE UNAME].each do |var|
     ENV.delete(var) if ENV.include?(var)
   end
 
   def install
     # -N: install if the package is missing, otherwise upgrade
     # -M: yes, we're a batch, so don't ask any questions
-    cmd = %w{-N -M BATCH=yes} << @resource[:name]
+    cmd = %w[-N -M BATCH=yes] << @resource[:name]
 
     output = portupgrade(*cmd)
     if output =~ /\*\* No such /
@@ -29,8 +29,8 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
 
     begin
       output = portversion(*cmd)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
     line = output.split("\n").pop
 
@@ -39,16 +39,16 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
       return :latest
     end
 
-    pkgstuff = $1
-    match = $2
-    info = $3
+    pkgstuff = Regexp.last_match(1)
+    match = Regexp.last_match(2)
+    info = Regexp.last_match(3)
 
     unless pkgstuff =~ /^\S+-([^-\s]+)$/
       raise Puppet::Error,
             _("Could not match package info '%{pkgstuff}'") % { pkgstuff: pkgstuff }
     end
 
-    version = $1
+    version = Regexp.last_match(1)
 
     if match == "=" or match == ">"
       # we're up to date or more recent
@@ -62,7 +62,8 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
             _("Could not match version info '%{info}'") % { info: info }
     end
 
-    source, newversion = $1, $2
+    source = Regexp.last_match(1)
+    newversion = Regexp.last_match(2)
 
     debug "Newer version in #{source}"
     newversion
@@ -71,8 +72,8 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
   def query
     # support portorigin_glob such as "mail/postfix"
     name = self.name
-    if name =~ /\//
-      name = self.name.split(/\//).slice(1)
+    if name =~ %r{/}
+      name = self.name.split(%r{/}).slice(1)
     end
     self.class.instances.each do |instance|
       if instance.name == name

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

@@ -23,7 +23,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
   # defaultfor 'os.name' => :freebsd
 
   # Remove unwanted environment variables.
-  %w{INTERACTIVE UNAME}.each do |var|
+  %w[INTERACTIVE UNAME].each do |var|
     if ENV.include?(var)
       ENV.delete(var)
     end
@@ -35,7 +35,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     Puppet.debug "portupgrade.rb Building packages list from installed ports"
 
     # regex to match output from pkg_info
-    regex = %r{^(\S+)-([^-\s]+):(\S+)$}
+    regex = /^(\S+)-([^-\s]+):(\S+)$/
     # Corresponding field names
     fields = [:portname, :ensure, :portorigin]
     # define Temporary hash used, packages array of hashes
@@ -46,8 +46,8 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     cmdline = ["-aoQ"]
     begin
       output = portinfo(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     # split output and match it and populate temp hash
@@ -64,7 +64,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
         # populate the actual :name field from the :portorigin
         # Set :provider to this object name
         hash[:name] = hash[:portorigin]
-        hash[:provider] = self.name
+        hash[:provider] = name
 
         # Add to the full packages listing
         packages << new(hash)
@@ -75,7 +75,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     }
 
     # return the packages array of hashes
-    return packages
+    packages
   end
 
   ######## Installation sub command
@@ -88,8 +88,8 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     # FIXME: it's possible that portinstall prompts for data so locks up.
     begin
       output = portinstall(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     if output =~ /\*\* No such /
@@ -97,7 +97,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     end
 
     # No return code required, so do nil to be clean
-    return nil
+    nil
   end
 
   ######## Latest subcommand (returns the latest version available, or current version if installed is latest)
@@ -111,39 +111,39 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
 
     begin
       output = portversion(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     # Check: output format.
     if output =~ /^\S+-([^-\s]+)\s+(\S)\s+(.*)/
-      installedversion = $1
-      comparison = $2
-      otherdata = $3
+      installedversion = Regexp.last_match(1)
+      comparison = Regexp.last_match(2)
+      otherdata = Regexp.last_match(3)
 
       # Only return a new version number when it's clear that there is a new version
       # all others return the current version so no unexpected 'upgrades' occur.
       case comparison
       when "=", ">"
         Puppet.debug "portupgrade.latest() - Installed package is latest (#{installedversion})"
-        return installedversion
+        installedversion
       when "<"
         # "portpkg-1.7_5 < needs updating (port has 1.14)"
         # "portpkg-1.7_5 < needs updating (port has 1.14) (=> 'newport/pkg')
         if otherdata =~ /\(port has (\S+)\)/
-          newversion = $1
+          newversion = Regexp.last_match(1)
           Puppet.debug "portupgrade.latest() - Installed version needs updating to (#{newversion})"
-          return newversion
+          newversion
         else
           Puppet.debug "portupgrade.latest() - Unable to determine new version from (#{otherdata})"
-          return installedversion
+          installedversion
         end
       when "?", "!", "#"
         Puppet.debug "portupgrade.latest() - Comparison Error reported from portversion (#{output})"
-        return installedversion
+        installedversion
       else
         Puppet.debug "portupgrade.latest() - Unknown code from portversion output (#{output})"
-        return installedversion
+        installedversion
       end
 
     elsif output =~ /^\*\* No matching package /
@@ -166,25 +166,25 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     cmdline = ["-qO", @resource[:name]]
     begin
       output = portinfo(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     # Check: if output isn't in the right format, return nil
     if output =~ /^(\S+)-([^-\s]+)/
       # Fill in the details
       hash = Hash.new
-      hash[:portorigin] = self.name
-      hash[:portname]   = $1
-      hash[:ensure]     = $2
+      hash[:portorigin] = name
+      hash[:portname]   = Regexp.last_match(1)
+      hash[:ensure]     = Regexp.last_match(2)
 
       # If more details are required, then we can do another pkg_info
       # query here and parse out that output and add to the hash
       # return the hash to the caller
-      return hash
+      hash
     else
       Puppet.debug "portupgrade.query() - package (#{@resource[:name]}) not installed"
-      return nil
+      nil
     end
   end
 
@@ -196,13 +196,13 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     cmdline = ["-qO", @resource[:name]]
     begin
       output = portinfo(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     if output =~ /^(\S+)/
       # output matches, so uninstall it
-      portuninstall $1
+      portuninstall Regexp.last_match(1)
     end
   end
 
@@ -214,17 +214,17 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     cmdline = ["-qO", @resource[:name]]
     begin
       output = portinfo(*cmdline)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new(output, $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new(output, e)
     end
 
     if output =~ /^(\S+)/
       # output matches, so upgrade the software
-      cmdline = ["-M BATCH=yes", $1]
+      cmdline = ["-M BATCH=yes", Regexp.last_match(1)]
       begin
         output = portupgrade(*cmdline)
-      rescue Puppet::ExecutionFailure
-        raise Puppet::Error.new(output, $!)
+      rescue Puppet::ExecutionFailure => e
+        raise Puppet::Error.new(output, e)
       end
     end
   end