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

opt code

Browse Source
This commit is contained in:
harveyshao 2021-10-31 22:32:14 +08:00
parent c210a7bf63
commit f4258e4092
24 changed files with 870 additions and 1111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/chat/header.go
View File

@ -88,7 +88,7 @@ func init() {
switch arg[0] {
case "/header":
switch kit.Select("", arg, 1) {
case AGENT, CHECK:
case AGENT, CHECK, aaa.LOGIN:
return // 非登录态
}
}

1
core/chat/river.go
View File

@ -109,6 +109,7 @@ func init() {
return // 没有授权
}
m.Debug("what %v-------", arg)
switch kit.Select("", arg, 1) {
case STORM, OCEAN, NODE:
m.Option(ice.MSG_RIVER, arg[0])

73
core/code/autogen.go
View File

@ -21,16 +21,6 @@ func _defs(m *ice.Message, args ...string) {
}
}
}
func _autogen_script(m *ice.Message, dir string) {
buf, _ := kit.Render(`chapter "{{.Option "name"}}"
field "{{.Option "help"}}" {{.Option "key"}}
`, m)
m.Cmd(nfs.DEFS, dir, string(buf))
}
func _autogen_source(m *ice.Message, zone, name string) {
m.Cmd(nfs.PUSH, ice.SRC_MAIN_SHY, "\n", kit.SSH_SOURCE+` `+path.Join(zone, kit.Keys(name, SHY)), "\n")
}
func _autogen_module(m *ice.Message, dir string) {
buf, _ := kit.Render(`package {{.Option "zone"}}
@ -74,9 +64,19 @@ func main() { print(ice.Run()) }
}
})
m.Cmd(nfs.SAVE, main, strings.Join(list, ice.NL))
m.Cmd(nfs.SAVE, main, kit.Join(list, ice.NL))
return
}
func _autogen_script(m *ice.Message, dir string) {
buf, _ := kit.Render(`chapter "{{.Option "name"}}"
field "{{.Option "help"}}" {{.Option "key"}}
`, m)
m.Cmd(nfs.DEFS, dir, string(buf))
}
func _autogen_source(m *ice.Message, zone, name string) {
m.Cmd(nfs.PUSH, ice.SRC_MAIN_SHY, ice.NL, kit.SSH_SOURCE+ice.SP+path.Join(zone, kit.Keys(name, SHY)), ice.NL)
}
func _autogen_mod(m *ice.Message, file string) (mod string) {
m.Cmd(nfs.DEFS, ice.GO_MOD, kit.Format(`module %s
@ -85,7 +85,7 @@ go 1.11
m.Cmd(nfs.CAT, file, func(line string, index int) {
if strings.HasPrefix(line, "module") {
mod = strings.Split(line, " ")[1]
mod = kit.Split(line, ice.SP)[1]
m.Logs("module", mod)
}
})
@ -127,17 +127,17 @@ func init() {
ice.Info.HostName, ice.Info.UserName,
))
m.Cmdy(nfs.DIR, ice.SRC_BINPACK_GO, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.SRC_VERSION_GO, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.SRC_MAIN_GO, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.SRC_BINPACK_GO)
m.Cmdy(nfs.DIR, ice.SRC_VERSION_GO)
m.Cmdy(nfs.DIR, ice.SRC_MAIN_GO)
}
func _autogen_miss(m *ice.Message) {
m.Cmd(nfs.DEFS, ice.ETC_MISS_SH, m.Conf(web.DREAM, kit.Keym("miss")))
defer m.Cmdy(nfs.CAT, ice.ETC_MISS_SH)
m.Cmdy(nfs.DIR, ice.ETC_MISS_SH, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.GO_MOD, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.GO_SUM, "time,size,line,path")
m.Cmdy(nfs.DIR, ice.ETC_MISS_SH)
m.Cmdy(nfs.DIR, ice.GO_MOD)
m.Cmdy(nfs.DIR, ice.GO_SUM)
}
const AUTOGEN = "autogen"
@ -145,10 +145,17 @@ const AUTOGEN = "autogen"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
AUTOGEN: {Name: "autogen path auto create binpack script", Help: "生成", Action: map[string]*ice.Action{
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case kit.MDB_MAIN:
m.Cmdy(nfs.DIR, ice.SRC, "path,size,time", ice.Option{nfs.DIR_REG, `.*\.go`})
m.RenameAppend(kit.MDB_PATH, arg[0])
}
}},
mdb.CREATE: {Name: "create main=src/main.go@key key zone type=Zone,Hash,Data name=hi list help", Help: "模块", Hand: func(m *ice.Message, arg ...string) {
_defs(m, "zone", m.Option("name"), "help", m.Option("name"))
_defs(m, "key", kit.Keys("web.code", m.Option("zone"), m.Option("name")))
switch m.Option("type") {
_defs(m, kit.MDB_ZONE, m.Option(kit.MDB_NAME), kit.MDB_HELP, m.Option(kit.MDB_NAME))
_defs(m, kit.MDB_KEY, kit.Keys("web.code", m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME)))
switch m.Option(kit.MDB_TYPE) {
case "Zone":
_defs(m, "list", "list zone id auto insert")
case "Hash":
@ -158,34 +165,26 @@ func init() {
}
m.Option("tag", kit.Format("`name:\"%s\" help:\"%s\"`", m.Option("list"), m.Option("help")))
if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), SHY)); !kit.FileExists(p) {
_autogen_script(m, p)
_autogen_source(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME))
}
if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), GO)); !kit.FileExists(p) {
_autogen_module(m, p)
_autogen_import(m, m.Option(kit.MDB_MAIN), m.Option(kit.MDB_ZONE), _autogen_mod(m, ice.GO_MOD))
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case kit.MDB_MAIN:
m.Option(nfs.DIR_REG, `.*\.go`)
m.Cmdy(nfs.DIR, ice.SRC, "path,size,time")
m.RenameAppend(kit.MDB_PATH, arg[0])
if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), SHY)); !kit.FileExists(p) {
_autogen_script(m, p)
_autogen_source(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME))
}
}},
ssh.SCRIPT: {Name: "script", Help: "脚本：生成 etc/miss.sh", Hand: func(m *ice.Message, arg ...string) {
_autogen_miss(m)
}},
BINPACK: {Name: "binpack", Help: "打包：生成 src/binpack.go", Hand: func(m *ice.Message, arg ...string) {
_autogen_version(m)
m.Cmd(BINPACK, mdb.CREATE)
m.Cmd(cli.SYSTEM, "sh", "-c", `cat src/binpack.go|sed 's/package main/package ice/g' > usr/release/binpack.go`)
}},
ssh.SCRIPT: {Name: "script", Help: "脚本：生成 etc/miss.sh", Hand: func(m *ice.Message, arg ...string) {
_autogen_miss(m)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if m.Option(nfs.DIR_ROOT, ice.SRC); len(arg) == 0 || strings.HasSuffix(arg[0], "/") {
if m.Option(nfs.DIR_ROOT, ice.SRC); len(arg) == 0 || strings.HasSuffix(arg[0], ice.PS) {
m.Cmdy(nfs.DIR, kit.Select("./", arg, 0))
} else {
m.Cmdy(nfs.CAT, arg[0])

110
core/code/bench.go
View File

@ -5,14 +5,11 @@ import (
"io/ioutil"
"net/http"
"os"
"path"
"strings"
"sync/atomic"
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"
"shylinux.com/x/toolkits/util/bench"
)
@ -23,7 +20,7 @@ func _bench_http(m *ice.Message, name, target string, arg ...string) {
m.Echo("nconn: %d nreqs: %d\n", nconn, nreqs*nconn)
list := []*http.Request{}
for _, v := range strings.Split(target, ",") {
for _, v := range strings.Split(target, ice.SP) {
switch ls := kit.Split(v); ls[0] {
case http.MethodPost:
if f, e := os.Open(ls[2]); m.Assert(e) {
@ -65,90 +62,27 @@ const (
const BENCH = "bench"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
},
Commands: map[string]*ice.Command{
"/bench": {Name: "/bench cmd...", Help: "性能压测", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(m.Optionv("cmd"))
}},
BENCH: {Name: "bench zone id auto insert", Help: "性能压测", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, arg)
}},
mdb.INSERT: {Name: "insert zone=some type=http,redis name=demo text nconn=3 nreqs=10", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, kit.MDB_ZONE, arg[1])
m.Cmdy(mdb.INSERT, BENCH, "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, BENCH, "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, BENCH, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
}},
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_TYPE) {
case HTTP:
_bench_http(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
case REDIS:
_bench_redis(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count", "time,id,type,name,text,nconn,nreqs")
m.Cmdy(mdb.SELECT, BENCH, "", mdb.ZONE, arg)
m.PushAction(kit.Select(mdb.REMOVE, ice.RUN, len(arg) > 0))
}},
"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{
"run": {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
// cli.Follow(m, "run", func() {
m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
// })
}},
"case": {Name: "case", Help: "用例", Hand: func(m *ice.Message, arg ...string) {
msg := m.Spawn()
if strings.HasSuffix(arg[0], "/") {
msg.Option(cli.CMD_DIR, arg[0])
msg.Split(msg.Cmdx(cli.SYSTEM, "grep", "-r", "func Test.*(", "./"), "file:line", ":", "\n")
msg.Table(func(index int, value map[string]string, head []string) {
if strings.HasPrefix(strings.TrimSpace(value["line"]), "//") {
return
}
ls := kit.Split(value["line"], " (", " (", " (")
m.Push("file", value["file"])
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
})
} else {
for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
ls := kit.Split(line, " (", " (", " (")
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
}
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 || arg[0] == "" {
m.Cmdy(nfs.DIR, "./")
return
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,nconn,nreqs",
)},
}, Commands: map[string]*ice.Command{
"/bench": {Name: "/bench cmd...", Help: "性能压测", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(m.Optionv("cmd"))
}},
BENCH: {Name: "bench zone id auto insert", Help: "性能压测", Action: ice.MergeAction(map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone=some type=http,redis name=demo text nconn=3 nreqs=10", Help: "添加"},
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_TYPE) {
case HTTP:
_bench_http(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
case REDIS:
_bench_redis(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
}
if len(arg) == 1 {
if strings.HasSuffix(arg[0], "/") {
m.Cmdy(nfs.DIR, arg[0])
} else {
for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
ls := kit.Split(line, " (", " (", " (")
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
}
}
return
}
m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
}},
},
})
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.ZoneSelect(m, arg...)
m.PushAction(kit.Select(mdb.REMOVE, ice.RUN, len(arg) > 0))
}},
}})
}

29
core/code/binpack.go
View File

@ -2,6 +2,7 @@ package code
import (
"fmt"
"io"
"io/ioutil"
"os"
"path"
@ -13,11 +14,11 @@ import (
kit "shylinux.com/x/toolkits"
)
func _pack_write(o *os.File, arg ...string) {
func _pack_write(o io.Writer, arg ...string) {
for _, v := range arg {
o.WriteString(v)
fmt.Fprint(o, v)
}
o.WriteString(ice.NL)
fmt.Fprintln(o)
}
func _pack_file(m *ice.Message, file string) string {
list := ""
@ -29,7 +30,7 @@ func _pack_file(m *ice.Message, file string) string {
}
}
if list = strings.ReplaceAll(list, " ", ","); len(list) > 0 {
if list = strings.ReplaceAll(list, ice.SP, ","); len(list) > 0 {
return fmt.Sprintf(`[]byte{%v}`, list[1:len(list)-1])
}
return "[]byte{}"
@ -43,7 +44,7 @@ func _pack_dir(m *ice.Message, pack *os.File, dir string) {
if path.Base(value[kit.MDB_PATH]) == "binpack.go" {
return
}
switch strings.Split(value[kit.MDB_PATH], "/")[0] {
switch strings.Split(value[kit.MDB_PATH], ice.PS)[0] {
case "pluged", "trash":
return
}
@ -72,8 +73,8 @@ func _pack_volcanos(m *ice.Message, pack *os.File, dir string) {
}
func _pack_ctx(m *ice.Message, pack *os.File) {
_pack_dir(m, pack, ice.SRC_HELP)
_pack_dir(m, pack, "src")
pack.WriteString(ice.NL)
_pack_dir(m, pack, ice.SRC)
_pack_write(pack)
}
const BINPACK = "binpack"
@ -84,27 +85,25 @@ func init() {
mdb.CREATE: {Name: "create", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
if pack, p, e := kit.Create(ice.SRC_BINPACK_GO); m.Assert(e) {
defer pack.Close()
defer m.Echo(p)
_pack_write(pack, `package main`)
_pack_write(pack, "")
_pack_write(pack)
_pack_write(pack, `import (`)
_pack_write(pack, ` ice "shylinux.com/x/icebergs"`)
_pack_write(pack, `)`)
_pack_write(pack, "")
_pack_write(pack)
_pack_write(pack, `func init() {`)
_pack_write(pack, ` ice.Info.Pack = map[string][]byte{`)
_pack_write(pack, ` ice.Info.Pack = map[string][]byte{`)
_pack_volcanos(m, pack, ice.USR_VOLCANOS)
_pack_dir(m, pack, ice.USR_LEARNING)
// _pack_dir(m, pack, ice.USR_ICEBERGS)
// _pack_dir(m, pack, ice.USR_TOOLKITS)
_pack_dir(m, pack, ice.USR_INTSHELL)
_pack_ctx(m, pack)
_pack_write(pack, ` }`)
_pack_write(pack, ` }`)
_pack_write(pack, `}`)
m.Echo(p)
}
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
@ -112,7 +111,7 @@ func init() {
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
for key, value := range ice.Info.Pack {
if strings.HasPrefix(key, "/") {
if strings.HasPrefix(key, ice.PS) {
key = ice.USR_VOLCANOS + key
}
m.Warn(os.MkdirAll(path.Dir(key), ice.MOD_DIR), "mkdir", key)

247
core/code/c.go
View File

@ -8,13 +8,12 @@ import (
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"
)
func _c_tags(m *ice.Message, key string) {
if _, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), ".tags")); e != nil {
m.Cmd(cli.SYSTEM, "ctags", "-R", "-f", ".tags", "./")
if _, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), _TAGS)); e != nil {
m.Cmd(cli.SYSTEM, "ctags", "-R", "-f", _TAGS, "./")
}
_go_tags(m, key)
}
@ -40,156 +39,130 @@ func _c_help(m *ice.Message, section, key string) string {
const (
H = "h"
CC = "cc"
MAN = "man"
MAN1 = "man1"
MAN2 = "man2"
MAN3 = "man3"
MAN8 = "man8"
)
const (
FIND = "find"
GREP = "grep"
MAN = "man"
)
const C = "c"
func init() {
Index.Register(&ice.Context{Name: C, Help: "系统",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
Index.Merge(&ice.Context{Name: C, Help: "系统", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
for _, k := range []string{H, C, CC} {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, k, m.Prefix(C))
}
m.Cmd(cmd, mdb.CREATE, k, m.Prefix(C))
}
}
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.SEARCH} {
for _, k := range []string{MAN1, MAN2, MAN3, MAN8} {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, k, m.Prefix(MAN))
m.Cmd(cmd, mdb.CREATE, k, m.Prefix(MAN))
}
}
LoadPlug(m, C)
LoadPlug(m, MAN)
}},
C: {Name: C, Help: "系统", Action: ice.MergeAction(map[string]*ice.Action{
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
name := strings.TrimSuffix(arg[1], path.Ext(arg[1])) + ".bin"
if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); !cli.IsSuccess(msg) {
m.Copy(msg)
return
}
m.Cmdy(cli.SYSTEM, "./"+name)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
_c_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}, PlugAction())},
MAN: {Name: MAN, Help: "手册", Action: ice.MergeAction(map[string]*ice.Action{
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, strings.TrimPrefix(arg[0], MAN), strings.TrimSuffix(arg[1], ice.PT+arg[0])))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
for _, i := range []string{"1", "2", "3", "8"} {
if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
m.PushSearch(ice.CMD, MAN, kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
}
}
LoadPlug(m, C)
}},
C: {Name: C, Help: "系统", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(C, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
name := strings.TrimSuffix(arg[1], path.Ext(arg[1])) + ".bin"
if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); !cli.IsSuccess(msg) {
m.Copy(msg)
return
}
m.Cmdy(cli.SYSTEM, "./"+name)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
_c_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}},
MAN: {Name: MAN, Help: "手册", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(MAN, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, strings.TrimPrefix(arg[0], MAN), strings.TrimSuffix(arg[1], "."+arg[0])))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
for _, i := range []string{"1", "2", "3", "8"} {
if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
m.PushSearch(ice.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
}
}
}},
}},
},
Configs: map[string]*ice.Config{
C: {Name: C, Help: "系统", Value: kit.Data(
PLUG, kit.Dict(
SPLIT, kit.Dict(
"space", " ",
"operator", "{[(.,:;!|<>)]}",
),
PREFIX, kit.Dict(
"//", COMMENT,
"/*", COMMENT,
"*", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"#include",
"#define",
"#ifndef",
"#ifdef",
"#else",
"#endif",
}, PlugAction())},
}, Configs: map[string]*ice.Config{
C: {Name: C, Help: "系统", Value: kit.Data(PLUG, kit.Dict(
SPLIT, kit.Dict("space", " ", "operator", "{[(.,:;!|<>)]}"),
PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "*", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"#include",
"#define",
"#ifndef",
"#ifdef",
"#else",
"#endif",
"if",
"else",
"for",
"while",
"do",
"break",
"continue",
"switch",
"case",
"default",
"return",
"if",
"else",
"for",
"while",
"do",
"break",
"continue",
"switch",
"case",
"default",
"return",
"typedef",
"sizeof",
"extern",
"static",
"const",
),
DATATYPE, kit.Simple(
"union",
"struct",
"unsigned",
"double",
"void",
"long",
"char",
"int",
),
FUNCTION, kit.Simple(
"assert",
"zmalloc",
),
CONSTANT, kit.Simple(
"NULL", "-1", "0", "1", "2",
),
),
KEYWORD, kit.Dict(),
"typedef",
"sizeof",
"extern",
"static",
"const",
),
)},
MAN: {Name: MAN, Help: "手册", Value: kit.Data(
PLUG, kit.Dict(
PREFIX, kit.Dict(
"NAME", COMMENT,
"LIBRARY", COMMENT,
"SYNOPSIS", COMMENT,
"DESCRIPTION", COMMENT,
"STANDARDS", COMMENT,
"SEE ALSO", COMMENT,
"HISTORY", COMMENT,
"BUGS", COMMENT,
),
DATATYPE, kit.Simple(
"union",
"struct",
"unsigned",
"double",
"void",
"long",
"char",
"int",
),
)},
},
}, nil)
FUNCTION, kit.Simple(
"assert",
"zmalloc",
),
CONSTANT, kit.Simple(
"NULL", "-1", "0", "1", "2",
),
), KEYWORD, kit.Dict(),
))},
MAN: {Name: MAN, Help: "手册", Value: kit.Data(PLUG, kit.Dict(
PREPARE, kit.Dict(
COMMENT, kit.Simple(
"NAME",
"LIBRARY",
"SYNOPSIS",
"DESCRIPTION",
"STANDARDS",
"SEE ALSO",
"HISTORY",
"BUGS",
),
), KEYWORD, kit.Dict(),
))},
}})
}

51
core/code/case.go
View File

@ -1,9 +1,13 @@
package code
import (
"path"
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
)
@ -78,5 +82,52 @@ func init() {
}
m.StatusTimeCount()
}},
"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{
"run": {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
// cli.Follow(m, "run", func() {
m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
// })
}},
"case": {Name: "case", Help: "用例", Hand: func(m *ice.Message, arg ...string) {
msg := m.Spawn()
if strings.HasSuffix(arg[0], "/") {
msg.Option(cli.CMD_DIR, arg[0])
msg.Split(msg.Cmdx(cli.SYSTEM, "grep", "-r", "func Test.*(", "./"), "file:line", ":", "\n")
msg.Table(func(index int, value map[string]string, head []string) {
if strings.HasPrefix(strings.TrimSpace(value["line"]), "//") {
return
}
ls := kit.Split(value["line"], " (", " (", " (")
m.Push("file", value["file"])
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
})
} else {
for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
ls := kit.Split(line, " (", " (", " (")
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
}
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 || arg[0] == "" {
m.Cmdy(nfs.DIR, "./")
return
}
if len(arg) == 1 {
if strings.HasSuffix(arg[0], "/") {
m.Cmdy(nfs.DIR, arg[0])
} else {
for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
ls := kit.Split(line, " (", " (", " (")
m.Push("func", strings.TrimPrefix(ls[1], "Test"))
}
}
return
}
m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
}},
}})
}

11
core/code/code.go
View File

@ -7,18 +7,11 @@ import (
const CODE = "code"
var Index = &ice.Context{Name: CODE, Help: "编程中心", 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()
}},
}}
var Index = &ice.Context{Name: CODE, Help: "编程中心"}
func init() {
web.Index.Register(Index, &web.Frame{},
WEBPACK, BINPACK, AUTOGEN, COMPILE, UPGRADE, PUBLISH, INSTALL,
AUTOGEN, WEBPACK, BINPACK, COMPILE, PUBLISH, UPGRADE, INSTALL,
VIMER, INNER, FAVOR, BENCH, PPROF,
C, SH, SHY, GO, JS,
)

26
core/code/code.shy
View File

@ -20,3 +20,29 @@ field "脚本" web.code.shy
field "后端" web.code.go
field "前端" web.code.js
code.go
code.shy
autogen.go
webpack.go
binpack.go
compile.go
publish.go
upgrade.go
install.go
vimer.go
inner.go
favor.go
bench.go
pprof.go
c.go
sh.go
shy.go
go.go
js.go
python.go
python.shy
case.go

10
core/code/compile.go
View File

@ -31,7 +31,7 @@ func init() {
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Cmdy(nfs.DIR, m.Config(nfs.PATH), "time,size,path")
m.Cmdy(nfs.DIR, m.Config(nfs.PATH))
return
}
@ -52,12 +52,12 @@ func init() {
}
}
file := path.Join(kit.Select("", m.Config(nfs.PATH), m.Option(cli.CMD_DIR) == ""),
kit.Keys(kit.Select(ice.ICE, kit.TrimExt(main, ".go"), main != ice.SRC_MAIN_GO), goos, arch))
kit.Keys(kit.Select(ice.ICE, kit.TrimExt(main), main != ice.SRC_MAIN_GO), goos, arch))
// 执行编译
_autogen_version(m.Spawn())
m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), cli.GOOS, goos, cli.GOARCH, arch))
if msg := m.Cmd(cli.SYSTEM, m.Confv(COMPILE, kit.Keym(GO)), "-o", file, main, ice.SRC_VERSION_GO, ice.SRC_BINPACK_GO); !cli.IsSuccess(msg) {
m.Optionv(cli.CMD_ENV, kit.Simple(m.Configv(cli.ENV), cli.GOOS, goos, cli.GOARCH, arch))
if msg := m.Cmd(cli.SYSTEM, m.Configv(GO), "-o", file, main, ice.SRC_VERSION_GO, ice.SRC_BINPACK_GO); !cli.IsSuccess(msg) {
m.Copy(msg)
return
}
@ -65,7 +65,7 @@ func init() {
// 编译成功
m.Log_EXPORT(cli.SOURCE, main, cli.TARGET, file)
m.Cmdy(nfs.DIR, file, "time,path,size,link,action")
m.Cmdy(PUBLISH, ice.CONTEXTS, "base")
m.Cmdy(PUBLISH, ice.CONTEXTS, ice.BASE)
m.StatusTimeCount()
}},
}})

60
core/code/favor.go
View File

@ -9,51 +9,19 @@ import (
const FAVOR = "favor"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
FAVOR: {Name: FAVOR, Help: "收藏夹", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,path,file,line",
)},
},
Commands: map[string]*ice.Command{
FAVOR: {Name: "favor zone id auto insert export import", Help: "收藏夹", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.HASH, arg)
}},
mdb.INSERT: {Name: "insert zone=数据结构 type=go name=hi text=hello path file line", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.HASH, kit.MDB_ZONE, arg[1])
m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(FAVOR), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(kit.MDB_ZONE, m.Conf(FAVOR, kit.META_FIELD))
m.Cmdy(mdb.EXPORT, m.Prefix(FAVOR), "", mdb.ZONE)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(kit.MDB_ZONE)
m.Cmdy(mdb.IMPORT, m.Prefix(FAVOR), "", mdb.ZONE)
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case kit.MDB_ZONE:
m.Cmdy(mdb.INPUTS, m.Prefix(FAVOR), "", mdb.HASH, arg)
default:
m.Cmdy(mdb.INPUTS, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg)
}
}},
INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
m.ProcessCommand(INNER, m.OptionSplit("path,file,line"), arg...)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count", m.Conf(FAVOR, kit.META_FIELD))
m.Cmdy(mdb.SELECT, m.Prefix(FAVOR), "", mdb.ZONE, arg)
m.PushAction(kit.Select(mdb.REMOVE, INNER, len(arg) > 0))
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
FAVOR: {Name: FAVOR, Help: "收藏夹", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,path,file,line",
)},
}, Commands: map[string]*ice.Command{
FAVOR: {Name: "favor zone id auto insert", Help: "收藏夹", Action: ice.MergeAction(map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone=数据结构 type=go name=hi text=hello path file line", Help: "添加"},
INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
m.ProcessCommand(INNER, m.OptionSplit("path,file,line"), arg...)
}},
},
})
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.ZoneSelect(m, arg...)
m.PushAction(kit.Select(mdb.REMOVE, INNER, len(arg) > 0))
}},
}})
}

261
core/code/go.go
View File

@ -14,29 +14,21 @@ import (
kit "shylinux.com/x/toolkits"
)
func _go_find(m *ice.Message, key string) {
for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, "find", ".", "-name", key), "\n") {
if p == "" {
continue
}
m.PushSearch(ice.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
}
}
func _go_tags(m *ice.Message, key string) {
if s, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), ".tags")); os.IsNotExist(e) || s.ModTime().Before(time.Now().Add(kit.Duration("-72h"))) {
m.Cmd(cli.SYSTEM, "gotags", "-R", "-f", ".tags", "./")
if s, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), _TAGS)); os.IsNotExist(e) || s.ModTime().Before(time.Now().Add(kit.Duration("-72h"))) {
m.Cmd(cli.SYSTEM, "gotags", "-R", "-f", _TAGS, "./")
}
ls := strings.Split(key, ".")
ls := strings.Split(key, ice.PT)
key = ls[len(ls)-1]
for _, l := range strings.Split(m.Cmdx(cli.SYSTEM, "grep", "^"+key+"\\>", ".tags"), "\n") {
ls := strings.SplitN(l, "\t", 2)
for _, l := range strings.Split(m.Cmdx(cli.SYSTEM, GREP, "^"+key+"\\>", _TAGS), ice.NL) {
ls := strings.SplitN(l, ice.TB, 2)
if len(ls) < 2 {
continue
}
ls = strings.SplitN(ls[1], "\t", 2)
ls = strings.SplitN(ls[1], ice.TB, 2)
file := ls[0]
ls = strings.SplitN(ls[1], ";\"", 2)
text := strings.TrimSuffix(strings.TrimPrefix(ls[0], "/^"), "$/")
@ -54,161 +46,128 @@ func _go_tags(m *ice.Message, key string) {
}
}
}
func _go_grep(m *ice.Message, key string) {
msg := m.Spawn()
msg.Split(m.Cmd(cli.SYSTEM, "grep", "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(ice.CMD, "grep", value) })
}
func _go_help(m *ice.Message, key string) {
p := m.Cmd(cli.SYSTEM, "go", "doc", key).Append(cli.CMD_OUT)
p := m.Cmd(cli.SYSTEM, GO, "doc", key).Append(cli.CMD_OUT)
if p == "" {
return
}
m.PushSearch(ice.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
}
func _go_find(m *ice.Message, key string) {
for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, FIND, ".", "-name", key), ice.NL) {
if p == "" {
continue
}
m.PushSearch(ice.CMD, FIND, kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
}
}
func _go_grep(m *ice.Message, key string) {
msg := m.Spawn()
msg.Split(m.Cmd(cli.SYSTEM, GREP, "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ice.PT).Append(cli.CMD_OUT), "file:line:text", ":", ice.NL)
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(ice.CMD, GREP, value) })
}
func PlugAction(fields ...string) map[string]*ice.Action {
return ice.SelectAction(map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(PLUG)) }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
}, fields...)
}
const (
_TAGS = ".tags"
FIND = "find"
GREP = "grep"
)
const GO = "go"
const DOC = "godoc"
const MOD = "mod"
const SUM = "sum"
const PROTO = "proto"
const GODOC = "godoc"
func init() {
Index.Register(&ice.Context{Name: GO, Help: "后端",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.ENGINE, mdb.CREATE, GO, m.Prefix(GO))
m.Cmd(mdb.SEARCH, mdb.CREATE, GO, m.Prefix(GO))
m.Cmd(mdb.SEARCH, mdb.CREATE, DOC, m.Prefix(GO))
Index.Register(&ice.Context{Name: GO, Help: "后端", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, GODOC, m.Prefix(GO))
m.Cmd(mdb.SEARCH, mdb.CREATE, GO, m.Prefix(GO))
m.Cmd(mdb.ENGINE, mdb.CREATE, GO, m.Prefix(GO))
for k := range c.Configs {
m.Cmd(mdb.PLUGIN, mdb.CREATE, k, m.Prefix(k))
m.Cmd(mdb.RENDER, mdb.CREATE, k, m.Prefix(k))
for k := range c.Configs {
m.Cmd(mdb.PLUGIN, mdb.CREATE, k, m.Prefix(k))
m.Cmd(mdb.RENDER, mdb.CREATE, k, m.Prefix(k))
}
LoadPlug(m, GO)
}},
GODOC: {Name: GODOC, Help: "文档", Action: ice.MergeAction(map[string]*ice.Action{
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], ice.PT+arg[0])))
}},
}, PlugAction())},
PROTO: {Name: PROTO, Help: "协议", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
SUM: {Name: SUM, Help: "版本", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
MOD: {Name: MOD, Help: "模块", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
GO: {Name: GO, Help: "后端", Action: ice.MergeAction(map[string]*ice.Action{
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
if strings.HasSuffix(arg[1], "test.go") {
m.Cmdy(cli.SYSTEM, GO, "test", "-v", "./"+arg[1])
} else {
m.Cmdy(cli.SYSTEM, GO, "run", "./"+arg[1])
}
LoadPlug(m, GO)
m.Set(ice.MSG_APPEND)
}},
SUM: {Name: SUM, Help: "版本", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(MOD, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
_go_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_help(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
MOD: {Name: MOD, Help: "模块", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(MOD, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
}},
PROTO: {Name: PROTO, Help: "协议", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(PROTO, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
}},
DOC: {Name: DOC, Help: "文档", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], "."+arg[0])))
}},
}},
GO: {Name: GO, Help: "后端", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
if strings.HasSuffix(arg[1], "test.go") {
m.Cmdy(cli.SYSTEM, GO, "test", "-v", "./"+arg[1])
} else {
m.Cmdy(cli.SYSTEM, GO, "run", "./"+arg[1])
}
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_help(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}},
},
Configs: map[string]*ice.Config{
PROTO: {Name: PROTO, Help: "协议", Value: kit.Data(
PLUG, kit.Dict(
PREFIX, kit.Dict(
"//", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"syntax", "option", "package", "import", "service", "message",
),
DATATYPE, kit.Simple(
"string", "int64", "int32",
),
),
KEYWORD, kit.Dict(),
}, PlugAction())},
}, Configs: map[string]*ice.Config{
PROTO: {Name: PROTO, Help: "协议", Value: kit.Data(PLUG, kit.Dict(
PREFIX, kit.Dict("//", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"syntax", "option", "package", "import", "service", "message",
),
)},
MOD: {Name: MOD, Help: "模块", Value: kit.Data(
PLUG, kit.Dict(
PREFIX, kit.Dict(
"//", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"module", "require", "replace", "=>",
),
),
KEYWORD, kit.Dict(),
DATATYPE, kit.Simple(
"string", "int64", "int32",
),
)},
GO: {Name: GO, Help: "后端", Value: kit.Data(
PLUG, kit.Dict(
SPLIT, kit.Dict(
"space", "\t ",
"operator", "{[(&.,:;!|<>)]}",
),
PREFIX, kit.Dict(
"//", COMMENT,
"/*", COMMENT,
"* ", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"package", "import", "type", "struct", "interface", "const", "var", "func",
"if", "else", "for", "range", "break", "continue",
"switch", "case", "default", "fallthrough",
"go", "select", "defer", "return",
),
DATATYPE, kit.Simple(
"int", "int32", "int64", "float64",
"string", "byte", "bool", "error", "chan", "map",
),
FUNCTION, kit.Simple(
"new", "make", "len", "cap", "copy", "append", "delete", "msg", "m",
),
CONSTANT, kit.Simple(
"false", "true", "nil", "-1", "0", "1", "2",
),
),
KEYWORD, kit.Dict(),
), KEYWORD, kit.Dict(),
))},
MOD: {Name: MOD, Help: "模块", Value: kit.Data(PLUG, kit.Dict(
PREFIX, kit.Dict("//", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"module", "require", "replace", "=>",
),
)},
},
}, nil)
), KEYWORD, kit.Dict(),
))},
GO: {Name: GO, Help: "后端", Value: kit.Data(PLUG, kit.Dict(
SPLIT, kit.Dict("space", "\t ", "operator", "{[(&.,:;!|<>)]}"),
PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "* ", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"package", "import", "type", "struct", "interface", "const", "var", "func",
"if", "else", "for", "range", "break", "continue",
"switch", "case", "default", "fallthrough",
"go", "select", "defer", "return",
),
DATATYPE, kit.Simple(
"int", "int32", "int64", "float64",
"string", "byte", "bool", "error", "chan", "map",
),
FUNCTION, kit.Simple(
"new", "make", "len", "cap", "copy", "append", "delete", "msg", "m",
),
CONSTANT, kit.Simple(
"false", "true", "nil", "-1", "0", "1", "2",
),
), KEYWORD, kit.Dict(),
))},
}}, nil)
}

72
core/code/inner.go
View File

@ -9,9 +9,22 @@ import (
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/ssh"
kit "shylinux.com/x/toolkits"
)
func _inner_exec(m *ice.Message, ext, file, dir string, arg ...string) {
if !m.Right(dir, file) {
return // 没有权限
}
if m.Cmdy(mdb.ENGINE, ext, file, dir, arg); m.Result() != "" {
return // 执行成功
}
if ls := kit.Simple(m.Confv(INNER, kit.Keym(EXEC, ext))); len(ls) > 0 {
m.Cmdy(cli.SYSTEM, ls, file, ice.Option{cli.CMD_DIR, dir})
m.Set(ice.MSG_APPEND)
}
}
func _inner_list(m *ice.Message, ext, file, dir string, arg ...string) {
if !m.Right(dir, file) {
return // 没有权限
@ -19,24 +32,10 @@ func _inner_list(m *ice.Message, ext, file, dir string, arg ...string) {
if m.Cmdy(mdb.RENDER, ext, file, dir, arg); m.Result() != "" {
return // 解析成功
}
if m.Conf(INNER, kit.Keys(kit.META_SOURCE, ext)) == ice.TRUE {
if m.Config(ssh.SOURCE, ext) == ice.TRUE {
m.Cmdy(nfs.CAT, path.Join(dir, file))
}
}
func _inner_show(m *ice.Message, ext, file, dir string, arg ...string) {
if !m.Right(dir, file) {
return // 没有权限
}
if m.Cmdy(mdb.ENGINE, ext, file, dir, arg); m.Result() != "" {
return // 执行成功
}
if ls := kit.Simple(m.Confv(INNER, kit.Keym(SHOW, ext))); len(ls) > 0 {
m.Cmdy(cli.SYSTEM, ls, file, ice.Option{cli.CMD_DIR, dir})
m.Set(ice.MSG_APPEND)
}
}
func LoadPlug(m *ice.Message, language string) {
m.Confm(language, kit.Keym(PLUG, PREPARE), func(key string, value interface{}) {
@ -60,51 +59,41 @@ const (
)
const (
PLUG = "plug"
SHOW = "show"
EXEC = "exec"
)
const INNER = "inner"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
INNER: {Name: "inner path=src/ file=main.go line=1 auto", Help: "源代码", Meta: kit.Dict(
ice.Display("/plugin/local/code/inner.js", "editor"),
ice.Display("/plugin/local/code/inner.js"),
), Action: ice.MergeAction(map[string]*ice.Action{
mdb.PLUGIN: {Name: "plugin", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
if m.Cmdy(mdb.PLUGIN, arg); m.Result() == "" {
m.Echo(kit.Select("{}", m.Conf(INNER, kit.Keym(PLUG, arg[0]))))
m.Echo(kit.Select("{}", m.Config(kit.Keys(PLUG, arg[0]))))
}
}},
mdb.ENGINE: {Name: "engine", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
_inner_show(m, arg[0], arg[1], arg[2])
}},
mdb.SEARCH: {Name: "search", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if strings.Contains(arg[1], ";") {
ls := strings.Split(arg[1], ";")
arg[0] = ls[0]
arg[1] = ls[1]
}
m.Option(cli.CMD_DIR, arg[2])
m.Option(nfs.DIR_ROOT, arg[2])
m.Cmdy(mdb.SEARCH, arg[:2], "cmd,file,line,text")
mdb.ENGINE: {Name: "engine", Help: "引擎", Hand: func(m *ice.Message, arg ...string) {
_inner_exec(m, arg[0], arg[1], arg[2])
}},
mdb.INPUTS: {Name: "favor inputs", Help: "补全"},
FAVOR: {Name: "favor", Help: "收藏"},
}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) < 2 {
nfs.Dir(m, kit.MDB_PATH)
return
}
if !strings.HasSuffix(arg[0], ice.PS) {
arg[1] = kit.Slice(strings.Split(arg[0], ice.PS), -1)[0]
arg[0] = strings.TrimSuffix(arg[0], arg[1])
m.ProcessRewrite("path", arg[0], "file", arg[1])
m.ProcessRewrite(nfs.PATH, arg[0], nfs.FILE, arg[1])
return
}
if len(arg) < 2 {
nfs.Dir(m, kit.MDB_PATH)
return
}
_inner_list(m, kit.Ext(arg[1]), arg[1], arg[0])
}},
}, Configs: map[string]*ice.Config{
INNER: {Name: "inner", Help: "源代码", Value: kit.Data(
cli.SOURCE, kit.Dict(
ssh.SOURCE, kit.Dict(
"s", ice.TRUE, "S", ice.TRUE,
"shy", ice.TRUE, "py", ice.TRUE,
"csv", ice.TRUE, "json", ice.TRUE,
@ -115,6 +104,10 @@ func init() {
"md", ice.TRUE, "license", ice.TRUE, "makefile", ice.TRUE, "sql", ice.TRUE,
"ini", ice.TRUE, "conf", ice.TRUE, "toml", ice.TRUE, "yaml", ice.TRUE, "yml", ice.TRUE,
),
EXEC, kit.Dict(
"py", []string{"python"},
"js", []string{"node"},
),
PLUG, kit.Dict(
"s", kit.Dict(
PREFIX, kit.Dict("//", COMMENT),
@ -163,11 +156,6 @@ func init() {
),
),
),
SHOW, kit.Dict(
"py", []string{"python"},
"js", []string{"node"},
),
)},
},
})
}})
}

17
core/code/install.go
View File

@ -18,7 +18,7 @@ import (
func _install_download(m *ice.Message) {
link := m.Option(kit.MDB_LINK)
name := path.Base(link)
file := path.Join(kit.Select(m.Conf(INSTALL, kit.META_PATH), m.Option(kit.MDB_PATH)), name)
file := path.Join(kit.Select(m.Config(kit.MDB_PATH), m.Option(kit.MDB_PATH)), name)
defer m.Cmdy(nfs.DIR, file)
if _, e := os.Stat(file); e == nil {
@ -54,7 +54,7 @@ func _install_download(m *ice.Message) {
})
}
func _install_build(m *ice.Message, arg ...string) {
p := m.Option(cli.CMD_DIR, path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK))))
p := m.Option(cli.CMD_DIR, path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK))))
pp := kit.Path(path.Join(p, "_install"))
// 推流
@ -87,8 +87,8 @@ func _install_build(m *ice.Message, arg ...string) {
m.ProcessHold()
}
func _install_order(m *ice.Message, arg ...string) {
m.Cmd(nfs.PUSH, "etc/path", kit.Path(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(kit.MDB_PATH)+"\n"))
m.Cmdy(nfs.CAT, "etc/path")
m.Cmd(nfs.PUSH, ice.ETC_PATH, kit.Path(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(kit.MDB_PATH)+ice.NL))
m.Cmdy(nfs.CAT, ice.ETC_PATH)
}
func _install_spawn(m *ice.Message, arg ...string) {
if kit.Int(m.Option(tcp.PORT)) >= 10000 {
@ -102,10 +102,10 @@ func _install_spawn(m *ice.Message, arg ...string) {
}
target := path.Join(m.Conf(cli.DAEMON, kit.META_PATH), m.Option(tcp.PORT))
source := path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)))
source := path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)))
m.Cmd(nfs.DIR, path.Join(source, kit.Select("_install", m.Option("install")))).Table(func(index int, value map[string]string, head []string) {
m.Cmd(cli.SYSTEM, "cp", "-r", strings.TrimSuffix(value[kit.MDB_PATH], "/"), target)
m.Cmd(cli.SYSTEM, "cp", "-r", strings.TrimSuffix(value[kit.MDB_PATH], ice.PS), target)
})
m.Echo(target)
}
@ -168,7 +168,7 @@ func init() {
_install_start(m, arg...)
}},
cli.SOURCE: {Name: "source link path", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
m.Option(nfs.DIR_ROOT, path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), "_install"))
m.Option(nfs.DIR_ROOT, path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), "_install"))
m.Cmdy(nfs.DIR, m.Option(kit.MDB_PATH))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -184,8 +184,7 @@ func init() {
m.Cmdy(nfs.CAT, kit.Select("./", arg, 2))
}
}},
},
})
}})
}
func InstallAction(fields ...string) map[string]*ice.Action {

241
core/code/js.go
View File

@ -1,12 +1,9 @@
package code
import (
"path"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
)
@ -18,157 +15,105 @@ const NODE = "node"
const VUE = "vue"
func init() {
Index.Register(&ice.Context{Name: JS, Help: "前端",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, VUE, m.Prefix(VUE))
m.Cmd(cmd, mdb.CREATE, JS, m.Prefix(JS))
Index.Register(&ice.Context{Name: JS, Help: "前端", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, VUE, m.Prefix(JS))
m.Cmd(cmd, mdb.CREATE, JS, m.Prefix(JS))
}
LoadPlug(m, JS)
}},
JS: {Name: JS, Help: "前端", Action: ice.MergeAction(map[string]*ice.Action{
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, NODE, arg[1])
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
LoadPlug(m, JS)
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
JS: {Name: JS, Help: "前端", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(JS, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, NODE, arg[1])
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}, PlugAction())},
NODE: {Name: "node auto download", Help: "前端", Action: map[string]*ice.Action{
web.DOWNLOAD: {Name: "download", Help: "下载", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(INSTALL, m.Config(cli.SOURCE))
}},
NODE: {Name: "node", Help: "前端", Action: map[string]*ice.Action{
web.DOWNLOAD: {Name: "download", Help: "下载", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(INSTALL, m.Conf(NODE, kit.META_SOURCE))
}},
}},
VUE: {Name: "vue", Help: "前端", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(VUE, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, NODE, arg[1])
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}},
},
Configs: map[string]*ice.Config{
VUE: {Name: VUE, Help: "vue", Value: kit.Data(
PLUG, kit.Dict(
SPLIT, kit.Dict(
"space", " \t",
"operator", "{[(&.,;!|<>)]}",
),
PREFIX, kit.Dict(
"//", COMMENT,
"/*", COMMENT,
"*", COMMENT,
),
}},
}, Configs: map[string]*ice.Config{
NODE: {Name: NODE, Help: "前端", Value: kit.Data(
cli.SOURCE, "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz",
)},
JS: {Name: JS, Help: "js", Value: kit.Data(PLUG, kit.Dict(
SPLIT, kit.Dict("space", " \t", "operator", "{[(&.,;!|<>)]}"),
PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "*", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"import",
"from",
"export",
"var",
"new",
"delete",
"typeof",
"const",
"function",
"if",
"else",
"for",
"while",
"break",
"continue",
"switch",
"case",
"default",
"return",
"try",
"throw",
"catch",
"finally",
),
)},
NODE: {Name: NODE, Help: "前端", Value: kit.Data(
kit.SSH_SOURCE, "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz",
)},
JS: {Name: JS, Help: "js", Value: kit.Data(
PLUG, kit.Dict(
SPLIT, kit.Dict(
"space", " \t",
"operator", "{[(&.,;!|<>)]}",
),
PREFIX, kit.Dict(
"//", COMMENT,
"/*", COMMENT,
"*", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"import",
"from",
"export",
FUNCTION, kit.Simple(
"window",
"console",
"document",
"arguments",
"event",
"Date",
"JSON",
"var",
"new",
"delete",
"typeof",
"const",
"function",
"__proto__",
"setTimeout",
"createElement",
"appendChild",
"removeChild",
"parentNode",
"childNodes",
"if",
"else",
"for",
"while",
"break",
"continue",
"switch",
"case",
"default",
"return",
"try",
"throw",
"catch",
"finally",
),
FUNCTION, kit.Simple(
"window",
"console",
"document",
"arguments",
"event",
"Date",
"JSON",
"Volcanos",
"request",
"require",
"__proto__",
"setTimeout",
"createElement",
"appendChild",
"removeChild",
"parentNode",
"childNodes",
"Volcanos",
"request",
"require",
"cb",
"cbs",
"shy",
"can",
"sub",
"msg",
"res",
"pane",
"plugin",
),
CONSTANT, kit.Simple(
"true", "false",
"undefined", "null",
"-1", "0", "1", "2", "10",
),
),
KEYWORD, kit.Dict(),
"cb",
"cbs",
"shy",
"can",
"sub",
"msg",
"res",
"pane",
"plugin",
),
)},
},
}, nil)
CONSTANT, kit.Simple(
"true", "false",
"undefined", "null",
"-1", "0", "1", "2", "10",
),
), KEYWORD, kit.Dict(),
))},
}}, nil)
}

124
core/code/pprof.go
View File

@ -24,80 +24,64 @@ const (
const PPROF = "pprof"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE,
PPROF, []string{GO, "tool", PPROF},
)},
},
Commands: map[string]*ice.Command{
"/pprof/": {Name: "/pprof/", Help: "性能分析", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.R.URL.Path = strings.Replace("/code"+m.R.URL.Path, "code", "debug", 1)
http.DefaultServeMux.ServeHTTP(m.W, m.R)
m.Render(ice.RENDER_VOID)
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,text,file",
PPROF, kit.List(GO, "tool", PPROF),
)},
}, Commands: map[string]*ice.Command{
"/pprof/": {Name: "/pprof/", Help: "性能分析", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.R.URL.Path = strings.Replace("/code"+m.R.URL.Path, "code", "debug", 1)
http.DefaultServeMux.ServeHTTP(m.W, m.R)
m.Render(ice.RENDER_VOID)
}},
PPROF: {Name: "pprof zone id auto create", Help: "性能分析", Action: ice.MergeAction(map[string]*ice.Action{
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case BINNARY:
m.Cmdy(nfs.DIR, "bin/", "path,size,time").RenameAppend(kit.MDB_PATH, BINNARY)
case SERVICE:
m.Cmd(web.SPIDE).Table(func(index int, value map[string]string, head []string) {
m.Push(SERVICE, kit.MergeURL2(value["client.url"], "/debug/pprof/profile"))
})
}
}},
PPROF: {Name: "pprof zone id auto create", Help: "性能分析", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create zone=some binnary service seconds=3", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, arg)
}},
mdb.INSERT: {Name: "insert zone type name text", Help: "插入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, kit.MDB_ZONE, arg[1])
m.Cmdy(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, PPROF, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case BINNARY:
m.Cmd(nfs.DIR, "bin/", "path,size,time").Table(func(index int, value map[string]string, head []string) {
m.Push(BINNARY, value["path"])
m.Push("", value, []string{"size,time"})
})
case SERVICE:
m.Cmd(web.SPIDE).Table(func(index int, value map[string]string, head []string) {
m.Push(SERVICE, kit.MergeURL2(value["client.url"], "/debug/pprof/profile"))
})
}
}},
mdb.CREATE: {Name: "create zone=some binnary service seconds=3", Help: "创建"},
mdb.INSERT: {Name: "insert zone type name text", Help: "插入"},
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, m.Option(SERVICE), SECONDS, m.Option(SECONDS))
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, m.Option(SERVICE), SECONDS, m.Option(SECONDS))
cmd := kit.Simple(m.Confv(PPROF, kit.Keym(PPROF)), "-text", m.Option(BINNARY), msg.Append(kit.MDB_FILE))
res := strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL)
if len(res) > 20 {
res = res[:20]
}
m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE),
kit.MDB_TEXT, strings.Join(res, ice.NL), kit.MDB_FILE, msg.Append(kit.MDB_FILE))
m.Echo(strings.Join(res, ice.NL))
m.ProcessInner()
}},
web.SERVE: {Name: "serve", Help: "展示", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
p := u.Hostname() + ":" + m.Cmdx(tcp.PORT, aaa.RIGHT)
m.Cmd(cli.DAEMON, m.Confv(PPROF, kit.Keym(PPROF)), "-http="+p, m.Option(BINNARY), m.Option(kit.MDB_FILE))
m.Echo("http://%s/ui/top", p)
m.ProcessInner()
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count,binnary,service,seconds", "time,id,text,file")
if m.Cmdy(mdb.SELECT, PPROF, "", mdb.ZONE, arg); len(arg) == 0 {
m.PushAction(ice.RUN, mdb.REMOVE)
return
cmd := kit.Simple(m.Confv(PPROF, kit.Keym(PPROF)), "-text", m.Option(BINNARY), msg.Append(kit.MDB_FILE))
res := strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL)
if len(res) > 20 {
res = res[:20]
}
m.Table(func(index int, value map[string]string, head []string) {
m.PushDownload(kit.MDB_LINK, "pprof.pd.gz", value[kit.MDB_FILE])
m.PushButton(web.SERVE)
})
m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE),
kit.MDB_TEXT, strings.Join(res, ice.NL), kit.MDB_FILE, msg.Append(kit.MDB_FILE))
m.Echo(strings.Join(res, ice.NL))
m.ProcessInner()
}},
},
})
web.SERVE: {Name: "serve", Help: "展示", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
p := u.Hostname() + ":" + m.Cmdx(tcp.PORT, aaa.RIGHT)
m.Cmd(cli.DAEMON, m.Confv(PPROF, kit.Keym(PPROF)), "-http="+p, m.Option(BINNARY), m.Option(kit.MDB_FILE))
m.Echo("http://%s/ui/top", p)
m.ProcessInner()
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count,binnary,service,seconds", m.Config(kit.MDB_FIELD))
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
m.PushAction(ice.RUN, mdb.REMOVE)
return
}
m.Table(func(index int, value map[string]string, head []string) {
m.PushDownload(kit.MDB_LINK, "pprof.pd.gz", value[kit.MDB_FILE])
m.PushButton(web.SERVE)
})
}},
}})
}

207
core/code/publish.go
View File

@ -17,141 +17,113 @@ import (
kit "shylinux.com/x/toolkits"
)
func _publish_file(m *ice.Message, file string, arg ...string) string {
if strings.HasSuffix(file, "ice.bin") {
// 打包应用
arg = append(arg, kit.Keys("ice", runtime.GOOS, runtime.GOARCH))
if _, e := os.Stat(path.Join(m.Conf(PUBLISH, kit.META_PATH), kit.Select(path.Base(file), arg, 0))); e == nil {
return ""
func _bin_list(m *ice.Message, dir string) {
p := m.Option(cli.CMD_DIR, dir)
for _, ls := range strings.Split(strings.TrimSpace(m.Cmd(cli.SYSTEM, "bash", "-c", "ls |xargs file |grep executable").Append(cli.CMD_OUT)), ice.NL) {
if file := strings.TrimSpace(strings.Split(ls, ":")[0]); file != "" {
if s, e := os.Stat(path.Join(p, file)); e == nil {
m.Push(kit.MDB_TIME, s.ModTime())
m.Push(kit.MDB_SIZE, kit.FmtSize(s.Size()))
m.Push(kit.MDB_FILE, file)
m.PushDownload(kit.MDB_LINK, file, path.Join(p, file))
}
}
}
m.SortTimeR(kit.MDB_TIME)
}
func _publish_file(m *ice.Message, file string, arg ...string) string {
if strings.HasSuffix(file, "ice.bin") { // 打包应用
arg = kit.Simple(kit.Keys(ice.ICE, runtime.GOOS, runtime.GOARCH))
} else if s, e := os.Stat(file); m.Assert(e) && s.IsDir() {
// 打包目录
p := path.Base(file) + ".tar.gz"
m.Cmd(cli.SYSTEM, "tar", "-zcf", p, file)
defer func() { os.Remove(p) }()
file = p
file = p // 打包目录
}
// 发布文件
target := path.Join(m.Conf(PUBLISH, kit.META_PATH), kit.Select(path.Base(file), arg, 0))
target := path.Join(m.Config(kit.MDB_PATH), kit.Select(path.Base(file), arg, 0))
m.Log_EXPORT(PUBLISH, target, kit.MDB_FROM, file)
m.Cmd(nfs.LINK, target, file)
return target
}
func _publish_list(m *ice.Message, arg ...string) {
m.Option(nfs.DIR_DEEP, ice.TRUE)
m.Option(nfs.DIR_REG, kit.Select("", arg, 0))
m.Option(nfs.DIR_ROOT, m.Config(kit.MDB_PATH))
m.Cmdy(nfs.DIR, "./", kit.Select("time,size,line,path,link", arg, 1))
}
const PUBLISH = "publish"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.Prefix(PUBLISH))
m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, ice.USR_PUBLISH)
m.Conf(PUBLISH, kit.Keym(ice.CONTEXTS), _contexts)
}},
PUBLISH: {Name: "publish path auto create volcanos icebergs intshell package dream", Help: "发布", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create file", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_publish_file(m, m.Option(kit.MDB_FILE))
}},
ice.VOLCANOS: {Name: "volcanos", Help: "火山架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.EchoQRCode(m.Option(ice.MSG_USERWEB)) }()
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "miss") }()
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.ETC_MISS_SH)
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.GO_MOD)
m.Cmd(nfs.DEFS, path.Join(m.Conf(PUBLISH, kit.META_PATH), ice.ORDER_JS), m.Conf(PUBLISH, kit.Keym(JS)))
m.Cmd(nfs.DEFS, path.Join(ice.USR_VOLCANOS, "page/cache.css"), "")
m.Cmd(nfs.DEFS, path.Join(ice.USR_VOLCANOS, "page/cache.js"), "")
m.Option(nfs.DIR_DEEP, ice.TRUE)
m.Option(nfs.DIR_REG, `.*\.(html|css|js)$`)
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
m.Cmdy(nfs.DIR, "./", "time,size,line,path,link")
}},
ice.ICEBERGS: {Name: "icebergs", Help: "冰山架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "base") }()
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_SH)
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
p := m.Option(cli.CMD_DIR, m.Conf(PUBLISH, kit.META_PATH))
ls := strings.Split(strings.TrimSpace(m.Cmd(cli.SYSTEM, "bash", "-c", "ls |xargs file |grep executable").Append(cli.CMD_OUT)), ice.NL)
for _, ls := range ls {
if file := strings.TrimSpace(strings.Split(ls, ":")[0]); file != "" {
if s, e := os.Stat(path.Join(p, file)); e == nil {
m.Push(kit.MDB_TIME, s.ModTime())
m.Push(kit.MDB_SIZE, kit.FmtSize(s.Size()))
m.Push(kit.MDB_FILE, file)
m.PushDownload(kit.MDB_LINK, file, path.Join(p, file))
}
}
}
m.SortTimeR(kit.MDB_TIME)
}},
ice.INTSHELL: {Name: "intshell", Help: "神农架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "tmux") }()
m.Cmd(nfs.DEFS, path.Join(m.Conf(PUBLISH, kit.META_PATH), ice.ORDER_SH), m.Conf(PUBLISH, kit.Keym(SH)))
m.Option(nfs.DIR_DEEP, ice.TRUE)
m.Option(nfs.DIR_REG, ".*\\.(sh|vim|conf)$")
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
m.Cmdy(nfs.DIR, "./", "time,size,line,path,link")
}},
ice.CONTEXTS: {Name: "contexts", Help: "环境", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(tcp.ReplaceLocalhost(m, m.Option(ice.MSG_USERWEB)))
host := u.Host
m.Option("httphost", fmt.Sprintf("%s://%s:%s", u.Scheme, strings.Split(host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(host, ":"), 1)))
m.Option("hostport", fmt.Sprintf("%s:%s", strings.Split(host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(host, ":"), 1)))
m.Option("hostname", strings.Split(host, ":")[0])
m.Option("userhost", fmt.Sprintf("%s@%s", m.Option(ice.MSG_USERNAME), strings.Split(host, ":")[0]))
m.Option("hostpath", kit.Path("./.ish/pluged"))
if len(arg) == 0 {
arg = append(arg, "tmux", "base", "miss", "binary", "source", "project")
}
for _, k := range arg {
if buf, err := kit.Render(m.Conf(PUBLISH, kit.Keym(ice.CONTEXTS, k)), m); m.Assert(err) {
m.EchoScript(strings.TrimSpace(string(buf)))
}
}
}},
"package": {Name: "package", Help: "依赖", Hand: func(m *ice.Message, arg ...string) {
web.PushStream(m)
p := kit.Path(ice.USR_PUBLISH)
m.Option(cli.CMD_DIR, kit.Path(os.Getenv(cli.HOME)))
// m.Cmdy(cli.SYSTEM, "tar", "-zcvf", "go.tar.gz", "go/pkg")
// m.Cmdy(cli.SYSTEM, "mv", "go.tar.gz", p)
m.Cmdy(cli.SYSTEM, "tar", "-zcvf", "vim.tar.gz", ".vim/plugged")
m.Cmdy(cli.SYSTEM, "mv", "vim.tar.gz", p)
m.Toast("打包成功")
m.ProcessHold()
}},
nfs.TRASH: {Name: "trash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
p := m.Option(cli.CMD_DIR, m.Config(kit.MDB_PATH))
os.Remove(path.Join(p, m.Option(kit.MDB_PATH)))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.DREAM, mdb.INPUTS, arg)
}},
web.DREAM: {Name: "dream name=hi repos", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.DREAM, tcp.START, arg)
m.Process(ice.PROCESS_OPEN, kit.MergeURL(m.Option(ice.MSG_USERWEB),
ice.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
m.Cmdy(nfs.DIR, kit.Select("", arg, 0), "time,size,path,action,link")
}},
}, Configs: map[string]*ice.Config{
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
PUBLISH: {Name: PUBLISH, Help: "发布", Value: kit.Data(
kit.MDB_PATH, "usr/publish", ice.CONTEXTS, _contexts,
kit.MDB_PATH, ice.USR_PUBLISH, ice.CONTEXTS, _contexts,
SH, `#!/bin/bash
echo "hello world"
`,
JS, `Volcanos("onengine", {})
`,
)},
}, Commands: map[string]*ice.Command{
PUBLISH: {Name: "publish path auto create volcanos icebergs intshell", Help: "发布", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.Config(kit.MDB_PATH))
m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.PrefixKey())
m.Config(ice.CONTEXTS, _contexts)
}},
ice.VOLCANOS: {Name: "volcanos", Help: "火山架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.EchoQRCode(m.Option(ice.MSG_USERWEB)) }()
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.CORE) }()
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.ETC_MISS_SH)
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.GO_MOD)
m.Cmd(nfs.DEFS, path.Join(m.Config(kit.MDB_PATH), ice.ORDER_JS), m.Config(JS))
m.Cmd(nfs.DEFS, path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS)), PAGE_CACHE_JS), "")
m.Cmd(nfs.DEFS, path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS)), PAGE_CACHE_CSS), "")
_publish_list(m, `.*\.(html|css|js)$`)
}},
ice.ICEBERGS: {Name: "icebergs", Help: "冰山架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.BASE) }()
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_SH)
_bin_list(m, m.Config(kit.MDB_PATH))
}},
ice.INTSHELL: {Name: "intshell", Help: "神农架", Hand: func(m *ice.Message, arg ...string) {
defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.MISC) }()
m.Cmd(nfs.DEFS, path.Join(m.Config(kit.MDB_PATH), ice.ORDER_SH), m.Config(SH))
_publish_list(m, ".*\\.(sh|vim|conf)$")
}},
ice.CONTEXTS: {Name: "contexts", Help: "环境", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(tcp.ReplaceLocalhost(m, m.Option(ice.MSG_USERWEB)))
m.Option("httphost", fmt.Sprintf("%s://%s:%s", u.Scheme, strings.Split(u.Host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(u.Host, ":"), 1)))
if len(arg) == 0 {
arg = append(arg, "misc", "core", "base", "binary", "source", "project")
}
for _, k := range arg {
if buf, err := kit.Render(m.Config(kit.Keys(ice.CONTEXTS, k)), m); m.Assert(err) {
m.EchoScript(strings.TrimSpace(string(buf)))
}
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.DREAM, mdb.INPUTS, arg)
}},
mdb.CREATE: {Name: "create file", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_publish_file(m, m.Option(kit.MDB_FILE))
}},
nfs.TRASH: {Name: "trash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
p := m.Option(cli.CMD_DIR, m.Config(kit.MDB_PATH))
os.Remove(path.Join(p, m.Option(kit.MDB_PATH)))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Config(kit.MDB_PATH))
m.Cmdy(nfs.DIR, kit.Select("", arg, 0), "time,size,path,action,link")
}},
}})
}
@ -159,23 +131,22 @@ var _contexts = kit.Dict(
"project", `# 创建项目
ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp project
`,
"source", `# 源码安装
"source", `# 下载源码
ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp source
`,
"binary", `# 应用安装
"binary", `# 安装应用
ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp binary
`,
"miss", `# 开发环境
export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
`,
"base", `# 生产环境
export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
`,
"tmux", `# 终端环境
"core", `# 开发环境
export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
`,
"misc", `# 终端环境
export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp
`,
"tool", `# 群组环境
mkdir contexts; cd contexts
export ctx_dev={{.Option "httphost"}} ctx_share={{.Option "share"}} ctx_river={{.Option "sess.river"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
`,
)

161
core/code/sh.go
View File

@ -1,111 +1,88 @@
package code
import (
"path"
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"
)
const SH = "sh"
func init() {
Index.Register(&ice.Context{Name: SH, Help: "命令",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, SH, m.Prefix(SH))
Index.Register(&ice.Context{Name: SH, Help: "命令", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, SH, m.Prefix(SH))
}
LoadPlug(m, SH)
}},
SH: {Name: SH, Help: "命令", Action: ice.MergeAction(map[string]*ice.Action{
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, SH, arg[1])
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
LoadPlug(m, SH)
m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
SH: {Name: SH, Help: "命令", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(SH, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, SH, arg[1])
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
MAN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, arg[0], arg[1]))
}},
MAN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, arg[0], arg[1]))
}},
},
Configs: map[string]*ice.Config{
SH: {Name: SH, Help: "命令", Value: kit.Data(
PLUG, kit.Dict(
SPLIT, kit.Dict(
"space", " ",
"operator", "{[(.,;!|<>)]}",
),
PREFIX, kit.Dict(
"#", COMMENT,
),
SUFFIX, kit.Dict(
"{", COMMENT,
),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"export",
"source",
"require",
}, PlugAction())},
}, Configs: map[string]*ice.Config{
SH: {Name: SH, Help: "命令", Value: kit.Data(PLUG, kit.Dict(
SPLIT, kit.Dict("space", " ", "operator", "{[(.,;!|<>)]}"),
PREFIX, kit.Dict("#", COMMENT),
SUFFIX, kit.Dict("{", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"export",
"source",
"require",
"if",
"then",
"else",
"fi",
"for",
"while",
"do",
"done",
"esac",
"case",
"in",
"return",
"if",
"then",
"else",
"fi",
"for",
"while",
"do",
"done",
"esac",
"case",
"in",
"return",
"shift",
"local",
"echo",
"eval",
"kill",
"let",
"cd",
),
FUNCTION, kit.Simple(
"xargs",
"date",
"find",
"grep",
"sed",
"awk",
"pwd",
"ps",
"ls",
"rm",
"go",
),
),
KEYWORD, kit.Dict(),
"shift",
"local",
"echo",
"eval",
"kill",
"let",
"cd",
),
)},
},
}, nil)
FUNCTION, kit.Simple(
"xargs",
"date",
"find",
"grep",
"sed",
"awk",
"pwd",
"ps",
"ls",
"rm",
"go",
),
), KEYWORD, kit.Dict(),
))},
}}, nil)
}

85
core/code/shy.go
View File

@ -5,62 +5,49 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
const SHY = "shy"
func init() {
Index.Register(&ice.Context{Name: SHY, Help: "脚本",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, SHY, m.Prefix(SHY))
Index.Register(&ice.Context{Name: SHY, Help: "脚本", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
m.Cmd(cmd, mdb.CREATE, SHY, m.Prefix(SHY))
}
LoadPlug(m, SHY)
}},
SHY: {Name: SHY, Help: "脚本", Action: ice.MergeAction(map[string]*ice.Action{
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
LoadPlug(m, SHY)
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
SHY: {Name: SHY, Help: "脚本", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(SHY, kit.Keym(PLUG)))
}},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
}},
}},
},
Configs: map[string]*ice.Config{
SHY: {Name: SHY, Help: "脚本", Value: kit.Data(
PLUG, kit.Dict(
PREFIX, kit.Dict("#", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"title",
"premenu",
"chapter",
"section",
"source",
"refer",
"field",
"spark",
"image",
"label",
"chain",
),
),
KEYWORD, kit.Dict(),
}, PlugAction())},
}, Configs: map[string]*ice.Config{
SHY: {Name: SHY, Help: "脚本", Value: kit.Data(PLUG, kit.Dict(
PREFIX, kit.Dict("#", COMMENT),
PREPARE, kit.Dict(
KEYWORD, kit.Simple(
"title",
"premenu",
"chapter",
"section",
"source",
"refer",
"field",
"spark",
"image",
"label",
"chain",
),
)},
},
}, nil)
), KEYWORD, kit.Dict(),
))},
}}, nil)
}

61
core/code/upgrade.go
View File

@ -13,37 +13,34 @@ import (
const UPGRADE = "upgrade"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
cli.SYSTEM, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.sh", kit.MDB_PATH, ice.BIN_ICE_SH,
kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.bin", kit.MDB_PATH, ice.BIN_ICE_BIN,
)),
cli.SOURCE, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "txt", kit.MDB_FILE, "main.go", kit.MDB_PATH, ice.SRC_MAIN_GO,
kit.MDB_TYPE, "txt", kit.MDB_FILE, "miss.sh", kit.MDB_PATH, ice.ETC_MISS_SH,
kit.MDB_TYPE, "txt", kit.MDB_FILE, "go.mod", kit.MDB_PATH, ice.GO_MOD,
)),
))},
},
Commands: map[string]*ice.Command{
UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
value[kit.MDB_FILE] = kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
m.Option("exit", ice.TRUE)
}
// 下载文件
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, "/publish/"+kit.Format(value[kit.MDB_FILE]))
m.Cmd(web.STORY, web.WATCH, msg.Append(kit.MDB_FILE), value[kit.MDB_PATH])
os.Chmod(kit.Format(value[kit.MDB_PATH]), 0770)
})
if m.Option("exit") == ice.TRUE {
m.Sleep("1s").Go(func() { m.Cmd("exit", 1) })
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
cli.SYSTEM, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.sh", kit.MDB_PATH, ice.BIN_ICE_SH,
kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.bin", kit.MDB_PATH, ice.BIN_ICE_BIN,
)),
cli.SOURCE, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "txt", kit.MDB_FILE, "main.go", kit.MDB_PATH, ice.SRC_MAIN_GO,
kit.MDB_TYPE, "txt", kit.MDB_FILE, "miss.sh", kit.MDB_PATH, ice.ETC_MISS_SH,
kit.MDB_TYPE, "txt", kit.MDB_FILE, "go.mod", kit.MDB_PATH, ice.GO_MOD,
)),
))},
}, Commands: map[string]*ice.Command{
UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
value[kit.MDB_FILE] = kit.Keys(ice.ICE, runtime.GOOS, runtime.GOARCH)
m.Option(ice.EXIT, ice.TRUE)
}
}},
},
})
// 下载文件
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, "/publish/"+kit.Format(value[kit.MDB_FILE]))
m.Cmd(web.STORY, web.WATCH, msg.Append(kit.MDB_FILE), value[kit.MDB_PATH])
os.Chmod(kit.Format(value[kit.MDB_PATH]), 0770)
})
if m.Option(ice.EXIT) == ice.TRUE {
m.Sleep("1s").Go(func() { m.Cmd(ice.EXIT, 1) })
}
}},
}})
}

44
core/code/vimer.go
View File

@ -1,9 +1,7 @@
package code
import (
"os"
"path"
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
@ -17,48 +15,40 @@ const VIMER = "vimer"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
VIMER: {Name: "vimer path=src/ file=main.go line=1 refresh:button=auto save", Help: "编辑器", Meta: kit.Dict(
ice.Display("/plugin/local/code/vimer.js", "inner"),
ice.Display("/plugin/local/code/vimer.js", INNER),
), Action: map[string]*ice.Action{
nfs.SAVE: {Name: "save type file path", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.SAVE, path.Join(m.Option(kit.MDB_PATH), m.Option(kit.MDB_FILE)))
}},
mdb.ENGINE: {Name: "engine", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
if m.Cmdy(mdb.ENGINE, arg); len(m.Resultv()) > 0 || len(m.Appendv(ice.MSG_APPEND)) > 0 {
if m.Cmdy(mdb.ENGINE, arg); len(m.Resultv()) > 0 || m.Length() > 0 {
return
}
if arg = kit.Split(strings.Join(arg, " ")); m.Right(arg) {
if m.Cmdy(arg); len(m.Appendv(ice.MSG_APPEND)) == 0 && len(m.Resultv()) == 0 {
if arg = kit.Split(kit.Join(arg, ice.SP)); m.Right(arg) {
if m.Cmdy(arg); len(m.Resultv()) == 0 && m.Length() == 0 {
m.Cmdy(cli.SYSTEM, arg)
}
}
}},
nfs.SAVE: {Name: "save type file path", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.SAVE, path.Join(m.Option(kit.MDB_PATH), m.Option(kit.MDB_FILE)))
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(AUTOGEN, mdb.INPUTS, arg)
}},
AUTOGEN: {Name: "create main=src/main.go@key key zone type=Zone,Hash,Data name=hi list help", Help: "模块", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(AUTOGEN, mdb.CREATE, arg)
}},
COMPILE: {Name: "compile", Help: "编译", Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_ENV,
cli.HOME, os.Getenv(cli.HOME), cli.PATH, os.Getenv(cli.PATH),
"CGO_ENABLED", "0", "GOCACHE", os.Getenv("GOCACHE"),
"GOPRIVATE", "shylinux.com",
)
_autogen_version(m)
if m.Cmdy(cli.SYSTEM, "go", "build", "-v", "-o", "bin/ice.bin", "src/main.go", "src/version.go"); cli.IsSuccess(m) {
m.Cmd("exit", "1")
}
m.ProcessInner()
}},
BINPACK: {Name: "binpack", Help: "打包", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(AUTOGEN, BINPACK)
p := path.Join("src/release", ice.GO_MOD)
if _, e := os.Stat(p); e == nil {
m.Cmd(nfs.COPY, ice.GO_MOD, p)
}
m.Cmd(nfs.COPY, ice.GO_MOD, path.Join(ice.SRC_RELEASE, ice.GO_MOD))
m.ProcessInner()
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(AUTOGEN, mdb.INPUTS, arg)
COMPILE: {Name: "compile", Help: "编译", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(COMPILE, ice.SRC_MAIN_GO)
m.Cmdy(nfs.LINK, ice.BIN_ICE_BIN, m.Append(nfs.PATH))
if cli.IsSuccess(m) {
m.Cmd(ice.EXIT, "1")
}
m.ProcessInner()
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(INNER, arg)

74
core/code/webpack.go
View File

@ -11,26 +11,36 @@ import (
kit "shylinux.com/x/toolkits"
)
func _volcanos(file ...string) string {
return path.Join(ice.USR_VOLCANOS, path.Join(file...))
func _volcanos(m *ice.Message, file ...string) string {
return path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS, kit.MDB_PATH)), path.Join(file...))
}
func _publish(file ...string) string {
return path.Join(ice.USR_PUBLISH, path.Join(file...))
func _publish(m *ice.Message, file ...string) string {
return path.Join(m.Conf(PUBLISH, kit.Keym(kit.MDB_PATH)), path.Join(file...))
}
const (
PUBLISH_ORDER_JS = "publish/order.js"
PAGE_CACHE_CSS = "page/cache.css"
PAGE_INDEX_CSS = "page/index.css"
PAGE_CACHE_JS = "page/cache.js"
PAGE_INDEX_JS = "page/index.js"
PAGE_CMD_CSS = "page/cmd.css"
PAGE_CMD_JS = "page/cmd.js"
)
const DEVPACK = "devpack"
const WEBPACK = "webpack"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
WEBPACK: {Name: "webpack path auto create prunes", Help: "打包", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create name=demo", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
dir := m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS, kit.MDB_PATH))
css, _, e := kit.Create(path.Join(dir, "page/cache.css"))
mdb.CREATE: {Name: "create name=hi", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
dir := _volcanos(m)
css, _, e := kit.Create(path.Join(dir, PAGE_CACHE_CSS))
m.Assert(e)
defer css.Close()
js, _, e := kit.Create(path.Join(dir, "page/cache.js"))
js, _, e := kit.Create(path.Join(dir, PAGE_CACHE_JS))
m.Assert(e)
defer js.Close()
@ -41,7 +51,7 @@ func init() {
for _, k := range []string{"lib", "panel", "plugin"} {
m.Cmd(nfs.DIR, k).Table(func(index int, value map[string]string, head []string) {
if kit.Ext(value[kit.MDB_PATH]) == CSS {
js.WriteString(`Volcanos.meta.cache["` + path.Join("/", value[kit.MDB_PATH]) + "\"] = []\n")
js.WriteString(`Volcanos.meta.cache["` + path.Join(ice.PS, value[kit.MDB_PATH]) + "\"] = []\n")
css.WriteString(m.Cmdx(nfs.CAT, value[kit.MDB_PATH]))
}
})
@ -50,49 +60,52 @@ func init() {
for _, k := range []string{"lib", "panel", "plugin"} {
m.Cmd(nfs.DIR, k).Table(func(index int, value map[string]string, head []string) {
if kit.Ext(value[kit.MDB_PATH]) == JS {
js.WriteString(`_can_name = "` + path.Join("/", value[kit.MDB_PATH]) + "\";\n")
js.WriteString(`_can_name = "` + path.Join(ice.PS, value[kit.MDB_PATH]) + "\";\n")
js.WriteString(m.Cmdx(nfs.CAT, value[kit.MDB_PATH]))
}
})
}
for _, k := range []string{"publish/order.js", "frame.js"} {
js.WriteString(`_can_name = "` + path.Join("/", k) + "\"\n")
for _, k := range []string{PUBLISH_ORDER_JS, ice.FRAME_JS} {
js.WriteString(`_can_name = "` + path.Join(ice.PS, k) + "\"\n")
js.WriteString(m.Cmdx(nfs.CAT, k))
}
if f, _, e := kit.Create(path.Join(ice.USR_PUBLISH, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS))); m.Assert(e) {
if f, _, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS))); m.Assert(e) {
defer f.Close()
f.WriteString(ice.NL)
f.WriteString(kit.Format(`Volcanos.meta.args = {river: "%s", storm: "%s"}`, m.Option("river"), m.Option("storm")))
f.WriteString(kit.Format(`Volcanos.meta.args = {river: "%s", storm: "%s"}`, m.Option(web.RIVER), m.Option(web.STORM)))
f.WriteString(ice.NL)
f.WriteString(`Volcanos.meta.pack = ` + kit.Formats(kit.UnMarshal(kit.Select("{}", m.Option("content")))))
}
m.Option(nfs.DIR_ROOT, "")
if f, p, e := kit.Create(_publish(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), HTML))); m.Assert(e) {
if f, p, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), HTML))); m.Assert(e) {
defer f.Close()
f.WriteString(fmt.Sprintf(_pack,
m.Cmdx(nfs.CAT, _volcanos("page/cache.css")),
m.Cmdx(nfs.CAT, _volcanos("page/index.css")),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_CACHE_CSS)),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_CSS)),
m.Cmdx(nfs.CAT, _volcanos(ice.PROTO_JS)),
m.Cmdx(nfs.CAT, _publish(path.Join(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS)))),
m.Cmdx(nfs.CAT, _volcanos(m, ice.PROTO_JS)),
m.Cmdx(nfs.CAT, _publish(m, path.Join(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS)))),
m.Cmdx(nfs.CAT, _volcanos("page/cache.js")),
m.Cmdx(nfs.CAT, _volcanos("page/index.js")),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_CACHE_JS)),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_JS)),
))
m.Echo(p)
}
m.Cmd(nfs.COPY, _volcanos("page/cmd.css"), _volcanos("page/index.css"), _volcanos("page/cache.css"))
m.Cmd(nfs.COPY, _volcanos("page/cmd.js"), _volcanos("proto.js"), _volcanos("frame.js"), _volcanos("page/cache.js"))
m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_CSS), _volcanos(m, PAGE_INDEX_CSS), _volcanos(m, PAGE_CACHE_CSS))
m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_JS), _volcanos(m, ice.PROTO_JS), _volcanos(m, PAGE_CACHE_JS))
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(nfs.SAVE, _volcanos("page/cache.js"))
m.Cmd(nfs.SAVE, _volcanos("page/cache.css"))
m.Cmd(nfs.COPY, _volcanos("page/cmd.css"), _volcanos("page/index.css"), _volcanos("page/cache.css"))
m.Cmd(nfs.COPY, _volcanos("page/cmd.js"), _volcanos("proto.js"), _volcanos("page/cache.js"))
m.Cmd(nfs.SAVE, _volcanos(m, PAGE_CACHE_JS))
m.Cmd(nfs.SAVE, _volcanos(m, PAGE_CACHE_CSS))
m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_CSS), _volcanos(m, PAGE_INDEX_CSS), _volcanos(m, PAGE_CACHE_CSS))
m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_JS), _volcanos(m, ice.PROTO_JS), _volcanos(m, PAGE_CACHE_JS))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_DEEP, true)
@ -107,14 +120,7 @@ func init() {
const _pack = `
<!DOCTYPE html>
<head>
<link rel="orange-touch-icon-precomposed" href="/publish/app.png"/>
<link rel="orange-touch-startup-image" href="/publish/splash.png"/>
<meta name="orange-mobile-web-app-capable" content="yes"/>
<meta name="orange-mobile-web-app-status-bar-style" content="black-translucent"/>
<meta name="viewport" content="width=device-width,initial-scale=0.8,user-scalable=no">
<meta charset="utf-8">
<title>volcanos</title>
<style type="text/css">%s</style>
<style type="text/css">%s</style>
</head>

6
data.go
View File

@ -23,6 +23,12 @@ func (m *Message) Config(key string, arg ...interface{}) string {
}
return m.Conf(m.PrefixKey(), kit.Keym(key))
}
func (m *Message) Configv(key string, arg ...interface{}) interface{} {
if len(arg) > 0 {
m.Confv(m.PrefixKey(), kit.Keym(key), arg[0])
}
return m.Confv(m.PrefixKey(), kit.Keym(key))
}
func (m *Message) ConfigSimple(key ...string) (list []string) {
for _, k := range kit.Split(kit.Join(key)) {
list = append(list, k, m.Config(k))

8
render.go
View File

@ -76,7 +76,13 @@ func (m *Message) RenderIndex(serve, repos string, file ...string) *Message {
func (m *Message) RenderCmd(index string, args ...interface{}) {
list := index
if index != "" {
list = kit.Format(kit.List(kit.Dict("index", index, "args", kit.Simple(args))))
msg := m.Cmd("command", index)
list = kit.Format(kit.List(kit.Dict(
kit.MDB_INDEX, index, kit.MDB_ARGS, kit.Simple(args),
msg.AppendSimple(kit.MDB_NAME, kit.MDB_HELP),
"feature", kit.UnMarshal(msg.Append("meta")),
"inputs", kit.UnMarshal(msg.Append("list")),
)))
}
m.RenderResult(kit.Format(`<!DOCTYPE html>
<head>