bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,31 @@
+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/vendored/puppet/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/gem_version.rb

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

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

@@ -0,0 +1,203 @@
+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 segments 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 segment 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

data/vendored/puppet/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/version_range.rb

@@ -0,0 +1,758 @@
+require 'semantic_puppet'
+
+module SemanticPuppet
+  # A Semantic Version Range.
+  #
+  # @see https://github.com/npm/node-semver for full specification
+  # @api public
+  class VersionRange
+    UPPER_X = 'X'.freeze
+    LOWER_X = 'x'.freeze
+    STAR = '*'.freeze
+
+    NR = '0|[1-9][0-9]*'.freeze
+    XR = '(x|X|\*|' + NR + ')'.freeze
+    XR_NC = '(?:x|X|\*|' + NR + ')'.freeze
+
+    PART = '(?:[0-9A-Za-z-]+)'.freeze
+    PARTS = PART + '(?:\.' + PART + ')*'.freeze
+    QUALIFIER = '(?:-(' + PARTS + '))?(?:\+(' + PARTS + '))?'.freeze
+    QUALIFIER_NC = '(?:-' + PARTS + ')?(?:\+' + PARTS + ')?'.freeze
+
+    PARTIAL = XR_NC + '(?:\.' + XR_NC + '(?:\.' + XR_NC + QUALIFIER_NC + ')?)?'.freeze
+
+    # The ~> isn't in the spec but allowed
+    SIMPLE = '([<>=~^]|<=|>=|~>|~=)?(' + PARTIAL + ')'.freeze
+    SIMPLE_EXPR = /\A#{SIMPLE}\z/.freeze
+
+    SIMPLE_WITH_EXTRA_WS = '([<>=~^]|<=|>=)?\s+(' + PARTIAL + ')'.freeze
+    SIMPLE_WITH_EXTRA_WS_EXPR = /\A#{SIMPLE_WITH_EXTRA_WS}\z/.freeze
+
+    HYPHEN = '(' + PARTIAL + ')\s+-\s+(' + PARTIAL + ')'.freeze
+    HYPHEN_EXPR = /\A#{HYPHEN}\z/.freeze
+
+    PARTIAL_EXPR = /\A#{XR}(?:\.#{XR}(?:\.#{XR}#{QUALIFIER})?)?\z/.freeze
+
+    LOGICAL_OR = /\s*\|\|\s*/.freeze
+    RANGE_SPLIT = /\s+/.freeze
+
+    # Parses a version range string into a comparable {VersionRange} instance.
+    #
+    # Currently parsed version range string may take any of the following:
+    # forms:
+    #
+    # * Regular Semantic Version strings
+    #   * ex. `"1.0.0"`, `"1.2.3-pre"`
+    # * Partial Semantic Version strings
+    #   * ex. `"1.0.x"`, `"1"`, `"2.X"`, `"3.*"`,
+    # * Inequalities
+    #   * ex. `"> 1.0.0"`, `"<3.2.0"`, `">=4.0.0"`
+    # * Approximate Caret Versions
+    #   * ex. `"^1"`, `"^3.2"`, `"^4.1.0"`
+    # * Approximate Tilde Versions
+    #   * ex. `"~1.0.0"`, `"~ 3.2.0"`, `"~4.0.0"`
+    # * Inclusive Ranges
+    #   * ex. `"1.0.0 - 1.3.9"`
+    # * Range Intersections
+    #   * ex. `">1.0.0 <=2.3.0"`
+    # * Combined ranges
+    #   * ex, `">=1.0.0 <2.3.0 || >=2.5.0 <3.0.0"`
+    #
+    # @param range_string [String] the version range string to parse
+    # @param strict_semver [Boolean] `false` if pre-releases should be included even when not explicitly appointed
+    # @return [VersionRange] a new {VersionRange} instance
+    # @api public
+    def self.parse(range_string, strict_semver = true)
+      # Remove extra whitespace after operators. Such whitespace should not cause a split
+      range_set = range_string.gsub(/([><=~^])(?:\s+|\s*v)/, '\1')
+      ranges = range_set.split(LOGICAL_OR)
+      return ALL_RANGE if ranges.empty?
+
+      new(ranges.map do |range|
+        if range =~ HYPHEN_EXPR
+          MinMaxRange.create(GtEqRange.new(parse_version($1)), LtEqRange.new(parse_version($2)))
+        else
+          # Split on whitespace
+          simples = range.split(RANGE_SPLIT).map do |simple|
+            match_data = SIMPLE_EXPR.match(simple)
+            raise ArgumentError, _("Unparsable version range: \"%{range}\"") % { range: range_string } unless match_data
+            operand = match_data[2]
+
+            # Case based on operator
+            case match_data[1]
+            when '~', '~>', '~='
+              parse_tilde(operand)
+            when '^'
+              parse_caret(operand)
+            when '>'
+              parse_gt_version(operand)
+            when '>='
+              GtEqRange.new(parse_version(operand))
+            when '<'
+              LtRange.new(parse_version(operand))
+            when '<='
+              parse_lteq_version(operand)
+            when '='
+              parse_xrange(operand)
+            else
+              parse_xrange(operand)
+            end
+          end
+          simples.size == 1 ? simples[0] : MinMaxRange.create(*simples)
+        end
+      end.uniq, range_string, strict_semver).freeze
+    end
+
+    def self.parse_partial(expr)
+      match_data = PARTIAL_EXPR.match(expr)
+      raise ArgumentError, _("Unparsable version range: \"%{expr}\"") % { expr: expr } unless match_data
+      match_data
+    end
+    private_class_method :parse_partial
+
+    def self.parse_caret(expr)
+      match_data = parse_partial(expr)
+      major = digit(match_data[1])
+      major == 0 ? allow_patch_updates(major, match_data) : allow_minor_updates(major, match_data)
+    end
+    private_class_method :parse_caret
+
+    def self.parse_tilde(expr)
+      match_data = parse_partial(expr)
+      allow_patch_updates(digit(match_data[1]), match_data)
+    end
+    private_class_method :parse_tilde
+
+    def self.parse_xrange(expr)
+      match_data = parse_partial(expr)
+      allow_patch_updates(digit(match_data[1]), match_data, false)
+    end
+    private_class_method :parse_xrange
+
+    def self.allow_patch_updates(major, match_data, tilde_or_caret = true)
+      return AllRange::SINGLETON unless major
+
+      minor = digit(match_data[2])
+      return MinMaxRange.new(GtEqRange.new(Version.new(major, 0, 0)), LtRange.new(Version.new(major + 1, 0, 0))) unless minor
+
+      patch = digit(match_data[3])
+      return MinMaxRange.new(GtEqRange.new(Version.new(major, minor, 0)), LtRange.new(Version.new(major, minor + 1, 0))) unless patch
+
+      version = Version.new(major, minor, patch, Version.parse_prerelease(match_data[4]), Version.parse_build(match_data[5]))
+      return EqRange.new(version) unless tilde_or_caret
+
+      MinMaxRange.new(GtEqRange.new(version), LtRange.new(Version.new(major, minor + 1, 0)))
+    end
+    private_class_method :allow_patch_updates
+
+    def self.allow_minor_updates(major, match_data)
+      return AllRange.SINGLETON unless major
+      minor = digit(match_data[2])
+      if minor
+        patch = digit(match_data[3])
+        if patch.nil?
+          MinMaxRange.new(GtEqRange.new(Version.new(major, minor, 0)), LtRange.new(Version.new(major + 1, 0, 0)))
+        else
+          if match_data[4].nil?
+            MinMaxRange.new(GtEqRange.new(Version.new(major, minor, patch)), LtRange.new(Version.new(major + 1, 0, 0)))
+          else
+            MinMaxRange.new(
+              GtEqRange.new(
+                Version.new(major, minor, patch, Version.parse_prerelease(match_data[4]), Version.parse_build(match_data[5]))),
+              LtRange.new(Version.new(major + 1, 0, 0)))
+          end
+        end
+      else
+        MinMaxRange.new(GtEqRange.new(Version.new(major, 0, 0)), LtRange.new(Version.new(major + 1, 0, 0)))
+      end
+    end
+    private_class_method :allow_minor_updates
+
+    def self.digit(str)
+      (str.nil? || UPPER_X == str || LOWER_X == str || STAR == str) ? nil : str.to_i
+    end
+    private_class_method :digit
+
+    def self.parse_version(expr)
+      match_data = parse_partial(expr)
+      major = digit(match_data[1]) || 0
+      minor = digit(match_data[2]) || 0
+      patch = digit(match_data[3]) || 0
+      Version.new(major, minor, patch, Version.parse_prerelease(match_data[4]), Version.parse_build(match_data[5]))
+    end
+    private_class_method :parse_version
+
+    def self.parse_gt_version(expr)
+      match_data = parse_partial(expr)
+      major = digit(match_data[1])
+      return LtRange::MATCH_NOTHING unless major
+      minor = digit(match_data[2])
+      return GtEqRange.new(Version.new(major + 1, 0, 0)) unless minor
+      patch = digit(match_data[3])
+      return GtEqRange.new(Version.new(major, minor + 1, 0)) unless patch
+      return GtRange.new(Version.new(major, minor, patch, Version.parse_prerelease(match_data[4]), Version.parse_build(match_data[5])))
+    end
+    private_class_method :parse_gt_version
+
+    def self.parse_lteq_version(expr)
+      match_data = parse_partial(expr)
+      major = digit(match_data[1])
+      return AllRange.SINGLETON unless major
+      minor = digit(match_data[2])
+      return LtRange.new(Version.new(major + 1, 0, 0)) unless minor
+      patch = digit(match_data[3])
+      return LtRange.new(Version.new(major, minor + 1, 0)) unless patch
+      return LtEqRange.new(Version.new(major, minor, patch, Version.parse_prerelease(match_data[4]), Version.parse_build(match_data[5])))
+    end
+    private_class_method :parse_lteq_version
+
+    # Provides read access to the ranges. For internal use only
+    # @api private
+    attr_reader :ranges
+
+    # Creates a new version range
+    # @overload initialize(from, to, exclude_end = false)
+    #   Creates a new instance using ruby `Range` semantics
+    #   @param begin [String,Version] the version denoting the start of the range (always inclusive)
+    #   @param end [String,Version] the version denoting the end of the range
+    #   @param exclude_end [Boolean] `true` if the `end` version should be excluded from the range
+    # @overload initialize(ranges, string)
+    #   Creates a new instance based on parsed content. For internal use only
+    #   @param ranges [Array<AbstractRange>] the ranges to include in this range
+    #   @param string [String] the original string representation that was parsed to produce the ranges
+    #   @param strict_semver [Boolean] `false` if pre-releases should be included even when not explicitly appointed
+    #
+    # @api private
+    def initialize(ranges, string, exclude_end = nil)
+      if ranges.is_a?(Array)
+        @strict_semver = exclude_end.nil? ? true : exclude_end
+      else
+        lb = GtEqRange.new(ranges)
+        if exclude_end
+          ub = LtRange.new(string)
+          string = ">=#{string} <#{ranges}"
+        else
+          ub = LtEqRange.new(string)
+          string = "#{string} - #{ranges}"
+        end
+        ranges = [MinMaxRange.create(lb, ub)]
+        @strict_semver = true
+      end
+      ranges.compact!
+
+      merge_happened = true
+      while ranges.size > 1 && merge_happened
+        # merge ranges if possible
+        merge_happened = false
+        result = []
+        until ranges.empty?
+          unmerged = []
+          x = ranges.pop
+          result << ranges.reduce(x) do |memo, y|
+            merged = memo.merge(y)
+            if merged.nil?
+              unmerged << y
+            else
+              merge_happened = true
+              memo = merged
+            end
+            memo
+          end
+          ranges = unmerged
+        end
+        ranges = result.reverse!
+      end
+
+      ranges = [LtRange::MATCH_NOTHING] if ranges.empty?
+      @ranges = ranges
+      @string = string.nil? ? ranges.join(' || ') : string
+    end
+
+    def eql?(range)
+      range.is_a?(VersionRange) && @ranges.eql?(range.ranges)
+    end
+    alias == eql?
+
+    def hash
+      @ranges.hash
+    end
+
+    # Returns the version that denotes the beginning of this range.
+    #
+    # Since this really is an OR between disparate ranges, it may have multiple beginnings. This method
+    # returns `nil` if that is the case.
+    #
+    # @return [Version] the beginning of the range, or `nil` if there are multiple beginnings
+    # @api public
+    def begin
+      @ranges.size == 1 ? @ranges[0].begin : nil
+    end
+
+    # Returns the version that denotes the end of this range.
+    #
+    # Since this really is an OR between disparate ranges, it may have multiple ends. This method
+    # returns `nil` if that is the case.
+    #
+    # @return [Version] the end of the range, or `nil` if there are multiple ends
+    # @api public
+    def end
+      @ranges.size == 1 ? @ranges[0].end : nil
+    end
+
+    # Returns `true` if the beginning is excluded from the range.
+    #
+    # Since this really is an OR between disparate ranges, it may have multiple beginnings. This method
+    # returns `nil` if that is the case.
+    #
+    # @return [Boolean] `true` if the beginning is excluded from the range, `false` if included, or `nil` if there are multiple beginnings
+    # @api public
+    def exclude_begin?
+      @ranges.size == 1 ? @ranges[0].exclude_begin? : nil
+    end
+
+    # Returns `true` if the end is excluded from the range.
+    #
+    # Since this really is an OR between disparate ranges, it may have multiple ends. This method
+    # returns `nil` if that is the case.
+    #
+    # @return [Boolean] `true` if the end is excluded from the range, `false` if not, or `nil` if there are multiple ends
+    # @api public
+    def exclude_end?
+      @ranges.size == 1 ? @ranges[0].exclude_end? : nil
+    end
+
+    # @return [Boolean] `true` if the given version is included in the range
+    # @api public
+    def include?(version)
+      if @strict_semver
+        @ranges.any? { |range| range.include?(version) && (version.stable? || range.test_prerelease?(version)) }
+      else
+        @ranges.any? { |range| range.include?(version) || !version.stable? && range.stable? &&  range.include?(version.to_stable) }
+      end
+    end
+    alias member? include?
+    alias cover? include?
+    alias === include?
+
+    # Computes the intersection of a pair of ranges. If the ranges have no
+    # useful intersection, an empty range is returned.
+    #
+    # @param other [VersionRange] the range to intersect with
+    # @return [VersionRange] the common subset
+    # @api public
+    def intersection(other)
+      raise ArgumentError, _("value must be a %{type}") % { :type => self.class.name } unless other.is_a?(VersionRange)
+      result = @ranges.map { |range| other.ranges.map { |o_range| range.intersection(o_range) } }.flatten
+      result.compact!
+      result.uniq!
+      result.empty? ? EMPTY_RANGE : VersionRange.new(result, nil)
+    end
+    alias :& :intersection
+
+    # Returns a string representation of this range. This will be the string that was used
+    # when the range was parsed.
+    #
+    # @return [String] a range expression representing this VersionRange
+    # @api public
+    def to_s
+      @string
+    end
+
+    # Returns a canonical string representation of this range, assembled from the internal
+    # matchers.
+    #
+    # @return [String] a range expression representing this VersionRange
+    # @api public
+    def inspect
+      @ranges.join(' || ')
+    end
+
+    # @api private
+    class AbstractRange
+      def include?(_)
+        true
+      end
+
+      def begin
+        Version::MIN
+      end
+
+      def end
+        Version::MAX
+      end
+
+      def exclude_begin?
+        false
+      end
+
+      def exclude_end?
+        false
+      end
+
+      def eql?(other)
+        other.class.eql?(self.class)
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def lower_bound?
+        false
+      end
+
+      def upper_bound?
+        false
+      end
+
+      # Merge two ranges so that the result matches the intersection of all matching versions.
+      #
+      # @param range [AbstractRange] the range to intersect with
+      # @return [AbstractRange,nil] the intersection between the ranges
+      #
+      # @api private
+      def intersection(range)
+        cmp = self.begin <=> range.end
+        if cmp > 0
+          nil
+        elsif cmp == 0
+          exclude_begin? || range.exclude_end? ? nil : EqRange.new(self.begin)
+        else
+          cmp = range.begin <=> self.end
+          if cmp > 0
+            nil
+          elsif cmp == 0
+            range.exclude_begin? || exclude_end? ? nil : EqRange.new(range.begin)
+          else
+            cmp = self.begin <=> range.begin
+            min = if cmp < 0
+              range
+            elsif cmp > 0
+              self
+            else
+              self.exclude_begin? ? self : range
+            end
+
+            cmp = self.end <=> range.end
+            max = if cmp > 0
+              range
+            elsif cmp < 0
+              self
+            else
+              self.exclude_end? ? self : range
+            end
+
+            if !max.upper_bound?
+              min
+            elsif !min.lower_bound?
+              max
+            else
+              MinMaxRange.new(min, max)
+            end
+          end
+        end
+      end
+
+      # Merge two ranges so that the result matches the sum of all matching versions. A merge
+      # is only possible when the ranges are either adjacent or have an overlap.
+      #
+      # @param other [AbstractRange] the range to merge with
+      # @return [AbstractRange,nil] the result of the merge
+      #
+      # @api private
+      def merge(other)
+        if include?(other.begin) || other.include?(self.begin)
+          cmp = self.begin <=> other.begin
+          if cmp < 0
+            min = self.begin
+            excl_begin = exclude_begin?
+          elsif cmp > 0
+            min = other.begin
+            excl_begin = other.exclude_begin?
+          else
+            min = self.begin
+            excl_begin = exclude_begin? && other.exclude_begin?
+          end
+
+          cmp = self.end <=> other.end
+          if cmp > 0
+            max = self.end
+            excl_end = self.exclude_end?
+          elsif cmp < 0
+            max = other.end
+            excl_end = other.exclude_end?
+          else
+            max = self.end
+            excl_end = exclude_end && other.exclude_end?
+          end
+
+          MinMaxRange.create(excl_begin ? GtRange.new(min) : GtEqRange.new(min), excl_end ? LtRange.new(max) : LtEqRange.new(max))
+        elsif exclude_end? && !other.exclude_begin? && self.end == other.begin
+          # Adjacent, self before other
+          from_to(self, other)
+        elsif other.exclude_end? && !exclude_begin? && other.end == self.begin
+          # Adjacent, other before self
+          from_to(other, self)
+        elsif !exclude_end? && !other.exclude_begin? && self.end.next(:patch) == other.begin
+          # Adjacent, self before other
+          from_to(self, other)
+        elsif !other.exclude_end? && !exclude_begin? && other.end.next(:patch) == self.begin
+          # Adjacent, other before self
+          from_to(other, self)
+        else
+          # No overlap
+          nil
+        end
+      end
+
+      # Checks if this matcher accepts a prerelease with the same major, minor, patch triple as the given version. Only matchers
+      # where this has been explicitly stated will respond `true` to this method
+      #
+      # @return [Boolean] `true` if this matcher accepts a prerelease with the tuple from the given version
+      def test_prerelease?(_)
+        false
+      end
+
+      def stable?
+        false
+      end
+
+      private
+
+      def from_to(a, b)
+        MinMaxRange.create(a.exclude_begin? ? GtRange.new(a.begin) : GtEqRange.new(a.begin), b.exclude_end? ? LtRange.new(b.end) : LtEqRange.new(b.end))
+      end
+    end
+
+    # @api private
+    class AllRange < AbstractRange
+      SINGLETON = AllRange.new
+
+      def intersection(range)
+        range
+      end
+
+      def merge(range)
+        self
+      end
+
+      def test_prerelease?(_)
+        true
+      end
+
+      def stable?
+        true
+      end
+
+      def to_s
+        '*'
+      end
+    end
+
+    # @api private
+    class MinMaxRange < AbstractRange
+      attr_reader :min, :max
+
+      def self.create(*ranges)
+        ranges.reduce { |memo, range| memo.intersection(range) }
+      end
+
+      def initialize(min, max)
+        @min = min.is_a?(MinMaxRange) ? min.min : min
+        @max = max.is_a?(MinMaxRange) ? max.max : max
+      end
+
+      def begin
+        @min.begin
+      end
+
+      def end
+        @max.end
+      end
+
+      def exclude_begin?
+        @min.exclude_begin?
+      end
+
+      def exclude_end?
+        @max.exclude_end?
+      end
+
+      def eql?(other)
+        super && @min.eql?(other.min) && @max.eql?(other.max)
+      end
+
+      def hash
+        @min.hash ^ @max.hash
+      end
+
+      def include?(version)
+        @min.include?(version) && @max.include?(version)
+      end
+
+      def lower_bound?
+        @min.lower_bound?
+      end
+
+      def upper_bound?
+        @max.upper_bound?
+      end
+
+      def test_prerelease?(version)
+        @min.test_prerelease?(version) || @max.test_prerelease?(version)
+      end
+
+      def stable?
+        @min.stable? && @max.stable?
+      end
+
+      def to_s
+        "#{@min} #{@max}"
+      end
+      alias inspect to_s
+    end
+
+    # @api private
+    class ComparatorRange < AbstractRange
+      attr_reader :version
+
+      def initialize(version)
+        @version = version
+      end
+
+      def eql?(other)
+        super && @version.eql?(other.version)
+      end
+
+      def hash
+        @class.hash ^ @version.hash
+      end
+
+      # Checks if this matcher accepts a prerelease with the same major, minor, patch triple as the given version
+      def test_prerelease?(version)
+        !@version.stable? && @version.major == version.major && @version.minor == version.minor && @version.patch == version.patch
+      end
+
+      def stable?
+        @version.stable?
+      end
+    end
+
+    # @api private
+    class GtRange < ComparatorRange
+      def include?(version)
+        version > @version
+      end
+
+      def exclude_begin?
+        true
+      end
+
+      def begin
+        @version
+      end
+
+      def lower_bound?
+        true
+      end
+
+      def to_s
+        ">#{@version}"
+      end
+    end
+
+    # @api private
+    class GtEqRange < ComparatorRange
+      def include?(version)
+        version >= @version
+      end
+
+      def begin
+        @version
+      end
+
+      def lower_bound?
+        @version != Version::MIN
+      end
+
+      def to_s
+        ">=#{@version}"
+      end
+    end
+
+    # @api private
+    class LtRange < ComparatorRange
+      MATCH_NOTHING = LtRange.new(Version::MIN)
+
+      def include?(version)
+        version < @version
+      end
+
+      def exclude_end?
+        true
+      end
+
+      def end
+        @version
+      end
+
+      def upper_bound?
+        true
+      end
+
+      def to_s
+        self.equal?(MATCH_NOTHING) ? '<0.0.0' : "<#{@version}"
+      end
+    end
+
+    # @api private
+    class LtEqRange < ComparatorRange
+      def include?(version)
+        version <= @version
+      end
+
+      def end
+        @version
+      end
+
+      def upper_bound?
+        @version != Version::MAX
+      end
+
+      def to_s
+        "<=#{@version}"
+      end
+    end
+
+    # @api private
+    class EqRange < ComparatorRange
+      def include?(version)
+        version == @version
+      end
+
+      def begin
+        @version
+      end
+
+      def lower_bound?
+        @version != Version::MIN
+      end
+
+      def upper_bound?
+        @version != Version::MAX
+      end
+
+      def end
+        @version
+      end
+
+      def to_s
+        @version.to_s
+      end
+    end
+
+    # A range that matches no versions
+    EMPTY_RANGE = VersionRange.new([], nil).freeze
+    ALL_RANGE = VersionRange.new([AllRange::SINGLETON], '*')
+  end
+end