semantic_puppet 0.1.3 → 1.0.3

data/.travis.yml

@@ -0,0 +1,28 @@
+---
+language: ruby
+
+cache: bundler
+
+before_install:
+  - bundle -v
+  - rm Gemfile.lock || true
+  - gem update --system
+  - gem update bundler
+  - gem --version
+  - bundle -v
+
+script: "bundle exec rspec --color --format documentation spec/unit"
+
+notifications:
+  email: false
+
+sudo: false
+
+rvm:
+  - "2.5.8"
+  - "2.6.6"
+  - "2.7.2"
+  - "jruby-19mode"
+
+jdk:
+  - openjdk8

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## 1.0.3 - 2021-01-12
+- List failed module install dependencies
+- Add Ruby 2.7 to Travis and AppVeyor
+
+## 1.0.2 - 2018-03-13
+- Removed i18n/gettext configuration and string externalization. After further consideration we have decided that
+  as a library, semantic_puppet should not be attempting to configure global localization state and the localization
+  of error messages etc. is the responsibility of the consuming application.
+- Added Appveyor CI configuration
+
+## 1.0.1 - 2017-07-01
+- Fix bug causing pre-release identifiers being considered invalid when they contained letters but started with a zero
+
+## 1.0.0 - 2017-04-05
+- Complete rewrite of the VersionRange to make it compatible with Node Semver
+- General speedup of Version (hash, <=>, and to_s in particular)
+
+## 0.1.4 - 2016-07-06
+### Changed
+- Externalized all user-facing strings using gettext libraries to support future localization.
+
 ## 0.1.3 - 2016-05-24
 ### Added
 - Typesafe implementation of ModuleRelease#eql? (and ModuleRelease#==). (PUP-6341)

data/CODEOWNERS

@@ -0,0 +1 @@
+* @puppetlabs/forge-team @puppetlabs/platform-core

data/README.md

@@ -12,10 +12,6 @@ Versions and Version Ranges and to query and resolve module dependencies.
 
 For sparse, but accurate documentation, please see the docs directory.
 
-Note that this is a 0 release version, and things can change. Expect that the
-version and version range code to stay relatively stable, but the module
-dependency code is expected to change.
-
 This library is used by a number of Puppet Labs projects, including
 [Puppet](https://github.com/puppetlabs/puppet) and
 [r10k](https://github.com/puppetlabs/r10k).
@@ -23,9 +19,8 @@ This library is used by a number of Puppet Labs projects, including
 Requirements
 ------------
 
-Semantic_puppet will work on several ruby versions, including 1.9.3, 2.0.0, and
-2.1.0. Ruby 1.8.7 is immediately deprecated as it is in
-[r10k](https://github.com/puppetlabs/r10k).
+Semantic_puppet will work on several ruby versions, including 1.9.3,
+2.0.0, 2.1.9 and 2.4.1. Please see the exact matrix in `.travis.yml`.
 
 No gem/library requirements.
 
@@ -48,17 +43,24 @@ install it out of a git repository:
 Usage
 -----
 
-SemanticPuppet is intended to be used as a library. 
+SemanticPuppet is intended to be used as a library.
 
-### Verison Range Operator Support
+### Version Range Operator Support
 
-SemanticPuppet will support the same version range operators as those used when
-publishing modules to [Puppet Forge](https://forge.puppetlabs.com) which is
-documented at 
-[Publishing Modules on the Puppet Forge](https://docs.puppetlabs.com/puppet/latest/reference/modules_publishing.html#dependencies-in-metadatajson).
+SemanticPuppet will support the same version range operators as those
+used when publishing modules to [Puppet
+Forge](https://forge.puppetlabs.com) which is documented at [Publishing
+Modules on the Puppet
+Forge](https://docs.puppetlabs.com/puppet/latest/reference/modules_publishing.html#dependencies-in-metadatajson).
 
 Contributors
 ------------
 
-Pieter van de Bruggen wrote the library originally, with additions by Alex
-Dreyer, Jesse Scott and Anderson Mills.
+Pieter van de Bruggen wrote the library originally. See
+[https://github.com/puppetlabs/semantic_puppet/graphs/contributors](https://github.com/puppetlabs/semantic_puppet/graphs/contributors)
+for a list of contributors.
+
+## Maintenance
+
+Tickets: File at
+[https://tickets.puppet.com/browse/FORGE](https://tickets.puppet.com/browse/FORGE)

data/appveyor.yml

@@ -0,0 +1,19 @@
+version: 1.0.1.{build}
+clone_depth: 10
+image: Visual Studio 2019
+environment:
+  matrix:
+    - RUBY_VERSION: 25-x64
+    - RUBY_VERSION: 26-x64
+    - RUBY_VERSION: 27-x64
+matrix:
+  fast_finish: true
+install:
+  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
+  - bundle install --jobs 4 --retry 2
+build: off
+test_script:
+  - ruby -v
+  - gem -v
+  - bundle -v
+  - bundle exec rspec --format documentation --color spec/unit

data/lib/semantic_puppet.rb

@@ -2,6 +2,4 @@ module SemanticPuppet
   autoload :Version, 'semantic_puppet/version'
   autoload :VersionRange, 'semantic_puppet/version_range'
   autoload :Dependency, 'semantic_puppet/dependency'
-
-  VERSION = '0.1.3'
 end

data/lib/semantic_puppet/dependency.rb

@@ -37,6 +37,15 @@ module SemanticPuppet
 
     # @!endgroup
 
+    # Returns the unsatisfiable dependency, if any.
+    # @return String
+    def unsatisfiable
+      @module_dependencies ||= []
+      @satisfieds ||= []
+
+      (@module_dependencies - @satisfieds).first
+    end
+
     # Fetches a graph of modules and their dependencies from the currently
     # configured list of {Source}s.
     #
@@ -64,10 +73,12 @@ module SemanticPuppet
     # @param graph [Graph] the root of a dependency graph
     # @return [Array<ModuleRelease>] the list of releases to act on
     def resolve(graph)
+      @module_dependencies, @satisfieds = nil
+
       catch :next do
         return walk(graph, graph.dependencies.dup)
       end
-      raise UnsatisfiableGraph.new(graph)
+      raise UnsatisfiableGraph.new(graph, unsatisfiable)
     end
 
     # Fetches all available releases for the given module name.
@@ -100,6 +111,9 @@ module SemanticPuppet
     # @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)
+      @satisfieds ||= []
+      @module_dependencies ||= []
+
       return considering if dependencies.empty?
 
       # Selecting a dependency from the collection...
@@ -113,6 +127,7 @@ module SemanticPuppet
 
       # ... we'll iterate through the list of possible versions in order.
       preferred_releases(deps).reverse_each do |dep|
+        @module_dependencies |= [name]
 
         # We should skip any releases that violate any module's constraints.
         unless [graph, *considering].all? { |x| x.satisfies_constraints?(dep) }
@@ -125,6 +140,8 @@ module SemanticPuppet
           next
         end
 
+        @satisfieds |= [name]
+
         catch :next do
           # After adding any new dependencies and imposing our own constraints
           # on existing dependencies, we'll mark ourselves as "under

data/lib/semantic_puppet/dependency/unsatisfiable_graph.rb

@@ -3,13 +3,19 @@ require 'semantic_puppet/dependency'
 module SemanticPuppet
   module Dependency
     class UnsatisfiableGraph < StandardError
-      attr_reader :graph
+      attr_reader :graph, :unsatisfied
 
-      def initialize(graph)
+      def initialize(graph, unsatisfied = nil)
         @graph = graph
 
         deps = sentence_from_list(graph.modules)
-        super "Could not find satisfying releases for #{deps}"
+
+        if unsatisfied
+          @unsatisfied = unsatisfied
+          super "Could not find satisfying releases of #{unsatisfied} for #{deps}"
+        else
+          super "Could not find satisfying releases for #{deps}"
+        end
       end
 
       private

data/lib/semantic_puppet/gem_version.rb

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

data/lib/semantic_puppet/version.rb

@@ -1,7 +1,6 @@
 require 'semantic_puppet'
 
 module SemanticPuppet
-
   # @note SemanticPuppet::Version subclasses Numeric so that it has sane Range
   #       semantics in Ruby 1.9+.
   class Version < Numeric
@@ -9,69 +8,46 @@ module SemanticPuppet
 
     class ValidationFailure < ArgumentError; end
 
-    class << self
-      # 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(/\A#{REGEX_FULL}\Z/)
-
-        if match.nil?
-          raise "Unable to parse '#{ver}' as a semantic version identifier"
-        end
-
-        prerelease = parse_prerelease(prerelease) if prerelease
-        # Build metadata is not yet supported in semantic_puppet, but we hope to.
-        # The following code prevents build metadata for now.
-        #build = parse_build_metadata(build) if build
-        if !build.nil?
-          raise "'#{ver}' MUST NOT include build identifiers"
-        end
-
-        self.new(major.to_i, minor.to_i, patch.to_i, prerelease, build)
-      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)
 
-      # 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 valid?(ver)
-        !!(ver =~ /\A#{REGEX_FULL}\Z/)
-      end
+      raise ValidationFailure, "Unable to parse '#{ver}' as a semantic version identifier" unless match
 
-      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
+      new(major.to_i, minor.to_i, patch.to_i, parse_prerelease(prerelease), parse_build(build)).freeze
+    end
 
-        return prerelease.map { |x| x =~ /^\d+$/ ? x.to_i : x }
+    # 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 parse_build_metadata(build)
-        subject = 'Build identifiers'
-        build = build.split('.', -1)
+    def self.parse_build(build)
+      build.nil? ? nil : build.split('.').freeze
+    end
 
-        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"
+    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
-
-        return build
-      end
-
-      def raise(msg)
-        super ValidationFailure, msg, caller.drop_while { |x| x !~ /\bparse\b/ }
-      end
+      end.freeze
     end
 
     attr_reader :major, :minor, :patch
@@ -95,24 +71,39 @@ module SemanticPuppet
       end
     end
 
+    # @return [String] the `prerelease` identifier as a string without the leading '-'
     def prerelease
-      @prerelease && @prerelease.join('.')
+      (@prerelease.nil? || @prerelease.empty?) ? nil : @prerelease.join('.')
     end
 
     # @return [Boolean] true if this is a stable release
     def stable?
-      @prerelease.nil?
+      @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 && @build.join('.')
+      (@build.nil? || @build.empty?) ? nil : @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)
+      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)
@@ -126,70 +117,87 @@ module SemanticPuppet
     alias == eql?
 
     def to_s
-      "#{major}.#{minor}.#{patch}" +
-      (@prerelease.nil? || prerelease.empty? ? '' : "-" + prerelease) +
-      (@build.nil?      || build.empty?      ? '' : "+" + build     )
+      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
-      self.to_s.hash
+      (((((@major * 0x100) ^ @minor) * 0x100) ^ @patch) * 0x100) ^ @prerelease.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
+      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
-      end
 
-      return 0
-    end
-
-    def first_prerelease
-      self.class.new(@major, @minor, @patch, [])
+        # 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
 
-    public
-
     # Version string matching regexes
-    REGEX_NUMERIC = "(0|[1-9]\\d*)[.](0|[1-9]\\d*)[.](0|[1-9]\\d*)" # Major . Minor . Patch
-    REGEX_PRE     = "(?:[-](.*?))?"            # Prerelease
-    REGEX_BUILD   = "(?:[+](.*?))?"            # Build
-    REGEX_FULL    = REGEX_NUMERIC + REGEX_PRE + REGEX_BUILD
+    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
+    MIN = self.new(0, 0, 0, [].freeze).freeze
 
     # The highest precedence Version possible
-    MAX = self.new((1.0/0.0), 0, 0).freeze
+    MAX = self.new(Float::INFINITY, 0, 0).freeze
   end
 end