refactor!: the DictionaryMut trait is merged back to the Dictionary trait

Author: kanru

NEWS

@@ -39,6 +39,7 @@ What's New in libchewing (unreleased)
     and without the break word.
   - rust: simplified dictionary API.
   - rust: logging now depends on tracing and tracing-subscriber.
+  - rust: the DictionaryMut trait is merged back to the Dictionary trait.
 
 * Dictionary
   - Default symbols.dat now includes commonly used emojis.

src/conversion/chewing.rs

@@ -681,8 +681,7 @@ mod tests {
     #[test]
     fn convert_zero_length_entry() {
         let mut dict = test_dictionary();
-        let dict_mut = dict.as_dict_mut().unwrap();
-        dict_mut.add_phrase(&[], ("", 0).into()).unwrap();
+        dict.add_phrase(&[], ("", 0).into()).unwrap();
         let engine = ChewingEngine::new();
         let mut composition = Composition::new();
         for sym in [

src/conversion/simple.rs

@@ -136,8 +136,7 @@ mod tests {
     #[test]
     fn convert_zero_length_entry() {
         let mut dict = test_dictionary();
-        let dict_mut = dict.as_dict_mut().unwrap();
-        dict_mut.add_phrase(&[], ("", 0).into()).unwrap();
+        dict.add_phrase(&[], ("", 0).into()).unwrap();
         let engine = SimpleEngine::new();
         let mut composition = Composition::new();
         for sym in [

src/dictionary/layered.rs

@@ -5,10 +5,7 @@ use std::{
 
 use tracing::error;
 
-use super::{
-    Dictionary, DictionaryInfo, DictionaryMut, Entries, LookupStrategy, Phrase,
-    UpdateDictionaryError,
-};
+use super::{Dictionary, DictionaryInfo, Entries, LookupStrategy, Phrase, UpdateDictionaryError};
 use crate::zhuyin::Syllable;
 
 /// A collection of dictionaries that returns the union of the lookup results.
@@ -143,26 +140,12 @@ impl Dictionary for Layered {
         None
     }
 
-    fn as_dict_mut(&mut self) -> Option<&mut dyn DictionaryMut> {
-        self.user_dict.as_dict_mut()
-    }
-}
-
-impl DictionaryMut for Layered {
     fn reopen(&mut self) -> Result<(), UpdateDictionaryError> {
-        if let Some(writer) = self.user_dict.as_dict_mut() {
-            writer.reopen()
-        } else {
-            Ok(())
-        }
+        self.user_dict.reopen()
     }
 
     fn flush(&mut self) -> Result<(), UpdateDictionaryError> {
-        if let Some(writer) = self.user_dict.as_dict_mut() {
-            writer.flush()
-        } else {
-            Ok(())
-        }
+        self.user_dict.flush()
     }
 
     fn add_phrase(
@@ -174,11 +157,7 @@ impl DictionaryMut for Layered {
             error!("BUG! added phrase is empty");
             return Ok(());
         }
-        if let Some(writer) = self.user_dict.as_dict_mut() {
-            writer.add_phrase(syllables, phrase)
-        } else {
-            Ok(())
-        }
+        self.user_dict.add_phrase(syllables, phrase)
     }
 
     fn update_phrase(
@@ -192,23 +171,16 @@ impl DictionaryMut for Layered {
             error!("BUG! added phrase is empty");
             return Ok(());
         }
-        if let Some(writer) = self.user_dict.as_dict_mut() {
-            writer.update_phrase(syllables, phrase, user_freq, time)
-        } else {
-            Ok(())
-        }
+        self.user_dict
+            .update_phrase(syllables, phrase, user_freq, time)
     }
 
     fn remove_phrase(
         &mut self,
         syllables: &[Syllable],
         phrase_str: &str,
     ) -> Result<(), UpdateDictionaryError> {
-        if let Some(writer) = self.user_dict.as_dict_mut() {
-            writer.remove_phrase(syllables, phrase_str)
-        } else {
-            Ok(())
-        }
+        self.user_dict.remove_phrase(syllables, phrase_str)
     }
 }
 
@@ -222,8 +194,7 @@ mod tests {
     use super::Layered;
     use crate::{
         dictionary::{
-            Dictionary, DictionaryBuilder, DictionaryMut, LookupStrategy, Phrase, Trie, TrieBuf,
-            TrieBuilder,
+            Dictionary, DictionaryBuilder, LookupStrategy, Phrase, Trie, TrieBuf, TrieBuilder,
         },
         syl,
         zhuyin::Bopomofo,
@@ -354,15 +325,14 @@ mod tests {
             ),
         );
         let _ = dict.about();
-        assert!(dict.as_dict_mut().is_none());
-        assert!(dict.reopen().is_ok());
-        assert!(dict.flush().is_ok());
+        assert!(dict.reopen().is_err());
+        assert!(dict.flush().is_err());
         assert!(
             dict.add_phrase(
                 &[syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]],
                 ("冊", 100).into()
             )
-            .is_ok()
+            .is_err()
         );
         assert!(
             dict.update_phrase(
@@ -371,11 +341,11 @@ mod tests {
                 0,
                 0,
             )
-            .is_ok()
+            .is_err()
         );
         assert!(
             dict.remove_phrase(&[syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]], "冊")
-                .is_ok()
+                .is_err()
         );
         Ok(())
     }

src/dictionary/loader.rs

@@ -174,14 +174,10 @@ impl UserDictionaryLoader {
                     let freq = phrase.freq();
                     let last_used = phrase.last_used().unwrap_or_default();
                     fresh_dict
-                        .as_dict_mut()
-                        .unwrap()
                         .update_phrase(&syllables, phrase, freq, last_used)
                         .map_err(|e| io::Error::new(io::ErrorKind::Other, Box::new(e)))?;
                 }
                 fresh_dict
-                    .as_dict_mut()
-                    .unwrap()
                     .flush()
                     .map_err(|e| io::Error::new(io::ErrorKind::Other, Box::new(e)))?;
             }
@@ -197,14 +193,10 @@ impl UserDictionaryLoader {
                         let freq = phrase.freq();
                         let last_used = phrase.last_used().unwrap_or_default();
                         fresh_dict
-                            .as_dict_mut()
-                            .unwrap()
                             .update_phrase(&syllables, phrase, freq, last_used)
                             .map_err(|e| io::Error::other(Box::new(e)))?;
                     }
                     fresh_dict
-                        .as_dict_mut()
-                        .unwrap()
                         .flush()
                         .map_err(|e| io::Error::other(Box::new(e)))?;
                 }

src/dictionary/mod.rs

@@ -323,7 +323,7 @@ pub enum LookupStrategy {
 /// ```
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 ///
-/// use chewing::{dictionary::{Dictionary, DictionaryMut, LookupStrategy, TrieBuf}, syl, zhuyin::Bopomofo};
+/// use chewing::{dictionary::{Dictionary, LookupStrategy, TrieBuf}, syl, zhuyin::Bopomofo};
 ///
 /// let mut dict = TrieBuf::new_in_memory();
 /// dict.add_phrase(&[syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]], ("測", 100).into())?;
@@ -348,21 +348,20 @@ pub trait Dictionary: Debug {
     fn about(&self) -> DictionaryInfo;
     /// Returns the dictionary file path if it's backed by a file.
     fn path(&self) -> Option<&Path>;
-    fn as_dict_mut(&mut self) -> Option<&mut dyn DictionaryMut>;
-}
-
-/// An interface for updating dictionaries.
-pub trait DictionaryMut: Debug {
     /// Reopens the dictionary if it was changed by a different process
     ///
     /// It should not fail if the dictionary is read-only or able to sync across
     /// processes automatically.
-    fn reopen(&mut self) -> Result<(), UpdateDictionaryError>;
+    fn reopen(&mut self) -> Result<(), UpdateDictionaryError> {
+        Err(UpdateDictionaryError { source: None })
+    }
     /// Flushes all the changes back to the filesystem
     ///
     /// The change made to the dictionary might not be persisted without
     /// calling this method.
-    fn flush(&mut self) -> Result<(), UpdateDictionaryError>;
+    fn flush(&mut self) -> Result<(), UpdateDictionaryError> {
+        Err(UpdateDictionaryError { source: None })
+    }
     /// An method for updating dictionaries.
     ///
     /// For more about the concept of dictionaries generally, please see the
@@ -373,7 +372,7 @@ pub trait DictionaryMut: Debug {
     /// ```
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     ///
-    /// use chewing::{dictionary::{DictionaryMut, TrieBuf}, syl, zhuyin::Bopomofo};
+    /// use chewing::{dictionary::{Dictionary, TrieBuf}, syl, zhuyin::Bopomofo};
     ///
     /// let mut dict = TrieBuf::new_in_memory();
     /// dict.add_phrase(&[syl![Bopomofo::C, Bopomofo::E, Bopomofo::TONE4]], ("測", 100).into())?;
@@ -383,25 +382,29 @@ pub trait DictionaryMut: Debug {
     /// TODO: doc
     fn add_phrase(
         &mut self,
-        syllables: &[Syllable],
-        phrase: Phrase,
-    ) -> Result<(), UpdateDictionaryError>;
-
+        _syllables: &[Syllable],
+        _phrase: Phrase,
+    ) -> Result<(), UpdateDictionaryError> {
+        Err(UpdateDictionaryError { source: None })
+    }
     /// TODO: doc
     fn update_phrase(
         &mut self,
-        syllables: &[Syllable],
-        phrase: Phrase,
-        user_freq: u32,
-        time: u64,
-    ) -> Result<(), UpdateDictionaryError>;
-
+        _syllables: &[Syllable],
+        _phrase: Phrase,
+        _user_freq: u32,
+        _time: u64,
+    ) -> Result<(), UpdateDictionaryError> {
+        Err(UpdateDictionaryError { source: None })
+    }
     /// TODO: doc
     fn remove_phrase(
         &mut self,
-        syllables: &[Syllable],
-        phrase_str: &str,
-    ) -> Result<(), UpdateDictionaryError>;
+        _syllables: &[Syllable],
+        _phrase_str: &str,
+    ) -> Result<(), UpdateDictionaryError> {
+        Err(UpdateDictionaryError { source: None })
+    }
 }
 
 /// Errors during dictionary construction.
@@ -447,12 +450,11 @@ pub trait DictionaryBuilder {
 
 #[cfg(test)]
 mod tests {
-    use crate::dictionary::{Dictionary, DictionaryBuilder, DictionaryMut};
+    use crate::dictionary::{Dictionary, DictionaryBuilder};
 
     #[test]
     fn ensure_object_safe() {
         const _: Option<&dyn Dictionary> = None;
-        const _: Option<&dyn DictionaryMut> = None;
         const _: Option<&dyn DictionaryBuilder> = None;
     }
 }

src/dictionary/sqlite.rs

@@ -9,8 +9,8 @@ use std::{
 use rusqlite::{Connection, Error as RusqliteError, OpenFlags, OptionalExtension, params};
 
 use super::{
-    BuildDictionaryError, Dictionary, DictionaryBuilder, DictionaryInfo, DictionaryMut, Entries,
-    LookupStrategy, Phrase, UpdateDictionaryError,
+    BuildDictionaryError, Dictionary, DictionaryBuilder, DictionaryInfo, Entries, LookupStrategy,
+    Phrase, UpdateDictionaryError,
 };
 use crate::zhuyin::Syllable;
 
@@ -383,17 +383,16 @@ impl Dictionary for SqliteDictionary {
         self.path.as_ref().map(|p| p as &Path)
     }
 
-    fn as_dict_mut(&mut self) -> Option<&mut dyn DictionaryMut> {
-        if !self.readonly { Some(self) } else { None }
-    }
-}
-
-impl DictionaryMut for SqliteDictionary {
     fn reopen(&mut self) -> Result<(), UpdateDictionaryError> {
         Ok(())
     }
 
     fn flush(&mut self) -> Result<(), UpdateDictionaryError> {
+        if self.readonly {
+            return Err(UpdateDictionaryError {
+                source: Some(Box::new(SqliteDictionaryError::ReadOnly)),
+            });
+        }
         self.conn.pragma_update(None, "wal_checkpoint", "PASSIVE")?;
         Ok(())
     }
@@ -594,8 +593,7 @@ mod tests {
     use super::SqliteDictionary;
     use crate::{
         dictionary::{
-            Dictionary, DictionaryBuilder, DictionaryMut, LookupStrategy, Phrase,
-            SqliteDictionaryBuilder,
+            Dictionary, DictionaryBuilder, LookupStrategy, Phrase, SqliteDictionaryBuilder,
         },
         syl,
         zhuyin::Bopomofo,
@@ -666,7 +664,7 @@ mod tests {
         let mut dict =
             SqliteDictionary::open_readonly(&temp_path).expect("Unable to open database");
         assert_eq!(temp_path.to_path_buf(), dict.path().unwrap());
-        assert!(dict.as_dict_mut().is_none());
+        assert!(dict.flush().is_err());
     }
 
     #[test]

src/dictionary/trie.rs

@@ -419,10 +419,6 @@ impl Dictionary for Trie {
     fn path(&self) -> Option<&Path> {
         self.path.as_ref().map(|p| p as &Path)
     }
-
-    fn as_dict_mut(&mut self) -> Option<&mut dyn super::DictionaryMut> {
-        None
-    }
 }
 
 fn context_specific<T: EncodeValue + Tagged>(

src/dictionary/trie_buf.rs

@@ -10,8 +10,8 @@ use std::{
 use tracing::{error, info};
 
 use super::{
-    BuildDictionaryError, Dictionary, DictionaryBuilder, DictionaryInfo, DictionaryMut, Entries,
-    LookupStrategy, Phrase, Trie, TrieBuilder, UpdateDictionaryError,
+    BuildDictionaryError, Dictionary, DictionaryBuilder, DictionaryInfo, Entries, LookupStrategy,
+    Phrase, Trie, TrieBuilder, UpdateDictionaryError,
 };
 use crate::zhuyin::Syllable;
 
@@ -304,12 +304,6 @@ impl Dictionary for TrieBuf {
         self.trie.as_ref()?.path()
     }
 
-    fn as_dict_mut(&mut self) -> Option<&mut dyn DictionaryMut> {
-        Some(self)
-    }
-}
-
-impl DictionaryMut for TrieBuf {
     fn reopen(&mut self) -> Result<(), UpdateDictionaryError> {
         self.sync()?;
         Ok(())
@@ -375,7 +369,7 @@ mod tests {
 
     use super::{Dictionary, TrieBuf};
     use crate::{
-        dictionary::{DictionaryMut, LookupStrategy, Phrase},
+        dictionary::{LookupStrategy, Phrase},
         syl,
         zhuyin::Bopomofo::*,
     };

src/editor/mod.rs

@@ -29,8 +29,8 @@ use crate::{
         special_symbol_input,
     },
     dictionary::{
-        DEFAULT_DICT_NAMES, Dictionary, DictionaryMut, Layered, LookupStrategy,
-        SystemDictionaryLoader, UpdateDictionaryError, UserDictionaryLoader,
+        DEFAULT_DICT_NAMES, Dictionary, Layered, LookupStrategy, SystemDictionaryLoader,
+        UpdateDictionaryError, UserDictionaryLoader,
     },
     input::{KeyState, KeyboardEvent, keysym::*},
     zhuyin::Syllable,