disqualified/
short_name.rs#[cfg_attr(
feature = "alloc",
doc = r#" To get a [`String`] from this type, use the [`to_string`](`alloc::string::ToString::to_string`) method."#
)]
#[derive(Clone, Copy)]
pub struct ShortName<'a>(pub &'a str);
impl ShortName<'static> {
pub fn of<T: ?Sized>() -> Self {
Self(core::any::type_name::<T>())
}
}
impl<'a> ShortName<'a> {
pub const fn original(&self) -> &'a str {
self.0
}
}
impl<'a> From<&'a str> for ShortName<'a> {
fn from(value: &'a str) -> Self {
Self(value)
}
}
impl<'a> core::fmt::Debug for ShortName<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let &ShortName(full_name) = self;
let mut index: usize = 0;
let end_of_string = full_name.len();
while index < end_of_string {
let rest_of_string = full_name.get(index..end_of_string).unwrap_or_default();
if let Some(special_character_index) = rest_of_string.find(|c: char| {
(c == ' ')
|| (c == '<')
|| (c == '>')
|| (c == '(')
|| (c == ')')
|| (c == '[')
|| (c == ']')
|| (c == ',')
|| (c == ';')
}) {
let segment_to_collapse = rest_of_string
.get(0..special_character_index)
.unwrap_or_default();
f.write_str(collapse_type_name(segment_to_collapse))?;
let special_character =
&rest_of_string[special_character_index..=special_character_index];
f.write_str(special_character)?;
match special_character {
">" | ")" | "]"
if rest_of_string[special_character_index + 1..].starts_with("::") =>
{
f.write_str("::")?;
index += special_character_index + 3;
}
_ => index += special_character_index + 1,
}
} else {
f.write_str(collapse_type_name(rest_of_string))?;
index = end_of_string;
}
}
Ok(())
}
}
impl<'a> core::fmt::Display for ShortName<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
<Self as core::fmt::Debug>::fmt(self, f)
}
}
#[inline(always)]
fn collapse_type_name(string: &str) -> &str {
let mut segments = string.rsplit("::");
let (last, second_last): (&str, Option<&str>) = (segments.next().unwrap(), segments.next());
let Some(second_last) = second_last else {
return last;
};
if second_last.starts_with(char::is_uppercase) {
let index = string.len() - last.len() - second_last.len() - 2;
&string[index..]
} else {
last
}
}
#[cfg(all(test, feature = "alloc"))]
mod name_formatting_tests {
use super::ShortName;
#[test]
fn trivial() {
assert_eq!(ShortName("test_system").to_string(), "test_system");
}
#[test]
fn path_separated() {
assert_eq!(
ShortName("bevy_prelude::make_fun_game").to_string(),
"make_fun_game"
);
}
#[test]
fn tuple_type() {
assert_eq!(
ShortName("(String, String)").to_string(),
"(String, String)"
);
}
#[test]
fn array_type() {
assert_eq!(ShortName("[i32; 3]").to_string(), "[i32; 3]");
}
#[test]
fn trivial_generics() {
assert_eq!(ShortName("a<B>").to_string(), "a<B>");
}
#[test]
fn multiple_type_parameters() {
assert_eq!(ShortName("a<B, C>").to_string(), "a<B, C>");
}
#[test]
fn enums() {
assert_eq!(ShortName("Option::None").to_string(), "Option::None");
assert_eq!(ShortName("Option::Some(2)").to_string(), "Option::Some(2)");
assert_eq!(
ShortName("bevy_render::RenderSet::Prepare").to_string(),
"RenderSet::Prepare"
);
}
#[test]
fn generics() {
assert_eq!(
ShortName("bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>").to_string(),
"extract_cameras<Camera3d>"
);
}
#[test]
fn nested_generics() {
assert_eq!(
ShortName("bevy::mad_science::do_mad_science<mad_science::Test<mad_science::Tube>, bavy::TypeSystemAbuse>").to_string(),
"do_mad_science<Test<Tube>, TypeSystemAbuse>"
);
}
#[test]
fn sub_path_after_closing_bracket() {
assert_eq!(
ShortName("bevy_asset::assets::Assets<bevy_scene::dynamic_scene::DynamicScene>::asset_event_system").to_string(),
"Assets<DynamicScene>::asset_event_system"
);
assert_eq!(
ShortName("(String, String)::default").to_string(),
"(String, String)::default"
);
assert_eq!(
ShortName("[i32; 16]::default").to_string(),
"[i32; 16]::default"
);
}
}