use std::{fs, path::Path};
pub fn to_pascal_case(s: &str) -> String {
s.split(['_', '-'])
.filter(|w| !w.is_empty())
.map(|word| {
let mut chars = word.chars();
match chars.next() {
None => String::new(),
Some(first) => first.to_uppercase().to_string() + chars.as_str(),
}
})
.collect()
}
pub fn pascal_to_snake(s: &str) -> String {
let mut out = String::new();
for (i, ch) in s.chars().enumerate() {
if ch.is_uppercase() && i > 0 {
out.push('_');
}
out.extend(ch.to_lowercase());
}
out
}
pub fn snake_to_kebab(snake: &str) -> String {
snake.replace('_', "-")
}
pub fn snake_to_camel(snake: &str) -> String {
let pascal = to_pascal_case(snake);
let mut chars = pascal.chars();
match chars.next() {
None => String::new(),
Some(first) => first.to_lowercase().to_string() + chars.as_str(),
}
}
pub fn snake_to_words(snake: &str) -> String {
snake
.split('_')
.filter(|w| !w.is_empty())
.collect::<Vec<_>>()
.join(" ")
}
pub fn capitalize(s: &str) -> String {
let mut chars = s.chars();
match chars.next() {
None => String::new(),
Some(first) => first.to_uppercase().to_string() + chars.as_str(),
}
}
const INVARIABLE: &[&str] = &[
"analisis",
"crisis",
"tesis",
"sintesis",
"hipotesis",
"dosis",
"lunes",
"martes",
"miercoles",
"jueves",
"viernes",
"virus",
"torax",
"fenix",
];
const VOWELS: [char; 5] = ['a', 'e', 'i', 'o', 'u'];
pub fn pluralize(snake: &str) -> String {
let (word, tail) = match snake.find('_') {
Some(i) => snake.split_at(i),
None => (snake, ""),
};
let plural = if INVARIABLE.contains(&word) {
word.to_string()
} else if word.ends_with(VOWELS) {
format!("{word}s")
} else if let Some(stem) = word.strip_suffix('z') {
format!("{stem}ces")
} else {
format!("{word}es")
};
format!("{plural}{tail}")
}
pub fn entity_ctx(pascal: &str, snake: &str) -> tera::Context {
let plural = pluralize(snake);
let mut ctx = tera::Context::new();
ctx.insert("pascal", pascal);
ctx.insert("snake", snake);
ctx.insert("plural_pascal", &to_pascal_case(&plural));
ctx.insert("plural", &plural);
ctx
}
pub fn crud_verb(action: &str) -> &'static str {
match action {
"create" => "crear",
"get" => "obtener",
"list" => "listar",
"update" => "actualizar",
"delete" => "borrar",
_ => unreachable!("unknown CRUD action {action}"),
}
}
pub fn crud_use_case(action: &str, snake: &str) -> String {
if action == "list" {
format!("{}_{}", crud_verb(action), pluralize(snake))
} else {
format!("{}_{snake}", crud_verb(action))
}
}
pub fn crud_use_cases(snake: &str) -> Vec<String> {
["create", "get", "list", "update", "delete"]
.iter()
.map(|action| crud_use_case(action, snake))
.collect()
}
pub fn is_crud_entity(snake: &str, use_cases: &[String]) -> bool {
crud_use_cases(snake)
.iter()
.all(|uc| use_cases.contains(uc))
}
pub fn crud_events(snake: &str) -> Vec<(String, String)> {
["creado", "actualizado", "borrado"]
.iter()
.map(|verb| (to_pascal_case(verb), format!("{snake}_{verb}")))
.collect()
}
pub fn event_variant(snake: &str, event_type: &str) -> String {
let unprefixed = event_type
.strip_prefix(snake)
.and_then(|rest| rest.strip_prefix('_'))
.filter(|rest| !rest.is_empty())
.unwrap_or(event_type);
to_pascal_case(unprefixed)
}
pub fn write_file(path: &Path, content: &str) -> Result<(), std::io::Error> {
let with_path = |e: std::io::Error| {
std::io::Error::new(e.kind(), format!("cannot write {}: {e}", path.display()))
};
if let Some(parent) = path.parent() {
fs::create_dir_all(parent).map_err(with_path)?;
}
fs::write(path, content).map_err(with_path)
}