x/icebergs
1
0
Fork 1
mirror of https://shylinux.com/x/icebergs synced 2025-04-26 09:34:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

opt some

Browse Source
This commit is contained in:
harveyshao 2021-11-02 10:07:37 +08:00
parent 51eb0852c2
commit 39f30857f0
9 changed files with 388 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
misc/git/config.go
View File

@ -16,7 +16,7 @@ func _config_get(m *ice.Message, key string) string {
return m.Cmdx(cli.SYSTEM, GIT, CONFIG, "--global", key) return m.Cmdx(cli.SYSTEM, GIT, CONFIG, "--global", key)
} }
func _config_list(m *ice.Message) { func _config_list(m *ice.Message) {
for _, v := range strings.Split(_config_get(m, "--list"), "\n") { for _, v := range strings.Split(_config_get(m, "--list"), ice.NL) {
if ls := strings.Split(v, "="); len(ls) > 1 { if ls := strings.Split(v, "="); len(ls) > 1 {
m.Push(kit.MDB_NAME, ls[0]) m.Push(kit.MDB_NAME, ls[0])
m.Push(kit.MDB_VALUE, ls[1]) m.Push(kit.MDB_VALUE, ls[1])
@ -46,26 +46,26 @@ func init() {
}, Commands: map[string]*ice.Command{ }, Commands: map[string]*ice.Command{
CONFIG: {Name: "server name auto create import", Help: "配置键", Action: map[string]*ice.Action{ CONFIG: {Name: "server name auto create import", Help: "配置键", Action: map[string]*ice.Action{
mdb.IMPORT: {Name: "import", Help: "初始化", Hand: func(m *ice.Message, arg ...string) { mdb.IMPORT: {Name: "import", Help: "初始化", Hand: func(m *ice.Message, arg ...string) {
kit.Fetch(m.Confv(CONFIG, kit.Keym("init")), func(conf string, value interface{}) { kit.Fetch(m.Configv("init"), func(conf string, value interface{}) {
kit.Fetch(value, func(key string, value string) { kit.Fetch(value, func(key string, value string) {
_config_set(m, kit.Keys(conf, key), value) _config_set(m, kit.Keys(conf, key), value)
}) })
}) })
}}, }},
mdb.CREATE: {Name: "create name value", Help: "添加", Hand: func(m *ice.Message, arg ...string) { mdb.CREATE: {Name: "create name value", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.DELETE, m.Prefix(CONFIG), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME)) m.Cmd(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME))
_config_set(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_VALUE)) _config_set(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_VALUE))
m.ProcessRefresh30ms() m.ProcessRefresh30ms()
}}, }},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) { mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_VALUE { if arg[0] == kit.MDB_VALUE {
m.Cmd(mdb.DELETE, m.Prefix(CONFIG), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME)) m.Cmd(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME))
_config_set(m, m.Option(kit.MDB_NAME), arg[1]) _config_set(m, m.Option(kit.MDB_NAME), arg[1])
m.ProcessRefresh30ms() m.ProcessRefresh30ms()
} }
}}, }},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) { mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.INSERT, m.Prefix(CONFIG), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME, kit.MDB_VALUE)) m.Cmd(mdb.INSERT, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME, kit.MDB_VALUE))
_config_set(m, "--unset", m.Option(kit.MDB_NAME)) _config_set(m, "--unset", m.Option(kit.MDB_NAME))
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

8
misc/git/git.go
View File

@ -15,18 +15,14 @@ var Index = &ice.Context{Name: GIT, Help: "代码库", Configs: map[string]*ice.
cli.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz", cli.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz",
)}, )},
}, Commands: map[string]*ice.Command{ }, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Load() }},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save() }},
GIT: {Name: "git path auto order build download", Help: "代码库", Action: ice.MergeAction(map[string]*ice.Action{ GIT: {Name: "git path auto order build download", Help: "代码库", Action: ice.MergeAction(map[string]*ice.Action{
cli.ORDER: {Name: "order", Help: "加载", Hand: func(m *ice.Message, arg ...string) { cli.ORDER: {Name: "order", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(code.INSTALL, cli.ORDER, m.Config(cli.SOURCE), "_install/bin") m.Cmdy(code.INSTALL, cli.ORDER, m.Config(cli.SOURCE), "_install/bin")
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(cli.SOURCE), "_install/libexec/git-core") m.Cmdy(code.INSTALL, cli.ORDER, m.Config(cli.SOURCE), "_install/libexec/git-core")
}}, }},
}, code.InstallAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, code.InstallAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(code.INSTALL, cli.SOURCE, m.Config(cli.SOURCE), arg) m.Cmdy(code.INSTALL, cli.SOURCE, m.Config(cli.SOURCE), arg)
}}, }},
}, }}
}
func init() { code.Index.Register(Index, &web.Frame{}) } func init() { code.Index.Register(Index, &web.Frame{}) }

76
misc/git/repos.go
View File

@ -41,55 +41,51 @@ const (
const REPOS = "repos" const REPOS = "repos"
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
Configs: map[string]*ice.Config{ REPOS: {Name: REPOS, Help: "代码库", Value: kit.Data(
REPOS: {Name: REPOS, Help: "代码库", Value: kit.Data( kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,name,branch,commit,remote",
kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,name,branch,commit,remote", kit.SSH_REPOS, "https://shylinux.com/x",
kit.SSH_REPOS, "https://shylinux.com/x", )},
)}, }, Commands: map[string]*ice.Command{
}, REPOS: {Name: "repos name path auto create", Help: "代码库", Action: ice.MergeAction(map[string]*ice.Action{
Commands: map[string]*ice.Command{ ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf(REPOS, kit.MDB_HASH, "") m.Conf(REPOS, kit.MDB_HASH, "")
_repos_insert(m, path.Base(kit.Pwd()), kit.Pwd()) _repos_insert(m, path.Base(kit.Pwd()), kit.Pwd())
m.Cmd(nfs.DIR, ice.USR, "name,path").Table(func(index int, value map[string]string, head []string) { m.Cmd(nfs.DIR, ice.USR, "name,path").Table(func(index int, value map[string]string, head []string) {
_repos_insert(m, value[kit.MDB_NAME], value[kit.MDB_PATH]) _repos_insert(m, value[kit.MDB_NAME], value[kit.MDB_PATH])
}) })
}}, }},
REPOS: {Name: "repos name path auto create", Help: "代码库", Action: map[string]*ice.Action{ mdb.CREATE: {Name: "create repos branch name path", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
mdb.CREATE: {Name: "create repos branch name path", Help: "添加", Hand: func(m *ice.Message, arg ...string) { m.Option(kit.MDB_NAME, kit.Select(strings.TrimSuffix(path.Base(m.Option(kit.SSH_REPOS)), ".git"), m.Option(kit.MDB_NAME)))
m.Option(kit.MDB_NAME, kit.Select(strings.TrimSuffix(path.Base(m.Option(kit.SSH_REPOS)), ".git"), m.Option(kit.MDB_NAME))) m.Option(kit.MDB_PATH, kit.Select(path.Join(ice.USR, m.Option(kit.MDB_NAME)), m.Option(kit.MDB_PATH)))
m.Option(kit.MDB_PATH, kit.Select(path.Join(ice.USR, m.Option(kit.MDB_NAME)), m.Option(kit.MDB_PATH))) m.Option(kit.SSH_REPOS, kit.Select(m.Conf(REPOS, kit.Keym(kit.SSH_REPOS))+ice.PS+m.Option(kit.MDB_NAME), m.Option(kit.SSH_REPOS)))
m.Option(kit.SSH_REPOS, kit.Select(m.Conf(REPOS, kit.Keym(kit.SSH_REPOS))+"/"+m.Option(kit.MDB_NAME), m.Option(kit.SSH_REPOS)))
if s, e := os.Stat(path.Join(m.Option(kit.MDB_PATH), ".git")); e == nil && s.IsDir() { if s, e := os.Stat(path.Join(m.Option(kit.MDB_PATH), ".git")); e == nil && s.IsDir() {
return
}
// 下载仓库
if s, e := os.Stat(m.Option(kit.MDB_PATH)); e == nil && s.IsDir() {
m.Option(cli.CMD_DIR, m.Option(kit.MDB_PATH))
m.Cmd(cli.SYSTEM, GIT, INIT)
m.Cmd(cli.SYSTEM, GIT, REMOTE, ADD, ORIGIN, m.Option(kit.SSH_REPOS))
m.Cmd(cli.SYSTEM, GIT, PULL, ORIGIN, MASTER)
} else {
m.Cmd(cli.SYSTEM, GIT, CLONE, "-b", kit.Select(MASTER, m.Option(BRANCH)),
m.Option(kit.SSH_REPOS), m.Option(kit.MDB_PATH))
}
_repos_insert(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_PATH))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 仓库列表
m.Fields(len(arg), m.Conf(REPOS, kit.META_FIELD))
m.Cmdy(mdb.SELECT, m.Prefix(REPOS), "", mdb.HASH)
m.Sort(kit.MDB_NAME)
return return
} }
m.Option(nfs.DIR_ROOT, _repos_path(arg[0])) // 下载仓库
m.Cmdy(nfs.CAT, kit.Select("./", arg, 1), "time,line,path") if s, e := os.Stat(m.Option(kit.MDB_PATH)); e == nil && s.IsDir() {
m.Option(cli.CMD_DIR, m.Option(kit.MDB_PATH))
m.Cmd(cli.SYSTEM, GIT, INIT)
m.Cmd(cli.SYSTEM, GIT, REMOTE, ADD, ORIGIN, m.Option(kit.SSH_REPOS))
m.Cmd(cli.SYSTEM, GIT, PULL, ORIGIN, MASTER)
} else {
m.Cmd(cli.SYSTEM, GIT, CLONE, "-b", kit.Select(MASTER, m.Option(BRANCH)),
m.Option(kit.SSH_REPOS), m.Option(kit.MDB_PATH))
}
_repos_insert(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_PATH))
}}, }},
}, }, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}) if len(arg) == 0 { // 仓库列表
mdb.HashSelect(m, arg...)
m.Sort(kit.MDB_NAME)
return
}
m.Option(nfs.DIR_ROOT, _repos_path(arg[0]))
m.Cmdy(nfs.CAT, kit.Select("./", arg, 1), "time,line,path")
}},
}})
} }

8
misc/git/spide.go
View File

@ -14,7 +14,7 @@ import (
) )
func _spide_for(text string, cb func([]string)) { func _spide_for(text string, cb func([]string)) {
for _, line := range strings.Split(text, "\n") { for _, line := range strings.Split(text, ice.NL) {
if len(line) == 0 || strings.HasPrefix(line, "!_") { if len(line) == 0 || strings.HasPrefix(line, "!_") {
continue continue
} }
@ -46,7 +46,7 @@ func _spide_go(m *ice.Message, file string) {
m.Push(kit.MDB_FILE, ls[1]) m.Push(kit.MDB_FILE, ls[1])
m.Push(kit.MDB_LINE, strings.TrimSuffix(ls[2], ";\"")) m.Push(kit.MDB_LINE, strings.TrimSuffix(ls[2], ";\""))
m.Push(kit.MDB_TYPE, ls[3]) m.Push(kit.MDB_TYPE, ls[3])
m.Push(kit.MDB_EXTRA, strings.Join(ls[4:], " ")) m.Push(kit.MDB_EXTRA, strings.Join(ls[4:], ice.SP))
}) })
} }
func _spide_c(m *ice.Message, file string) { func _spide_c(m *ice.Message, file string) {
@ -83,9 +83,9 @@ func init() {
m.Option(nfs.DIR_DEEP, ice.TRUE) m.Option(nfs.DIR_DEEP, ice.TRUE)
nfs.Dir(m, kit.MDB_PATH) nfs.Dir(m, kit.MDB_PATH)
color := []string{"yellow", "blue", "cyan", "red"} color := []string{cli.YELLOW, cli.BLUE, cli.CYAN, cli.RED}
m.Table(func(index int, value map[string]string, head []string) { m.Table(func(index int, value map[string]string, head []string) {
m.Push(kit.MDB_COLOR, color[strings.Count(value[kit.MDB_PATH], "/")%len(color)]) m.Push(kit.MDB_COLOR, color[strings.Count(value[kit.MDB_PATH], ice.PS)%len(color)])
}) })
return return
} }

244
misc/git/total.go
View File

@ -14,141 +14,139 @@ import (
const TOTAL = "total" const TOTAL = "total"
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
Configs: map[string]*ice.Config{ TOTAL: {Name: TOTAL, Help: "统计量", Value: kit.Data(
TOTAL: {Name: TOTAL, Help: "统计量", Value: kit.Data( kit.MDB_SHORT, kit.MDB_NAME, "skip", kit.Dict("wubi-dict", ice.TRUE, "word-dict", ice.TRUE),
kit.MDB_SHORT, kit.MDB_NAME, "skip", kit.Dict("wubi-dict", ice.TRUE, "word-dict", ice.TRUE), )},
)}, }, Commands: map[string]*ice.Command{
}, TOTAL: {Name: "total name auto", Help: "统计量", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
Commands: map[string]*ice.Command{ if len(arg) > 0 { // 提交详情
TOTAL: {Name: "total name auto", Help: "统计量", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Richs(REPOS, nil, arg[0], func(key string, value map[string]interface{}) {
if len(arg) > 0 { // 提交详情 m.Cmdy("_sum", kit.Value(value, kit.META_PATH), arg[1:])
m.Richs(REPOS, nil, arg[0], func(key string, value map[string]interface{}) { })
m.Cmdy("_sum", kit.Value(value, kit.META_PATH), arg[1:]) return
}) }
// 提交统计
days, commit, adds, dels, rest := 0, 0, 0, 0, 0
m.Richs(REPOS, nil, kit.MDB_FOREACH, func(mu *sync.Mutex, key string, value map[string]interface{}) {
value = kit.GetMeta(value)
if m.Conf(TOTAL, kit.Keym("skip", value[kit.MDB_NAME])) == ice.TRUE {
return return
} }
// 提交统计 msg := m.Cmd("_sum", value[kit.MDB_PATH], "total", "10000")
days, commit, adds, dels, rest := 0, 0, 0, 0, 0
m.Richs(REPOS, nil, kit.MDB_FOREACH, func(mu *sync.Mutex, key string, value map[string]interface{}) { mu.Lock()
value = kit.GetMeta(value) defer mu.Unlock()
if m.Conf(TOTAL, kit.Keym("skip", value[kit.MDB_NAME])) == ice.TRUE {
return msg.Table(func(index int, value map[string]string, head []string) {
if kit.Int(value["days"]) > days {
days = kit.Int(value["days"])
} }
commit += kit.Int(value["commit"])
msg := m.Cmd("_sum", value[kit.MDB_PATH], "total", "10000") adds += kit.Int(value["adds"])
dels += kit.Int(value["dels"])
mu.Lock() rest += kit.Int(value["rest"])
defer mu.Unlock()
msg.Table(func(index int, value map[string]string, head []string) {
if kit.Int(value["days"]) > days {
days = kit.Int(value["days"])
}
commit += kit.Int(value["commit"])
adds += kit.Int(value["adds"])
dels += kit.Int(value["dels"])
rest += kit.Int(value["rest"])
})
m.Push("name", value[kit.MDB_NAME])
m.Copy(msg)
}) })
m.Push("name", "total") m.Push("name", value[kit.MDB_NAME])
m.Push("tags", "v3.0.0") m.Copy(msg)
m.Push("days", days) })
m.Push("commit", commit)
m.Push("adds", adds) m.Push("name", "total")
m.Push("dels", dels) m.Push("tags", "v3.0.0")
m.Push("rest", rest) m.Push("days", days)
m.SortIntR("rest") m.Push("commit", commit)
m.StatusTimeCount() m.Push("adds", adds)
}}, m.Push("dels", dels)
"_sum": {Name: "_sum [path] [total] [count|date] args...", Help: "统计量", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Push("rest", rest)
if len(arg) > 0 { m.SortIntR("rest")
if s, e := os.Stat(arg[0] + "/.git"); e == nil && s.IsDir() { m.StatusTimeCount()
m.Option(cli.CMD_DIR, arg[0]) }},
arg = arg[1:] "_sum": {Name: "_sum [path] [total] [count|date] args...", Help: "统计量", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
} else if s, e := os.Stat(arg[0] + "/refs"); e == nil && s.IsDir() { if len(arg) > 0 {
m.Option(cli.CMD_DIR, arg[0]) if s, e := os.Stat(arg[0] + "/.git"); e == nil && s.IsDir() {
arg = arg[1:] m.Option(cli.CMD_DIR, arg[0])
} arg = arg[1:]
} else if s, e := os.Stat(arg[0] + "/refs"); e == nil && s.IsDir() {
m.Option(cli.CMD_DIR, arg[0])
arg = arg[1:]
}
}
total := false
if len(arg) > 0 && arg[0] == "total" {
total, arg = true, arg[1:]
}
args := []string{}
args = append(args, "log",
// kit.Format("--author=%s\\|shylinux", m.Option(ice.MSG_USERNAME)),
"--shortstat", "--pretty=commit: %ad %n%s", "--date=iso", "--reverse")
if len(arg) > 0 {
if strings.Contains(arg[0], "-") && !strings.Contains(arg[0], ":") {
arg[0] = arg[0] + " 00:00:00"
}
args = append(args, kit.Select("-n", "--since", strings.Contains(arg[0], "-")))
args = append(args, arg...)
} else {
args = append(args, "-n", "30")
}
var total_day time.Duration
count, count_add, count_del := 0, 0, 0
for i, v := range strings.Split(m.Cmdx(cli.SYSTEM, GIT, args), "commit: ") {
l := strings.Split(v, "\n")
hs := strings.Split(l[0], " ")
if len(l) < 2 {
continue
} }
total := false add, del := "0", "0"
if len(arg) > 0 && arg[0] == "total" { if len(l) > 3 {
total, arg = true, arg[1:] fs := strings.Split(strings.TrimSpace(l[3]), ", ")
} if adds := strings.Split(fs[1], " "); len(fs) > 2 {
dels := strings.Split(fs[2], " ")
args := []string{} add = adds[0]
args = append(args, "log", del = dels[0]
// kit.Format("--author=%s\\|shylinux", m.Option(ice.MSG_USERNAME)), } else if strings.Contains(adds[1], "insertion") {
"--shortstat", "--pretty=commit: %ad %n%s", "--date=iso", "--reverse") add = adds[0]
if len(arg) > 0 { } else {
if strings.Contains(arg[0], "-") && !strings.Contains(arg[0], ":") { del = adds[0]
arg[0] = arg[0] + " 00:00:00"
} }
args = append(args, kit.Select("-n", "--since", strings.Contains(arg[0], "-")))
args = append(args, arg...)
} else {
args = append(args, "-n", "30")
}
var total_day time.Duration
count, count_add, count_del := 0, 0, 0
for i, v := range strings.Split(m.Cmdx(cli.SYSTEM, GIT, args), "commit: ") {
l := strings.Split(v, "\n")
hs := strings.Split(l[0], " ")
if len(l) < 2 {
continue
}
add, del := "0", "0"
if len(l) > 3 {
fs := strings.Split(strings.TrimSpace(l[3]), ", ")
if adds := strings.Split(fs[1], " "); len(fs) > 2 {
dels := strings.Split(fs[2], " ")
add = adds[0]
del = dels[0]
} else if strings.Contains(adds[1], "insertion") {
add = adds[0]
} else {
del = adds[0]
}
}
if total {
if count++; i == 1 {
if t, e := time.Parse("2006-01-02", hs[0]); e == nil {
total_day = time.Now().Sub(t)
m.Append("from", hs[0])
}
}
count_add += kit.Int(add)
count_del += kit.Int(del)
continue
}
m.Push("date", hs[0])
m.Push("adds", add)
m.Push("dels", del)
m.Push("rest", kit.Int(add)-kit.Int(del))
m.Push("note", l[1])
m.Push("hour", strings.Split(hs[1], ":")[0])
m.Push("time", hs[1])
} }
if total { if total {
m.Push("tags", m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags")) if count++; i == 1 {
m.Push("days", int(total_day.Hours())/24) if t, e := time.Parse("2006-01-02", hs[0]); e == nil {
m.Push("commit", count) total_day = time.Now().Sub(t)
m.Push("adds", count_add) m.Append("from", hs[0])
m.Push("dels", count_del) }
m.Push("rest", count_add-count_del) }
count_add += kit.Int(add)
count_del += kit.Int(del)
continue
} }
}},
}, m.Push("date", hs[0])
m.Push("adds", add)
m.Push("dels", del)
m.Push("rest", kit.Int(add)-kit.Int(del))
m.Push("note", l[1])
m.Push("hour", strings.Split(hs[1], ":")[0])
m.Push("time", hs[1])
}
if total {
m.Push("tags", m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags"))
m.Push("days", int(total_day.Hours())/24)
m.Push("commit", count)
m.Push("adds", count_add)
m.Push("dels", count_del)
m.Push("rest", count_add-count_del)
}
}},
},
}) })
} }

131
misc/tmux/buffer.go
View File

@ -10,73 +10,74 @@ import (
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
) )
const TEXT = "text"
const BUFFER = "buffer"
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
Configs: map[string]*ice.Config{ BUFFER: {Name: BUFFER, Help: "缓存", Value: kit.Data()},
BUFFER: {Name: BUFFER, Help: "缓存", Value: kit.Data()}, }, Commands: map[string]*ice.Command{
}, BUFFER: {Name: "buffer name value auto export import", Help: "缓存", Action: map[string]*ice.Action{
Commands: map[string]*ice.Command{ mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
BUFFER: {Name: "buffer name value auto export import", Help: "缓存", Action: map[string]*ice.Action{ switch arg[0] {
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) { case kit.MDB_TEXT:
switch arg[0] { m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", m.Option(kit.MDB_NAME), arg[1])
case kit.MDB_TEXT:
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", m.Option(kit.MDB_NAME), arg[1])
}
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Conf(BUFFER, mdb.LIST, "")
m.Conf(BUFFER, kit.Keys(mdb.META, kit.MDB_COUNT), "0")
m.Cmd(BUFFER).Table(func(index int, value map[string]string, head []string) {
m.Grow(BUFFER, "", kit.Dict(
kit.MDB_NAME, value[head[0]], kit.MDB_TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", value[head[0]]),
))
})
m.Cmdy(mdb.EXPORT, m.Prefix(BUFFER), "", mdb.LIST)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Conf(BUFFER, mdb.LIST, "")
m.Conf(BUFFER, kit.Keys(mdb.META, kit.MDB_COUNT), "0")
m.Cmdy(mdb.IMPORT, m.Prefix(BUFFER), "", mdb.LIST)
m.Grows(BUFFER, "", "", "", func(index int, value map[string]interface{}) {
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", value[kit.MDB_NAME], value[kit.MDB_TEXT])
})
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 1 && arg[1] != "" { // 设置缓存
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", arg[0], arg[1])
}
if len(arg) > 0 { // 查看缓存
m.Echo(m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", arg[0]))
return
}
// 缓存列表
for i, v := range kit.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-buffers"), "\n", "\n", "\n") {
ls := strings.SplitN(v, ": ", 3)
m.Push(kit.MDB_NAME, ls[0])
m.Push(kit.MDB_SIZE, ls[1])
if i < 3 {
m.Push(kit.MDB_TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", ls[0]))
} else {
m.Push(kit.MDB_TEXT, ls[2][1:len(ls[2])-1])
}
} }
}}, }},
TEXT: {Name: "text auto save text:textarea", Help: "文本", Action: map[string]*ice.Action{ mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
nfs.SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) { m.Config(mdb.LIST, "")
if len(arg) > 0 && arg[0] != "" { m.Config(kit.MDB_COUNT, "0")
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", arg[0])
} m.Cmd(BUFFER).Table(func(index int, value map[string]string, head []string) {
m.Cmdy(TEXT) m.Grow(m.PrefixKey(), "", kit.Dict(
}}, kit.MDB_NAME, value[head[0]], kit.MDB_TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", value[head[0]]),
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ))
text := m.Cmdx(cli.SYSTEM, TMUX, "show-buffer") })
m.EchoQRCode(text) m.Cmdy(mdb.EXPORT, m.PrefixKey(), "", mdb.LIST)
m.EchoScript(text)
m.Render("")
}}, }},
}, mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
}) m.Config(mdb.LIST, "")
m.Config(kit.MDB_COUNT, "0")
m.Cmdy(mdb.IMPORT, m.PrefixKey(), "", mdb.LIST)
m.Grows(m.PrefixKey(), "", "", "", func(index int, value map[string]interface{}) {
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", value[kit.MDB_NAME], value[kit.MDB_TEXT])
})
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 1 && arg[1] != "" { // 设置缓存
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", arg[0], arg[1])
}
if len(arg) > 0 { // 查看缓存
m.Echo(m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", arg[0]))
return
}
// 缓存列表
for i, v := range kit.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-buffers"), ice.NL, ice.NL, ice.NL) {
ls := strings.SplitN(v, ": ", 3)
m.Push(kit.MDB_NAME, ls[0])
m.Push(kit.MDB_SIZE, ls[1])
if i < 3 {
m.Push(kit.MDB_TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", ls[0]))
} else {
m.Push(kit.MDB_TEXT, ls[2][1:len(ls[2])-1])
}
}
}},
TEXT: {Name: "text auto save text:textarea", Help: "文本", Action: map[string]*ice.Action{
nfs.SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 && arg[0] != "" {
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", arg[0])
}
m.Cmdy(TEXT)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
text := m.Cmdx(cli.SYSTEM, TMUX, "show-buffer")
m.EchoQRCode(text)
m.EchoScript(text)
m.Render("")
}},
}})
} }

44
misc/tmux/script.go
View File

@ -6,35 +6,19 @@ import (
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
) )
const SCRIPT = "script"
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
Configs: map[string]*ice.Config{ SCRIPT: {Name: SCRIPT, Help: "脚本", Value: kit.Data(
SCRIPT: {Name: SCRIPT, Help: "脚本", Value: kit.Data( kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,type,name,text",
kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,type,name,text", )},
)}, }, Commands: map[string]*ice.Command{
}, SCRIPT: {Name: "script name auto create export import", Help: "脚本", Action: ice.MergeAction(map[string]*ice.Action{
Commands: map[string]*ice.Command{ mdb.CREATE: {Name: "create type=shell,tmux,vim name=hi text:textarea=pwd", Help: "添加"},
SCRIPT: {Name: "script name auto create export import", Help: "脚本", Action: map[string]*ice.Action{ }, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.CREATE: {Name: "create type=shell,tmux,vim name=hi text:textarea=pwd", Help: "添加", Hand: func(m *ice.Message, arg ...string) { mdb.HashSelect(m, arg...)
m.Cmdy(mdb.INSERT, m.Prefix(SCRIPT), "", mdb.HASH, arg) m.PushAction(mdb.REMOVE)
}}, }},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) { }})
m.Cmdy(mdb.MODIFY, m.Prefix(SCRIPT), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(SCRIPT), "", mdb.HASH, m.OptionSimple(kit.MDB_NAME))
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.EXPORT, m.Prefix(SCRIPT), "", mdb.HASH)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.IMPORT, m.Prefix(SCRIPT), "", mdb.HASH)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), m.Conf(SCRIPT, kit.META_FIELD))
m.Cmdy(mdb.SELECT, m.Prefix(SCRIPT), "", mdb.HASH, kit.MDB_NAME, arg)
m.PushAction(mdb.REMOVE)
}},
},
})
} }

276
misc/tmux/session.go
View File

@ -17,157 +17,161 @@ const (
FIELDS = "fields" FIELDS = "fields"
) )
const (
SESSION = "session"
WINDOW = "window"
PANE = "pane"
VIEW = "view"
)
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
Configs: map[string]*ice.Config{ SESSION: {Name: SESSION, Help: "会话", Value: kit.Data(
SESSION: {Name: SESSION, Help: "会话", Value: kit.Data( FORMAT, "#{session_id},#{session_attached},#{session_name},#{session_windows},#{session_height},#{session_width}",
FORMAT, "#{session_id},#{session_attached},#{session_name},#{session_windows},#{session_height},#{session_width}", FIELDS, "id,tag,session,windows,height,width",
FIELDS, "id,tag,session,windows,height,width", )},
)}, WINDOW: {Name: WINDOW, Help: "窗口", Value: kit.Data(
WINDOW: {Name: WINDOW, Help: "窗口", Value: kit.Data( FORMAT, "#{window_id},#{window_active},#{window_name},#{window_panes},#{window_height},#{window_width}",
FORMAT, "#{window_id},#{window_active},#{window_name},#{window_panes},#{window_height},#{window_width}", FIELDS, "id,tag,window,panes,height,width",
FIELDS, "id,tag,window,panes,height,width", )},
)}, PANE: {Name: PANE, Help: "终端", Value: kit.Data(
PANE: {Name: PANE, Help: "终端", Value: kit.Data( FORMAT, "#{pane_id},#{pane_active},#{pane_index},#{pane_tty},#{pane_height},#{pane_width}",
FORMAT, "#{pane_id},#{pane_active},#{pane_index},#{pane_tty},#{pane_height},#{pane_width}", FIELDS, "id,tag,pane,tty,height,width",
FIELDS, "id,tag,pane,tty,height,width", )},
)}, }, Commands: map[string]*ice.Command{
}, SESSION: {Name: "session session window pane cmd auto create script", Help: "会话管理", Action: map[string]*ice.Action{
Commands: map[string]*ice.Command{ web.DREAM_CREATE: {Name: "dream.create type name", Help: "梦想", Hand: func(m *ice.Message, arg ...string) {
SESSION: {Name: "session session window pane cmd auto create script", Help: "会话管理", Action: map[string]*ice.Action{ m.Cmd(m.Prefix(SESSION), mdb.CREATE)
web.DREAM_CREATE: {Name: "dream.create type name", Help: "梦想", Hand: func(m *ice.Message, arg ...string) { }},
m.Cmd(m.Prefix(SESSION), mdb.CREATE) mdb.CREATE: {Name: "create name", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
}}, m.Option(cli.CMD_ENV, TMUX, "")
mdb.CREATE: {Name: "create name", Help: "添加", Hand: func(m *ice.Message, arg ...string) { if m.Option(PANE) != "" {
m.Option(cli.CMD_ENV, TMUX, "") m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE))
if m.Option(PANE) != "" {
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE))
} else if m.Option(WINDOW) != "" { } else if m.Option(WINDOW) != "" {
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)) m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW))
} else if m.Option(SESSION) != "" { // 创建窗口 } else if m.Option(SESSION) != "" { // 创建窗口
m.Cmdy(cli.SYSTEM, TMUX, "new-window", "-t", m.Option(SESSION), "-dn", m.Option(kit.MDB_NAME)) m.Cmdy(cli.SYSTEM, TMUX, "new-window", "-t", m.Option(SESSION), "-dn", m.Option(kit.MDB_NAME))
} else { // 创建会话 } else { // 创建会话
m.Option(cli.CMD_DIR, path.Join(m.Conf(web.DREAM, kit.META_PATH), m.Option(kit.MDB_NAME))) m.Option(cli.CMD_DIR, path.Join(m.Conf(web.DREAM, kit.META_PATH), m.Option(kit.MDB_NAME)))
ls := kit.Split(m.Option(kit.MDB_NAME), "-_") ls := kit.Split(m.Option(kit.MDB_NAME), "-_")
name := ls[len(ls)-1] name := ls[len(ls)-1]
m.Cmdy(cli.SYSTEM, TMUX, "new-session", "-ds", m.Option(kit.MDB_NAME), "-n", name) m.Cmdy(cli.SYSTEM, TMUX, "new-session", "-ds", m.Option(kit.MDB_NAME), "-n", name)
name = m.Option(kit.MDB_NAME) + ":" + ls[len(ls)-1] name = m.Option(kit.MDB_NAME) + ":" + ls[len(ls)-1]
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", kit.Keys(name, "1"), "-p", "20") m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", kit.Keys(name, "1"), "-p", "20")
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", kit.Keys(name, "2"), "-h") m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", kit.Keys(name, "2"), "-h")
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "3"), "ish_miss_log", "Enter") m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "3"), "ish_miss_log", "Enter")
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "2"), "ish_miss_space dev ops") m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "2"), "ish_miss_space dev ops")
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "1"), "vi etc/miss.sh", "Enter") m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "1"), "vi etc/miss.sh", "Enter")
m.Cmdy(cli.SYSTEM, TMUX, "link-window", "-s", name, "-t", "miss:") m.Cmdy(cli.SYSTEM, TMUX, "link-window", "-s", name, "-t", "miss:")
} }
m.ProcessRefresh30ms() m.ProcessRefresh30ms()
}}, }},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) { mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] { switch arg[0] {
case WINDOW: // 重命名窗口 case WINDOW: // 重命名窗口
m.Cmd(cli.SYSTEM, TMUX, "rename-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW), arg[1]) m.Cmd(cli.SYSTEM, TMUX, "rename-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW), arg[1])
case SESSION: // 重命名会话 case SESSION: // 重命名会话
m.Cmd(cli.SYSTEM, TMUX, "rename-session", "-t", m.Option(SESSION), arg[1]) m.Cmd(cli.SYSTEM, TMUX, "rename-session", "-t", m.Option(SESSION), arg[1])
} }
}}, }},
mdb.SELECT: {Name: "select", Help: "进入", Hand: func(m *ice.Message, arg ...string) { mdb.SELECT: {Name: "select", Help: "进入", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(cli.SYSTEM, TMUX, "switch-client", "-t", m.Option(SESSION)) m.Cmd(cli.SYSTEM, TMUX, "switch-client", "-t", m.Option(SESSION))
if m.Option(WINDOW) != "" { if m.Option(WINDOW) != "" {
m.Cmd(cli.SYSTEM, TMUX, "select-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)) m.Cmd(cli.SYSTEM, TMUX, "select-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW))
} }
if m.Option(PANE) != "" { if m.Option(PANE) != "" {
m.Cmd(cli.SYSTEM, TMUX, "select-pane", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE)) m.Cmd(cli.SYSTEM, TMUX, "select-pane", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE))
} }
}}, }},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) { mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
if m.Option(PANE) != "" { if m.Option(PANE) != "" {
m.Cmd(cli.SYSTEM, TMUX, "kill-pane", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE)) m.Cmd(cli.SYSTEM, TMUX, "kill-pane", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE))
} else if m.Option(WINDOW) != "" { } else if m.Option(WINDOW) != "" {
m.Cmd(cli.SYSTEM, TMUX, "kill-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)) m.Cmd(cli.SYSTEM, TMUX, "kill-window", "-t", m.Option(SESSION)+":"+m.Option(WINDOW))
} else if m.Option(SESSION) != "" { } else if m.Option(SESSION) != "" {
m.Cmd(cli.SYSTEM, TMUX, "kill-session", "-t", m.Option(SESSION)) m.Cmd(cli.SYSTEM, TMUX, "kill-session", "-t", m.Option(SESSION))
} }
}}, }},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) { mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] { switch arg[0] {
case kit.MDB_NAME: case kit.MDB_NAME:
m.Option(nfs.DIR_ROOT, m.Conf(web.DREAM, kit.META_PATH)) m.Option(nfs.DIR_ROOT, m.Conf(web.DREAM, kit.META_PATH))
m.Cmdy(nfs.DIR, "./", "name size time") m.Cmdy(nfs.DIR, "./", "name size time")
default: default:
m.Option(mdb.FIELDS, "name,type,text") m.Option(mdb.FIELDS, "name,type,text")
m.Cmdy(mdb.SELECT, SCRIPT, "", mdb.HASH) m.Cmdy(mdb.SELECT, SCRIPT, "", mdb.HASH)
} }
}}, }},
SCRIPT: {Name: "script name", Help: "脚本", Hand: func(m *ice.Message, arg ...string) { SCRIPT: {Name: "script name", Help: "脚本", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.SELECT, SCRIPT, "", mdb.HASH, kit.MDB_NAME, m.Option(kit.MDB_NAME)).Table(func(index int, value map[string]string, head []string) { m.Cmd(mdb.SELECT, SCRIPT, "", mdb.HASH, kit.MDB_NAME, m.Option(kit.MDB_NAME)).Table(func(index int, value map[string]string, head []string) {
switch value[kit.MDB_TYPE] { switch value[kit.MDB_TYPE] {
case "shell": case "shell":
for _, line := range kit.Split(value[kit.MDB_TEXT], "\n", "\n", "\n") { for _, line := range kit.Split(value[kit.MDB_TEXT], "\n", "\n", "\n") {
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE), line, "Enter") m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", m.Option(SESSION)+":"+m.Option(WINDOW)+"."+m.Option(PANE), line, "Enter")
}
case "tmux":
for _, line := range kit.Split(value[kit.MDB_TEXT], "\n", "\n", "\n") {
m.Cmd(cli.SYSTEM, TMUX, line)
}
case "vim":
} }
}) case "tmux":
}}, for _, line := range kit.Split(value[kit.MDB_TEXT], "\n", "\n", "\n") {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Cmd(cli.SYSTEM, TMUX, line)
if len(arg) > 3 { // 执行命令 }
target := arg[0] + ":" + arg[1] + "." + arg[2] case "vim":
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", target, strings.Join(arg[3:], " "), "Enter")
m.Sleep("100ms")
}
if len(arg) > 2 { // 终端内容
target := arg[0] + ":" + arg[1] + "." + arg[2]
m.Echo(strings.TrimSpace(m.Cmdx(VIEW, target)))
return
}
if len(arg) == 2 { // 终端列表
m.Cmdy(PANE, arg[0]+":"+arg[1])
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
}
if len(arg) == 1 { // 窗口列表
m.Cmdy(WINDOW, arg[0])
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
}
// 会话列表
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-session", "-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n")
m.Table(func(index int, value map[string]string, head []string) {
switch value["tag"] {
case "1":
m.PushButton("")
default:
m.PushButton(mdb.SELECT, mdb.REMOVE)
} }
}) })
}}, }},
WINDOW: {Name: "windows", Help: "窗口", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-windows", "-t", kit.Select("", arg, 0), if len(arg) > 3 { // 执行命令
"-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n") target := arg[0] + ":" + arg[1] + "." + arg[2]
}}, m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", target, strings.Join(arg[3:], " "), "Enter")
PANE: {Name: "panes", Help: "终端", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Sleep("100ms")
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-panes", "-t", kit.Select("", arg, 0), }
"-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n") if len(arg) > 2 { // 终端内容
}}, target := arg[0] + ":" + arg[1] + "." + arg[2]
VIEW: {Name: "view", Help: "终端", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Echo(strings.TrimSpace(m.Cmdx(VIEW, target)))
m.Cmdy(cli.SYSTEM, TMUX, "capture-pane", "-pt", kit.Select("", arg, 0)).Set(ice.MSG_APPEND) return
}}, }
}, if len(arg) == 2 { // 终端列表
}) m.Cmdy(PANE, arg[0]+":"+arg[1])
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
}
if len(arg) == 1 { // 窗口列表
m.Cmdy(WINDOW, arg[0])
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
}
// 会话列表
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-session", "-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n")
m.Table(func(index int, value map[string]string, head []string) {
switch value["tag"] {
case "1":
m.PushButton("")
default:
m.PushButton(mdb.SELECT, mdb.REMOVE)
}
})
}},
WINDOW: {Name: "windows", Help: "窗口", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-windows", "-t", kit.Select("", arg, 0),
"-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n")
}},
PANE: {Name: "panes", Help: "终端", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-panes", "-t", kit.Select("", arg, 0),
"-F", m.Conf(m.Prefix(cmd), kit.Keym(FORMAT))), m.Conf(m.Prefix(cmd), kit.Keym(FIELDS)), ",", "\n")
}},
VIEW: {Name: "view", Help: "终端", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(cli.SYSTEM, TMUX, "capture-pane", "-pt", kit.Select("", arg, 0)).Set(ice.MSG_APPEND)
}},
}})
} }

13
misc/tmux/tmux.go
View File

@ -8,16 +8,6 @@ import (
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
) )
const (
TEXT = "text"
BUFFER = "buffer"
SCRIPT = "script"
SESSION = "session"
WINDOW = "window"
PANE = "pane"
VIEW = "view"
)
const TMUX = "tmux" const TMUX = "tmux"
var Index = &ice.Context{Name: TMUX, Help: "工作台", Configs: map[string]*ice.Config{ var Index = &ice.Context{Name: TMUX, Help: "工作台", Configs: map[string]*ice.Config{
@ -25,9 +15,6 @@ var Index = &ice.Context{Name: TMUX, Help: "工作台", Configs: map[string]*ice
cli.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz", cli.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz",
)}, )},
}, Commands: map[string]*ice.Command{ }, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Load() }},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save() }},
TMUX: {Name: "tmux path auto start order build download", Help: "服务", Action: ice.MergeAction(map[string]*ice.Action{ TMUX: {Name: "tmux path auto start order build download", Help: "服务", Action: ice.MergeAction(map[string]*ice.Action{
cli.START: {Name: "start", Help: "启动", Hand: func(m *ice.Message, arg ...string) { cli.START: {Name: "start", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Optionv(code.PREPARE, func(p string) []string { m.Optionv(code.PREPARE, func(p string) []string {