Update lang tasks to also read shortcuts

- Updated docs with more accurate picture of translation state
- invalid task found keys that were no longer used from 2 commands
- Cleaned up rewrite-clj

scripts/src/logseq/tasks/lang.clj

@@ -1,33 +1,68 @@
 (ns logseq.tasks.lang
   "Tasks related to language translations"
-  (:require [logseq.rewrite-clj :as rewrite-clj]
+  (:require [logseq.tasks.rewrite-clj :as rewrite-clj]
             [clojure.set :as set]
             [logseq.tasks.util :as task-util]))
 
 (defn- get-dicts
   []
-  (dissoc (rewrite-clj/var-sexp ["dicts" "src/main/frontend/dicts.cljs"])
+  (dissoc (rewrite-clj/var-sexp "src/main/frontend/dicts.cljs" "dicts")
           :tongue/fallback))
 
+(defn- get-non-en-shortcuts
+  []
+  (nth (rewrite-clj/var-sexp "src/main/frontend/modules/shortcut/dict.cljs" "dict")
+       3))
+
+;; unnecessary complexity :(
+(defn- decorate-namespace [k]
+  (let [n (name k)
+        ns (namespace k)]
+    (keyword (str "command." ns) n)))
+
+(defn- get-en-shortcut-dicts
+  []
+  (->> (rewrite-clj/var-sexp
+        "src/main/frontend/modules/shortcut/config.cljs"
+        "all-default-keyboard-shortcuts")
+       (map (fn [[k v]] (vector (decorate-namespace k) (:desc v))))
+       (into {})))
+
+(defn- get-en-categories
+  []
+  (->> (rewrite-clj/var-sexp
+        "src/main/frontend/modules/shortcut/config.cljs"
+        "category")
+       (map (fn [[k v]] (vector k (:doc (meta v)))))
+       (into {})))
+
+(defn- get-shortcuts
+  []
+  (merge {:en (merge (get-en-categories)
+                     (get-en-shortcut-dicts))}
+         (get-non-en-shortcuts)))
+
 (defn- get-languages
   []
-  (rewrite-clj/var-sexp ["languages" "src/main/frontend/dicts.cljs"]))
+  (->> (rewrite-clj/var-sexp "src/main/frontend/dicts.cljs" "languages")
+       (map (juxt :value :label))
+       (into {})))
 
 (defn list-langs
   "List translated langagues with their number of translations"
   []
-  (let [dicts (get-dicts)
+  (let [dicts (merge-with merge (get-dicts) (get-shortcuts))
         en-count (count (dicts :en))
-        langs (into {} (map (juxt :value :label) (get-languages)))]
+        langs (get-languages)]
     (->> dicts
-         (map (fn [[locale dicts]]
-                [locale
-                 (Math/round (* 100.0 (/ (count dicts) en-count)))
-                 (count dicts)
-                 (langs locale)]))
-         (sort-by #(nth % 2) >)
-         (map #(zipmap [:locale :percent-translated :translation-count :language] %))
-         task-util/print-table)))
+           (map (fn [[locale dicts]]
+                  [locale
+                   (Math/round (* 100.0 (/ (count dicts) en-count)))
+                   (count dicts)
+                   (langs locale)]))
+           (sort-by #(nth % 2) >)
+           (map #(zipmap [:locale :percent-translated :translation-count :language] %))
+           task-util/print-table)))
 
 (defn- shorten [s length]
   (if (< (count s) length)
@@ -39,27 +74,34 @@
   [& args]
   (let [lang (or (keyword (first args))
                  (task-util/print-usage "LOCALE"))
-        dicts (get-dicts)
-        translated-language (dicts lang)
-        _ (when-not translated-language
+        _ (when-not (contains? (get-languages) lang)
             (println "Language" lang "does not have an entry in dicts.cljs")
             (System/exit 1))
-        missing (set/difference (set (keys (dicts :en)))
-                                (set (keys translated-language)))]
-    (if (zero? (count missing))
+        all-dicts [[(get-dicts) "frontend/dicts.cljs"]
+                   [(get-shortcuts) "shortcut/dict.cljs"]]
+        all-missing (map (fn [[dicts file]]
+                           [(select-keys (dicts :en)
+                                         (set/difference (set (keys (dicts :en)))
+                                                         (set (keys (dicts lang)))))
+                            file])
+                         all-dicts)]
+    (if (every? (comp zero? count first) all-missing)
       (println "Language" lang "is fully translated!")
-      (->> (select-keys (dicts :en) missing)
-           (map (fn [[k v]]
-                  {:translation-key k
-                   ;; Shorten values
-                   :string-to-translate (shorten v 50)}))
-           (sort-by :translation-key)
+      (->> all-missing
+           (mapcat (fn [[m file]]
+                     (map (fn [[k v]]
+                            {:translation-key k
+                             ;; Shorten values
+                             :string-to-translate (shorten v 50)
+                             :file file})
+                          m)))
+           (sort-by (juxt :file :translation-key))
            task-util/print-table))))
 
-(defn invalid-dicts
-  "Lists translation keys that don't exist in English"
+(defn invalid-translations
+  "Lists translation that don't exist in English"
   []
-  (let [dicts (get-dicts)
+  (let [dicts (merge-with merge (get-dicts) (get-shortcuts))
         ;; For now defined as :en but clj-kondo analysis could be more thorough
         valid-keys (set (keys (dicts :en)))
         invalid-dicts
@@ -70,16 +112,16 @@
                         (set/difference (set (keys get-dicts))
                                         valid-keys)))))]
     (if (empty? invalid-dicts)
-      (println "All dicts have valid keys!")
+      (println "All translations have valid keys!")
       (do
-        (println "Invalid dict keys found:")
+        (println "Invalid translation keys found:")
         (task-util/print-table invalid-dicts)
         (System/exit 1)))))
 
 (defn list-duplicates
   "Lists translations that are the same as the one in English"
   [& args]
-  (let [dicts (get-dicts)
+  (let [dicts (merge-with merge (get-dicts) (get-shortcuts))
         en-dicts (dicts :en)
         lang (or (keyword (first args))
                  (task-util/print-usage "LOCALE"))

scripts/src/logseq/tasks/rewrite_clj.clj

@@ -1,4 +1,4 @@
-(ns logseq.rewrite-clj
+(ns logseq.tasks.rewrite-clj
   "Rewrite-clj fns"
   (:require [rewrite-clj.zip :as z]))
 
@@ -10,6 +10,6 @@
       z/sexpr))
 
 (defn var-sexp
-  [[string-var file]]
+  [file string-var]
   (let [zloc (z/of-string (slurp file))]
     (find-symbol-first-right-sexpr zloc (symbol string-var))))