use crate::module_scan::canonical_module_path;
use super::crate_rule::CrateBoundary;
use super::module_rule::ModuleBoundary;
pub(crate) fn canonical_set<I, S>(values: I) -> String
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
let mut values: Vec<String> = values
.into_iter()
.map(|value| value.as_ref().to_string())
.collect();
values.sort_unstable();
values.dedup();
serde_json::to_string(&values).expect("a list of strings always serializes")
}
pub(crate) fn canonical_module_set<I, S>(values: I) -> String
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
canonical_set(
values
.into_iter()
.map(|value| canonical_module_path(value.as_ref())),
)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Constitution {
name: String,
boundaries: Vec<Boundary>,
}
impl Constitution {
pub fn new(name: &str) -> Self {
Self {
name: name.to_string(),
boundaries: Vec::new(),
}
}
pub fn boundary(mut self, boundary: impl Into<Boundary>) -> Self {
self.boundaries.push(boundary.into());
self
}
pub fn name(&self) -> &str {
&self.name
}
pub fn boundaries(&self) -> &[Boundary] {
&self.boundaries
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DependencyKind {
#[default]
Normal,
Dev,
Build,
}
impl DependencyKind {
pub(crate) fn finding_suffix(&self) -> &'static str {
match self {
DependencyKind::Normal => "",
DependencyKind::Dev => " (dev)",
DependencyKind::Build => " (build)",
}
}
pub(crate) fn key_label(&self) -> &'static str {
match self {
DependencyKind::Normal => "normal",
DependencyKind::Dev => "dev",
DependencyKind::Build => "build",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SourceKind {
Registry,
Git,
Path,
}
impl SourceKind {
pub(crate) fn label(&self) -> &'static str {
match self {
SourceKind::Registry => "registry",
SourceKind::Git => "git",
SourceKind::Path => "path",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Boundary {
Crate(CrateBoundary),
Module(ModuleBoundary),
}
impl From<CrateBoundary> for Boundary {
fn from(boundary: CrateBoundary) -> Self {
Boundary::Crate(boundary)
}
}
impl From<ModuleBoundary> for Boundary {
fn from(boundary: ModuleBoundary) -> Self {
Boundary::Module(boundary)
}
}