liubin/icebergs
1
0
Fork 0
forked from x/icebergs
Code Pull Requests Activity

opt misc

Browse Source
This commit is contained in:
IT 老营长 @云轩领航-创始人 2022-08-16 10:41:05 +08:00
parent 056684387a
commit 4bbdd8d9e4
54 changed files with 427 additions and 483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/aaa/user.go
View File

@ -92,7 +92,7 @@ func UserRoot(m *ice.Message, arg ...string) *ice.Message { // password username
return m
}
func UserInfo(m *ice.Message, name ice.Any, key, meta string) (value string) {
if m.Cmd(USER, name).Tables(func(val ice.Maps) {
if m.Cmd(USER, name, func(val ice.Maps) {
value = val[key]
}).Length() == 0 && kit.Format(name) == m.Option(ice.MSG_USERNAME) {
return m.Option(meta)

2
base/ctx/context.go
View File

@ -33,7 +33,7 @@ func init() {
DisplayStorySpide(m, lex.PREFIX, m.ActionKey(), nfs.ROOT, kit.Select(ice.ICE, arg, 0), lex.SPLIT, ice.PT)
} else if index := kit.Keys(arg[1]); strings.HasSuffix(index, arg[2]) { // 命令列表
m.Cmdy(CONTEXT, index, COMMAND).Tables(func(value ice.Maps) {
m.Cmdy(CONTEXT, index, COMMAND, func(value ice.Maps) {
m.Push(nfs.FILE, arg[1])
})

17
base/mdb/hash.go
View File

@ -14,6 +14,15 @@ func _hash_fields(m *ice.Message) []string {
return kit.Split(kit.Select(HASH_FIELD, m.OptionFields()))
}
func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
switch field {
case EXPIRE:
m.Push(field, "72h")
m.Push(field, "24h")
m.Push(field, "8h")
m.Push(field, "3h")
m.Push(field, "1h")
return
}
defer RLock(m, prefix, chain)()
list := map[string]int{}
@ -206,7 +215,13 @@ func HashCreate(m *ice.Message, arg ...Any) string {
return m.Echo(msg.Cmdx(INSERT, m.PrefixKey(), "", HASH, HashArgs(msg, arg...))).Result()
}
func HashRemove(m *ice.Message, arg ...Any) *ice.Message {
return m.Cmdy(DELETE, m.PrefixKey(), "", HASH, m.OptionSimple(HashShort(m)), arg)
args := kit.Simple(arg)
if len(args) == 0 {
args = m.OptionSimple(HashShort(m))
} else if len(args) == 1 {
args = []string{HashShort(m), args[0]}
}
return m.Cmdy(DELETE, m.PrefixKey(), "", HASH, args)
}
func HashModify(m *ice.Message, arg ...Any) *ice.Message {
return m.Cmd(MODIFY, m.PrefixKey(), "", HASH, m.OptionSimple(HashShort(m)), HashArgs(m, arg...))

4
base/mdb/list.go
View File

@ -93,9 +93,9 @@ func _list_import(m *ice.Message, prefix, chain, file string) {
defer f.Close()
r := csv.NewReader(f)
count := 0
head, _ := r.Read()
count := 0
for {
line, e := r.Read()
if e != nil {

8
base/mdb/zone.go
View File

@ -182,7 +182,13 @@ func ZoneCreate(m *ice.Message, arg ...Any) {
m.Cmdy(INSERT, m.PrefixKey(), "", HASH, arg)
}
func ZoneRemove(m *ice.Message, arg ...Any) {
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, m.OptionSimple(ZoneShort(m)), arg)
args := kit.Simple(arg)
if len(args) == 0 {
args = m.OptionSimple(ZoneShort(m))
} else if len(args) == 1 {
args = []string{ZoneShort(m), args[0]}
}
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, args)
}
func ZoneInsert(m *ice.Message, arg ...Any) {
args := kit.Simple(arg...)

2
base/nfs/pack.go
View File

@ -148,7 +148,7 @@ func CloseFile(m *ice.Message, p ice.Any) {
}
func CopyFile(m *ice.Message, to io.WriteCloser, from io.ReadCloser, cb func(int)) {
buf := make([]byte, ice.MOD_BUFS)
buf := make([]byte, 1024*1024)
for {
n, e := from.Read(buf)
if e != nil {

2
base/tcp/host.go
View File

@ -69,7 +69,7 @@ func init() {
Index.MergeCommands(ice.Commands{
HOST: {Name: "host name auto", Help: "主机", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(HOST).Tables(func(value ice.Maps) { m.Cmd(HOST, aaa.WHITE, value[aaa.IP]) })
m.Cmd(HOST, func(value ice.Maps) { m.Cmd(HOST, aaa.WHITE, value[aaa.IP]) })
}},
aaa.BLACK: {Name: "black", Help: "黑名单", Hand: func(m *ice.Message, arg ...string) {
m.Logs(mdb.CREATE, aaa.BLACK, arg[0])

2
base/tcp/port.go
View File

@ -63,7 +63,7 @@ func init() {
current := kit.Int(m.Config(BEGIN))
m.Option(nfs.DIR_ROOT, ice.USR_LOCAL_DAEMON)
m.Cmd(nfs.DIR, nfs.PWD, nfs.DIR_CLI_FIELDS).Tables(func(value ice.Maps) {
m.Cmd(nfs.DIR, nfs.PWD, nfs.DIR_CLI_FIELDS, func(value ice.Maps) {
bin := m.Cmd(nfs.DIR, path.Join(value[nfs.PATH], ice.BIN), nfs.DIR_CLI_FIELDS).Append(nfs.PATH)
if bin == "" {
bin = m.Cmd(nfs.DIR, path.Join(value[nfs.PATH], "sbin"), nfs.DIR_CLI_FIELDS).Append(nfs.PATH)

2
base/web/option.go
View File

@ -101,7 +101,7 @@ func PushPodCmd(m *ice.Message, cmd string, arg ...string) {
m.Tables(func(value ice.Maps) { m.Push(ice.POD, m.Option(ice.MSG_USERPOD)) })
}
m.Cmd(SPACE, ice.OptionFields(mdb.TYPE, mdb.NAME)).Tables(func(value ice.Maps) {
m.Cmd(SPACE, ice.OptionFields(mdb.TYPE, mdb.NAME), func(value ice.Maps) {
switch value[mdb.TYPE] {
case SERVER, WORKER:
if value[mdb.NAME] == ice.Info.HostName {

6
base/web/route.go
View File

@ -12,14 +12,14 @@ import (
)
func _route_travel(m *ice.Message, route string) {
m.Cmd(SPACE).Tables(func(val ice.Maps) {
m.Cmd(SPACE, func(val ice.Maps) {
switch val[mdb.TYPE] {
case SERVER: // 远程查询
if val[mdb.NAME] == ice.Info.NodeName {
return // 避免循环
}
m.Cmd(SPACE, val[mdb.NAME], ROUTE).Tables(func(value ice.Maps) {
m.Cmd(SPACE, val[mdb.NAME], ROUTE, func(value ice.Maps) {
m.Push(mdb.TYPE, value[mdb.TYPE])
m.Push(ROUTE, kit.Keys(val[mdb.NAME], value[ROUTE]))
})
@ -44,7 +44,7 @@ func _route_list(m *ice.Message) *ice.Message {
// 网卡信息
u := OptionUserWeb(m)
m.Cmd(tcp.HOST).Tables(func(value ice.Maps) {
m.Cmd(tcp.HOST, func(value ice.Maps) {
m.Push(mdb.TYPE, MYSELF)
m.Push(ROUTE, ice.Info.NodeName)
m.PushAnchor(value[aaa.IP], kit.Format("%s://%s:%s", u.Scheme, value[aaa.IP], u.Port()))

6
base/web/serve.go
View File

@ -374,10 +374,10 @@ func init() {
PP(ice.REQUIRE): {Name: "/require/shylinux.com/x/volcanos/proto.js", Help: "代码库", Hand: func(m *ice.Message, arg ...string) {
_share_repos(m, path.Join(arg[0], arg[1], arg[2]), arg[3:]...)
}},
PP(ice.REQUIRE, ice.PAGE, ice.NODE_MODULES): {Name: "/require/page/node_modules/", Help: "依赖库", Hand: func(m *ice.Message, arg ...string) {
p := path.Join(ice.USR_VOLCANOS, ice.PAGE, ice.NODE_MODULES, path.Join(arg...))
PP(ice.REQUIRE, ice.NODE_MODULES): {Name: "/require/node_modules/", Help: "依赖库", Hand: func(m *ice.Message, arg ...string) {
p := path.Join(ice.SRC, ice.NODE_MODULES, path.Join(arg...))
if !nfs.ExistsFile(m, p) {
m.Cmd(cli.SYSTEM, "npm", "install", arg[0], kit.Dict(cli.CMD_DIR, path.Join(ice.USR_VOLCANOS, ice.PAGE)))
m.Cmd(cli.SYSTEM, "npm", "install", arg[0], kit.Dict(cli.CMD_DIR, path.Join(ice.SRC)))
}
m.RenderDownload(p)
}},

6
base/web/space.go
View File

@ -247,7 +247,7 @@ func _space_fork(m *ice.Message) {
}
}
func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
m.Cmd(SPACE, ice.OptionFields("")).Tables(func(value ice.Maps) {
m.Cmd(SPACE, ice.OptionFields(""), func(value ice.Maps) {
if !strings.Contains(value[mdb.NAME], name) {
return
}
@ -262,8 +262,8 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
if name != "" {
return
}
m.Cmd(SERVE, ice.OptionFields("")).Tables(func(val ice.Maps) {
m.Cmd(tcp.HOST, ice.OptionFields("")).Tables(func(value ice.Maps) {
m.Cmd(SERVE, ice.OptionFields(""), func(val ice.Maps) {
m.Cmd(tcp.HOST, ice.OptionFields(""), func(value ice.Maps) {
m.PushSearch(kit.SimpleKV("", MYSELF, value[mdb.NAME], kit.Format("http://%s:%s", value[aaa.IP], val[tcp.PORT])))
})
})

16
base/web/spide.go
View File

@ -258,9 +258,19 @@ func _spide_save(m *ice.Message, cache, save, uri string, res *http.Response) {
if f, p, e := nfs.CreateFile(m, save); m.Assert(e) {
defer f.Close()
if n, e := io.Copy(f, res.Body); m.Assert(e) {
m.Logs(mdb.EXPORT, nfs.SIZE, n, nfs.FILE, p)
m.Echo(p)
total := kit.Int(res.Header.Get(ContentLength)) + 1
switch cb := m.OptionCB("").(type) {
case func(int, int, int):
count := 0
nfs.CopyFile(m, f, res.Body, func(n int) {
count += n
cb(count, total, count*100/total)
})
default:
if n, e := io.Copy(f, res.Body); m.Assert(e) {
m.Logs(mdb.EXPORT, nfs.SIZE, n, nfs.FILE, p)
m.Echo(p)
}
}
}

4
core/chat/river.go
View File

@ -43,8 +43,8 @@ func _river_list(m *ice.Message) {
}
}
m.Cmd(mdb.SELECT, m.PrefixKey(), "", mdb.HASH, ice.OptionFields(mdb.HASH, mdb.NAME)).Tables(func(value ice.Maps) {
m.Cmd(mdb.SELECT, m.PrefixKey(), kit.Keys(mdb.HASH, value[mdb.HASH], OCEAN), mdb.HASH, m.Option(ice.MSG_USERNAME)).Tables(func(val ice.Maps) {
m.Cmd(mdb.SELECT, m.PrefixKey(), "", mdb.HASH, ice.OptionFields(mdb.HASH, mdb.NAME), func(value ice.Maps) {
m.Cmd(mdb.SELECT, m.PrefixKey(), kit.Keys(mdb.HASH, value[mdb.HASH], OCEAN), mdb.HASH, m.Option(ice.MSG_USERNAME), func(val ice.Maps) {
m.Push("", value, []string{mdb.HASH, mdb.NAME}, val)
})
})

2
core/chat/room.go
View File

@ -28,7 +28,7 @@ func init() {
}},
mdb.INSERT: {Name: "insert zone type=hi name=hello text=world", Help: "发送", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.PrefixKey(), "", mdb.ZONE, m.Option(mdb.ZONE), arg[2:])
m.Cmdy(mdb.SELECT, m.PrefixKey(), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, ice.Option{"fields", "time,space"}).Tables(func(value ice.Maps) {
m.Cmdy(mdb.SELECT, m.PrefixKey(), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, ice.Option{"fields", "time,space"}, func(value ice.Maps) {
m.Cmdy(web.SPACE, value[web.SPACE], "toast", m.Option("text"), m.Option("name"))
})
}},

4
core/chat/template.go
View File

@ -27,9 +27,9 @@ func init() {
}
}},
RIVER_CREATE: {Name: "river.create river template", Help: "建群", Hand: func(m *ice.Message, arg ...string) {
m.Cmd("", m.Option(TEMPLATE)).Tables(func(value ice.Maps) {
m.Cmd("", m.Option(TEMPLATE), func(value ice.Maps) {
h := m.Cmdx(STORM, mdb.CREATE, mdb.TYPE, "", mdb.NAME, value[STORM], mdb.TEXT, "")
m.Cmd("", m.Option(TEMPLATE), value[STORM]).Tables(func(value ice.Maps) {
m.Cmd("", m.Option(TEMPLATE), value[STORM], func(value ice.Maps) {
m.Cmd(STORM, mdb.INSERT, mdb.HASH, h, kit.SimpleKV("space,index", value))
})
})

2
core/chat/topic.go
View File

@ -108,7 +108,7 @@ body.{{.Option "topic"}} fieldset.panel.Header>div.output div:hover { background
m.Cmd(nfs.SAVE, path.Join("src/website/topic/"+m.Option("topic")+".css"), string(buf))
}},
"form": {Name: "form", Help: "表单", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(m.CommandKey(), m.Option(mdb.ZONE)).Tables(func(value ice.Maps) {
m.Cmd(m.CommandKey(), m.Option(mdb.ZONE), func(value ice.Maps) {
tags, _ := form[value["tags"]]
m.Push("tags", value["tags"])
m.Push("type", kit.Select(kit.Format(kit.Value(tags, "type")), value["type"]))

2
core/chat/website.go
View File

@ -149,7 +149,7 @@ func _website_render(m *ice.Message, w http.ResponseWriter, r *http.Request, kin
return true
}
func _website_search(m *ice.Message, kind, name, text string, arg ...string) {
m.Cmd(m.PrefixKey(), ice.OptionFields("")).Tables(func(value ice.Maps) {
m.Cmd(m.PrefixKey(), ice.OptionFields(""), func(value ice.Maps) {
m.PushSearch(value, mdb.TEXT, MergeWebsite(m, value[nfs.PATH]))
})
}

2
core/code/case.go
View File

@ -25,7 +25,7 @@ func init() {
cli.CHECK: {Name: "check", Help: "检查", Hand: func(m *ice.Message, arg ...string) {
if m.ProcessInner(); len(arg) > 0 {
success := 0
m.Cmd(m.PrefixKey(), arg[0]).Tables(func(value ice.Maps) {
m.Cmd(m.PrefixKey(), arg[0], func(value ice.Maps) {
m.Push(mdb.TIME, m.Time())
m.Push(mdb.ID, value[mdb.ID])
if err := m.Cmdx(m.PrefixKey(), cli.CHECK, value); err == ice.OK {

4
core/code/go.go
View File

@ -54,10 +54,10 @@ func _go_help(m *ice.Message, key string) {
}
}
func _go_find(m *ice.Message, key string, dir string) {
m.Cmd(nfs.FIND, dir, key).Tables(func(value ice.Maps) { m.PushSearch(nfs.LINE, 1, value) })
m.Cmd(nfs.FIND, dir, key, func(value ice.Maps) { m.PushSearch(nfs.LINE, 1, value) })
}
func _go_grep(m *ice.Message, key string, dir string) {
m.Cmd(nfs.GREP, dir, key).Tables(func(value ice.Maps) { m.PushSearch(value) })
m.Cmd(nfs.GREP, dir, key, func(value ice.Maps) { m.PushSearch(value) })
}
var _cache_mods = ice.Messages{}

2
core/code/inner.go
View File

@ -122,7 +122,7 @@ func init() {
m.Option(nfs.DIR_ROOT, arg[2])
m.Option(cli.CMD_DIR, kit.Path(arg[2]))
m.Cmdy(mdb.SEARCH, arg[0], arg[1], arg[2])
m.Cmd(FAVOR, arg[1], ice.OptionFields("")).Tables(func(value ice.Maps) {
m.Cmd(FAVOR, arg[1], ice.OptionFields(""), func(value ice.Maps) {
if p := path.Join(value[nfs.PATH], value[nfs.FILE]); strings.HasPrefix(p, m.Option(nfs.PATH)) {
m.Push(nfs.FILE, strings.TrimPrefix(p, m.Option(nfs.PATH)))
m.Push(nfs.LINE, value[nfs.LINE])

19
core/code/install.go
View File

@ -3,6 +3,7 @@ package code
import (
"path"
"strings"
"time"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
@ -38,13 +39,19 @@ func _install_download(m *ice.Message) {
}
m.Cmd(nfs.SAVE, file, "")
web.GoToast(m, web.DOWNLOAD, func(toast func(string, int, int)) {
mdb.HashCreate(m, mdb.NAME, name, nfs.PATH, file, mdb.LINK, link)
begin, last := time.Now(), time.Now()
mdb.HashCreate(m, mdb.NAME, name, nfs.PATH, file, mdb.LINK, link)
web.GoToast(m, name, func(toast func(string, int, int)) {
m.Cmd("web.spide", ice.DEV, web.SPIDE_SAVE, file, web.SPIDE_GET, link, func(count int, total int, step int) {
mdb.HashSelectUpdate(m, name, func(value ice.Map) {
value[mdb.COUNT], value[mdb.TOTAL], value[mdb.VALUE] = count, total, step
})
toast(name, count, total)
mdb.HashSelectUpdate(m, name, func(value ice.Map) { value[mdb.COUNT], value[mdb.TOTAL], value[mdb.VALUE] = count, total, step })
if now := time.Now(); now.Sub(last) > 500*time.Millisecond {
cost := now.Sub(begin)
toast(kit.FormatShow("from", begin.Format("15:04:05"), "cost", kit.FmtDuration(cost),
"rest", kit.FmtDuration(cost*time.Duration(100)/time.Duration(step+1)-cost),
), count, total)
last = now
}
})
m.Cmd(nfs.TAR, mdb.EXPORT, name, kit.Dict(cli.CMD_DIR, path.Dir(file)))
web.PushNoticeRefresh(m)

2
core/code/pprof.go
View File

@ -40,7 +40,7 @@ func init() {
case BINNARY:
m.Cmdy(nfs.DIR, ice.BIN, nfs.DIR_CLI_FIELDS).RenameAppend(nfs.PATH, BINNARY)
case SERVICE:
m.Cmd(web.SPIDE).Tables(func(value ice.Maps) {
m.Cmd(web.SPIDE, func(value ice.Maps) {
m.Push(SERVICE, kit.MergeURL2(value[web.CLIENT_URL], "/debug/pprof/profile"))
})
}

9
core/code/webpack.go
View File

@ -29,7 +29,7 @@ func _webpack_can(m *ice.Message) {
}
func _webpack_css(m *ice.Message, css, js io.Writer, p string) {
fmt.Fprintln(css, kit.Format("/* %s */", path.Join(ice.PS, p)))
fmt.Fprintln(css, m.Cmdx(nfs.CAT, strings.TrimPrefix(p, ice.REQUIRE+ice.PS)))
fmt.Fprintln(css, m.Cmdx(nfs.CAT, strings.Replace(p, "require/node_modules/", "src/node_modules/", 1)))
fmt.Fprintln(js, `Volcanos.meta.cache["`+path.Join(ice.PS, p)+`"] = []`)
}
func _webpack_js(m *ice.Message, js io.Writer, p string) {
@ -38,7 +38,7 @@ func _webpack_js(m *ice.Message, js io.Writer, p string) {
}
func _webpack_node(m *ice.Message, js io.Writer, p string) {
fmt.Fprintln(js, `_can_name = "`+path.Join(ice.PS, p)+`"`)
fmt.Fprintln(js, m.Cmdx(nfs.CAT, strings.TrimPrefix(p, ice.REQUIRE+ice.PS)))
fmt.Fprintln(js, m.Cmdx(nfs.CAT, strings.Replace(p, "require/node_modules/", "src/node_modules/", 1)))
fmt.Fprintln(js, `Volcanos.meta.cache["`+path.Join(ice.PS, p)+`"] = []`)
}
func _webpack_cache(m *ice.Message, dir string, write bool) {
@ -82,18 +82,19 @@ func _webpack_cache(m *ice.Message, dir string, write bool) {
_webpack_js(m, js, k)
}
m.Option(nfs.DIR_ROOT, "")
mdb.HashSelects(m).Sort(nfs.PATH).Tables(func(value ice.Maps) {
defer fmt.Fprintln(js)
p := value[nfs.PATH]
switch kit.Ext(p) {
case nfs.CSS:
_webpack_css(m, css, js, path.Join(ice.REQUIRE, ice.PAGE, ice.NODE_MODULES, p))
_webpack_css(m, css, js, path.Join(ice.REQUIRE, ice.NODE_MODULES, p))
return
case nfs.JS:
default:
p = p + "/lib/" + p + ".js"
}
_webpack_node(m, js, path.Join(ice.REQUIRE, ice.PAGE, ice.NODE_MODULES, p))
_webpack_node(m, js, path.Join(ice.REQUIRE, ice.NODE_MODULES, p))
})
}
func _webpack_build(m *ice.Message, file string) {

2
core/mall/asset.go
View File

@ -83,7 +83,7 @@ func init() {
}},
CHECK: {Name: "check", Help: "核算", Hand: func(m *ice.Message, arg ...string) {
if m.Option(ACCOUNT) == "" {
m.Cmd(ASSET).Tables(func(value ice.Maps) {
m.Cmd(ASSET, func(value ice.Maps) {
_asset_check(m, value[ACCOUNT])
})
m.ProcessRefresh30ms()

2
core/wiki/word.go
View File

@ -50,7 +50,7 @@ func init() {
if arg[0] == mdb.FOREACH && arg[1] == "" {
m.PushSearch(mdb.TYPE, nfs.SHY, mdb.NAME, ice.SRC_MAIN_SHY, mdb.TEXT, chat.MergeCmd(m, ""))
}
m.Cmd(mdb.SELECT, m.PrefixKey(), "", mdb.HASH).Tables(func(value ice.Maps) {
m.Cmd(mdb.SELECT, m.PrefixKey(), "", mdb.HASH, func(value ice.Maps) {
if arg[1] == "" {
if value[mdb.TYPE] == SPARK {
value[mdb.TEXT] = ice.Render(m, ice.RENDER_SCRIPT, value[mdb.TEXT])

2
logs.go
View File

@ -145,7 +145,7 @@ func (m *Message) FormatShip() string {
return kit.Format("%s->%s", m.source.Name, m.target.Name)
}
func (m *Message) FormatCost() string {
return kit.FmtTime(kit.Int64(time.Since(m.time)))
return kit.FmtDuration(time.Since(m.time))
}
func (m *Message) FormatSize() string {
return kit.Format("%dx%d %v", m.Length(), len(m.meta[MSG_APPEND]), kit.Simple(m.meta[MSG_APPEND]))

60
misc/alpha/alpha.go
View File

@ -18,68 +18,64 @@ const (
)
type alpha struct {
cache
ice.Zone
field string `data:"word,translation,definition"`
store string `data:"usr/local/export/alpha"`
store string `data:"usr/local/export"`
fsize string `data:"300000"`
limit string `data:"50000"`
least string `data:"1000"`
load string `name:"load file=usr/word-dict/ecdict name=ecdict" help:"词典"`
load string `name:"load file=usr/word-dict/ecdict name=ecdict" help:"加载"`
list string `name:"list method=word,line word auto" help:"词典"`
}
func (a alpha) Load(m *ice.Message, arg ...string) {
name := m.Option(mdb.NAME)
func (s alpha) Load(m *ice.Message, arg ...string) {
// 清空数据
meta := m.Confm(m.PrefixKey(), mdb.META)
m.Assert(nfs.RemoveAll(m.Message, path.Join(kit.Format(meta[mdb.STORE]), name)))
m.Conf(m.PrefixKey(), name, "")
lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
m.Assert(nfs.RemoveAll(m.Message, path.Join(m.Config(mdb.STORE), lib)))
s.Zone.Remove(m, mdb.ZONE, lib)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.FIELD, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
prefix := kit.Keys(mdb.HASH, m.Result())
// 缓存配置
m.Conf(m.PrefixKey(), kit.Keys(name, mdb.META), kit.Dict(meta))
m.Cmd(mdb.IMPORT, m.PrefixKey(), name, mdb.LIST, m.Option(nfs.FILE))
// 加载配置
m.Cmd(mdb.IMPORT, m.PrefixKey(), prefix, mdb.LIST, m.Option(nfs.FILE))
// 保存词库
m.Conf(m.PrefixKey(), kit.Keys(name, kit.Keym(mdb.LIMIT)), 0)
m.Conf(m.PrefixKey(), kit.Keys(name, kit.Keym(mdb.LEAST)), 0)
m.Echo("%s: %d", name, mdb.Grow(m.Message, m.PrefixKey(), name, kit.Dict(WORD, ice.SP)))
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
m.Echo("%s: %d", lib, mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(WORD, ice.SP)))
}
func (a alpha) List(m *ice.Message, arg ...string) {
func (s alpha) List(m *ice.Message, arg ...string) {
if len(arg) < 2 || arg[1] == "" {
m.Cmdy(a.cache, kit.Slice(arg, 1))
return
m.Cmdy(cache{}, kit.Slice(arg, 1))
return // 缓存列表
}
// 搜索方法
switch arg[1] = strings.TrimSpace(arg[1]); arg[0] {
case LINE:
m.OptionFields(m.Config(mdb.FIELD))
case WORD:
if m.Cmdy(a.cache, kit.Slice(arg, 1)); m.Length() > 0 {
return
if m.Cmdy(cache{}, kit.Slice(arg, 1)); m.Length() > 0 {
return // 查询缓存
}
defer func() {
if m.Length() > 0 {
m.Cmd(a.cache.Create, m.AppendSimple())
if m.Length() > 0 { // 写入缓存
m.Cmd(cache{}, mdb.CREATE, m.AppendSimple())
}
}()
m.OptionFields(mdb.DETAIL)
// 精确匹配
m.OptionFields(ice.FIELDS_DETAIL)
arg[1] = "^" + arg[1] + ice.FS
}
// 搜索词汇
msg := m.Cmd(cli.SYSTEM, "grep", "-rih", arg[1], m.Config(mdb.STORE))
wiki.CSV(msg.Message, msg.Result(), kit.Split(m.Config(mdb.FIELD))...).Tables(func(value ice.Maps) {
wiki.CSV(m.Message, m.Cmdx(cli.SYSTEM, "grep", "-rih", arg[1], m.Config(mdb.STORE)), kit.Split(m.Config(mdb.FIELD))...).Tables(func(value ice.Maps) {
if m.FieldsIsDetail() {
m.Push(mdb.DETAIL, value, kit.Split(m.Config(mdb.FIELD)))
m.Push(mdb.TIME, m.Time())
return
m.PushDetail(value, m.Config(mdb.FIELD))
} else {
m.PushRecord(value, m.Config(mdb.FIELD))
}
m.PushSearch(kit.SimpleKV("", arg[0], value[WORD], value["translation"]), value)
})
m.StatusTimeCount()
}).StatusTimeCount()
}
func init() { ice.Cmd("web.wiki.alpha.alpha", alpha{}) }

2
misc/alpha/alpha.shy
View File

@ -1,3 +1,3 @@
chapter "alpha"
field "英汉" web.wiki.input.input
field web.wiki.alpha.alpha

10
misc/alpha/cache.go
View File

@ -6,13 +6,9 @@ import (
type cache struct {
ice.Hash
short string `data:"word"`
field string `data:"time,word,translation,definition"`
create string `name:"create word translation definition" help:"创建"`
}
func (c cache) Create(m *ice.Message, arg ...string) {
c.Hash.Create(m, arg...)
short string `data:"word"`
field string `data:"time,word,translation,definition"`
list string `name:"list word auto create prunes" help:"缓存"`
}
func init() { ice.Cmd("web.wiki.alpha.cache", cache{}) }

2
misc/bash/configs.go
View File

@ -10,7 +10,7 @@ import (
func init() {
Index.MergeCommands(ice.Commands{
"/configs": {Name: "/configs", Help: "配置", Hand: func(m *ice.Message, arg ...string) {
m.Cmd("web.code.git.configs").Tables(func(value ice.Maps) {
m.Cmd("web.code.git.configs", func(value ice.Maps) {
if strings.HasPrefix(value[mdb.NAME], "url") {
m.Echo(`git config --global "%s" "%s"`, value[mdb.NAME], value[mdb.VALUE])
m.Echo(ice.NL)

2
misc/bash/favor.go
View File

@ -15,7 +15,7 @@ func init() {
"/favor": {Name: "/favor", Help: "收藏", Actions: ice.Actions{
mdb.EXPORT: {Name: "export zone name", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Echo("#!/bin/sh\n\n")
m.Cmdy(FAVOR, m.Option(mdb.ZONE)).Tables(func(value ice.Maps) {
m.Cmdy(FAVOR, m.Option(mdb.ZONE), func(value ice.Maps) {
if m.Option(mdb.NAME) == "" || m.Option(mdb.NAME) == value[mdb.NAME] {
m.Echo("# %v\n%v\n\n", value[mdb.NAME], value[mdb.TEXT])
}

2
misc/bash/input.go
View File

@ -16,7 +16,7 @@ func init() {
word := list[kit.Int(m.Option("index"))]
switch arg[0] {
case "shy":
m.Cmd("web.code.input.find", word).Tables(func(value ice.Maps) {
m.Cmd("web.code.input.find", word, func(value ice.Maps) {
m.Echo(value["text"]).Echo(" ")
})

25
misc/git/configs.go
View File

@ -9,11 +9,14 @@ import (
kit "shylinux.com/x/toolkits"
)
func _configs_set(m *ice.Message, key, value string) {
m.Cmd(cli.SYSTEM, GIT, "config", "--global", key, value)
func _configs_set(m *ice.Message, key, value string) string {
return _git_cmds(m, "config", "--global", key, value)
}
func _configs_get(m *ice.Message, key string) string {
return m.Cmdx(cli.SYSTEM, GIT, "config", "--global", key)
if msg := _git_cmd(m, "config", "--global", key); cli.IsSuccess(msg) {
return msg.Result()
}
return ""
}
func _configs_list(m *ice.Message) {
for _, v := range strings.Split(_configs_get(m, "--list"), ice.NL) {
@ -25,8 +28,8 @@ func _configs_list(m *ice.Message) {
}
m.Sort(mdb.NAME)
mdb.HashSelect(m.Spawn(ice.OptionFields("name,value"))).Table(func(index int, value ice.Maps, head []string) {
m.Push("", value, head).PushButton(mdb.CREATE)
mdb.HashSelectValue(m, func(value ice.Maps) {
m.Push("", value, kit.Split("name,value")).PushButton(mdb.CREATE)
})
}
@ -35,7 +38,7 @@ const CONFIGS = "configs"
func init() {
Index.Merge(&ice.Context{Configs: ice.Configs{
CONFIGS: {Name: CONFIGS, Help: "配置键", Value: kit.Data(
mdb.SHORT, mdb.NAME, ice.INIT, kit.Dict(
mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,value", ice.INIT, kit.Dict(
"alias", kit.Dict("s", "status", "b", "branch", "l", "log --oneline --decorate"),
"credential", kit.Dict("helper", "store"),
"core", kit.Dict("quotepath", "false"),
@ -50,25 +53,25 @@ func init() {
})
}},
mdb.CREATE: {Name: "create name value", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(mdb.NAME))
_configs_set(m, m.Option(mdb.NAME), m.Option(mdb.VALUE))
mdb.HashRemove(m, m.Option(mdb.NAME))
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.INSERT, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(mdb.NAME, mdb.VALUE))
mdb.HashCreate(m.Spawn(), m.OptionSimple(mdb.NAME, mdb.VALUE))
_configs_set(m, "--unset", m.Option(mdb.NAME))
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == mdb.VALUE {
m.Cmd(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(mdb.NAME))
mdb.HashRemove(m, m.Option(mdb.NAME))
_configs_set(m, m.Option(mdb.NAME), arg[1])
}
}},
}, Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 {
_configs_list(m)
return
} else {
m.Echo(_configs_get(m, arg[0]))
}
m.Echo(_configs_get(m, arg[0]))
}},
}})
}

8
misc/git/count.go
View File

@ -25,13 +25,13 @@ func init() {
m.Option(nfs.DIR_DEEP, ice.TRUE)
m.Option(nfs.DIR_TYPE, nfs.TYPE_CAT)
m.Cmdy(nfs.DIR, arg, func(file string) {
if strings.Contains(file, "var/") {
if strings.Contains(file, "node_modules/") {
return
}
if strings.Contains(file, "bin/") {
return
}
if !strings.Contains(file, ice.PT) {
if strings.Contains(file, "var/") {
return
}
switch kit.Ext(file) {
@ -63,8 +63,6 @@ func init() {
m.SortIntR("lines")
m.StatusTime()
}},
}, Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.DIR, arg)
}},
}, Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.DIR, arg) }},
})
}

29
misc/git/git.go
View File

@ -6,30 +6,25 @@ import (
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
kit "shylinux.com/x/toolkits"
)
func _git_cmd(m *ice.Message, arg ...string) *ice.Message {
return m.Cmd(cli.SYSTEM, GIT, arg)
}
func _git_cmds(m *ice.Message, arg ...string) string {
return _git_cmd(m, arg...).Result()
}
const GIT = "git"
var Index = &ice.Context{Name: GIT, Help: "代码库", Configs: ice.Configs{
GIT: {Name: GIT, Help: "代码库", Value: kit.Data(
nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz",
)},
}, Commands: ice.Commands{
GIT: {Name: "git path auto install order build download", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
code.INSTALL: {Name: "install", Help: "安装", Hand: func(m *ice.Message, arg ...string) {
web.PushStream(m)
defer m.ProcessInner()
m.Cmdy(cli.SYSTEM, "yum", "install", "-y", "git")
}},
var Index = &ice.Context{Name: GIT, Help: "代码库", Commands: ice.Commands{
GIT: {Name: "git path auto order build download", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
cli.ORDER: {Name: "order", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/libexec/git-core")
m.Cmd(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/libexec/git-core")
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
}},
}, code.InstallAction()), Hand: func(m *ice.Message, arg ...string) {
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, nfs.SOURCE, m.Config(nfs.SOURCE), arg)
m.Echo("hello world %v", arg)
}},
}}

53
misc/git/repos.go
View File

@ -11,24 +11,23 @@ import (
kit "shylinux.com/x/toolkits"
)
func _repos_cmd(m *ice.Message, name string, arg ...string) *ice.Message {
m.Cmdy(cli.SYSTEM, GIT, arg, ice.Option{cli.CMD_DIR, _repos_path(name)})
return m
}
func _repos_path(name string) string {
if strings.Contains(name, ":\\") {
return name
}
return kit.Select(path.Join(ice.USR, name)+ice.PS, nfs.PWD, name == path.Base(kit.Pwd()))
}
func _repos_cmd(m *ice.Message, name string, arg ...string) *ice.Message {
return m.Cmdy(cli.SYSTEM, GIT, arg, ice.Option{cli.CMD_DIR, _repos_path(name)})
}
func _repos_insert(m *ice.Message, name string, dir string) {
if s, e := nfs.StatFile(m, m.Option(cli.CMD_DIR, path.Join(dir, ".git"))); e == nil && s.IsDir() {
ls := strings.SplitN(strings.Trim(m.Cmdx(cli.SYSTEM, GIT, "log", "-n1", `--pretty=format:"%ad %s"`, "--date=iso"), `"`), ice.SP, 4)
mdb.Rich(m, REPOS, nil, kit.Data(mdb.NAME, name, nfs.PATH, dir,
ls := strings.SplitN(strings.Trim(_git_cmds(m, "log", "-n1", `--pretty=format:"%ad %s"`, "--date=iso"), `"`), ice.SP, 4)
mdb.HashCreate(m, mdb.NAME, name, nfs.PATH, dir,
COMMIT, kit.Select("", ls, 3), mdb.TIME, strings.Join(ls[:2], ice.SP),
BRANCH, strings.TrimSpace(m.Cmdx(cli.SYSTEM, GIT, BRANCH)),
REMOTE, strings.TrimSpace(m.Cmdx(cli.SYSTEM, GIT, REMOTE, "-v")),
))
REMOTE, strings.TrimSpace(_git_cmds(m, REMOTE, "-v")),
BRANCH, strings.TrimSpace(_git_cmds(m, BRANCH)),
)
}
}
@ -44,30 +43,19 @@ const (
const REPOS = "repos"
func init() {
Index.Merge(&ice.Context{Configs: ice.Configs{
REPOS: {Name: REPOS, Help: "代码库", Value: kit.Data(
mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,branch,commit,remote",
REPOS, "https://shylinux.com/x", nfs.PATH, ice.USR_LOCAL,
)},
}, Commands: ice.Commands{
Index.MergeCommands(ice.Commands{
REPOS: {Name: "repos repos path auto create", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Conf(REPOS, mdb.HASH, "")
_repos_insert(m, path.Base(kit.Pwd()), kit.Pwd())
m.Cmd(nfs.DIR, ice.USR, "name,path").Tables(func(value ice.Maps) {
_repos_insert(m, value[mdb.NAME], value[nfs.PATH])
})
cli.IsAlpine(m, "git", "apk add git")
m.Cmd(nfs.DIR, ice.USR, "name,path", func(value ice.Maps) { _repos_insert(m, value[mdb.NAME], value[nfs.PATH]) })
m.Go(func() { m.Sleep300ms(); cli.IsAlpine(m, GIT) })
m.Config(REPOS, "https://shylinux.com/x")
}},
mdb.CREATE: {Name: "create repos branch name path", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.NAME, kit.Select(strings.TrimSuffix(path.Base(m.Option(REPOS)), ".git"), m.Option(mdb.NAME)))
m.Option(nfs.PATH, kit.Select(path.Join(ice.USR, m.Option(mdb.NAME)), m.Option(nfs.PATH)))
m.Option(REPOS, kit.Select(m.Config(REPOS)+ice.PS+m.Option(mdb.NAME), m.Option(REPOS)))
// if strings.Contains(m.Option(REPOS), "@") {
// ls := strings.Split(m.Option(REPOS), "@")
// m.Option(REPOS, ls[0])
// m.Option(BRANCH, ls[1])
// }
_repos_insert(m, m.Option(mdb.NAME), m.Option(nfs.PATH))
if s, e := nfs.StatFile(m, path.Join(m.Option(nfs.PATH), ".git")); e == nil && s.IsDir() {
@ -77,21 +65,20 @@ func init() {
// 下载仓库
if s, e := nfs.StatFile(m, m.Option(nfs.PATH)); e == nil && s.IsDir() {
m.Option(cli.CMD_DIR, m.Option(nfs.PATH))
m.Cmd(cli.SYSTEM, GIT, INIT)
m.Cmd(cli.SYSTEM, GIT, REMOTE, ADD, ORIGIN, m.Option(REPOS))
m.Cmd(cli.SYSTEM, GIT, PULL, ORIGIN, kit.Select(MASTER, m.Option(BRANCH)))
_git_cmd(m, INIT)
_git_cmd(m, REMOTE, ADD, ORIGIN, m.Option(REPOS))
_git_cmd(m, PULL, ORIGIN, kit.Select(MASTER, m.Option(BRANCH)))
} else {
m.Option(cli.CMD_DIR, "")
m.Cmd(cli.SYSTEM, GIT, CLONE, "-b", kit.Select(MASTER, m.Option(BRANCH)),
m.Option(REPOS), m.Option(nfs.PATH))
_git_cmd(m, CLONE, "-b", kit.Select(MASTER, m.Option(BRANCH)), m.Option(REPOS), m.Option(nfs.PATH))
}
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, arg ...string) {
}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,branch,commit,remote")), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 { // 仓库列表
mdb.HashSelect(m, arg...).Sort(mdb.NAME).RenameAppend(mdb.NAME, REPOS)
return
} else { // 文件列表
m.Cmdy(nfs.DIR, kit.Select("", arg, 1), "time,line,path", kit.Dict(nfs.DIR_ROOT, _repos_path(arg[0])))
}
m.Cmdy(nfs.DIR, kit.Select("", arg, 1), "time,line,path", kit.Dict(nfs.DIR_ROOT, _repos_path(arg[0])))
}},
}})
})
}

127
misc/git/server.go
View File

@ -8,14 +8,12 @@ import (
"io"
"net/http"
"path"
"regexp"
"strconv"
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/tcp"
@ -23,25 +21,6 @@ import (
kit "shylinux.com/x/toolkits"
)
func requestReader(m *ice.Message) (io.ReadCloser, error) {
switch m.R.Header.Get("content-encoding") {
case "deflate":
return flate.NewReader(m.R.Body), nil
case "gzip":
return gzip.NewReader(m.R.Body)
}
return m.R.Body, nil
}
func packetWrite(m *ice.Message, cmd string, str ...string) {
s := strconv.FormatInt(int64(len(cmd)+4), 16)
if len(s)%4 != 0 {
s = strings.Repeat("0", 4-len(s)%4) + s
}
m.W.Write([]byte(s + cmd + "0000" + strings.Join(str, "")))
}
var basicAuthRegex = regexp.MustCompile("^([^:]*):(.*)$")
func _server_rewrite(m *ice.Message, p string, r *http.Request) {
if ua := r.Header.Get(web.UserAgent); strings.HasPrefix(ua, "Mozilla") {
r.URL.Path = strings.Replace(r.URL.Path, "/x/", "/chat/pod/", 1)
@ -53,37 +32,26 @@ func _server_rewrite(m *ice.Message, p string, r *http.Request) {
}
}
func _server_login(m *ice.Message) error {
if m.Conf("web.serve", "meta.localhost") != ice.FALSE {
if m.Conf("web.serve", kit.Keym(tcp.LOCALHOST)) != ice.FALSE {
if tcp.IsLocalHost(m, m.Option(ice.MSG_USERIP)) {
return nil
return nil // 本机请求
}
}
parts := strings.SplitN(m.R.Header.Get("Authorization"), ice.SP, 2)
if len(parts) < 2 {
return fmt.Errorf("Invalid authorization header, not enought parts")
}
authType, authData := parts[0], parts[1]
if strings.ToLower(authType) != "basic" {
return fmt.Errorf("Authentication '%s' was not of 'Basic' type", authType)
ls := strings.SplitN(m.R.Header.Get(web.Authorization), ice.SP, 2)
if strings.ToLower(ls[0]) != "basic" {
return fmt.Errorf("Authentication '%s' was not of 'Basic' type", ls[0])
}
data, err := base64.StdEncoding.DecodeString(authData)
data, err := base64.StdEncoding.DecodeString(ls[1])
if err != nil {
return err
}
matches := basicAuthRegex.FindStringSubmatch(string(data))
if matches == nil {
return fmt.Errorf("Authorization data '%s' did not match auth regexp", data)
if ls = strings.SplitN(string(data), ice.DF, 2); !aaa.UserLogin(m, ls[0], ls[1]) {
return fmt.Errorf("username or password error") // 登录失败
}
username, password := matches[1], matches[2]
if !aaa.UserLogin(m, username, password) {
return fmt.Errorf("username or password error")
}
if aaa.UserRole(m, username) == aaa.VOID {
return fmt.Errorf("userrole has no right")
if aaa.UserRole(m, ls[0]) == aaa.VOID {
return fmt.Errorf("userrole has no right") // 没有权限
}
return nil
}
@ -102,12 +70,12 @@ func _server_repos(m *ice.Message, arg ...string) error {
if m.Option(cli.CMD_DIR, repos); strings.HasSuffix(path.Join(arg...), "info/refs") {
web.RenderType(m.W, "", kit.Format("application/x-git-%s-advertisement", service))
msg := m.Cmd(cli.SYSTEM, GIT, service, "--stateless-rpc", "--advertise-refs", ice.PT)
packetWrite(m, "# service=git-"+service+ice.NL, msg.Result())
msg := _git_cmd(m, service, "--stateless-rpc", "--advertise-refs", ice.PT)
_server_writer(m, "# service=git-"+service+ice.NL, msg.Result())
return nil
}
reader, err := requestReader(m)
reader, err := _server_reader(m)
if err != nil {
return err
}
@ -116,35 +84,44 @@ func _server_repos(m *ice.Message, arg ...string) error {
m.Option(cli.CMD_OUTPUT, m.W)
m.Option(cli.CMD_INPUT, reader)
web.RenderType(m.W, "", kit.Format("application/x-git-%s-result", service))
m.Cmd(cli.SYSTEM, GIT, service, "--stateless-rpc", ice.PT)
_git_cmd(m, service, "--stateless-rpc", ice.PT)
return nil
}
func _server_writer(m *ice.Message, cmd string, str ...string) {
s := strconv.FormatInt(int64(len(cmd)+4), 16)
if len(s)%4 != 0 {
s = strings.Repeat("0", 4-len(s)%4) + s
}
m.W.Write([]byte(s + cmd + "0000" + strings.Join(str, "")))
}
func _server_reader(m *ice.Message) (io.ReadCloser, error) {
switch m.R.Header.Get("content-encoding") {
case "deflate":
return flate.NewReader(m.R.Body), nil
case "gzip":
return gzip.NewReader(m.R.Body)
}
return m.R.Body, nil
}
const SERVER = "server"
func init() {
Index.MergeCommands(ice.Commands{
web.WEB_LOGIN: {Hand: func(m *ice.Message, arg ...string) { m.Render(ice.RENDER_VOID) }},
"/repos/": {Name: "/repos/", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
"/repos/": {Name: "/repos/", Help: "代码库", Actions: ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
web.AddRewrite(func(p string, w http.ResponseWriter, r *http.Request) bool {
if strings.HasPrefix(p, "/x/") {
_server_rewrite(m, p, r)
} else if strings.HasPrefix(p, "/chat/pod/") {
_server_rewrite(m, p, r)
}
return false
})
}},
}, ctx.CmdAction()), Hand: func(m *ice.Message, arg ...string) {
if !m.IsCliUA() {
p := kit.Split(web.MergeURL2(m, "/x/"+path.Join(arg...)), "?")[0]
m.RenderResult("git clone %v", p)
return
}
}, Hand: func(m *ice.Message, arg ...string) {
if m.Option("go-get") == "1" { // 下载地址
p := kit.Split(web.MergeURL2(m, "/x/"+path.Join(arg...)), "?")[0]
m.RenderResult(kit.Format(`<meta name="%s" content="%s">`, "go-import", kit.Format(`%s git %s`, strings.TrimPrefix(p, "https://"), p)))
p := web.MergeLink(m, "/x/"+path.Join(arg...))
m.RenderResult(kit.Format(`<meta name="%s" content="%s">`, "go-import", kit.Format(`%s git %s`, strings.Split(p, "://")[1], p)))
return
}
@ -152,39 +129,35 @@ func init() {
case "receive-pack": // 上传代码
if err := _server_login(m); err != nil {
web.RenderHeader(m.W, "WWW-Authenticate", `Basic realm="git server"`)
web.RenderStatus(m.W, 401, err.Error())
web.RenderStatus(m.W, http.StatusUnauthorized, err.Error())
return // 没有权限
}
if !nfs.ExistsFile(m, path.Join(repos)) {
m.Cmd(cli.SYSTEM, GIT, INIT, "--bare", repos) // 创建仓库
if !nfs.ExistsFile(m, repos) { // 创建仓库
_git_cmd(m, INIT, "--bare", repos)
m.Logs(mdb.CREATE, REPOS, repos)
}
case "upload-pack": // 下载代码
aaa.UserRoot(m)
if kit.Select("", arg, 1) == "info" && m.Cmd(web.DREAM, arg[0]).Length() > 0 {
m.Cmd(web.SPACE, arg[0], "web.code.git.status", "submit", web.MergeURL2(m, "/x/")+arg[0])
}
if !nfs.ExistsFile(m, path.Join(repos)) {
web.RenderStatus(m.W, 404, kit.Format("not found: %s", arg[0]))
if !nfs.ExistsFile(m, repos) {
web.RenderStatus(m.W, http.StatusNotFound, kit.Format("not found: %s", arg[0]))
return
}
}
if err := _server_repos(m, arg...); err != nil {
web.RenderStatus(m.W, 500, err.Error())
web.RenderStatus(m.W, http.StatusInternalServerError, err.Error())
}
}},
SERVER: {Name: "server path auto create import", Help: "服务器", Actions: ice.Actions{
mdb.CREATE: {Name: "create name", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, path.Join(ice.USR_LOCAL, REPOS))
m.Cmdy(cli.SYSTEM, GIT, INIT, "--bare", m.Option(mdb.NAME))
m.Option(cli.CMD_DIR, ice.USR_LOCAL_REPOS)
_git_cmd(m, INIT, "--bare", m.Option(mdb.NAME))
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(REPOS, ice.OptionFields("time,name,path")).Tables(func(value ice.Maps) {
remote := strings.Split(web.MergeURL2(m, "/x/"+value[REPOS]), "?")[0]
m.Cmdy(REPOS, ice.OptionFields("time,name,path"), func(value ice.Maps) {
m.Option(cli.CMD_DIR, value[nfs.PATH])
m.Cmd(cli.SYSTEM, GIT, PUSH, remote, MASTER)
m.Cmd(cli.SYSTEM, GIT, PUSH, "--tags", remote, MASTER)
remote := web.MergeLink(m, "/x/"+value[REPOS])
_git_cmd(m, PUSH, remote, MASTER)
_git_cmd(m, PUSH, "--tags", remote, MASTER)
})
}},
nfs.TRASH: {Name: "trash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
@ -193,11 +166,9 @@ func init() {
}},
}, Hand: func(m *ice.Message, arg ...string) {
if m.Option(nfs.DIR_ROOT, ice.USR_LOCAL_REPOS); len(arg) == 0 {
m.Cmdy(nfs.DIR, nfs.PWD).Tables(func(value ice.Maps) {
m.PushScript("git clone " + web.MergeURL2(m, "/x/"+strings.TrimSuffix(value[nfs.PATH], ice.PS)))
})
m.Cut("time,path,size,script,action")
m.StatusTimeCount()
m.Cmdy(nfs.DIR, nfs.PWD, func(value ice.Maps) {
m.PushScript("git clone " + web.MergeLink(m, "/x/"+path.Clean(value[nfs.PATH])))
}).Cut("time,path,size,script,action")
return
}
m.Cmdy("_sum", path.Join(m.Option(nfs.DIR_ROOT), arg[0]))

22
misc/git/spide.go
View File

@ -18,7 +18,6 @@ func _spide_for(text string, cb func([]string)) {
if len(line) == 0 || strings.HasPrefix(line, "!_") {
continue
}
cb(kit.Split(line, "\t ", "\t ", "\t "))
}
}
@ -29,17 +28,17 @@ func _spide_go(m *ice.Message, file string) {
return
case "w", "e":
return
ls[0] = "-" + ls[0] + ":" + strings.TrimPrefix(ls[len(ls)-1], "type:")
ls[0] = "-" + ls[0] + ice.DF + strings.TrimPrefix(ls[len(ls)-1], "type:")
case "m":
if strings.HasPrefix(ls[6], "ntype") {
return
} else if strings.HasPrefix(ls[5], "ctype") {
ls[0] = strings.TrimPrefix(ls[5], "ctype:") + ":" + ls[0]
ls[0] = strings.TrimPrefix(ls[5], "ctype:") + ice.DF + ls[0]
} else {
ls[0] = ls[3] + ":" + ls[0]
ls[0] = ls[3] + ice.DF + ls[0]
}
default:
ls[0] = ls[3] + ":" + ls[0]
ls[0] = ls[3] + ice.DF + ls[0]
}
m.Push(mdb.NAME, ls[0])
@ -62,7 +61,6 @@ const SPIDE = "spide"
func init() {
Index.MergeCommands(ice.Commands{
SPIDE: {Name: "spide repos auto", Help: "构架图", Actions: ice.MergeActions(ice.Actions{
code.INNER: {Name: "web.code.inner"},
"depend": {Name: "depend path=icebergs/base", Help: "依赖", Hand: func(m *ice.Message, arg ...string) {
keys := map[string]bool{}
list := map[string]map[string]bool{}
@ -85,11 +83,7 @@ func init() {
keys[p], item[p] = true, true
})
item := []string{}
for k := range keys {
item = append(item, k)
}
item = kit.Sort(item)
item := kit.SortedKey(keys)
for k, v := range list {
m.Push("pkg", k)
@ -100,19 +94,19 @@ func init() {
}
m.SortIntR("count")
m.ProcessInner()
}},
}}, code.INNER: {Name: "web.code.inner"},
}, ctx.CmdAction()), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 { // 仓库列表
m.Cmdy(REPOS)
return
}
if arg[0] = kit.Replace(arg[0], "src", "contexts"); arg[0] == path.Base(kit.Pwd()) {
if arg[0] = kit.Replace(arg[0], ice.SRC, ice.CONTEXTS); arg[0] == path.Base(kit.Pwd()) {
m.Option(nfs.DIR_ROOT, path.Join(ice.SRC)+ice.PS)
} else {
m.Option(nfs.DIR_ROOT, path.Join(ice.USR, arg[0])+ice.PS)
}
ctx.DisplayStory(m, "spide.js?field=path", "root", arg[0])
ctx.DisplayStory(m, "spide.js", "field", "path", "root", arg[0])
if len(arg) == 1 { // 目录列表
m.Option(nfs.DIR_DEEP, ice.TRUE)

103
misc/git/status.go
View File

@ -28,7 +28,7 @@ func _status_tag(m *ice.Message, tags string) string {
}
func _status_tags(m *ice.Message, repos string) {
vs := ice.Maps{}
m.Cmd(STATUS).Tables(func(value ice.Maps) {
m.Cmd(STATUS, func(value ice.Maps) {
if value[mdb.TYPE] == "##" {
if value[REPOS] == ice.RELEASE {
value[REPOS] = ice.ICE
@ -46,12 +46,11 @@ func _status_tags(m *ice.Message, repos string) {
if k != repos && repos != "" {
continue
}
count++
toast(k, count, total)
if k == ice.ICE {
k = ice.RELEASE
}
count++
toast(k, count, total)
change := false
m.Option(nfs.DIR_ROOT, _repos_path(k))
@ -61,24 +60,20 @@ func _status_tags(m *ice.Message, repos string) {
return text
}
if v, ok := vs[kit.Slice(strings.Split(ls[0], ice.PS), -1)[0]]; ok && ls[1] != v {
m.Info("upgrade %v %v to %v", ls[0], ls[1], v)
m.Logs("upgrade", "repos", ls[0], "from", ls[1], "to", v)
text = strings.ReplaceAll(text, ls[1], v)
change = true
}
return text
})
if !change || mod == "" {
continue
}
m.Cmd(nfs.SAVE, ice.GO_SUM, "")
m.Cmd(nfs.SAVE, ice.GO_MOD, mod)
switch m.Option(cli.CMD_DIR, _repos_path(k)); k {
case ice.CONTEXTS:
defer m.Cmd(cli.SYSTEM, cli.MAKE, ice.Option{cli.CMD_DIR, _repos_path(k)})
case ice.ICEBERGS:
case ice.RELEASE, ice.ICEBERGS, ice.TOOLKITS:
m.Cmd(cli.SYSTEM, code.GO, cli.BUILD)
default:
m.Cmd(cli.SYSTEM, cli.MAKE)
@ -93,7 +88,7 @@ func _status_each(m *ice.Message, title string, cmds ...string) {
toast(cli.BEGIN, count, total)
list := []string{}
m.Cmd(REPOS, ice.OptionFields("name,path")).Tables(func(value ice.Maps) {
m.Cmd(REPOS, ice.OptionFields("name,path"), func(value ice.Maps) {
toast(value[REPOS], count, total)
if msg := m.Cmd(cmds, ice.Option{cli.CMD_DIR, value[nfs.PATH]}); !cli.IsSuccess(msg) {
@ -108,12 +103,12 @@ func _status_each(m *ice.Message, title string, cmds ...string) {
web.Toast30s(m, strings.Join(list, ice.NL), ice.FAILURE)
} else {
toast(ice.SUCCESS, count, total)
web.PushNoticeRefresh(m)
}
web.PushNoticeRefresh(m)
})
}
func _status_stat(m *ice.Message, files, adds, dels int) (int, int, int) {
for _, v := range kit.Split(m.Cmdx(cli.SYSTEM, GIT, DIFF, "--shortstat"), ice.FS) {
for _, v := range kit.Split(_git_cmds(m, DIFF, "--shortstat"), ice.FS) {
n := kit.Int(kit.Split(strings.TrimSpace(v))[0])
switch {
case strings.Contains(v, "file"):
@ -127,10 +122,10 @@ func _status_stat(m *ice.Message, files, adds, dels int) (int, int, int) {
return files, adds, dels
}
func _status_list(m *ice.Message) (files, adds, dels int, last time.Time) {
m.Cmd(REPOS, ice.OptionFields("name,path")).Tables(func(value ice.Maps) {
m.Cmd(REPOS, ice.OptionFields("name,path"), func(value ice.Maps) {
m.Option(cli.CMD_DIR, value[nfs.PATH])
diff := m.Cmdx(cli.SYSTEM, GIT, STATUS, "-sb")
tags := m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags")
diff := _git_cmds(m, STATUS, "-sb")
tags := _git_cmds(m, "describe", "--tags")
for _, v := range strings.Split(strings.TrimSpace(diff), ice.NL) {
if v == "" {
@ -171,7 +166,7 @@ func _status_list(m *ice.Message) (files, adds, dels int, last time.Time) {
}
files, adds, dels = _status_stat(m, files, adds, dels)
now, _ := time.Parse("2006-01-02 15:04:05 -0700", strings.TrimSpace(m.Cmdx(cli.SYSTEM, GIT, "log", `--pretty=%cd`, "--date=iso", "-n1")))
now, _ := time.Parse("2006-01-02 15:04:05 -0700", strings.TrimSpace(_git_cmds(m, "log", `--pretty=%cd`, "--date=iso", "-n1")))
if now.After(last) {
last = now
}
@ -184,10 +179,10 @@ const (
MAKE = "make"
PUSH = "push"
TAG = "tag"
ADD = "add"
OPT = "opt"
PRO = "pro"
TAG = "tag"
PIE = "pie"
TAGS = "tags"
@ -205,7 +200,7 @@ func init() {
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case mdb.NAME, REPOS:
m.Cmdy(REPOS).Cut("repos")
m.Cmdy(REPOS).Cut(REPOS)
case TAGS, VERSION:
if m.Option(TAGS) == ice.ErrWarn {
@ -219,15 +214,15 @@ func init() {
for _, v := range kit.Split(m.Option(nfs.FILE), " /") {
m.Push(mdb.TEXT, v)
}
case "email":
m.Push(arg[0], m.Cmdx(cli.SYSTEM, GIT, "config", "user.email"))
case "username":
m.Push(arg[0], kit.Select(m.Option(ice.MSG_USERNAME), m.Cmdx(cli.SYSTEM, GIT, "config", "user.name")))
m.Push(arg[0], kit.Select(m.Option(ice.MSG_USERNAME), _configs_get(m, "user.name")))
case "email":
m.Push(arg[0], _configs_get(m, "user.email"))
}
}},
"user": {Name: "user email username", Help: "用户", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(cli.SYSTEM, GIT, "config", "--global", "user.email", m.Option("email"))
m.Cmd(cli.SYSTEM, GIT, "config", "--global", "user.name", m.Option("username"))
CONFIGS: {Name: "configs email username", Help: "配置", Hand: func(m *ice.Message, arg ...string) {
_configs_set(m, "user.name", m.Option("username"))
_configs_set(m, "user.email", m.Option("email"))
}},
CLONE: {Name: "clone repos='https://shylinux.com/x/volcanos' path=", Help: "克隆", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(REPOS, mdb.CREATE)
@ -240,7 +235,6 @@ func init() {
web.PushStream(m)
m.Cmdy(cli.SYSTEM, MAKE)
web.ToastSuccess(m)
m.ProcessHold()
}},
PUSH: {Name: "push", Help: "上传", Hand: func(m *ice.Message, arg ...string) {
if m.Option(REPOS) == "" {
@ -249,26 +243,25 @@ func init() {
return
}
if strings.TrimSpace(m.Cmdx(cli.SYSTEM, GIT, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}", ice.Option{cli.CMD_DIR, _repos_path(m.Option(REPOS))})) == "" {
_repos_cmd(m, m.Option(REPOS), PUSH, "--set-upstream", "origin", "master")
m.Option(cli.CMD_DIR, _repos_path(m.Option(REPOS)))
if strings.TrimSpace(_git_cmds(m, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")) == "" {
_git_cmd(m, PUSH, "--set-upstream", "origin", "master")
} else {
_repos_cmd(m, m.Option(REPOS), PUSH)
_git_cmd(m, PUSH)
}
_repos_cmd(m, m.Option(REPOS), PUSH, "--tags")
m.ProcessRefresh3ms()
_git_cmd(m, PUSH, "--tags")
}},
TAGS: {Name: "tags", Help: "标签", Hand: func(m *ice.Message, arg ...string) {
_status_tags(m, kit.Select("", arg, 0))
m.ProcessHold()
}},
PIE: {Name: "pie", Help: "饼图", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(TOTAL, PIE)
}},
STASH: {Name: "stash", Help: "缓存", Hand: func(m *ice.Message, arg ...string) {
_status_each(m, STASH, cli.SYSTEM, GIT, STASH)
m.ProcessHold()
}},
PIE: {Name: "pie", Help: "饼图", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(TOTAL, PIE)
}},
ADD: {Name: "add", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_repos_cmd(m, m.Option(REPOS), ADD, m.Option(nfs.FILE)).SetAppend()
@ -279,15 +272,15 @@ func init() {
} else {
m.Option(mdb.TEXT, kit.Select("opt some", strings.Join(arg, ice.SP)))
}
_repos_cmd(m, m.Option(REPOS), COMMIT, "-am", m.Option(mdb.TEXT))
m.ProcessBack()
}},
"branch_switch": {Name: "branch_switch", Help: "切换", Hand: func(m *ice.Message, arg ...string) {
_repos_cmd(m.Spawn(), m.Option(REPOS), "checkout", m.Option(BRANCH))
}},
"publish": {Name: "publish", Help: "发布", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.PUBLISH, ice.CONTEXTS, ice.MISC, ice.CORE)
TAG: {Name: "tag version@key", Help: "标签", Hand: func(m *ice.Message, arg ...string) {
if m.Option(VERSION) == "" {
m.Option(VERSION, _status_tag(m, m.Option(TAGS)))
}
_repos_cmd(m, m.Option(REPOS), TAG, m.Option(VERSION))
_repos_cmd(m, m.Option(REPOS), PUSH, "--tags")
}},
BRANCH: {Name: "branch", Help: "分支", Hand: func(m *ice.Message, arg ...string) {
for _, line := range kit.Split(_repos_cmd(m.Spawn(), arg[0], BRANCH).Result(), ice.NL, ice.NL) {
@ -300,16 +293,11 @@ func init() {
}
}
}},
TAG: {Name: "tag version@key", Help: "标签", Hand: func(m *ice.Message, arg ...string) {
if m.Option(VERSION) == "" {
m.Option(VERSION, _status_tag(m, m.Option(TAGS)))
}
_repos_cmd(m, m.Option(REPOS), TAG, m.Option(VERSION))
_repos_cmd(m, m.Option(REPOS), PUSH, "--tags")
m.ProcessRefresh3ms()
"branch_switch": {Name: "branch_switch", Help: "切换", Hand: func(m *ice.Message, arg ...string) {
_repos_cmd(m.Spawn(), m.Option(REPOS), "checkout", m.Option(BRANCH))
}},
code.DEVPACK: {Name: "devpack", Help: "开发模式", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.VIMER, code.DEVPACK)
code.PUBLISH: {Name: "publish", Help: "发布", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.PUBLISH, ice.CONTEXTS, ice.MISC, ice.CORE)
}},
code.BINPACK: {Name: "binpack", Help: "发布模式", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(nfs.LINK, ice.GO_SUM, path.Join(ice.SRC_RELEASE, ice.GO_SUM))
@ -317,20 +305,25 @@ func init() {
m.Cmdy(nfs.CAT, ice.GO_MOD)
m.Cmdy(code.VIMER, code.BINPACK)
}},
code.DEVPACK: {Name: "devpack", Help: "开发模式", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.VIMER, code.DEVPACK)
}},
}, Hand: func(m *ice.Message, arg ...string) {
if _configs_get(m, "user.email") == "" {
m.Echo("please config user.email")
m.Action(CONFIGS)
return
}
if len(arg) == 0 {
m.Action(PULL, MAKE, PUSH, TAGS, STASH, PIE, "publish", "user")
m.Action(PULL, MAKE, PUSH, TAGS, PIE, code.PUBLISH)
files, adds, dels, last := _status_list(m)
m.Status("files", files, "adds", adds, "dels", dels, "last", last.Format(ice.MOD_TIME))
web.Toast3s(m, kit.Format("files: %d, adds: %d, dels: %d", files, adds, dels), ice.CONTEXTS)
return
}
m.Option(cli.CMD_DIR, _repos_path(arg[0]))
m.Echo(m.Cmdx(cli.SYSTEM, GIT, DIFF))
_repos_cmd(m, arg[0], DIFF)
m.Action(COMMIT, TAGS, BRANCH)
files, adds, dels := _status_stat(m, 0, 0, 0)
m.Status("files", files, "adds", adds, "dels", dels)
web.Toast3s(m, kit.Format("files: %d, adds: %d, dels: %d", files, adds, dels), arg[0])

79
misc/git/total.go
View File

@ -8,9 +8,11 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
"shylinux.com/x/toolkits/task"
)
const TOTAL = "total"
@ -20,27 +22,27 @@ func init() {
TOTAL: {Name: TOTAL, Help: "统计量", Value: kit.Data(
"skip", kit.Dict(
"wubi-dict", ice.TRUE, "word-dict", ice.TRUE,
"websocket", ice.TRUE, "go-sql-mysql", ice.TRUE,
"echarts", ice.TRUE, "go-qrcode", ice.TRUE,
"websocket", ice.TRUE, "go-qrcode", ice.TRUE,
"go-sql-mysql", ice.TRUE, "echarts", ice.TRUE,
),
)},
}, Commands: ice.Commands{
TOTAL: {Name: "total repos auto pie", Help: "统计量", Actions: ice.Actions{
PIE: {Name: "pie", Help: "饼图", Hand: func(m *ice.Message, arg ...string) {
defer m.Display("/plugin/story/pie.js")
m.Cmd(TOTAL).Tables(func(value ice.Maps) {
if value[REPOS] == "total" {
m.StatusTimeCount(REPOS, "total", "value", "1", "total", value["rest"])
defer ctx.DisplayStory(m, "pie.js")
m.Cmd(TOTAL, func(value ice.Maps) {
if value[REPOS] == mdb.TOTAL {
m.StatusTimeCount(REPOS, mdb.TOTAL, mdb.VALUE, "1", mdb.TOTAL, value["rest"])
return
}
m.Push(REPOS, value[REPOS])
m.Push("value", value["rest"])
m.Push(mdb.VALUE, value["rest"])
})
}},
}, Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 { // 提交详情
arg[0] = kit.Replace(arg[0], "src", "contexts")
m.Cmd(REPOS, ice.OptionFields("name,path")).Tables(func(value ice.Maps) {
arg[0] = kit.Replace(arg[0], ice.SRC, ice.CONTEXTS)
m.Cmd(REPOS, ice.OptionFields("name,path"), func(value ice.Maps) {
if value[REPOS] == arg[0] {
m.Cmdy("_sum", value[nfs.PATH], arg[1:])
}
@ -49,33 +51,36 @@ func init() {
}
// 提交统计
wg, lock := &sync.WaitGroup{}, &task.Lock{}
days, commit, adds, dels, rest := 0, 0, 0, 0, 0
Richs(m, REPOS, nil, mdb.FOREACH, func(mu *sync.Mutex, key string, value ice.Map) {
value = kit.GetMeta(value)
if m.Config(kit.Keys("skip", value[mdb.NAME])) == ice.TRUE {
m.Cmd(REPOS, ice.OptionFields("name,path"), func(value ice.Maps) {
if m.Config(kit.Keys("skip", value[REPOS])) == ice.TRUE {
return
}
msg := m.Cmd("_sum", value[nfs.PATH], mdb.TOTAL, "10000")
wg.Add(1)
m.Go(func() {
defer wg.Done()
msg := m.Cmd("_sum", value[nfs.PATH], mdb.TOTAL, "10000")
mu.Lock()
defer mu.Unlock()
defer lock.Lock()()
msg.Tables(func(value ice.Maps) {
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"])
})
msg.Tables(func(value ice.Maps) {
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(REPOS, value[REPOS])
m.Copy(msg)
})
m.Push(REPOS, value[mdb.NAME])
m.Copy(msg)
})
wg.Wait()
m.Push(REPOS, "total")
m.Push(REPOS, mdb.TOTAL)
m.Push("tags", "v3.0.0")
m.Push("days", days)
m.Push("commit", commit)
@ -114,7 +119,7 @@ func init() {
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: ") {
for i, v := range strings.Split(_git_cmds(m, args...), "commit: ") {
l := strings.Split(v, ice.NL)
hs := strings.Split(l[0], ice.SP)
if len(l) < 2 {
@ -155,7 +160,7 @@ func init() {
}
if total { // 累积求和
m.Push("tags", m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags"))
m.Push("tags", _git_cmds(m, "describe", "--tags"))
m.Push("days", int(total_day.Hours())/24)
m.Push("commit", count)
m.Push("adds", count_add)
@ -165,19 +170,3 @@ func init() {
}},
}})
}
func Richs(m *ice.Message, prefix string, chain ice.Any, raw ice.Any, cb func(*sync.Mutex, string, ice.Map)) {
wg, mu := &sync.WaitGroup{}, &sync.Mutex{}
defer wg.Wait()
mdb.Richs(m, prefix, chain, raw, func(key string, value ice.Map) {
wg.Add(1)
val := ice.Map{}
for k, v := range value {
val[k] = v
}
m.Go(func() {
defer wg.Done()
cb(mu, key, val)
})
})
}

7
misc/git/trend.go
View File

@ -12,9 +12,7 @@ const TREND = "trend"
func init() {
Index.MergeCommands(ice.Commands{
TREND: {Name: "trend repos@key begin_time@date auto", Help: "趋势图", Meta: kit.Dict(
ice.DisplayStory("trend.js"),
), Actions: ice.MergeActions(ice.Actions{
TREND: {Name: "trend repos@key begin_time@date auto", Help: "趋势图", Actions: ice.MergeActions(ice.Actions{
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(REPOS, ice.OptionFields("name,time"))
}}, code.INNER: {Name: "web.code.inner"},
@ -23,8 +21,9 @@ func init() {
m.Cmdy(REPOS)
return
}
arg[0] = kit.Replace(arg[0], "src", "contexts")
arg[0] = kit.Replace(arg[0], ice.SRC, ice.CONTEXTS)
m.Cmdy(TOTAL, kit.Slice(arg, 0, 2))
ctx.DisplayStory(m, "trend.js")
}},
})
}

22
misc/input/input.go
View File

@ -26,25 +26,23 @@ const (
)
type input struct {
ice.Zone
insert string `name:"insert zone=person text code weight" help:"添加"`
load string `name:"load file=usr/wubi-dict/wubi86 zone=wubi86" help:"加载"`
save string `name:"save file=usr/wubi-dict/person zone=person" help:"保存"`
list string `name:"list method code auto" help:"输入法"`
}
func (i input) Load(m *ice.Message, arg ...string) {
func (s input) Load(m *ice.Message, arg ...string) {
if f, e := nfs.OpenFile(m.Message, m.Option(nfs.FILE)); m.Assert(e) {
defer f.Close()
// 清空数据
lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
m.Assert(nfs.RemoveAll(m.Message, path.Join(m.Config(mdb.STORE), lib)))
m.Cmd(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, mdb.ZONE, lib)
prefix := kit.Keys(mdb.HASH, mdb.Rich(m.Message, m.PrefixKey(), "", kit.Data(
mdb.STORE, path.Join(m.Config(mdb.STORE), lib),
m.ConfigSimple(mdb.FSIZE, mdb.LIMIT, mdb.LEAST),
mdb.ZONE, lib, mdb.COUNT, 0,
)))
s.Zone.Remove(m, mdb.ZONE, lib)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
prefix := kit.Keys(mdb.HASH, m.Result())
// 加载词库
for bio := bufio.NewScanner(f); bio.Scan(); {
@ -61,13 +59,11 @@ func (i input) Load(m *ice.Message, arg ...string) {
// 保存词库
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
n := mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, "成功", CODE, "z", WEIGHT, "0"))
m.Logs(mdb.IMPORT, m.PrefixKey(), lib, mdb.COUNT, n)
m.Echo("%s: %d", lib, n)
m.Echo("%s: %d", lib, mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, "成功", CODE, "z", WEIGHT, "0")))
}
}
func (i input) Save(m *ice.Message, arg ...string) {
if f, p, e := kit.Create(m.Option(nfs.FILE)); m.Assert(e) {
func (s input) Save(m *ice.Message, arg ...string) {
if f, p, e := nfs.CreateFile(m.Message, m.Option(nfs.FILE)); m.Assert(e) {
defer f.Close()
n := 0
m.Option(mdb.CACHE_LIMIT, -2)
@ -85,7 +81,7 @@ func (i input) Save(m *ice.Message, arg ...string) {
m.Echo("%s: %d", p, n)
}
}
func (i input) List(m *ice.Message, arg ...string) {
func (s input) List(m *ice.Message, arg ...string) {
if len(arg) < 2 || arg[1] == "" {
return
}

4
misc/input/input.shy
View File

@ -1,4 +1,4 @@
chapter "input"
section "input"
field "五笔" web.code.input.wubi
field web.code.input.wubi

25
misc/input/wubi.go
View File

@ -5,40 +5,35 @@ import (
"shylinux.com/x/ice"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
type wubi struct {
input
short string `data:"zone"`
store string `data:"usr/local/export/input/wubi"`
fsize string `data:"300000"`
limit string `data:"50000"`
field string `data:"time,zone,id,text,code,weight"`
store string `data:"usr/local/export/"`
fsize string `data:"100000"`
limit string `data:"10000"`
least string `data:"1000"`
insert string `name:"insert zone=person text code weight" help:"添加"`
load string `name:"load file=usr/wubi-dict/wubi86 zone=wubi86" help:"加载"`
save string `name:"save file=usr/wubi-dict/person zone=person" help:"保存"`
list string `name:"list method=word,line code auto" help:"五笔"`
load string `name:"load file=usr/wubi-dict/wubi86 zone=wubi86" help:"加载"`
save string `name:"save file=usr/wubi-dict/person zone=person" help:"保存"`
list string `name:"list method=word,line code auto" help:"五笔"`
}
func (w wubi) Input(m *ice.Message, arg ...string) {
if arg[0] = strings.TrimSpace(arg[0]); strings.HasPrefix(arg[0], "ice") {
switch list := kit.Split(arg[0]); list[1] {
case "add": // ice add 想你 shwq [person [9999]]
m.Cmd(w, ctx.ACTION, mdb.INSERT, mdb.TEXT, list[2], cli.CODE, list[3],
mdb.ZONE, kit.Select("person", list, 4), mdb.VALUE, kit.Select("999999", list, 5),
)
case "add": // ice add 想你 shwq [9999 [person]]
m.Cmd(w, mdb.INSERT, mdb.TEXT, list[2], cli.CODE, list[3], mdb.VALUE, kit.Select("999999", list, 4), mdb.ZONE, kit.Select("person", list, 5))
m.Echo(list[3] + ice.NL)
}
return
}
m.Option(mdb.CACHE_LIMIT, "10")
m.Cmd(w, "word", arg[0]).Tables(func(value ice.Maps) {
m.Cmd(w, WORD, arg[0], func(value ice.Maps) {
m.Echo(value[mdb.TEXT] + ice.NL)
})
}

6
misc/lark/home.go
View File

@ -21,8 +21,8 @@ func init() {
text, link, list := kit.Select("", arg, 3), kit.MergeURL2(m.Conf(web.SHARE, kit.Keym("domain")), "/chat/lark/sso"), []string{}
if len(arg) == 0 {
m.Cmd("web.chat./river").Tables(func(val ice.Maps) {
m.Cmd("web.chat./river", val[mdb.HASH], chat.STORM).Tables(func(value ice.Maps) {
m.Cmd("web.chat./river", func(val ice.Maps) {
m.Cmd("web.chat./river", val[mdb.HASH], chat.STORM, func(value ice.Maps) {
list = append(list, kit.Keys(val[mdb.NAME], value[mdb.NAME]),
ice.CMD, kit.Format([]string{HOME, val[mdb.HASH], value[mdb.HASH], val[mdb.NAME] + "." + value[mdb.NAME]}))
})
@ -31,7 +31,7 @@ func init() {
m.Option(ice.MSG_RIVER, arg[0])
m.Option(ice.MSG_STORM, arg[1])
link = kit.MergeURL(link, chat.RIVER, arg[0], chat.STORM, arg[1])
m.Cmd("web.chat./river", arg[0], chat.STORM, arg[1]).Tables(func(value ice.Maps) {
m.Cmd("web.chat./river", arg[0], chat.STORM, arg[1], func(value ice.Maps) {
list = append(list, value[ice.CMD], ice.CMD, kit.Keys(value[ice.CTX], value[ice.CMD]))
})
}

2
misc/ssh/rsa.go
View File

@ -32,7 +32,7 @@ func init() {
))
}},
mdb.EXPORT: {Name: "export key=.ssh/id_rsa pub=.ssh/id_rsa.pub", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(m.PrefixKey(), m.Option(mdb.HASH)).Tables(func(value ice.Maps) {
m.Cmd(m.PrefixKey(), m.Option(mdb.HASH), func(value ice.Maps) {
m.Cmdx(nfs.SAVE, kit.HomePath(m.Option("key")), value[PRIVATE])
m.Cmdx(nfs.SAVE, kit.HomePath(m.Option("pub")), value[PUBLIC])
})

4
misc/ssh/service.go
View File

@ -31,7 +31,7 @@ func _ssh_config(m *ice.Message, h string) *ssh.ServerConfig {
m.Logs(ice.LOG_AUTH, tcp.HOSTPORT, conn.RemoteAddr(), aaa.USERNAME, conn.User())
err = nil // 本机用户
} else {
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(mdb.HASH, h), mdb.LIST).Tables(func(value ice.Maps) {
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(mdb.HASH, h), mdb.LIST, func(value ice.Maps) {
if !strings.HasPrefix(value[mdb.NAME], conn.User()+"@") {
return
}
@ -135,7 +135,7 @@ func init() {
}},
mdb.EXPORT: {Name: "export authkey=.ssh/authorized_keys", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
list := []string{}
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(mdb.HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST).Tables(func(value ice.Maps) {
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(mdb.HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST, func(value ice.Maps) {
list = append(list, fmt.Sprintf("%s %s %s", value[mdb.TYPE], value[mdb.TEXT], value[mdb.NAME]))
})

56
misc/tmux/buffer.go
View File

@ -4,7 +4,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
@ -14,53 +13,37 @@ const (
BUFFER = "buffer"
TEXT = "text"
)
const (
SET_BUFFER = "set-buffer"
SHOW_BUFFER = "show-buffer"
LIST_BUFFER = "list-buffers"
)
func init() {
Index.MergeCommands(ice.Commands{
BUFFER: {Name: "buffer name value auto export import", Help: "缓存", Actions: ice.Actions{
BUFFER: {Name: "buffer name value auto", Help: "缓存", Actions: ice.Actions{
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case mdb.TEXT:
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", m.Option(mdb.NAME), arg[1])
_tmux_cmd(m, SET_BUFFER, "-b", m.Option(mdb.NAME), arg[1])
}
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Config(mdb.LIST, "")
m.Config(mdb.COUNT, "0")
m.Cmd(BUFFER).Table(func(index int, value ice.Maps, head []string) {
mdb.Grow(m, m.PrefixKey(), "", kit.Dict(
mdb.NAME, value[head[0]], mdb.TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", value[head[0]]),
))
})
m.Cmdy(mdb.EXPORT, m.PrefixKey(), "", mdb.LIST)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Config(mdb.LIST, "")
m.Config(mdb.COUNT, "0")
m.Option(mdb.CACHE_LIMIT, "-1")
m.Cmdy(mdb.IMPORT, m.PrefixKey(), "", mdb.LIST)
mdb.Grows(m, m.PrefixKey(), "", "", "", func(index int, value ice.Map) {
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", value[mdb.NAME], value[mdb.TEXT])
})
}},
}, Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 1 && arg[1] != "" { // 设置缓存
m.Cmd(cli.SYSTEM, TMUX, "set-buffer", "-b", arg[0], arg[1])
_tmux_cmd(m, SET_BUFFER, "-b", arg[0], arg[1])
}
if len(arg) > 0 { // 查看缓存
m.Echo(m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", arg[0]))
m.Echo(_tmux_cmd(m, SHOW_BUFFER, "-b", arg[0]).Result())
return
}
// 缓存列表
for i, v := range kit.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-buffers"), ice.NL, ice.NL, ice.NL) {
for i, v := range kit.Split(_tmux_cmd(m, LIST_BUFFER).Result(), ice.NL, ice.NL, ice.NL) {
ls := strings.SplitN(v, ": ", 3)
m.Push(mdb.NAME, ls[0])
m.Push(nfs.SIZE, ls[1])
if i < 3 {
m.Push(mdb.TEXT, m.Cmdx(cli.SYSTEM, TMUX, "show-buffer", "-b", ls[0]))
m.Push(mdb.TEXT, _tmux_cmd(m, SHOW_BUFFER, "-b", ls[0]).Result())
} else {
m.Push(mdb.TEXT, ls[2][1:len(ls[2])-1])
}
@ -69,24 +52,13 @@ func init() {
TEXT: {Name: "text auto save text:textarea", Help: "文本", Actions: ice.Actions{
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])
_tmux_cmd(m, SET_BUFFER, arg[0])
}
m.Cmdy(TEXT)
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == mdb.FOREACH && arg[1] == "" {
text := m.Cmdx(cli.SYSTEM, TMUX, "show-buffer")
if strings.HasPrefix(text, "http") {
m.PushSearch(mdb.TEXT, text)
} else {
m.PushSearch(mdb.TEXT, ice.Render(m, ice.RENDER_SCRIPT, text))
}
}
}},
}, Hand: func(m *ice.Message, arg ...string) {
text := m.Cmdx(cli.SYSTEM, TMUX, "show-buffer")
if m.EchoQRCode(text); strings.HasPrefix(text, ice.HTTP) {
m.Echo(ice.NL)
text := _tmux_cmd(m, SHOW_BUFFER).Result()
if m.EchoQRCode(text).Echo(ice.NL); strings.HasPrefix(text, ice.HTTP) {
m.EchoAnchor(text)
} else {
m.EchoScript(text)

4
misc/tmux/script.go
View File

@ -11,8 +11,6 @@ func init() {
Index.MergeCommands(ice.Commands{
SCRIPT: {Name: "script name auto create export import", Help: "脚本", Actions: ice.MergeActions(ice.Actions{
mdb.CREATE: {Name: "create type=shell,tmux,vim name=hi text:textarea=pwd", Help: "添加"},
}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,type,name,text")), Hand: func(m *ice.Message, arg ...string) {
mdb.HashSelect(m, arg...)
}},
}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,type,name,text"))},
})
}

107
misc/tmux/session.go
View File

@ -17,16 +17,23 @@ func _tmux_key(arg ...string) string {
return arg[0] + ice.DF + arg[1] + ice.PT + arg[2]
} else if len(arg) > 1 {
return arg[0] + ice.DF + arg[1]
} else {
} else if len(arg) > 0 {
return arg[0]
} else {
return "miss"
}
}
func _tmux_cmd(m *ice.Message, arg ...string) *ice.Message {
return m.Cmd(cli.SYSTEM, TMUX, arg)
}
func _tmux_cmds(m *ice.Message, arg ...string) string {
return _tmux_cmd(m, arg...).Result()
}
const (
FORMAT = "format"
FIELDS = "fields"
)
const (
SESSION = "session"
WINDOW = "window"
@ -34,6 +41,30 @@ const (
VIEW = "view"
CMD = "cmd"
)
const (
NEW_SESSION = "new-session"
NEW_WINDOW = "new-window"
LINK_WINDOW = "link-window"
SPLIT_WINDOW = "split-window"
KILL_PANE = "kill-pane"
KILL_WINDOW = "kill-window"
KILL_SESSION = "kill-session"
RENAME_WINDOW = "rename-window"
RENAME_SESSION = "rename-session"
SWITCH_CLIENT = "switch-client"
SELECT_WINDOW = "select-window"
SELECT_PANE = "select-pane"
LIST_SESSION = "list-session"
LIST_WINDOWS = "list-windows"
LIST_PANES = "list-panes"
SEND_KEYS = "send-keys"
CAPTURE_PANE = "capture-pane"
ENTER = "Enter"
)
func init() {
Index.Merge(&ice.Context{Configs: ice.Configs{
@ -51,9 +82,9 @@ func init() {
)},
}, Commands: ice.Commands{
SESSION: {Name: "session session window pane cmd auto", Help: "会话管理", Actions: ice.Actions{
web.DREAM_CREATE: {Name: "dream.create type name", Help: "梦想", Hand: func(m *ice.Message, arg ...string) {
if m.Cmd(m.PrefixKey(), m.Option(mdb.NAME)).Length() == 0 {
m.Cmd(m.PrefixKey(), mdb.CREATE)
web.DREAM_CREATE: {Name: "dream.create", Help: "梦想", Hand: func(m *ice.Message, arg ...string) {
if m.Cmd("", m.Option(mdb.NAME)).Length() == 0 {
m.Cmd("", mdb.CREATE)
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
@ -69,62 +100,61 @@ func init() {
mdb.CREATE: {Name: "create name", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_ENV, TMUX, "")
if m.Option(PANE) != "" { // 创建终端
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
_tmux_cmd(m, SPLIT_WINDOW, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
} else if m.Option(WINDOW) != "" { // 创建终端
m.Cmdy(cli.SYSTEM, TMUX, "split-window", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
_tmux_cmd(m, SPLIT_WINDOW, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
} else if m.Option(SESSION) != "" { // 创建窗口
m.Cmdy(cli.SYSTEM, TMUX, "new-window", "-t", m.Option(SESSION), "-dn", m.Option(mdb.NAME))
_tmux_cmd(m, NEW_WINDOW, "-d", "-t", m.Option(SESSION), "-n", m.Option(mdb.NAME))
} else { // 创建会话
m.Option(cli.CMD_DIR, path.Join(ice.USR_LOCAL_WORK, m.Option(mdb.NAME)))
ls := kit.Split(strings.TrimSuffix(m.Option(mdb.NAME), "-story"), "-")
name := ls[len(ls)-1]
m.Cmdy(cli.SYSTEM, TMUX, "new-session", "-ds", m.Option(mdb.NAME), "-n", name)
name = _tmux_key(m.Option(mdb.NAME), ls[len(ls)-1])
ls := kit.Split(m.Option(mdb.NAME), "-")
name := kit.Select(ls[0], ls, 1)
_tmux_cmd(m, NEW_SESSION, "-d", "-s", m.Option(mdb.NAME), "-n", name)
m.Cmd(cli.SYSTEM, TMUX, "split-window", "-t", kit.Keys(name, "1"), "-p", "40")
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "2"), "ish_miss_log", "Enter")
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", kit.Keys(name, "1"), "vi etc/miss.sh", "Enter")
name = _tmux_key(m.Option(mdb.NAME), name)
_tmux_cmd(m, SPLIT_WINDOW, "-t", kit.Keys(name, "1"), "-p", "40")
_tmux_cmd(m, SEND_KEYS, "-t", kit.Keys(name, "2"), "ish_miss_log", ENTER)
_tmux_cmd(m, SEND_KEYS, "-t", kit.Keys(name, "1"), "vi etc/miss.sh", ENTER)
m.Cmdy(cli.SYSTEM, TMUX, "link-window", "-s", name, "-t", "miss:")
_tmux_cmd(m, LINK_WINDOW, "-s", name, "-t", "miss:")
}
m.ProcessRefresh30ms()
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
if m.Option(PANE) != "" { // 删除终端
m.Cmd(cli.SYSTEM, TMUX, "kill-pane", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
_tmux_cmd(m, KILL_PANE, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
} else if m.Option(WINDOW) != "" { // 删除窗口
m.Cmd(cli.SYSTEM, TMUX, "kill-window", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
_tmux_cmd(m, KILL_WINDOW, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
} else if m.Option(SESSION) != "" { // 删除会话
m.Cmd(cli.SYSTEM, TMUX, "kill-session", "-t", m.Option(SESSION))
_tmux_cmd(m, KILL_SESSION, "-t", m.Option(SESSION))
}
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case WINDOW: // 重命名窗口
m.Cmd(cli.SYSTEM, TMUX, "rename-window", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)), arg[1])
_tmux_cmd(m, RENAME_WINDOW, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)), arg[1])
case SESSION: // 重命名会话
m.Cmd(cli.SYSTEM, TMUX, "rename-session", "-t", m.Option(SESSION), arg[1])
_tmux_cmd(m, RENAME_SESSION, "-t", m.Option(SESSION), arg[1])
}
}},
mdb.SELECT: {Name: "select", Help: "进入", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(cli.SYSTEM, TMUX, "switch-client", "-t", m.Option(SESSION))
_tmux_cmd(m, SWITCH_CLIENT, "-t", m.Option(SESSION))
if m.Option(WINDOW) != "" { // 切换窗口
m.Cmd(cli.SYSTEM, TMUX, "select-window", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
_tmux_cmd(m, SELECT_WINDOW, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW)))
}
if m.Option(PANE) != "" { // 切换终端
m.Cmd(cli.SYSTEM, TMUX, "select-pane", "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
_tmux_cmd(m, SELECT_PANE, "-t", _tmux_key(m.Option(SESSION), m.Option(WINDOW), m.Option(PANE)))
}
}},
SCRIPT: {Name: "script name", Help: "脚本", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(SCRIPT, m.Option(mdb.NAME)).Tables(func(value ice.Maps) {
m.Cmd(SCRIPT, m.Option(mdb.NAME), func(value ice.Maps) {
switch value[mdb.TYPE] {
case "shell":
for _, line := range kit.Split(value[mdb.TEXT], ice.NL, ice.NL, ice.NL) {
@ -136,7 +166,7 @@ func init() {
}
case "tmux":
for _, line := range kit.Split(value[mdb.TEXT], ice.NL, ice.NL, ice.NL) {
m.Cmd(cli.SYSTEM, TMUX, line)
_tmux_cmd(m, line)
}
}
})
@ -151,20 +181,18 @@ func init() {
m.Echo(strings.TrimSpace(m.Cmdx(VIEW, _tmux_key(arg[0], arg[1], arg[2]))))
return
}
m.Action(mdb.CREATE)
if len(arg) > 1 { // 终端列表
m.Cmdy(PANE, _tmux_key(arg[0], arg[1]))
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
}
if len(arg) > 0 { // 窗口列表
} else if len(arg) > 0 { // 窗口列表
m.Cmdy(WINDOW, arg[0])
m.PushAction(mdb.SELECT, mdb.REMOVE)
return
} else { // 会话列表
m.Split(_tmux_cmd(m, LIST_SESSION, "-F", m.Config(FORMAT)).Result(), m.Config(FIELDS), ice.FS, ice.NL)
}
// 会话列表
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-session", "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
m.Tables(func(value ice.Maps) {
switch value["tag"] {
case "1":
@ -175,17 +203,16 @@ func init() {
})
}},
WINDOW: {Name: "windows", Help: "窗口", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-windows", "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
m.Split(m.Cmdx(cli.SYSTEM, TMUX, LIST_WINDOWS, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
}},
PANE: {Name: "panes", Help: "终端", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, "list-panes", "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
m.Split(_tmux_cmds(m, LIST_PANES, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
}},
VIEW: {Name: "view", Help: "内容", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(cli.SYSTEM, TMUX, "capture-pane", "-pt", kit.Select("", arg, 0)).Set(ice.MSG_APPEND)
m.Echo(_tmux_cmds(m, CAPTURE_PANE, "-p", "-t", kit.Select("", arg, 0)))
}},
CMD: {Name: "cmd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(cli.SYSTEM, TMUX, "send-keys", "-t", arg[0], strings.Join(arg[1:], ice.SP), "Enter")
m.Sleep300ms()
_tmux_cmd(m, SEND_KEYS, "-t", arg[0], strings.Join(arg[1:], ice.SP), ENTER)
}},
}})
}

10
misc/tmux/tmux.go
View File

@ -11,19 +11,15 @@ import (
const TMUX = "tmux"
var Index = &ice.Context{Name: TMUX, Help: "工作台", Configs: ice.Configs{
TMUX: {Name: TMUX, Help: "工作台", Value: kit.Data(
nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz",
)},
}, Commands: ice.Commands{
var Index = &ice.Context{Name: TMUX, Help: "工作台", Commands: ice.Commands{
TMUX: {Name: "tmux path auto start order build download", Help: "服务", Actions: ice.MergeActions(ice.Actions{
cli.START: {Name: "start", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Optionv(code.PREPARE, func(p string) []string {
return []string{"-S", kit.Path(m.Option(cli.CMD_DIR, p), "tmux.socket"), "new-session", "-dn", "miss"}
return []string{"-S", kit.Path(m.Option(cli.CMD_DIR, p), "tmux.socket"), NEW_SESSION, "-d", "-n", "miss"}
})
m.Cmdy(code.INSTALL, cli.START, m.Config(nfs.SOURCE), "bin/tmux")
}},
}, code.InstallAction()), Hand: func(m *ice.Message, arg ...string) {
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, nfs.SOURCE, m.Config(nfs.SOURCE), arg)
}},
}}

4
misc/vim/favor.go
View File

@ -17,7 +17,7 @@ func init() {
Index.MergeCommands(ice.Commands{
"/favor": {Name: "/favor", Help: "收藏", Actions: ice.Actions{
mdb.SELECT: {Name: "select", Help: "主题", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(FAVOR).Tables(func(value ice.Maps) {
m.Cmd(FAVOR, func(value ice.Maps) {
m.Echo(value[mdb.ZONE]).Echo(ice.NL)
})
}},
@ -25,7 +25,7 @@ func init() {
m.Cmd(FAVOR, mdb.INSERT)
}},
}, Hand: func(m *ice.Message, arg ...string) {
m.Cmd(FAVOR, m.Option(mdb.ZONE)).Tables(func(value ice.Maps) {
m.Cmd(FAVOR, m.Option(mdb.ZONE), func(value ice.Maps) {
m.Echo("%v\n", m.Option(mdb.ZONE)).Echo("%v:%v:%v:(%v): %v\n",
value[nfs.FILE], value[nfs.LINE], "1", value[mdb.NAME], value[mdb.TEXT])
})

2
render.go
View File

@ -92,7 +92,7 @@ func (m *Message) IsMobileUA() bool {
return strings.Contains(m.Option(MSG_USERUA), "Mobile")
}
func (m *Message) IsCliUA() bool {
if m.Option(MSG_USERUA) == "" || !strings.HasPrefix(m.Option(MSG_USERUA), "Mozilla/5.0") {
if m.Option(MSG_USERUA) == "" || !strings.HasPrefix(m.Option(MSG_USERUA), "Mozilla") {
return true
}
return false