1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//! Utility types for the package definitions
//!
//! These types exist only for the purpose of strong typing
//! and cannot do anything special.
use std::result::Result as RResult;
use std::ops::Deref;
use serde::Deserialize;
use anyhow::Result;
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(transparent)]
pub struct PackageName(String);
impl Deref for PackageName {
type Target = String;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<String> for PackageName {
fn from(s: String) -> Self {
PackageName(s)
}
}
impl std::fmt::Display for PackageName {
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
self.0.fmt(f)
}
}
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(transparent)]
pub struct PackageVersion(String);
impl From<String> for PackageVersion {
fn from(s: String) -> Self {
PackageVersion(s)
}
}
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(transparent)]
pub struct SystemDependency(String);
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(transparent)]
pub struct BuildDependency(String);
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(transparent)]
pub struct Dependency(String);
impl std::convert::TryInto<(PackageName, PackageVersionConstraint)> for Dependency {
type Error = anyhow::Error;
fn try_into(self) -> RResult<(PackageName, PackageVersionConstraint), Self::Error> {
// TODO: Implement properly
let v: Vec<_> = self.0.split("-").collect();
Ok((PackageName::from(String::from(v[0])), PackageVersionConstraint::Any))
}
}
#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
#[serde(transparent)]
pub struct HashValue(String);
/// A type which can be used to express a package version constraint
// TODO: Remove allow(unused)
#[derive(Debug, Eq, PartialEq)]
#[allow(unused)]
pub enum PackageVersionConstraint {
Any,
Latest,
LowerAs(PackageVersion),
HigherAs(PackageVersion),
InRange(PackageVersion, PackageVersion),
Exact(PackageVersion),
}
impl PackageVersionConstraint {
pub fn matches(&self, v: &PackageVersion) -> Result<PackageVersionMatch> {
match self {
PackageVersionConstraint::Any => Ok(PackageVersionMatch::True),
PackageVersionConstraint::Latest => Ok(PackageVersionMatch::Undecided),
PackageVersionConstraint::LowerAs(_vers) => Ok(PackageVersionMatch::Undecided), // TODO: Fix implementation
PackageVersionConstraint::HigherAs(_vers) => Ok(PackageVersionMatch::Undecided), // TODO: Fix implementation
PackageVersionConstraint::InRange(_vers1, _vers2) => Ok(PackageVersionMatch::Undecided), // TODO: Fix implementation
PackageVersionConstraint::Exact(vers) => Ok(PackageVersionMatch::from(*v == *vers)),
}
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum PackageVersionMatch {
True,
False,
Undecided,
}
impl PackageVersionMatch {
// TODO: Remove allow(unused)
#[allow(unused)]
pub fn is_true(&self) -> bool {
*self == PackageVersionMatch::True
}
pub fn is_false(&self) -> bool {
*self == PackageVersionMatch::False
}
// TODO: Remove allow(unused)
#[allow(unused)]
pub fn is_undecided(&self) -> bool {
*self == PackageVersionMatch::Undecided
}
}
impl From<bool> for PackageVersionMatch {
fn from(b: bool) -> Self {
if b {
PackageVersionMatch::True
} else {
PackageVersionMatch::False
}
}
}
|
