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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
use anyhow::{anyhow, bail, Context, Error, Result};
use std::{
cmp::Ordering,
fs::{self, read_dir, OpenOptions},
io::Read,
path::{Path, PathBuf},
};
use crate::{
cargo_toml::{append_bins, bins_start_end_ind},
info_file::{ExerciseInfo, InfoFile},
CURRENT_FORMAT_VERSION, DEBUG_PROFILE,
};
fn forbidden_char(input: &str) -> Option<char> {
input.chars().find(|c| *c != '_' && !c.is_alphanumeric())
}
fn check_info_file_exercises(info_file: &InfoFile) -> Result<hashbrown::HashSet<PathBuf>> {
let mut names = hashbrown::HashSet::with_capacity(info_file.exercises.len());
let mut paths = hashbrown::HashSet::with_capacity(info_file.exercises.len());
let mut file_buf = String::with_capacity(1 << 14);
for exercise_info in &info_file.exercises {
if exercise_info.name.is_empty() {
bail!("Found an empty exercise name in `info.toml`");
}
if let Some(c) = forbidden_char(&exercise_info.name) {
bail!(
"Char `{c}` in the exercise name `{}` is not allowed",
exercise_info.name,
);
}
if let Some(dir) = &exercise_info.dir {
if dir.is_empty() {
bail!(
"The exercise `{}` has an empty dir name in `info.toml`",
exercise_info.name,
);
}
if let Some(c) = forbidden_char(dir) {
bail!("Char `{c}` in the exercise dir `{dir}` is not allowed");
}
}
if exercise_info.hint.trim().is_empty() {
bail!("The exercise `{}` has an empty hint. Please provide a hint or at least tell the user why a hint isn't needed for this exercise", exercise_info.name);
}
if !names.insert(exercise_info.name.as_str()) {
bail!(
"The exercise name `{}` is duplicated. Exercise names must all be unique",
exercise_info.name,
);
}
let path = exercise_info.path();
OpenOptions::new()
.read(true)
.open(&path)
.with_context(|| format!("Failed to open the file {path}"))?
.read_to_string(&mut file_buf)
.with_context(|| format!("Failed to read the file {path}"))?;
if !file_buf.contains("fn main()") {
bail!("The `main` function is missing in the file `{path}`.\nCreate at least an empty `main` function to avoid language server errors");
}
file_buf.clear();
paths.insert(PathBuf::from(path));
}
Ok(paths)
}
fn unexpected_file(path: &Path) -> Error {
anyhow!("Found the file `{}`. Only `README.md` and Rust files related to an exercise in `info.toml` are allowed in the `exercises` directory", path.display())
}
fn check_exercise_dir_files(info_file_paths: &hashbrown::HashSet<PathBuf>) -> Result<()> {
for entry in read_dir("exercises").context("Failed to open the `exercises` directory")? {
let entry = entry.context("Failed to read the `exercises` directory")?;
if entry.file_type().unwrap().is_file() {
let path = entry.path();
let file_name = path.file_name().unwrap();
if file_name == "README.md" {
continue;
}
if !info_file_paths.contains(&path) {
return Err(unexpected_file(&path));
}
continue;
}
let dir_path = entry.path();
for entry in read_dir(&dir_path)
.with_context(|| format!("Failed to open the directory {}", dir_path.display()))?
{
let entry = entry
.with_context(|| format!("Failed to read the directory {}", dir_path.display()))?;
let path = entry.path();
if !entry.file_type().unwrap().is_file() {
bail!("Found `{}` but expected only files. Only one level of exercise nesting is allowed", path.display());
}
let file_name = path.file_name().unwrap();
if file_name == "README.md" {
continue;
}
if !info_file_paths.contains(&path) {
return Err(unexpected_file(&path));
}
}
}
Ok(())
}
fn check_exercises(info_file: &InfoFile) -> Result<()> {
match info_file.format_version.cmp(&CURRENT_FORMAT_VERSION) {
Ordering::Less => bail!("`format_version` < {CURRENT_FORMAT_VERSION} (supported version)\nPlease migrate to the latest format version"),
Ordering::Greater => bail!("`format_version` > {CURRENT_FORMAT_VERSION} (supported version)\nTry updating the Rustlings program"),
Ordering::Equal => (),
}
let info_file_paths = check_info_file_exercises(info_file)?;
check_exercise_dir_files(&info_file_paths)?;
Ok(())
}
fn check_cargo_toml(
exercise_infos: &[ExerciseInfo],
current_cargo_toml: &str,
exercise_path_prefix: &[u8],
) -> Result<()> {
let (bins_start_ind, bins_end_ind) = bins_start_end_ind(current_cargo_toml)?;
let old_bins = ¤t_cargo_toml.as_bytes()[bins_start_ind..bins_end_ind];
let mut new_bins = Vec::with_capacity(1 << 13);
append_bins(&mut new_bins, exercise_infos, exercise_path_prefix);
if old_bins != new_bins {
if DEBUG_PROFILE {
bail!("The file `dev/Cargo.toml` is outdated. Please run `cargo run -- dev update` to update it");
}
bail!("The file `Cargo.toml` is outdated. Please run `rustlings dev update` to update it");
}
Ok(())
}
pub fn check() -> Result<()> {
let info_file = InfoFile::parse()?;
check_exercises(&info_file)?;
if DEBUG_PROFILE {
check_cargo_toml(
&info_file.exercises,
include_str!("../../dev-Cargo.toml"),
b"../",
)?;
} else {
let current_cargo_toml =
fs::read_to_string("Cargo.toml").context("Failed to read the file `Cargo.toml`")?;
check_cargo_toml(&info_file.exercises, ¤t_cargo_toml, b"")?;
}
println!("\nEverything looks fine!");
Ok(())
}
|
