class Bundler::PubGrub::VersionRange - bundler: Ruby Standard Library Documentation

# class Bundler::PubGrub::VersionRange

### Constants

EMPTY

### Attributes

include_max[R]
include_max?[R]
include_min[R]
include_min?[R]
max[R]
min[R]

### Public Class Methods

any() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 74
    def self.any
      new
    end

empty() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 70
    def self.empty
      EMPTY
    end

new(min: nil, max: nil, include_min: false, include_max: false, name: nil) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 78
    def initialize(min: nil, max: nil, include_min: false, include_max: false, name: nil)
      @min = min
      @max = max
      @include_min = include_min
      @include_max = include_max
      @name = name
    end

### Public Instance Methods

==(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 390
    def ==(other)
      self.class == other.class &&
        min == other.min &&
        max == other.max &&
        include_min == other.include_min &&
        include_max == other.include_max
    end

allows_all?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 320
    def allows_all?(other)
      return true if other.empty?

      if other.is_a?(VersionUnion)
        return VersionUnion.new([self]).allows_all?(other)
      end

      return false if max && !other.max
      return false if min && !other.min

      if min
        case min <=> other.min
        when -1
        when 0
          return false if !include_min && other.include_min
        when 1
          return false
        end
      end

      if max
        case max <=> other.max
        when -1
          return false
        when 0
          return false if !include_max && other.include_max
        when 1
        end
      end

      true
    end

allows_any?(other)
Alias for: intersects?
any?() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 353
    def any?
      !min && !max
    end

compare_version(version) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 151
    def compare_version(version)
      if min
        case version <=> min
        when -1
          return -1
        when 0
          return -1 if !include_min
        when 1
        end
      end

      if max
        case version <=> max
        when -1
        when 0
          return 1 if !include_max
        when 1
          return 1
        end
      end

      0
    end

contiguous_to?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 312
    def contiguous_to?(other)
      return false if other.empty?

      intersects?(other) ||
        (min == other.max && (include_min || other.include_max)) ||
        (max == other.min && (include_max || other.include_min))
    end

empty?() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 357
    def empty?
      false
    end

eql?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 90
    def eql?(other)
      if other.is_a?(VersionRange)
        !other.empty? &&
          min.eql?(other.min) &&
          max.eql?(other.max) &&
          include_min.eql?(other.include_min) &&
          include_max.eql?(other.include_max)
      else
        ranges.eql?(other.ranges)
      end
    end

hash() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 86
    def hash
      @hash ||= min.hash ^ max.hash ^ include_min.hash ^ include_max.hash
    end

include?(version) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 106
    def include?(version)
      compare_version(version) == 0
    end

inspect() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 365
    def inspect
      "#<#{self.class} #{to_s}>"
    end

intersect(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 199
    def intersect(other)
      return other if other.empty?
      return other.intersect(self) if other.is_a?(VersionUnion)

      min_range =
        if !min
          other
        elsif !other.min
          self
        else
          case min <=> other.min
          when 0
            include_min ? other : self
          when -1
            other
          when 1
            self
          end
        end

      max_range =
        if !max
          other
        elsif !other.max
          self
        else
          case max <=> other.max
          when 0
            include_max ? other : self
          when -1
            self
          when 1
            other
          end
        end

      if !min_range.equal?(max_range) && min_range.min && max_range.max
        case min_range.min <=> max_range.max
        when -1
        when 0
          if !min_range.include_min || !max_range.include_max
            return EMPTY
          end
        when 1
          return EMPTY
        end
      end

      VersionRange.new(
        min: min_range.min,
        include_min: min_range.include_min,
        max: max_range.max,
        include_max: max_range.include_max
      )
    end

intersects?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 192
    def intersects?(other)
      return false if other.empty?
      return other.intersects?(self) if other.is_a?(VersionUnion)
      !strictly_lower?(other) && !strictly_higher?(other)
    end

Also aliased as: allows_any?
invert() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 375
    def invert
      return self.class.empty if any?

      low = VersionRange.new(max: min, include_max: !include_min)
      high = VersionRange.new(min: max, include_min: !include_max)

      if !min
        high
      elsif !max
        low
      else
        low.union(high)
      end
    end

partition_versions(versions) click to toggle source

Partitions passed versions into [lower, within, higher]

versions must be sorted

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 113
    def partition_versions(versions)
      min_index =
        if !min || versions.empty?
          0
        elsif include_min?
          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] >= min }
        else
          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] > min }
        end

      lower = versions.slice(0, min_index)
      versions = versions.slice(min_index, versions.size)

      max_index =
        if !max || versions.empty?
          versions.size
        elsif include_max?
          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] > max }
        else
          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] >= max }
        end

      [
        lower,
        versions.slice(0, max_index),
        versions.slice(max_index, versions.size)
      ]
    end

ranges() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 102
    def ranges
      [self]
    end

select_versions(versions) click to toggle source

Returns versions which are included by this range.

versions must be sorted

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 145
    def select_versions(versions)
      return versions if any?

      partition_versions(versions)[1]
    end

span(other) click to toggle source

The span covered by two ranges

If self and other are contiguous, this builds a union of the two ranges. (if they aren’t you are probably calling the wrong method)

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 259
    def span(other)
      return self if other.empty?

      min_range =
        if !min
          self
        elsif !other.min
          other
        else
          case min <=> other.min
          when 0
            include_min ? self : other
          when -1
            self
          when 1
            other
          end
        end

      max_range =
        if !max
          self
        elsif !other.max
          other
        else
          case max <=> other.max
          when 0
            include_max ? self : other
          when -1
            other
          when 1
            self
          end
        end

      VersionRange.new(
        min: min_range.min,
        include_min: min_range.include_min,
        max: max_range.max,
        include_max: max_range.include_max
      )
    end

strictly_higher?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 188
    def strictly_higher?(other)
      other.strictly_lower?(self)
    end

strictly_lower?(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 175
    def strictly_lower?(other)
      return false if !max || !other.min

      case max <=> other.min
      when 0
        !include_max || !other.include_min
      when -1
        true
      when 1
        false
      end
    end

to_s() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 361
    def to_s
      @name ||= constraints.join(", ")
    end

union(other) click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 302
    def union(other)
      return other.union(self) if other.is_a?(VersionUnion)

      if contiguous_to?(other)
        span(other)
      else
        VersionUnion.union([self, other])
      end
    end

upper_invert() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 369
    def upper_invert
      return self.class.empty unless max

      VersionRange.new(min: max, include_min: !include_max)
    end

### Private Instance Methods

constraints() click to toggle source

    # File bundler/vendor/pub_grub/lib/pub_grub/version_range.rb, line 400
    def constraints
      return ["any"] if any?
      return ["= #{min}"] if min.to_s == max.to_s

      c = []
      c << "#{include_min ? ">=" : ">"} #{min}" if min
      c << "#{include_max ? "<=" : "<"} #{max}" if max
      c
    end