openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Puppet package provider for Python's `pip` package management frontend.
 # <http://pip.pypa.io/>
 
@@ -6,7 +8,6 @@ require_relative '../../../puppet/util/package/version/range'
 require_relative '../../../puppet/provider/package_targetable'
 
 Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package::Targetable do
-
   desc "Python packages via `pip`.
 
   This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
@@ -31,14 +32,14 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
   def self.provider_command
     # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
-    self.cmd.map { |c| which(c) }.find { |c| c != nil }
+    cmd.map { |c| which(c) }.find { |c| !c.nil? }
   end
 
   def self.cmd
     if Puppet::Util::Platform.windows?
       ["pip.exe"]
     else
-      ["pip", "pip-python", "pip2", "pip-2"]
+      %w[pip pip-python pip2 pip-2]
     end
   end
 
@@ -64,7 +65,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   def self.instances(target_command = nil)
     if target_command
       command = target_command
-      self.validate_command(command)
+      validate_command(command)
     else
       command = provider_command
     end
@@ -73,7 +74,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     return packages unless command
 
     command_options = ['freeze']
-    command_version = self.pip_version(command)
+    command_version = pip_version(command)
     if compare_pip_versions(command_version, '8.1.0') >= 0
       command_options << '--all'
     end
@@ -82,6 +83,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
       process.collect do |line|
         pkg = parse(line)
         next unless pkg
+
         pkg[:command] = command
         packages << new(pkg)
       end
@@ -91,7 +93,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
     # Not needed when "pip freeze --all" is available.
     if compare_pip_versions(command_version, '8.1.0') == -1
-      packages << new({:ensure => command_version, :name => File.basename(command), :provider => name, :command => command})
+      packages << new({ :ensure => command_version, :name => File.basename(command), :provider => name, :command => command })
     end
 
     packages
@@ -102,7 +104,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   # or _package_ @ someURL@_version_
   def self.parse(line)
     if line.chomp =~ /^([^=]+)===?([^=]+)$/
-      {:ensure => $2, :name => $1, :provider => name}
+      { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
     elsif line.chomp =~ /^([^@]+) @ [^@]+@(.+)$/
       { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
     end
@@ -117,7 +119,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     self.class.instances(command).each do |pkg|
       return pkg.properties if @resource[:name].casecmp(pkg.name).zero?
     end
-    return nil
+    nil
   end
 
   # Return latest version available for current package
@@ -134,12 +136,10 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   end
 
   def self.compare_pip_versions(x, y)
-    begin
-      Puppet::Util::Package::Version::Pip.compare(x, y)
-    rescue PIP_VERSION::ValidationFailure => ex
-      Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
-      Puppet::Util::Package.versioncmp(x, y)
-    end
+    Puppet::Util::Package::Version::Pip.compare(x, y)
+  rescue PIP_VERSION::ValidationFailure => ex
+    Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
+    Puppet::Util::Package.versioncmp(x, y)
   end
 
   # Use pip CLI to look up versions from PyPI repositories,
@@ -160,19 +160,19 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     command = resource_or_provider_command
     self.class.validate_command(command)
 
-    command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}==versionplease"]
+    command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}==9!0dev0+x"]
     extra_arg = list_extra_flags(command_version)
     command_and_options << extra_arg if extra_arg
     command_and_options << install_options if @resource[:install_options]
     execpipe command_and_options do |process|
       process.collect do |line|
         # PIP OUTPUT: Could not find a version that satisfies the requirement example==versionplease (from versions: 1.2.3, 4.5.6)
-        if line =~ /from versions: (.+)\)/
-          versionList = $1.split(', ').sort do |x,y|
-            self.class.compare_pip_versions(x, y)
-          end
-          return versionList
+        next unless line =~ /from versions: (.+)\)/
+
+        versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+          self.class.compare_pip_versions(x, y)
         end
+        return versionList
       end
     end
     []
@@ -183,17 +183,17 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     self.class.validate_command(command)
 
     Dir.mktmpdir("puppet_pip") do |dir|
-      command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}", '-d', "#{dir}", '-v']
+      command_and_options = [self.class.quote(command), 'install', (@resource[:name]).to_s, '-d', dir.to_s, '-v']
       command_and_options << install_options if @resource[:install_options]
       execpipe command_and_options do |process|
         process.collect do |line|
           # PIP OUTPUT: Using version 0.10.1 (newest of versions: 1.2.3, 4.5.6)
-          if line =~ /Using version .+? \(newest of versions: (.+?)\)/
-            versionList = $1.split(', ').sort do |x,y|
-              self.class.compare_pip_versions(x, y)
-            end
-            return versionList
+          next unless line =~ /Using version .+? \(newest of versions: (.+?)\)/
+
+          versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+            self.class.compare_pip_versions(x, y)
           end
+          return versionList
         end
       end
       return []
@@ -215,13 +215,13 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     should_range
   end
 
-  def get_install_command_options()
+  def get_install_command_options
     should = @resource[:ensure]
-    command_options = %w{install -q}
+    command_options = %w[install -q]
     command_options += install_options if @resource[:install_options]
 
     if @resource[:source]
-      if String === should
+      if should.is_a?(String)
         command_options << "#{@resource[:source]}@#{should}#egg=#{@resource[:name]}"
       else
         command_options << "#{@resource[:source]}#egg=#{@resource[:name]}"
@@ -236,7 +236,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
       return command_options
     end
 
-    unless String === should
+    unless should.is_a?(String)
       command_options << @resource[:name]
 
       return command_options
@@ -306,6 +306,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   def insync?(is)
     return false unless is && is != :absent
+
     begin
       should = @resource[:ensure]
       should_range = PIP_VERSION_RANGE.parse(should, PIP_VERSION)
@@ -339,7 +340,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   def list_extra_flags(command_version)
     klass = self.class
     if klass.compare_pip_versions(command_version, '20.2.4') == 1 &&
-      klass.compare_pip_versions(command_version, '21.1') == -1
+       klass.compare_pip_versions(command_version, '21.1') == -1
       '--use-deprecated=legacy-resolver'
     end
   end

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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 # Puppet package provider for Python's `pip2` package management frontend.
 # <http://pip.pypa.io/>
 
 Puppet::Type.type(:package).provide :pip2,
-  :parent => :pip do
-
+                                    :parent => :pip do
   desc "Python packages via `pip2`.
 
   This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip2.

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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 # Puppet package provider for Python's `pip3` package management frontend.
 # <http://pip.pypa.io/>
 
 Puppet::Type.type(:package).provide :pip3,
-  :parent => :pip do
-
+                                    :parent => :pip do
   desc "Python packages via `pip3`.
 
   This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip3.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package do
   desc "OpenSolaris image packaging system. See pkg(5) for more information.
 
     This provider supports the `install_options` attribute, which allows
-    command-line flags to be passed to pkg. These options should be specified as an 
+    command-line flags to be passed to pkg. These options should be specified as an
     array where each element is either a string or a hash."
 
   # https://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
@@ -28,12 +30,12 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   commands :pkg => "/usr/bin/pkg"
 
-  confine :osfamily => :solaris
+  confine 'os.family' => :solaris
 
-  defaultfor :osfamily => :solaris, :kernelrelease => ['5.11', '5.12']
+  defaultfor 'os.family' => :solaris, :kernelrelease => ['5.11', '5.12']
 
   def self.instances
-    pkg(:list, '-Hv').split("\n").map{|l| new(parse_line(l))}
+    pkg(:list, '-Hv').split("\n").map { |l| new(parse_line(l)) }
   end
 
   # The IFO flag field is just what it names, the first field can have either
@@ -46,22 +48,22 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     (
       case flags[0..0]
       when 'i'
-        {:status => 'installed'}
+        { :status => 'installed' }
       when '-'
-        {:status => 'known'}
+        { :status => 'known' }
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[0..0] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[0..0] }
       end
     ).merge(
       case flags[1..1]
       when 'f'
-        {:mark => :hold}
+        { :mark => :hold }
       when '-'
         {}
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[1..1] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[1..1] }
       end
     )
   end
@@ -87,11 +89,11 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   def self.pkg_state(state)
     case state
     when /installed/
-      {:status => 'installed'}
+      { :status => 'installed' }
     when /known/
-      {:status => 'known'}
+      { :status => 'known' }
     else
-      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: self.name, state: state }
+      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: name, state: state }
     end
   end
 
@@ -99,19 +101,19 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   # formats of output for different pkg versions.
   def self.parse_line(line)
     (case line.chomp
-    # FMRI                                                                         IFO
-    # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
-    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
-      {:publisher => $1, :name => $2, :ensure => $3}.merge ifo_flag($4)
-
-    # FMRI                                                             STATE      UFOXI
-    # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
-    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
-      {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
-
-    else
-      raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: self.name, parse_line: line }
-    end).merge({:provider => self.name})
+     # FMRI                                                                         IFO
+     # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(...)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge ifo_flag(Regexp.last_match(4))
+
+     # FMRI                                                             STATE      UFOXI
+     # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge pkg_state(Regexp.last_match(4)).merge(ufoxi_flag(Regexp.last_match(5)))
+
+     else
+       raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: name, parse_line: line }
+     end).merge({ :provider => name })
   end
 
   def hold
@@ -120,7 +122,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   def unhold
     r = exec_cmd(command(:pkg), 'unfreeze', @resource[:name])
-    raise Puppet::Error, _("Unable to unfreeze %{package}") % { package: r[:out] } unless [0,4].include? r[:exit]
+    raise Puppet::Error, _("Unable to unfreeze %{package}") % { package: r[:out] } unless [0, 4].include? r[:exit]
   end
 
   def insync?(is)
@@ -152,12 +154,12 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       # unfortunately it doesn't consider downgrades 'available' (eg. with
       # installed foo@1.0, list -a foo@0.9 would fail).
       name = @resource[:name]
-      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map{|l|self.class.parse_line(l)}
+      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map { |l| self.class.parse_line(l) }
       n = potential_matches.length
       if n > 1
         warning(_("Implicit version %{should} has %{n} possible matches") % { should: should, n: n })
       end
-      potential_matches.each{ |p|
+      potential_matches.each { |p|
         command = is == :absent ? 'install' : 'update'
         options = ['-n']
         options.concat(join_options(@resource[:install_options])) if @resource[:install_options]
@@ -180,7 +182,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
         end
       }
       raise Puppet::DevError, _("No version of %{name} matching %{should} is installable, even though the package is currently installed") %
-          { name: name, should: should }
+                              { name: name, should: should }
     end
 
     false
@@ -214,42 +216,43 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     end
 
     # If not, then return the installed, else nil
-    (lst.find {|p| p[:status] == 'installed' } || {})[:ensure]
+    (lst.find { |p| p[:status] == 'installed' } || {})[:ensure]
   end
 
   # install the package and accept all licenses.
   def install(nofail = false)
     name = @resource[:name]
     should = @resource[:ensure]
-    is = self.query
+    is = query
     if is[:ensure].to_sym == :absent
       command = 'install'
     else
       command = 'update'
     end
     args = ['--accept']
-    if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.2') >= 0
+    if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.2') >= 0
       args.push('--sync-actuators-timeout', '900')
     end
     args.concat(join_options(@resource[:install_options])) if @resource[:install_options]
     unless should.is_a? Symbol
       name += "@#{should}"
     end
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       tries = 1
       # pkg install exits with code 7 when the image is currently in use by another process and cannot be modified
       r = exec_cmd(command(:pkg), command, *args, name)
-      while r[:exit] == 7 do
+      while r[:exit] == 7
         if tries > 4
           raise Puppet::Error, _("Pkg could not install %{name} after %{tries} tries. Aborting run") % { name: name, tries: tries }
         end
-        sleep 2 ** tries
+
+        sleep 2**tries
         tries += 1
         r = exec_cmd(command(:pkg), command, *args, name)
       end
     ensure
-      self.hold if @resource[:mark] == :hold
+      hold if @resource[:mark] == :hold
     end
     return r if nofail
     raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] } if r[:exit] != 0
@@ -264,11 +267,11 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       cmd << '-r'
     end
     cmd << @resource[:name]
-    self.unhold if self.properties[:mark] == :hold
+    unhold if properties[:mark] == :hold
     begin
       pkg cmd
     rescue StandardError, LoadError => e
-      self.hold if self.properties[:mark] == :hold
+      hold if properties[:mark] == :hold
       raise e
     end
   end
@@ -277,19 +280,21 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   def update
     r = install(true)
     # 4 == /No updates available for this image./
-    return if [0,4].include? r[:exit]
+    return if [0, 4].include? r[:exit]
+
     raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] }
   end
 
   # list a specific package
   def query
     r = exec_cmd(command(:pkg), 'list', '-Hv', @resource[:name])
-    return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
+    return { :ensure => :absent, :name => @resource[:name] } if r[:exit] != 0
+
     self.class.parse_line(r[:out])
   end
 
   def exec_cmd(*cmd)
     output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
-    {:out => output, :exit => output.exitstatus}
+    { :out => output, :exit => output.exitstatus }
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Motivation: DMG files provide a true HFS file system
 # and are easier to manage and .pkg bundles.
@@ -35,9 +37,9 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
       whether a package has been installed. Thus, to install new a version of a
       package, you must create a new DMG with a different filename."
 
-  confine :operatingsystem => :darwin
-  confine :feature         => :cfpropertylist
-  defaultfor :operatingsystem => :darwin
+  confine 'os.name' => :darwin
+  confine :feature => :cfpropertylist
+  defaultfor 'os.name' => :darwin
   commands :installer => "/usr/sbin/installer"
   commands :hdiutil => "/usr/bin/hdiutil"
   commands :curl => "/usr/bin/curl"
@@ -75,26 +77,27 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     end
 
     unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file"))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file")
     end
+
     require 'open-uri' # Dead code; this is never used. The File.open call 20-ish lines south of here used to be Kernel.open but changed in '09. -NF
     cached_source = source
     tmpdir = Dir.mktmpdir
     ext = /(\.dmg|\.pkg)$/i.match(source)[0]
     begin
-      if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+      if %r{\A[A-Za-z][A-Za-z0-9+\-.]*://} =~ cached_source
         cached_source = File.join(tmpdir, "#{name}#{ext}")
-        args = [ "-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source ]
+        args = ["-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source]
         if http_proxy_host and http_proxy_port
           args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
-        elsif http_proxy_host and not http_proxy_port
+        elsif http_proxy_host and !http_proxy_port
           args << "--proxy" << http_proxy_host
         end
         begin
           curl(*args)
-            Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(' ')})"
         rescue Puppet::ExecutionFailure
-          Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
+          Puppet.debug "curl #{args.join(' ')} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source
         end
       end
@@ -104,10 +107,11 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         File.open(cached_source) do |dmg|
           xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
           hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
-          raise Puppet::Error.new(_("No disk entities returned by mount at %{path}") % { path: dmg.path }) unless hdiutil_info.has_key?("system-entities")
-          mounts = hdiutil_info["system-entities"].collect { |entity|
+          raise Puppet::Error, _("No disk entities returned by mount at %{path}") % { path: dmg.path } unless hdiutil_info.has_key?("system-entities")
+
+          mounts = hdiutil_info["system-entities"].filter_map { |entity|
             entity["mount-point"]
-          }.compact
+          }
           begin
             mounts.each do |mountpoint|
               Dir.entries(mountpoint).select { |f|
@@ -133,21 +137,23 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def query
     if Puppet::FileSystem.exist?("/var/db/.puppet_pkgdmg_installed_#{@resource[:name]}")
       Puppet.debug "/var/db/.puppet_pkgdmg_installed_#{@resource[:name]} found"
-      return {:name => @resource[:name], :ensure => :present}
+      { :name => @resource[:name], :ensure => :present }
     else
-      return nil
+      nil
     end
   end
 
   def install
     source = @resource[:source]
     unless source
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package source."))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package source.")
     end
+
     name = @resource[:name]
     unless name
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package name."))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package name.")
     end
-    self.class.installpkgdmg(source,name)
+
+    self.class.installpkgdmg(source, name)
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package do
@@ -5,20 +7,19 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
   commands :pkgin => "pkgin"
 
-  defaultfor :operatingsystem => [ :smartos, :netbsd ]
+  defaultfor 'os.name' => [:smartos, :netbsd]
 
   has_feature :installable, :uninstallable, :upgradeable, :versionable
 
   def self.parse_pkgin_line(package)
-
     # e.g.
     #   vim-7.2.446;Vim editor (vi clone) without GUI
     match, name, version, status = *package.match(/([^\s;]+)-([^\s;]+)[;\s](=|>|<)?.+$/)
     if match
       {
-        :name     => name,
-        :status   => status,
-        :ensure   => version
+        :name => name,
+        :status => status,
+        :ensure => version
       }
     end
   end
@@ -47,7 +48,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
       end
     end
 
-    packages.first.update( :ensure => :absent )
+    packages.first.update(:ensure => :absent)
   end
 
   def parse_pkgsearch_line
@@ -58,12 +59,12 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
     # Remove the last three lines of help text.
     packages.slice!(-4, 4)
 
-    pkglist = packages.map{ |line| self.class.parse_pkgin_line(line) }
-    pkglist.select{ |package| resource[:name] == package[:name] }
+    pkglist = packages.map { |line| self.class.parse_pkgin_line(line) }
+    pkglist.select { |package| resource[:name] == package[:name] }
   end
 
   def install
-    if String === @resource[:ensure]
+    if @resource[:ensure].is_a?(String)
       pkgin("-y", :install, "#{resource[:name]}-#{resource[:ensure]}")
     else
       pkgin("-y", :install, resource[:name])
@@ -75,13 +76,13 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
   end
 
   def latest
-    package = parse_pkgsearch_line.detect{ |p| p[:status] == '<' }
-    return properties[:ensure] if not package
-    return package[:ensure]
+    package = parse_pkgsearch_line.detect { |p| p[:status] == '<' }
+    return properties[:ensure] unless package
+
+    package[:ensure]
   end
 
   def update
     pkgin("-y", :install, resource[:name])
   end
-
 end