openvox 7.37.1 → 8.19.0

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

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

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   # Provide sorting functionality
   include Puppet::Util::Package
@@ -22,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]
@@ -33,27 +35,27 @@ 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
 
   # What's the latest package version available?
   def latest
-    output = aptcache :policy,  @resource[:name]
+    output = aptcache :policy, @resource[:name]
 
     if output =~ /Candidate:\s+(\S+)\s/
-      return $1
+      Regexp.last_match(1)
     else
-      self.err _("Could not find latest version")
-      return nil
+      err _("Could not find latest version")
+      nil
     end
   end
 
@@ -63,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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/util/package/version/gem'
 require_relative '../../../puppet/util/package/version/range'
 require_relative '../../../puppet/provider/package_targetable'
@@ -55,9 +57,11 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
   # that contains the content of PATH but without puppet/bin dir.
   # This is used to pass a custom PATH and execute commands in a controlled environment
   def self.windows_path_without_puppet_bin
-    @path ||= Puppet::Util.get_env('PATH').split(File::PATH_SEPARATOR)
-                                          .reject { |dir| dir =~ /puppet\\bin$/ }
-                                          .join(File::PATH_SEPARATOR)
+    # rubocop:disable Naming/MemoizedInstanceVariableName
+    @path ||= ENV['PATH'].split(File::PATH_SEPARATOR)
+                         .reject { |dir| dir =~ /puppet\\bin$/ }
+                         .join(File::PATH_SEPARATOR)
+    # rubocop:enable Naming/MemoizedInstanceVariableName
   end
 
   private_class_method :windows_path_without_puppet_bin
@@ -73,13 +77,14 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     validate_command(command)
     cmd = [command] << command_options
 
-    custom_environment = {'HOME'=>Puppet::Util.get_env('HOME')}.merge(custom_environment)
+    custom_environment = { 'HOME' => ENV.fetch('HOME', nil) }.merge(custom_environment)
 
     if Puppet::Util::Platform.windows?
       custom_environment[:PATH] = windows_path_without_puppet_bin
     end
 
-    execute(cmd, {:failonfail => true, :combine => true, :custom_environment => custom_environment})
+    # This uses an unusual form of passing the command and args as [<cmd>, [<arg1>, <arg2>, ...]]
+    execute(cmd, { :failonfail => true, :combine => true, :custom_environment => custom_environment })
   end
 
   def self.instances(target_command = nil)
@@ -115,17 +120,16 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
 
     begin
-      list = execute_gem_command(options[:command], command_options).lines.
-        map {|set| gemsplit(set) }.
-        reject {|x| x.nil? }
+      list = execute_gem_command(options[:command], command_options).lines
+                                                                    .filter_map { |set| gemsplit(set) }
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
     end
 
     if options[:justme]
-      return list.shift
+      list.shift
     else
-      return list
+      list
     end
   end
 
@@ -137,11 +141,11 @@ 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]},
+        :name => gem_name,
+        :ensure => versions.map { |v| v.split[0] },
         :provider => name
       }
     else
@@ -152,6 +156,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
 
   def insync?(is)
     return false unless is && is != :absent
+
     is = [is] unless is.is_a? Array
     should = @resource[:ensure]
 
@@ -164,12 +169,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
 
@@ -207,9 +210,9 @@ 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)
-    else
-      command_options << "-v" << 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
 
     if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1
@@ -234,14 +237,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
@@ -280,7 +283,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/hpux.rb

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 # HP-UX packaging.
 
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package do
-
   desc "HP-UX's packaging system."
 
   commands :swinstall => "/usr/sbin/swinstall",
-    :swlist => "/usr/sbin/swlist",
-    :swremove => "/usr/sbin/swremove"
+           :swlist => "/usr/sbin/swlist",
+           :swremove => "/usr/sbin/swremove"
 
-  confine :operatingsystem => "hp-ux"
+  confine 'os.name' => "hp-ux"
 
-  defaultfor :operatingsystem => "hp-ux"
+  defaultfor 'os.name' => "hp-ux"
 
   def self.instances
     # TODO:  This is very hard on HP-UX!
@@ -22,15 +23,16 @@ Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package
   # source and name are required
   def install
     raise ArgumentError, _("source must be provided to install HP-UX packages") unless resource[:source]
+
     args = standard_args + ["-s", resource[:source], resource[:name]]
     swinstall(*args)
   end
 
   def query
     swlist resource[:name]
-    {:ensure => :present}
+    { :ensure => :present }
   rescue
-    {:ensure => :absent}
+    { :ensure => :absent }
   end
 
   def uninstall

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 require_relative '../../../puppet/provider/command'
 
@@ -12,7 +14,7 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
     Revisions are only used internally for ensuring the latest version/revision of a port.
   "
 
-  confine :operatingsystem => :darwin
+  confine 'os.name' => :darwin
 
   has_command(:port, "/opt/local/bin/port") do
     environment :HOME => "/opt/local"
@@ -23,7 +25,6 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   has_feature :upgradeable
   has_feature :versionable
 
-
   def self.parse_installed_query_line(line)
     regex = /(\S+)\s+@(\S+)_(\d+).*\(active\)/
     fields = [:name, :ensure, :revision]
@@ -43,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
@@ -74,7 +75,8 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   def query
     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