puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

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

@@ -0,0 +1,60 @@
+require 'semantic/dependency'
+
+module Semantic
+  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/lib/semantic/dependency/graph_node.rb

@@ -0,0 +1,117 @@
+require 'semantic/dependency'
+require 'set'
+
+module Semantic
+  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/lib/semantic/dependency/module_release.rb

@@ -0,0 +1,46 @@
+require 'semantic/dependency'
+
+module Semantic
+  module Dependency
+    class ModuleRelease
+      include GraphNode
+
+      attr_reader :name, :version
+
+      # Create a new instance of a module release.
+      #
+      # @param source [Semantic::Dependency::Source]
+      # @param name [String]
+      # @param version [Semantic::Version]
+      # @param dependencies [{String => Semantic::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 to_s
+        "#<#{self.class} #{name}@#{version}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'semantic/dependency'
+
+module Semantic
+  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')
+          hash[key] ||= VersionRange::EMPTY_RANGE
+          hash
+        end
+        ModuleRelease.new(self, name, version, dependencies)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'semantic/dependency'
+
+module Semantic
+  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/lib/semantic/version.rb

@@ -0,0 +1,168 @@
+require 'semantic'
+
+module Semantic
+
+  # @note Semantic::Version subclasses Numeric so that it has sane Range
+  #       semantics in Ruby 1.9+.
+  class Version < Numeric
+    include Comparable
+
+    class ValidationFailure < ArgumentError; end
+
+    class << self
+      LOOSE_REGEX = /
+        \A
+        (\d+)[.](\d+)[.](\d+) # Major . Minor . Patch
+        (?: [-](.*?))?        # Prerelease
+        (?: [+](.*?))?        # Build
+        \Z
+      /x
+
+      # Parse a Semantic Version string.
+      #
+      # @param ver [String] the version string to parse
+      # @return [Version] a comparable {Version} object
+      def parse(ver)
+        match, major, minor, patch, prerelease, build = *ver.match(LOOSE_REGEX)
+
+        if match.nil?
+          raise 'Version numbers MUST begin with three dot-separated numbers'
+        elsif [major, minor, patch].any? { |x| x =~ /^0\d+/ }
+          raise 'Version numbers MUST NOT contain leading zeroes'
+        end
+
+        prerelease = parse_prerelease(prerelease) if prerelease
+        build = parse_build_metadata(build) if build
+
+        self.new(major.to_i, minor.to_i, patch.to_i, prerelease, build)
+      end
+
+      private
+      def parse_prerelease(prerelease)
+        subject = 'Prerelease identifiers'
+        prerelease = prerelease.split('.', -1)
+
+        if prerelease.empty? or prerelease.any? { |x| x.empty? }
+          raise "#{subject} MUST NOT be empty"
+        elsif prerelease.any? { |x| x =~ /[^0-9a-zA-Z-]/ }
+          raise "#{subject} MUST use only ASCII alphanumerics and hyphens"
+        elsif prerelease.any? { |x| x =~ /^0\d+$/ }
+          raise "#{subject} MUST NOT contain leading zeroes"
+        end
+
+        return prerelease.map { |x| x =~ /^\d+$/ ? x.to_i : x }
+      end
+
+      def parse_build_metadata(build)
+        subject = 'Build identifiers'
+        build = build.split('.', -1)
+
+        if build.empty? or build.any? { |x| x.empty? }
+          raise "#{subject} MUST NOT be empty"
+        elsif build.any? { |x| x =~ /[^0-9a-zA-Z-]/ }
+          raise "#{subject} MUST use only ASCII alphanumerics and hyphens"
+        end
+
+        return build
+      end
+
+      def raise(msg)
+        super ValidationFailure, msg, caller.drop_while { |x| x !~ /\bparse\b/ }
+      end
+    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
+
+    def prerelease
+      @prerelease && @prerelease.join('.')
+    end
+
+    # @return [Boolean] true if this is a stable release
+    def stable?
+      @prerelease.nil?
+    end
+
+    def build
+      @build && @build.join('.')
+    end
+
+    def <=>(other)
+      return self.major <=> other.major unless self.major == other.major
+      return self.minor <=> other.minor unless self.minor == other.minor
+      return self.patch <=> other.patch unless self.patch == other.patch
+      return compare_prerelease(other)
+    end
+
+    def to_s
+      "#{major}.#{minor}.#{patch}" +
+      (@prerelease.nil? || prerelease.empty? ? '' : "-" + prerelease) +
+      (@build.nil?      || build.empty?      ? '' : "+" + build     )
+    end
+
+    def hash
+      self.to_s.hash
+    end
+
+    private
+    # This is a hack; tildes sort later than any valid identifier. The
+    # advantage is that we don't need to handle stable vs. prerelease
+    # comparisons separately.
+    @@STABLE_RELEASE = [ '~' ].freeze
+
+    def compare_prerelease(other)
+      all_mine  = @prerelease                               || @@STABLE_RELEASE
+      all_yours = other.instance_variable_get(:@prerelease) || @@STABLE_RELEASE
+
+      # Precedence is determined by comparing each dot separated identifier from
+      # left to right...
+      size = [ all_mine.size, all_yours.size ].max
+      Array.new(size).zip(all_mine, all_yours) do |_, mine, yours|
+
+        # ...until a difference is found.
+        next if mine == yours
+
+        # Numbers are compared numerically, strings are compared ASCIIbetically.
+        if mine.class == yours.class
+          return mine <=> yours
+
+        # A larger set of pre-release fields has a higher precedence.
+        elsif mine.nil?
+          return -1
+        elsif yours.nil?
+          return 1
+
+        # Numeric identifiers always have lower precedence than non-numeric.
+        elsif mine.is_a? Numeric
+          return -1
+        elsif yours.is_a? Numeric
+          return 1
+        end
+      end
+
+      return 0
+    end
+
+    def first_prerelease
+      self.class.new(@major, @minor, @patch, [])
+    end
+  end
+end