uv_resolver/
exclude_newer.rs

1use std::{
2    ops::{Deref, DerefMut},
3    str::FromStr,
4};
5
6use jiff::Timestamp;
7use rustc_hash::FxHashMap;
8use serde::ser::SerializeMap;
9use uv_distribution_types::{ExcludeNewerOverride, ExcludeNewerSpan, ExcludeNewerValue};
10use uv_normalize::PackageName;
11use uv_preview::PreviewFeature;
12use uv_warnings::warn_user_once;
13
14/// The configuration layer that supplied the effective `exclude-newer` cutoff for a package.
15#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
16pub enum EffectiveExcludeNewerSource {
17    /// The global `exclude-newer` setting.
18    Global,
19    /// A package-specific `exclude-newer-package` override.
20    Package,
21    /// An index-specific `[[tool.uv.index]].exclude-newer` override.
22    Index,
23}
24
25#[derive(Debug, Clone, PartialEq, Eq)]
26pub enum ExcludeNewerValueChange {
27    /// A relative span changed to a new value
28    SpanChanged(ExcludeNewerSpan, ExcludeNewerSpan),
29    /// A relative span was added
30    SpanAdded(ExcludeNewerSpan),
31    /// A relative span was removed
32    SpanRemoved,
33    /// A relative span is present and the timestamp changed
34    RelativeTimestampChanged(Timestamp, Timestamp, ExcludeNewerSpan),
35    /// The timestamp changed and a relative span is not present
36    AbsoluteTimestampChanged(Timestamp, Timestamp),
37}
38
39impl ExcludeNewerValueChange {
40    fn is_relative_timestamp_change(&self) -> bool {
41        matches!(self, Self::RelativeTimestampChanged(_, _, _))
42    }
43}
44
45impl std::fmt::Display for ExcludeNewerValueChange {
46    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47        match self {
48            Self::SpanChanged(old, new) => {
49                write!(f, "change of exclude newer span from `{old}` to `{new}`")
50            }
51            Self::SpanAdded(span) => {
52                write!(f, "addition of exclude newer span `{span}`")
53            }
54            Self::SpanRemoved => {
55                write!(f, "removal of exclude newer span")
56            }
57            Self::RelativeTimestampChanged(old, new, span) => {
58                write!(
59                    f,
60                    "change of calculated ({span}) exclude newer timestamp from `{old}` to `{new}`"
61                )
62            }
63            Self::AbsoluteTimestampChanged(old, new) => {
64                write!(
65                    f,
66                    "change of exclude newer timestamp from `{old}` to `{new}`"
67                )
68            }
69        }
70    }
71}
72
73#[derive(Debug, Clone, PartialEq, Eq)]
74pub enum ExcludeNewerChange {
75    GlobalChanged(ExcludeNewerValueChange),
76    GlobalAdded(ExcludeNewerValue),
77    GlobalRemoved,
78    Package(ExcludeNewerPackageChange),
79}
80
81impl ExcludeNewerChange {
82    /// Whether the change is due to a change in a relative timestamp.
83    pub fn is_relative_timestamp_change(&self) -> bool {
84        match self {
85            Self::GlobalChanged(change) => change.is_relative_timestamp_change(),
86            Self::GlobalAdded(_) | Self::GlobalRemoved => false,
87            Self::Package(change) => change.is_relative_timestamp_change(),
88        }
89    }
90}
91
92impl std::fmt::Display for ExcludeNewerChange {
93    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
94        match self {
95            Self::GlobalChanged(change) => {
96                write!(f, "{change}")
97            }
98            Self::GlobalAdded(value) => {
99                write!(f, "addition of global exclude newer {value}")
100            }
101            Self::GlobalRemoved => write!(f, "removal of global exclude newer"),
102            Self::Package(change) => {
103                write!(f, "{change}")
104            }
105        }
106    }
107}
108
109#[derive(Debug, Clone, PartialEq, Eq)]
110pub enum ExcludeNewerPackageChange {
111    PackageAdded(PackageName, ExcludeNewerOverride),
112    PackageRemoved(PackageName),
113    PackageChanged(PackageName, Box<ExcludeNewerOverrideChange>),
114}
115
116impl ExcludeNewerPackageChange {
117    fn is_relative_timestamp_change(&self) -> bool {
118        match self {
119            Self::PackageAdded(_, _) | Self::PackageRemoved(_) => false,
120            Self::PackageChanged(_, change) => change.is_relative_timestamp_change(),
121        }
122    }
123}
124
125impl std::fmt::Display for ExcludeNewerPackageChange {
126    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
127        match self {
128            Self::PackageAdded(name, ExcludeNewerOverride::Enabled(value)) => {
129                write!(
130                    f,
131                    "addition of exclude newer `{}` for package `{name}`",
132                    value.as_ref()
133                )
134            }
135            Self::PackageAdded(name, ExcludeNewerOverride::Disabled) => {
136                write!(
137                    f,
138                    "addition of exclude newer exclusion for package `{name}`"
139                )
140            }
141            Self::PackageRemoved(name) => {
142                write!(f, "removal of exclude newer for package `{name}`")
143            }
144            Self::PackageChanged(name, change) => write!(f, "{change} for package `{name}`"),
145        }
146    }
147}
148
149fn compare_exclude_newer_value(
150    this: &ExcludeNewerValue,
151    other: &ExcludeNewerValue,
152) -> Option<ExcludeNewerValueChange> {
153    match (this.span(), other.span()) {
154        (None, Some(span)) => Some(ExcludeNewerValueChange::SpanAdded(*span)),
155        (Some(_), None) => Some(ExcludeNewerValueChange::SpanRemoved),
156        (Some(self_span), Some(other_span)) if self_span != other_span => Some(
157            ExcludeNewerValueChange::SpanChanged(*self_span, *other_span),
158        ),
159        (Some(_), Some(span)) if this.timestamp() != other.timestamp() => {
160            Some(ExcludeNewerValueChange::RelativeTimestampChanged(
161                this.timestamp(),
162                other.timestamp(),
163                *span,
164            ))
165        }
166        (None, None) if this.timestamp() != other.timestamp() => Some(
167            ExcludeNewerValueChange::AbsoluteTimestampChanged(this.timestamp(), other.timestamp()),
168        ),
169        (Some(_), Some(_)) | (None, None) => None,
170    }
171}
172
173pub struct ExcludeNewerValueWithSpanRef<'a>(pub &'a ExcludeNewerValue);
174
175impl serde::Serialize for ExcludeNewerValueWithSpanRef<'_> {
176    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
177    where
178        S: serde::Serializer,
179    {
180        if let Some(span) = self.0.span() {
181            let mut map = serializer.serialize_map(Some(2))?;
182            map.serialize_entry("timestamp", &self.0.timestamp())?;
183            map.serialize_entry("span", span)?;
184            map.end()
185        } else {
186            self.0.timestamp().serialize(serializer)
187        }
188    }
189}
190
191/// A package-specific exclude-newer entry.
192#[derive(Debug, Clone, PartialEq, Eq)]
193#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
194pub struct ExcludeNewerPackageEntry {
195    package: PackageName,
196    setting: ExcludeNewerOverride,
197}
198
199impl FromStr for ExcludeNewerPackageEntry {
200    type Err = String;
201
202    /// Parses a [`ExcludeNewerPackageEntry`] from a string in the format `PACKAGE=DATE` or `PACKAGE=false`.
203    fn from_str(s: &str) -> Result<Self, Self::Err> {
204        let Some((package, value)) = s.split_once('=') else {
205            return Err(format!(
206                "Invalid `exclude-newer-package` value `{s}`: expected format `PACKAGE=DATE` or `PACKAGE=false`"
207            ));
208        };
209
210        let package = PackageName::from_str(package).map_err(|err| {
211            format!("Invalid `exclude-newer-package` package name `{package}`: {err}")
212        })?;
213
214        let setting = if value == "false" {
215            ExcludeNewerOverride::Disabled
216        } else {
217            ExcludeNewerOverride::Enabled(Box::new(ExcludeNewerValue::from_str(value).map_err(
218                |err| format!("Invalid `exclude-newer-package` value `{value}`: {err}"),
219            )?))
220        };
221
222        Ok(Self { package, setting })
223    }
224}
225
226impl From<(PackageName, ExcludeNewerOverride)> for ExcludeNewerPackageEntry {
227    fn from((package, setting): (PackageName, ExcludeNewerOverride)) -> Self {
228        Self { package, setting }
229    }
230}
231
232impl From<(PackageName, ExcludeNewerValue)> for ExcludeNewerPackageEntry {
233    fn from((package, timestamp): (PackageName, ExcludeNewerValue)) -> Self {
234        Self {
235            package,
236            setting: ExcludeNewerOverride::Enabled(Box::new(timestamp)),
237        }
238    }
239}
240
241pub fn serialize_exclude_newer_package_with_spans<S>(
242    value: &Option<ExcludeNewerPackage>,
243    serializer: S,
244) -> Result<S::Ok, S::Error>
245where
246    S: serde::Serializer,
247{
248    let Some(value) = value else {
249        return serializer.serialize_none();
250    };
251
252    let mut map = serializer.serialize_map(Some(value.len()))?;
253    for (name, setting) in value {
254        match setting {
255            ExcludeNewerOverride::Disabled => map.serialize_entry(name, &false)?,
256            ExcludeNewerOverride::Enabled(value) => {
257                map.serialize_entry(name, &ExcludeNewerValueWithSpanRef(value.as_ref()))?;
258            }
259        }
260    }
261    map.end()
262}
263
264#[derive(Debug, Clone, PartialEq, Eq)]
265pub enum ExcludeNewerOverrideChange {
266    Disabled { was: ExcludeNewerValue },
267    Enabled { now: ExcludeNewerValue },
268    TimestampChanged(ExcludeNewerValueChange),
269}
270
271impl ExcludeNewerOverrideChange {
272    fn is_relative_timestamp_change(&self) -> bool {
273        match self {
274            Self::Disabled { .. } | Self::Enabled { .. } => false,
275            Self::TimestampChanged(change) => change.is_relative_timestamp_change(),
276        }
277    }
278}
279
280impl std::fmt::Display for ExcludeNewerOverrideChange {
281    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
282        match self {
283            Self::Disabled { was } => {
284                write!(f, "add exclude newer exclusion (was `{was}`)")
285            }
286            Self::Enabled { now } => {
287                write!(f, "remove exclude newer exclusion (now `{now}`)")
288            }
289            Self::TimestampChanged(change) => write!(f, "{change}"),
290        }
291    }
292}
293
294#[derive(Debug, Clone, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
295#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
296pub struct ExcludeNewerPackage(FxHashMap<PackageName, ExcludeNewerOverride>);
297
298impl Deref for ExcludeNewerPackage {
299    type Target = FxHashMap<PackageName, ExcludeNewerOverride>;
300
301    fn deref(&self) -> &Self::Target {
302        &self.0
303    }
304}
305
306impl DerefMut for ExcludeNewerPackage {
307    fn deref_mut(&mut self) -> &mut Self::Target {
308        &mut self.0
309    }
310}
311
312impl FromIterator<ExcludeNewerPackageEntry> for ExcludeNewerPackage {
313    fn from_iter<T: IntoIterator<Item = ExcludeNewerPackageEntry>>(iter: T) -> Self {
314        Self(
315            iter.into_iter()
316                .map(|entry| (entry.package, entry.setting))
317                .collect(),
318        )
319    }
320}
321
322impl IntoIterator for ExcludeNewerPackage {
323    type Item = (PackageName, ExcludeNewerOverride);
324    type IntoIter = std::collections::hash_map::IntoIter<PackageName, ExcludeNewerOverride>;
325
326    fn into_iter(self) -> Self::IntoIter {
327        self.0.into_iter()
328    }
329}
330
331impl<'a> IntoIterator for &'a ExcludeNewerPackage {
332    type Item = (&'a PackageName, &'a ExcludeNewerOverride);
333    type IntoIter = std::collections::hash_map::Iter<'a, PackageName, ExcludeNewerOverride>;
334
335    fn into_iter(self) -> Self::IntoIter {
336        self.0.iter()
337    }
338}
339
340impl ExcludeNewerPackage {
341    /// Returns true if this map is empty (no package-specific settings).
342    pub fn is_empty(&self) -> bool {
343        self.0.is_empty()
344    }
345
346    fn compare(&self, other: &Self) -> Option<ExcludeNewerPackageChange> {
347        for (package, setting) in self {
348            match (setting, other.get(package)) {
349                (
350                    ExcludeNewerOverride::Enabled(self_timestamp),
351                    Some(ExcludeNewerOverride::Enabled(other_timestamp)),
352                ) => {
353                    if let Some(change) =
354                        compare_exclude_newer_value(self_timestamp, other_timestamp)
355                    {
356                        return Some(ExcludeNewerPackageChange::PackageChanged(
357                            package.clone(),
358                            Box::new(ExcludeNewerOverrideChange::TimestampChanged(change)),
359                        ));
360                    }
361                }
362                (
363                    ExcludeNewerOverride::Enabled(self_timestamp),
364                    Some(ExcludeNewerOverride::Disabled),
365                ) => {
366                    return Some(ExcludeNewerPackageChange::PackageChanged(
367                        package.clone(),
368                        Box::new(ExcludeNewerOverrideChange::Disabled {
369                            was: self_timestamp.as_ref().clone(),
370                        }),
371                    ));
372                }
373                (
374                    ExcludeNewerOverride::Disabled,
375                    Some(ExcludeNewerOverride::Enabled(other_timestamp)),
376                ) => {
377                    return Some(ExcludeNewerPackageChange::PackageChanged(
378                        package.clone(),
379                        Box::new(ExcludeNewerOverrideChange::Enabled {
380                            now: other_timestamp.as_ref().clone(),
381                        }),
382                    ));
383                }
384                (ExcludeNewerOverride::Disabled, Some(ExcludeNewerOverride::Disabled)) => {}
385                (_, None) => {
386                    return Some(ExcludeNewerPackageChange::PackageRemoved(package.clone()));
387                }
388            }
389        }
390
391        for (package, value) in other {
392            if !self.contains_key(package) {
393                return Some(ExcludeNewerPackageChange::PackageAdded(
394                    package.clone(),
395                    value.clone(),
396                ));
397            }
398        }
399
400        None
401    }
402}
403
404/// A setting that excludes files newer than a timestamp, at a global level or per-package.
405#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Default)]
406#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
407pub struct ExcludeNewer {
408    /// Global timestamp that applies to all packages if no package-specific timestamp is set.
409    #[serde(default, skip_serializing_if = "Option::is_none")]
410    pub global: Option<ExcludeNewerValue>,
411    /// Per-package timestamps that override the global timestamp.
412    #[serde(default, skip_serializing_if = "FxHashMap::is_empty")]
413    pub package: ExcludeNewerPackage,
414}
415
416impl ExcludeNewer {
417    /// Create a new exclude newer configuration with just a global timestamp.
418    pub fn global(global: ExcludeNewerValue) -> Self {
419        Self {
420            global: Some(global),
421            package: ExcludeNewerPackage::default(),
422        }
423    }
424
425    fn warn_index_exclude_newer_preview() {
426        if !uv_preview::is_enabled(PreviewFeature::IndexExcludeNewer) {
427            warn_user_once!(
428                "Setting `exclude-newer` on configured indexes is experimental and may change without warning. Pass `--preview-features {}` to disable this warning.",
429                PreviewFeature::IndexExcludeNewer
430            );
431        }
432    }
433
434    /// Create from CLI arguments.
435    pub fn from_args(
436        global: Option<ExcludeNewerValue>,
437        package: Vec<ExcludeNewerPackageEntry>,
438    ) -> Self {
439        let package: ExcludeNewerPackage = package.into_iter().collect();
440
441        Self { global, package }
442    }
443
444    /// Returns the effective exclude-newer timestamp for a specific package, falling back to the
445    /// global value if no package-specific setting exists.
446    pub(crate) fn exclude_newer_package(&self, package_name: &PackageName) -> Option<Timestamp> {
447        match self.package.get(package_name) {
448            Some(ExcludeNewerOverride::Enabled(value)) => Some(value.timestamp()),
449            Some(ExcludeNewerOverride::Disabled) => None,
450            None => self.global.as_ref().map(ExcludeNewerValue::timestamp),
451        }
452    }
453
454    /// Returns the effective exclude-newer timestamp for a package resolved from a specific index.
455    pub fn exclude_newer_package_for_index(
456        &self,
457        package_name: &PackageName,
458        index: Option<&ExcludeNewerOverride>,
459    ) -> Option<Timestamp> {
460        self.exclude_newer_package_for_index_with_source(package_name, index)
461            .map(|(timestamp, _)| timestamp)
462    }
463
464    /// Returns the effective exclude-newer timestamp and its source for a package resolved from a
465    /// specific index.
466    pub(crate) fn exclude_newer_package_for_index_with_source(
467        &self,
468        package_name: &PackageName,
469        index: Option<&ExcludeNewerOverride>,
470    ) -> Option<(Timestamp, EffectiveExcludeNewerSource)> {
471        match self.package.get(package_name) {
472            Some(ExcludeNewerOverride::Enabled(value)) => {
473                Some((value.timestamp(), EffectiveExcludeNewerSource::Package))
474            }
475            Some(ExcludeNewerOverride::Disabled) => None,
476            None => match index {
477                Some(ExcludeNewerOverride::Disabled) => {
478                    Self::warn_index_exclude_newer_preview();
479                    None
480                }
481                Some(ExcludeNewerOverride::Enabled(value)) => Some((
482                    {
483                        Self::warn_index_exclude_newer_preview();
484                        value.timestamp()
485                    },
486                    EffectiveExcludeNewerSource::Index,
487                )),
488                None => self
489                    .global
490                    .as_ref()
491                    .map(|value| (value.timestamp(), EffectiveExcludeNewerSource::Global)),
492            },
493        }
494    }
495
496    /// Returns true if this has any configuration (global or per-package).
497    pub(crate) fn is_empty(&self) -> bool {
498        self.global.is_none() && self.package.is_empty()
499    }
500
501    pub fn compare(&self, other: &Self) -> Option<ExcludeNewerChange> {
502        match (&self.global, &other.global) {
503            (Some(self_global), Some(other_global)) => {
504                if let Some(change) = compare_exclude_newer_value(self_global, other_global) {
505                    if !change.is_relative_timestamp_change() {
506                        return Some(ExcludeNewerChange::GlobalChanged(change));
507                    }
508                }
509            }
510            (None, Some(global)) => {
511                return Some(ExcludeNewerChange::GlobalAdded(global.clone()));
512            }
513            (Some(_), None) => return Some(ExcludeNewerChange::GlobalRemoved),
514            (None, None) => (),
515        }
516        self.package
517            .compare(&other.package)
518            .map(ExcludeNewerChange::Package)
519    }
520}
521
522impl std::fmt::Display for ExcludeNewer {
523    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
524        if let Some(global) = &self.global {
525            write!(f, "global: {global}")?;
526            if !self.package.is_empty() {
527                write!(f, ", ")?;
528            }
529        }
530        let mut first = true;
531        for (name, setting) in &self.package {
532            if !first {
533                write!(f, ", ")?;
534            }
535            match setting {
536                ExcludeNewerOverride::Enabled(timestamp) => {
537                    write!(f, "{name}: {}", timestamp.as_ref())?;
538                }
539                ExcludeNewerOverride::Disabled => {
540                    write!(f, "{name}: disabled")?;
541                }
542            }
543            first = false;
544        }
545        Ok(())
546    }
547}
uv_resolver/exclude_newer.rs

uv_resolver/
exclude_newer.rs
