Class: Dependabot::RustToolchain::Requirement

Inherits:
Dependabot::Requirement
  • Object
show all
Defined in:
lib/dependabot/rust_toolchain/requirement.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*requirements) ⇒ Requirement

Returns a new instance of Requirement.



63
64
65
66
67
68
69
 
# File 'lib/dependabot/rust_toolchain/requirement.rb', line 63

def initialize(*requirements)
  requirements = requirements.flatten.flat_map do |req_string|
    req_string&.split(",")&.map(&:strip)
  end.compact

  super(requirements)
end

Class Method Details

.parse(obj) ⇒ Object

Raises:

  • (BadRequirementError) 


25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/dependabot/rust_toolchain/requirement.rb', line 25

def self.parse(obj)
  return ["=", RustToolchain::Version.new(obj.to_s)] if obj.is_a?(Gem::Version)

  requirement_string = obj.to_s.strip

  # Parse requirement strings with operators (e.g., ">= 1.72.0")
  match = requirement_string.match(/^(>=|>|<=|<|=)\s?(.+)$/)
  if match
    operator = T.must(match[1])
    version_string = T.must(match[2]).strip

    # Special case: handle ">= 0" which is used to represent "all versions"
    return [operator, RustToolchain::Version.new("0.0.0")] if version_string == "0"

    # Validate the version string
    if RustToolchain::Version.correct?(version_string)
      return [operator, RustToolchain::Version.new(version_string)]
    end
  end

  # Handle bare version strings (no operator)
  if requirement_string == "0"
    # Special case: handle bare "0" as "0.0.0"
    return ["=", RustToolchain::Version.new("0.0.0")]
  end

  if RustToolchain::Version.correct?(requirement_string)
    return ["=", RustToolchain::Version.new(requirement_string)]
  end

  # If it's not a valid Rust toolchain format, fall back to default
  msg = "Illformed requirement [#{obj.inspect}]"
  raise BadRequirementError, msg
end

.requirements_array(requirement_string) ⇒ Object 



18
19
20
 
# File 'lib/dependabot/rust_toolchain/requirement.rb', line 18

def self.requirements_array(requirement_string)
  [new(requirement_string)]
end

Instance Method Details

#satisfied_by?(version) ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/dependabot/rust_toolchain/requirement.rb', line 73

def satisfied_by?(version)
  version = RustToolchain::Version.new(version.to_s) unless version.is_a?(RustToolchain::Version)

  T.cast(requirements, T::Array[T::Array[T.untyped]]).all? do |req|
    op = T.cast(req[0], String)
    rv = T.cast(req[1], RustToolchain::Version)

    case op
    when "="
      satisfy_exact_requirement?(version, rv)
    when ">="
      satisfy_greater_than_or_equal_requirement?(version, rv)
    when ">"
      satisfy_greater_than_requirement?(version, rv)
    when "<="
      satisfy_less_than_or_equal_requirement?(version, rv)
    when "<"
      satisfy_less_than_requirement?(version, rv)
    else
      # Fall back to default behavior for other operators
      ops_method = T.let(OPS[op], T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean)))
      ops_method ||= T.cast(OPS["="], T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
      ops_method.call(version, rv)
    end
  end
end