openvox 8.19.0

data/lib/puppet/util/network_device/transport/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../../../puppet/util/network_device'
+require_relative '../../../../puppet/util/network_device/transport'
+
+class Puppet::Util::NetworkDevice::Transport::Base
+  attr_accessor :user, :password, :host, :port
+  attr_accessor :default_prompt, :timeout
+
+  def initialize
+    @timeout = 10
+  end
+
+  def send(cmd)
+  end
+
+  def expect(prompt)
+  end
+
+  def command(cmd, options = {})
+    send(cmd)
+    expect(options[:prompt] || default_prompt) do |output|
+      yield output if block_given?
+    end
+  end
+end

data/lib/puppet/util/network_device/transport.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/network_device'
+
+# stub
+module Puppet::Util::NetworkDevice::Transport
+end

data/lib/puppet/util/network_device.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Puppet::Util::NetworkDevice
+  class << self
+    attr_reader :current
+  end
+
+  def self.init(device)
+    require "puppet/util/network_device/#{device.provider}/device"
+    @current = Puppet::Util::NetworkDevice.const_get(device.provider.capitalize).const_get(:Device).new(device.url, device.options)
+  rescue => detail
+    raise detail, _("Can't load %{provider} for %{device}: %{detail}") % { provider: device.provider, device: device.name, detail: detail }, detail.backtrace
+  end
+
+  # Should only be used in tests
+  def self.teardown
+    @current = nil
+  end
+end

data/lib/puppet/util/package/version/debian.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Package::Version
+  class Debian < Numeric
+    include Comparable
+
+    # Version string matching regexes
+    REGEX_EPOCH = '(?:([0-9]+):)?'
+    # alphanumerics and the characters . + - ~ , starts with a digit, ~ only of debian_revision is present
+    REGEX_UPSTREAM_VERSION = '([\.\+~0-9a-zA-Z-]+?)'
+    # alphanumerics and the characters + . ~
+    REGEX_DEBIAN_REVISION = '(?:-([\.\+~0-9a-zA-Z]*))?'
+
+    REGEX_FULL    = REGEX_EPOCH + REGEX_UPSTREAM_VERSION + REGEX_DEBIAN_REVISION.freeze
+    REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/
+
+    class ValidationFailure < ArgumentError; end
+
+    def self.parse(ver)
+      raise ValidationFailure, "Unable to parse '#{ver}' as a string" unless ver.is_a?(String)
+
+      match, epoch, upstream_version, debian_revision = *ver.match(REGEX_FULL_RX)
+
+      raise ValidationFailure, "Unable to parse '#{ver}' as a debian version identifier" unless match
+
+      new(epoch.to_i, upstream_version, debian_revision).freeze
+    end
+
+    def to_s
+      s = @upstream_version
+      s = "#{@epoch}:#{s}" if @epoch != 0
+      s = "#{s}-#{@debian_revision}" if @debian_revision
+      s
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        @epoch.eql?(other.epoch) &&
+        @upstream_version.eql?(other.upstream_version) &&
+        @debian_revision.eql?(other.debian_revision)
+    end
+    alias == eql?
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      cmp = @epoch <=> other.epoch
+      if cmp == 0
+        cmp = compare_upstream_version(other)
+        if cmp == 0
+          cmp = compare_debian_revision(other)
+        end
+      end
+      cmp
+    end
+
+    attr_reader :epoch, :upstream_version, :debian_revision
+
+    private
+
+    def initialize(epoch, upstream_version, debian_revision)
+      @epoch            = epoch
+      @upstream_version = upstream_version
+      @debian_revision  = debian_revision
+    end
+
+    def compare_upstream_version(other)
+      mine = @upstream_version
+      yours = other.upstream_version
+      compare_debian_versions(mine, yours)
+    end
+
+    def compare_debian_revision(other)
+      mine = @debian_revision
+      yours = other.debian_revision
+      compare_debian_versions(mine, yours)
+    end
+
+    def compare_debian_versions(mine, yours)
+      #   First the initial part of each string consisting entirely of non-digit characters is determined.
+      # These two parts (one of which may be empty) are compared lexically. If a difference is found it is
+      # returned. The lexical comparison is a comparison of ASCII values modified so that all the letters
+      # sort earlier than all the non-letters and so that a tilde sorts before anything, even the end of a
+      # part. For example, the following parts are in sorted order from earliest to latest: ~~, ~~a, ~, the
+      # empty part, a.
+      #
+      #   Then the initial part of the remainder of each string which consists entirely of digit characters
+      # is determined. The numerical values of these two parts are compared, and any difference found is
+      # returned as the result of the comparison. For these purposes an empty string (which can only occur
+      # at the end of one or both version strings being compared) counts as zero.
+      #
+      #   These two steps (comparing and removing initial non-digit strings and initial digit strings) are
+      # repeated until a difference is found or both strings are exhausted.
+
+      mine_index = 0
+      yours_index = 0
+      cmp = 0
+      mine ||= ''
+      yours ||= ''
+      while mine_index < mine.length && yours_index < yours.length && cmp == 0
+        # handle ~
+        _mymatch, mytilde = *match_tildes(mine.slice(mine_index..-1))
+        mytilde ||= ''
+
+        _yoursmatch, yourstilde = *match_tildes(yours.slice(yours_index..-1))
+        yourstilde ||= ''
+
+        cmp = -1 * (mytilde.length <=> yourstilde.length)
+        mine_index += mytilde.length
+        yours_index += yourstilde.length
+
+        next unless cmp == 0 # handle letters
+
+        _mymatch, myletters = *match_letters(mine.slice(mine_index..-1))
+        myletters ||= ''
+
+        _yoursmatch, yoursletters = *match_letters(yours.slice(yours_index..-1))
+        yoursletters ||= ''
+
+        cmp = myletters <=> yoursletters
+        mine_index += myletters.length
+        yours_index += yoursletters.length
+
+        next unless cmp == 0 # handle nonletters except tilde
+
+        _mymatch, mynon_letters = *match_non_letters(mine.slice(mine_index..-1))
+        mynon_letters ||= ''
+
+        _yoursmatch, yoursnon_letters = *match_non_letters(yours.slice(yours_index..-1))
+        yoursnon_letters ||= ''
+
+        cmp = mynon_letters <=> yoursnon_letters
+        mine_index += mynon_letters.length
+        yours_index += yoursnon_letters.length
+
+        next unless cmp == 0 # handle digits
+
+        _mymatch, mydigits = *match_digits(mine.slice(mine_index..-1))
+        mydigits ||= ''
+
+        _yoursmatch, yoursdigits = *match_digits(yours.slice(yours_index..-1))
+        yoursdigits ||= ''
+
+        cmp = mydigits.to_i <=> yoursdigits.to_i
+        mine_index += mydigits.length
+        yours_index += yoursdigits.length
+      end
+      if cmp == 0
+        if mine_index < mine.length && match_tildes(mine[mine_index])
+          cmp = -1
+        elsif yours_index < yours.length && match_tildes(yours[yours_index])
+          cmp = 1
+        else
+          cmp = mine.length <=> yours.length
+        end
+      end
+      cmp
+    end
+
+    def match_digits(a)
+      a.match(/^([0-9]+)/)
+    end
+
+    def match_non_letters(a)
+      a.match(/^([.+-]+)/)
+    end
+
+    def match_tildes(a)
+      a.match(/^(~+)/)
+    end
+
+    def match_letters(a)
+      a.match(/^([A-Za-z]+)/)
+    end
+  end
+end

data/lib/puppet/util/package/version/gem.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Package::Version
+  class Gem < ::Gem::Version
+    def self.parse(version)
+      raise ValidationFailure, version unless version.is_a? String
+      raise ValidationFailure, version unless version =~ ANCHORED_VERSION_PATTERN
+
+      new(version)
+    end
+
+    class ValidationFailure < ArgumentError
+      def initialize(version)
+        super("#{version} is not a valid ruby gem version.")
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/pip.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Package::Version
+  class Pip
+    include Comparable
+
+    VERSION_PATTERN = "
+      v?
+      (?:
+        (?:(?<epoch>[0-9]+)!)?                              # epoch
+        (?<release>[0-9]+(?:\\.[0-9]+)*)                    # release segment
+        (?<pre>                                             # pre-release
+          [-_\\.]?
+          (?<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+          [-_\\.]?
+          (?<pre_n>[0-9]+)?
+        )?
+        (?<post>                                            # post release
+          (?:-(?<post_n1>[0-9]+))
+          |
+          (?:
+            [-_\\.]?
+            (?<post_l>post|rev|r)
+            [-_\\.]?
+            (?<post_n2>[0-9]+)?
+          )
+        )?
+        (?<dev>                                             # dev release
+          [-_\\.]?
+          (?<dev_l>dev)
+          [-_\\.]?
+          (?<dev_n>[0-9]+)?
+        )?
+      )
+      (?:\\+(?<local>[a-z0-9]+(?:[-_\\.][a-z0-9]+)*))?      # local version
+    "
+
+    def self.parse(version)
+      raise ValidationFailure, version.to_s unless version.is_a? String
+
+      matched = version.match(Regexp.new("^\\s*" + VERSION_PATTERN + "\\s*$", Regexp::EXTENDED | Regexp::MULTILINE | Regexp::IGNORECASE))
+      raise ValidationFailure, version unless matched
+
+      new(matched)
+    end
+
+    def self.compare(version_a, version_b)
+      version_a = parse(version_a) unless version_a.is_a?(self)
+      version_b = parse(version_b) unless version_b.is_a?(self)
+
+      version_a <=> version_b
+    end
+
+    def to_s
+      parts = []
+
+      parts.push("#{@epoch_data}!")           if @epoch_data && @epoch_data != 0
+      parts.push(@release_data.join("."))     if @release_data
+      parts.push(@pre_data.join)              if @pre_data
+      parts.push(".post#{@post_data[1]}")     if @post_data
+      parts.push(".dev#{@dev_data[1]}")       if @dev_data
+      parts.push("+#{@local_data.join('.')}") if @local_data
+
+      parts.join
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) && key.eql?(other.key)
+    end
+    alias == eql?
+
+    def <=>(other)
+      raise ValidationFailure, other.to_s unless other.is_a?(self.class)
+
+      compare(key, other.key)
+    end
+
+    attr_reader :key
+
+    private
+
+    def initialize(matched)
+      @epoch_data   = matched[:epoch].to_i
+      @release_data = matched[:release].split('.').map(&:to_i)                                       if matched[:release]
+      @pre_data     = parse_letter_version(matched[:pre_l], matched[:pre_n])                         if matched[:pre_l]  || matched[:pre_n]
+      @post_data    = parse_letter_version(matched[:post_l], matched[:post_n1] || matched[:post_n2]) if matched[:post_l] || matched[:post_n1] || matched[:post_n2]
+      @dev_data     = parse_letter_version(matched[:dev_l], matched[:dev_n])                         if matched[:dev_l]  || matched[:dev_n]
+      @local_data   = parse_local_version(matched[:local])                                           if matched[:local]
+
+      @key = compose_key(@epoch_data, @release_data, @pre_data, @post_data, @dev_data, @local_data)
+    end
+
+    def parse_letter_version(letter, number)
+      if letter
+        number ||= 0
+        letter.downcase!
+
+        if letter == "alpha"
+          letter = "a"
+        elsif letter == "beta"
+          letter = "b"
+        elsif %w[c pre preview].include?(letter)
+          letter = "rc"
+        elsif %w[rev r].include?(letter)
+          letter = "post"
+        end
+
+        return [letter, number.to_i]
+      end
+
+      ["post", number.to_i] if !letter && number
+    end
+
+    def parse_local_version(local_version)
+      local_version.split(/[\\._-]/).map { |part| part =~ /[0-9]+/ && part !~ /[a-zA-Z]+/ ? part.to_i : part.downcase } if local_version
+    end
+
+    def compose_key(epoch, release, pre, post, dev, local)
+      release_key = release.reverse
+      release_key.each_with_index do |element, index|
+        break unless element == 0
+
+        release_key.delete_at(index) unless release_key.at(index + 1) != 0
+      end
+      release_key.reverse!
+
+      if !pre && !post && dev
+        pre_key = -Float::INFINITY
+      else
+        pre_key = pre || Float::INFINITY
+      end
+
+      post_key = post || -Float::INFINITY
+
+      dev_key = dev || Float::INFINITY
+
+      if !local
+        local_key = [[-Float::INFINITY, ""]]
+      else
+        local_key = local.map { |i| (i.is_a? Integer) ? [i, ""] : [-Float::INFINITY, i] }
+      end
+
+      [epoch, release_key, pre_key, post_key, dev_key, local_key]
+    end
+
+    def compare(this, other)
+      if (this.is_a? Array) && (other.is_a? Array)
+        this  << -Float::INFINITY if this.length < other.length
+        other << -Float::INFINITY if this.length > other.length
+
+        this.each_with_index do |element, index|
+          return compare(element, other.at(index)) if element != other.at(index)
+        end
+      elsif (this.is_a? Array) && !(other.is_a? Array)
+        raise Puppet::Error, "Cannot compare #{this} (Array) with #{other} (#{other.class}). Only ±Float::INFINITY accepted." unless other.abs == Float::INFINITY
+
+        return other == -Float::INFINITY ? 1 : -1
+      elsif !(this.is_a? Array) && (other.is_a? Array)
+        raise Puppet::Error, "Cannot compare #{this} (#{this.class}) with #{other} (Array). Only ±Float::INFINITY accepted." unless this.abs == Float::INFINITY
+
+        return this == -Float::INFINITY ? -1 : 1
+      end
+      this <=> other
+    end
+
+    class ValidationFailure < ArgumentError
+      def initialize(version)
+        super("#{version} is not a valid python package version. Please refer to https://www.python.org/dev/peps/pep-0440/.")
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/eq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Eq < Simple
+      def to_s
+        @version.to_s
+      end
+
+      def include?(version)
+        version == @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/gt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Gt < Simple
+      def to_s
+        ">#{@version}"
+      end
+
+      def include?(version)
+        version > @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/gt_eq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class GtEq < Simple
+      def to_s
+        ">=#{@version}"
+      end
+
+      def include?(version)
+        version >= @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/lt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Lt < Simple
+      def to_s
+        "<#{@version}"
+      end
+
+      def include?(version)
+        version < @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/lt_eq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class LtEq < Simple
+      def to_s
+        "<=#{@version}"
+      end
+
+      def include?(version)
+        version <= @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/min_max.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range'
+
+module Puppet::Util::Package::Version
+  class Range
+    class MinMax
+      def initialize(min, max)
+        @min = min
+        @max = max
+      end
+
+      def to_s
+        "#{@min} #{@max}"
+      end
+
+      def to_gem_version
+        "#{@min}, #{@max}"
+      end
+
+      def include?(version)
+        @min.include?(version) && @max.include?(version)
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/simple.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/util/package/version/range'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Simple
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'range/lt'
+require_relative 'range/lt_eq'
+require_relative 'range/gt'
+require_relative 'range/gt_eq'
+require_relative 'range/eq'
+require_relative 'range/min_max'
+
+module Puppet::Util::Package::Version
+  class Range
+    class ValidationFailure < ArgumentError; end
+    # Parses a version range string into a comparable {Range} instance.
+    #
+    # Currently parsed version range string may take any of the following
+    # forms:
+    #
+    # * Regular Version strings
+    #   * ex. `"1.0.0"`, `"1.2.3-pre"`
+    # * Inequalities
+    #   * ex. `">1.0.0"`, `"<3.2.0"`, `">=4.0.0"`
+    # * Range Intersections (min is always first)
+    #   * ex. `">1.0.0 <=2.3.0"`
+    #
+    RANGE_SPLIT = /\s+/
+    FULL_REGEX = /\A((?:[<>=])*)(.+)\Z/
+
+    # @param range_string [String] the version range string to parse
+    # @param version_class [Version] a version class implementing comparison operators and parse method
+    # @return [Range] a new {Range} instance
+    # @api public
+    def self.parse(range_string, version_class)
+      raise ValidationFailure, "Unable to parse '#{range_string}' as a string" unless range_string.is_a?(String)
+
+      simples = range_string.split(RANGE_SPLIT).map do |simple|
+        match, operator, version = *simple.match(FULL_REGEX)
+        raise ValidationFailure, "Unable to parse '#{simple}' as a version range identifier" unless match
+
+        case operator
+        when '>'
+          Gt.new(version_class.parse(version))
+        when '>='
+          GtEq.new(version_class.parse(version))
+        when '<'
+          Lt.new(version_class.parse(version))
+        when '<='
+          LtEq.new(version_class.parse(version))
+        when ''
+          Eq.new(version_class.parse(version))
+        else
+          raise ValidationFailure, "Operator '#{operator}' is not implemented"
+        end
+      end
+      simples.size == 1 ? simples[0] : MinMax.new(simples[0], simples[1])
+    end
+  end
+end

data/lib/puppet/util/package/version/rpm.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative '../../../../puppet/util/rpm_compare'
+
+module Puppet::Util::Package::Version
+  class Rpm < Numeric
+    # provides Rpm parsing and comparison
+    extend Puppet::Util::RpmCompare
+    include Puppet::Util::RpmCompare
+    include Comparable
+
+    class ValidationFailure < ArgumentError; end
+
+    attr_reader :epoch, :version, :release, :arch
+
+    def self.parse(ver)
+      raise ValidationFailure unless ver.is_a?(String)
+
+      version = rpm_parse_evr(ver)
+      new(version[:epoch], version[:version], version[:release], version[:arch]).freeze
+    end
+
+    def to_s
+      version_found = ''.dup
+      version_found += "#{@epoch}:" if @epoch
+      version_found += @version
+      version_found += "-#{@release}" if @release
+      version_found
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        @epoch.eql?(other.epoch) &&
+        @version.eql?(other.version) &&
+        @release.eql?(other.release) &&
+        @arch.eql?(other.arch)
+    end
+    alias == eql?
+
+    def <=>(other)
+      raise ArgumentError, _("Cannot compare, as %{other} is not a Rpm Version") % { other: other } unless other.is_a?(self.class)
+
+      rpm_compare_evr(to_s, other.to_s)
+    end
+
+    private
+
+    # overwrite rpm_compare_evr to treat no epoch as zero epoch
+    # in order to compare version correctly
+    #
+    # returns 1 if a is newer than b,
+    #         0 if they are identical
+    #        -1 if a is older than b
+    def rpm_compare_evr(a, b)
+      a_hash = rpm_parse_evr(a)
+      b_hash = rpm_parse_evr(b)
+
+      a_hash[:epoch] ||= '0'
+      b_hash[:epoch] ||= '0'
+
+      rc = compare_values(a_hash[:epoch], b_hash[:epoch])
+      return rc unless rc == 0
+
+      super(a, b)
+    end
+
+    def initialize(epoch, version, release, arch)
+      @epoch   = epoch
+      @version = version
+      @release = release
+      @arch    = arch
+    end
+  end
+end