feat: remove dictionary relay and add human-friendly dictionary name …

…in wikit desktop app

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wikit"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

core/src/config.rs

@@ -11,26 +11,27 @@
 ///     [srvcfg]
 ///     uris = [
 ///         "file://<filesystem path>",
-///         "https://[user@token]<wikit api router>",
-///         "http://[user@token]<wikit api router>",
 ///     ]
 ///     port = 8888
 ///     host = "0.0.0.0"
 ///
-/// `[cltcfg]` is used for wikit desktop client, and `[srvcfg]` is used for serving dictionary.
+/// `[cltcfg]` is used for wikit desktop client, and `[srvcfg]` is used for serving dictionaries.
 ///
 /// `uris` are a list of [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) which
-/// refers directory resource path, supported URI are
+/// refers directory resource path, supported URIs are
 ///
-/// - file://
+/// - `file://`
 ///
 ///     This refers your local file on your system, such as `file:///home/user/Downloads/awesome.wikit`
 ///     where `/home/user/Downloads/awesome.wikit` is the full path to your dictionary
 ///     `awesome.wikit` on your system.
 ///
-/// - https:// and http://
+/// - `https://` and `http://`
+///
+///     Wikit allows client access remote hosted dictionary by network. However, this type URI is
+///     only allowed in `[cltcfg]` section, if them does appear in `[srvcfg]`, then will be ignored.
 ///
-///     wikit allows you access remote hosted dictionary by network.
+///     Only IP address is allowed for now, domain will be added in future.
 ///
 ///     Assuming the base url of the remote server is `https://example.com`, then there must exist following API
 ///

core/src/router.rs

@@ -1,16 +1,14 @@
 use crate::config;
 use crate::wikit;
 use crate::crypto;
+use crate::util;
 
 use std::net::{IpAddr, Ipv4Addr};
 use std::{sync::Mutex, collections::HashMap};
-use std::path::Path;
 use std::sync::Arc;
 
-use sqlx::postgres::PgPoolOptions;
-use rocket::{Build, Request, response::content, catch, get, catchers, routes};
-use regex::Regex;
-use rocket::serde::{Serialize, Deserialize, json::Json};
+use rocket::{Build, Request, catch, get, catchers, routes};
+use rocket::serde::json::Json;
 use once_cell::sync::Lazy;
 
 pub static DICTMP: Lazy<Arc<Mutex<HashMap<String, String>>>> = Lazy::new(|| {
@@ -30,47 +28,35 @@ fn not_found(req: &Request) -> String {
 
 #[get("/list")]
 async fn list() -> Json<Vec<wikit::DictList>> {
-    let mut dict = vec![];
+    let mut dictlist = vec![];
     if let Ok(config) = config::load_config() {
         for uri in config.srvcfg.uris.iter() {
             let dictid = crypto::md5(uri.as_bytes());
             if let Some(dict) = wikit::load_dictionary_from_uri(uri) {
                 let style_key = format!("style[{}]", dictid);
                 let script_key = format!("script[{}]", dictid);
-                match dict {
-                    wikit::WikitDictionary::Local(d) => {
-                        if let Ok(mut dictmp) = DICTMP.lock() {
-                            if dictmp.get(&style_key).is_none() {
-                                dictmp.insert(style_key, d.head.style.clone());
-                            }
-                            if dictmp.get(&script_key).is_none() {
-                                dictmp.insert(script_key, d.head.script.clone());
-                            }
+                if let wikit::WikitDictionary::Local(d) = dict {
+                    if let Ok(mut dictmp) = DICTMP.lock() {
+                        if dictmp.get(&style_key).is_none() {
+                            dictmp.insert(style_key, d.head.style.clone());
                         }
-                    },
-                    wikit::WikitDictionary::Remote(d) => {
-                        if let Ok(mut dictmp) = DICTMP.lock() {
-                            if dictmp.get(&style_key).is_none() {
-                                dictmp.insert(style_key, d.get_style(&dictid));
-                            }
-                            if dictmp.get(&script_key).is_none() {
-                                dictmp.insert(script_key, d.get_script(&dictid));
-                            }
+                        if dictmp.get(&script_key).is_none() {
+                            dictmp.insert(script_key, d.head.script.clone());
                         }
-                    },
+                    }
+                    if let Ok(mut dictmp) = DICTMP.lock() {
+                        dictmp.insert(dictid.clone(), uri.to_string());
+                    }
+
+                    dictlist.push(wikit::DictList {
+                        name: d.head.name,
+                        id: dictid.clone(),
+                    });
                 }
             }
-            if let Ok(mut dictmp) = DICTMP.lock() {
-                dictmp.insert(dictid.clone(), uri.to_string());
-            }
-            dict.push(wikit::DictList {
-                // FIXME(2021-11-21): give a nice dictionar name
-                name: dictid.clone(),
-                id: dictid.clone(),
-            });
         }
     }
-    Json(dict)
+    Json(dictlist)
 }
 
 #[get("/style?<dictname>")]

core/src/wikit.rs

@@ -21,6 +21,7 @@ const WIKIT_MAGIC: &'static str = "WIKIT516";
 // the latest wikit dictionary format version
 const LATEST_WIKIT_FMT_VERSION: u32 = 0x00_00_00_01;
 
+// TODO(2022-02-19): select a better type name
 #[derive(Debug, Serialize, Deserialize)]
 pub struct DictList {
     pub name: String,

desktop/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wikit-desktop"
-version = "0.1.0-beta.2"
+version = "0.1.0-beta.3"
 description = "Wikit Desktop - A universal dictionary for human"
 authors = ["ikey4u <pwnkeeper@gmail.com>"]
 license = "MIT"

desktop/src-tauri/src/main.rs

@@ -69,20 +69,22 @@ fn lookup(dictid: String, word: String) -> LookupResponse {
 }
 
 #[tauri::command]
-fn get_dict_list() -> Vec<String> {
+fn get_dict_list() -> Vec<wikit::DictList> {
+    let mut dictlist = vec![];
     let mut dictdb = DICTDB.lock().unwrap();
-
     if let Ok(dicts) = wikit::load_client_dictionary() {
         for dict in dicts {
             match dict {
                 wikit::WikitDictionary::Local(ref ld) => {
                     let id = format!("{}", ld.path.display());
+                    dictlist.push(wikit::DictList{ name: ld.head.name.clone(), id: id.clone() });
                     dictdb.insert(id.clone(), dict);
                 },
                 wikit::WikitDictionary::Remote(ref rd) => {
                     if let Ok(ds) = rd.get_dict_list() {
                         for d in ds {
                             dictdb.insert(d.id.clone(), dict.clone());
+                            dictlist.push(d);
                         }
                     } else {
                         println!("failed to get remote dictionary list");
@@ -91,12 +93,6 @@ fn get_dict_list() -> Vec<String> {
             }
         }
     }
-
-    let mut dictlist = vec![];
-    for (k, _) in dictdb.iter() {
-        dictlist.push(k.to_string());
-    }
-
     dictlist
 }
 

desktop/src/App.svelte

@@ -19,7 +19,7 @@
     let r = await ffi.get_dict_list();
     $dictSettings.dict.all = r;
     if (r.length > 0) {
-      $dictSettings.dict.selected = [r[0]];
+      $dictSettings.dict.selected = [r[0].id];
     }
 
     unlisten = listen("rust-event", (e) => {
@@ -48,8 +48,18 @@
       return;
     }
 
+    let dictid = $dictSettings.dict.selected[0];
+    if (!dictid) {
+      if ($dictSettings.dict.all.length > 0) {
+        dictid = $dictSettings.dict.all[0].id
+      } else {
+        console.log("no dictionary is found, stop lookup");
+        return;
+      }
+    }
+
     input = input.trim().toLowerCase();
-    let resp = await ffi.lookup($dictSettings.dict.selected[0], input);
+    let resp = await ffi.lookup(dictid, input);
     let meanings = resp["words"];
     let meaning = meanings[input]
     if (!meaning) {

desktop/src/Settings.svelte

@@ -32,9 +32,9 @@
         {#each $dictSettings.dict.all as dict, i}
           <Item>
             <Graphic>
-              <Radio bind:group={selection} value="{dict}" />
+              <Radio bind:group={selection} value="{dict.id}" />
             </Graphic>
-            <Text>{dict}</Text>
+            <Text>{dict.name}</Text>
           </Item>
         {/each}
       </List>
@@ -56,9 +56,6 @@
   async () => {
    let r = await ffi.get_dict_list();
     $dictSettings.dict.all = r;
-    if (r.length > 0) {
-      $dictSettings.dict.selected = [r[0]];
-    }
     open = true
   }
 }>+</div>

desktop/src/store.js

@@ -2,7 +2,9 @@ import { writable } from 'svelte/store';
 
 export const dictSettings = writable({
   'dict': {
+    // array of dictionary, element format is `{ "id:: "<the dict id>", "name": "dictionary name for human" }`
     'all': [],
+    // selected dictionary ID
     'selected': [],
   },
 });