diff --git a/README.md b/README.md index 468b1d4..3974f22 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # 自動注音 AutoZhuyin -給繁體中文使用者的輸入法(macOS、Windows):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。 +給繁體中文使用者的輸入法(macOS、Windows、Linux):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。 ``` 按鍵: ji3 hello world su3cl3␣ @@ -45,6 +45,16 @@ PKG 會裝到 `/Library/Input Methods/`,系統上所有使用者都能用。 SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安裝:以系統管理員身分執行 `uninstall.bat`。 +### Linux(Bazzite、SteamOS 桌面模式、Fedora…) + +需求:系統內建 IBus 輸入法框架(Bazzite、Fedora 預設就有)。只在桌面模式可用,Steam 遊戲模式不支援系統輸入法。 + +1. 解壓縮 `AutoZhuyin-Linux-<版本>.tar.gz`,在終端機進到資料夾執行 `./install.sh`。不需要 sudo,只會裝在家目錄(`~/.local/share/autozhuyin`),所以唯讀系統也能用。 +2. KDE(Bazzite / SteamOS 預設):系統設定 → 鍵盤 → 虛擬鍵盤,選 **IBus Wayland** → 套用,登出再登入。GNOME 不用設定。 +3. 之後每次登入會自動切換到自動注音(`~/.config/autostart/autozhuyin.desktop`)。 + +暫時改回一般鍵盤:`ibus engine xkb:us::eng`;切回:`ibus engine autozhuyin`;移除:`./uninstall.sh`。 + ## 按鍵 | 按鍵 | 作用 | @@ -87,10 +97,10 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安 ## 個人資料 -| | macOS | Windows | -|---|---|---| -| 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` | -| 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` | +| | macOS | Windows | Linux | +|---|---|---|---| +| 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` | `~/.config/autozhuyin/learned.json` | +| 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` | `~/.config/autozhuyin/user-phrases.txt` | 自訂詞的格式和 `lexicon.txt` 一樣,每行一個詞:`ㄗˋ-ㄉㄨㄥˋ-ㄓㄨˋ-ㄧㄣ 自動注音 -4`(讀音、詞、分數;分數越大越優先)。 Mac 版可以在輸入法選單選「清除學習紀錄」。 @@ -126,6 +136,18 @@ scripts/package-windows.sh # 產生 build/AutoZhuyin-Wi - `windows/autozhuyin/data/` 是產生出來的,不進版本控制。 - 版本號在 `windows/autozhuyin/ime.json`。 +### Linux + +Linux 版是 IBus 輸入法(`linux/autozhuyin_ibus.py`),直接使用 Windows 版的 Python 核心(`windows/autozhuyin/core/`)和資料。 + +```bash +python3 -m unittest discover -s linux/tests # 用假的 IBus 模組測試外殼 +scripts/package-linux.sh # 產生 build/AutoZhuyin-Linux-<版本>.tar.gz(會先跑測試) +``` + +- 安裝在使用者目錄,不寫入 `/usr`:開機時由 autostart 啟動 `autozhuyin_ibus.py --activate`,它會把引擎動態註冊給 ibus-daemon 並切換過去。 +- 也支援由 ibus-daemon 啟動(`--ibus`,配合 `/usr/share/ibus/component` 的 XML),之後要做 RPM 時可以用。 + > 修改核心邏輯時,Swift(`Sources/AutoZhuyinCore/`)和 Python(`windows/autozhuyin/core/`)兩邊都要改,並在兩邊的測試加上相同案例。 ### 訓練判斷權重 @@ -179,12 +201,12 @@ scripts/release.sh minor --push # 同時 push commit 和 tag `release.sh` 會自動: 1. 遞增版本號(`Resources/Info.plist` 的版本與 build 號、`windows/autozhuyin/ime.json`) 2. 跑 Swift 和 Python 全部測試 -3. 產生 `build/AutoZhuyin-<版本>.pkg` 和 `build/AutoZhuyin-Windows-<版本>.zip` +3. 產生 `build/AutoZhuyin-<版本>.pkg`、`build/AutoZhuyin-Windows-<版本>.zip`、`build/AutoZhuyin-Linux-<版本>.tar.gz` 4. commit「Release v<版本>」並打上 `v<版本>` tag 任何一步失敗都會把版本號改回去。只想改版本號不打包:`scripts/bump-version.sh [patch|minor|major]`。 -最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg` 和 `.zip`。 +最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg`、`.zip` 和 `.tar.gz`。 ## 專案結構 @@ -212,13 +234,18 @@ windows/ installer/ install.bat、uninstall.bat、給使用者的 README.txt tests/ Python 測試 tools/ 產生資料檔、圖示 +linux/ + autozhuyin_ibus.py IBus 外殼(共用 windows/autozhuyin/core) + installer/ install.sh、uninstall.sh、給使用者的 README.txt + tests/ 用假 IBus 模組的外殼測試 training/ 合成資料、訓練權重、Swift/Python 一致性測試資料 THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔) ``` ## 已知限制 -- Windows 版還沒在實機上測試過。 +- Windows 版、Linux 版還沒在實機上測試過。 +- Linux 版只支援 IBus。KDE 上有些 Flatpak 程式(例如 Flatpak 版 Chrome)在 IBus Wayland 下可能打不出字。 - 聲調鍵打在注音符號中間(例如 `uv3l`)無法自動修正。 - 很短的字串本質上就有歧義。像 `up`(也是 ㄧㄣ 因)這種常用的,按空白後會先保留,看下一個詞再決定(`up jo4` = 因為、`up the` = up the);其他判斷錯的可以按 Tab 修正,修正後會記住。 - 安裝檔沒有簽章(macOS 沒有 Developer ID,Windows 沒有程式碼簽章憑證)。 @@ -228,6 +255,8 @@ THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝 - [x] 匯入完整詞庫 - [x] 注音順序錯誤修正 - [x] Windows 版 +- [x] Linux 版(IBus) +- [ ] Linux Fcitx5 版(KDE 上相容性較好) - [x] 用資料訓練判斷權重(合成資料) - [ ] 加入真實打字資料一起訓練 - [ ] 已送出的英文單字若判斷錯誤,可以「事後翻轉」 diff --git a/linux/autozhuyin_ibus.py b/linux/autozhuyin_ibus.py new file mode 100644 index 0000000..6bedd25 --- /dev/null +++ b/linux/autozhuyin_ibus.py @@ -0,0 +1,315 @@ +#!/usr/bin/env python3 +"""IBus engine for AutoZhuyin (自動注音) on Linux. + +All the logic lives in autozhuyin.core (shared with Windows and the tests); this file +only translates IBus key events and draws the preedit / candidate table. + +Run modes: + autozhuyin_ibus.py --ibus started by ibus-daemon (from the component XML) + autozhuyin_ibus.py [--activate] started by the user/autostart: registers the engine + itself if ibus-daemon does not know it, and with + --activate makes it the current input method +""" +import json +import os +import sys +import time + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) + +import gi # noqa: E402 + +gi.require_version("IBus", "1.0") +from gi.repository import GLib, GObject, IBus # noqa: E402 + +import autozhuyin # noqa: E402 +from autozhuyin.core.classifier import LITERAL, Classifier, LearnedPreferences # noqa: E402 +from autozhuyin.core.engine import ( # noqa: E402 + BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, SHIFT_TAP, TAB, UP, CompositionEngine, +) +from autozhuyin.core.english import EnglishModel # noqa: E402 +from autozhuyin.core.lexicon import Lexicon # noqa: E402 +from autozhuyin.core.shift_tap import ShiftTapDetector # noqa: E402 + +ENGINE_NAME = "autozhuyin" +BUS_NAME = "org.freedesktop.IBus.AutoZhuyin" +VERSION = "0.0.0" + +_DATA = os.path.join(os.path.dirname(os.path.abspath(autozhuyin.__file__)), "data") +_USER_DIR = os.path.join(os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config"), "autozhuyin") +_LEARNED_FILE = os.path.join(_USER_DIR, "learned.json") +_USER_PHRASES = os.path.join(_USER_DIR, "user-phrases.txt") + +try: + with open(os.path.join(HERE, "version.txt"), encoding="utf-8") as _f: + VERSION = _f.read().strip() or VERSION +except OSError: + pass + +_classifier = None + + +def _save_learned(weights): + try: + os.makedirs(_USER_DIR, exist_ok=True) + with open(_LEARNED_FILE, "w", encoding="utf-8") as f: + json.dump(weights, f, ensure_ascii=False) + except OSError: + pass + + +def shared_classifier(): + """Loads the lexicon and English model once per process.""" + global _classifier + if _classifier is None: + lexicon = Lexicon.from_file(os.path.join(_DATA, "lexicon.txt")) + if os.path.exists(_USER_PHRASES): + with open(_USER_PHRASES, encoding="utf-8") as f: + lexicon.load(f) + english = EnglishModel.from_files( + os.path.join(_DATA, "english-common.txt"), + os.path.join(_DATA, "english-dict.txt"), + os.path.join(_DATA, "english-bigram.json"), + ) + weights = {} + try: + with open(_LEARNED_FILE, encoding="utf-8") as f: + weights = json.load(f) + except (OSError, ValueError): + pass + trained = Classifier.load_weights(os.path.join(_DATA, "classifier-weights.json")) + _classifier = Classifier(lexicon, english, LearnedPreferences(weights, _save_learned), trained) + return _classifier + + +_SPECIAL = { + IBus.KEY_BackSpace: BACKSPACE, IBus.KEY_Return: ENTER, IBus.KEY_KP_Enter: ENTER, + IBus.KEY_Escape: ESCAPE, IBus.KEY_Tab: TAB, + IBus.KEY_Up: UP, IBus.KEY_Down: DOWN, IBus.KEY_Left: LEFT, IBus.KEY_Right: RIGHT, +} +_SHIFT_KEYS = (IBus.KEY_Shift_L, IBus.KEY_Shift_R) +_SHORTCUT_MASK = (IBus.ModifierType.CONTROL_MASK | IBus.ModifierType.MOD1_MASK + | IBus.ModifierType.SUPER_MASK | IBus.ModifierType.MOD4_MASK) +_LITERAL_COLOR = 0x1E64DC # blue hint for English segments + + +class AutoZhuyinEngine(IBus.Engine): + __gtype_name__ = "AutoZhuyinEngine" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._setup() + + def _setup(self): + if getattr(self, "engine", None) is not None: + return + self.engine = CompositionEngine(shared_classifier()) + self.shift_tap = ShiftTapDetector() + self.table = IBus.LookupTable.new(self.engine.page_size, 0, True, False) + self.table.set_orientation(IBus.Orientation.VERTICAL) + self.mode_prop = IBus.Property( + key="mode", prop_type=IBus.PropType.NORMAL, + label=IBus.Text.new_from_string("中英自動"), + symbol=IBus.Text.new_from_string("自"), + tooltip=IBus.Text.new_from_string("單按 Shift 切換英文模式"), + sensitive=True, visible=True, state=IBus.PropState.UNCHECKED) + self.props = IBus.PropList() + self.props.append(self.mode_prop) + + # --- keys --- + + def do_process_key_event(self, keyval, keycode, state): + self._setup() + released = bool(state & IBus.ModifierType.RELEASE_MASK) + + # Shift pressed and released alone: English mode (or flip the current word). + if keyval in _SHIFT_KEYS: + now = time.monotonic() + if not released: + if state & _SHORTCUT_MASK: + self.shift_tap.key_pressed() + else: + self.shift_tap.shift_down(now) + return False + if self.shift_tap.shift_up(now): + self.engine.handle(SHIFT_TAP) + self._update(None) + self._update_mode() + return False + if released: + return False + self.shift_tap.key_pressed() + + # Shortcuts (Ctrl/Alt/Super) go to the app; commit any composition first. + if state & _SHORTCUT_MASK: + if self.engine.keys: + self._update(self.engine.commit_all()) + return False + + key = self._key(keyval, state) + if key is None: + return self._busy() # swallow other keys (Delete, Home…) while composing + if not self.engine.wants(key): + return False + handled, commit = self.engine.handle(key) + self._update(commit) + return handled + + def _key(self, keyval, state): + if keyval in _SPECIAL: + return _SPECIAL[keyval] + if keyval == IBus.KEY_space: + return " " + code = IBus.keyval_to_unicode(keyval) + if not code or not code.isprintable(): + return None + # Caps Lock without Shift: keep Zhuyin working by using lowercase. + if state & IBus.ModifierType.LOCK_MASK and not state & IBus.ModifierType.SHIFT_MASK: + code = code.lower() + return code + + def _busy(self): + return bool(self.engine.keys or self.engine.candidates) + + # --- candidate panel (mouse) --- + + def do_candidate_clicked(self, index, button, state): + self.engine.select_candidate(self.engine.page_start + index) + self._update(None) + + def do_page_up(self): + return self._move_candidate(-self.engine.page_size) + + def do_page_down(self): + return self._move_candidate(self.engine.page_size) + + def do_cursor_up(self): + return self._move_candidate(-1) + + def do_cursor_down(self): + return self._move_candidate(1) + + def _move_candidate(self, delta): + if not self.engine.candidates: + return False + e = self.engine + e.candidate_index = max(0, min(len(e.candidates) - 1, e.candidate_index + delta)) + self._update(None) + return True + + # --- lifecycle --- + + def do_focus_in(self): + self._setup() + self.register_properties(self.props) + self._update_mode() + + def do_focus_out(self): + self._setup() + # PreeditFocusMode.COMMIT: IBus commits the shown text itself on focus out. + self.engine.reset() + self.hide_lookup_table() + + def do_reset(self): + self._setup() + self.engine.reset() + self.hide_preedit_text() + self.hide_lookup_table() + + def do_disable(self): + self.do_reset() + + # --- drawing --- + + def _update(self, commit): + if commit: + self.commit_text(IBus.Text.new_from_string(commit)) + pieces = self.engine.marked_pieces + text = "".join(t for t, _ in pieces) + if text: + ibus_text = IBus.Text.new_from_string(text) + attrs = IBus.AttrList() + attrs.append(IBus.attr_underline_new(IBus.AttrUnderline.SINGLE, 0, len(text))) + pos = 0 + for piece, mode in pieces: + if mode == LITERAL and piece: + attrs.append(IBus.attr_foreground_new(_LITERAL_COLOR, pos, pos + len(piece))) + pos += len(piece) + ibus_text.set_attributes(attrs) + self.update_preedit_text_with_mode(ibus_text, self.engine.cursor_offset, True, + IBus.PreeditFocusMode.COMMIT) + else: + self.hide_preedit_text() + + if self.engine.candidates: + self.table.clear() + for _, candidate in self.engine.candidates: + self.table.append_candidate(IBus.Text.new_from_string(candidate)) + self.table.set_cursor_pos(self.engine.candidate_index) + self.update_lookup_table(self.table, True) + else: + self.hide_lookup_table() + + def _update_mode(self): + english = self.engine.english_mode + self.mode_prop.set_label(IBus.Text.new_from_string("英文" if english else "中英自動")) + self.mode_prop.set_symbol(IBus.Text.new_from_string("英" if english else "自")) + self.update_property(self.mode_prop) + + +# --- process setup --- + +def make_component(exec_path): + component = IBus.Component( + name=BUS_NAME, description="自動注音 AutoZhuyin", version=VERSION, + license="Private", author="AutoZhuyin", homepage="", + command_line=f"{sys.executable} {exec_path} --ibus", textdomain="") + icon = os.path.join(HERE, "icon.png") + component.add_engine(IBus.EngineDesc( + name=ENGINE_NAME, longname="自動注音", description="大千注音+英文,自動判斷中英", + language="zh_TW", license="Private", author="AutoZhuyin", + icon=icon if os.path.exists(icon) else "", layout="us", symbol="自", rank=0)) + return component + + +def main(argv): + IBus.init() + bus = IBus.Bus() + loop = GLib.MainLoop() + started_by_ibus = "--ibus" in argv + activate = "--activate" in argv + factory = None + + def on_connected(*_): + nonlocal factory + factory = IBus.Factory.new(bus.get_connection()) + factory.add_engine(ENGINE_NAME, GObject.type_from_name("AutoZhuyinEngine")) + if started_by_ibus: + bus.request_name(BUS_NAME, 0) + else: + known = any(e.get_name() == ENGINE_NAME for e in bus.list_engines()) + if not known: + bus.register_component(make_component(os.path.abspath(__file__))) + if activate: + bus.set_global_engine(ENGINE_NAME) + + def on_disconnected(*_): + if started_by_ibus: + loop.quit() + # Otherwise wait: IBus.Bus reconnects (and emits "connected") when ibus-daemon restarts. + + bus.connect("connected", on_connected) + bus.connect("disconnected", on_disconnected) + shared_classifier() # load data before the first key + if bus.is_connected(): + on_connected() + elif started_by_ibus: + print("autozhuyin: cannot connect to ibus-daemon", file=sys.stderr) + return 1 + loop.run() + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/linux/installer/README.txt b/linux/installer/README.txt new file mode 100644 index 0000000..8838192 --- /dev/null +++ b/linux/installer/README.txt @@ -0,0 +1,57 @@ +自動注音 AutoZhuyin(Linux 測試版,IBus) +========================================= + +用大千注音鍵盤直接打字,不用切換中英文,輸入法會自動判斷你打的是注音還是英文。 + + 按鍵: ji3 hello world su3cl3 (最後按空白) + 輸出: 我hello world 你好 + +適用:Bazzite、SteamOS 桌面模式、Fedora 等有 IBus 的系統(KDE 或 GNOME)。 +只在桌面模式可用;Steam 遊戲模式不支援系統輸入法。 + + +安裝 +---- +1. 解壓縮,在終端機(Konsole)進到這個資料夾,執行: + ./install.sh + 不需要 sudo,檔案只會裝在你的家目錄(~/.local/share/autozhuyin)。 + +2. KDE(Bazzite / SteamOS 預設): + 系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」→ 套用,然後登出再登入。 + GNOME:IBus 是內建的,不用另外設定。 + +3. 之後每次登入都會自動切換到自動注音。 + + +使用方式 +-------- + 空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白 + Enter 送出目前組字 + Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正 + ← → 在組字區移動游標;游標在中間時直接打注音會插入新字, + Backspace 刪掉游標前的字 + ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 + Esc 取消組字 + 單按 Shift 切換英文模式(按鍵直接送出),再單按一次回到中英自動判斷 + Shift+字母 打大寫字母(也會強制英文) + ` + 標點 強制全形標點,例如 `< 或 `, = , `. = 。 `/ = ? `; = ; + +注音符號的順序打錯也沒關係,例如 ㄧㄒㄠˇ 會自動變成 ㄒㄧㄠˇ(小)。 + + +切換與移除 +---------- + 暫時改回一般鍵盤: ibus engine xkb:us::eng + 切回自動注音: ibus engine autozhuyin + 移除: ./uninstall.sh + +個人資料(學習紀錄、自訂詞)在 ~/.config/autozhuyin/: + learned.json 按 Tab 修正的學習紀錄 + user-phrases.txt 自訂詞,一行一個,例如:ㄗˋ-ㄉㄨㄥˋ 自動 -1 + + +有問題時 +-------- +在終端機手動執行看看錯誤訊息: + /usr/bin/python3 ~/.local/share/autozhuyin/autozhuyin_ibus.py --activate +把畫面上的訊息回報給我。 diff --git a/linux/installer/install.sh b/linux/installer/install.sh new file mode 100755 index 0000000..74243a1 --- /dev/null +++ b/linux/installer/install.sh @@ -0,0 +1,63 @@ +#!/bin/bash +# Installs AutoZhuyin (自動注音) for the current user as an IBus input method. +# Nothing outside your home folder is touched, so it works on read-only systems +# (Bazzite, SteamOS, Fedora Atomic). No sudo needed. +set -euo pipefail +cd "$(dirname "$0")" + +DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin" +AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart" +PY=/usr/bin/python3 + +echo "== 自動注音 AutoZhuyin 安裝 ==" + +# 1. IBus and its Python bindings must come with the system. +if ! command -v ibus >/dev/null 2>&1; then + echo "找不到 IBus(ibus 指令)。這個系統沒有內建 IBus,自動注音目前只支援 IBus。" >&2 + exit 1 +fi +if ! "$PY" -c 'import gi; gi.require_version("IBus", "1.0"); from gi.repository import IBus' 2>/dev/null; then + echo "系統的 Python 缺少 IBus 模組(python3-gobject / IBus-1.0 typelib)。" >&2 + exit 1 +fi + +# 2. Copy the program. +pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null || true +rm -rf "$DEST" +mkdir -p "$DEST" +cp -R autozhuyin autozhuyin_ibus.py version.txt "$DEST/" +[ -f icon.png ] && cp icon.png "$DEST/" +[ -f THIRD_PARTY_LICENSES.txt ] && cp THIRD_PARTY_LICENSES.txt "$DEST/" +chmod +x "$DEST/autozhuyin_ibus.py" + +# 3. Start with the desktop session: registers the engine with IBus and selects it. +mkdir -p "$AUTOSTART" +cat > "$AUTOSTART/autozhuyin.desktop" </dev/null 2>&1; then + nohup "$PY" "$DEST/autozhuyin_ibus.py" --activate >/dev/null 2>&1 & + sleep 1 + echo "已啟動並切換到自動注音。" +else + echo "IBus 目前沒有在執行,請照下面的步驟啟用 IBus 後登出再登入。" +fi + +cat <<'MSG' + +安裝完成。 +- KDE(Bazzite / SteamOS 桌面模式):系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」, + 按套用後登出再登入。之後每次登入都會自動切換到自動注音。 +- 想暫時改回一般鍵盤:ibus engine xkb:us::eng ;切回自動注音:ibus engine autozhuyin +- 移除:執行 uninstall.sh +MSG diff --git a/linux/installer/uninstall.sh b/linux/installer/uninstall.sh new file mode 100755 index 0000000..2e5e55f --- /dev/null +++ b/linux/installer/uninstall.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Removes AutoZhuyin (自動注音) for the current user. Your learned corrections and +# user phrases in ~/.config/autozhuyin are kept (delete that folder to remove them). +set -uo pipefail + +DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin" +AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart/autozhuyin.desktop" + +if command -v ibus >/dev/null 2>&1 && [ "$(ibus engine 2>/dev/null)" = "autozhuyin" ]; then + ibus engine xkb:us::eng 2>/dev/null +fi +pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null +rm -rf "$DEST" "$AUTOSTART" +echo "已移除自動注音。學習紀錄留在 ~/.config/autozhuyin,不需要可以自行刪除。" diff --git a/linux/tests/test_ibus_engine.py b/linux/tests/test_ibus_engine.py new file mode 100644 index 0000000..8145670 --- /dev/null +++ b/linux/tests/test_ibus_engine.py @@ -0,0 +1,167 @@ +"""Drives autozhuyin_ibus.AutoZhuyinEngine through a minimal stand-in for +gi.repository.IBus, to catch wrapper bugs without Linux. Run from the repo root: + python3 -m unittest discover -s linux/tests +""" +import os +import sys +import types +import unittest + +LINUX = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, os.path.join(os.path.dirname(LINUX), "windows")) # autozhuyin package +sys.path.insert(0, LINUX) + + +# --- stand-in for gi / IBus (only what the wrapper uses) --- +class Flag(int): + def __or__(self, o): return Flag(int(self) | int(o)) + def __and__(self, o): return Flag(int(self) & int(o)) + + +IBus = types.SimpleNamespace() +for i, name in enumerate(["BackSpace", "Return", "KP_Enter", "Escape", "Tab", "Up", "Down", "Left", + "Right", "space", "Shift_L", "Shift_R", "Delete"]): + setattr(IBus, "KEY_" + name, 0xff00 + i) +IBus.KEY_space = 0x20 +IBus.ModifierType = types.SimpleNamespace( + SHIFT_MASK=Flag(1), LOCK_MASK=Flag(2), CONTROL_MASK=Flag(4), MOD1_MASK=Flag(8), + SUPER_MASK=Flag(1 << 26), MOD4_MASK=Flag(64), RELEASE_MASK=Flag(1 << 30)) +IBus.keyval_to_unicode = lambda k: chr(k) if 0x20 <= k < 0x7f else "\x00" + + +class Text: + def __init__(self, s): self.text, self.attrs = s, None + @staticmethod + def new_from_string(s): return Text(s) + def set_attributes(self, a): self.attrs = a + + +class AttrList(list): + pass + + +class LookupTable: + def __init__(self): self.items, self.cursor = [], 0 + @staticmethod + def new(*a): return LookupTable() + def set_orientation(self, o): pass + def clear(self): self.items = [] + def append_candidate(self, t): self.items.append(t.text) + def set_cursor_pos(self, p): self.cursor = p + + +class Property: + def __init__(self, **kw): self.label = kw["label"].text + def set_label(self, t): self.label = t.text + def set_symbol(self, t): pass + + +class Engine: + def __init__(self, *a, **kw): + self.committed, self.preedit, self.cursor, self.shown = "", "", 0, None + self.preedit_attrs = None + + def commit_text(self, t): self.committed += t.text + def update_preedit_text_with_mode(self, t, cursor, visible, mode): + self.preedit, self.cursor, self.preedit_attrs = t.text, cursor, t.attrs + def hide_preedit_text(self): self.preedit = "" + def update_lookup_table(self, table, visible): self.shown = list(table.items) + def hide_lookup_table(self): self.shown = None + def register_properties(self, p): pass + def update_property(self, p): self.mode_label = p.label + + +IBus.Text, IBus.AttrList, IBus.LookupTable, IBus.Property, IBus.Engine = Text, AttrList, LookupTable, Property, Engine +IBus.PropList = lambda: types.SimpleNamespace(append=lambda p: None) +IBus.attr_underline_new = lambda kind, a, b: ("underline", a, b) +IBus.attr_foreground_new = lambda color, a, b: ("color", a, b) +IBus.AttrUnderline = types.SimpleNamespace(SINGLE=1) +IBus.Orientation = types.SimpleNamespace(VERTICAL=1) +IBus.PropType = types.SimpleNamespace(NORMAL=0) +IBus.PropState = types.SimpleNamespace(UNCHECKED=0) +IBus.PreeditFocusMode = types.SimpleNamespace(COMMIT=1) + +gi = types.ModuleType("gi") +gi.require_version = lambda *a: None +repo = types.ModuleType("gi.repository") +repo.IBus, repo.GLib, repo.GObject = IBus, types.SimpleNamespace(), types.SimpleNamespace() +gi.repository = repo +sys.modules["gi"], sys.modules["gi.repository"] = gi, repo + +import autozhuyin_ibus # noqa: E402 + +M = IBus.ModifierType + + +def press(e, keys): + """Types keys; returns the list of 'handled' results.""" + names = {"\n": IBus.KEY_Return, "\b": IBus.KEY_BackSpace, "\t": IBus.KEY_Tab, "←": IBus.KEY_Left, + "→": IBus.KEY_Right, "↓": IBus.KEY_Down, " ": IBus.KEY_space} + out = [] + for c in keys: + kv = names.get(c, ord(c)) + out.append(e.do_process_key_event(kv, 0, Flag(0))) + e.do_process_key_event(kv, 0, M.RELEASE_MASK) + return out + + +class IBusEngineTests(unittest.TestCase): + def setUp(self): + self.e = autozhuyin_ibus.AutoZhuyinEngine() + + def test_mixed_sentence(self): + press(self.e, "ji3 hello world su3cl3 ") + self.assertEqual(self.e.committed, "我hello world 你好") + self.assertEqual(self.e.preedit, "") + + def test_preedit_marks_english_blue(self): + press(self.e, "ji3hello") + self.assertEqual(self.e.preedit, "我hello") + self.assertIn(("color", 1, 6), self.e.preedit_attrs) + self.assertEqual(self.e.cursor, 6) + + def test_space_passes_through_when_idle(self): + self.assertEqual(press(self.e, " "), [False]) + + def test_candidates_and_click(self): + press(self.e, "su3↓") + self.assertTrue(self.e.shown) + second = self.e.shown[1] + self.e.do_candidate_clicked(1, 1, 0) + self.assertIsNone(self.e.shown) + press(self.e, "\n") + self.assertEqual(self.e.committed, second) + + def test_shift_tap_toggles_english(self): + self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0)) + self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK) + self.assertEqual(self.e.mode_label, "英文") + self.assertEqual(press(self.e, "a"), [False]) # goes to the app as typed + + def test_shift_as_modifier_is_not_a_tap(self): + self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0)) + self.e.do_process_key_event(ord("A"), 0, M.SHIFT_MASK) + self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK) + self.assertFalse(self.e.engine.english_mode) + + def test_ctrl_shortcut_commits_and_passes(self): + press(self.e, "su3") + self.assertFalse(self.e.do_process_key_event(ord("c"), 0, M.CONTROL_MASK)) + self.assertEqual(self.e.committed, "你") + + def test_backtick_symbol(self): + press(self.e, "`<") + self.assertEqual(self.e.committed, ",") + + def test_insert_in_middle(self): + press(self.e, "rup fu4←wu0 \n") + self.assertEqual(self.e.committed, "今天氣") + + def test_focus_out_resets(self): + press(self.e, "su3") + self.e.do_focus_out() + self.assertEqual(self.e.engine.keys, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/scripts/package-linux.sh b/scripts/package-linux.sh new file mode 100755 index 0000000..45691ed --- /dev/null +++ b/scripts/package-linux.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# Builds build/AutoZhuyin-Linux-.tar.gz: the IBus engine, the shared Python +# core and data, and install/uninstall scripts (per-user install, no root needed). +set -euo pipefail +cd "$(dirname "$0")/.." + +VERSION="$(python3 -I -c 'import json,sys; print(json.load(open(sys.argv[1]))["version"])' windows/autozhuyin/ime.json)" +NAME="AutoZhuyin-Linux-$VERSION" +OUT="build/$NAME" + +python3 -I windows/tools/build_data.py +(cd windows && python3 -m unittest discover -q tests) +python3 -m unittest discover -q -s linux/tests + +if [ ! -f build/icon.tiff ]; then + DEVELOPER_DIR="${DEVELOPER_DIR:-/Applications/Xcode.app/Contents/Developer}" xcrun swift scripts/make-icon.swift build/icon.tiff +fi + +rm -rf "$OUT" "$OUT.tar.gz" +mkdir -p "$OUT/autozhuyin" +rsync -a --exclude __pycache__ --exclude '*.pyc' \ + windows/autozhuyin/__init__.py windows/autozhuyin/core windows/autozhuyin/data "$OUT/autozhuyin/" +cp linux/autozhuyin_ibus.py linux/installer/install.sh linux/installer/uninstall.sh linux/installer/README.txt \ + THIRD_PARTY_LICENSES.txt "$OUT/" +echo "$VERSION" > "$OUT/version.txt" +sips -s format png -z 64 64 build/icon.tiff --out "$OUT/icon.png" >/dev/null +chmod +x "$OUT/install.sh" "$OUT/uninstall.sh" "$OUT/autozhuyin_ibus.py" + +# Plain ustar without macOS extended attributes, so GNU tar doesn't warn. +(cd build && COPYFILE_DISABLE=1 tar --no-xattrs --format ustar -czf "$NAME.tar.gz" "$NAME") +echo "Built build/$NAME.tar.gz" diff --git a/scripts/release.sh b/scripts/release.sh index 66b8486..b606609 100755 --- a/scripts/release.sh +++ b/scripts/release.sh @@ -1,5 +1,5 @@ #!/bin/bash -# One-step release: bump the version, run all tests, build both installers, then +# One-step release: bump the version, run all tests, build all installers, then # commit the version change and tag it. # # Usage: scripts/release.sh [patch|minor|major] [--push] (default: patch) @@ -38,14 +38,16 @@ xcrun swift test -q 2>&1 | tail -3 echo "==> Packaging (runs the Python tests too)" scripts/package.sh >/dev/null scripts/package-windows.sh >/dev/null +scripts/package-linux.sh >/dev/null trap - ERR git add Resources/Info.plist windows/autozhuyin/ime.json git commit -q -m "Release v$VERSION" git tag -a "v$VERSION" -m "AutoZhuyin v$VERSION" echo "==> Tagged v$VERSION" -ls -lh "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" -shasum -a 256 "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" +FILES=("build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" "build/AutoZhuyin-Linux-$VERSION.tar.gz") +ls -lh "${FILES[@]}" +shasum -a 256 "${FILES[@]}" if [ "$PUSH" = 1 ]; then git push origin HEAD "v$VERSION" diff --git a/windows/autozhuyin/core/engine.py b/windows/autozhuyin/core/engine.py index 7aec1bd..8dff359 100644 --- a/windows/autozhuyin/core/engine.py +++ b/windows/autozhuyin/core/engine.py @@ -339,6 +339,8 @@ class CompositionEngine: return False # English mode: everything goes to the app as typed if key in SPECIAL_KEYS: return bool(self.keys) + if key == BACKTICK: + return True if self.keys: return True if key == " ": diff --git a/windows/tests/test_pime_wrapper.py b/windows/tests/test_pime_wrapper.py index e332b12..b865070 100644 --- a/windows/tests/test_pime_wrapper.py +++ b/windows/tests/test_pime_wrapper.py @@ -105,6 +105,10 @@ class WrapperTests(unittest.TestCase): def test_mixed_sentence(self): self.assertEqual(type_text(self.svc, "ji3 hello world su3cl3 "), "我hello world 你好") + def test_backtick_symbol(self): + self.assertEqual(type_text(self.svc, "`<"), ",") + self.assertEqual(type_text(self.svc, "ji3`."), "我。") + def test_composition_shown(self): type_text(self.svc, "su3c") self.assertEqual(self.svc.reply["compositionString"], "你ㄏ")