feat: support sorting candidates by frequency

kanru · kanru · commit f19e10b39e97 · 2025-11-14T09:20:40.000+09:00
diff --git a/NEWS b/NEWS
@@ -4,13 +4,17 @@ What's New in libchewing (unreleased)
 * Features
   - cli: Now outputs and reads dictionary metadata in source file
   - cli: Detects mismatched phrase word count and syllable count
+  - editor: Support optional sorting candidates by frequency. Previously the
+    candidates are always sorted by their order in the dictionary.
 
 * Developer Features
   - New API `chewing_handle_KeyboardEvent()` can be used to support any
     keyboard layout combination without updating libchewing. Other keyboard
     handling API will be deprecated in future release.
   - New API `chewing_new3()` and `chewing_get_defaultDictonaryNames()` can be
     used to initialize a chewing context with specific dictionaries enabled.
+  - New boolean config option `chewing.sort_candidates_by_frequency` can be
+    set to enable sorting candidates by frequency.
 
 * Bug Fixes
   - Auto shift cursor after candidate selection now moves the cursor to the
diff --git a/capi/src/io.rs b/capi/src/io.rs
@@ -417,6 +417,7 @@ pub unsafe extern "C" fn chewing_config_has_option(
             | "chewing.space_is_select_key"
             | "chewing.conversion_engine"
             | "chewing.enable_fullwidth_toggle_key"
+            | "chewing.sort_candidates_by_frequency"
     );
 
     ret as c_int
@@ -468,6 +469,7 @@ pub unsafe extern "C" fn chewing_config_get_int(
             ConversionEngineKind::FuzzyChewingEngine => FUZZY_CHEWING_CONVERSION_ENGINE,
         },
         "chewing.enable_fullwidth_toggle_key" => option.enable_fullwidth_toggle_key as c_int,
+        "chewing.sort_candidates_by_frequency" => option.sort_candidates_by_frequency as c_int,
         _ => ERROR,
     }
 }
@@ -588,6 +590,10 @@ pub unsafe extern "C" fn chewing_config_set_int(
             ensure_bool!(value);
             options.enable_fullwidth_toggle_key = value > 0;
         }
+        "chewing.sort_candidates_by_frequency" => {
+            ensure_bool!(value);
+            options.sort_candidates_by_frequency = value > 0;
+        }
         _ => return ERROR,
     };
 
diff --git a/src/editor/mod.rs b/src/editor/mod.rs
@@ -77,6 +77,7 @@ pub struct EditorOptions {
     pub lookup_strategy: LookupStrategy,
     pub conversion_engine: ConversionEngineKind,
     pub enable_fullwidth_toggle_key: bool,
+    pub sort_candidates_by_frequency: bool,
 }
 
 impl Default for EditorOptions {
@@ -97,6 +98,7 @@ impl Default for EditorOptions {
             // FIXME may be out of sync with the engine used
             conversion_engine: ConversionEngineKind::ChewingEngine,
             enable_fullwidth_toggle_key: true,
+            sort_candidates_by_frequency: false,
         }
     }
 }
@@ -1558,7 +1560,7 @@ mod tests {
     use crate::{
         conversion::ChewingEngine,
         dictionary::{Layered, TrieBuf},
-        editor::{EditorKeyBehavior, SymbolSelector, abbrev::AbbrevTable, estimate},
+        editor::{EditorKeyBehavior, EditorOptions, SymbolSelector, abbrev::AbbrevTable, estimate},
         input::{
             KeyboardEvent, keycode,
             keymap::{QWERTY_MAP, map_ascii},
@@ -1641,6 +1643,102 @@ mod tests {
         assert_eq!("冊", editor.display());
     }
 
+    #[test]
+    fn editing_mode_input_bopomofo_select() {
+        let dict = TrieBuf::from([(
+            vec![crate::syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]],
+            vec![("冊", 100), ("測", 200)],
+        )]);
+        let dict = Layered::new(vec![Box::new(dict)], Box::new(TrieBuf::new_in_memory()));
+        let conversion_engine = Box::new(ChewingEngine::new());
+        let estimate = LaxUserFreqEstimate::new(0);
+        let abbrev = AbbrevTable::new();
+        let sym_sel = SymbolSelector::default();
+        let mut editor = Editor::new(conversion_engine, dict, estimate, abbrev, sym_sel);
+
+        editor.set_editor_options(EditorOptions {
+            sort_candidates_by_frequency: false,
+            ..Default::default()
+        });
+
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_H)
+                .ksym(keysym::SYM_LOWER_H)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_K)
+                .ksym(keysym::SYM_LOWER_H)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_4)
+                .ksym(keysym::SYM_4)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_DOWN)
+                .ksym(keysym::SYM_DOWN)
+                .build(),
+        );
+        let candidates = editor
+            .all_candidates()
+            .expect("should be in selection mode");
+        assert_eq!(vec!["冊", "測"], candidates);
+    }
+
+    #[test]
+    fn editing_mode_input_bopomofo_select_sorted() {
+        let dict = TrieBuf::from([(
+            vec![crate::syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]],
+            vec![("冊", 100), ("測", 200)],
+        )]);
+        let dict = Layered::new(vec![Box::new(dict)], Box::new(TrieBuf::new_in_memory()));
+        let conversion_engine = Box::new(ChewingEngine::new());
+        let estimate = LaxUserFreqEstimate::new(0);
+        let abbrev = AbbrevTable::new();
+        let sym_sel = SymbolSelector::default();
+        let mut editor = Editor::new(conversion_engine, dict, estimate, abbrev, sym_sel);
+
+        editor.set_editor_options(EditorOptions {
+            sort_candidates_by_frequency: true,
+            ..Default::default()
+        });
+
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_H)
+                .ksym(keysym::SYM_LOWER_H)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_K)
+                .ksym(keysym::SYM_LOWER_H)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_4)
+                .ksym(keysym::SYM_4)
+                .build(),
+        );
+        editor.process_keyevent(
+            KeyboardEvent::builder()
+                .code(keycode::KEY_DOWN)
+                .ksym(keysym::SYM_DOWN)
+                .build(),
+        );
+        let candidates = editor
+            .all_candidates()
+            .expect("should be in selection mode");
+        assert_eq!(vec!["測", "冊"], candidates);
+    }
+
     #[test]
     fn editing_mode_input_chinese_to_english_mode() {
         let dict = TrieBuf::from([(
diff --git a/src/editor/selection/phrase.rs b/src/editor/selection/phrase.rs
@@ -1,4 +1,4 @@
-use std::cmp::min;
+use std::cmp::{Reverse, min};
 
 use crate::{
     conversion::{Composition, Gap, Interval},
@@ -228,21 +228,22 @@ impl PhraseSelector {
                 self.lookup_strategy,
             )
             .into_iter()
-            .map(|phrase| phrase.into())
-            .collect::<Vec<String>>();
+            .collect::<Vec<_>>();
         if self.end - self.begin == 1 {
             let alt = editor
                 .syl
                 .alt_syllables(self.com.symbol(self.begin).unwrap().to_syllable().unwrap());
             for &syl in alt {
                 candidates.extend(
                     dict.lookup_all_phrases(&[syl], self.lookup_strategy)
-                        .into_iter()
-                        .map(|ph| ph.into()),
+                        .into_iter(),
                 )
             }
         }
-        candidates
+        if editor.options.sort_candidates_by_frequency {
+            candidates.sort_by_key(|ph| Reverse(ph.freq()));
+        }
+        candidates.into_iter().map(|ph| ph.into()).collect()
     }
 
     pub(crate) fn interval(&self, phrase: impl Into<Box<str>>) -> Interval {
diff --git a/tests/test-bopomofo.c b/tests/test-bopomofo.c
@@ -539,6 +539,36 @@ void test_select_candidate_shift_cursor_rearword()
     chewing_delete(ctx);
 }
 
+void test_select_candidate_sorted()
+{
+    ChewingContext *ctx;
+
+    static const char *CAND1[] = {
+        "妙", "廟", "繆", "玅", "謬", "庙", "庿"
+    };
+
+    static const char *CAND2[] = {
+        "廟", "妙", "繆", "玅", "謬", "庙", "庿"
+    };
+
+    clean_userphrase();
+
+    ctx = chewing_new();
+    start_testcase(ctx);
+
+    chewing_set_candPerPage(ctx, 2);
+    chewing_set_spaceAsSelection(ctx, 1);
+    chewing_set_phraseChoiceRearward(ctx, 1);
+    ok(chewing_config_set_int(ctx, "chewing.sort_candidates_by_frequency", 1) == 0, "set config should return OK");
+    type_keystroke_by_string(ctx, "aul4 ");
+    ok_candidate(ctx, CAND1, ARRAY_SIZE(CAND1));
+    type_keystroke_by_string(ctx, "2<E>");
+    type_keystroke_by_string(ctx, "aul4 ");
+    ok_candidate(ctx, CAND2, ARRAY_SIZE(CAND2));
+
+    chewing_delete(ctx);
+}
+
 void test_select_candidate()
 {
     test_select_candidate_no_rearward();
@@ -555,6 +585,7 @@ void test_select_candidate()
     test_select_candidate_second_page_rewind();
     test_select_candidate_shift_cursor();
     test_select_candidate_shift_cursor_rearword();
+    test_select_candidate_sorted();
 }
 
 void test_Esc_not_entering_chewing()
