Zanie Blue
2dc4fd0a19
Part of #8090 Adds the ability to include a group (`--group`) in the sync or _only_ sync a group (`--only-group`). Includes all groups in the resolution, which will have the same limitations as extras as described in #6981. There's a great deal of refactoring of the "development" concept into "groups" behind the scenes that I am continuing to defer here to minimize the diff. Additionally, this does not yet resolve interactions with the existing `dev` group — we'll tackle that separately as well. I probably won't merge the stack until that design is resolved. The current proposal is that we'll just "combine' the `dev-dependencies` contents into the `dev` group.
100 lines
3.2 KiB
Rust
100 lines
3.2 KiB
Rust
use either::Either;
|
|
use uv_normalize::{GroupName, DEV_DEPENDENCIES};
|
|
|
|
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
|
|
pub enum DevMode {
|
|
/// Include development dependencies.
|
|
#[default]
|
|
Include,
|
|
/// Exclude development dependencies.
|
|
Exclude,
|
|
/// Only include development dependencies, excluding all other dependencies.
|
|
Only,
|
|
}
|
|
|
|
impl DevMode {
|
|
/// Determine the [`DevMode`] policy from the command-line arguments.
|
|
pub fn from_args(dev: bool, no_dev: bool, only_dev: bool) -> Self {
|
|
if only_dev {
|
|
Self::Only
|
|
} else if no_dev {
|
|
Self::Exclude
|
|
} else if dev {
|
|
Self::Include
|
|
} else {
|
|
Self::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum DevSpecification {
|
|
/// Include dev dependencies from the specified group.
|
|
Include(Vec<GroupName>),
|
|
/// Do not include dev dependencies.
|
|
Exclude,
|
|
/// Include dev dependencies from the specified groups, and exclude all non-dev dependencies.
|
|
Only(Vec<GroupName>),
|
|
}
|
|
|
|
impl DevSpecification {
|
|
/// Returns an [`Iterator`] over the group names to include.
|
|
pub fn iter(&self) -> impl Iterator<Item = &GroupName> {
|
|
match self {
|
|
Self::Exclude => Either::Left(std::iter::empty()),
|
|
Self::Include(groups) | Self::Only(groups) => Either::Right(groups.iter()),
|
|
}
|
|
}
|
|
|
|
/// Returns `true` if the specification allows for production dependencies.
|
|
pub fn prod(&self) -> bool {
|
|
matches!(self, Self::Exclude | Self::Include(_))
|
|
}
|
|
}
|
|
|
|
impl From<DevMode> for DevSpecification {
|
|
fn from(mode: DevMode) -> Self {
|
|
match mode {
|
|
DevMode::Include => Self::Include(vec![DEV_DEPENDENCIES.clone()]),
|
|
DevMode::Exclude => Self::Exclude,
|
|
DevMode::Only => Self::Only(vec![DEV_DEPENDENCIES.clone()]),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DevSpecification {
|
|
/// Determine the [`DevSpecification`] policy from the command-line arguments.
|
|
pub fn from_args(
|
|
dev: bool,
|
|
no_dev: bool,
|
|
only_dev: bool,
|
|
group: Vec<GroupName>,
|
|
only_group: Vec<GroupName>,
|
|
) -> Self {
|
|
let from_mode = DevSpecification::from(DevMode::from_args(dev, no_dev, only_dev));
|
|
if !group.is_empty() {
|
|
match from_mode {
|
|
DevSpecification::Exclude => Self::Include(group),
|
|
DevSpecification::Include(dev) => {
|
|
Self::Include(group.into_iter().chain(dev).collect())
|
|
}
|
|
DevSpecification::Only(_) => {
|
|
unreachable!("cannot specify both `--only-dev` and `--group`")
|
|
}
|
|
}
|
|
} else if !only_group.is_empty() {
|
|
match from_mode {
|
|
DevSpecification::Exclude => Self::Only(only_group),
|
|
DevSpecification::Only(dev) => {
|
|
Self::Only(only_group.into_iter().chain(dev).collect())
|
|
}
|
|
// TODO(zanieb): `dev` defaults to true we can't tell if `--dev` was provided in
|
|
// conflict with `--only-group` here
|
|
DevSpecification::Include(_) => Self::Only(only_group),
|
|
}
|
|
} else {
|
|
from_mode
|
|
}
|
|
}
|
|
}
|