lux_lib/package/
version.rs

1use std::{
2    cmp::{self, Ordering},
3    fmt::Display,
4    str::FromStr,
5};
6
7use html_escape::decode_html_entities;
8use itertools::Itertools;
9
10use miette::Diagnostic;
11use nonempty::NonEmpty;
12use semver::{Comparator, Error, Op, Prerelease, Version, VersionReq};
13use serde::{de, Deserialize, Deserializer, Serialize};
14use thiserror::Error;
15
16mod upgrade;
17
18#[derive(Debug, Error, Diagnostic)]
19pub enum VersionReqToVersionError {
20    #[error("cannot parse version from non-exact version requirement '{0}'")]
21    NonExactVersionReq(VersionReq),
22    #[error("cannot parse version from version requirement '*' (any version)")]
23    Any,
24}
25
26#[derive(Clone, Eq, PartialEq, Hash, Debug)]
27pub enum PackageVersion {
28    /// **SemVer version** as defined by <https://semver.org>,
29    /// but a bit more lenient for compatibility with luarocks
30    SemVer(SemVer),
31    /// A known **Dev** version
32    DevVer(DevVer),
33    /// An arbitrary string version.
34    /// Yes, luarocks-site allows arbitrary string versions in the root manifest
35    /// ┻━┻ ︵ヽ(`Д´)ﾉ︵ ┻━┻
36    StringVer(StringVer),
37}
38
39impl HasModRev for PackageVersion {
40    fn to_modrev_string(&self) -> String {
41        match self {
42            Self::SemVer(ver) => ver.to_modrev_string(),
43            Self::DevVer(ver) => ver.to_modrev_string(),
44            Self::StringVer(ver) => ver.to_modrev_string(),
45        }
46    }
47}
48
49impl PackageVersion {
50    pub fn parse(text: &str) -> Result<Self, PackageVersionParseError> {
51        PackageVersion::from_str(text)
52    }
53    /// The package version without its spec revision.
54    pub fn to_version_string(&self) -> String {
55        self.to_modrev_string()
56    }
57    /// Note that this loses the specrev information.
58    pub fn into_version_req(&self) -> PackageVersionReq {
59        match self {
60            PackageVersion::DevVer(DevVer { modrev, .. }) => {
61                PackageVersionReq::DevVer(modrev.to_owned())
62            }
63            PackageVersion::StringVer(StringVer { modrev, .. }) => {
64                PackageVersionReq::StringVer(modrev.to_owned())
65            }
66            PackageVersion::SemVer(SemVer { version, .. }) => {
67                let version = version.to_owned();
68                PackageVersionReq::SemVer(VersionReq {
69                    comparators: vec![Comparator {
70                        op: Op::Exact,
71                        major: version.major,
72                        minor: Some(version.minor),
73                        patch: Some(version.patch),
74                        pre: version.pre,
75                    }],
76                })
77            }
78        }
79    }
80
81    /// A `~>` version requirement that allows non-breaking updates, or `None` if this is
82    /// not a SemVer version.
83    /// Following the SemVer conventions around zero versions, the most significant non-zero
84    /// component is kept, so that only the components to its right may change.
85    pub(crate) fn to_pessimistic_version_req(&self) -> Option<String> {
86        let PackageVersion::SemVer(sem_ver) = self else {
87            return None;
88        };
89        let version = &sem_ver.version;
90        Some(match (version.major, version.minor) {
91            (0, 0) => format!("~> 0.0.{}", version.patch),
92            (0, minor) => format!("~> 0.{minor}"),
93            (major, _) => format!("~> {major}"),
94        })
95    }
96
97    pub(crate) fn is_semver(&self) -> bool {
98        matches!(self, PackageVersion::SemVer(_))
99    }
100
101    pub(crate) fn default_dev_version() -> Self {
102        Self::DevVer(DevVer::default())
103    }
104
105    pub(crate) fn default_dev_version_with_specrev(specrev: SpecRev) -> Self {
106        Self::DevVer(DevVer::default_with_specrev(specrev))
107    }
108}
109
110impl TryFrom<PackageVersionReq> for PackageVersion {
111    type Error = VersionReqToVersionError;
112
113    fn try_from(req: PackageVersionReq) -> Result<Self, Self::Error> {
114        match req {
115            PackageVersionReq::SemVer(version_req) => {
116                match NonEmpty::try_from(version_req.comparators.clone()) {
117                    Ok(comparators)
118                        if comparators
119                            .iter()
120                            .any(|comparator| comparator.op != semver::Op::Exact) =>
121                    {
122                        Err(VersionReqToVersionError::NonExactVersionReq(version_req))
123                    }
124                    Ok(comparators) => {
125                        let comparator = comparators.first();
126                        let version = semver::Version {
127                            major: comparator.major,
128                            minor: comparator.minor.unwrap_or(0),
129                            patch: comparator.patch.unwrap_or(0),
130                            pre: comparator.pre.clone(),
131                            build: semver::BuildMetadata::EMPTY,
132                        };
133                        Ok(PackageVersion::SemVer(SemVer {
134                            version,
135                            component_count: comparator_component_count(comparator),
136                            specrev: 1.into(),
137                        }))
138                    }
139                    Err(_) => Err(VersionReqToVersionError::NonExactVersionReq(version_req)),
140                }
141            }
142            PackageVersionReq::DevVer(modrev) => Ok(PackageVersion::DevVer(DevVer {
143                modrev,
144                specrev: 1.into(),
145            })),
146            PackageVersionReq::StringVer(modrev) => Ok(PackageVersion::StringVer(StringVer {
147                modrev,
148                specrev: 1.into(),
149            })),
150            PackageVersionReq::Any => Err(VersionReqToVersionError::Any),
151        }
152    }
153}
154
155#[derive(Error, Debug, Diagnostic)]
156#[non_exhaustive]
157pub enum PackageVersionParseError {
158    #[error(transparent)]
159    #[diagnostic(transparent)]
160    Specrev(#[from] SpecrevParseError),
161    #[error("failed to parse version")]
162    Version(#[from] Error),
163}
164
165impl Serialize for PackageVersion {
166    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
167    where
168        S: serde::Serializer,
169    {
170        match self {
171            PackageVersion::SemVer(version) => version.serialize(serializer),
172            PackageVersion::DevVer(version) => version.serialize(serializer),
173            PackageVersion::StringVer(version) => version.serialize(serializer),
174        }
175    }
176}
177
178impl<'de> Deserialize<'de> for PackageVersion {
179    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
180    where
181        D: Deserializer<'de>,
182    {
183        let s = String::deserialize(deserializer)?;
184        Self::from_str(&s).map_err(de::Error::custom)
185    }
186}
187
188impl Display for PackageVersion {
189    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
190        match self {
191            PackageVersion::SemVer(version) => version.fmt(f),
192            PackageVersion::DevVer(version) => version.fmt(f),
193            PackageVersion::StringVer(version) => version.fmt(f),
194        }
195    }
196}
197
198impl PartialOrd for PackageVersion {
199    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
200        Some(self.cmp(other))
201    }
202}
203
204impl Ord for PackageVersion {
205    fn cmp(&self, other: &Self) -> Ordering {
206        match (self, other) {
207            (PackageVersion::SemVer(a), PackageVersion::SemVer(b)) => a.cmp(b),
208            (PackageVersion::SemVer(..), PackageVersion::DevVer(..)) => Ordering::Less,
209            (PackageVersion::SemVer(..), PackageVersion::StringVer(..)) => Ordering::Greater,
210            (PackageVersion::DevVer(..), PackageVersion::SemVer(..)) => Ordering::Greater,
211            (PackageVersion::DevVer(a), PackageVersion::DevVer(b)) => a.cmp(b),
212            (PackageVersion::DevVer(..), PackageVersion::StringVer(..)) => Ordering::Greater,
213            (PackageVersion::StringVer(a), PackageVersion::StringVer(b)) => a.cmp(b),
214            (PackageVersion::StringVer(..), PackageVersion::SemVer(..)) => Ordering::Less,
215            (PackageVersion::StringVer(..), PackageVersion::DevVer(..)) => Ordering::Less,
216        }
217    }
218}
219
220impl FromStr for PackageVersion {
221    type Err = PackageVersionParseError;
222
223    fn from_str(text: &str) -> Result<Self, Self::Err> {
224        let (modrev, specrev) = split_specrev(text)?;
225        match modrev {
226            "scm" => Ok(PackageVersion::DevVer(DevVer {
227                modrev: DevVersion::Scm,
228                specrev,
229            })),
230            "dev" => Ok(PackageVersion::DevVer(DevVer {
231                modrev: DevVersion::Dev,
232                specrev,
233            })),
234            modrev => match parse_version(modrev) {
235                Ok(version) => Ok(PackageVersion::SemVer(SemVer {
236                    component_count: cmp::min(text.chars().filter(|c| *c == '.').count() + 1, 3),
237                    version,
238                    specrev,
239                })),
240                Err(_) => Ok(PackageVersion::StringVer(StringVer {
241                    modrev: modrev.into(),
242                    specrev,
243                })),
244            },
245        }
246    }
247}
248
249/// The revision of a rov
250#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
251pub struct SpecRev(u16);
252
253impl From<u16> for SpecRev {
254    fn from(value: u16) -> Self {
255        Self(value)
256    }
257}
258
259impl Display for SpecRev {
260    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
261        self.0.fmt(f)
262    }
263}
264
265impl Default for SpecRev {
266    fn default() -> Self {
267        Self(1)
268    }
269}
270
271/// Iterates `SpecRev`s upwards, starting from `1`.
272pub(crate) struct SpecRevIterator {
273    current: u16,
274}
275
276impl SpecRevIterator {
277    pub fn new() -> Self {
278        SpecRevIterator {
279            current: SpecRev::default().0,
280        }
281    }
282}
283
284impl Iterator for SpecRevIterator {
285    type Item = SpecRev;
286
287    fn next(&mut self) -> Option<Self::Item> {
288        let current = self.current;
289        self.current += 1;
290        if self.current == 0 {
291            None // overflow
292        } else {
293            Some(SpecRev(current))
294        }
295    }
296}
297
298// TODO: Stop deriving Eq here
299#[derive(Clone, Eq, PartialEq, Hash, Debug)]
300pub struct SemVer {
301    version: Version,
302    component_count: usize,
303    specrev: SpecRev,
304}
305
306impl HasModRev for SemVer {
307    fn to_modrev_string(&self) -> String {
308        self.version.to_string()
309    }
310}
311
312impl Display for SemVer {
313    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
314        if self
315            .version
316            .pre
317            .as_str()
318            .chars()
319            .any(|c| c.is_ascii_alphabetic())
320        {
321            // pre-release instead of specrev
322            return self.version.fmt(f);
323        }
324        let (version_str, remainder) = split_semver_version(&self.version.to_string());
325        let mut luarocks_version_str = version_str.split('.').take(self.component_count).join(".");
326        if let Some(remainder) = remainder {
327            // luarocks allows and arbitrary number of '.' separators
328            // We treat anything after the third '.' as a semver prerelease/build version,
329            // so we have to convert it back for luarocks.
330            luarocks_version_str.push_str(&format!(".{remainder}"));
331        }
332        let str = format!("{}-{}", luarocks_version_str, self.specrev);
333        str.fmt(f)
334    }
335}
336
337fn split_semver_version(version_str: &str) -> (String, Option<String>) {
338    if let Some(pos) = version_str.rfind('-') {
339        if let Some(pre_build_str) = version_str.get(pos + 1..) {
340            (version_str[..pos].into(), Some(pre_build_str.into()))
341        } else {
342            (version_str[..pos].into(), None)
343        }
344    } else {
345        (version_str.into(), None)
346    }
347}
348
349impl Serialize for SemVer {
350    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
351    where
352        S: serde::Serializer,
353    {
354        self.to_string().serialize(serializer)
355    }
356}
357
358impl Ord for SemVer {
359    fn cmp(&self, other: &Self) -> Ordering {
360        match cmp_versions(&self.version, &other.version) {
361            Ordering::Equal => self.specrev.cmp(&other.specrev),
362            ord => ord,
363        }
364    }
365}
366
367/// Compare two LuaRocks versions.
368/// ┻━┻ ︵╰(°□°╰) Luarocks allows for an arbitrary number of version digits (e.g. `2.1.0.10`),
369/// which Lux treats as a SemVer prerelease.
370fn cmp_versions(a: &Version, b: &Version) -> Ordering {
371    match (a.major, a.minor, a.patch).cmp(&(b.major, b.minor, b.patch)) {
372        Ordering::Equal => cmp_prerelease(&a.pre, &b.pre),
373        ord => ord,
374    }
375}
376
377fn cmp_prerelease(a: &Prerelease, b: &Prerelease) -> Ordering {
378    match (a.is_empty(), b.is_empty()) {
379        (true, true) => Ordering::Equal,
380        (false, true) => Ordering::Greater,
381        (true, false) => Ordering::Less,
382        (false, false) => a.cmp(b),
383    }
384}
385
386fn comparator_component_count(comparator: &Comparator) -> usize {
387    if comparator.patch.is_some() {
388        3
389    } else if comparator.minor.is_some() {
390        2
391    } else {
392        1
393    }
394}
395
396/// Based on `semver`'s matching, but with the prerelease compared as an extension
397/// for compatibility with LuaRocks.
398/// The "prereleases only match prerelease comparators" rule is not applied.
399fn comparator_matches(comparator: &Comparator, version: &Version) -> bool {
400    match comparator.op {
401        Op::Exact | Op::Wildcard => matches_exact(comparator, version),
402        Op::Greater => matches_greater(comparator, version),
403        Op::GreaterEq => matches_greater(comparator, version) || matches_exact(comparator, version),
404        Op::Less => matches_less(comparator, version),
405        Op::LessEq => matches_less(comparator, version) || matches_exact(comparator, version),
406        Op::Tilde => matches_tilde(comparator, version),
407        Op::Caret => matches_caret(comparator, version),
408        _ => false,
409    }
410}
411
412fn matches_exact(comparator: &Comparator, version: &Version) -> bool {
413    if version.major != comparator.major {
414        return false;
415    }
416    if let Some(minor) = comparator.minor {
417        if version.minor != minor {
418            return false;
419        }
420    }
421    if let Some(patch) = comparator.patch {
422        if version.patch != patch {
423            return false;
424        }
425    }
426    version.pre == comparator.pre
427}
428
429fn matches_greater(comparator: &Comparator, version: &Version) -> bool {
430    if version.major != comparator.major {
431        return version.major > comparator.major;
432    }
433    match comparator.minor {
434        None => return false,
435        Some(minor) => {
436            if version.minor != minor {
437                return version.minor > minor;
438            }
439        }
440    }
441    match comparator.patch {
442        None => return false,
443        Some(patch) => {
444            if version.patch != patch {
445                return version.patch > patch;
446            }
447        }
448    }
449    cmp_prerelease(&version.pre, &comparator.pre) == Ordering::Greater
450}
451
452fn matches_less(comparator: &Comparator, version: &Version) -> bool {
453    if version.major != comparator.major {
454        return version.major < comparator.major;
455    }
456    match comparator.minor {
457        None => return false,
458        Some(minor) => {
459            if version.minor != minor {
460                return version.minor < minor;
461            }
462        }
463    }
464    match comparator.patch {
465        None => return false,
466        Some(patch) => {
467            if version.patch != patch {
468                return version.patch < patch;
469            }
470        }
471    }
472    cmp_prerelease(&version.pre, &comparator.pre) == Ordering::Less
473}
474
475fn matches_tilde(comparator: &Comparator, version: &Version) -> bool {
476    if version.major != comparator.major {
477        return false;
478    }
479    if let Some(minor) = comparator.minor {
480        if version.minor != minor {
481            return false;
482        }
483    }
484    if let Some(patch) = comparator.patch {
485        if version.patch != patch {
486            return version.patch > patch;
487        }
488    }
489    cmp_prerelease(&version.pre, &comparator.pre) != Ordering::Less
490}
491
492fn matches_caret(comparator: &Comparator, version: &Version) -> bool {
493    if version.major != comparator.major {
494        return false;
495    }
496    let minor = match comparator.minor {
497        None => return true,
498        Some(minor) => minor,
499    };
500    let patch = match comparator.patch {
501        None => {
502            if comparator.major > 0 {
503                return version.minor >= minor;
504            } else {
505                return version.minor == minor;
506            }
507        }
508        Some(patch) => patch,
509    };
510    if comparator.major > 0 {
511        if version.minor != minor {
512            return version.minor > minor;
513        } else if version.patch != patch {
514            return version.patch > patch;
515        }
516    } else if minor > 0 {
517        if version.minor != minor {
518            return false;
519        } else if version.patch != patch {
520            return version.patch > patch;
521        }
522    } else if version.minor != minor || version.patch != patch {
523        return false;
524    }
525    cmp_prerelease(&version.pre, &comparator.pre) != Ordering::Less
526}
527
528impl PartialOrd for SemVer {
529    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
530        Some(self.cmp(other))
531    }
532}
533
534#[derive(Clone, Eq, PartialEq, PartialOrd, Ord, Hash, Debug, Serialize, Deserialize, Default)]
535#[serde(rename_all = "lowercase")]
536pub enum DevVersion {
537    #[default]
538    Dev,
539    Scm,
540}
541
542impl Display for DevVersion {
543    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
544        match self {
545            Self::Dev => "dev".fmt(f),
546            Self::Scm => "scm".fmt(f),
547        }
548    }
549}
550
551#[derive(Clone, Eq, PartialEq, Hash, Debug, Default)]
552pub struct DevVer {
553    modrev: DevVersion,
554    specrev: SpecRev,
555}
556
557impl DevVer {
558    fn default_with_specrev(specrev: SpecRev) -> Self {
559        Self {
560            modrev: DevVersion::default(),
561            specrev,
562        }
563    }
564}
565
566impl HasModRev for DevVer {
567    fn to_modrev_string(&self) -> String {
568        self.modrev.to_string().to_lowercase()
569    }
570}
571
572impl Display for DevVer {
573    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
574        let str = format!("{}-{}", self.modrev, self.specrev);
575        str.fmt(f)
576    }
577}
578
579impl Serialize for DevVer {
580    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
581    where
582        S: serde::Serializer,
583    {
584        self.to_string().serialize(serializer)
585    }
586}
587
588impl Ord for DevVer {
589    fn cmp(&self, other: &Self) -> Ordering {
590        // NOTE: We compare specrevs first for dev versions
591        let result = self.specrev.cmp(&other.specrev);
592        if result == Ordering::Equal {
593            return self.modrev.cmp(&other.modrev);
594        }
595        result
596    }
597}
598
599impl PartialOrd for DevVer {
600    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
601        Some(self.cmp(other))
602    }
603}
604
605#[derive(Clone, Eq, PartialEq, Hash, Debug)]
606pub struct StringVer {
607    modrev: String,
608    specrev: SpecRev,
609}
610
611impl HasModRev for StringVer {
612    fn to_modrev_string(&self) -> String {
613        self.modrev.to_string()
614    }
615}
616
617impl Display for StringVer {
618    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
619        let str = format!("{}-{}", self.modrev, self.specrev);
620        str.fmt(f)
621    }
622}
623
624impl Serialize for StringVer {
625    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
626    where
627        S: serde::Serializer,
628    {
629        self.to_string().serialize(serializer)
630    }
631}
632
633impl Ord for StringVer {
634    fn cmp(&self, other: &Self) -> Ordering {
635        // NOTE: We compare specrevs first for dev versions
636        let result = self.specrev.cmp(&other.specrev);
637        if result == Ordering::Equal {
638            return self.modrev.cmp(&other.modrev);
639        }
640        result
641    }
642}
643
644impl PartialOrd for StringVer {
645    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
646        Some(self.cmp(other))
647    }
648}
649
650pub(crate) trait HasModRev {
651    /// If a version has a modrev (and possibly a specrev),
652    /// this is equivalent to `to_string()`, but includes only the modrev.
653    fn to_modrev_string(&self) -> String;
654}
655
656#[derive(Error, Debug, Diagnostic)]
657#[non_exhaustive]
658#[error(transparent)]
659pub struct PackageVersionReqError(#[from] Error);
660
661/// **SemVer version** requirement as defined by <https://semver.org>.
662/// or a **Dev** version requirement, which can be one of "dev", "scm", or "git"
663#[derive(Clone, Eq, PartialEq, Hash, Debug)]
664pub enum PackageVersionReq {
665    /// A PackageVersionReq that matches a SemVer version.
666    SemVer(VersionReq),
667    /// A PackageVersionReq that matches only known dev versions.
668    DevVer(DevVersion),
669    /// A PackageVersionReq that matches a arbitrary string version.
670    StringVer(String),
671    /// A PackageVersionReq that has no version constraint.
672    Any,
673}
674
675impl PackageVersionReq {
676    /// Returns a `PackageVersionReq` that matches any version.
677    pub fn any() -> Self {
678        PackageVersionReq::Any
679    }
680
681    pub fn parse(text: &str) -> Result<Self, PackageVersionReqError> {
682        PackageVersionReq::from_str(text)
683    }
684
685    pub fn matches(&self, version: &PackageVersion) -> bool {
686        match (self, version) {
687            (PackageVersionReq::SemVer(req), PackageVersion::SemVer(ver)) => req
688                .comparators
689                .iter()
690                .all(|comparator| comparator_matches(comparator, &ver.version)),
691            (PackageVersionReq::DevVer(req), PackageVersion::DevVer(ver)) => req == &ver.modrev,
692            (PackageVersionReq::StringVer(req), PackageVersion::StringVer(ver)) => {
693                req == &ver.modrev
694            }
695            (PackageVersionReq::Any, _) => true,
696            _ => false,
697        }
698    }
699
700    pub fn is_any(&self) -> bool {
701        matches!(self, PackageVersionReq::Any)
702    }
703
704    /// Returns true if this requirement pins the Luau dialect (`lua = "luau"`).
705    pub fn is_luau(&self) -> bool {
706        matches!(self, PackageVersionReq::StringVer(req) if req == "luau")
707    }
708}
709
710impl Display for PackageVersionReq {
711    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
712        match self {
713            PackageVersionReq::SemVer(version_req) => {
714                let mut str = version_req.to_string();
715                if str.starts_with("=") {
716                    str = str.replacen("=", "==", 1);
717                } else if str.starts_with("^") {
718                    str = str.replacen("^", "~>", 1);
719                }
720                str.fmt(f)
721            }
722            PackageVersionReq::DevVer(name_req) => write!(f, "=={}", name_req),
723            PackageVersionReq::StringVer(name_req) => write!(f, "=={}", name_req),
724            PackageVersionReq::Any => f.write_str("any"),
725        }
726    }
727}
728
729impl<'de> Deserialize<'de> for PackageVersionReq {
730    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
731    where
732        D: Deserializer<'de>,
733    {
734        String::deserialize(deserializer)?
735            .parse()
736            .map_err(serde::de::Error::custom)
737    }
738}
739
740impl FromStr for PackageVersionReq {
741    type Err = PackageVersionReqError;
742
743    fn from_str(text: &str) -> Result<Self, Self::Err> {
744        let text = correct_version_req_str(text);
745
746        let trimmed = text.trim_start_matches('=').trim_start_matches('@').trim();
747
748        match parse_version_req(&text) {
749            Ok(_) => Ok(PackageVersionReq::SemVer(parse_version_req(&text)?)),
750            Err(_) => match trimmed {
751                "scm" => Ok(PackageVersionReq::DevVer(DevVersion::Scm)),
752                "dev" => Ok(PackageVersionReq::DevVer(DevVersion::Dev)),
753                ver => Ok(PackageVersionReq::StringVer(ver.to_string())),
754            },
755        }
756    }
757}
758
759fn correct_version_req_str(text: &str) -> String {
760    text.chars()
761        .chunk_by(|t| t.is_alphanumeric() || matches!(t, '-' | '_' | '.'))
762        .into_iter()
763        .map(|(is_version_str, chars)| (is_version_str, chars.collect::<String>()))
764        .map(|(is_version_str, chunk)| {
765            if is_version_str && !is_known_dev_version_str(&chunk) {
766                let version_str = trim_specrev(&chunk);
767                correct_prerelease_version_string(version_str)
768            } else {
769                chunk
770            }
771        })
772        .collect::<String>()
773}
774
775fn trim_specrev(version_str: &str) -> &str {
776    if let Some(pos) = version_str.rfind('-') {
777        let suffix = &version_str[pos + 1..];
778        if suffix.chars().all(|c| c.is_ascii_digit()) {
779            &version_str[..pos]
780        } else {
781            version_str
782        }
783    } else {
784        version_str
785    }
786}
787
788#[derive(Error, Debug, Diagnostic)]
789#[non_exhaustive]
790pub enum SpecrevParseError {
791    #[error("specrev {specrev} in version {full_version} contains non-numeric characters")]
792    InvalidSpecrev {
793        specrev: String,
794        full_version: String,
795    },
796    #[error("could not parse specrev in version {0}")]
797    InvalidVersion(String),
798}
799
800fn split_specrev(version_str: &str) -> Result<(&str, SpecRev), SpecrevParseError> {
801    if let Some(pos) = version_str.rfind('-') {
802        if let Some(specrev_str) = version_str.get(pos + 1..) {
803            if specrev_str.chars().all(|c| c.is_ascii_digit()) {
804                let specrev =
805                    specrev_str
806                        .parse::<u16>()
807                        .map_err(|_| SpecrevParseError::InvalidSpecrev {
808                            specrev: specrev_str.into(),
809                            full_version: version_str.into(),
810                        })?;
811                Ok((&version_str[..pos], specrev.into()))
812            } else {
813                // A non-numeric suffix is a semver prerelease, not a specrev.
814                Ok((version_str, 1.into()))
815            }
816        } else {
817            Err(SpecrevParseError::InvalidVersion(version_str.into()))
818        }
819    } else {
820        // We assume a specrev of 1 if none can be found.
821        Ok((version_str, 1.into()))
822    }
823}
824
825fn is_known_dev_version_str(text: &str) -> bool {
826    matches!(text, "dev" | "scm")
827}
828
829/// Parses a Version from a string, automatically supplying any missing details (i.e. missing
830/// minor/patch sections).
831fn parse_version(s: &str) -> Result<Version, Error> {
832    let version_str = correct_version_string(s);
833    Version::parse(&version_str)
834}
835
836/// Transform LuaRocks constraints into constraints that can be parsed by the semver crate.
837fn parse_version_req(version_constraints: &str) -> Result<VersionReq, Error> {
838    let unescaped = decode_html_entities(version_constraints)
839        .to_string()
840        .as_str()
841        .to_owned();
842    let transformed = match unescaped {
843        s if s.starts_with("~>") => parse_pessimistic_version_constraint(s)?,
844        s if s.starts_with("@") => format!("={}", &s[1..]),
845        // The semver crate only understands "= version", unlike luarocks which understands "== version".
846        s if s.starts_with("==") => s[1..].to_string(),
847        s if s // semver parses no constraint prefix as ^ (equivalent to ~>)
848            .find(|c: char| c.is_alphanumeric())
849            .is_some_and(|idx| idx == 0) =>
850        {
851            format!("={}", s)
852        }
853        s => s,
854    };
855
856    let version_req = VersionReq::parse(&transformed)?;
857    Ok(version_req)
858}
859
860fn parse_pessimistic_version_constraint(version_constraint: String) -> Result<String, Error> {
861    // pessimistic operator
862    let min_version_str = &version_constraint[2..].trim();
863    let min_version = Version::parse(&correct_version_string(min_version_str))?;
864
865    let max_version = match min_version_str.matches('.').count() {
866        0 => Version {
867            major: &min_version.major + 1,
868            ..min_version.clone()
869        },
870        1 => Version {
871            minor: &min_version.minor + 1,
872            ..min_version.clone()
873        },
874        _ => Version {
875            patch: &min_version.patch + 1,
876            ..min_version.clone()
877        },
878    };
879
880    Ok(format!(">= {min_version}, < {max_version}"))
881}
882
883/// ┻━┻ ︵╰(°□°╰) Luarocks allows for an arbitrary number of version digits
884/// This function attempts to correct a non-semver compliant version string,
885/// by swapping the third '.' out with a '-', converting the non-semver
886/// compliant digits to a pre-release identifier.
887fn correct_version_string(version: &str) -> String {
888    let version = append_minor_patch_if_missing(version);
889    correct_prerelease_version_string(&version)
890}
891
892fn correct_prerelease_version_string(version: &str) -> String {
893    if version.contains('-') {
894        return version.to_string();
895    }
896    let parts: Vec<&str> = version.split('.').collect();
897    if parts.len() > 3 {
898        format!(
899            "{}.{}.{}-{}",
900            parts[0],
901            parts[1],
902            parts[2],
903            parts[3..].join(".")
904        )
905    } else {
906        version.to_string()
907    }
908}
909
910/// Recursively append .0 until the version string has a minor or patch version
911fn append_minor_patch_if_missing(version: &str) -> String {
912    if version.matches('.').count() < 2 {
913        append_minor_patch_if_missing(&format!("{version}.0"))
914    } else {
915        version.to_string()
916    }
917}
918
919#[cfg(test)]
920mod tests {
921    use super::*;
922
923    #[tokio::test]
924    async fn parse_semver_version() {
925        assert_eq!(
926            PackageVersion::parse("1-1").unwrap(),
927            PackageVersion::SemVer(SemVer {
928                version: "1.0.0".parse().unwrap(),
929                component_count: 1,
930                specrev: 1.into(),
931            })
932        );
933        assert_eq!(
934            PackageVersion::parse("1.0-1").unwrap(),
935            PackageVersion::SemVer(SemVer {
936                version: "1.0.0".parse().unwrap(),
937                component_count: 2,
938                specrev: 1.into(),
939            })
940        );
941        assert_eq!(
942            PackageVersion::parse("1.0.0-1").unwrap(),
943            PackageVersion::SemVer(SemVer {
944                version: "1.0.0".parse().unwrap(),
945                component_count: 3,
946                specrev: 1.into()
947            })
948        );
949        assert_eq!(
950            PackageVersion::parse("1.0.0-1").unwrap(),
951            PackageVersion::SemVer(SemVer {
952                version: "1.0.0".parse().unwrap(),
953                component_count: 3,
954                specrev: 1.into()
955            })
956        );
957        assert_eq!(
958            PackageVersion::parse("1.0.0-10-1").unwrap(),
959            PackageVersion::SemVer(SemVer {
960                version: "1.0.0-10".parse().unwrap(),
961                component_count: 3,
962                specrev: 1.into()
963            })
964        );
965        assert_eq!(
966            PackageVersion::parse("1.0.0.10-1").unwrap(),
967            PackageVersion::SemVer(SemVer {
968                version: "1.0.0-10".parse().unwrap(),
969                component_count: 3,
970                specrev: 1.into()
971            })
972        );
973        assert_eq!(
974            PackageVersion::parse("1.0.0.10.0-1").unwrap(),
975            PackageVersion::SemVer(SemVer {
976                version: "1.0.0-10.0".parse().unwrap(),
977                component_count: 3,
978                specrev: 1.into()
979            })
980        );
981    }
982
983    #[test]
984    fn to_pessimistic_version_req() {
985        for (version, req, expected) in [
986            ("1.5.6-2", "~> 1", ">=1.0.0, <2.0.0"),
987            ("0.5.6-2", "~> 0.5", ">=0.5.0, <0.6.0"),
988            ("0.0.6-2", "~> 0.0.6", ">=0.0.6, <0.0.7"),
989        ] {
990            let pessimistic = PackageVersion::parse(version)
991                .unwrap()
992                .to_pessimistic_version_req()
993                .unwrap();
994            assert_eq!(pessimistic, req);
995            let req = PackageVersionReq::parse(&pessimistic).unwrap();
996            assert_eq!(req.to_string(), expected);
997        }
998
999        let req = PackageVersionReq::parse("~> 1").unwrap();
1000        assert!(req.matches(&PackageVersion::parse("1.9.0-2").unwrap()));
1001        assert!(!req.matches(&PackageVersion::parse("2.0.0-1").unwrap()));
1002
1003        let req = PackageVersionReq::parse("~> 0.5").unwrap();
1004        assert!(req.matches(&PackageVersion::parse("0.5.9-1").unwrap()));
1005        assert!(!req.matches(&PackageVersion::parse("0.6.0-1").unwrap()));
1006
1007        assert_eq!(
1008            PackageVersion::parse("scm")
1009                .unwrap()
1010                .to_pessimistic_version_req(),
1011            None
1012        );
1013    }
1014
1015    #[test]
1016    fn four_component_versions_sort_after_base_version() {
1017        let base = PackageVersion::parse("2.1.0-1").unwrap();
1018        let extended = PackageVersion::parse("2.1.0.10-1").unwrap();
1019        assert!(extended > base);
1020        assert!(base < extended);
1021        assert_eq!(
1022            PackageVersion::parse("2.1.0.10-1").unwrap(),
1023            PackageVersion::parse("2.1.0.10-1").unwrap()
1024        );
1025    }
1026
1027    #[test]
1028    fn four_component_version_satisfies_greater_eq_req() {
1029        let req = PackageVersionReq::parse(">= 2.1.0").unwrap();
1030        assert!(req.matches(&PackageVersion::parse("2.1.0.10-1").unwrap()));
1031        assert!(req.matches(&PackageVersion::parse("2.1.0-1").unwrap()));
1032        assert!(!req.matches(&PackageVersion::parse("2.0.9-1").unwrap()));
1033    }
1034
1035    #[test]
1036    fn parse_semver_prerelease() {
1037        let prerelease = PackageVersion::parse("1.2.3-alpha.1").unwrap();
1038        assert_eq!(
1039            prerelease,
1040            PackageVersion::SemVer(SemVer {
1041                version: "1.2.3-alpha.1".parse().unwrap(),
1042                component_count: 3,
1043                specrev: 1.into()
1044            })
1045        );
1046        assert_eq!(prerelease.to_string(), "1.2.3-alpha.1");
1047        assert_eq!(
1048            PackageVersion::parse("1.2.3-1").unwrap().to_string(),
1049            "1.2.3-1"
1050        );
1051        assert_eq!(
1052            PackageVersion::parse(&prerelease.to_string()).unwrap(),
1053            prerelease
1054        );
1055    }
1056
1057    #[test]
1058    fn prerelease_req_matches() {
1059        let req = PackageVersionReq::parse("=1.2.3-alpha.1").unwrap();
1060        assert!(req.matches(&PackageVersion::parse("1.2.3-alpha.1").unwrap()));
1061        assert!(!req.matches(&PackageVersion::parse("1.2.3-alpha.2").unwrap()));
1062    }
1063
1064    #[tokio::test]
1065    async fn parse_dev_version() {
1066        assert_eq!(
1067            PackageVersion::parse("dev-1").unwrap(),
1068            PackageVersion::DevVer(DevVer {
1069                modrev: DevVersion::Dev,
1070                specrev: 1.into()
1071            })
1072        );
1073        assert_eq!(
1074            PackageVersion::parse("scm-1").unwrap(),
1075            PackageVersion::DevVer(DevVer {
1076                modrev: DevVersion::Scm,
1077                specrev: 1.into()
1078            })
1079        );
1080        assert_eq!(
1081            PackageVersion::parse("git-1").unwrap(),
1082            PackageVersion::StringVer(StringVer {
1083                modrev: "git".into(),
1084                specrev: 1.into()
1085            })
1086        );
1087        assert_eq!(
1088            PackageVersion::parse("scm-1").unwrap(),
1089            PackageVersion::DevVer(DevVer {
1090                modrev: DevVersion::Scm,
1091                specrev: 1.into()
1092            })
1093        );
1094    }
1095
1096    #[tokio::test]
1097    async fn parse_dev_version_req() {
1098        assert_eq!(
1099            PackageVersionReq::parse("dev").unwrap(),
1100            PackageVersionReq::DevVer(DevVersion::Dev)
1101        );
1102        assert_eq!(
1103            PackageVersionReq::parse("scm").unwrap(),
1104            PackageVersionReq::DevVer(DevVersion::Scm)
1105        );
1106        assert_eq!(
1107            PackageVersionReq::parse("git").unwrap(),
1108            PackageVersionReq::StringVer("git".into())
1109        );
1110        assert_eq!(
1111            PackageVersionReq::parse("==dev").unwrap(),
1112            PackageVersionReq::DevVer(DevVersion::Dev)
1113        );
1114        assert_eq!(
1115            PackageVersionReq::parse("==git").unwrap(),
1116            PackageVersionReq::StringVer("git".into())
1117        );
1118        assert_eq!(
1119            PackageVersionReq::parse("== dev").unwrap(),
1120            PackageVersionReq::DevVer(DevVersion::Dev)
1121        );
1122        assert_eq!(
1123            PackageVersionReq::parse("== scm").unwrap(),
1124            PackageVersionReq::DevVer(DevVersion::Scm)
1125        );
1126        assert_eq!(
1127            PackageVersionReq::parse("@dev").unwrap(),
1128            PackageVersionReq::DevVer(DevVersion::Dev)
1129        );
1130        assert_eq!(
1131            PackageVersionReq::parse("@git").unwrap(),
1132            PackageVersionReq::StringVer("git".into())
1133        );
1134        assert_eq!(
1135            PackageVersionReq::parse("@ dev").unwrap(),
1136            PackageVersionReq::DevVer(DevVersion::Dev)
1137        );
1138        assert_eq!(
1139            PackageVersionReq::parse("@ scm").unwrap(),
1140            PackageVersionReq::DevVer(DevVersion::Scm)
1141        );
1142        assert_eq!(
1143            PackageVersionReq::parse(">1-1,<1.2-2").unwrap(),
1144            PackageVersionReq::SemVer(">1,<1.2".parse().unwrap())
1145        );
1146        assert_eq!(
1147            PackageVersionReq::parse("> 1-1, < 1.2-2").unwrap(),
1148            PackageVersionReq::SemVer("> 1, < 1.2".parse().unwrap())
1149        );
1150        assert_eq!(
1151            PackageVersionReq::parse("> 2.1.0.10, < 2.1.1").unwrap(),
1152            PackageVersionReq::SemVer("> 2.1.0-10, < 2.1.1".parse().unwrap())
1153        );
1154    }
1155
1156    #[tokio::test]
1157    async fn package_version_req_semver_roundtrips() {
1158        let req = PackageVersionReq::parse("==0.7.1").unwrap();
1159        assert_eq!(req.to_string(), "==0.7.1");
1160
1161        let req = PackageVersionReq::parse("0.7.1").unwrap();
1162        assert_eq!(req.to_string(), "==0.7.1");
1163
1164        let req = PackageVersionReq::parse(">=0.7.1").unwrap();
1165        assert_eq!(req.to_string(), ">=0.7.1");
1166
1167        let req = PackageVersionReq::parse(">0.7.1").unwrap();
1168        assert_eq!(req.to_string(), ">0.7.1");
1169
1170        let req = PackageVersionReq::parse("<0.7.1").unwrap();
1171        assert_eq!(req.to_string(), "<0.7.1");
1172
1173        let req = PackageVersionReq::parse("~> 0.7.1").unwrap();
1174        assert_eq!(req.to_string(), ">=0.7.1, <0.7.2");
1175    }
1176
1177    #[tokio::test]
1178    async fn package_version_req_devver_roundtrips() {
1179        let req = PackageVersionReq::parse("==scm").unwrap();
1180        assert_eq!(req.to_string(), "==scm");
1181
1182        let req = PackageVersionReq::parse("@scm").unwrap();
1183        assert_eq!(req.to_string(), "==scm");
1184
1185        let req = PackageVersionReq::parse("scm").unwrap();
1186        assert_eq!(req.to_string(), "==scm");
1187
1188        let req = PackageVersionReq::parse("==a144124839f027a2d0a95791936c478d047126fc").unwrap();
1189        assert_eq!(
1190            req.to_string(),
1191            "==a144124839f027a2d0a95791936c478d047126fc"
1192        );
1193    }
1194}
lux_lib/package/version.rs

lux_lib/package/
version.rs
