openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 require_relative '../../../puppet/util/package'
 
@@ -13,23 +15,21 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
 
   # The commands we are using on an AIX box are installed standard
   # (except nimclient) nimclient needs the bos.sysmgt.nim.client fileset.
-  commands    :nimclient  => "/usr/sbin/nimclient",
-              :lslpp      => "/usr/bin/lslpp",
-              :rpm        => "rpm"
+  commands    :nimclient => "/usr/sbin/nimclient",
+              :lslpp => "/usr/bin/lslpp",
+              :rpm => "rpm"
 
   # If NIM has not been configured, /etc/niminfo will not be present.
   # However, we have no way of knowing if the NIM server is not configured
   # properly.
-  confine  :exists => "/etc/niminfo"
+  confine :exists => "/etc/niminfo"
 
   has_feature :versionable
 
   attr_accessor :latest_info
 
-
-
   def self.srclistcmd(source)
-    [ command(:nimclient), "-o", "showres", "-a", "installp_flags=L", "-a", "resource=#{source}" ]
+    [command(:nimclient), "-o", "showres", "-a", "installp_flags=L", "-a", "resource=#{source}"]
   end
 
   def uninstall
@@ -62,7 +62,7 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
 
     pkg = @resource[:name]
 
-    version_specified = (useversion and (! @resource.should(:ensure).is_a? Symbol))
+    version_specified = (useversion and (!@resource.should(:ensure).is_a? Symbol))
 
     # This is unfortunate for a couple of reasons.  First, because of a subtle
     # difference in the command-line syntax for installing an RPM vs an
@@ -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,18 +90,17 @@ 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}'") %
-                     { package: pkg, version: version, source: source }
+                   { package: pkg, version: version, source: source }
                else
                  _("Unable to find package '%{package}' on lpp_source '%{source}'") % { package: pkg, source: source }
                end
@@ -113,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
@@ -145,7 +144,6 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     end
   end
 
-
   private
 
   ## UTILITY METHODS FOR PARSING `nimclient -o showres` output
@@ -180,7 +178,6 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
   #   @@R:mypackage.foo-1.2.3-4 1.2.3-4
   #   @@R:mypackage.foo-1.2.3-8 1.2.3-8
 
-
   # Parse the output of a `nimclient -o showres` command.  Returns a two-dimensional
   # hash, where the first-level keys are package names, the second-level keys are
   # version number strings for all of the available version numbers for a package,
@@ -205,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)
@@ -248,12 +245,12 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     package_string = match.captures[1]
 
     case package_type_flag
-      when "I","S"
-        parse_installp_package_string(package_string)
-      when "R"
-        parse_rpm_package_string(package_string)
-      else
-        self.fail _("Unrecognized package type specifier: '%{package_type_flag}' in package line:\n'%{line}'") % { package_type_flag: package_type_flag, line: line }
+    when "I", "S"
+      parse_installp_package_string(package_string)
+    when "R"
+      parse_rpm_package_string(package_string)
+    else
+      self.fail _("Unrecognized package type specifier: '%{package_type_flag}' in package line:\n'%{line}'") % { package_type_flag: package_type_flag, line: line }
     end
   end
 
@@ -271,21 +268,23 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
     unless packages.has_key?(package_name)
       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
+
     packages[package_name][version]
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 # Packaging on OpenBSD.  Doesn't work anywhere else that I know of.
@@ -9,12 +11,12 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     These options should be specified as an array where each element is either a
      string or a hash."
 
-  commands :pkginfo   => "pkg_info",
-           :pkgadd    => "pkg_add",
+  commands :pkginfo => "pkg_info",
+           :pkgadd => "pkg_add",
            :pkgdelete => "pkg_delete"
 
-  defaultfor :operatingsystem => :openbsd
-  confine :operatingsystem => :openbsd
+  defaultfor 'os.name' => :openbsd
+  confine 'os.name' => :openbsd
 
   has_feature :versionable
   has_feature :install_options
@@ -28,19 +30,19 @@ 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-]*)(.*)$/
-        fields = [:name, :ensure, :flavor ]
+        regex = /^(.*)-(\d[^-]*)-?([\w-]*)(.*)$/
+        fields = [:name, :ensure, :flavor]
         hash = {}
 
         # now turn each returned line into a package object
         process.each_line { |line|
           match = regex.match(line.split[0])
           if match
-            fields.zip(match.captures) { |field,value|
+            fields.zip(match.captures) { |field, value|
               hash[field] = value
             }
 
-            hash[:provider] = self.name
+            hash[:provider] = name
 
             packages << new(hash)
             hash = {}
@@ -54,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
 
@@ -67,7 +69,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   def latest
     parse_pkgconf
 
-    if @resource[:source][-1,1] == ::File::SEPARATOR
+    if @resource[:source][-1, 1] == ::File::SEPARATOR
       e_vars = { 'PKG_PATH' => @resource[:source] }
     else
       e_vars = {}
@@ -79,7 +81,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
       query = @resource[:name]
     end
 
-    output = Puppet::Util.withenv(e_vars) {pkginfo "-Q", query}
+    output = Puppet::Util.withenv(e_vars) { pkginfo "-Q", query }
     version = properties[:ensure]
 
     if output.nil? or output.size == 0 or output =~ /Error from /
@@ -87,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
@@ -139,11 +141,11 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
         unless @resource[:source]
           raise Puppet::Error,
-          _("No valid installpath found in /etc/pkg.conf and no source was set")
+                _("No valid installpath found in /etc/pkg.conf and no source was set")
         end
       else
         raise Puppet::Error,
-        _("You must specify a package source or configure an installpath in /etc/pkg.conf")
+              _("You must specify a package source or configure an installpath in /etc/pkg.conf")
       end
     end
   end
@@ -153,7 +155,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
     parse_pkgconf
 
-    if @resource[:source][-1,1] == ::File::SEPARATOR
+    if @resource[:source][-1, 1] == ::File::SEPARATOR
       e_vars = { 'PKG_PATH' => @resource[:source] }
       full_name = get_full_name(latest)
     else
@@ -192,42 +194,43 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
         use_version = get_version
       end
 
-      [ @resource[:name], use_version, @resource[:flavor]].join('-').gsub(/-+$/, '')
+      [@resource[:name], use_version, @resource[:flavor]].join('-').gsub(/-+$/, '')
     end
   end
 
   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
       return '' if version == -1
+
       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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::Provider::Package do
@@ -5,21 +7,21 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
 
   commands :opkg => "opkg"
 
-  confine     :operatingsystem => :openwrt
-  defaultfor  :operatingsystem => :openwrt
+  confine     'os.name' => :openwrt
+  defaultfor  'os.name' => :openwrt
 
   def self.instances
     packages = []
     execpipe("#{command(:opkg)} list-installed") do |process|
-      regex = %r{^(\S+) - (\S+)}
+      regex = /^(\S+) - (\S+)/
       fields = [:name, :ensure]
       hash = {}
 
       process.each_line { |line|
         match = regex.match(line)
         if match
-          fields.zip(match.captures) { |field,value| hash[field] = value }
-          hash[:provider] = self.name
+          fields.zip(match.captures) { |field, value| hash[field] = value }
+          hash[:provider] = name
           packages << new(hash)
           hash = {}
         else
@@ -29,11 +31,11 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
     end
     packages
   rescue Puppet::ExecutionFailure
-    return nil
+    nil
   end
 
   def latest
-    output = opkg( "list", @resource[:name])
+    output = opkg("list", @resource[:name])
     matches = /^(\S+) - (\S+)/.match(output).captures
     matches[1]
   end
@@ -44,29 +46,30 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
     opkg('update') if package_lists.size <= 2
 
     if @resource[:source]
-      opkg( '--force-overwrite', 'install', @resource[:source] )
+      opkg('--force-overwrite', 'install', @resource[:source])
     else
-      opkg( '--force-overwrite', 'install', @resource[:name] )
+      opkg('--force-overwrite', 'install', @resource[:name])
     end
   end
 
   def uninstall
-    opkg( 'remove', @resource[:name] )
+    opkg('remove', @resource[:name])
   end
 
   def update
-    self.install
+    install
   end
 
   def query
     # list out our specific package
-    output = opkg( 'list-installed', @resource[:name] )
+    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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 require 'set'
 require 'uri'
@@ -17,8 +19,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
   commands :yaourt => "/usr/bin/yaourt" if yaourt?
 
-  confine     :operatingsystem => [:archlinux, :manjarolinux]
-  defaultfor  :operatingsystem => [:archlinux, :manjarolinux]
+  confine     'os.name' => [:archlinux, :manjarolinux, :artix]
+  defaultfor  'os.name' => [:archlinux, :manjarolinux, :artix]
   has_feature :install_options
   has_feature :uninstall_options
   has_feature :upgradeable
@@ -27,12 +29,10 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # Checks if a given name is a group
   def self.group?(name)
-    begin
-      !pacman('--sync', '--groups', name).empty?
-    rescue Puppet::ExecutionFailure
-      # pacman returns an expected non-zero exit code when the name is not a group
-      false
-    end
+    !pacman('--sync', '--groups', 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.
@@ -45,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
@@ -73,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), "--query"]) 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), "--query"]) 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
@@ -115,7 +113,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
       # Replace the list of packages with a version string consisting of packages that make up the group
       groups.each do |name, packages|
-        groups[name] = packages.sort.map {|package| "#{package} #{installed_packages[package]}"}.join ', '
+        groups[name] = packages.sort.map { |package| "#{package} #{installed_packages[package]}" }.join ', '
       end
     rescue Puppet::ExecutionFailure
       # pacman returns an expected non-zero exit code when the filter name is not a group
@@ -128,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
@@ -136,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("--sync", "--print", "--print-format", "%n %v", resource_name).lines.map{ |line| line.chomp }.sort.join(', ') if self.class.group?(resource_name)
+    return pacman("--sync", "--print", "--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
@@ -144,7 +142,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     begin
       if pacman_check
         output = pacman "--sync", "--print", "--print-format", "%v", resource_name
-        return output.chomp
+        output.chomp
       else
         output = yaourt "-Qma", resource_name
         output.split("\n").each do |line|
@@ -186,8 +184,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   def self.to_resource_hash(name, version)
     {
-      :name     => name,
-      :ensure   => version,
+      :name => name,
+      :ensure => version,
       :provider => self.name
     }
   end
@@ -210,7 +208,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
     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 << "--remove"
     cmd << '--recursive' if is_group
@@ -241,15 +239,15 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     end
 
     source = case source_uri.scheme
-    when nil then source
-    when /https?/i then source
-    when /ftp/i then source
-    when /file/i then source_uri.path
-    when /puppet/i
-      fail _("puppet:// URL is not supported by pacman")
-    else
-      fail _("Source %{source} is not supported by pacman") % { source: source }
-    end
+             when nil       then source
+             when /https?/i then source
+             when /ftp/i    then source
+             when /file/i   then source_uri.path
+             when /puppet/i
+               fail _("puppet:// URL is not supported by pacman")
+             else
+               fail _("Source %{source} is not supported by pacman") % { source: source }
+             end
     pacman "--noconfirm", "--noprogressbar", "--update", source
   end
 
@@ -259,7 +257,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 << "--sync" << resource_name
 
@@ -269,5 +267,4 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       pacman(*cmd)
     end
   end
-
 end