puppet 5.3.4 → 6.29.0

data/lib/puppet/vendor/semantic/lib/semantic.rb

@@ -1,5 +0,0 @@
-require 'puppet/vendor/semantic_puppet/lib/semantic_puppet'
-
-$stderr.puts "Warning: Puppet's internal vendored libraries are Private APIs and can change without warning. The 'semantic' library has been replaced with 'semantic_puppet'."
-
-Semantic = SemanticPuppet

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency/graph.rb

@@ -1,60 +0,0 @@
-require 'semantic_puppet/dependency'
-
-module SemanticPuppet
-  module Dependency
-    class Graph
-      include GraphNode
-
-      attr_reader :modules
-
-      # Create a new instance of a dependency graph.
-      #
-      # @param modules [{String => VersionRange}] the required module
-      #        set and their version constraints
-      def initialize(modules = {})
-        @modules = modules.keys
-
-        modules.each do |name, range|
-          add_constraint('initialize', name, range.to_s) do |node|
-            range === node.version
-          end
-
-          add_dependency(name)
-        end
-      end
-
-      # Constrains graph solutions based on the given block.  Graph constraints
-      # are used to describe fundamental truths about the tooling or module
-      # system (e.g.: module names contain a namespace component which is
-      # dropped during install, so module names must be unique excluding the
-      # namespace).
-      #
-      # @example Ensuring a single source for all modules
-      #     @graph.add_constraint('installed', mod.name) do |nodes|
-      #       nodes.count { |node| node.source } == 1
-      #     end
-      #
-      # @see #considering_solution?
-      #
-      # @param source [String, Symbol] a name describing the source of the
-      #               constraint
-      # @yieldparam nodes [Array<GraphNode>] the nodes to test the constraint
-      #             against
-      # @yieldreturn [Boolean] whether the node passed the constraint
-      # @return [void]
-      def add_graph_constraint(source, &block)
-        constraints[:graph] << [ source, block ]
-      end
-
-      # Checks the proposed solution (or partial solution) against the graph's
-      # constraints.
-      #
-      # @see #add_graph_constraint
-      #
-      # @return [Boolean] true if none of the graph constraints are violated
-      def satisfies_graph?(solution)
-        constraints[:graph].all? { |_, check| check[solution] }
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency/graph_node.rb

@@ -1,117 +0,0 @@
-require 'semantic_puppet/dependency'
-require 'set'
-
-module SemanticPuppet
-  module Dependency
-    module GraphNode
-      include Comparable
-
-      def name
-      end
-
-      # Determines whether the modules dependencies are satisfied by the known
-      # releases.
-      #
-      # @return [Boolean] true if all dependencies are satisfied
-      def satisfied?
-        dependencies.none? { |_, v| v.empty? }
-      end
-
-      def children
-        @_children ||= {}
-      end
-
-      def populate_children(nodes)
-        if children.empty?
-          nodes = nodes.select { |node| satisfies_dependency?(node) }
-          nodes.each do |node|
-            children[node.name] = node
-            node.populate_children(nodes)
-          end
-          self.freeze
-        end
-      end
-
-      # @api internal
-      # @return [{ String => SortedSet<GraphNode> }] the satisfactory
-      #         dependency nodes
-      def dependencies
-        @_dependencies ||= Hash.new { |h, k| h[k] = SortedSet.new }
-      end
-
-      # Adds the given dependency name to the list of dependencies.
-      #
-      # @param name [String] the dependency name
-      # @return [void]
-      def add_dependency(name)
-        dependencies[name]
-      end
-
-      # @return [Array<String>] the list of dependency names
-      def dependency_names
-        dependencies.keys
-      end
-
-      def constraints
-        @_constraints ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      def constraints_for(name)
-        return [] unless constraints.has_key?(name)
-
-        constraints[name].map do |constraint|
-          {
-            :source      => constraint[0],
-            :description => constraint[1],
-            :test        => constraint[2],
-          }
-        end
-      end
-
-      # Constrains the named module to suitable releases, as determined by the
-      # given block.
-      #
-      # @example Version-locking currently installed modules
-      #     installed_modules.each do |m|
-      #       @graph.add_constraint('installed', m.name, m.version) do |node|
-      #         m.version == node.version
-      #       end
-      #     end
-      #
-      # @param source [String, Symbol] a name describing the source of the
-      #               constraint
-      # @param mod [String] the name of the module
-      # @param desc [String] a description of the enforced constraint
-      # @yieldparam node [GraphNode] the node to test the constraint against
-      # @yieldreturn [Boolean] whether the node passed the constraint
-      # @return [void]
-      def add_constraint(source, mod, desc, &block)
-        constraints["#{mod}"] << [ source, desc, block ]
-      end
-
-      def satisfies_dependency?(node)
-        dependencies.key?(node.name) && satisfies_constraints?(node)
-      end
-
-      # @param release [ModuleRelease] the release to test
-      def satisfies_constraints?(release)
-        constraints_for(release.name).all? { |x| x[:test].call(release) }
-      end
-
-      def << (nodes)
-        Array(nodes).each do |node|
-          next unless dependencies.key?(node.name)
-          if satisfies_dependency?(node)
-            dependencies[node.name] << node
-          end
-        end
-
-        return self
-      end
-
-      def <=>(other)
-        name <=> other.name
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency/module_release.rb

@@ -1,58 +0,0 @@
-require 'semantic_puppet/dependency'
-
-module SemanticPuppet
-  module Dependency
-    class ModuleRelease
-      include GraphNode
-
-      attr_reader :name, :version
-
-      # Create a new instance of a module release.
-      #
-      # @param source [SemanticPuppet::Dependency::Source]
-      # @param name [String]
-      # @param version [SemanticPuppet::Version]
-      # @param dependencies [{String => SemanticPuppet::VersionRange}]
-      def initialize(source, name, version, dependencies = {})
-        @source      = source
-        @name        = name.freeze
-        @version     = version.freeze
-
-        dependencies.each do |name, range|
-          add_constraint('initialize', name, range.to_s) do |node|
-            range === node.version
-          end
-
-          add_dependency(name)
-        end
-      end
-
-      def priority
-        @source.priority
-      end
-
-      def <=>(oth)
-        our_key   = [ priority, name, version ]
-        their_key = [ oth.priority, oth.name, oth.version ]
-
-        return our_key <=> their_key
-      end
-
-      def eql?(other)
-        other.is_a?(ModuleRelease) &&
-          @name.eql?(other.name) &&
-          @version.eql?(other.version) &&
-          dependencies.eql?(other.dependencies)
-      end
-      alias == eql?
-
-      def hash
-        @name.hash ^ @version.hash
-      end
-
-      def to_s
-        "#<#{self.class} #{name}@#{version}>"
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency/source.rb

@@ -1,25 +0,0 @@
-require 'semantic_puppet/dependency'
-
-module SemanticPuppet
-  module Dependency
-    class Source
-      def self.priority
-        0
-      end
-
-      def priority
-        self.class.priority
-      end
-
-      def create_release(name, version, dependencies = {})
-        version = Version.parse(version) if version.is_a? String
-        dependencies = dependencies.inject({}) do |hash, (key, value)|
-          hash[key] = VersionRange.parse(value || '>= 0.0.0')
-          hash[key] ||= VersionRange::EMPTY_RANGE
-          hash
-        end
-        ModuleRelease.new(self, name, version, dependencies)
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency/unsatisfiable_graph.rb

@@ -1,31 +0,0 @@
-require 'semantic_puppet/dependency'
-
-module SemanticPuppet
-  module Dependency
-    class UnsatisfiableGraph < StandardError
-      attr_reader :graph
-
-      def initialize(graph)
-        @graph = graph
-
-        deps = sentence_from_list(graph.modules)
-        super "Could not find satisfying releases for #{deps}"
-      end
-
-      private
-
-      def sentence_from_list(list)
-        case list.length
-        when 1
-          list.first
-        when 2
-          list.join(' and ')
-        else
-          list = list.dup
-          list.push("and #{list.pop}")
-          list.join(', ')
-        end
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/dependency.rb

@@ -1,181 +0,0 @@
-require 'semantic_puppet'
-
-module SemanticPuppet
-  module Dependency
-    extend self
-
-    autoload :Graph,         'semantic_puppet/dependency/graph'
-    autoload :GraphNode,     'semantic_puppet/dependency/graph_node'
-    autoload :ModuleRelease, 'semantic_puppet/dependency/module_release'
-    autoload :Source,        'semantic_puppet/dependency/source'
-
-    autoload :UnsatisfiableGraph, 'semantic_puppet/dependency/unsatisfiable_graph'
-
-    # @!group Sources
-
-    # @return [Array<Source>] a frozen copy of the {Source} list
-    def sources
-      (@sources ||= []).dup.freeze
-    end
-
-    # Appends a new {Source} to the current list.
-    # @param source [Source] the {Source} to add
-    # @return [void]
-    def add_source(source)
-      sources
-      @sources << source
-      nil
-    end
-
-    # Clears the current list of {Source}s.
-    # @return [void]
-    def clear_sources
-      sources
-      @sources.clear
-      nil
-    end
-
-    # @!endgroup
-
-    # Fetches a graph of modules and their dependencies from the currently
-    # configured list of {Source}s.
-    #
-    # @todo Return a specialized "Graph" object.
-    # @todo Allow for external constraints to be added to the graph.
-    # @see #sources
-    # @see #add_source
-    # @see #clear_sources
-    #
-    # @param modules [{ String => String }]
-    # @return [Graph] the root of a dependency graph
-    def query(modules)
-      constraints = Hash[modules.map { |k, v| [ k, VersionRange.parse(v) ] }]
-
-      graph = Graph.new(constraints)
-      fetch_dependencies(graph)
-      return graph
-    end
-
-    # Given a graph result from {#query}, this method will resolve the graph of
-    # dependencies, if possible, into a flat list of the best suited modules. If
-    # the dependency graph does not have a suitable resolution, this method will
-    # raise an exception to that effect.
-    #
-    # @param graph [Graph] the root of a dependency graph
-    # @return [Array<ModuleRelease>] the list of releases to act on
-    def resolve(graph)
-      catch :next do
-        return walk(graph, graph.dependencies.dup)
-      end
-      raise UnsatisfiableGraph.new(graph)
-    end
-
-    # Fetches all available releases for the given module name.
-    #
-    # @param name [String] the module name to find releases for
-    # @return [Array<ModuleRelease>] the available releases
-    def fetch_releases(name)
-      releases = {}
-
-      sources.each do |source|
-        source.fetch(name).each do |dependency|
-          releases[dependency.version] ||= dependency
-        end
-      end
-
-      return releases.values
-    end
-
-    private
-
-    # Iterates over a changing set of dependencies in search of the best
-    # solution available. Fitness is specified as meeting all the constraints
-    # placed on it, being {ModuleRelease#satisfied? satisfied}, and having the
-    # greatest version number (with stability being preferred over prereleases).
-    #
-    # @todo Traversal order is not presently guaranteed.
-    #
-    # @param graph [Graph] the root of a dependency graph
-    # @param dependencies [{ String => Array<ModuleRelease> }] the dependencies
-    # @param considering [Array<GraphNode>] the set of releases being tested
-    # @return [Array<GraphNode>] the list of releases to use, if successful
-    def walk(graph, dependencies, *considering)
-      return considering if dependencies.empty?
-
-      # Selecting a dependency from the collection...
-      name = dependencies.keys.sort.first
-      deps = dependencies.delete(name)
-
-      # ... (and stepping over it if we've seen it before) ...
-      unless (deps & considering).empty?
-        return walk(graph, dependencies, *considering)
-      end
-
-      # ... we'll iterate through the list of possible versions in order.
-      preferred_releases(deps).reverse_each do |dep|
-
-        # We should skip any releases that violate any module's constraints.
-        unless [graph, *considering].all? { |x| x.satisfies_constraints?(dep) }
-          next
-        end
-
-        # We should skip over any releases that violate graph-level constraints.
-        potential_solution = considering.dup << dep
-        unless graph.satisfies_graph? potential_solution
-          next
-        end
-
-        catch :next do
-          # After adding any new dependencies and imposing our own constraints
-          # on existing dependencies, we'll mark ourselves as "under
-          # consideration" and recurse.
-          merged = dependencies.merge(dep.dependencies) { |_,a,b| a & b }
-
-          # If all subsequent dependencies resolved well, the recursive call
-          # will return a completed dependency list. If there were problems
-          # resolving our dependencies, we'll catch `:next`, which will cause
-          # us to move to the next possibility.
-          return walk(graph, merged, *potential_solution)
-        end
-      end
-
-      # Once we've exhausted all of our possible versions, we know that our
-      # last choice was unusable, so we'll unwind the stack and make a new
-      # choice.
-      throw :next
-    end
-
-    # Given a {ModuleRelease}, this method will iterate through the current
-    # list of {Source}s to find the complete list of versions available for its
-    # dependencies.
-    #
-    # @param node [GraphNode] the node to fetch details for
-    # @return [void]
-    def fetch_dependencies(node, cache = {})
-      node.dependency_names.each do |name|
-        unless cache.key?(name)
-          cache[name] = fetch_releases(name)
-          cache[name].each { |dep| fetch_dependencies(dep, cache) }
-        end
-
-        node << cache[name]
-      end
-    end
-
-    # Given a list of potential releases, this method returns the most suitable
-    # releases for exploration. Only {ModuleRelease#satisfied? satisfied}
-    # releases are considered, and releases with stable versions are preferred.
-    #
-    # @param releases [Array<ModuleRelease>] a list of potential releases
-    # @return [Array<ModuleRelease>] releases open for consideration
-    def preferred_releases(releases)
-      satisfied = releases.select { |x| x.satisfied? }
-
-      if satisfied.any? { |x| x.version.stable? }
-        return satisfied.select { |x| x.version.stable? }
-      else
-        return satisfied
-      end
-    end
-  end
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/gem_version.rb

@@ -1,3 +0,0 @@
-module SemanticPuppet
-  VERSION = '1.0.1'
-end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/version.rb

@@ -1,203 +0,0 @@
-require 'semantic_puppet'
-
-module SemanticPuppet
-  # @note SemanticPuppet::Version subclasses Numeric so that it has sane Range
-  #       semantics in Ruby 1.9+.
-  class Version < Numeric
-    include Comparable
-
-    class ValidationFailure < ArgumentError; end
-
-    # Parse a Semantic Version string.
-    #
-    # @param ver [String] the version string to parse
-    # @return [Version] a comparable {Version} object
-    def self.parse(ver)
-      match, major, minor, patch, prerelease, build = *ver.match(REGEX_FULL_RX)
-
-      raise ValidationFailure, _("Unable to parse '%{version}' as a semantic version identifier") % {version: ver} unless match
-
-      new(major.to_i, minor.to_i, patch.to_i, parse_prerelease(prerelease), parse_build(build)).freeze
-    end
-
-    # Validate a Semantic Version string.
-    #
-    # @param ver [String] the version string to validate
-    # @return [bool] whether or not the string represents a valid Semantic Version
-    def self.valid?(ver)
-      match = ver.match(REGEX_FULL_RX)
-      if match.nil?
-        false
-      else
-        prerelease = match[4]
-        prerelease.nil? || prerelease.split('.').all? { |x| !(x =~ /^0\d+$/) }
-      end
-    end
-
-    def self.parse_build(build)
-      build.nil? ? nil : build.split('.').freeze
-    end
-
-    def self.parse_prerelease(prerelease)
-      return nil unless prerelease
-      prerelease.split('.').map do |x|
-        if x =~ /^\d+$/
-          raise ValidationFailure, _('Numeric pre-release identifiers MUST NOT contain leading zeroes') if x.length > 1 && x.start_with?('0')
-          x.to_i
-        else
-          x
-        end
-      end.freeze
-    end
-
-    attr_reader :major, :minor, :patch
-
-    def initialize(major, minor, patch, prerelease = nil, build = nil)
-      @major      = major
-      @minor      = minor
-      @patch      = patch
-      @prerelease = prerelease
-      @build      = build
-    end
-
-    def next(part)
-      case part
-      when :major
-        self.class.new(@major.next, 0, 0)
-      when :minor
-        self.class.new(@major, @minor.next, 0)
-      when :patch
-        self.class.new(@major, @minor, @patch.next)
-      end
-    end
-
-    # @return [String] the `prerelease` identifier as a string without the leading '-'
-    def prerelease
-      (@prerelease.nil? || @prerelease.empty?) ? nil : @prerelease.join('.')
-    end
-
-    # @return [Boolean] true if this is a stable release
-    def stable?
-      @prerelease.nil? || @prerelease.empty?
-    end
-
-    # @return [Version] this version stripped from any prerelease identifier.
-    def to_stable
-      @prerelease.nil? ? self : Version.new(@major, @minor, @patch, nil, @build)
-    end
-
-    # @return [String] the `build` identifier as a string without the leading '+'
-    def build
-      (@build.nil? || @build.empty?) ? nil : @build.join('.')
-    end
-
-    def <=>(other)
-      return nil unless other.is_a?(Version)
-      cmp = @major <=> other.major
-      if cmp == 0
-        cmp = @minor <=> other.minor
-        if cmp == 0
-          cmp = @patch <=> other.patch
-          if cmp == 0
-            cmp = compare_prerelease(other)
-          end
-        end
-      end
-      cmp
-    end
-
-    def eql?(other)
-      other.is_a?(Version) &&
-        @major.eql?(other.major) &&
-        @minor.eql?(other.minor) &&
-        @patch.eql?(other.patch) &&
-        @prerelease.eql?(other.instance_variable_get(:@prerelease)) &&
-        @build.eql?(other.instance_variable_get(:@build))
-    end
-    alias == eql?
-
-    def to_s
-      s = "#{@major}.#{@minor}.#{@patch}"
-
-      # Appending the @prerelease and @build in a thoroughly tested and optimized
-      # way. Using interpolations and/or array joins may look simpler but will slows
-      # things down. Don't change this code without measuring performance of new
-      # solution.
-      unless @prerelease.nil?
-        s << '-' << @prerelease[0].to_s
-        i = 0
-        l = @prerelease.length
-        while (i += 1) < l
-          s << '.' << @prerelease[i].to_s
-        end
-      end
-      unless @build.nil?
-        s << '+' << @build[0].to_s
-        i = 0
-        l = @build.length
-        while (i += 1) < l
-          s << '.' << @build[i].to_s
-        end
-      end
-      s
-    end
-    alias inspect to_s
-
-    def hash
-      (((((@major * 0x100) ^ @minor) * 0x100) ^ @patch) * 0x100) ^ @prerelease.hash
-    end
-
-    def compare_prerelease(other)
-      mine = @prerelease
-
-      # Need to use the instance variable here to avoid getting a string
-      yours = other.instance_variable_get(:@prerelease)
-
-      # A version that has a prerelease is always less than a version that doesn't
-      if mine.nil?
-        yours.nil? ? 0 : 1
-      elsif yours.nil?
-        -1
-      else
-        # Compare all prerelease identifier segments that can be compared. Should
-        # all segments compare equal up to the point where one of the prereleases
-        # have no more segments, then the one with more segements is greater.
-        your_max = yours.size
-        mine.each_with_index do |x, idx|
-          # 'mine' win if 'your' list of segments is exhausted
-          return 1 if idx >= your_max
-          y = yours[idx]
-
-          # Integer always wins over String
-          cmp = if x.is_a?(Integer)
-            y.is_a?(Integer) ? x <=> y : -1
-          elsif y.is_a?(Integer)
-            1
-          else
-            x <=> y
-          end
-
-          # No need to continue if a diff is found
-          return cmp unless cmp == 0
-        end
-
-        # All segments, up to the point where at least one list of segement is exhausted,
-        # compared equal. The one with the highest segment count wins.
-        mine.size <=> your_max
-      end
-    end
-
-    # Version string matching regexes
-    REGEX_NUMERIC = '(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)'.freeze # Major . Minor . Patch
-    REGEX_PRE     = '(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?'.freeze    # Prerelease
-    REGEX_BUILD   = '(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?'.freeze  # Build
-    REGEX_FULL    = REGEX_NUMERIC + REGEX_PRE + REGEX_BUILD.freeze
-    REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/.freeze
-
-    # The lowest precedence Version possible
-    MIN = self.new(0, 0, 0, [].freeze).freeze
-
-    # The highest precedence Version possible
-    MAX = self.new(Float::INFINITY, 0, 0).freeze
-  end
-end