update: modifyWeight will sync after 1 second;

Author: MapoMagpie

core/core.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/MapoMagpie/rimedm/dict"
 	"github.com/MapoMagpie/rimedm/tui"
+	mutil "github.com/MapoMagpie/rimedm/util"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/junegunn/fzf/src/util"
@@ -178,7 +179,8 @@ func Start(opts *Options) {
 		},
 	}
 
-	// 修改权重
+	// 修改权重，这是一个高频操作，通过debouncer延迟同步到文件。
+	modifyWeightDebouncer := mutil.NewDebouncer(time.Millisecond * 1000) // 一秒后
 	modifyWeightEvent := &tui.Event{
 		Keys: []string{"ctrl+up", "ctrl+down", "ctrl+left", "ctrl+right"},
 		Cb: func(key string, m *tui.Model) (tea.Model, tea.Cmd) {
@@ -230,14 +232,17 @@ func Start(opts *Options) {
 				currEntry.ReRaw(currEntryData.ToBytes())
 				listManager.ReSort()
 				list := listManager.List()
-
 				// 重新设置 listManager 的 currIndex为当前修改的项
 				for i, item := range list {
 					if item.(*dict.MatchResult).Entry == currEntry {
 						listManager.SetIndex(i)
 						break
 					}
 				}
+				// 延迟同步到文件
+				modifyWeightDebouncer.Do(func() {
+					FlushAndSync(opts, dc, opts.SyncOnChange)
+				})
 			}
 			return m, func() tea.Msg { return 0 } // trigger bubbletea update
 		},
@@ -265,6 +270,7 @@ func Start(opts *Options) {
 	model := tui.NewModel(listManager, menuFetcher, events...)
 	teaProgram := tea.NewProgram(model)
 
+	// 输入处理 搜索
 	go func() {
 		var cancelFunc context.CancelFunc
 		resultChan := make(chan []*dict.MatchResult)
@@ -312,7 +318,15 @@ func Start(opts *Options) {
 	}
 }
 
+var lock *mutil.FLock = mutil.NewFLock()
+
+// 同步变更到文件中，如果启用了自动部署Rime的功能则调用部署指令
 func FlushAndSync(opts *Options, dc *dict.Dictionary, sync bool) {
+	// 此操作的阻塞的，但可能被异步调用，因此加上防止重复调用机制
+	if lock.Should() {
+		return
+	}
+	defer lock.Done()
 	if !sync {
 		return
 	}

dict/dictionary.go

@@ -38,7 +38,7 @@ func (d *Dictionary) Entries() []*Entry {
 }
 
 func (d *Dictionary) Search(key []rune, resultChan chan<- []*MatchResult, ctx context.Context) {
-	log.Println("search key: ", string(key))
+	// log.Println("search key: ", string(key))
 	if len(key) == 0 {
 		done := false
 		go func() {

dict/loader.go

@@ -10,6 +10,7 @@ import (
 	"reflect"
 	"sync"
 
+	"github.com/MapoMagpie/rimedm/util"
 	"github.com/goccy/go-yaml"
 )
 
@@ -65,7 +66,7 @@ var (
 
 func loadFromFile(path string, ch chan<- *FileEntries, wg *sync.WaitGroup) {
 	defer wg.Done()
-	fe := &FileEntries{FilePath: path, Entries: make([]*Entry, 0), ID: idgen.NextID()}
+	fe := &FileEntries{FilePath: path, Entries: make([]*Entry, 0), ID: util.IDGen.NextID()}
 	file, err := os.OpenFile(path, os.O_RDONLY, 0666)
 	if fe.Err = err; err != nil {
 		ch <- fe

util/debounce.go

@@ -0,0 +1,51 @@
+package util
+
+import (
+	"sync"
+	"time"
+)
+
+// Debouncer 防抖结构体
+type Debouncer struct {
+	duration time.Duration
+	timer    *time.Timer
+	mu       sync.Mutex
+}
+
+// New 创建一个新的防抖实例
+func NewDebouncer(duration time.Duration) *Debouncer {
+	return &Debouncer{
+		duration: duration,
+	}
+}
+
+// Debounce 防抖方法
+func (d *Debouncer) Do(f func()) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	// 如果已有定时器，先停止
+	if d.timer != nil {
+		d.timer.Stop()
+	}
+
+	// 设置新的定时器
+	d.timer = time.AfterFunc(d.duration, f)
+}
+
+// 使用示例：
+/*
+func main() {
+	debouncer := debounce.New(500 * time.Millisecond)
+
+	for i := 0; i < 10; i++ {
+		debouncer.Debounce(func() {
+			fmt.Println("Executed after last call!")
+		})
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// 等待足够长时间以确保最后一次执行
+	time.Sleep(600 * time.Millisecond)
+}
+*/

dict/util.go renamed to util/id_generator.go

@@ -1,4 +1,4 @@
-package dict
+package util
 
 import "sync"
 
@@ -8,7 +8,7 @@ type IDGenerator struct {
 }
 
 var (
-	idgen *IDGenerator = &IDGenerator{currentID: 0}
+	IDGen *IDGenerator = &IDGenerator{currentID: 0}
 )
 
 func (gen *IDGenerator) NextID() uint8 {

util/lock.go

@@ -0,0 +1,38 @@
+package util
+
+import (
+	"sync"
+)
+
+// FLock 用于防止函数重复调用的互斥锁工具
+type FLock struct {
+	mu    sync.Mutex
+	inUse bool
+}
+
+// NewFLock 创建一个新的 FunctionLock 实例
+func NewFLock() *FLock {
+	return &FLock{}
+}
+
+// Should 判断函数是否应该继续执行
+// 返回 true 表示可以执行，false 表示函数正在执行中
+func (fl *FLock) Should() bool {
+	fl.mu.Lock()
+	defer fl.mu.Unlock()
+
+	if fl.inUse {
+		return false
+	}
+
+	fl.inUse = true
+	return true
+}
+
+// Done 标记函数执行完成
+func (fl *FLock) Done() {
+	fl.mu.Lock()
+	defer fl.mu.Unlock()
+
+	fl.inUse = false
+}