mirror of
https://github.com/astral-sh/uv.git
synced 2025-11-19 11:35:36 +00:00
ff4d079dc9
... we just remove the trailing whitespace from the input and that resolves things. Thanks @konstin for pointing this out! Ref https://github.com/astral-sh/puffin/pull/399#discussion_r1389854823
1459 lines
45 KiB
Rust
1459 lines
45 KiB
Rust
//! A library for python [dependency specifiers](https://packaging.python.org/en/latest/specifications/dependency-specifiers/)
|
|
//! better known as [PEP 508](https://peps.python.org/pep-0508/)
|
|
//!
|
|
//! ## Usage
|
|
//!
|
|
//! ```
|
|
//! use std::str::FromStr;
|
|
//! use pep508_rs::Requirement;
|
|
//! use puffin_normalize::ExtraName;
|
|
//!
|
|
//! let marker = r#"requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8""#;
|
|
//! let dependency_specification = Requirement::from_str(marker).unwrap();
|
|
//! assert_eq!(dependency_specification.name.as_ref(), "requests");
|
|
//! assert_eq!(dependency_specification.extras, Some(vec![ExtraName::from_str("security").unwrap(), ExtraName::from_str("tests").unwrap()]));
|
|
//! ```
|
|
|
|
#![deny(missing_docs)]
|
|
|
|
#[cfg(feature = "pyo3")]
|
|
use std::collections::hash_map::DefaultHasher;
|
|
use std::collections::HashSet;
|
|
use std::fmt::{Display, Formatter};
|
|
#[cfg(feature = "pyo3")]
|
|
use std::hash::{Hash, Hasher};
|
|
use std::str::{Chars, FromStr};
|
|
|
|
#[cfg(feature = "pyo3")]
|
|
use pep440_rs::PyVersion;
|
|
#[cfg(feature = "pyo3")]
|
|
use pyo3::{
|
|
create_exception, exceptions::PyNotImplementedError, pyclass, pyclass::CompareOp, pymethods,
|
|
pymodule, types::PyModule, IntoPy, PyObject, PyResult, Python,
|
|
};
|
|
#[cfg(feature = "serde")]
|
|
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
|
|
use thiserror::Error;
|
|
use unicode_width::UnicodeWidthStr;
|
|
use url::Url;
|
|
|
|
pub use marker::{
|
|
MarkerEnvironment, MarkerExpression, MarkerOperator, MarkerTree, MarkerValue,
|
|
MarkerValueString, MarkerValueVersion, MarkerWarningKind, StringVersion,
|
|
};
|
|
use pep440_rs::{Version, VersionSpecifier, VersionSpecifiers};
|
|
use puffin_normalize::{ExtraName, PackageName};
|
|
|
|
mod marker;
|
|
|
|
/// Error with a span attached. Not that those aren't `String` but `Vec<char>` indices.
|
|
#[derive(Debug, Clone, Eq, PartialEq)]
|
|
pub struct Pep508Error {
|
|
/// Either we have an error string from our parser or an upstream error from `url`
|
|
pub message: Pep508ErrorSource,
|
|
/// Span start index
|
|
pub start: usize,
|
|
/// Span length
|
|
pub len: usize,
|
|
/// The input string so we can print it underlined
|
|
pub input: String,
|
|
}
|
|
|
|
/// Either we have an error string from our parser or an upstream error from `url`
|
|
#[derive(Debug, Error, Clone, Eq, PartialEq)]
|
|
pub enum Pep508ErrorSource {
|
|
/// An error from our parser
|
|
#[error("{0}")]
|
|
String(String),
|
|
/// A url parsing error
|
|
#[error(transparent)]
|
|
UrlError(#[from] url::ParseError),
|
|
}
|
|
|
|
impl Display for Pep508Error {
|
|
/// Pretty formatting with underline
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
// We can use char indices here since it's a Vec<char>
|
|
let start_offset = self
|
|
.input
|
|
.chars()
|
|
.take(self.start)
|
|
.collect::<String>()
|
|
.width();
|
|
let underline_len = if self.start == self.input.len() {
|
|
// We also allow 0 here for convenience
|
|
assert!(
|
|
self.len <= 1,
|
|
"Can only go one past the input not {}",
|
|
self.len
|
|
);
|
|
1
|
|
} else {
|
|
self.input
|
|
.chars()
|
|
.skip(self.start)
|
|
.take(self.len)
|
|
.collect::<String>()
|
|
.width()
|
|
};
|
|
write!(
|
|
f,
|
|
"{}\n{}\n{}{}",
|
|
self.message,
|
|
self.input,
|
|
" ".repeat(start_offset),
|
|
"^".repeat(underline_len)
|
|
)
|
|
}
|
|
}
|
|
|
|
/// We need this to allow e.g. anyhow's `.context()`
|
|
impl std::error::Error for Pep508Error {}
|
|
|
|
#[cfg(feature = "pyo3")]
|
|
create_exception!(
|
|
pep508,
|
|
PyPep508Error,
|
|
pyo3::exceptions::PyValueError,
|
|
"A PEP 508 parser error with span information"
|
|
);
|
|
|
|
/// A PEP 508 dependency specification
|
|
#[derive(Hash, Debug, Clone, Eq, PartialEq)]
|
|
#[cfg_attr(feature = "pyo3", pyclass(module = "pep508"))]
|
|
pub struct Requirement {
|
|
/// The distribution name such as `numpy` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
pub name: PackageName,
|
|
/// The list of extras such as `security`, `tests` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
pub extras: Option<Vec<ExtraName>>,
|
|
/// The version specifier such as `>= 2.8.1`, `== 2.8.*` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
/// or a url
|
|
pub version_or_url: Option<VersionOrUrl>,
|
|
/// The markers such as `python_version > "3.8"` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`.
|
|
/// Those are a nested and/or tree
|
|
pub marker: Option<MarkerTree>,
|
|
}
|
|
|
|
impl Display for Requirement {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "{}", self.name)?;
|
|
if let Some(extras) = &self.extras {
|
|
write!(
|
|
f,
|
|
"[{}]",
|
|
extras
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<_>>()
|
|
.join(",")
|
|
)?;
|
|
}
|
|
if let Some(version_or_url) = &self.version_or_url {
|
|
match version_or_url {
|
|
VersionOrUrl::VersionSpecifier(version_specifier) => {
|
|
let version_specifier: Vec<String> =
|
|
version_specifier.iter().map(ToString::to_string).collect();
|
|
write!(f, " {}", version_specifier.join(", "))?;
|
|
}
|
|
VersionOrUrl::Url(url) => {
|
|
// We add the space for markers later if necessary
|
|
write!(f, " @ {url}")?;
|
|
}
|
|
}
|
|
}
|
|
if let Some(marker) = &self.marker {
|
|
write!(f, " ; {marker}")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// <https://github.com/serde-rs/serde/issues/908#issuecomment-298027413>
|
|
#[cfg(feature = "serde")]
|
|
impl<'de> Deserialize<'de> for Requirement {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
let s = String::deserialize(deserializer)?;
|
|
FromStr::from_str(&s).map_err(de::Error::custom)
|
|
}
|
|
}
|
|
|
|
/// <https://github.com/serde-rs/serde/issues/1316#issue-332908452>
|
|
#[cfg(feature = "serde")]
|
|
impl Serialize for Requirement {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
serializer.collect_str(self)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "pyo3")]
|
|
#[pymethods]
|
|
impl Requirement {
|
|
/// The distribution name such as `numpy` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
#[getter]
|
|
pub fn name(&self) -> String {
|
|
self.name.to_string()
|
|
}
|
|
|
|
/// The list of extras such as `security`, `tests` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
#[getter]
|
|
pub fn extras(&self) -> Option<Vec<String>> {
|
|
self.extras
|
|
.as_ref()
|
|
.map(|extras| extras.iter().map(ToString::to_string).collect())
|
|
}
|
|
|
|
/// The marker expression such as `python_version > "3.8"` in
|
|
/// `requests [security,tests] >= 2.8.1, == 2.8.* ; python_version > "3.8"`
|
|
#[getter]
|
|
pub fn marker(&self) -> Option<String> {
|
|
self.marker.as_ref().map(std::string::ToString::to_string)
|
|
}
|
|
|
|
/// Parses a PEP 440 string
|
|
#[new]
|
|
pub fn py_new(requirement: &str) -> PyResult<Self> {
|
|
Self::from_str(requirement).map_err(|err| PyPep508Error::new_err(err.to_string()))
|
|
}
|
|
|
|
#[getter]
|
|
fn version_or_url(&self, py: Python<'_>) -> PyObject {
|
|
match &self.version_or_url {
|
|
None => py.None(),
|
|
Some(VersionOrUrl::VersionSpecifier(version_specifier)) => version_specifier
|
|
.iter()
|
|
.map(|x| x.clone().into_py(py))
|
|
.collect::<Vec<PyObject>>()
|
|
.into_py(py),
|
|
Some(VersionOrUrl::Url(url)) => url.to_string().into_py(py),
|
|
}
|
|
}
|
|
|
|
fn __str__(&self) -> String {
|
|
self.to_string()
|
|
}
|
|
|
|
fn __repr__(&self) -> String {
|
|
format!(r#""{self}""#)
|
|
}
|
|
|
|
fn __richcmp__(&self, other: &Self, op: CompareOp) -> PyResult<bool> {
|
|
let err = PyNotImplementedError::new_err("Requirement only supports equality comparisons");
|
|
match op {
|
|
CompareOp::Lt => Err(err),
|
|
CompareOp::Le => Err(err),
|
|
CompareOp::Eq => Ok(self == other),
|
|
CompareOp::Ne => Ok(self != other),
|
|
CompareOp::Gt => Err(err),
|
|
CompareOp::Ge => Err(err),
|
|
}
|
|
}
|
|
|
|
fn __hash__(&self) -> u64 {
|
|
let mut hasher = DefaultHasher::new();
|
|
self.hash(&mut hasher);
|
|
hasher.finish()
|
|
}
|
|
|
|
/// Returns whether the markers apply for the given environment
|
|
#[allow(clippy::needless_pass_by_value)]
|
|
#[pyo3(name = "evaluate_markers")]
|
|
pub fn py_evaluate_markers(&self, env: &MarkerEnvironment, extras: Vec<String>) -> bool {
|
|
self.evaluate_markers(
|
|
env,
|
|
&extras.iter().map(String::as_str).collect::<Vec<&str>>(),
|
|
)
|
|
}
|
|
|
|
/// Returns whether the requirement would be satisfied, independent of environment markers, i.e.
|
|
/// if there is potentially an environment that could activate this requirement.
|
|
///
|
|
/// Note that unlike [Self::evaluate_markers] this does not perform any checks for bogus
|
|
/// expressions but will simply return true. As caller you should separately perform a check
|
|
/// with an environment and forward all warnings.
|
|
#[allow(clippy::needless_pass_by_value)]
|
|
#[pyo3(name = "evaluate_extras_and_python_version")]
|
|
pub fn py_evaluate_extras_and_python_version(
|
|
&self,
|
|
extras: HashSet<String>,
|
|
python_versions: Vec<PyVersion>,
|
|
) -> bool {
|
|
self.evaluate_extras_and_python_version(
|
|
&extras,
|
|
&python_versions
|
|
.into_iter()
|
|
.map(|py_version| py_version.0)
|
|
.collect::<Vec<_>>(),
|
|
)
|
|
}
|
|
|
|
/// Returns whether the markers apply for the given environment
|
|
#[allow(clippy::needless_pass_by_value)]
|
|
#[pyo3(name = "evaluate_markers_and_report")]
|
|
pub fn py_evaluate_markers_and_report(
|
|
&self,
|
|
env: &MarkerEnvironment,
|
|
extras: Vec<String>,
|
|
) -> (bool, Vec<(MarkerWarningKind, String, String)>) {
|
|
self.evaluate_markers_and_report(env, &extras)
|
|
}
|
|
}
|
|
|
|
impl Requirement {
|
|
/// Returns `true` if the [`Version`] satisfies the [`Requirement`].
|
|
pub fn is_satisfied_by(&self, version: &Version) -> bool {
|
|
let Some(version_or_url) = self.version_or_url.as_ref() else {
|
|
return true;
|
|
};
|
|
|
|
let specifiers = match version_or_url {
|
|
VersionOrUrl::VersionSpecifier(specifiers) => specifiers,
|
|
// TODO(charlie): Support URL dependencies.
|
|
VersionOrUrl::Url(_) => return false,
|
|
};
|
|
|
|
specifiers
|
|
.iter()
|
|
.all(|specifier| specifier.contains(version))
|
|
}
|
|
|
|
/// Returns whether the markers apply for the given environment
|
|
pub fn evaluate_markers(&self, env: &MarkerEnvironment, extras: &[&str]) -> bool {
|
|
if let Some(marker) = &self.marker {
|
|
marker.evaluate(env, extras)
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
|
|
/// Returns whether the requirement would be satisfied, independent of environment markers, i.e.
|
|
/// if there is potentially an environment that could activate this requirement.
|
|
///
|
|
/// Note that unlike [`Self::evaluate_markers`] this does not perform any checks for bogus
|
|
/// expressions but will simply return true. As caller you should separately perform a check
|
|
/// with an environment and forward all warnings.
|
|
pub fn evaluate_extras_and_python_version(
|
|
&self,
|
|
extras: &HashSet<String>,
|
|
python_versions: &[Version],
|
|
) -> bool {
|
|
if let Some(marker) = &self.marker {
|
|
marker.evaluate_extras_and_python_version(extras, python_versions)
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
|
|
/// Returns whether the markers apply for the given environment
|
|
pub fn evaluate_markers_and_report(
|
|
&self,
|
|
env: &MarkerEnvironment,
|
|
extras: &[String],
|
|
) -> (bool, Vec<(MarkerWarningKind, String, String)>) {
|
|
if let Some(marker) = &self.marker {
|
|
marker.evaluate_collect_warnings(
|
|
env,
|
|
&extras
|
|
.iter()
|
|
.map(std::string::String::as_str)
|
|
.collect::<Vec<&str>>(),
|
|
)
|
|
} else {
|
|
(true, Vec::new())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for Requirement {
|
|
type Err = Pep508Error;
|
|
|
|
/// Parse a [Dependency Specifier](https://packaging.python.org/en/latest/specifications/dependency-specifiers/)
|
|
fn from_str(input: &str) -> Result<Self, Self::Err> {
|
|
parse(&mut CharIter::new(input))
|
|
}
|
|
}
|
|
|
|
impl Requirement {
|
|
/// Parse a [Dependency Specifier](https://packaging.python.org/en/latest/specifications/dependency-specifiers/)
|
|
pub fn parse(input: &mut CharIter) -> Result<Self, Pep508Error> {
|
|
parse(input)
|
|
}
|
|
}
|
|
|
|
/// The actual version specifier or url to install
|
|
#[derive(Debug, Clone, Eq, Hash, PartialEq)]
|
|
pub enum VersionOrUrl {
|
|
/// A PEP 440 version specifier set
|
|
VersionSpecifier(VersionSpecifiers),
|
|
/// A installable URL
|
|
Url(Url),
|
|
}
|
|
|
|
/// A `Vec<char>` and an index inside of it. Like [String], but with utf-8 aware indexing
|
|
pub struct CharIter<'a> {
|
|
input: &'a str,
|
|
chars: Chars<'a>,
|
|
/// char-based (not byte-based) position
|
|
pos: usize,
|
|
}
|
|
|
|
impl<'a> CharIter<'a> {
|
|
/// Convert from `&str`
|
|
pub fn new(input: &'a str) -> Self {
|
|
Self {
|
|
input,
|
|
chars: input.chars(),
|
|
pos: 0,
|
|
}
|
|
}
|
|
|
|
fn copy_chars(&self) -> String {
|
|
self.input.to_string()
|
|
}
|
|
|
|
fn peek(&self) -> Option<(usize, char)> {
|
|
self.chars.clone().next().map(|char| (self.pos, char))
|
|
}
|
|
|
|
fn eat(&mut self, token: char) -> Option<usize> {
|
|
let (start_pos, peek_char) = self.peek()?;
|
|
if peek_char == token {
|
|
self.next();
|
|
Some(start_pos)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn next(&mut self) -> Option<(usize, char)> {
|
|
let next = (self.pos, self.chars.next()?);
|
|
self.pos += 1;
|
|
Some(next)
|
|
}
|
|
|
|
fn peek_char(&self) -> Option<char> {
|
|
self.chars.clone().next()
|
|
}
|
|
|
|
fn get_pos(&self) -> usize {
|
|
self.pos
|
|
}
|
|
|
|
fn peek_while(&mut self, condition: impl Fn(char) -> bool) -> (String, usize, usize) {
|
|
let peeker = self.chars.clone();
|
|
let start = self.get_pos();
|
|
let mut len = 0;
|
|
let substring = peeker
|
|
.take_while(|c| {
|
|
if condition(*c) {
|
|
len += 1;
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
})
|
|
.collect::<String>();
|
|
(substring, start, len)
|
|
}
|
|
|
|
fn take_while(&mut self, condition: impl Fn(char) -> bool) -> (String, usize, usize) {
|
|
// no pretty, but works
|
|
let mut substring = String::new();
|
|
let start = self.get_pos();
|
|
let mut len = 0;
|
|
while let Some(char) = self.peek_char() {
|
|
if !condition(char) {
|
|
break;
|
|
}
|
|
|
|
substring.push(char);
|
|
self.next();
|
|
len += 1;
|
|
}
|
|
(substring, start, len)
|
|
}
|
|
|
|
fn next_expect_char(&mut self, expected: char, span_start: usize) -> Result<(), Pep508Error> {
|
|
match self.next() {
|
|
None => Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected '{expected}', found end of dependency specification"
|
|
)),
|
|
start: span_start,
|
|
len: 1,
|
|
input: self.copy_chars(),
|
|
}),
|
|
Some((_, value)) if value == expected => Ok(()),
|
|
Some((pos, other)) => Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected '{expected}', found '{other}'"
|
|
)),
|
|
start: pos,
|
|
len: 1,
|
|
input: self.copy_chars(),
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn eat_whitespace(&mut self) {
|
|
while let Some(char) = self.peek_char() {
|
|
if char.is_whitespace() {
|
|
self.next();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_name(chars: &mut CharIter) -> Result<PackageName, Pep508Error> {
|
|
// https://peps.python.org/pep-0508/#names
|
|
// ^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$ with re.IGNORECASE
|
|
let mut name = String::new();
|
|
if let Some((index, char)) = chars.next() {
|
|
if matches!(char, 'A'..='Z' | 'a'..='z' | '0'..='9') {
|
|
name.push(char);
|
|
} else {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected package name starting with an alphanumeric character, found '{char}'"
|
|
)),
|
|
start: index,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
} else {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String("Empty field is not allowed for PEP508".to_string()),
|
|
start: 0,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
|
|
loop {
|
|
match chars.peek() {
|
|
Some((index, char @ ('A'..='Z' | 'a'..='z' | '0'..='9' | '.' | '-' | '_'))) => {
|
|
name.push(char);
|
|
chars.next();
|
|
// [.-_] can't be the final character
|
|
if chars.peek().is_none() && matches!(char, '.' | '-' | '_') {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Package name must end with an alphanumeric character, not '{char}'"
|
|
)),
|
|
start: index,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
}
|
|
Some(_) | None => {
|
|
return Ok(PackageName::new(name)
|
|
.expect("`PackageName` validation should match PEP 508 parsing"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// parses extras in the `[extra1,extra2] format`
|
|
fn parse_extras(chars: &mut CharIter) -> Result<Option<Vec<ExtraName>>, Pep508Error> {
|
|
let Some(bracket_pos) = chars.eat('[') else {
|
|
return Ok(None);
|
|
};
|
|
let mut extras = Vec::new();
|
|
|
|
loop {
|
|
// wsp* before the identifier
|
|
chars.eat_whitespace();
|
|
let mut buffer = String::new();
|
|
let early_eof_error = Pep508Error {
|
|
message: Pep508ErrorSource::String(
|
|
"Missing closing bracket (expected ']', found end of dependency specification)"
|
|
.to_string(),
|
|
),
|
|
start: bracket_pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
};
|
|
|
|
// First char of the identifier
|
|
match chars.next() {
|
|
// letterOrDigit
|
|
Some((_, alphanumeric @ ('a'..='z' | 'A'..='Z' | '0'..='9'))) => {
|
|
buffer.push(alphanumeric);
|
|
}
|
|
Some((pos, other)) => {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected an alphanumeric character starting the extra name, found '{other}'"
|
|
)),
|
|
start: pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
None => return Err(early_eof_error),
|
|
}
|
|
// Parse from the second char of the identifier
|
|
// We handle the illegal character case below
|
|
// identifier_end = letterOrDigit | (('-' | '_' | '.' )* letterOrDigit)
|
|
// identifier_end*
|
|
buffer.push_str(
|
|
&chars
|
|
.take_while(
|
|
|char| matches!(char, 'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.'),
|
|
)
|
|
.0,
|
|
);
|
|
match chars.peek() {
|
|
Some((pos, char)) if char != ',' && char != ']' && !char.is_whitespace() => {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Invalid character in extras name, expected an alphanumeric character, '-', '_', '.', ',' or ']', found '{char}'"
|
|
)),
|
|
start: pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
_ => {}
|
|
};
|
|
// wsp* after the identifier
|
|
chars.eat_whitespace();
|
|
// end or next identifier?
|
|
match chars.next() {
|
|
Some((_, ',')) => {
|
|
extras.push(
|
|
ExtraName::new(buffer)
|
|
.expect("`ExtraName` validation should match PEP 508 parsing"),
|
|
);
|
|
}
|
|
Some((_, ']')) => {
|
|
extras.push(
|
|
ExtraName::new(buffer)
|
|
.expect("`ExtraName` validation should match PEP 508 parsing"),
|
|
);
|
|
break;
|
|
}
|
|
Some((pos, other)) => {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected either ',' (separating extras) or ']' (ending the extras section), found '{other}'"
|
|
)),
|
|
start: pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
None => return Err(early_eof_error),
|
|
}
|
|
}
|
|
|
|
Ok(Some(extras))
|
|
}
|
|
|
|
fn parse_url(chars: &mut CharIter) -> Result<VersionOrUrl, Pep508Error> {
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
// <URI_reference>
|
|
let (url, start, len) = chars.take_while(|char| !char.is_whitespace());
|
|
if url.is_empty() {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String("Expected URL".to_string()),
|
|
start,
|
|
len,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
let url = Url::parse(&url).map_err(|err| Pep508Error {
|
|
message: Pep508ErrorSource::UrlError(err),
|
|
start,
|
|
len,
|
|
input: chars.copy_chars(),
|
|
})?;
|
|
Ok(VersionOrUrl::Url(url))
|
|
}
|
|
|
|
/// PEP 440 wrapper
|
|
fn parse_specifier(
|
|
chars: &mut CharIter,
|
|
buffer: &str,
|
|
start: usize,
|
|
end: usize,
|
|
) -> Result<VersionSpecifier, Pep508Error> {
|
|
VersionSpecifier::from_str(buffer).map_err(|err| Pep508Error {
|
|
message: Pep508ErrorSource::String(err),
|
|
start,
|
|
len: end - start,
|
|
input: chars.copy_chars(),
|
|
})
|
|
}
|
|
|
|
/// Such as `>=1.19,<2.0`, either delimited by the end of the specifier or a `;` for the marker part
|
|
///
|
|
/// ```text
|
|
/// version_one (wsp* ',' version_one)*
|
|
/// ```
|
|
fn parse_version_specifier(chars: &mut CharIter) -> Result<Option<VersionOrUrl>, Pep508Error> {
|
|
let mut start = chars.get_pos();
|
|
let mut specifiers = Vec::new();
|
|
let mut buffer = String::new();
|
|
let requirement_kind = loop {
|
|
match chars.peek() {
|
|
Some((end, ',')) => {
|
|
let specifier = parse_specifier(chars, &buffer, start, end)?;
|
|
specifiers.push(specifier);
|
|
buffer.clear();
|
|
chars.next();
|
|
start = end + 1;
|
|
}
|
|
Some((_, ';')) | None => {
|
|
let end = chars.get_pos();
|
|
let specifier = parse_specifier(chars, &buffer, start, end)?;
|
|
specifiers.push(specifier);
|
|
break Some(VersionOrUrl::VersionSpecifier(
|
|
specifiers.into_iter().collect(),
|
|
));
|
|
}
|
|
Some((_, char)) => {
|
|
buffer.push(char);
|
|
chars.next();
|
|
}
|
|
}
|
|
};
|
|
Ok(requirement_kind)
|
|
}
|
|
|
|
/// Such as `(>=1.19,<2.0)`
|
|
///
|
|
/// ```text
|
|
/// '(' version_one (wsp* ',' version_one)* ')'
|
|
/// ```
|
|
fn parse_version_specifier_parentheses(
|
|
chars: &mut CharIter,
|
|
) -> Result<Option<VersionOrUrl>, Pep508Error> {
|
|
let brace_pos = chars.get_pos();
|
|
chars.next();
|
|
// Makes for slightly better error underline
|
|
chars.eat_whitespace();
|
|
let mut start = chars.get_pos();
|
|
let mut specifiers = Vec::new();
|
|
let mut buffer = String::new();
|
|
let requirement_kind = loop {
|
|
match chars.next() {
|
|
Some((end, ',')) => {
|
|
let specifier =
|
|
parse_specifier(chars, &buffer, start, end)?;
|
|
specifiers.push(specifier);
|
|
buffer.clear();
|
|
start = end + 1;
|
|
}
|
|
Some((end, ')')) => {
|
|
let specifier = parse_specifier(chars, &buffer, start, end)?;
|
|
specifiers.push(specifier);
|
|
break Some(VersionOrUrl::VersionSpecifier(specifiers.into_iter().collect()));
|
|
}
|
|
Some((_, char)) => buffer.push(char),
|
|
None => return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String("Missing closing parenthesis (expected ')', found end of dependency specification)".to_string()),
|
|
start: brace_pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
}),
|
|
}
|
|
};
|
|
Ok(requirement_kind)
|
|
}
|
|
|
|
/// Parse a [dependency specifier](https://packaging.python.org/en/latest/specifications/dependency-specifiers)
|
|
fn parse(chars: &mut CharIter) -> Result<Requirement, Pep508Error> {
|
|
// Technically, the grammar is:
|
|
// ```text
|
|
// name_req = name wsp* extras? wsp* versionspec? wsp* quoted_marker?
|
|
// url_req = name wsp* extras? wsp* urlspec wsp+ quoted_marker?
|
|
// specification = wsp* ( url_req | name_req ) wsp*
|
|
// ```
|
|
// So we can merge this into:
|
|
// ```text
|
|
// specification = wsp* name wsp* extras? wsp* (('@' wsp* url_req) | ('(' versionspec ')') | (versionspec)) wsp* (';' wsp* marker)? wsp*
|
|
// ```
|
|
// Where the extras start with '[' if any, then we have '@', '(' or one of the version comparison
|
|
// operators. Markers start with ';' if any
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
// name
|
|
let name = parse_name(chars)?;
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
// extras?
|
|
let extras = parse_extras(chars)?;
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
|
|
// ( url_req | name_req )?
|
|
let requirement_kind = match chars.peek_char() {
|
|
Some('@') => {
|
|
chars.next();
|
|
Some(parse_url(chars)?)
|
|
}
|
|
Some('(') => parse_version_specifier_parentheses(chars)?,
|
|
Some('<' | '=' | '>' | '~' | '!') => parse_version_specifier(chars)?,
|
|
Some(';') | None => None,
|
|
Some(other) => {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(format!(
|
|
"Expected one of `@`, `(`, `<`, `=`, `>`, `~`, `!`, `;`, found `{other}`"
|
|
)),
|
|
start: chars.get_pos(),
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
};
|
|
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
// quoted_marker?
|
|
let marker = if chars.peek_char() == Some(';') {
|
|
// Skip past the semicolon
|
|
chars.next();
|
|
Some(marker::parse_markers_impl(chars)?)
|
|
} else {
|
|
None
|
|
};
|
|
// wsp*
|
|
chars.eat_whitespace();
|
|
if let Some((pos, char)) = chars.next() {
|
|
return Err(Pep508Error {
|
|
message: Pep508ErrorSource::String(if marker.is_none() {
|
|
format!(r#"Expected end of input or ';', found '{char}'"#)
|
|
} else {
|
|
format!(r#"Expected end of input, found '{char}'"#)
|
|
}),
|
|
start: pos,
|
|
len: 1,
|
|
input: chars.copy_chars(),
|
|
});
|
|
}
|
|
|
|
Ok(Requirement {
|
|
name,
|
|
extras,
|
|
version_or_url: requirement_kind,
|
|
marker,
|
|
})
|
|
}
|
|
|
|
/// A library for [dependency specifiers](https://packaging.python.org/en/latest/specifications/dependency-specifiers/)
|
|
/// as originally specified in [PEP 508](https://peps.python.org/pep-0508/)
|
|
///
|
|
/// This has `Version` and `VersionSpecifier` included. That is because
|
|
/// `pep440_rs.Version("1.2.3") != pep508_rs.Requirement("numpy==1.2.3").version_or_url` as the
|
|
/// `Version`s come from two different binaries and can therefore never be equal.
|
|
#[cfg(feature = "pyo3")]
|
|
#[pymodule]
|
|
#[pyo3(name = "pep508_rs")]
|
|
pub fn python_module(py: Python<'_>, m: &PyModule) -> PyResult<()> {
|
|
// Allowed to fail if we embed this module in another
|
|
#[allow(unused_must_use)]
|
|
{
|
|
pyo3_log::try_init();
|
|
}
|
|
|
|
m.add_class::<PyVersion>()?;
|
|
m.add_class::<VersionSpecifier>()?;
|
|
|
|
m.add_class::<Requirement>()?;
|
|
m.add_class::<MarkerEnvironment>()?;
|
|
m.add("Pep508Error", py.get_type::<PyPep508Error>())?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Half of these tests are copied from <https://github.com/pypa/packaging/pull/624>
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::str::FromStr;
|
|
|
|
use indoc::indoc;
|
|
use url::Url;
|
|
|
|
use pep440_rs::{Operator, Version, VersionSpecifier};
|
|
use puffin_normalize::{ExtraName, PackageName};
|
|
|
|
use crate::marker::{
|
|
parse_markers_impl, MarkerExpression, MarkerOperator, MarkerTree, MarkerValue,
|
|
MarkerValueString, MarkerValueVersion,
|
|
};
|
|
use crate::{CharIter, Requirement, VersionOrUrl};
|
|
|
|
fn assert_err(input: &str, error: &str) {
|
|
assert_eq!(Requirement::from_str(input).unwrap_err().to_string(), error);
|
|
}
|
|
|
|
#[test]
|
|
fn error_empty() {
|
|
assert_err(
|
|
"",
|
|
indoc! {"\
|
|
Empty field is not allowed for PEP508
|
|
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_start() {
|
|
assert_err(
|
|
"_name",
|
|
indoc! {"
|
|
Expected package name starting with an alphanumeric character, found '_'
|
|
_name
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_end() {
|
|
assert_err(
|
|
"name_",
|
|
indoc! {"
|
|
Package name must end with an alphanumeric character, not '_'
|
|
name_
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_examples() {
|
|
let input = r#"requests[security,tests] >=2.8.1, ==2.8.* ; python_version < '2.7'"#;
|
|
let requests = Requirement::from_str(input).unwrap();
|
|
assert_eq!(input, requests.to_string());
|
|
let expected = Requirement {
|
|
name: PackageName::from_str("requests").unwrap(),
|
|
extras: Some(vec![
|
|
ExtraName::from_str("security").unwrap(),
|
|
ExtraName::from_str("tests").unwrap(),
|
|
]),
|
|
version_or_url: Some(VersionOrUrl::VersionSpecifier(
|
|
[
|
|
VersionSpecifier::new(
|
|
Operator::GreaterThanEqual,
|
|
Version {
|
|
epoch: 0,
|
|
release: vec![2, 8, 1],
|
|
pre: None,
|
|
post: None,
|
|
dev: None,
|
|
local: None,
|
|
},
|
|
false,
|
|
)
|
|
.unwrap(),
|
|
VersionSpecifier::new(
|
|
Operator::Equal,
|
|
Version {
|
|
epoch: 0,
|
|
release: vec![2, 8],
|
|
pre: None,
|
|
post: None,
|
|
dev: None,
|
|
local: None,
|
|
},
|
|
true,
|
|
)
|
|
.unwrap(),
|
|
]
|
|
.into_iter()
|
|
.collect(),
|
|
)),
|
|
marker: Some(MarkerTree::Expression(MarkerExpression {
|
|
l_value: MarkerValue::MarkerEnvVersion(MarkerValueVersion::PythonVersion),
|
|
operator: MarkerOperator::LessThan,
|
|
r_value: MarkerValue::QuotedString("2.7".to_string()),
|
|
})),
|
|
};
|
|
assert_eq!(requests, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn parenthesized_single() {
|
|
let numpy = Requirement::from_str("numpy ( >=1.19 )").unwrap();
|
|
assert_eq!(numpy.name.as_ref(), "numpy");
|
|
}
|
|
|
|
#[test]
|
|
fn parenthesized_double() {
|
|
let numpy = Requirement::from_str("numpy ( >=1.19, <2.0 )").unwrap();
|
|
assert_eq!(numpy.name.as_ref(), "numpy");
|
|
}
|
|
|
|
#[test]
|
|
fn versions_single() {
|
|
let numpy = Requirement::from_str("numpy >=1.19 ").unwrap();
|
|
assert_eq!(numpy.name.as_ref(), "numpy");
|
|
}
|
|
|
|
#[test]
|
|
fn versions_double() {
|
|
let numpy = Requirement::from_str("numpy >=1.19, <2.0 ").unwrap();
|
|
assert_eq!(numpy.name.as_ref(), "numpy");
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_eof1() {
|
|
assert_err(
|
|
"black[",
|
|
indoc! {"
|
|
Missing closing bracket (expected ']', found end of dependency specification)
|
|
black[
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_eof2() {
|
|
assert_err(
|
|
"black[d",
|
|
indoc! {"
|
|
Missing closing bracket (expected ']', found end of dependency specification)
|
|
black[d
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_eof3() {
|
|
assert_err(
|
|
"black[d,",
|
|
indoc! {"
|
|
Missing closing bracket (expected ']', found end of dependency specification)
|
|
black[d,
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_illegal_start1() {
|
|
assert_err(
|
|
"black[ö]",
|
|
indoc! {"
|
|
Expected an alphanumeric character starting the extra name, found 'ö'
|
|
black[ö]
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_illegal_start2() {
|
|
assert_err(
|
|
"black[_d]",
|
|
indoc! {"
|
|
Expected an alphanumeric character starting the extra name, found '_'
|
|
black[_d]
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_illegal_character() {
|
|
assert_err(
|
|
"black[jüpyter]",
|
|
indoc! {"
|
|
Invalid character in extras name, expected an alphanumeric character, '-', '_', '.', ',' or ']', found 'ü'
|
|
black[jüpyter]
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras1() {
|
|
let numpy = Requirement::from_str("black[d]").unwrap();
|
|
assert_eq!(numpy.extras, Some(vec![ExtraName::from_str("d").unwrap()]));
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras2() {
|
|
let numpy = Requirement::from_str("black[d,jupyter]").unwrap();
|
|
assert_eq!(
|
|
numpy.extras,
|
|
Some(vec![
|
|
ExtraName::from_str("d").unwrap(),
|
|
ExtraName::from_str("jupyter").unwrap()
|
|
])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_parenthesized_pep440() {
|
|
assert_err(
|
|
"numpy ( ><1.19 )",
|
|
indoc! {"
|
|
Version specifier `><1.19 ` doesn't match PEP 440 rules
|
|
numpy ( ><1.19 )
|
|
^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_parenthesized_parenthesis() {
|
|
assert_err(
|
|
"numpy ( >=1.19",
|
|
indoc! {"
|
|
Missing closing parenthesis (expected ')', found end of dependency specification)
|
|
numpy ( >=1.19
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_whats_that() {
|
|
assert_err(
|
|
"numpy % 1.16",
|
|
indoc! {"
|
|
Expected one of `@`, `(`, `<`, `=`, `>`, `~`, `!`, `;`, found `%`
|
|
numpy % 1.16
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn url() {
|
|
let pip_url =
|
|
Requirement::from_str("pip @ https://github.com/pypa/pip/archive/1.3.1.zip#sha1=da9234ee9982d4bbb3c72346a6de940a148ea686")
|
|
.unwrap();
|
|
let url = "https://github.com/pypa/pip/archive/1.3.1.zip#sha1=da9234ee9982d4bbb3c72346a6de940a148ea686";
|
|
let expected = Requirement {
|
|
name: PackageName::from_str("pip").unwrap(),
|
|
extras: None,
|
|
marker: None,
|
|
version_or_url: Some(VersionOrUrl::Url(Url::parse(url).unwrap())),
|
|
};
|
|
assert_eq!(pip_url, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn test_marker_parsing() {
|
|
let marker = r#"python_version == "2.7" and (sys_platform == "win32" or (os_name == "linux" and implementation_name == 'cpython'))"#;
|
|
let actual = parse_markers_impl(&mut CharIter::new(marker)).unwrap();
|
|
let expected = MarkerTree::And(vec![
|
|
MarkerTree::Expression(MarkerExpression {
|
|
l_value: MarkerValue::MarkerEnvVersion(MarkerValueVersion::PythonVersion),
|
|
operator: MarkerOperator::Equal,
|
|
r_value: MarkerValue::QuotedString("2.7".to_string()),
|
|
}),
|
|
MarkerTree::Or(vec![
|
|
MarkerTree::Expression(MarkerExpression {
|
|
l_value: MarkerValue::MarkerEnvString(MarkerValueString::SysPlatform),
|
|
operator: MarkerOperator::Equal,
|
|
r_value: MarkerValue::QuotedString("win32".to_string()),
|
|
}),
|
|
MarkerTree::And(vec![
|
|
MarkerTree::Expression(MarkerExpression {
|
|
l_value: MarkerValue::MarkerEnvString(MarkerValueString::OsName),
|
|
operator: MarkerOperator::Equal,
|
|
r_value: MarkerValue::QuotedString("linux".to_string()),
|
|
}),
|
|
MarkerTree::Expression(MarkerExpression {
|
|
l_value: MarkerValue::MarkerEnvString(
|
|
MarkerValueString::ImplementationName,
|
|
),
|
|
operator: MarkerOperator::Equal,
|
|
r_value: MarkerValue::QuotedString("cpython".to_string()),
|
|
}),
|
|
]),
|
|
]),
|
|
]);
|
|
assert_eq!(expected, actual);
|
|
}
|
|
|
|
#[test]
|
|
fn name_and_marker() {
|
|
Requirement::from_str(r#"numpy; sys_platform == "win32" or (os_name == "linux" and implementation_name == 'cpython')"#).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn error_marker_incomplete1() {
|
|
assert_err(
|
|
r#"numpy; sys_platform"#,
|
|
indoc! {"
|
|
Expected a valid marker operator (such as '>=' or 'not in'), found ''
|
|
numpy; sys_platform
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_marker_incomplete2() {
|
|
assert_err(
|
|
r#"numpy; sys_platform =="#,
|
|
indoc! {"\
|
|
Expected marker value, found end of dependency specification
|
|
numpy; sys_platform ==
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_marker_incomplete3() {
|
|
assert_err(
|
|
r#"numpy; sys_platform == "win32" or"#,
|
|
indoc! {"
|
|
Expected marker value, found end of dependency specification
|
|
numpy; sys_platform == \"win32\" or
|
|
^"},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_marker_incomplete4() {
|
|
assert_err(
|
|
r#"numpy; sys_platform == "win32" or (os_name == "linux""#,
|
|
indoc! {r#"
|
|
Expected ')', found end of dependency specification
|
|
numpy; sys_platform == "win32" or (os_name == "linux"
|
|
^"#},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_marker_incomplete5() {
|
|
assert_err(
|
|
r#"numpy; sys_platform == "win32" or (os_name == "linux" and"#,
|
|
indoc! {"
|
|
Expected marker value, found end of dependency specification
|
|
numpy; sys_platform == \"win32\" or (os_name == \"linux\" and
|
|
^"},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_pep440() {
|
|
assert_err(
|
|
r#"numpy >=1.1.*"#,
|
|
indoc! {"
|
|
Operator >= must not be used in version ending with a star
|
|
numpy >=1.1.*
|
|
^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_no_name() {
|
|
assert_err(
|
|
r#"==0.0"#,
|
|
indoc! {"
|
|
Expected package name starting with an alphanumeric character, found '='
|
|
==0.0
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_no_comma_between_extras() {
|
|
assert_err(
|
|
r#"name[bar baz]"#,
|
|
indoc! {"
|
|
Expected either ',' (separating extras) or ']' (ending the extras section), found 'b'
|
|
name[bar baz]
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extra_comma_after_extras() {
|
|
assert_err(
|
|
r#"name[bar, baz,]"#,
|
|
indoc! {"
|
|
Expected an alphanumeric character starting the extra name, found ']'
|
|
name[bar, baz,]
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_extras_not_closed() {
|
|
assert_err(
|
|
r#"name[bar, baz >= 1.0"#,
|
|
indoc! {"
|
|
Expected either ',' (separating extras) or ']' (ending the extras section), found '>'
|
|
name[bar, baz >= 1.0
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_no_space_after_url() {
|
|
assert_err(
|
|
r#"name @ https://example.com/; extra == 'example'"#,
|
|
indoc! {"
|
|
Expected end of input or ';', found 'e'
|
|
name @ https://example.com/; extra == 'example'
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_name_at_nothing() {
|
|
assert_err(
|
|
r#"name @"#,
|
|
indoc! {"
|
|
Expected URL
|
|
name @
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_error_invalid_marker_key() {
|
|
assert_err(
|
|
r#"name; invalid_name"#,
|
|
indoc! {"
|
|
Expected a valid marker name, found 'invalid_name'
|
|
name; invalid_name
|
|
^^^^^^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_markers_invalid_order() {
|
|
assert_err(
|
|
"name; '3.7' <= invalid_name",
|
|
indoc! {"
|
|
Expected a valid marker name, found 'invalid_name'
|
|
name; '3.7' <= invalid_name
|
|
^^^^^^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_markers_notin() {
|
|
assert_err(
|
|
"name; '3.7' notin python_version",
|
|
indoc! {"
|
|
Expected a valid marker operator (such as '>=' or 'not in'), found 'notin'
|
|
name; '3.7' notin python_version
|
|
^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_markers_inpython_version() {
|
|
assert_err(
|
|
"name; '3.6'inpython_version",
|
|
indoc! {"
|
|
Expected a valid marker operator (such as '>=' or 'not in'), found 'inpython_version'
|
|
name; '3.6'inpython_version
|
|
^^^^^^^^^^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_markers_not_python_version() {
|
|
assert_err(
|
|
"name; '3.7' not python_version",
|
|
indoc! {"
|
|
Expected 'i', found 'p'
|
|
name; '3.7' not python_version
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_markers_invalid_operator() {
|
|
assert_err(
|
|
"name; '3.7' ~ python_version",
|
|
indoc! {"
|
|
Expected a valid marker operator (such as '>=' or 'not in'), found '~'
|
|
name; '3.7' ~ python_version
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_invalid_prerelease() {
|
|
assert_err(
|
|
"name==1.0.org1",
|
|
indoc! {"
|
|
Version specifier `==1.0.org1` doesn't match PEP 440 rules
|
|
name==1.0.org1
|
|
^^^^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_no_version_value() {
|
|
assert_err(
|
|
"name==",
|
|
indoc! {"
|
|
Version specifier `==` doesn't match PEP 440 rules
|
|
name==
|
|
^^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_no_version_operator() {
|
|
assert_err(
|
|
"name 1.0",
|
|
indoc! {"
|
|
Expected one of `@`, `(`, `<`, `=`, `>`, `~`, `!`, `;`, found `1`
|
|
name 1.0
|
|
^"
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_random_char() {
|
|
assert_err(
|
|
"name >= 1.0 #",
|
|
indoc! {"
|
|
Version specifier `>= 1.0 #` doesn't match PEP 440 rules
|
|
name >= 1.0 #
|
|
^^^^^^^^"
|
|
},
|
|
);
|
|
}
|
|
}
|