mod generated;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Tone {
Light,
MediumLight,
Medium,
MediumDark,
Dark,
}
pub const TONES: [Tone; 5] = [
Tone::Light,
Tone::MediumLight,
Tone::Medium,
Tone::MediumDark,
Tone::Dark,
];
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Emoji {
pub emoji: &'static str,
pub name: &'static str,
pub group: &'static str,
pub subgroup: &'static str,
tones: Option<[&'static str; 5]>,
}
impl Emoji {
pub fn supports_tones(&self) -> bool {
self.tones.is_some()
}
pub fn tone(&self, tone: Tone) -> &'static str {
match self.tones {
Some(variants) => variants[tone_index(tone)],
None => self.emoji,
}
}
pub fn tone_variants(&self) -> Option<[(Tone, &'static str); 5]> {
self.tones.map(|variants| {
[
(Tone::Light, variants[0]),
(Tone::MediumLight, variants[1]),
(Tone::Medium, variants[2]),
(Tone::MediumDark, variants[3]),
(Tone::Dark, variants[4]),
]
})
}
}
fn tone_index(tone: Tone) -> usize {
match tone {
Tone::Light => 0,
Tone::MediumLight => 1,
Tone::Medium => 2,
Tone::MediumDark => 3,
Tone::Dark => 4,
}
}
pub const EMOJI_COUNT: usize = generated::EMOJIS.len();
pub fn tone_capable_count() -> usize {
generated::EMOJIS.iter().filter(|e| e.tones.is_some()).count()
}
pub fn all() -> &'static [Emoji] {
generated::EMOJIS
}
pub fn groups() -> &'static [&'static str] {
generated::GROUPS
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum MatchTier {
Exact,
LeadingWord,
Word,
Substring,
}
fn normalize(s: &str) -> String {
s.split_whitespace()
.map(str::to_lowercase)
.collect::<Vec<_>>()
.join(" ")
}
fn words(normalized_name: &str) -> impl Iterator<Item = &str> {
normalized_name
.split(|c: char| !c.is_alphanumeric())
.filter(|w| !w.is_empty())
}
fn score(normalized_name: &str, normalized_query: &str) -> Option<MatchTier> {
if normalized_name == normalized_query {
return Some(MatchTier::Exact);
}
let mut leading = true;
let mut any_word_match = false;
for word in words(normalized_name) {
if word == normalized_query {
if leading {
return Some(MatchTier::LeadingWord);
}
any_word_match = true;
}
leading = false;
}
if any_word_match {
return Some(MatchTier::Word);
}
if normalized_name.contains(normalized_query) {
return Some(MatchTier::Substring);
}
None
}
pub fn search(query: &str, table: &[Emoji]) -> Vec<Emoji> {
let normalized_query = normalize(query);
if normalized_query.is_empty() {
return table.to_vec();
}
let mut scored: Vec<(MatchTier, usize, Emoji)> = table
.iter()
.enumerate()
.filter_map(|(index, entry)| {
let normalized_name = normalize(entry.name);
score(&normalized_name, &normalized_query).map(|tier| (tier, index, *entry))
})
.collect();
scored.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
scored.into_iter().map(|(_, _, entry)| entry).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_entry_has_a_non_empty_character_and_name() {
for entry in all() {
assert!(
!entry.emoji.is_empty(),
"entry {:?} has an empty character",
entry.name
);
assert!(
!entry.name.is_empty(),
"entry with character {:?} has an empty name",
entry.emoji
);
assert!(!entry.group.is_empty());
assert!(!entry.subgroup.is_empty());
}
}
#[test]
fn entry_count_matches_the_number_this_crate_documents() {
assert_eq!(EMOJI_COUNT, 1914);
assert_eq!(all().len(), 1914);
assert_eq!(tone_capable_count(), 323);
}
#[test]
fn a_tone_incapable_entrys_grid_character_never_carries_a_skin_tone_modifier() {
for entry in all().iter().filter(|e| !e.supports_tones()) {
for ch in entry.emoji.chars() {
let cp = ch as u32;
assert!(
!(0x1F3FB..=0x1F3FF).contains(&cp),
"{:?} ({}) has a skin-tone modifier despite supports_tones() == false",
entry.name,
entry.emoji
);
}
}
}
#[test]
fn no_entry_is_a_bare_skin_tone_or_hair_component() {
let component_names = [
"light skin tone",
"medium-light skin tone",
"medium skin tone",
"medium-dark skin tone",
"dark skin tone",
"red hair",
"curly hair",
"white hair",
"bald",
];
for entry in all() {
assert!(
!component_names.contains(&entry.name),
"bare component {:?} leaked into the table",
entry.name
);
}
}
#[test]
fn groups_lists_all_ten_cldr_groups_in_file_order() {
let g = groups();
assert_eq!(g.len(), 10);
assert_eq!(g[0], "Smileys & Emotion");
assert_eq!(g[1], "People & Body");
assert_eq!(g[2], "Component");
assert_eq!(g[9], "Flags");
}
#[test]
fn every_table_entry_group_is_one_of_the_listed_groups() {
let g = groups();
for entry in all() {
assert!(
g.contains(&entry.group),
"{:?} has group {:?}, not in groups()",
entry.name,
entry.group
);
}
}
#[test]
fn the_component_group_has_no_entries_after_filtering() {
assert!(
!all().iter().any(|e| e.group == "Component"),
"Component should be empty once component-status entries are excluded"
);
}
#[test]
fn table_order_is_cldr_order_not_alphabetical() {
assert_eq!(all()[0].name, "grinning face");
assert_eq!(all()[0].emoji, "😀");
}
#[test]
fn a_gesture_with_tones_reports_five_distinct_variants() {
let waving_hand = all()
.iter()
.find(|e| e.name == "waving hand")
.expect("waving hand should be in the table");
assert!(waving_hand.supports_tones());
let variants = waving_hand
.tone_variants()
.expect("supports_tones() said true");
let chars: std::collections::HashSet<&str> = variants.iter().map(|(_, c)| *c).collect();
assert_eq!(chars.len(), 5, "the five tone variants must be distinct");
for (_, variant) in variants {
assert_ne!(variant, waving_hand.emoji);
}
}
#[test]
fn an_emoji_without_tones_reports_none() {
let fire = all()
.iter()
.find(|e| e.name == "fire")
.expect("fire should be in the table");
assert!(!fire.supports_tones());
assert!(fire.tone_variants().is_none());
}
#[test]
fn asking_a_tone_incapable_emoji_for_a_tone_returns_the_plain_emoji() {
let fire = all().iter().find(|e| e.name == "fire").unwrap();
for tone in TONES {
assert_eq!(fire.tone(tone), fire.emoji);
}
}
#[test]
fn asking_a_tone_capable_emoji_for_each_tone_matches_its_variants_list() {
let waving_hand = all().iter().find(|e| e.name == "waving hand").unwrap();
let variants = waving_hand.tone_variants().unwrap();
for (tone, expected) in variants {
assert_eq!(waving_hand.tone(tone), expected);
}
}
#[test]
fn a_tone_family_whose_neutral_form_needs_a_variation_selector_still_merges_correctly() {
let entry = all()
.iter()
.find(|e| e.name == "index pointing up")
.expect("index pointing up should be a single, merged entry");
assert!(entry.supports_tones());
let variants = entry.tone_variants().unwrap();
for (_, variant) in variants {
assert_ne!(variant, entry.emoji);
}
}
#[test]
fn a_two_person_family_with_a_neutral_form_is_kept_without_tones() {
let entry = all()
.iter()
.find(|e| e.name == "kiss: woman, man")
.expect("kiss: woman, man should be in the table");
assert!(!entry.supports_tones());
}
#[test]
fn a_two_person_family_with_no_neutral_form_is_excluded_entirely() {
assert!(!all().iter().any(|e| e.name == "kiss: person, person"));
assert!(!all()
.iter()
.any(|e| e.name == "couple with heart: person, person"));
}
#[test]
fn search_still_finds_a_tone_capable_emoji_by_its_base_name_only_once() {
let results = search("waving hand", all());
let matches: Vec<_> = results.iter().filter(|e| e.name == "waving hand").collect();
assert_eq!(
matches.len(),
1,
"a tone-capable emoji must appear exactly once in the table, not once per tone"
);
}
#[test]
fn multi_codepoint_emoji_are_never_sliced_mid_character() {
let flag = all()
.iter()
.find(|e| e.name == "transgender flag")
.expect("transgender flag should be in the table");
assert!(flag.emoji.chars().count() >= 4);
let rebuilt: String = flag.emoji.chars().collect();
assert_eq!(rebuilt, flag.emoji);
}
#[test]
fn a_query_containing_a_multi_byte_character_never_panics_and_finds_nothing() {
let results = search("🔥", all());
assert!(results.is_empty());
}
#[test]
fn exact_name_match_beats_a_leading_word_match() {
let results = search("fire", all());
assert!(!results.is_empty());
assert_eq!(results[0].name, "fire");
}
#[test]
fn leading_word_match_beats_a_glued_substring_match() {
let results = search("fire", all());
let pos = |name: &str| results.iter().position(|e| e.name == name).unwrap();
let engine = pos("fire engine");
let firefighter = pos("firefighter");
let firecracker = pos("firecracker");
let fireworks = pos("fireworks");
assert!(engine < firefighter);
assert!(engine < firecracker);
assert!(engine < fireworks);
}
#[test]
fn a_whole_word_match_after_the_first_word_beats_a_glued_substring_match() {
assert_eq!(
score("smiling face with heart-eyes", "face"),
Some(MatchTier::Word)
);
assert_eq!(score("boldface", "face"), Some(MatchTier::Substring));
assert!(MatchTier::Word < MatchTier::Substring);
}
#[test]
fn case_and_leading_or_trailing_whitespace_do_not_affect_matching() {
let a = search("Fire", all());
let b = search(" fire ", all());
let c = search("FIRE", all());
assert_eq!(
a.iter().map(|e| e.name).collect::<Vec<_>>(),
b.iter().map(|e| e.name).collect::<Vec<_>>()
);
assert_eq!(
a.iter().map(|e| e.name).collect::<Vec<_>>(),
c.iter().map(|e| e.name).collect::<Vec<_>>()
);
}
#[test]
fn internal_whitespace_runs_are_collapsed_before_matching() {
let normal = search("fire engine", all());
let extra_spaces = search("fire engine", all());
assert_eq!(
normal.iter().map(|e| e.name).collect::<Vec<_>>(),
extra_spaces.iter().map(|e| e.name).collect::<Vec<_>>()
);
assert!(normal.iter().any(|e| e.name == "fire engine"));
}
#[test]
fn empty_query_returns_everything_in_cldr_order() {
let results = search("", all());
assert_eq!(results.len(), all().len());
assert_eq!(
results.iter().map(|e| e.name).collect::<Vec<_>>(),
all().iter().map(|e| e.name).collect::<Vec<_>>()
);
}
#[test]
fn whitespace_only_query_also_returns_everything() {
let results = search(" ", all());
assert_eq!(results.len(), all().len());
}
#[test]
fn a_query_matching_nothing_returns_an_empty_vec() {
let results = search("this is definitely not an emoji name", all());
assert!(results.is_empty());
}
#[test]
fn substring_match_still_finds_a_glued_word() {
let results = search("cracker", all());
assert!(results.iter().any(|e| e.name == "firecracker"));
}
#[test]
fn search_over_an_empty_table_returns_nothing_and_does_not_panic() {
assert!(search("fire", &[]).is_empty());
assert_eq!(search("", &[]).len(), 0);
}
}