Решение на Форматиране на импорти от Владимир Стоянов

Обратно към всички решения

Към профила на Владимир Стоянов

Код

use std::collections::HashSet;

pub struct Import<'a>(pub &'a [&'a str]);

pub fn to_string(import: &Import) -> String {

return import.0.join("::");

}

pub enum Order {

Original,

Sorted,

}

pub fn format_flat(imports: &[Import], order: Order) -> Vec<String> {

let mut imports_string = HashSet::new();

for import in imports {

imports_string.insert(to_string(import));

}

for x in &imports_string {

println!("{x:?}");

}

match order {

Order::Sorted => {

let mut unsorted: Vec<String> = imports_string.into_iter().collect::<Vec<String>>();

unsorted.sort();

unsorted

}

Order::Original => {

let mut original: Vec<String> = Vec::new();

for import in imports {

let curr_string = to_string(import);

if imports_string.contains(&curr_string) {

imports_string.remove(&curr_string);

original.push(curr_string);

}

}

original

}

}

}

struct ImportTree {

crate_name: String,

nodes: Vec<ImportTree>,

is_module: bool,

}

impl ImportTree {

pub fn new(name: String) -> ImportTree {

ImportTree {

crate_name: name,

nodes: Vec::new(),

is_module: false,

}

}

pub fn insert(&mut self, crates: &[&str]) {

if crates.is_empty() {

self.is_module = true;

return;

}

let root_crate = crates[0];

let remain = &crates[1..];

if let Some(existing_node) = self

.nodes

.iter_mut()

.find(|node| node.crate_name == root_crate)

{

existing_node.insert(remain);

} else {

let mut new_node = ImportTree::new(root_crate.to_string());

new_node.insert(remain);

self.nodes.push(new_node);

}

}

fn format(&mut self, sorted: bool, indent_level: usize) -> String {

let mut res = String::new();

let to_push: String;

let curr_crate_name = self.crate_name.clone();

let indent = " ".repeat(indent_level);

let next_indent = " ".repeat(indent_level + 1);

if self.nodes.is_empty() {

// leaf node

to_push = format!("{indent}{curr_crate_name},\n");

} else {

// has leaves

to_push = format!("{indent}{curr_crate_name}::{{\n");

}

res.push_str(&to_push[..]);

if sorted {

self.nodes.sort_by(|x, y| x.crate_name.cmp(&y.crate_name));

}

if !self.nodes.is_empty() && self.is_module {

res.push_str(&format!("{next_indent}self,\n"));

}

for node in &mut self.nodes {

res.push_str(&node.format(sorted, indent_level + 1)[..]);

}

if !self.nodes.is_empty() {

if indent_level != 0 {

res.push_str(&format!("{indent}}},\n"));

} else {

res.push_str("}\n");

}

}

res

}

}

pub fn format_nested(imports: &[Import], order: Order) -> Vec<String> {

let mut root_trees: Vec<ImportTree> = Vec::new();

for import in imports {

let root_crate = import.0[0];

let remain = &import.0[1..];

if let Some(existing_tree) = root_trees

.iter_mut()

.find(|tree| tree.crate_name == root_crate)

{

existing_tree.insert(remain);

} else {

let mut new_tree = ImportTree::new(root_crate.to_string());

new_tree.insert(remain);

root_trees.push(new_tree);

}

}

match order {

Order::Sorted => {

let mut res: Vec<String> = root_trees

.iter_mut()

.map(|tree| tree.format(true, 0))

.collect();

res.sort();

res

}

Order::Original => {

return root_trees

.iter_mut()

.map(|tree| tree.format(false, 0))

.collect()

}

}

}

fn main() {

let imports = &[

Import(&["my_crate", "b", "B2"]),

Import(&["my_crate", "a"]),

Import(&["my_crate", "b", "B1"]),

Import(&["my_crate", "c"]),

Import(&["my_crate", "a"]),

Import(&["foo", "b", "B2"]),

Import(&["foo", "a", "A1"]),

Import(&["foo", "b", "B1"]),

Import(&["foo", "b"]),

];

println!("Original");

for string in format_nested(imports, Order::Original) {

println!("{}", string);

}

println!("Sorted");

for string in format_nested(imports, Order::Sorted) {

println!("{}", string);

}

let imports = &[Import(&["foo"]), Import(&["bar"]), Import(&["baz"])];

for string in format_nested(imports, Order::Original) {

println!("{}", string);

}

}

#[cfg(test)]

mod test_flat {

use super::*;

#[test]

fn test_basic() {

let imports = &[

Import(&["my_crate", "a"]),

Import(&["my_crate", "b", "B1"]),

Import(&["my_crate", "b", "B2"]),

Import(&["my_crate", "c"]),

];

assert_eq!(

format_flat(imports, Order::Sorted),

&[

"my_crate::a",

"my_crate::b::B1",

"my_crate::b::B2",

"my_crate::c",

]

);

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"my_crate::{\n",

" a,\n",

" b::{\n",

" B1,\n",

" B2,\n",

" },\n",

" c,\n",

"}\n",

)]

);

}

#[test]

fn test_basics() {

let imports = &[

Import(&["my_crate", "a"]),

Import(&["my_crate", "b", "B1"]),

Import(&["my_crate", "b", "B2"]),

Import(&["my_crate", "c"]),

];

assert_eq!(

format_flat(imports, Order::Sorted),

&[

"my_crate::a",

"my_crate::b::B1",

"my_crate::b::B2",

"my_crate::c",

]

);

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"my_crate::{\n",

" a,\n",

" b::{\n",

" B1,\n",

" B2,\n",

" },\n",

" c,\n",

"}\n",

)]

);

}

#[test]

fn test_duplicates() {

let imports = &[

Import(&["std", "vec", "Vec"]),

Import(&["std", "vec", "Vec"]), // Duplicate

Import(&["std", "string", "String"]),

];

assert_eq!(

format_flat(imports, Order::Original),

&["std::vec::Vec", "std::string::String",]

);

}

#[test]

fn test_different_crates() {

let imports = &[

Import(&["tokio", "runtime", "Runtime"]),

Import(&["serde", "json", "Value"]),

Import(&["std", "vec", "Vec"]),

];

assert_eq!(

format_flat(imports, Order::Sorted),

&[

"serde::json::Value",

"std::vec::Vec",

"tokio::runtime::Runtime",

]

);

}

#[test]

fn test_original_order() {

let imports = &[

Import(&["crate", "module2", "Item2"]),

Import(&["crate", "module1", "Item1"]),

Import(&["crate", "module3", "Item3"]),

];

assert_eq!(

format_flat(imports, Order::Original),

&[

"crate::module2::Item2",

"crate::module1::Item1",

"crate::module3::Item3",

]

);

}

#[test]

fn test_mixed_lengths() {

let imports = &[

Import(&["short", "path"]),

Import(&["very", "long", "path", "here"]),

Import(&["medium", "path", "length"]),

];

assert_eq!(

format_flat(imports, Order::Sorted),

&[

"medium::path::length",

"short::path",

"very::long::path::here",

]

);

}

#[test]

fn test_empty_imports() {

let imports: &[Import] = &[];

assert_eq!(format_flat(imports, Order::Sorted), Vec::<String>::new());

}

#[test]

fn test_single_component() {

let imports = &[Import(&["crate"]), Import(&["std"])];

assert_eq!(format_flat(imports, Order::Sorted), &["crate", "std",]);

}

#[test]

fn test_complex_duplicates() {

let imports = &[

Import(&["tokio", "sync", "Mutex"]),

Import(&["std", "sync", "Mutex"]),

Import(&["tokio", "sync", "Mutex"]), // Duplicate

Import(&["std", "sync", "RwLock"]),

Import(&["std", "sync", "Mutex"]), // Duplicate

];

assert_eq!(

format_flat(imports, Order::Sorted),

&[

"std::sync::Mutex",

"std::sync::RwLock",

"tokio::sync::Mutex",

]

);

}

}

#[cfg(test)]

mod test_nested {

use super::*;

#[test]

fn test_empty_input() {

let imports: &[Import] = &[];

assert_eq!(format_nested(imports, Order::Sorted), Vec::<String>::new());

assert_eq!(

format_nested(imports, Order::Original),

Vec::<String>::new()

);

}

#[test]

fn test_single_crate_flat_imports() {

let imports = &[

Import(&["std", "string", "String"]),

Import(&["std", "vec", "Vec"]),

Import(&["std", "collections", "HashMap"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"std::{\n",

" collections::{\n",

" HashMap,\n",

" },\n",

" string::{\n",

" String,\n",

" },\n",

" vec::{\n",

" Vec,\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_multiple_crates() {

let imports = &[

Import(&["tokio", "sync", "Mutex"]),

Import(&["serde", "json"]),

Import(&["std", "vec", "Vec"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[

concat!("serde::{\n", " json,\n", "}\n",),

concat!(

"std::{\n",

" vec::{\n",

" Vec,\n",

" },\n",

"}\n",

),

concat!(

"tokio::{\n",

" sync::{\n",

" Mutex,\n",

" },\n",

"}\n",

),

]

);

}

#[test]

fn test_self_case() {

let imports = &[

Import(&["foo", "bar"]), // module import

Import(&["foo", "bar", "Baz"]), // item in module

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"foo::{\n",

" bar::{\n",

" self,\n",

" Baz,\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_original_order() {

let imports = &[

Import(&["foo", "module2", "Item2"]),

Import(&["foo", "module1", "Item1"]),

Import(&["foo", "module3", "Item3"]),

];

assert_eq!(

format_nested(imports, Order::Original),

&[concat!(

"foo::{\n",

" module2::{\n",

" Item2,\n",

" },\n",

" module1::{\n",

" Item1,\n",

" },\n",

" module3::{\n",

" Item3,\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_complex_nesting() {

let imports = &[

Import(&["deep", "a", "b", "c", "d"]),

Import(&["deep", "a", "b", "e"]),

Import(&["deep", "a", "f"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"deep::{\n",

" a::{\n",

" b::{\n",

" c::{\n",

" d,\n",

" },\n",

" e,\n",

" },\n",

" f,\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_duplicates() {

let imports = &[

Import(&["dup", "a", "A"]),

Import(&["dup", "a", "A"]), // Duplicate

Import(&["dup", "b", "B"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"dup::{\n",

" a::{\n",

" A,\n",

" },\n",

" b::{\n",

" B,\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_complex_self_multiple_levels() {

let imports = &[

Import(&["complex", "a"]), // module a

Import(&["complex", "a", "b"]), // module a::b

Import(&["complex", "a", "b", "C"]), // item a::b::C

Import(&["complex", "a", "D"]), // item a::D

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[concat!(

"complex::{\n",

" a::{\n",

" self,\n",

" D,\n", // capitals come first in lex. order

" b::{\n",

" self,\n",

" C,\n",

" },\n",

" },\n",

"}\n",

)]

);

}

#[test]

fn test_single_item_crates() {

let imports = &[

Import(&["one", "Item1"]),

Import(&["two", "Item2"]),

Import(&["three", "Item3"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[

"one::{\n Item1,\n}\n",

"three::{\n Item3,\n}\n",

"two::{\n Item2,\n}\n",

]

);

}

#[test]

fn test_bulgarian() {

let imports = &[

Import(&["едно", "Итем1"]),

Import(&["two", "Итем2"]),

Import(&["three", "Итем3"]),

];

assert_eq!(

format_nested(imports, Order::Sorted),

&[

"three::{\n Итем3,\n}\n",

"two::{\n Итем2,\n}\n",

"едно::{\n Итем1,\n}\n",

]

);

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20241203-1739405-60pdpn/solution)
warning: function `main` is never used
   --> src/lib.rs:157:4
    |
157 | fn main() {
    |    ^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: `solution` (lib) generated 1 warning
    Finished test [unoptimized + debuginfo] target(s) in 2.05s
     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_sorted ... ok
test solution_test::test_flat_original_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 ... FAILED
test solution_test::test_nested_original ... ok
test solution_test::test_nested_original_2 ... ok
test solution_test::test_nested_original_duplicates ... ok
test solution_test::test_nested_original_multi_crate ... ok
test solution_test::test_nested_original_self ... ok
test solution_test::test_nested_sorted ... 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 solution_test::test_flat_sorted_duplicates ... ok

failures:

---- solution_test::test_nested_only_crate stdout ----
thread 'solution_test::test_nested_only_crate' panicked at 'assertion failed: `(left == right)`
  left: `["my_crate,\n"]`,
 right: `["my_crate\n"]`', tests/solution_test.rs:132:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_nested_only_crate

test result: FAILED. 19 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--test solution_test`

История (2 версии и 0 коментара)