puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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

@@ -46,7 +46,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
             unless line =~ /Updating the pkgdb/
               # Print a warning on lines we can't match, but move
               # on, since it should be non-fatal
-              warning("Failed to match line #{line}")
+              warning(_("Failed to match line %{line}") % { line: line })
             end
           end
         }
@@ -133,11 +133,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
@@ -209,7 +209,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
       return master_version unless master_version == 0
       return '' if version == -1
-      raise Puppet::Error, "#{version} is not available for this package"
+      raise Puppet::Error, _("%{version} is not available for this package") % { version: version }
     end
   rescue Puppet::ExecutionFailure
     return nil

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

@@ -22,7 +22,7 @@ Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::
           packages << new(hash)
           hash = {}
         else
-          warning("Failed to match line %s" % line)
+          warning(_("Failed to match line %s" % line))
         end
       }
     end

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

@@ -46,7 +46,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     end
 
     unless self.query
-      fail("Could not find package '#{@resource[:name]}'")
+      fail(_("Could not find package '%{name}'") % { name: @resource[:name] })
     end
   end
 
@@ -82,13 +82,13 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
           if match = regex.match(line)
             packages[match.captures[0]] = match.captures[1]
           else
-            warning("Failed to match line '#{line}'")
+            warning(_("Failed to match line '%{line}'") % { line: line })
           end
         end
       end
       packages
     rescue Puppet::ExecutionFailure
-      fail("Error getting installed packages")
+      fail(_("Error getting installed packages"))
     end
   end
 
@@ -173,7 +173,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
     if version
       unless @resource.allow_virtual?
-        warning("#{resource_name} is a group, but allow_virtual is false.")
+        warning(_("%{resource_name} is a group, but allow_virtual is false.") % { resource_name: resource_name })
         return nil
       end
     else
@@ -200,7 +200,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
     is_group = self.class.group?(resource_name)
 
-    fail("Refusing to uninstall package group #{resource_name}, because allow_virtual is false.") if is_group && !@resource.allow_virtual?
+    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 += uninstall_options if @resource[:uninstall_options]
@@ -230,7 +230,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     begin
       source_uri = URI.parse source
     rescue => detail
-      self.fail Puppet::Error, "Invalid source '#{source}': #{detail}", detail
+      self.fail Puppet::Error, _("Invalid source '%{source}': %{detail}") % { source: source, detail: detail }, detail
     end
 
     source = case source_uri.scheme
@@ -239,9 +239,9 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     when /ftp/i then source
     when /file/i then source_uri.path
     when /puppet/i
-      fail "puppet:// URL is not supported by pacman"
+      fail _("puppet:// URL is not supported by pacman")
     else
-      fail "Source #{source} is not supported by pacman"
+      fail _("Source %{source} is not supported by pacman") % { source: source }
     end
     pacman "--noconfirm", "--noprogressbar", "-Sy"
     pacman "--noconfirm", "--noprogressbar", "-U", source
@@ -251,7 +251,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     resource_name = @resource[:name]
 
     # 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.") if self.class.group?(resource_name) && !@resource.allow_virtual?
+    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 += install_options if @resource[:install_options]

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

@@ -43,7 +43,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       when '-'
         {:status => 'known'}
       else
-        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[0..0]]
+        raise ArgumentError, _('Unknown format %s: %s[%s]') % [self.name, flags, flags[0..0]]
       end
     ).merge(
       case flags[1..1]
@@ -52,7 +52,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       when '-'
         {}
       else
-        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[1..1]]
+        raise ArgumentError, _('Unknown format %s: %s[%s]') % [self.name, flags, flags[1..1]]
       end
     )
   end
@@ -82,7 +82,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     when /known/
       {:status => 'known'}
     else
-      raise ArgumentError, 'Unknown format %s: %s' % [self.name, state]
+      raise ArgumentError, _('Unknown format %s: %s') % [self.name, state]
     end
   end
 
@@ -101,7 +101,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
 
     else
-      raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
+      raise ArgumentError, _('Unknown line format %s: %s') % [self.name, line]
     end).merge({:provider => self.name})
   end
 
@@ -111,7 +111,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 #{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)
@@ -146,7 +146,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       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")
+        warning(_("Implicit version %{should} has %{n} possible matches") % { should: should, n: n })
       end
       potential_matches.each{ |p|
         command = is == :absent ? 'install' : 'update'
@@ -156,7 +156,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
           # if the first installable match would cause no changes, we're in sync
           return true
         when 0
-          warning("Selecting version '#{p[:ensure]}' for implicit '#{should}'")
+          warning(_("Selecting version '%{version}' for implicit '%{should}'") % { version: p[:ensure], should: should })
           @resource[:ensure] = p[:ensure]
           return false
         end
@@ -212,7 +212,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     end
     r = exec_cmd(command(:pkg), command, *args, name)
     return r if nofail
-    raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
+    raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] } if r[:exit] != 0
   end
 
   # uninstall the package. The complication comes from the -r_ecursive flag which is no longer
@@ -232,7 +232,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     r = install(true)
     # 4 == /No updates available for this image./
     return if [0,4].include? r[:exit]
-    raise Puppet::Error, "Unable to update #{r[:out]}"
+    raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] }
   end
 
   # list a specific package

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

@@ -75,7 +75,7 @@ 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.new(_("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
@@ -104,7 +104,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         File.open(cached_source) do |dmg|
           xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", dmg.path
           hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
-          raise Puppet::Error.new("No disk entities returned by mount at #{dmg.path}") unless hdiutil_info.has_key?("system-entities")
+          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|
             entity["mount-point"]
           }.compact
@@ -142,10 +142,10 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def install
     source = nil
     unless source = @resource[:source]
-      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a package source.")
+      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package source."))
     end
     unless name = @resource[:name]
-      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a package name.")
+      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package name."))
     end
     self.class.installpkgdmg(source,name)
   end

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

@@ -5,7 +5,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
   commands :pkgin => "pkgin"
 
-  defaultfor :operatingsystem => [ :dragonfly , :smartos, :netbsd ]
+  defaultfor :operatingsystem => [ :smartos, :netbsd ]
 
   has_feature :installable, :uninstallable, :upgradeable, :versionable
 
@@ -40,10 +40,10 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
     if packages.empty?
       if @resource[:ensure] == :absent
-        notice "declared as absent but unavailable #{@resource.file}:#{resource.line}"
+        notice _("declared as absent but unavailable %{file}:%{line}") % { file: @resource.file, line: resource.line }
         return false
       else
-        @resource.fail "No candidate to be installed"
+        @resource.fail _("No candidate to be installed")
       end
     end
 

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

@@ -7,7 +7,7 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
 
   confine :operatingsystem => [:freebsd, :dragonfly]
 
-  defaultfor :operatingsystem => :freebsd
+  defaultfor :operatingsystem => [:freebsd, :dragonfly]
 
   has_feature :versionable
   has_feature :upgradeable

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

@@ -15,8 +15,8 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
 
   def self.healthcheck()
     unless Puppet::FileSystem.exist?("/var/opt/csw/pkgutil/admin")
-      Puppet.notice "It is highly recommended you create '/var/opt/csw/pkgutil/admin'."
-      Puppet.notice "See /var/opt/csw/pkgutil"
+      Puppet.notice _("It is highly recommended you create '/var/opt/csw/pkgutil/admin'.")
+      Puppet.notice _("See /var/opt/csw/pkgutil")
     end
 
     correct_wgetopts = false
@@ -26,7 +26,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
       end
     end
     if ! correct_wgetopts
-      Puppet.notice "It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf."
+      Puppet.notice _("It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf.")
     end
   end
 
@@ -70,7 +70,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
       if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
         { :alias => $1, :name => $2, :avail => $3 }
       else
-        Puppet.warning "Cannot match %s" % line
+        Puppet.warning _("Cannot match %s") % line
       end
     end.reject { |h| h.nil? }
   end
@@ -88,7 +88,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
     output = output.split("\n")
 
     if output[-1] == "Not in catalog"
-      Puppet.warning "Package not in pkgutil catalog: %s" % hash[:justme]
+      Puppet.warning _("Package not in pkgutil catalog: %s") % hash[:justme]
       return nil
     end
 
@@ -142,7 +142,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
 
       return hash
     else
-      Puppet.warning "Cannot match %s" % line
+      Puppet.warning _("Cannot match %s") % line
       return nil
     end
   end

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

@@ -2,14 +2,19 @@ require 'puppet/provider/package'
 require 'fileutils'
 
 Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
-  desc "Provides packaging support for Gentoo's portage system."
+  desc "Provides packaging support for Gentoo's portage system.
 
-  has_features :versionable, :reinstallable
+    This provider supports the `install_options` and `uninstall_options` attributes, which allows command-line
+    flags to be passed to emerge.  These options should be specified as a string (e.g. '--flag'), a hash
+    (e.g. {'--flag' => 'value'}), or an array where each element is either a string or a hash."
+
+  has_features :install_options, :purgeable, :reinstallable, :uninstall_options, :versionable, :virtual_packages
 
   {
-    :emerge => "/usr/bin/emerge",
-    :eix => "/usr/bin/eix",
-    :update_eix => "/usr/bin/eix-update",
+    :emerge => '/usr/bin/emerge',
+    :eix => '/usr/bin/eix',
+    :qatom_bin => '/usr/bin/qatom',
+    :update_eix => '/usr/bin/eix-update',
   }.each_pair do |name, path|
     has_command(name, path) do
       environment :HOME => '/'
@@ -24,15 +29,18 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     result_format = self.eix_result_format
     result_fields = self.eix_result_fields
 
+    limit = self.eix_limit
     version_format = self.eix_version_format
     slot_versions_format = self.eix_slot_versions_format
+    installed_versions_format = self.eix_installed_versions_format
+    installable_versions_format = self.eix_install_versions_format
     begin
-      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format do
-        search_output = eix *(self.eix_search_arguments + ["--installed"])
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix *(self.eix_search_arguments + ['--installed'])
       end
 
       packages = []
@@ -57,65 +65,123 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
   def install
     should = @resource.should(:ensure)
-    name = package_name
-    unless should == :present or should == :latest
-      # We must install a specific version
-      name = package_atom_with_version(should)
+    cmd = %w{}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + qatom[:slot] if qatom[:slot]
+    cmd << '--update' if [:latest].include?(should)
+    cmd += install_options if @resource[:install_options]
+    cmd << name
+    emerge *cmd
+  end
+
+  def uninstall
+    should = @resource.should(:ensure)
+    cmd = %w{--rage-clean}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + qatom[:slot] if qatom[:slot]
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << name
+    if [:purged].include?(should)
+      Puppet::Util.withenv :CONFIG_PROTECT => "-*" do
+        emerge *cmd
+      end
+    else
+      emerge *cmd
     end
-    emerge name
   end
 
-  # The common package name format.
-  def package_name
-    @resource[:category] ? "#{@resource[:category]}/#{@resource[:name]}" : @resource[:name]
+  def reinstall
+    self.install
   end
 
-  def package_name_without_slot
-    package_name.sub(self.class.slot_pattern, '')
+  def update
+    self.install
   end
 
-  def package_slot
-    if match = package_name.match(self.class.slot_pattern)
-      match[1]
+  def qatom
+    output_format = self.qatom_output_format
+    result_format = self.qatom_result_format
+    result_fields = self.qatom_result_fields
+    @atom ||= begin
+      search_output = nil
+      package_info = {}
+      # do the search
+      search_output = qatom_bin *([@resource[:name], '--format', output_format])
+      # verify if the search found anything
+      match = result_format.match(search_output)
+      if match
+        result_fields.zip(match.captures) do |field, value|
+          # some fields can be empty or (null) (if we are not passed a category in the package name for instance)
+          if value == '(null)'
+            package_info[field] = nil
+          elsif !value or value.empty?
+            package_info[field] = nil
+          else
+            package_info[field] = value
+          end
+        end
+      end
+      @atom = package_info
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
     end
   end
 
-  def package_atom_with_version(version)
-    if slot = package_slot
-      "=#{package_name_without_slot}-#{version}:#{package_slot}"
-    else
-      "=#{package_name}-#{version}"
-    end
+  def qatom_output_format
+    '"[%{CATEGORY}] [%{PN}] [%{PV}] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
   end
 
-  def uninstall
-    emerge "--unmerge", package_name
+  def qatom_result_format
+    /^\"\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\](.*)\"$/
   end
 
-  def reinstall
-    self.install
+  def qatom_result_fields
+    [:category, :pn, :pv, :pr, :slot, :pfx, :sfx]
   end
 
-  def update
-    self.install
+  def self.get_sets
+    @sets ||= begin
+      @sets = emerge *(['--list-sets'])
+    end
   end
 
   def query
+    limit = self.class.eix_limit
     result_format = self.class.eix_result_format
     result_fields = self.class.eix_result_fields
 
     version_format = self.class.eix_version_format
     slot_versions_format = self.class.eix_slot_versions_format
-    search_field = package_name_without_slot.count('/') > 0 ? "--category-name" : "--name"
-    search_value = package_name_without_slot
+    installed_versions_format = self.class.eix_installed_versions_format
+    installable_versions_format = self.class.eix_install_versions_format
+    search_field = qatom[:category] ? '--category-name' : '--name'
+    search_value = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+
+    @eix_result ||= begin
+      # package sets
+      package_sets = []
+      self.class.get_sets.each_line do |package_set|
+        package_sets << package_set.to_s.strip
+      end
 
-    begin
-      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+      if @resource[:name].match(/^@/)
+         if package_sets.include?(@resource[:name][1..-1].to_s)
+           return({:name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999,"})
+        end
+      end
+
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format do
-        search_output = eix *(self.class.eix_search_arguments + ["--exact",search_field,search_value])
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix *(self.class.eix_search_arguments + ['--exact',search_field,search_value])
       end
 
       packages = []
@@ -127,10 +193,19 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
           result_fields.zip(match.captures) do |field, value|
             package[field] = value unless !value or value.empty?
           end
-          if package_slot
-            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], package_slot)
-            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], package_slot)
+          # dev-lang python [3.4.5] [3.5.2] [2.7.12:2.7,3.4.5:3.4] [2.7.12:2.7,3.4.5:3.4,3.5.2:3.5] https://www.python.org/ An interpreted, interactive, object-oriented programming language
+          # version_available is what we CAN install / update to
+          # ensure is what is currently installed
+          # This DOES NOT choose to install/upgrade or not, just provides current info
+          # prefer checking versions to slots as versions are finer grained
+          if qatom[:pv]
+            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], qatom[:pv])
+            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], qatom[:pv])
+          elsif qatom[:slot]
+            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
+            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
           end
+
           package[:ensure] = package[:ensure] ? package[:ensure] : :absent
           packages << package
         end
@@ -138,12 +213,11 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
       case packages.size
         when 0
-          not_found_value = "#{@resource[:category] ? @resource[:category] : "<unspecified category>"}/#{@resource[:name]}"
-          raise Puppet::Error.new("No package found with the specified name [#{not_found_value}]")
+          raise Puppet::Error.new(_("No package found with the specified name [%{name}]") % { name: @resource[:name] })
         when 1
-          return packages[0]
+          @eix_result = packages[0]
         else
-          raise Puppet::Error.new("More than one package with the specified name [#{search_value}], please use the category parameter to disambiguate")
+          raise Puppet::Error.new(_("More than one package with the specified name [%{search_value}], please use the category parameter to disambiguate") % { search_value: search_value })
       end
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error.new(detail)
@@ -154,40 +228,74 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     self.query[:version_available]
   end
 
+  private
+  def eix_get_version_for_versions(versions, target)
+    # [2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] 3.5.2
+    return nil if versions.nil?
+    versions = versions.split(',')
+    # [2.7.10-r1 2.7.12 3.4.3-r1 3.4.5 3.5.2]
+    versions.find { |version| version == target }
+    # 3.5.2
+  end
+
   private
   def eix_get_version_for_slot(versions_and_slots, slot)
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5] 3.5
     return nil if versions_and_slots.nil?
-    versions_and_slots = versions_and_slots.split(",")
-    versions_and_slots.map! { |version_and_slot| version_and_slot.split(":") }
-    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot }
+    versions_and_slots = versions_and_slots.split(',')
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5]
+    versions_and_slots.map! { |version_and_slot| version_and_slot.split(':') }
+    # [2.7.12: 2.7
+    #  3.4.5:  3.4
+    #  3.5.2:  3.5]
+    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot[1..-1] }
+    # [3.5.2:  3.5]
     version_for_slot.first if version_for_slot
-  end
-
-  def self.slot_pattern
-    /:([\w+.\/*=-]+)$/
+    # 3.5.2
   end
 
   def self.eix_search_format
-    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
+    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<installedversions:INSTALLEDVERSIONS>] [<availableversions:STABLEVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
   end
 
   def self.eix_result_format
-    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
+    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
   end
 
   def self.eix_result_fields
-    [:category, :name, :ensure, :version_available, :installed_slots, :slot_versions_available, :vendor, :description]
+    # ensure:[3.4.5], version_available:[3.5.2], installed_slots:[2.7.12:2.7,3.4.5:3.4], installable_versions:[2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] slot_versions_available:[2.7.12:2.7,3.4.5:3.4,3.5.2:3.5]
+    [:category, :name, :ensure, :version_available, :installed_slots, :installed_versions, :installable_versions, :slot_versions_available, :vendor, :description]
   end
 
   def self.eix_version_format
-    "{last}<version>{}"
+    '{last}<version>{}'
   end
 
   def self.eix_slot_versions_format
-    "{!first},{}<version>:<slot>"
+    '{!first},{}<version>:<slot>'
+  end
+
+  def self.eix_installed_versions_format
+    '{!first},{}<version>'
+  end
+
+  def self.eix_install_versions_format
+    '{!first}{!last},{}{}{isstable}<version>{}'
+  end
+
+  def self.eix_limit
+    '0'
   end
 
   def self.eix_search_arguments
-    ["--nocolor", "--pure-packages", "--format",self.eix_search_format]
+    ['--nocolor', '--pure-packages', '--format', self.eix_search_format]
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
   end
 end