openvox 7.37.1

data/lib/puppet/provider/package/windows/msi_package.rb

@@ -0,0 +1,70 @@
+require_relative '../../../../puppet/provider/package/windows/package'
+
+class Puppet::Provider::Package::Windows
+  class MsiPackage < Puppet::Provider::Package::Windows::Package
+    attr_reader :productcode, :packagecode
+
+    # From msi.h
+    INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
+    INSTALLUILEVEL_NONE  = 2 # completely silent installation
+
+    # registry values to load under each product entry in
+    # HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
+    # for this provider
+    REG_VALUE_NAMES = [
+      'DisplayVersion',
+      'WindowsInstaller'
+    ]
+
+    # Get the COM installer object, it's in a separate method for testing
+    def self.installer
+      # REMIND: when does the COM release happen?
+      WIN32OLE.new("WindowsInstaller.Installer")
+    end
+
+    # Return an instance of the package from the registry, or nil
+    def self.from_registry(name, values)
+      if valid?(name, values)
+        inst = installer
+
+        if inst.ProductState(name) == INSTALLSTATE_DEFAULT
+          MsiPackage.new(get_display_name(values),
+                         values['DisplayVersion'],
+                         name, # productcode
+                         inst.ProductInfo(name, 'PackageCode'))
+        end
+      end
+    end
+
+    # Is this a valid MSI package we should manage?
+    def self.valid?(name, values)
+      # See http://community.spiceworks.com/how_to/show/2238
+      displayName = get_display_name(values)
+      !!(displayName && displayName.length > 0 &&
+         values['WindowsInstaller'] == 1 && # DWORD
+         name =~ /\A\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}\Z/i)
+    end
+
+    def initialize(name, version, productcode, packagecode)
+      super(name, version)
+
+      @productcode = productcode
+      @packagecode = packagecode
+    end
+
+    # Does this package match the resource?
+    def match?(resource)
+      resource[:name].casecmp(packagecode) == 0 ||
+        resource[:name].casecmp(productcode) == 0 ||
+        resource[:name] == name
+    end
+
+    def self.install_command(resource)
+      ['msiexec.exe', '/qn', '/norestart', '/i', munge(resource[:source])]
+    end
+
+    def uninstall_command
+      ['msiexec.exe', '/qn', '/norestart', '/x', productcode]
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require_relative '../../../../puppet/provider/package'
+require_relative '../../../../puppet/util/windows'
+
+class Puppet::Provider::Package::Windows
+  class Package
+    extend Enumerable
+    extend Puppet::Util::Errors
+
+    include Puppet::Util::Windows::Registry
+    extend Puppet::Util::Windows::Registry
+
+    attr_reader :name, :version
+
+    REG_DISPLAY_VALUE_NAMES = [ 'DisplayName', 'QuietDisplayName' ]
+
+    def self.reg_value_names_to_load
+      REG_DISPLAY_VALUE_NAMES |
+      MsiPackage::REG_VALUE_NAMES |
+      ExePackage::REG_VALUE_NAMES
+    end
+
+    # Enumerate each package. The appropriate package subclass
+    # will be yielded.
+    def self.each(&block)
+      with_key do |key, values|
+        name = key.name.match(/^.+\\([^\\]+)$/).captures[0]
+
+        [MsiPackage, ExePackage].find do |klass|
+          pkg = klass.from_registry(name, values)
+          if pkg
+            yield pkg
+          end
+        end
+      end
+    end
+
+    # Yield each registry key and its values associated with an
+    # installed package. This searches both per-machine and current
+    # user contexts, as well as packages associated with 64 and
+    # 32-bit installers.
+    def self.with_key(&block)
+      %w[HKEY_LOCAL_MACHINE HKEY_CURRENT_USER].each do |hive|
+        [KEY64, KEY32].each do |mode|
+          mode |= KEY_READ
+          begin
+            self.open(hive, 'Software\Microsoft\Windows\CurrentVersion\Uninstall', mode) do |uninstall|
+              each_key(uninstall) do |name, wtime|
+                self.open(hive, "#{uninstall.keyname}\\#{name}", mode) do |key|
+                  yield key, values_by_name(key, reg_value_names_to_load)
+                end
+              end
+            end
+          rescue Puppet::Util::Windows::Error => e
+            raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
+          end
+        end
+      end
+    end
+
+    # Get the class that knows how to install this resource
+    def self.installer_class(resource)
+      fail(_("The source parameter is required when using the Windows provider.")) unless resource[:source]
+
+      case resource[:source]
+      when /\.msi"?\Z/i
+        # REMIND: can we install from URL?
+        # REMIND: what about msp, etc
+        MsiPackage
+      when /\.exe"?\Z/i
+        fail(_("The source does not exist: '%{source}'") % { source: resource[:source] }) unless
+          Puppet::FileSystem.exist?(resource[:source]) || resource[:source].start_with?('http://', 'https://')
+        ExePackage
+      else
+        fail(_("Don't know how to install '%{source}'") % { source: resource[:source] })
+      end
+    end
+
+    def self.munge(value)
+      quote(replace_forward_slashes(value))
+    end
+
+    def self.replace_forward_slashes(value)
+      if value.include?('/')
+        value = value.tr('/', "\\")
+        Puppet.debug('Package source parameter contained /s - replaced with \\s')
+      end
+      value
+    end
+
+    def self.quote(value)
+      value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+    end
+
+    def self.get_display_name(values)
+      return if values.nil?
+      return values['DisplayName'] if values['DisplayName'] && values['DisplayName'].length > 0
+      return values['QuietDisplayName'] if values['QuietDisplayName'] && values['QuietDisplayName'].length > 0
+
+      ''
+    end
+
+    def initialize(name, version)
+      @name = name
+      @version = version
+    end
+  end
+end
+
+require_relative '../../../../puppet/provider/package/windows/msi_package'
+require_relative '../../../../puppet/provider/package/windows/exe_package'

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

@@ -0,0 +1,130 @@
+require_relative '../../../puppet/provider/package'
+require_relative '../../../puppet/util/windows'
+require_relative 'windows/package'
+
+Puppet::Type.type(:package).provide(:windows, :parent => Puppet::Provider::Package) do
+  desc "Windows package management.
+
+    This provider supports either MSI or self-extracting executable installers.
+
+    This provider requires a `source` attribute when installing the package.
+    It accepts paths to local files, mapped drives, or UNC paths.
+
+    This provider supports the `install_options` and `uninstall_options`
+    attributes, which allow command-line flags to be passed to the installer.
+    These options should be specified as an array where each element is either
+    a string or a hash.
+
+    If the executable requires special arguments to perform a silent install or
+    uninstall, then the appropriate arguments should be specified using the
+    `install_options` or `uninstall_options` attributes, respectively.  Puppet
+    will automatically quote any option that contains spaces."
+
+  confine    :operatingsystem => :windows
+  defaultfor :operatingsystem => :windows
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :install_options
+  has_feature :uninstall_options
+  has_feature :versionable
+
+  attr_accessor :package
+  class << self
+    attr_accessor :paths
+  end
+
+  def self.post_resource_eval
+    @paths.each do |path|
+      begin
+        Puppet::FileSystem.unlink(path)
+      rescue => detail
+        raise Puppet::Error.new(_("Error when unlinking %{path}: %{detail}") % { path: path ,detail: detail.message}, detail)
+      end
+    end if @paths
+  end
+
+  # Return an array of provider instances
+  def self.instances
+    Puppet::Provider::Package::Windows::Package.map do |pkg|
+      provider = new(to_hash(pkg))
+      provider.package = pkg
+      provider
+    end
+  end
+
+  def self.to_hash(pkg)
+    {
+      :name     => pkg.name,
+      :ensure   => pkg.version || :installed,
+      :provider => :windows
+    }
+  end
+
+  # Query for the provider hash for the current resource. The provider we
+  # are querying, may not have existed during prefetch
+  def query
+    Puppet::Provider::Package::Windows::Package.find do |pkg|
+      if pkg.match?(resource)
+        return self.class.to_hash(pkg)
+      end
+    end
+    nil
+  end
+
+  def install
+    installer = Puppet::Provider::Package::Windows::Package.installer_class(resource)
+
+    command = [installer.install_command(resource), install_options].flatten.compact.join(' ')
+    working_dir = File.dirname(resource[:source])
+    unless Puppet::FileSystem.exist?(working_dir)
+      working_dir = nil
+    end
+    output = execute(command, :failonfail => false, :combine => true, :cwd => working_dir, :suppress_window => true)
+
+    check_result(output.exitstatus)
+  end
+
+  def uninstall
+    command = [package.uninstall_command, uninstall_options].flatten.compact.join(' ')
+    output = execute(command, :failonfail => false, :combine => true, :suppress_window => true)
+
+    check_result(output.exitstatus)
+  end
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+  self::ERROR_SUCCESS                  = 0
+  self::ERROR_SUCCESS_REBOOT_INITIATED = 1641
+  self::ERROR_SUCCESS_REBOOT_REQUIRED  = 3010
+
+  # (Un)install may "fail" because the package requested a reboot, the system requested a
+  # reboot, or something else entirely. Reboot requests mean the package was installed
+  # successfully, but we warn since we don't have a good reboot strategy.
+  def check_result(hr)
+    operation = resource[:ensure] == :absent ? 'uninstall' : 'install'
+
+    case hr
+    when self.class::ERROR_SUCCESS
+      # yeah
+    when self.class::ERROR_SUCCESS_REBOOT_INITIATED
+      warning(_("The package %{operation}ed successfully and the system is rebooting now.") % { operation: operation })
+    when self.class::ERROR_SUCCESS_REBOOT_REQUIRED
+      warning(_("The package %{operation}ed successfully, but the system must be rebooted.") % { operation: operation })
+    else
+      raise Puppet::Util::Windows::Error.new(_("Failed to %{operation}") % { operation: operation }, hr)
+    end
+  end
+
+  # This only gets called if there is a value to validate, but not if it's absent
+  def validate_source(value)
+    fail(_("The source parameter cannot be empty when using the Windows provider.")) if value.empty?
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  end
+end

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

@@ -0,0 +1,387 @@
+require_relative '../../../puppet/util/package/version/range'
+require_relative '../../../puppet/util/package/version/rpm'
+require_relative '../../../puppet/util/rpm_compare'
+
+Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
+  # provides Rpm parsing and comparison
+  include Puppet::Util::RpmCompare
+
+  desc "Support via `yum`.
+
+  Using this provider's `uninstallable` feature will not remove dependent packages. To
+  remove dependent packages with this provider use the `purgeable` feature, but note this
+  feature is destructive and should be used with the utmost care.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to yum.
+  These options should be specified as an array where each element is either a string or a hash."
+
+  has_feature :install_options, :versionable, :virtual_packages, :install_only, :version_ranges
+
+  RPM_VERSION       = Puppet::Util::Package::Version::Rpm
+  RPM_VERSION_RANGE = Puppet::Util::Package::Version::Range
+
+  commands :cmd => "yum", :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+defaultfor :operatingsystem => :amazon
+defaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+    return false if is.include?(self.class::MULTIVERSION_SEPARATOR) && !@resource[:install_only]
+
+    should = @resource[:ensure]
+    if should.is_a?(String)
+      begin
+        should_version = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+
+        if should_version.is_a?(RPM_VERSION_RANGE::Eq)
+          return super
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return super
+      end
+
+      is.split(self.class::MULTIVERSION_SEPARATOR).any? do |version|
+        begin
+          is_version = RPM_VERSION.parse(version)
+          should_version.include?(is_version)
+        rescue RPM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{is} as a RPM version")
+        end
+      end
+    end
+  end
+
+  VERSION_REGEX = /^(?:(\d+):)?(\S+)-(\S+)$/
+
+  def self.prefetch(packages)
+    raise Puppet::Error, _("The yum provider can only be used as root") if Process.euid != 0
+    super
+  end
+
+  # Retrieve the latest package version information for a given package name
+  # and combination of repos to enable and disable.
+  #
+  # @note If multiple package versions are defined (such as in the case where a
+  #   package is built for multiple architectures), the first package found
+  #   will be used.
+  #
+  # @api private
+  # @param package [String] The name of the package to query
+  # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
+  # @return [Hash<Symbol, String>]
+  def self.latest_package_version(package, disablerepo, enablerepo, disableexcludes)
+
+    key = [disablerepo, enablerepo, disableexcludes]
+
+    @latest_versions ||= {}
+    if @latest_versions[key].nil?
+      @latest_versions[key] = check_updates(disablerepo, enablerepo, disableexcludes)
+    end
+
+    if @latest_versions[key][package]
+      @latest_versions[key][package].first
+    end
+  end
+
+  # Search for all installed packages that have newer versions, given a
+  # combination of repositories to enable and disable.
+  #
+  # @api private
+  # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
+  # @return [Hash<String, Array<Hash<String, String>>>] All packages that were
+  #   found with a list of found versions for each package.
+  def self.check_updates(disablerepo, enablerepo, disableexcludes)
+    args = [command(:cmd), 'check-update']
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
+
+    output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
+
+    updates = {}
+    if output.exitstatus == 100
+      updates = parse_updates(output)
+    elsif output.exitstatus == 0
+      self.debug "#{command(:cmd)} check-update exited with 0; no package updates available."
+    else
+      self.warning _("Could not check for updates, '%{cmd} check-update' exited with %{status}") % { cmd: command(:cmd), status: output.exitstatus }
+    end
+    updates
+  end
+
+  def self.parse_updates(str)
+    # Strip off all content that contains Obsoleting, Security: or Update
+    body = str.partition(/^(Obsoleting|Security:|Update)/).first
+
+    updates = Hash.new { |h, k| h[k] = [] }
+
+    body.split(/^\s*\n/).each do |line|
+      line.split.each_slice(3) do |tuple|
+        next unless tuple[0].include?('.') && tuple[1] =~ VERSION_REGEX
+
+        hash = update_to_hash(*tuple[0..1])
+        # Create entries for both the package name without a version and a
+        # version since yum considers those as mostly interchangeable.
+        short_name = hash[:name]
+        long_name  = "#{hash[:name]}.#{hash[:arch]}"
+        updates[short_name] << hash
+        updates[long_name] << hash
+      end
+    end
+    updates
+  end
+
+  def self.update_to_hash(pkgname, pkgversion)
+
+    # The pkgname string has two parts: name, and architecture. Architecture
+    # is the portion of the string following the last "." character. All
+    # characters preceding the final dot are the package name. Parse out
+    # these two pieces of component data.
+    name, _, arch = pkgname.rpartition('.')
+    if name.empty?
+      raise _("Failed to parse package name and architecture from '%{pkgname}'") % { pkgname: pkgname }
+    end
+
+    match = pkgversion.match(VERSION_REGEX)
+    epoch = match[1] || '0'
+    version = match[2]
+    release = match[3]
+
+    {
+      :name => name,
+      :epoch => epoch,
+      :version => version,
+      :release => release,
+      :arch    => arch,
+    }
+  end
+
+  def self.clear
+    @latest_versions = nil
+  end
+
+  def self.error_level
+    '0'
+  end
+
+  def self.update_command
+    # In yum both `upgrade` and `update` can be used to update packages
+    # `yum upgrade` == `yum --obsoletes update`
+    # Quote the DNF docs:
+    # "Yum does this if its obsoletes config option is enabled but
+    # the behavior is not properly documented and can be harmful."
+    # So we'll stick with the safer option
+    # If a user wants to remove obsoletes, they can use { :install_options => '--obsoletes' }
+    # More detail here: https://bugzilla.redhat.com/show_bug.cgi?id=1096506
+    'update'
+  end
+
+  def best_version(should)
+    if should.is_a?(String)
+      begin
+        should_range = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+        if should_range.is_a?(RPM_VERSION_RANGE::Eq)
+          return should
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return should
+      end
+      versions = []
+      available_versions(@resource[:name], disablerepo, enablerepo, disableexcludes).each do |version|
+        begin
+          rpm_version = RPM_VERSION.parse(version)
+          versions << rpm_version if should_range.include?(rpm_version)
+        rescue RPM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{version} as a RPM version")
+        end
+      end
+
+      version = versions.sort.last if versions.any?
+
+      if version
+        version = version.to_s.sub(/^\d+:/, '')
+        return version
+      end
+
+      Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+      should
+    end
+  end
+
+  def available_versions(package_name, disablerepo, enablerepo, disableexcludes)
+    args = [command(:cmd), 'list', package_name, '--showduplicates']
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
+
+    output = execute("#{args.compact.join(' ')} | sed -e '1,/Available Packages/ d' | awk '{print $2}'")
+    output.split("\n")
+  end
+
+  def install
+    wanted = @resource[:name]
+    error_level = self.class.error_level
+    update_command = self.class.update_command
+    # If not allowing virtual packages, do a query to ensure a real package exists
+    unless @resource.allow_virtual?
+      execute([command(:cmd), '-d', '0', '-e', error_level, '-y', install_options, :list, wanted].compact)
+    end
+
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    operation = :install
+
+    case should
+    when :latest
+      current_package = self.query
+      if current_package && !current_package[:ensure].to_s.empty?
+        operation = update_command
+        self.debug "Ensuring latest, so using #{operation}"
+      else
+        self.debug "Ensuring latest, but package is absent, so using install"
+        operation = :install
+      end
+      should = nil
+    when true, :present, :installed
+      # if we have been given a source and we were not asked for a specific
+      # version feed it to yum directly
+      if @resource[:source]
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      end
+      should = nil
+    when false,:absent
+      # pass
+      should = nil
+    else
+      if @resource[:source]
+        # An explicit source was supplied, which means we're ensuring a specific
+        # version, and also supplying the path to a package that supplies that
+        # version.
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      else
+        # No explicit source was specified, so add the package version
+        should = best_version(should)
+        wanted += "-#{should}"
+        if wanted.scan(self.class::ARCH_REGEX)
+          self.debug "Detected Arch argument in package! - Moving arch to end of version string"
+          wanted.gsub!(/(.+)(#{self.class::ARCH_REGEX})(.+)/,'\1\3\2')
+        end
+      end
+      current_package = self.query
+      if current_package
+        if @resource[:install_only]
+          self.debug "Updating package #{@resource[:name]} from version #{current_package[:ensure]} to #{should} as install_only packages are never downgraded"
+          operation = update_command
+        elsif rpm_compareEVR(should, current_package[:ensure]) < 0
+          self.debug "Downgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = :downgrade
+        elsif rpm_compareEVR(should, current_package[:ensure]) > 0
+          self.debug "Upgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = update_command
+        end
+      end
+    end
+
+    # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
+    # ensure we capture output to check for errors.
+    no_debug = if Puppet.runtime[:facter].value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
+    command = [command(:cmd)] + no_debug + ["-e", error_level, "-y", install_options, operation, wanted].compact
+    output = execute(command)
+
+    if output.to_s =~ /^No package #{wanted} available\.$/
+      raise Puppet::Error, _("Could not find package %{wanted}") % { wanted: wanted }
+    end
+
+    # If a version was specified, query again to see if it is a matching version
+    if should
+      is = self.query
+      raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
+
+      version = is[:ensure]
+      # FIXME: Should we raise an exception even if should == :latest
+      # and yum updated us to a version other than @param_hash[:ensure] ?
+      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: version } unless
+        insync?(version)
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = self.class.latest_package_version(@resource[:name], disablerepo, enablerepo, disableexcludes)
+    unless upd.nil?
+      # FIXME: there could be more than one update for a package
+      # because of multiarch
+      return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
+    else
+      # Yum didn't find updates, pretend the current version is the latest
+      self.debug "Yum didn't find updates, current version (#{properties[:ensure]}) is the latest"
+      version = properties[:ensure]
+      raise Puppet::DevError, _("Tried to get latest on a missing package") if version == :absent || version == :purged
+      return version
+    end
+  end
+
+  def update
+    # Install in yum can be used for update, too
+    self.install
+  end
+
+  def purge
+    execute([command(:cmd), "-y", :erase, @resource[:name]])
+  end
+
+  private
+
+  def enablerepo
+    scan_options(resource[:install_options], '--enablerepo')
+  end
+
+  def disablerepo
+    scan_options(resource[:install_options], '--disablerepo')
+  end
+
+  def disableexcludes
+    scan_options(resource[:install_options], '--disableexcludes')
+  end
+
+  # Scan a structure that looks like the package type 'install_options'
+  # structure for all hashes that have a specific key.
+  #
+  # @api private
+  # @param options [Array<String | Hash>, nil] The options structure. If the
+  #   options are nil an empty array will be returned.
+  # @param key [String] The key to look for in all contained hashes
+  # @return [Array<String>] All hash values with the given key.
+  def scan_options(options, key)
+    return [] unless options.is_a?(Enumerable)
+    values = options.map do | repo |
+      value = if repo.is_a?(String)
+        next unless repo.include?('=')
+        Hash[*repo.strip.split('=')] # make it a hash
+      else
+        repo
+      end
+      value[key]
+    end
+    values.compact.uniq
+  end
+end