Class: Udb::RequirementSpec

Inherits:

Object

• Object
• Udb::RequirementSpec

Extended by:

T::Sig

Defined in:

lib/udb/version_spec.rb

Overview

Represents a version requirement

A requirement is either a logical comparison (>, >=, <, <=, =, !=) or a compatible operator (~>).

Examples:

Logical requirement

# When the requirement is a logical comparison, the extension parameter is not needed
RequirementSpec.new(">= 0.5").satisfied_by?(VersionSpec.new("1.0"), nil) #=> true
RequirementSpec.new(">= 0.5").satisfied_by?(VersionSpec.new("0.4"), nil) #=> false

Compatible requirement

s_ext = cfg_arch.extension(...) # S extension, which is breaking between 1.11 -> 1.12
RequirementSpec.new("~> 1.11").satisfied_by?(VersionSpec.new("1.10"), s_ext) #=> true
RequirementSpec.new("~> 1.11").satisfied_by?(VersionSpec.new("1.11"), s_ext) #=> true
RequirementSpec.new("~> 1.11").satisfied_by?(VersionSpec.new("1.12"), s_ext) #=> false

Constant Summary

REQUIREMENT_OP_REGEX =

/((?:>=)|(?:>)|(?:~>)|(?:<)|(?:<=)|(?:!=)|(?:=))/

REQUIREMENT_REGEX =

/#{REQUIREMENT_OP_REGEX}\s*(#{VersionSpec::VERSION_REGEX})/

Instance Attribute Summary

• #op ⇒ String readonly
• #version_spec ⇒ VersionSpec readonly

Instance Method Summary

• #eql?(other) ⇒ Boolean
• #hash ⇒ Integer
• #initialize(requirement) constructor
• #satisfied_by?(version, ext) ⇒ Boolean

  If the version satisfies the requirement.

• #to_s ⇒ String

Constructor Details

#initialize(requirement)

Parameters:

• requirement (String) —

  A requirement string

# File 'lib/udb/version_spec.rb', line 192

def initialize(requirement)
  if requirement =~ /^\s*#{REQUIREMENT_REGEX}\s*$/
    m = T.must(::Regexp.last_match)
    @op = T.must(m[1]).freeze
    @op_sym = @op.to_sym
    @op_sym.freeze
    @version_str = T.must(m[2]).freeze
    @version_spec = VersionSpec.new(@version_str).freeze
  else
    raise ArgumentError, "Bad requirement string '#{requirement}' #{REQUIREMENT_REGEX}"
  end
end

Instance Attribute Details

#op ⇒ String (readonly)

Returns:

• (String)

# File 'lib/udb/version_spec.rb', line 185

def op
  @op
end

#version_spec ⇒ VersionSpec (readonly)

Returns:

• (VersionSpec)

# File 'lib/udb/version_spec.rb', line 188

def version_spec
  @version_spec
end

Instance Method Details

#eql?(other) ⇒ Boolean

Parameters:

• other (T.untyped)

Returns:

• (Boolean)

# File 'lib/udb/version_spec.rb', line 206

def eql?(other)
  if other.is_a?(RequirementSpec)
    self.hash == other.hash
  else
    false
  end
end

#hash ⇒ Integer

Returns:

• (Integer)

# File 'lib/udb/version_spec.rb', line 215

def hash
  @hash ||= [@op_sym, @version_spec].hash.freeze
end

#satisfied_by?(version, ext) ⇒ Boolean

Returns if the version satisfies the requirement.

Parameters:

• version (VersionSpec) —

  A version spec

• ext (Hash) —

  Raw extension spec (from YAML)

• version (String, VersionSpec) —

  A version string

• ext (Extension, Hash{String => T.untyped}) —

  An extension, needed to evaluate the compatible (~>) operator

Returns:

• (Boolean) —

  if the version satisfies the requirement

# File 'lib/udb/version_spec.rb', line 252

def satisfied_by?(version, ext)
  v_spec =
    case version
    when String
      VersionSpec.new(version)
    when VersionSpec
      version
    else
      T.absurd(version)
    end

  result =
    case @op_sym
    when :>=
      v_spec >= @version_spec
    when :>
      v_spec > @version_spec
    when :<=
      v_spec <= @version_spec
    when :<
      v_spec < @version_spec
    when :"="
      v_spec == @version_spec
    when :"!="
      v_spec != @version_spec
    when :"~>"
      if ext.is_a?(Extension)
        matching_ver = ext.versions.find { |v| v.version_spec == v_spec }
        raise "Can't find version?" if matching_ver.nil?

        matching_ver.compatible?(ext.arch.extension_version(ext.name, v_spec.to_s))
      else
        versions = ext.fetch("versions")
        compatible_versions = []
        versions.each do |vinfo|
          vspec = VersionSpec.new(vinfo.fetch("version"))
          compatible_versions << vspec if vspec >= v_spec
          break if compatible_versions.size.positive? && vinfo.key?("breaking")
        end

        compatible_versions.include?(v_spec)
      end
    when :"!~>" # not a legal spec, but used for inversion
      if ext.is_a?(Extension)
        matching_ver = ext.versions.find { |v| v.version_spec == v_spec }
        raise "Can't find version?" if matching_ver.nil?

        !matching_ver.compatible?(ext.arch.extension_version(ext.name, v_spec.to_s))
      else
        versions = ext.fetch("versions")
        compatible_versions = []
        versions.each do |vinfo|
          vspec = VersionSpec.new(vinfo.fetch("version"))
          compatible_versions << vspec if vspec >= v_spec
          break if compatible_versions.size.positive? && vinfo.key?("breaking")
        end

        !compatible_versions.include?(v_spec)
      end
    end

  T.must(result)
end

#to_s ⇒ String

Returns:

• (String)

# File 'lib/udb/version_spec.rb', line 220

def to_s
  "#{@op} #{@version_str}"
end