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
|
pub enum Action {
Add { repo: String },
Update,
Upgrade { packages: Vec<String> },
Autoremove,
Remove { packages: Vec<String> },
List,
Search { term: String },
Clean { packages: Vec<String> },
Show { package: String },
}
impl Action {
pub fn parse(args: &[String]) -> Result<Self, String> {
let cmd = args.get(1)
.ok_or("no command provided")?
.as_str();
match cmd {
"add" => {
let repo = args.get(2)
.ok_or("add requires <repo>")?
.clone();
Ok(Action::Add { repo })
}
"update" => Ok(Action::Update),
"upgrade" => {
let packages = args[2..].to_vec();
Ok(Action::Upgrade { packages })
}
"autoremove" => Ok(Action::Autoremove),
"remove" => {
let packages = args[2..].to_vec();
if packages.is_empty() {
Err("remove requires a package".into())
} else {
Ok(Action::Remove { packages })
}
}
"list" => Ok(Action::List),
"search" => {
let term = args.get(2)
.ok_or("search requires <term>")?
.clone();
Ok(Action::Search { term })
}
"clean" => {
let packages = args[2..].to_vec();
Ok(Action::Clean { packages })
}
"show" => {
let package = args.get(2)
.ok_or("show requires <package>")?
.clone();
Ok(Action::Show { package })
}
_ => Err(format!("unknown command {}", cmd)),
}
}
pub fn execute(self) {
match self {
Action::Add { repo } => add(repo),
Action::Update => update(),
Action::Upgrade { packages } => upgrade(packages),
Action::Autoremove => autoremove(),
Action::Remove { packages } => remove(packages),
Action::List => list(),
Action::Search { term } => search(term),
Action::Clean { packages } => clean(packages),
Action::Show { package } => show(package),
}
}
}
fn add(repo: String) {
println!("adding {}", repo);
}
fn update() {
println!("updating");
}
fn upgrade(packages: Vec<String>) {
for (_, p) in packages.iter().enumerate() {
println!("upgrading: {}", p);
}
}
fn autoremove() {
println!("autoremoving");
}
fn remove(packages: Vec<String>) {
for (_, p) in packages.iter().enumerate() {
println!("removing: {}", p);
}
}
fn list() {
println!("listing");
}
fn search(term: String) {
println!("searching: {}", term);
}
fn clean(packages: Vec<String>) {
for (_, p) in packages.iter().enumerate() {
println!("cleaning: {}", p);
}
}
fn show(package: String) {
println!("showing {}", package);
}
|
