openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Whole new package, so include pack stuff
 require_relative '../../../puppet/provider/package'
 
@@ -11,17 +13,17 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
   ## has_features is usually autodetected based on defs below.
   # has_features :installable, :uninstallable, :upgradeable
 
-  commands :portupgrade   => "/usr/local/sbin/portupgrade",
-  :portinstall   => "/usr/local/sbin/portinstall",
-  :portversion   => "/usr/local/sbin/portversion",
-  :portuninstall => "/usr/local/sbin/pkg_deinstall",
-  :portinfo      => "/usr/sbin/pkg_info"
+  commands :portupgrade => "/usr/local/sbin/portupgrade",
+           :portinstall => "/usr/local/sbin/portinstall",
+           :portversion => "/usr/local/sbin/portversion",
+           :portuninstall => "/usr/local/sbin/pkg_deinstall",
+           :portinfo => "/usr/sbin/pkg_info"
 
   ## Activate this only once approved by someone important.
-  # defaultfor :operatingsystem => :freebsd
+  # 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
@@ -33,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
@@ -44,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
@@ -62,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)
@@ -73,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
@@ -86,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 /
@@ -95,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)
@@ -109,59 +111,50 @@ 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
 
-    else
+    elsif output =~ /^\*\* No matching package /
       # error: output not parsed correctly, error out with nil.
       # Seriously - this section should never be called in a perfect world.
       # as verification that the port is installed has already happened in query.
-      if output =~ /^\*\* No matching package /
-        raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
-      else
-        # Any other error (dump output to log)
-        raise Puppet::ExecutionFailure, _("Unexpected output from portversion: %{output}") % { output: output }
-      end
-
-      # Just in case we still are running, return nil
-      return nil
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
+    else
+      # Any other error (dump output to log)
+      raise Puppet::ExecutionFailure, _("Unexpected output from portversion: %{output}") % { output: output }
     end
-
-    # At this point normal operation has finished and we shouldn't have been called.
-    # Error out and let the admin deal with it.
-    raise Puppet::Error, _("portversion.latest() - fatal error with portversion: %{output}") % { output: output }
   end
 
   ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.
@@ -173,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
 
@@ -203,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
 
@@ -221,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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
   desc "Puppet Ruby Gem support. This provider is useful for managing
         gems needed by the ruby provided in the puppet-agent package."
@@ -6,20 +8,7 @@ Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
 
   confine :true => Puppet.runtime[:facter].value(:aio_agent_version)
 
-  def self.windows_gemcmd
-    puppet_dir = Puppet::Util.get_env('PUPPET_DIR')
-    if puppet_dir
-      File.join(Puppet::Util.get_env('PUPPET_DIR').to_s, 'bin', 'gem.bat')
-    else
-      File.join(Gem.default_bindir, 'gem.bat')
-    end
-  end
-
-  if Puppet::Util::Platform.windows?
-    commands :gemcmd => windows_gemcmd
-  else
-    commands :gemcmd => "/opt/puppetlabs/puppet/bin/gem"
-  end
+  commands :gemcmd => Puppet.run_mode.gem_cmd
 
   def uninstall
     super
@@ -28,7 +17,9 @@ Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
   end
 
   def self.execute_gem_command(command, command_options, custom_environment = {})
-    custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+    if (pkg_config_path = Puppet.run_mode.pkg_config_path)
+      custom_environment['PKG_CONFIG_PATH'] = pkg_config_path
+    end
     super(command, command_options, custom_environment)
   end
 end

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'English'
 unless Puppet::Util::Platform.jruby_fips?
   require 'rubygems/commands/list_command'
 end
@@ -31,11 +34,11 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
   # CommandDefiner in provider.rb will set failonfail, combine, and environment.
 
   has_command(:puppetservercmd, '/opt/puppetlabs/bin/puppetserver') do
-    environment(HOME: ENV['HOME'])
+    environment(HOME: ENV.fetch('HOME', nil))
   end
 
   def self.gemlist(options)
-    command_options = ['gem', 'list']
+    command_options = %w[gem list]
 
     if options[:local]
       command_options << '--local'
@@ -67,19 +70,19 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
     # causing gemsplit to output:
     # Warning: Could not match *** LOCAL GEMS ***
     gem_list = list
-                 .lines
-                 .select { |x| x =~ /^(\S+)\s+\((.+)\)/ }
-                 .map { |set| gemsplit(set) }
+               .lines
+               .select { |x| x =~ /^(\S+)\s+\((.+)\)/ }
+               .map { |set| gemsplit(set) }
 
     if options[:justme]
-      return gem_list.shift
+      gem_list.shift
     else
-      return gem_list
+      gem_list
     end
   end
 
   def install(useversion = true)
-    command_options = ['gem', 'install']
+    command_options = %w[gem install]
     command_options += install_options if resource[:install_options]
 
     command_options << '-v' << resource[:ensure] if (!resource[:ensure].is_a? Symbol) && useversion
@@ -101,10 +104,10 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
         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
         # interpret it as a gem repository
-        command_options << '--source' << "#{resource[:source]}" << resource[:name]
+        command_options << '--source' << resource[:source].to_s << resource[:name]
       end
     else
       command_options << resource[:name]
@@ -116,7 +119,7 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
   end
 
   def uninstall
-    command_options = ['gem', 'uninstall']
+    command_options = %w[gem uninstall]
     command_options << '--executables' << '--all' << resource[:name]
     command_options += uninstall_options if resource[:uninstall_options]
 
@@ -156,7 +159,7 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
       gem_env['GEM_HOME'] = puppetserver_conf['jruby-puppet'].key?('gem-home') ? puppetserver_conf['jruby-puppet']['gem-home'] : puppetserver_default_gem_home
       gem_env['GEM_PATH'] = puppetserver_conf['jruby-puppet'].key?('gem-path') ? puppetserver_conf['jruby-puppet']['gem-path'].join(':') : puppetserver_default_gem_path
     end
-    gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$$}"
+    gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$PROCESS_ID}"
 
     # Remove the 'gem' from the command_options
     command_options.shift
@@ -165,7 +168,7 @@ Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
     # There is no method exclude default gems from the local gem list,
     # for example: psych (default: 2.2.2)
     # but default gems should not be managed by this (or any) provider.
-    gem_list = gem_out.lines.reject { |gem| gem =~ / \(default\: / }
+    gem_list = gem_out.lines.reject { |gem| gem =~ / \(default: / }
     gem_list.join("\n")
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 require_relative '../../../puppet/util/rpm_compare'
 
@@ -22,13 +24,16 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   # Note: self:: is required here to keep these constants in the context of what will
   # eventually become this Puppet::Type::Package::ProviderRpm class.
   # The query format by which we identify installed packages
-  self::NEVRA_FORMAT = %Q{%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n}
-  self::NEVRA_REGEX  = %r{^'?(\S+) (\S+) (\S+) (\S+) (\S+)$}
+  self::NEVRA_FORMAT = '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'
+  self::NEVRA_REGEX  = /^'?(\S+) (\S+) (\S+) (\S+) (\S+)$/
   self::NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]
   self::MULTIVERSION_SEPARATOR = "; "
 
   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('--version')
@@ -38,9 +43,11 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
         true
       end
   end
+  # rubocop:enable Layout
 
   def self.current_version
     return @current_version unless @current_version.nil?
+
     output = rpm "--version"
     @current_version = output.gsub('RPM version ', '').strip
   end
@@ -64,8 +71,8 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
         # now turn each returned line into a package object
         nevra_to_multiversion_hash(process).each { |hash| packages << new(hash) }
       }
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error, _("Failed to list packages"), $!.backtrace
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error, _("Failed to list packages"), e.backtrace
     end
 
     packages
@@ -75,10 +82,10 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   # a hash with entries :instance => fully versioned package name, and
   # :ensure => version-release
   def query
-    #NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
-    #IF YOU CALL THIS METHOD, IT WILL CALL RPM
-    #Use get(:property) to check if cached values are available
-    cmd = ["-q",  @resource[:name], "#{self.class.nosignature}", "#{self.class.nodigest}", "--qf", "#{self.class::NEVRA_FORMAT}"]
+    # NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
+    # IF YOU CALL THIS METHOD, IT WILL CALL RPM
+    # Use get(:property) to check if cached values are available
+    cmd = ["-q", @resource[:name], self.class.nosignature.to_s, self.class.nodigest.to_s, "--qf", self.class::NEVRA_FORMAT.to_s]
 
     begin
       output = rpm(*cmd)
@@ -107,7 +114,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
       @resource.fail _("RPMs must specify a package source")
     end
 
-    cmd = [command(:rpm), "-q", "--qf", "#{self.class::NEVRA_FORMAT}", "-p", source]
+    cmd = [command(:rpm), "-q", "--qf", self.class::NEVRA_FORMAT.to_s, "-p", source]
     h = self.class.nevra_to_multiversion_hash(execute(cmd))
     h[:ensure]
   rescue Puppet::ExecutionFailure => e
@@ -120,7 +127,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
       @resource.fail _("RPMs must specify a package source")
     end
 
-    version =  @property_hash[:ensure]
+    version = @property_hash[:ensure]
 
     # RPM gets upset if you try to install an already installed package
     return if @resource.should(:ensure) == version || (@resource.should(:ensure) == :latest && version == latest)
@@ -142,16 +149,12 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     nvr = "#{nav}-#{release}"
     if @resource[:name].start_with? nvr
       identifier = nvr
+    elsif @resource[:name].start_with? nav
+      identifier = nav
+    elsif @resource[:install_only]
+      identifier = get(:ensure).split(self.class::MULTIVERSION_SEPARATOR).map { |ver| "#{name}-#{ver}" }
     else
-      if @resource[:name].start_with? nav
-        identifier = nav
-      else
-        if @resource[:install_only]
-          identifier = get(:ensure).split(self.class::MULTIVERSION_SEPARATOR).map { |ver| "#{name}-#{ver}" }
-        else
-          identifier = name
-        end
-      end
+      identifier = name
     end
     # If an arch is specified in the resource, uninstall that arch,
     # otherwise uninstall the arch returned by query.
@@ -172,7 +175,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   end
 
   def update
-    self.install
+    install
   end
 
   def install_options
@@ -189,11 +192,12 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
 
     should = resource[:ensure]
     is.split(self.class::MULTIVERSION_SEPARATOR).any? do |version|
-      0 == rpm_compareEVR(should, version)
+      0 == rpm_compare_evr(should, version)
     end
   end
 
   private
+
   # @param line [String] one line of rpm package query information
   # @return [Hash] of NEVRA_FIELDS strings parsed from package info
   # or an empty hash if we failed to parse
@@ -205,14 +209,14 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     match = self::NEVRA_REGEX.match(line)
     if match
       self::NEVRA_FIELDS.zip(match.captures) { |f, v| hash[f] = v }
-      hash[:provider] = self.name
+      hash[:provider] = name
       hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
       hash[:ensure].prepend("#{hash[:epoch]}:") if hash[:epoch] != '0'
     else
       Puppet.debug("Failed to match rpm line #{line}")
     end
 
-    return hash
+    hash
   end
 
   # @param line [String] multiple lines of rpm package query information
@@ -223,28 +227,29 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     list = []
     multiversion_hash = {}
     multiline.each_line do |line|
-      hash = self.nevra_to_hash(line)
-      if !hash.empty?
-        if multiversion_hash.empty?
-          multiversion_hash = hash.dup
-          next
-        end
-
-        if multiversion_hash[:name] != hash[:name]
-          list << multiversion_hash
-          multiversion_hash = hash.dup
-          next
-        end
-
-        if !multiversion_hash[:ensure].include?(hash[:ensure])
-          multiversion_hash[:ensure].concat("#{self::MULTIVERSION_SEPARATOR}#{hash[:ensure]}")
-        end
+      hash = nevra_to_hash(line)
+      next if hash.empty?
+
+      if multiversion_hash.empty?
+        multiversion_hash = hash.dup
+        next
+      end
+
+      if multiversion_hash[:name] != hash[:name]
+        list << multiversion_hash
+        multiversion_hash = hash.dup
+        next
+      end
+
+      unless multiversion_hash[:ensure].include?(hash[:ensure])
+        multiversion_hash[:ensure].concat("#{self::MULTIVERSION_SEPARATOR}#{hash[:ensure]}")
       end
     end
     list << multiversion_hash if multiversion_hash
     if list.size == 1
       return list[0]
     end
-    return list
+
+    list
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :rug, :parent => :rpm do
   desc "Support for suse `rug` package manager."
 
@@ -5,12 +7,12 @@ Puppet::Type.type(:package).provide :rug, :parent => :rpm do
 
   commands :rug => "/usr/bin/rug"
   commands :rpm => "rpm"
-  confine    :operatingsystem => [:suse, :sles]
+  confine  'os.name' => [:suse, :sles]
 
   # Install a package using 'rug'.
   def install
     should = @resource.should(:ensure)
-    self.debug "Ensuring => #{should}"
+    debug "Ensuring => #{should}"
     wanted = @resource[:name]
 
     # XXX: We don't actually deal with epochs here.
@@ -23,29 +25,27 @@ Puppet::Type.type(:package).provide :rug, :parent => :rpm do
     end
     rug "--quiet", :install, "-y", wanted
 
-    unless self.query
-      raise Puppet::ExecutionFailure.new(
-        _("Could not find package %{name}") % { name: self.name }
-      )
+    unless query
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: name }
     end
   end
 
   # What's the latest package version available?
   def latest
-    #rug can only get a list of *all* available packages?
+    # rug can only get a list of *all* available packages?
     output = rug "list-updates"
 
-    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s\|]+)/
-      return $1
+    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s|]+)/
+      Regexp.last_match(1)
     else
       # rug didn't find updates, pretend the current
       # version is the latest
-      return @property_hash[:ensure]
+      @property_hash[:ensure]
     end
   end
 
   def update
     # rug install can be used for update, too
-    self.install
+    install
   end
 end