x/icebergs
1
0
Fork 1
mirror of https://shylinux.com/x/icebergs synced 2025-04-27 01:48:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

opt code

Browse Source
This commit is contained in:
shaoying 2020-10-21 08:54:43 +08:00
parent d4bb2126b0
commit b8bc1e211b
18 changed files with 509 additions and 738 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
base/nfs/nfs.go
View File

@ -149,11 +149,6 @@ func _file_list(m *ice.Message, root string, name string, level int, deep bool,
} }
} }
func _file_show(m *ice.Message, name string) { func _file_show(m *ice.Message, name string) {
if strings.HasPrefix(name, "http") {
m.Cmdy("web.spide", "dev", "raw", "GET", name)
return // 远程文件
}
if f, e := os.Open(path.Join(m.Option(DIR_ROOT), name)); e == nil { if f, e := os.Open(path.Join(m.Option(DIR_ROOT), name)); e == nil {
defer f.Close() defer f.Close()
@ -176,6 +171,12 @@ func _file_show(m *ice.Message, name string) {
return return
} }
if b, ok := ice.BinPack["/"+name]; ok {
m.Info("binpack %v %v", len(b), name)
m.Echo(string(b))
return // 打包文件
}
// 远程文件 // 远程文件
switch cb := m.Optionv(CAT_CB).(type) { switch cb := m.Optionv(CAT_CB).(type) {
case func(string, int): case func(string, int):

12
base/ssh/scripts.go
View File

@ -49,25 +49,27 @@ func Render(msg *ice.Message, cmd string, args ...interface{}) {
} }
} }
func Script(m *ice.Message, name string) io.Reader { func Script(m *ice.Message, name string) io.Reader {
if b, ok := ice.BinPack[name]; ok {
m.Debug("binpack %v %v", len(b), name)
return bytes.NewReader(b)
}
if strings.Contains(m.Option("_script"), "/") { if strings.Contains(m.Option("_script"), "/") {
name = path.Join(path.Dir(m.Option("_script")), name) name = path.Join(path.Dir(m.Option("_script")), name)
} }
m.Option("_script", name) m.Option("_script", name)
m.Debug("name %v", name)
if s, e := os.Open(path.Join(m.Option(nfs.DIR_ROOT), name)); e == nil { if s, e := os.Open(path.Join(m.Option(nfs.DIR_ROOT), name)); e == nil {
return s return s
} }
switch strings.Split(name, "/")[0] { switch strings.Split(name, "/")[0] {
case "etc", "var": case "etc", "var":
m.Warn(true, ice.ErrNotFound) m.Warn(true, ice.ErrNotFound)
return nil return nil
} }
if b, ok := ice.BinPack["/"+name]; ok {
m.Info("binpack %v %v", len(b), name)
return bytes.NewReader(b)
}
if msg := m.Cmd("web.spide", "dev", "GET", path.Join("/share/local/", name)); msg.Result(0) != ice.ErrWarn { if msg := m.Cmd("web.spide", "dev", "GET", path.Join("/share/local/", name)); msg.Result(0) != ice.ErrWarn {
bio := bytes.NewBuffer([]byte(msg.Result())) bio := bytes.NewBuffer([]byte(msg.Result()))
return bio return bio

44
core/chat/header.go
View File

@ -3,11 +3,8 @@ package chat
import ( import (
ice "github.com/shylinux/icebergs" ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa" "github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/nfs"
"github.com/shylinux/icebergs/base/web" "github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits" kit "github.com/shylinux/toolkits"
"fmt"
) )
const ( const (
@ -40,27 +37,7 @@ func init() {
}}, }},
"pack": {Name: "pack", Help: "打包", Hand: func(m *ice.Message, arg ...string) { "pack": {Name: "pack", Help: "打包", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("web.code.webpack", "pack") m.Cmdy("web.code.webpack", "create")
if f, _, e := kit.Create("usr/publish/webpack/" + m.Option("name") + ".js"); m.Assert(e) {
defer f.Close()
f.WriteString(`Volcanos.meta.pack = ` + kit.Formats(kit.UnMarshal(m.Option("content"))))
}
m.Option(nfs.DIR_ROOT, "")
if f, p, e := kit.Create("usr/publish/webpack/" + m.Option("name") + ".html"); m.Assert(e) {
f.WriteString(fmt.Sprintf(_pack,
m.Cmdx(nfs.CAT, "usr/volcanos/cache.css"),
m.Cmdx(nfs.CAT, "usr/volcanos/index.css"),
m.Cmdx(nfs.CAT, "usr/volcanos/proto.js"),
m.Cmdx(nfs.CAT, "usr/volcanos/cache.js"),
m.Cmdx(nfs.CAT, "usr/publish/webpack/"+m.Option("name")+".js"),
m.Cmdx(nfs.CAT, "usr/volcanos/index.js"),
))
m.Echo(p)
}
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Echo(m.Conf(HEADER, TITLE)) m.Echo(m.Conf(HEADER, TITLE))
@ -68,22 +45,3 @@ func init() {
}, },
}, nil) }, nil)
} }
const _pack = `
<!DOCTYPE html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=0.7,user-scalable=no">
<title>volcanos</title>
<link rel="shortcut icon" type="image/ico" href="favicon.ico">
<style type="text/css">%s</style>
<style type="text/css">%s</style>
</head>
<body>
<script>%s</script>
<script>%s</script>
<script>%s</script>
<script>%s</script>
<script>Volcanos.meta.webpack = true</script>
</body>
`

59
core/code/_trash.go
View File

@ -1,59 +0,0 @@
package code
func _pprof_show(m *ice.Message, zone string, id string) {
favor := m.Conf(PPROF, kit.Keys(kit.MDB_META, web.FAVOR))
m.Richs(PPROF, nil, zone, func(key string, val map[string]interface{}) {
val = val[kit.MDB_META].(map[string]interface{})
list := []string{}
task.Put(val, func(task *task.Task) error {
m.Sleep("1s")
m.Grows(PPROF, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
// 压测命令
m.Log_EXPORT(kit.MDB_META, PPROF, kit.MDB_ZONE, zone, kit.MDB_VALUE, kit.Format(value))
cmd := kit.Format(value[kit.MDB_TYPE])
arg := kit.Format(value[kit.MDB_TEXT])
res := m.Cmd(mdb.ENGINE, value[kit.MDB_TYPE], value[kit.MDB_NAME], value[kit.MDB_TEXT], value[kit.MDB_EXTRA]).Result()
m.Cmd(web.FAVOR, favor, cmd, arg, res)
list = append(list, cmd+": "+arg, res)
})
return nil
})
// 收藏程序
msg := m.Cmd(web.CACHE, web.CATCH, kit.MIME_FILE, kit.Format(val[BINNARY]))
bin := msg.Append(kit.MDB_TEXT)
m.Cmd(web.FAVOR, favor, kit.MIME_FILE, bin, val[BINNARY])
// 性能分析
msg = m.Cmd(web.SPIDE, "self", web.CACHE, http.MethodGet, kit.Select("/code/pprof/profile", val[SERVICE]), "seconds", kit.Select("5", kit.Format(val[SECONDS])))
m.Cmd(web.FAVOR, favor, PPROF, msg.Append(kit.MDB_TEXT), kit.Keys(zone, "pd.gz"))
// 结果摘要
cmd := kit.Simple(m.Confv(PPROF, "meta.pprof"), "-text", val[BINNARY], msg.Append(kit.MDB_TEXT))
res := strings.Split(m.Cmdx(cli.SYSTEM, cmd), "\n")
if len(res) > 20 {
res = res[:20]
}
m.Cmd(web.FAVOR, favor, web.TYPE_SHELL, strings.Join(cmd, " "), strings.Join(res, "\n"))
list = append(list, web.TYPE_SHELL+": "+strings.Join(cmd, " "), strings.Join(res, "\n"))
// 结果展示
u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
p := kit.Format("%s:%s", u.Hostname(), m.Cmdx(tcp.PORT, aaa.Right))
m.Option(cli.CMD_STDOUT, "var/daemon/stdout")
m.Option(cli.CMD_STDERR, "var/daemon/stderr")
m.Cmd(cli.DAEMON, m.Confv(PPROF, "meta.pprof"), "-http="+p, val[BINNARY], msg.Append(kit.MDB_TEXT))
url := u.Scheme + "://" + p + "/ui/top"
m.Cmd(web.FAVOR, favor, web.SPIDE, url, msg.Append(kit.MDB_TEXT))
m.Set(ice.MSG_RESULT).Echo(url).Echo(" \n").Echo("\n")
m.Echo(strings.Join(list, "\n")).Echo("\n")
m.Push("url", url)
m.Push(PPROF, msg.Append(kit.MDB_TEXT))
m.Push(SERVICE, strings.Replace(kit.Format(val[SERVICE]), "profile", "", -1))
m.Push("bin", bin)
})
}

30
core/code/autogen.go
View File

@ -10,19 +10,15 @@ import (
"strings" "strings"
) )
func _autogen_script(m *ice.Message, p string) { func _autogen_script(m *ice.Message, dir string) {
// if b, e := kit.Render(m.Conf(AUTOGEN, "meta.shy"), m); m.Assert(e) { if b, e := kit.Render(m.Conf(AUTOGEN, "meta.shy"), m); m.Assert(e) {
if b, e := kit.Render(` m.Cmd(nfs.SAVE, dir, string(b))
chapter {{.Option "name"}}
field {{.Option "name"}} web.code.{{.Option "name"}}.{{.Option "name"}}
`, m); m.Assert(e) {
m.Cmd(nfs.SAVE, p, string(b))
} }
} }
func _autogen_source(m *ice.Message, name string) { func _autogen_source(m *ice.Message, name string) {
m.Cmd("nfs.file", "append", "src/main.shy", "\n", `source `+name+"/"+name+".shy", "\n") m.Cmd("nfs.file", "append", "src/main.shy", "\n", `source `+name+"/"+name+".shy", "\n")
} }
func _autogen_index(m *ice.Message, p string, from string, ctx string) { func _autogen_index(m *ice.Message, dir string, from string, ctx string) {
list := []string{} list := []string{}
up, low := "", "" up, low := "", ""
@ -43,16 +39,17 @@ func _autogen_index(m *ice.Message, p string, from string, ctx string) {
list = append(list, line) list = append(list, line)
}) })
m.Cmd(nfs.CAT, from) m.Cmd(nfs.CAT, from)
m.Cmdy(nfs.SAVE, p, strings.Join(list, "\n"))
m.Cmdy(nfs.SAVE, dir, strings.Join(list, "\n"))
} }
func _autogen_main(m *ice.Message, file string, mod string, ctx string) { func _autogen_main(m *ice.Message, file string, mod string, ctx string) {
list := []string{} list := []string{}
m.Option(nfs.CAT_CB, func(line string, index int) { m.Option(nfs.CAT_CB, func(line string, index int) {
list = append(list, line) list = append(list, line)
if strings.HasPrefix(line, "import (") { if strings.HasPrefix(line, "import (") {
list = append(list, ` _ "`+mod+"/src/"+ctx+`"`, "") list = append(list, kit.Format(` _ "%s/src/%s"`, mod, ctx), "")
} }
}) })
m.Cmd(nfs.CAT, file) m.Cmd(nfs.CAT, file)
@ -76,7 +73,10 @@ func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
AUTOGEN: {Name: AUTOGEN, Help: "生成", Value: kit.Data( AUTOGEN: {Name: AUTOGEN, Help: "生成", Value: kit.Data(
kit.MDB_FIELD, "time,id,name,from", kit.MDB_FIELD, "time,id,name,from", "shy", `
chapter "{{.Option "name"}}"
field "{{.Option "name"}}" web.code.{{.Option "name"}}.{{.Option "name"}}
`,
)}, )},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
@ -95,13 +95,11 @@ func init() {
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) { mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] { switch arg[0] {
case "main": case "main":
m.Cmdy(nfs.DIR, "src") m.Cmdy(nfs.DIR, "src", "path,size,time")
m.Appendv(ice.MSG_APPEND, "path", "size", "time")
m.Sort(kit.MDB_PATH) m.Sort(kit.MDB_PATH)
case "from": case "from":
m.Option(nfs.DIR_DEEP, true) m.Option(nfs.DIR_DEEP, true)
m.Cmdy(nfs.DIR, "usr/icebergs") m.Cmdy(nfs.DIR, "usr/icebergs", "path,size,time")
m.Appendv(ice.MSG_APPEND, "path", "size", "time")
m.Sort(kit.MDB_PATH) m.Sort(kit.MDB_PATH)
} }
}}, }},

10
core/code/bench.go
View File

@ -15,7 +15,7 @@ import (
"sync/atomic" "sync/atomic"
) )
func _bench_http(m *ice.Message, kind, name, target string, arg ...string) { func _bench_http(m *ice.Message, name, target string, arg ...string) {
nconn := kit.Int64(kit.Select("10", m.Option(NCONN))) nconn := kit.Int64(kit.Select("10", m.Option(NCONN)))
nreqs := kit.Int64(kit.Select("1000", m.Option(NREQS))) nreqs := kit.Int64(kit.Select("1000", m.Option(NREQS)))
m.Echo("nconn: %d nreqs: %d\n", nconn, nreqs*nconn) m.Echo("nconn: %d nreqs: %d\n", nconn, nreqs*nconn)
@ -49,6 +49,8 @@ func _bench_http(m *ice.Message, kind, name, target string, arg ...string) {
m.Echo("body: %d\n", body) m.Echo("body: %d\n", body)
m.Option(ice.MSG_PROCESS, "_inner") m.Option(ice.MSG_PROCESS, "_inner")
} }
func _bench_redis(m *ice.Message, name, target string, arg ...string) {
}
const ( const (
NCONN = "nconn" NCONN = "nconn"
@ -63,7 +65,7 @@ func init() {
BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)}, BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
BENCH: {Name: "bench zone=auto id=auto auto insert", Help: "性能压测", Action: map[string]*ice.Action{ 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) { mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, arg) m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, arg)
}}, }},
@ -81,7 +83,9 @@ func init() {
cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) { cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_TYPE) { switch m.Option(kit.MDB_TYPE) {
case "http": case "http":
_bench_http(m, m.Option(kit.MDB_TYPE), m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT)) _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) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

253
core/code/c.go
View File

@ -7,57 +7,16 @@ import (
"github.com/shylinux/icebergs/base/nfs" "github.com/shylinux/icebergs/base/nfs"
kit "github.com/shylinux/toolkits" kit "github.com/shylinux/toolkits"
"bufio"
"os" "os"
"path" "path"
"strings" "strings"
) )
func _c_find(m *ice.Message, key string) {
for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, FIND, ".", "-name", key), "\n") {
if p == "" {
continue
}
m.Push(kit.MDB_FILE, strings.TrimPrefix(p, "./"))
m.Push(kit.MDB_LINE, 1)
m.Push(kit.MDB_TEXT, "")
}
}
func _c_grep(m *ice.Message, key string) {
m.Split(m.Cmd(cli.SYSTEM, GREP, "--exclude-dir=.git", "--exclude-dir=pluged", "--exclude=.[a-z]*",
"-rn", "\\<"+key+"\\>", ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
}
func _c_tags(m *ice.Message, key string) { func _c_tags(m *ice.Message, key string) {
if _, e := os.Stat(path.Join(m.Option("_path"), m.Conf(C, "meta.tags"))); e != nil { if _, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), ".tags")); e != nil {
// 创建索引 m.Cmd(cli.SYSTEM, "ctags", "-R", "-f", ".tags", "./")
m.Cmd(cli.SYSTEM, CTAGS, "-R", "-f", m.Conf(C, "meta.tags"), "./")
} }
_go_tags(m, key)
for _, l := range strings.Split(m.Cmdx(cli.SYSTEM, GREP, "^"+key+"\\>", m.Conf(C, "meta.tags")), "\n") {
ls := strings.SplitN(l, "\t", 2)
if len(ls) < 2 {
continue
}
ls = strings.SplitN(ls[1], "\t", 2)
file := ls[0]
ls = strings.SplitN(ls[1], ";\"", 2)
text := strings.TrimSuffix(strings.TrimPrefix(ls[0], "/^"), "$/")
line := kit.Int(text)
p := path.Join(m.Option("_path"), file)
f, e := os.Open(p)
m.Assert(e)
bio := bufio.NewScanner(f)
for i := 1; bio.Scan(); i++ {
if i == line || bio.Text() == text {
m.Push(kit.MDB_FILE, strings.TrimPrefix(file, "./"))
m.Push(kit.MDB_LINE, i)
m.Push(kit.MDB_TEXT, bio.Text())
}
}
}
m.Sort(kit.MDB_LINE, "int")
} }
func _c_help(m *ice.Message, section, key string) string { func _c_help(m *ice.Message, section, key string) string {
p := m.Cmd(cli.SYSTEM, MAN, section, key).Append(cli.CMD_OUT) p := m.Cmd(cli.SYSTEM, MAN, section, key).Append(cli.CMD_OUT)
@ -78,150 +37,160 @@ func _c_help(m *ice.Message, section, key string) string {
return string(res) return string(res)
} }
const CC = "cc"
const C = "c"
const H = "h" const H = "h"
const C = "c"
const CC = "cc"
const MAN1 = "man1" const MAN1 = "man1"
const MAN2 = "man2" const MAN2 = "man2"
const MAN3 = "man3" const MAN3 = "man3"
const MAN8 = "man8" const MAN8 = "man8"
const ( const (
FIND = "find" FIND = "find"
GREP = "grep" GREP = "grep"
CTAGS = "ctags" MAN = "man"
MAN = "man"
) )
func init() { func init() {
Index.Register(&ice.Context{Name: C, Help: "c", Index.Register(&ice.Context{Name: C, Help: "系统",
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, CC, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, CC, m.Prefix(C))
m.Cmd(mdb.PLUGIN, mdb.CREATE, CC, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, CC, m.Prefix(C))
m.Cmd(mdb.RENDER, mdb.CREATE, CC, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.SEARCH, mdb.CREATE, CC, m.Prefix(C))
m.Cmd(mdb.SEARCH, mdb.CREATE, C, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, C, m.Prefix(C))
m.Cmd(mdb.PLUGIN, mdb.CREATE, C, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, C, m.Prefix(C))
m.Cmd(mdb.RENDER, mdb.CREATE, C, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.SEARCH, mdb.CREATE, C, m.Prefix(C))
m.Cmd(mdb.SEARCH, mdb.CREATE, H, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, H, m.Prefix(C))
m.Cmd(mdb.PLUGIN, mdb.CREATE, H, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, H, m.Prefix(C))
m.Cmd(mdb.RENDER, mdb.CREATE, H, C, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.SEARCH, mdb.CREATE, H, m.Prefix(C))
for _, k := range []string{MAN1, MAN2, MAN3, MAN8} { for _, k := range []string{MAN1, MAN2, MAN3, MAN8} {
m.Cmd(mdb.SEARCH, mdb.CREATE, k, MAN, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, k, m.Prefix(MAN))
m.Cmd(mdb.PLUGIN, mdb.CREATE, k, MAN, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, k, m.Prefix(MAN))
m.Cmd(mdb.RENDER, mdb.CREATE, k, MAN, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.SEARCH, mdb.CREATE, k, m.Prefix(MAN))
} }
}}, }},
C: {Name: C, Help: "c", Action: map[string]*ice.Action{ C: {Name: C, Help: "系统", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, m.Option("_path"))
_c_find(m, kit.Select("main", arg, 1))
m.Cmdy(mdb.SEARCH, "man2", arg[1:])
_c_tags(m, kit.Select("main", arg, 1))
_c_grep(m, kit.Select("main", arg, 1))
}},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(C, "meta.plug")) m.Echo(m.Conf(C, "meta.plug"))
}}, }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) 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
}
m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
_go_find(m, kit.Select("main", arg, 1))
m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
_c_tags(m, kit.Select("main", arg, 1))
_go_grep(m, kit.Select("main", arg, 1))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}}, }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
MAN: {Name: MAN, Help: "man", Action: map[string]*ice.Action{ MAN: {Name: MAN, Help: "手册", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(MAN, "meta.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 { if arg[0] == kit.MDB_FOREACH {
return return
} }
for _, k := range []string{"1", "2", "3", "8"} { for _, k := range []string{"1", "2", "3", "8"} {
if text := _c_help(m, k, kit.Select("main", arg, 1)); text != "" { if text := _c_help(m, k, kit.Select("main", arg, 1)); text != "" {
m.Push(kit.MDB_FILE, arg[1]+".man"+k) for _, k := range kit.Split(m.Option(mdb.FIELDS)) {
m.Push(kit.MDB_LINE, "1") switch k {
m.Push(kit.MDB_TEXT, text) case kit.MDB_FILE:
m.Push(k, arg[1]+".man"+k)
case kit.MDB_LINE:
m.Push(k, 1)
case kit.MDB_TEXT:
m.Push(k, text)
default:
m.Push(k, "")
}
}
} }
} }
}}, }},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { }},
m.Echo(m.Conf(C, "meta.man.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])))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
C: {Name: C, Help: "c", Value: kit.Data( MAN: {Name: MAN, Help: "手册", Value: kit.Data(
"tags", ".tags", "plug", kit.Dict(
"man.plug", kit.Dict( PREFIX, kit.Dict(
"prefix", kit.Dict( "NAME", COMMENT,
"NAME", "comment", "LIBRARY", COMMENT,
"LIBRARY", "comment", "SYNOPSIS", COMMENT,
"SYNOPSIS", "comment", "DESCRIPTION", COMMENT,
"DESCRIPTION", "comment", "STANDARDS", COMMENT,
"STANDARDS", "comment", "SEE ALSO", COMMENT,
"SEE ALSO", "comment", "HISTORY", COMMENT,
"HISTORY", "comment", "BUGS", COMMENT,
"BUGS", "comment",
), ),
), ),
)},
C: {Name: C, Help: "系统", Value: kit.Data(
"plug", kit.Dict( "plug", kit.Dict(
"split", kit.Dict( SPLIT, kit.Dict(
"space", " ", "space", " ",
"operator", "{[(.,;!|<>)]}", "operator", "{[(.,:;!|<>)]}",
), ),
"prefix", kit.Dict( PREFIX, kit.Dict(
"//", "comment", "//", COMMENT,
"/*", "comment", "/*", COMMENT,
"*", "comment", "*", COMMENT,
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"#include", "keyword", "#include", KEYWORD,
"#define", "keyword", "#define", KEYWORD,
"#ifndef", "keyword", "#ifndef", KEYWORD,
"#ifdef", "keyword", "#ifdef", KEYWORD,
"#else", "keyword", "#else", KEYWORD,
"#endif", "keyword", "#endif", KEYWORD,
"if", "keyword", "if", KEYWORD,
"else", "keyword", "else", KEYWORD,
"for", "keyword", "for", KEYWORD,
"while", "keyword", "while", KEYWORD,
"do", "keyword", "do", KEYWORD,
"break", "keyword", "break", KEYWORD,
"continue", "keyword", "continue", KEYWORD,
"switch", "keyword", "switch", KEYWORD,
"case", "keyword", "case", KEYWORD,
"default", "keyword", "default", KEYWORD,
"return", "keyword", "return", KEYWORD,
"typedef", "keyword", "typedef", KEYWORD,
"extern", "keyword", "extern", KEYWORD,
"static", "keyword", "static", KEYWORD,
"const", "keyword", "const", KEYWORD,
"sizeof", "keyword", "sizeof", KEYWORD,
"union", "datatype", "union", DATATYPE,
"struct", "datatype", "struct", DATATYPE,
"unsigned", "datatype", "unsigned", DATATYPE,
"double", "datatype", "double", DATATYPE,
"void", "datatype", "void", DATATYPE,
"long", "datatype", "long", DATATYPE,
"char", "datatype", "char", DATATYPE,
"int", "datatype", "int", DATATYPE,
"assert", "function", "assert", FUNCTION,
"zmalloc", "function", "zmalloc", FUNCTION,
"NULL", "string", "NULL", STRING,
"-1", "string", "-1", STRING,
"0", "string", "0", STRING,
"1", "string", "1", STRING,
"2", "string", "2", STRING,
), ),
), ),
)}, )},

2
core/code/code.go
View File

@ -21,7 +21,7 @@ var Index = &ice.Context{Name: CODE, Help: "编程中心",
func init() { func init() {
web.Index.Register(Index, &web.Frame{}, web.Index.Register(Index, &web.Frame{},
INSTALL, AUTOGEN, COMPILE, PUBLISH, UPGRADE, INSTALL, AUTOGEN, COMPILE, PUBLISH, UPGRADE,
INNER, VIMER, FAVOR, BENCH, PPROF, VIMER, INNER, FAVOR, BENCH, PPROF,
C, SH, SHY, GO, JS, C, SH, SHY, GO, JS,
) )
} }

13
core/code/code.shy
View File

@ -6,6 +6,9 @@ chapter "code"
# field "发布" web.code.publish # field "发布" web.code.publish
# field "升级" web.code.upgrade # field "升级" web.code.upgrade
field "打包" web.code.binpack
field "打包" web.code.webpack
field "编辑" web.code.vimer field "编辑" web.code.vimer
field "查看" web.code.inner field "查看" web.code.inner
field "收藏" web.code.favor field "收藏" web.code.favor
@ -13,8 +16,8 @@ field "测试" web.code.bench
field "优化" web.code.pprof field "优化" web.code.pprof
return return
field "查看" web.code.c field "系统" web.code.c
field "编辑" web.code.sh field "命令" web.code.sh
field "测试" web.code.shy field "脚本" web.code.shy
field "收藏" web.code.go field "后端" web.code.go
field "优化" web.code.js field "前端" web.code.js

9
core/code/compile.go
View File

@ -29,14 +29,12 @@ func init() {
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
COMPILE: {Name: "compile os=linux,darwin,windows arch=amd64,386,arm src=src/main.go@key 执行:button", Help: "编译", Action: map[string]*ice.Action{ COMPILE: {Name: "compile os=linux,darwin,windows arch=amd64,386,arm src=src/main.go@key 执行:button", Help: "编译", Action: map[string]*ice.Action{
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) { mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.DIR, "src") m.Cmdy(nfs.DIR, "src", "path,size,time")
m.Appendv(ice.MSG_APPEND, "path", "size", "time")
m.Sort(kit.MDB_PATH) m.Sort(kit.MDB_PATH)
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { if len(arg) == 0 {
// 目录列表 m.Cmdy(nfs.DIR, m.Conf(COMPILE, kit.META_PATH), "time,size,path")
m.Cmdy(nfs.DIR, m.Conf(COMPILE, kit.META_PATH), "time size path")
return return
} }
@ -55,7 +53,8 @@ func init() {
} }
// 编译目标 // 编译目标
file := path.Join(m.Conf(cmd, kit.META_PATH), kit.Keys(kit.Select("ice", path.Base(strings.TrimSuffix(main, ".go")), main != "src/main.go"), goos, arch))
file := path.Join(kit.Select("", m.Conf(cmd, kit.META_PATH), m.Option(cli.CMD_DIR) == ""), kit.Keys(kit.Select("ice", path.Base(strings.TrimSuffix(main, ".go")), main != "src/main.go"), goos, arch))
args := []string{"-ldflags"} args := []string{"-ldflags"}
list := []string{ list := []string{
fmt.Sprintf(`-X main.Time="%s"`, m.Time()), fmt.Sprintf(`-X main.Time="%s"`, m.Time()),

138
core/code/go.go
View File

@ -27,6 +27,8 @@ func _go_find(m *ice.Message, key string) {
m.Push(k, 1) m.Push(k, 1)
case kit.MDB_TEXT: case kit.MDB_TEXT:
m.Push(k, "") m.Push(k, "")
default:
m.Push(k, "")
} }
} }
} }
@ -67,6 +69,8 @@ func _go_tags(m *ice.Message, key string) {
m.Push(k, i) m.Push(k, i)
case kit.MDB_TEXT: case kit.MDB_TEXT:
m.Push(k, bio.Text()) m.Push(k, bio.Text())
default:
m.Push(k, "")
} }
} }
} }
@ -101,6 +105,8 @@ func _go_help(m *ice.Message, key string) {
m.Push(k, 1) m.Push(k, 1)
case kit.MDB_TEXT: case kit.MDB_TEXT:
m.Push(k, string(res)) m.Push(k, string(res))
default:
m.Push(k, "")
} }
} }
} }
@ -111,7 +117,7 @@ const MOD = "mod"
const SUM = "sum" const SUM = "sum"
func init() { func init() {
Index.Register(&ice.Context{Name: GO, Help: "go", Index.Register(&ice.Context{Name: GO, Help: "后端",
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.PLUGIN, mdb.CREATE, GO, m.Prefix(GO)) m.Cmd(mdb.PLUGIN, mdb.CREATE, GO, m.Prefix(GO))
@ -130,23 +136,23 @@ func init() {
m.Cmd(mdb.RENDER, mdb.CREATE, SUM, m.Prefix(SUM)) m.Cmd(mdb.RENDER, mdb.CREATE, SUM, m.Prefix(SUM))
}}, }},
SUM: {Name: SUM, Help: "sum", Action: map[string]*ice.Action{ SUM: {Name: SUM, Help: "版本", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, "meta.mod.plug")) m.Echo(m.Conf(MOD, "meta.plug"))
}}, }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}}, }},
}}, }},
MOD: {Name: MOD, Help: "mod", Action: map[string]*ice.Action{ MOD: {Name: MOD, Help: "模块", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, "meta.mod.plug")) m.Echo(m.Conf(MOD, "meta.plug"))
}}, }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}}, }},
}}, }},
DOC: {Name: DOC, Help: "doc", Action: map[string]*ice.Action{ DOC: {Name: DOC, Help: "文档", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, "meta.plug")) m.Echo(m.Conf(GO, "meta.plug"))
}}, }},
@ -155,7 +161,7 @@ func init() {
m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], "."+arg[0]))) m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], "."+arg[0])))
}}, }},
}}, }},
GO: {Name: GO, Help: "go", Action: map[string]*ice.Action{ GO: {Name: GO, Help: "后端", Action: map[string]*ice.Action{
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(GO, "meta.plug")) m.Echo(m.Conf(GO, "meta.plug"))
}}, }},
@ -177,83 +183,85 @@ func init() {
} }
m.Option(cli.CMD_DIR, kit.Select("src", arg, 2)) m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
_go_find(m, kit.Select("main", arg, 1)) _go_find(m, kit.Select("main", arg, 1))
_go_tags(m, kit.Select("main", arg, 1))
_go_help(m, kit.Select("main", arg, 1)) _go_help(m, kit.Select("main", arg, 1))
_go_tags(m, kit.Select("main", arg, 1))
_go_grep(m, kit.Select("main", arg, 1)) _go_grep(m, kit.Select("main", arg, 1))
}}, }},
}}, }},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
GO: {Name: GO, Help: "go", Value: kit.Data( MOD: {Name: MOD, Help: "模块", Value: kit.Data(
"mod.plug", kit.Dict( "plug", kit.Dict(
"prefix", kit.Dict( PREFIX, kit.Dict(
"#", "comment", "#", COMMENT,
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"module", "keyword", "module", KEYWORD,
"require", "keyword", "require", KEYWORD,
"replace", "keyword", "replace", KEYWORD,
"=>", "keyword", "=>", KEYWORD,
), ),
), ),
)},
GO: {Name: GO, Help: "后端", Value: kit.Data(
"plug", kit.Dict( "plug", kit.Dict(
"split", kit.Dict( SPLIT, kit.Dict(
"space", "\t ", "space", "\t ",
"operator", "{[(&.,:;!|<>)]}", "operator", "{[(&.,:;!|<>)]}",
), ),
"prefix", kit.Dict( PREFIX, kit.Dict(
"//", "comment", "//", COMMENT,
"/*", "comment", "/*", COMMENT,
"*", "comment", "*", COMMENT,
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"package", "keyword", "package", KEYWORD,
"import", "keyword", "import", KEYWORD,
"const", "keyword", "const", KEYWORD,
"func", "keyword", "func", KEYWORD,
"var", "keyword", "var", KEYWORD,
"type", "keyword", "type", KEYWORD,
"struct", "keyword", "struct", KEYWORD,
"interface", "keyword", "interface", KEYWORD,
"if", "keyword", "if", KEYWORD,
"else", "keyword", "else", KEYWORD,
"for", "keyword", "for", KEYWORD,
"range", "keyword", "range", KEYWORD,
"break", "keyword", "break", KEYWORD,
"continue", "keyword", "continue", KEYWORD,
"switch", "keyword", "switch", KEYWORD,
"case", "keyword", "case", KEYWORD,
"default", "keyword", "default", KEYWORD,
"fallthrough", "keyword", "fallthrough", KEYWORD,
"go", "keyword", "go", KEYWORD,
"select", "keyword", "select", KEYWORD,
"return", "keyword", "return", KEYWORD,
"defer", "keyword", "defer", KEYWORD,
"map", "datatype", "map", DATATYPE,
"chan", "datatype", "chan", DATATYPE,
"string", "datatype", "string", DATATYPE,
"error", "datatype", "error", DATATYPE,
"bool", "datatype", "bool", DATATYPE,
"byte", "datatype", "byte", DATATYPE,
"int", "datatype", "int", DATATYPE,
"int64", "datatype", "int64", DATATYPE,
"float64", "datatype", "float64", DATATYPE,
"len", "function", "len", FUNCTION,
"cap", "function", "cap", FUNCTION,
"copy", "function", "copy", FUNCTION,
"append", "function", "append", FUNCTION,
"msg", "function", "msg", FUNCTION,
"m", "function", "m", FUNCTION,
"nil", "string", "nil", STRING,
"-1", "string", "-1", STRING,
"0", "string", "0", STRING,
"1", "string", "1", STRING,
"2", "string", "2", STRING,
), ),
), ),
)}, )},

46
core/code/inner.go
View File

@ -12,6 +12,19 @@ import (
"strings" "strings"
) )
const (
COMMENT = "comment"
KEYWORD = "keyword"
FUNCTION = "function"
DATATYPE = "datatype"
STRING = "string"
)
const (
SPLIT = "split"
PREFIX = "prefix"
SUFFIX = "suffix"
)
func _inner_ext(name string) string { func _inner_ext(name string) string {
return strings.ToLower(kit.Select(path.Base(name), strings.TrimPrefix(path.Ext(name), "."))) return strings.ToLower(kit.Select(path.Base(name), strings.TrimPrefix(path.Ext(name), ".")))
} }
@ -28,7 +41,7 @@ func _inner_list(m *ice.Message, ext, file, dir string, arg ...string) {
return // 解析成功 return // 解析成功
} }
if m.Conf(INNER, kit.Keys("meta.source", ext)) == "true" { if m.Conf(INNER, kit.Keys(kit.META_SOURCE, ext)) == "true" {
if m.Cmdy(nfs.CAT, path.Join(dir, file)); m.Result() != "" { if m.Cmdy(nfs.CAT, path.Join(dir, file)); m.Result() != "" {
return return
} }
@ -100,39 +113,38 @@ func init() {
), ),
"plug", kit.Dict( "plug", kit.Dict(
"makefile", kit.Dict( "makefile", kit.Dict(
"prefix", kit.Dict("#", "comment"), PREFIX, kit.Dict("#", COMMENT),
"suffix", kit.Dict(":", "comment"), SUFFIX, kit.Dict(":", COMMENT),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"ifeq", "keyword", "ifeq", KEYWORD,
"ifneq", "keyword", "ifneq", KEYWORD,
"else", "keyword", "else", KEYWORD,
"endif", "keyword", "endif", KEYWORD,
), ),
), ),
"py", kit.Dict( "py", kit.Dict(
"prefix", kit.Dict("#", "comment"), PREFIX, kit.Dict("#", COMMENT),
"keyword", kit.Dict("print", "keyword"), KEYWORD, kit.Dict("print", KEYWORD),
), ),
"csv", kit.Dict("display", true), "csv", kit.Dict("display", true),
"json", kit.Dict("link", true), "json", kit.Dict("link", true),
"html", kit.Dict( "html", kit.Dict(
"split", kit.Dict( SPLIT, kit.Dict(
"space", " ", "space", " ",
"operator", "<>", "operator", "<>",
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"head", "keyword", "head", KEYWORD,
"body", "keyword", "body", KEYWORD,
), ),
), ),
"css", kit.Dict( "css", kit.Dict(
"suffix", kit.Dict("{", "comment"), SUFFIX, kit.Dict("{", COMMENT),
), ),
"md", kit.Dict("display", true, "profile", true), "md", kit.Dict(),
), ),
"show", kit.Dict( "show", kit.Dict(
"sh", []string{"sh"},
"py", []string{"python"}, "py", []string{"python"},
"js", []string{"node"}, "js", []string{"node"},
), ),

189
core/code/js.go
View File

@ -8,151 +8,120 @@ import (
"github.com/shylinux/icebergs/base/web" "github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits" kit "github.com/shylinux/toolkits"
"net/http"
"os"
"path" "path"
"strings"
) )
func _js_find(m *ice.Message, key string) {
for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, "find", ".", "-name", key), "\n") {
if p == "" {
continue
}
m.Push("file", strings.TrimPrefix(p, "./"))
m.Push("line", 1)
m.Push("text", "")
}
}
func _js_grep(m *ice.Message, key string) {
m.Split(m.Cmd(cli.SYSTEM, "grep", "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
}
const JS = "js" const JS = "js"
const TS = "ts"
const TSX = "tsx"
const CSS = "css" const CSS = "css"
const HTML = "html" const HTML = "html"
const NODE = "node" const NODE = "node"
func init() { func init() {
Index.Register(&ice.Context{Name: JS, Help: "js", Index.Register(&ice.Context{Name: JS, Help: "前端",
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, JS, JS, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, JS, m.Prefix(JS))
m.Cmd(mdb.PLUGIN, mdb.CREATE, JS, JS, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, JS, m.Prefix(JS))
m.Cmd(mdb.RENDER, mdb.CREATE, JS, JS, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.SEARCH, mdb.CREATE, JS, m.Prefix(JS))
}}, }},
NODE: {Name: NODE, Help: "node", Action: map[string]*ice.Action{ JS: {Name: JS, Help: "前端", Action: map[string]*ice.Action{
"install": {Name: "install", Help: "下载", Hand: func(m *ice.Message, arg ...string) {
// 下载
source := m.Conf(NODE, "meta.source")
p := path.Join(m.Conf("web.code._install", "meta.path"), path.Base(source))
if _, e := os.Stat(p); e != nil {
msg := m.Cmd(web.SPIDE, "dev", web.CACHE, http.MethodGet, source)
m.Cmd(web.CACHE, web.WATCH, msg.Append(web.DATA), p)
}
// 解压
m.Option(cli.CMD_DIR, m.Conf("web.code._install", "meta.path"))
m.Cmd(cli.SYSTEM, "tar", "xvf", path.Base(source))
m.Echo(p)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
JS: {Name: JS, Help: "js", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, m.Option("_path"))
_js_find(m, kit.Select("main", arg, 1))
_js_grep(m, kit.Select("main", arg, 1))
}},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(JS, "meta.plug")) m.Echo(m.Conf(JS, "meta.plug"))
}}, }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}}, mdb.SEARCH: {Name: "search type name text", 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("main", arg, 1))
_go_grep(m, kit.Select("main", arg, 1))
}},
}},
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))
}},
}},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
NODE: {Name: NODE, Help: "服务器", Value: kit.Data( NODE: {Name: NODE, Help: "前端", Value: kit.Data(
"source", "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz", "source", "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz",
)}, )},
JS: {Name: JS, Help: "js", Value: kit.Data( JS: {Name: JS, Help: "js", Value: kit.Data(
"plug", kit.Dict( "plug", kit.Dict(
"split", kit.Dict( SPLIT, kit.Dict(
"space", " \t", "space", " \t",
"operator", "{[(&.,;!|<>)]}", "operator", "{[(&.,;!|<>)]}",
), ),
"prefix", kit.Dict( PREFIX, kit.Dict(
"//", "comment", "//", COMMENT,
"/*", "comment", "/*", COMMENT,
"*", "comment", "*", COMMENT,
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"var", "keyword", "var", KEYWORD,
"new", "keyword", "new", KEYWORD,
"delete", "keyword", "delete", KEYWORD,
"typeof", "keyword", "typeof", KEYWORD,
"function", "keyword", "function", KEYWORD,
"if", "keyword", "if", KEYWORD,
"else", "keyword", "else", KEYWORD,
"for", "keyword", "for", KEYWORD,
"while", "keyword", "while", KEYWORD,
"break", "keyword", "break", KEYWORD,
"continue", "keyword", "continue", KEYWORD,
"switch", "keyword", "switch", KEYWORD,
"case", "keyword", "case", KEYWORD,
"default", "keyword", "default", KEYWORD,
"return", "keyword", "return", KEYWORD,
"window", "function", "window", FUNCTION,
"console", "function", "console", FUNCTION,
"document", "function", "document", FUNCTION,
"arguments", "function", "arguments", FUNCTION,
"event", "function", "event", FUNCTION,
"Date", "function", "Date", FUNCTION,
"JSON", "function", "JSON", FUNCTION,
"0", "string", "0", STRING,
"1", "string", "1", STRING,
"10", "string", "10", STRING,
"-1", "string", "-1", STRING,
"true", "string", "true", STRING,
"false", "string", "false", STRING,
"undefined", "string", "undefined", STRING,
"null", "string", "null", STRING,
"__proto__", "function", "__proto__", FUNCTION,
"setTimeout", "function", "setTimeout", FUNCTION,
"createElement", "function", "createElement", FUNCTION,
"appendChild", "function", "appendChild", FUNCTION,
"removeChild", "function", "removeChild", FUNCTION,
"parentNode", "function", "parentNode", FUNCTION,
"childNodes", "function", "childNodes", FUNCTION,
"Volcanos", "function", "Volcanos", FUNCTION,
"request", "function", "request", FUNCTION,
"require", "function", "require", FUNCTION,
"cb", "function", "cb", FUNCTION,
"cbs", "function", "cbs", FUNCTION,
"shy", "function", "shy", FUNCTION,
"can", "function", "can", FUNCTION,
"sub", "function", "sub", FUNCTION,
"msg", "function", "msg", FUNCTION,
"res", "function", "res", FUNCTION,
"pane", "function", "pane", FUNCTION,
"plugin", "function", "plugin", FUNCTION,
"-1", "string", "-1", STRING,
"0", "string", "0", STRING,
"1", "string", "1", STRING,
"2", "string", "2", STRING,
), ),
), ),
)}, )},

262
core/code/pack.go
View File

@ -7,8 +7,6 @@ import (
"github.com/shylinux/icebergs/base/nfs" "github.com/shylinux/icebergs/base/nfs"
kit "github.com/shylinux/toolkits" kit "github.com/shylinux/toolkits"
"bufio"
"bytes"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"os" "os"
@ -20,12 +18,13 @@ func _pack_file(m *ice.Message, file string) string {
list := "" list := ""
if f, e := os.Open(file); e == nil { if f, e := os.Open(file); e == nil {
defer f.Close() defer f.Close()
if b, e := ioutil.ReadAll(f); e == nil { if b, e := ioutil.ReadAll(f); e == nil {
list = fmt.Sprintf("%v", b) list = fmt.Sprintf("%v", b)
} }
} }
list = strings.ReplaceAll(list, " ", ",")
if len(list) > 0 { if list = strings.ReplaceAll(list, " ", ","); len(list) > 0 {
return fmt.Sprintf(`[]byte{%v}`, list[1:len(list)-1]) return fmt.Sprintf(`[]byte{%v}`, list[1:len(list)-1])
} }
return "[]byte{}" return "[]byte{}"
@ -72,22 +71,57 @@ func _pack_contexts(m *ice.Message, pack *os.File) {
pack.WriteString("\n") pack.WriteString("\n")
} }
const ( const WEBPACK = "webpack"
WEBPACK = "webpack" const BINPACK = "binpack"
BINPACK = "binpack"
MODPACK = "modpack"
)
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
WEBPACK: {Name: "webpack path auto 打包", Help: "打包", Action: map[string]*ice.Action{ BINPACK: {Name: "binpack path auto create", Help: "打包", Action: map[string]*ice.Action{
"pack": {Name: "pack", Help: "打包", Hand: func(m *ice.Message, arg ...string) { mdb.CREATE: {Name: "create name=demo from=src/main.go", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
name := kit.Keys(m.Option(kit.MDB_NAME), "go")
if pack, p, e := kit.Create(path.Join(m.Conf(PUBLISH, kit.META_PATH), BINPACK, name)); m.Assert(e) {
defer pack.Close()
pack.WriteString(m.Cmdx(nfs.CAT, m.Option("from")))
pack.WriteString("\n")
pack.WriteString(`func init() {` + "\n")
pack.WriteString(` ice.BinPack = map[string][]byte{` + "\n")
_pack_volcanos(m, pack, "usr/volcanos")
_pack_dir(m, pack, "usr/learning")
_pack_dir(m, pack, "usr/icebergs")
_pack_dir(m, pack, "usr/toolkits")
_pack_dir(m, pack, "usr/intshell")
_pack_contexts(m, pack)
pack.WriteString(` }` + "\n")
pack.WriteString(`}` + "\n")
m.Echo(p)
}
m.Option(cli.CMD_DIR, path.Join(m.Conf(PUBLISH, kit.META_PATH), BINPACK))
m.Cmd(COMPILE, "windows", "amd64", name)
m.Cmd(COMPILE, "darwin", "amd64", name)
m.Cmd(COMPILE, "linux", "amd64", name)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, path.Join(m.Conf(PUBLISH, kit.META_PATH)))
m.Option(nfs.DIR_TYPE, nfs.FILE)
m.Cmdy(nfs.DIR, BINPACK).Table(func(index int, value map[string]string, head []string) {
m.PushDownload(value[kit.MDB_PATH])
})
}},
WEBPACK: {Name: "webpack path auto create", Help: "打包", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create name=demo", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
css, _, e := kit.Create(path.Join(m.Conf(WEBPACK, kit.META_PATH), "cache.css")) css, _, e := kit.Create(path.Join(m.Conf(WEBPACK, kit.META_PATH), "cache.css"))
m.Assert(e) m.Assert(e)
defer css.Close() defer css.Close()
js, p, e := kit.Create(path.Join(m.Conf(WEBPACK, kit.META_PATH), "cache.js")) js, _, e := kit.Create(path.Join(m.Conf(WEBPACK, kit.META_PATH), "cache.js"))
m.Assert(e) m.Assert(e)
defer js.Close() defer js.Close()
@ -117,191 +151,59 @@ func init() {
js.WriteString(`_can_name = "` + path.Join("/", k) + "\"\n") js.WriteString(`_can_name = "` + path.Join("/", k) + "\"\n")
js.WriteString(m.Cmdx(nfs.CAT, k)) js.WriteString(m.Cmdx(nfs.CAT, k))
} }
m.Echo(p)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
m.Option(nfs.DIR_TYPE, nfs.FILE)
m.Option(nfs.DIR_DEEP, true)
if len(arg) == 0 { if f, _, e := kit.Create("usr/publish/webpack/" + m.Option("name") + ".js"); m.Assert(e) {
m.Cmdy(nfs.DIR, WEBPACK).Table(func(index int, value map[string]string, head []string) { defer f.Close()
// m.Push(kit.MDB_LINK, m.Cmdx(mdb.RENDER, web.RENDER.Download, "/publish/"+value[kit.MDB_PATH]))
})
return
}
m.Cmdy(nfs.CAT, arg[0]) f.WriteString(`Volcanos.meta.pack = ` + kit.Formats(kit.UnMarshal(kit.Select("{}", m.Option("content")))))
}}, }
BINPACK: {Name: "binpack path auto 打包", Help: "打包", Action: map[string]*ice.Action{
"pack": {Name: "pack", Help: "打包", Hand: func(m *ice.Message, arg ...string) {
name := kit.Keys(kit.Select(m.Option(kit.MDB_NAME), "demo"), "go")
if pack, p, e := kit.Create(path.Join(m.Conf(PUBLISH, kit.META_PATH), BINPACK, name)); m.Assert(e) {
defer pack.Close()
pack.WriteString(m.Cmdx(nfs.CAT, "src/main.go")) m.Option(nfs.DIR_ROOT, "")
if f, p, e := kit.Create("usr/publish/webpack/" + m.Option("name") + ".html"); m.Assert(e) {
f.WriteString(fmt.Sprintf(_pack,
m.Cmdx(nfs.CAT, "usr/volcanos/cache.css"),
m.Cmdx(nfs.CAT, "usr/volcanos/index.css"),
pack.WriteString("\n") m.Cmdx(nfs.CAT, "usr/volcanos/proto.js"),
pack.WriteString(`func init() {` + "\n") m.Cmdx(nfs.CAT, "usr/volcanos/cache.js"),
pack.WriteString(` ice.BinPack = map[string][]byte{` + "\n") m.Cmdx(nfs.CAT, "usr/publish/webpack/"+m.Option("name")+".js"),
m.Cmdx(nfs.CAT, "usr/volcanos/index.js"),
_pack_volcanos(m, pack, "usr/volcanos") ))
_pack_dir(m, pack, "usr/learning")
_pack_dir(m, pack, "usr/icebergs")
_pack_dir(m, pack, "usr/intshell")
_pack_contexts(m, pack)
pack.WriteString(` }` + "\n")
pack.WriteString(`}` + "\n")
m.Echo(p) m.Echo(p)
} }
m.Option(cli.CMD_DIR, path.Join(m.Conf(PUBLISH, kit.META_PATH), BINPACK))
m.Cmd(COMPILE, "windows", "amd64", name)
m.Cmd(COMPILE, "darwin", "amd64", name)
m.Cmd(COMPILE, "linux", "amd64", name)
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH)) m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
m.Option(nfs.DIR_TYPE, nfs.FILE) m.Option(nfs.DIR_TYPE, nfs.FILE)
m.Option(nfs.DIR_DEEP, true) m.Option(nfs.DIR_DEEP, true)
m.Cmdy(nfs.DIR, BINPACK).Table(func(index int, value map[string]string, head []string) { m.Cmdy(nfs.DIR, WEBPACK).Table(func(index int, value map[string]string, head []string) {
// m.Push(kit.MDB_LINK, m.Cmdx(mdb.RENDER, web.RENDER.Download, "/publish/"+value[kit.MDB_PATH])) m.PushDownload(path.Join(m.Option(nfs.DIR_ROOT), value[kit.MDB_PATH]))
}) })
}}, }},
MODPACK: {Name: "modpack path=auto auto 创建", Help: "打包", Meta: kit.Dict(
"style", "editor", "创建", kit.List("_input", "text", "name", "name"),
), Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Option("name", "hi")
m.Option("help", "hello")
for i := 0; i < len(arg)-1; i += 2 {
m.Option(arg[i], arg[i+1])
}
// 生成文件
name := m.Option(kit.MDB_NAME)
os.Mkdir(path.Join("src/", name), ice.MOD_DIR)
kit.Fetch(m.Confv(MODPACK, "meta.base"), func(key string, value string) {
p := path.Join("src/", name, name+"."+key)
if _, e := os.Stat(p); e != nil && os.IsNotExist(e) {
if f, p, e := kit.Create(p); m.Assert(e) {
if b, e := kit.Render(value, m); m.Assert(e) {
if n, e := f.Write(b); m.Assert(e) {
m.Log_EXPORT(kit.MDB_FILE, p, kit.MDB_SIZE, n)
}
}
}
}
})
defer m.Cmdy(nfs.DIR, "src/"+name)
// 模块名称
mod := ""
if f, e := os.Open("go.mod"); e == nil {
defer f.Close()
for bio := bufio.NewScanner(f); bio.Scan(); {
if strings.HasPrefix(bio.Text(), "module") {
mod = strings.Split(bio.Text(), " ")[1]
break
}
}
}
// 检查模块
begin, has := false, false
if f, e := os.Open("src/main.go"); e == nil {
for bio := bufio.NewScanner(f); bio.Scan(); {
if strings.HasPrefix(strings.TrimSpace(bio.Text()), "//") {
continue
}
if strings.HasPrefix(bio.Text(), "import") {
if strings.Contains(bio.Text(), mod+"/src/"+name) {
has = true
}
continue
}
if strings.HasPrefix(bio.Text(), "import (") {
begin = true
continue
}
if strings.HasPrefix(bio.Text(), ")") {
begin = false
continue
}
if begin {
if strings.Contains(bio.Text(), mod+"/src/"+name) {
has = true
}
}
}
f.Close()
}
if has {
return
}
// 插入模块
if f, e := os.Open("src/main.go"); m.Assert(e) {
defer f.Close()
if b, e := ioutil.ReadAll(f); m.Assert(e) {
if f, e := os.Create("src/main.go"); m.Assert(e) {
defer f.Close()
for bio := bufio.NewScanner(bytes.NewBuffer(b)); bio.Scan(); {
f.WriteString(bio.Text())
f.WriteString("\n")
if strings.HasPrefix(bio.Text(), "import (") {
m.Info("src/main.go import: %v", mod+"/src/"+name)
f.WriteString("\t_ \"" + mod + "/src/" + name + `"`)
f.WriteString("\n\n")
}
}
}
}
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, "src")
if m.Cmdy(nfs.DIR, kit.Select("", arg, 0)); len(m.Resultv()) > 0 {
m.Option("_display", "/plugin/local/code/inner.js")
}
}},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
WEBPACK: {Name: WEBPACK, Help: "webpack", Value: kit.Data( WEBPACK: {Name: WEBPACK, Help: "webpack", Value: kit.Data(kit.MDB_PATH, "usr/volcanos")},
kit.MDB_PATH, "usr/volcanos",
)},
BINPACK: {Name: BINPACK, Help: "binpack", Value: kit.Data()}, BINPACK: {Name: BINPACK, Help: "binpack", Value: kit.Data()},
MODPACK: {Name: MODPACK, Help: "modpack", Value: kit.Data(
"base", kit.Dict(
"shy", `title {{.Option "name"}}
`,
"go", `package {{.Option "name"}}
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/icebergs/core/chat"
kit "github.com/shylinux/toolkits"
)
var Index = &ice.Context{Name: "{{.Option "name"}}", Help: "{{.Option "help"}}",
Configs: map[string]*ice.Config{
"{{.Option "name"}}": {Name: "{{.Option "name"}}", Help: "{{.Option "help"}}", Value: kit.Data()},
},
Commands: map[string]*ice.Command{
"{{.Option "name"}}": {Name: "{{.Option "name"}}", Help: "{{.Option "help"}}", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Echo("hello {{.Option "name"}} world")
}},
},
}
func init() { chat.Index.Register(Index, &web.Frame{}) }
`,
),
)},
}, },
}, nil) }, nil)
} }
const _pack = `
<!DOCTYPE html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=0.7,user-scalable=no">
<title>volcanos</title>
<link rel="shortcut icon" type="image/ico" href="favicon.ico">
<style type="text/css">%s</style>
<style type="text/css">%s</style>
</head>
<body>
<script>%s</script>
<script>%s</script>
<script>%s</script>
<script>%s</script>
<script>Volcanos.meta.webpack = true</script>
</body>
`

10
core/code/pprof.go
View File

@ -25,12 +25,12 @@ const PPROF = "pprof"
func init() { func init() {
Index.Merge(&ice.Context{ Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
PPROF: {Name: "pprof", Help: "性能分析", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE, PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE,
PPROF, []string{"go", "tool", "pprof"}, PPROF, []string{"go", "tool", "pprof"},
)}, )},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
PPROF: {Name: "pprof zone=auto id=auto auto create", Help: "性能分析", Action: map[string]*ice.Action{ PPROF: {Name: "pprof zone id auto create", Help: "性能分析", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create zone binnary service seconds", Help: "创建", Hand: func(m *ice.Message, arg ...string) { mdb.CREATE: {Name: "create zone binnary service seconds", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, arg) m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, arg)
}}, }},
@ -38,7 +38,11 @@ func init() {
m.Cmdy(mdb.INSERT, PPROF, _sub_key(m, m.Option(kit.MDB_ZONE)), mdb.LIST, arg[2:]) m.Cmdy(mdb.INSERT, PPROF, _sub_key(m, m.Option(kit.MDB_ZONE)), mdb.LIST, arg[2:])
}}, }},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) { mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, PPROF, _sub_key(m, m.Option(kit.MDB_ZONE)), mdb.LIST, kit.MDB_ID, m.Option(kit.MDB_ID), arg) if m.Option(kit.MDB_ID) != "" {
m.Cmdy(mdb.MODIFY, PPROF, _sub_key(m, m.Option(kit.MDB_ZONE)), mdb.LIST, kit.MDB_ID, m.Option(kit.MDB_ID), arg)
} else {
m.Cmdy(mdb.MODIFY, PPROF, "", mdb.HASH, kit.MDB_ZONE, m.Option(kit.MDB_ZONE), arg)
}
}}, }},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) { mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, PPROF, "", mdb.HASH, kit.MDB_ZONE, m.Option(kit.MDB_ZONE)) m.Cmdy(mdb.DELETE, PPROF, "", mdb.HASH, kit.MDB_ZONE, m.Option(kit.MDB_ZONE))

111
core/code/sh.go
View File

@ -13,24 +13,15 @@ import (
const SH = "sh" const SH = "sh"
func init() { func init() {
Index.Register(&ice.Context{Name: SH, Help: "sh", Index.Register(&ice.Context{Name: SH, Help: "命令",
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.PLUGIN, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.RENDER, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.ENGINE, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.ENGINE, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.SEARCH, mdb.CREATE, SH, SH, c.Cap(ice.CTX_FOLLOW))
}}, }},
SH: {Name: SH, Help: "sh", Action: map[string]*ice.Action{ SH: {Name: SH, Help: "命令", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, m.Option("_path"))
_c_find(m, kit.Select("main", arg, 1))
m.Cmdy(mdb.SEARCH, "man1", arg[1:])
_c_grep(m, kit.Select("main", arg, 1))
}},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(SH, "meta.plug")) m.Echo(m.Conf(SH, "meta.plug"))
}}, }},
@ -39,65 +30,75 @@ func init() {
}}, }},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2]) m.Option(cli.CMD_DIR, arg[2])
m.Cmdy(cli.SYSTEM, "sh", arg[1]) m.Cmdy(cli.SYSTEM, SH, arg[1])
m.Set(ice.MSG_APPEND) 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("main", arg, 1))
m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
_go_grep(m, kit.Select("main", arg, 1))
}},
"man": {Hand: func(m *ice.Message, arg ...string) { MAN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, arg[0], arg[1])) m.Echo(_c_help(m, arg[0], arg[1]))
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}}, }},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
SH: {Name: SH, Help: "sh", Value: kit.Data( SH: {Name: SH, Help: "命令", Value: kit.Data(
"plug", kit.Dict( "plug", kit.Dict(
"split", kit.Dict( SPLIT, kit.Dict(
"space", " ", "space", " ",
"operator", "{[(.,;!|<>)]}", "operator", "{[(.,;!|<>)]}",
), ),
"prefix", kit.Dict( PREFIX, kit.Dict(
"#", "comment", "#", COMMENT,
), ),
"suffix", kit.Dict( SUFFIX, kit.Dict(
"{", "comment", "{", COMMENT,
), ),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"export", "keyword", "export", KEYWORD,
"source", "keyword", "source", KEYWORD,
"require", "keyword", "require", KEYWORD,
"if", "keyword", "if", KEYWORD,
"then", "keyword", "then", KEYWORD,
"else", "keyword", "else", KEYWORD,
"fi", "keyword", "fi", KEYWORD,
"for", "keyword", "for", KEYWORD,
"while", "keyword", "while", KEYWORD,
"do", "keyword", "do", KEYWORD,
"done", "keyword", "done", KEYWORD,
"esac", "keyword", "esac", KEYWORD,
"case", "keyword", "case", KEYWORD,
"in", "keyword", "in", KEYWORD,
"return", "keyword", "return", KEYWORD,
"shift", "keyword", "shift", KEYWORD,
"local", "keyword", "local", KEYWORD,
"echo", "keyword", "echo", KEYWORD,
"eval", "keyword", "eval", KEYWORD,
"kill", "keyword", "kill", KEYWORD,
"let", "keyword", "let", KEYWORD,
"cd", "keyword", "cd", KEYWORD,
"xargs", "function", "xargs", FUNCTION,
"date", "function", "date", FUNCTION,
"find", "function", "find", FUNCTION,
"grep", "function", "grep", FUNCTION,
"sed", "function", "sed", FUNCTION,
"awk", "function", "awk", FUNCTION,
"pwd", "function", "pwd", FUNCTION,
"ps", "function", "ps", FUNCTION,
"ls", "function", "ls", FUNCTION,
"rm", "function", "rm", FUNCTION,
"go", "function", "go", FUNCTION,
), ),
), ),
)}, )},

44
core/code/shy.go
View File

@ -13,23 +13,15 @@ import (
const SHY = "shy" const SHY = "shy"
func init() { func init() {
Index.Register(&ice.Context{Name: SHY, Help: "shy", Index.Register(&ice.Context{Name: SHY, Help: "脚本",
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.PLUGIN, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.PLUGIN, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.RENDER, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.RENDER, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.ENGINE, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW)) m.Cmd(mdb.ENGINE, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW))
m.Cmd(mdb.SEARCH, mdb.CREATE, SHY, SHY, c.Cap(ice.CTX_FOLLOW))
}}, }},
SHY: {Name: SHY, Help: "shy", Action: map[string]*ice.Action{ SHY: {Name: SHY, Help: "脚本", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
return
}
m.Option(cli.CMD_DIR, m.Option("_path"))
_c_find(m, kit.Select("main", arg, 1))
_c_grep(m, kit.Select("main", arg, 1))
}},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Conf(SHY, "meta.plug")) m.Echo(m.Conf(SHY, "meta.plug"))
}}, }},
@ -39,20 +31,28 @@ func init() {
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1])) m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
}}, }},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}}, 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("main", arg, 1))
_go_grep(m, kit.Select("main", arg, 1))
}},
}},
}, },
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
SHY: {Name: SHY, Help: "shy", Value: kit.Data( SHY: {Name: SHY, Help: "脚本", Value: kit.Data(
"plug", kit.Dict( "plug", kit.Dict(
"prefix", kit.Dict("#", "comment"), PREFIX, kit.Dict("#", COMMENT),
"keyword", kit.Dict( KEYWORD, kit.Dict(
"title", "keyword", "title", KEYWORD,
"chapter", "keyword", "chapter", KEYWORD,
"section", "keyword", "section", KEYWORD,
"refer", "keyword", "refer", KEYWORD,
"field", "keyword", "field", KEYWORD,
"label", "keyword", "label", KEYWORD,
"chain", "keyword", "chain", KEYWORD,
), ),
), ),
)}, )},

4
core/code/upgrade.go
View File

@ -16,8 +16,8 @@ func init() {
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict( UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
kit.MDB_PATH, "usr/upgrade", "system", kit.Dict(kit.MDB_LIST, kit.List( kit.MDB_PATH, "usr/upgrade", "system", kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_INPUT, "bin", "file", "ice.bin", "path", "bin/ice.bin", kit.MDB_INPUT, "bin", kit.MDB_FILE, "ice.sh", kit.MDB_PATH, "bin/ice.sh",
kit.MDB_INPUT, "bin", "file", "ice.sh", "path", "bin/ice.sh", kit.MDB_INPUT, "bin", kit.MDB_FILE, "ice.bin", kit.MDB_PATH, "bin/ice.bin",
)), )),
))}, ))},
}, },