Решение на Форматиране на импорти от Михаил Цанков
Резултати
- 20 точки от тестове
- 0 бонус точки
- 20 точки общо
- 20 успешни тест(а)
- 0 неуспешни тест(а)
Код
pub struct Import<'a>(pub &'a [&'a str]);
#[derive(PartialEq)]
pub enum Order {
Original,
Sorted,
}
pub fn format_flat(imports: &[Import], order: Order) -> Vec<String> {
let mut result = Vec::new();
let import_paths: Vec<String> = imports.iter().map(|import| import.0.join("::")).collect();
for path in import_paths {
if result.contains(&path) {
continue;
}
result.push(path);
}
if order == Order::Sorted {
result.sort();
}
result
}
struct ImportTree {
value: Option<String>,
children: Vec<ImportTree>,
has_self: bool,
}
fn build_tree(imports: &[Import]) -> ImportTree {
let mut tree = ImportTree {
value: None,
children: Vec::new(),
has_self: false,
};
for import in imports {
let mut current = &mut tree;
for (i, part) in import.0.iter().enumerate() {
if let Some(index) = current
.children
.iter()
.position(|c| c.value.as_deref() == Some(*part))
{
current = &mut current.children[index];
} else {
current.children.push(ImportTree {
value: Some(part.to_string()),
children: Vec::new(),
has_self: false,
});
let last_index = current.children.len() - 1;
current = &mut current.children[last_index];
}
if i == import.0.len() - 1 {
current.has_self = true;
}
}
}
fn add_self_children(node: &mut ImportTree) {
for child in &mut node.children {
add_self_children(child);
}
if node.has_self && !node.children.is_empty() {
if !node
.children
.iter()
.any(|c| c.value.as_deref() == Some("self"))
{
node.children.insert(
0,
ImportTree {
value: Some("self".to_string()),
children: Vec::new(),
has_self: false,
},
);
}
}
}
add_self_children(&mut tree);
tree
}
fn sort_tree(tree: &mut ImportTree) {
tree.children.sort_by(|a, b| {
if a.value.is_none() || b.value.is_none() {
return std::cmp::Ordering::Equal;
}
if a.value.as_ref().unwrap() == "self" {
return std::cmp::Ordering::Less;
}
if b.value.as_ref().unwrap() == "self" {
return std::cmp::Ordering::Greater;
}
a.value.as_ref().unwrap().cmp(b.value.as_ref().unwrap())
});
for child in &mut tree.children {
sort_tree(child);
}
}
pub fn format_nested(imports: &[Import], order: Order) -> Vec<String> {
let tree = build_tree(imports);
fn build_nested_imports(tree: &ImportTree) -> Vec<String> {
if tree.children.is_empty() {
return tree
.value
.as_ref()
.map(|value| vec![value.to_string()])
.unwrap_or_else(Vec::new);
}
let mut nested_imports = Vec::new();
let mut child_imports = Vec::new();
for child in &tree.children {
let child_imports_vec = build_nested_imports(child);
child_imports.extend(child_imports_vec);
}
if let Some(value) = &tree.value {
let child_imports_str = child_imports.join(",\n");
let child_imports_str = child_imports_str
.lines()
.map(|line| format!(" {}", line))
.collect::<Vec<String>>()
.join("\n");
let child_imports_str = format!("{},", child_imports_str);
nested_imports.push(format!("{}::{{\n{}\n}}", value, child_imports_str));
} else {
for import in child_imports {
nested_imports.push(format!("{}\n", import));
}
}
nested_imports
}
if order == Order::Original {
return build_nested_imports(&tree);
}
let mut tree = tree;
sort_tree(&mut tree);
build_nested_imports(&tree)
}
Лог от изпълнението
Compiling solution v0.1.0 (/tmp/d20241203-1739405-1jtpyig/solution)
Finished test [unoptimized + debuginfo] target(s) in 1.22s
Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)
running 20 tests
test solution_test::test_flat_empty ... ok
test solution_test::test_flat_multi_crate ... ok
test solution_test::test_flat_original ... ok
test solution_test::test_flat_original_duplicates ... ok
test solution_test::test_flat_sorted ... ok
test solution_test::test_flat_sorted_duplicates ... ok
test solution_test::test_nested_basic ... ok
test solution_test::test_nested_deep ... ok
test solution_test::test_nested_empty ... ok
test solution_test::test_nested_only_crate ... ok
test solution_test::test_nested_original_2 ... ok
test solution_test::test_nested_original ... ok
test solution_test::test_nested_original_multi_crate ... ok
test solution_test::test_nested_original_duplicates ... ok
test solution_test::test_nested_sorted ... ok
test solution_test::test_nested_original_self ... ok
test solution_test::test_nested_sorted_2 ... ok
test solution_test::test_nested_sorted_duplicates ... ok
test solution_test::test_nested_sorted_multi_crate ... ok
test solution_test::test_nested_sorted_self ... ok
test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s