opt mdb

base/mdb/engine.go

@@ -7,5 +7,5 @@ import (
 const ENGINE = "engine"
 
 func init() {
-	Index.MergeCommands(ice.Commands{ENGINE: {Name: "engine type name text auto", Help: "引擎", Actions: RenderAction()}})
+	Index.MergeCommands(ice.Commands{ENGINE: {Help: "引擎", Actions: RenderAction()}})
 }

base/mdb/hash.go

@@ -24,7 +24,6 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
 		return
 	}
 	defer RLock(m, prefix, chain)()
-
 	list := map[string]int{}
 	Richs(m, prefix, chain, FOREACH, func(key string, val Map) {
 		val = kit.GetMeta(val)
@@ -32,24 +31,18 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
 	})
 	for k, i := range list {
 		if k != "" {
-			m.Push(field, k)
+			m.Push(field, k).Push(COUNT, i)
-			m.Push(COUNT, i)
 		}
 	}
 	m.SortIntR(COUNT)
 }
 func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
+	m.Logs(INSERT, KEY, path.Join(prefix, chain), arg[0], arg[1])
 	defer Lock(m, prefix, chain)()
-
+	if value := kit.GetMeta(m.Confm(prefix, kit.Keys(HASH, arg[1]))); value != nil && arg[1] != "" {
-	if value := m.Confm(prefix, kit.Keys(HASH, arg[1])); value != nil && arg[1] != "" {
+		kit.Fetch(arg[2:], func(k, v string) { kit.Value(value, k, v)})
-		value = kit.GetMeta(value)
-		for i := 2; i < len(arg)-1; i += 2 {
-			kit.Value(value, arg[i], arg[i+1])
-		}
 		return arg[1]
 	}
-
-	m.Logs(INSERT, KEY, path.Join(prefix, chain), arg[0], arg[1])
 	if expire := m.Conf(prefix, kit.Keys(chain, kit.Keym(EXPIRE))); expire != "" {
 		arg = kit.Simple(TIME, m.Time(expire), arg)
 	}
@@ -62,7 +55,6 @@ func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
 }
 func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
 	defer Lock(m, prefix, chain)()
-
 	Richs(m, prefix, chain, value, func(key string, val Map) {
 		if target, ok := kit.GetMeta(val)[TARGET].(io.Closer); ok {
 			target.Close()
@@ -72,26 +64,18 @@ func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
 	})
 }
 func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg ...string) {
-	defer Lock(m, prefix, chain)()
-
-	Richs(m, prefix, chain, value, func(key string, val Map) {
 	m.Logs(MODIFY, KEY, path.Join(prefix, chain), field, value, arg)
-		_mdb_modify(m, val, field, arg...)
+	defer Lock(m, prefix, chain)()
-	})
+	Richs(m, prefix, chain, value, func(key string, val Map) { _mdb_modify(m, val, field, arg...) })
 }
 func _hash_select(m *ice.Message, prefix, chain, field, value string) {
-	defer RLock(m, prefix, chain)()
-
 	if field == HASH && value == RANDOM {
 		value = RANDOMS
 	}
+	defer m.SortTimeR(TIME)
+	defer RLock(m, prefix, chain)()
 	fields := _hash_fields(m)
-	Richs(m, prefix, chain, value, func(key string, value Map) {
+	Richs(m, prefix, chain, value, func(key string, value Map) { _mdb_select(m, m.OptionCB(""), key, value, fields, nil) })
-		_mdb_select(m, m.OptionCB(""), key, value, fields, nil)
-	})
-	if !m.FieldsIsDetail() {
-		m.SortTimeR(TIME)
-	}
 }
 func _hash_select_field(m *ice.Message, prefix, chain string, key string, field string) (value string) {
 	defer RLock(m, prefix, chain)()
@@ -106,72 +90,54 @@ func _hash_select_field(m *ice.Message, prefix, chain string, key string, field
 }
 func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
 	defer RLock(m, prefix, chain)()
-
 	fields := _hash_fields(m)
-	Richs(m, prefix, chain, FOREACH, func(key string, val Map) {
+	Richs(m, prefix, chain, FOREACH, func(key string, value Map) {
-		switch val = kit.GetMeta(val); cb := m.OptionCB(PRUNES).(type) {
+		switch value = kit.GetMeta(value); cb := m.OptionCB(PRUNES).(type) {
 		case func(string, Map) bool:
-			if !cb(key, val) {
+			if cb(key, value) {
-				return
+				m.Push(key, value, fields)
 			}
 		default:
-			for i := 0; i < len(arg)-1; i += 2 {
+			kit.Fetch(arg, func(k, v string) {
-				if val[arg[i]] != arg[i+1] && kit.Value(val, arg[i]) != arg[i+1] {
+				if value[k] == v || kit.Value(value, k) == v {
-					return
+					m.Push(key, value, fields)
 				}
+			})
 		}
-		}
-		m.Push(key, val, fields)
 	})
 }
 func _hash_export(m *ice.Message, prefix, chain, file string) {
-	defer Lock(m, prefix, chain)()
-
 	f, p, e := miss.CreateFile(kit.Keys(file, JSON))
 	m.Assert(e)
 	defer f.Close()
-
+	m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p)
+	defer m.Echo(p).StatusTime(LINK, "/share/local/"+p)
 	en := json.NewEncoder(f)
 	en.SetIndent("", "  ")
-	m.Assert(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))))
+	defer Lock(m, prefix, chain)()
-
+	m.Warn(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))), EXPORT, p)
-	m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p)
 	m.Conf(prefix, kit.Keys(chain, HASH), "")
-	m.Echo(p).StatusTime(LINK, "/share/local/"+p)
 }
 func _hash_import(m *ice.Message, prefix, chain, file string) {
-	defer Lock(m, prefix, chain)()
-
 	f, e := miss.OpenFile(kit.Keys(file, JSON))
 	if m.Warn(e) {
 		return
 	}
 	defer f.Close()
-
 	list := Map{}
 	m.Assert(json.NewDecoder(f).Decode(&list))
-
+	m.Logs(IMPORT, KEY, path.Join(prefix, chain), COUNT, len(list))
-	count := 0
+	defer m.Echo("%d", len(list))
-	if m.Conf(prefix, kit.Keys(chain, META, SHORT)) == "" {
+	defer Lock(m, prefix, chain)()
-		for k, data := range list {
-			m.Conf(prefix, kit.Keys(chain, HASH, k), data)
-			count++
-		}
-	} else {
 	for k, data := range list {
 		if m.Confv(prefix, kit.Keys(chain, HASH, k)) == nil {
 			m.Confv(prefix, kit.Keys(chain, HASH, k), data)
 		} else {
 			Rich(m, prefix, chain, data)
 		}
-			count++
 	}
 }
 
-	m.Logs(IMPORT, KEY, path.Join(prefix, chain), COUNT, count)
-	m.Echo("%d", count)
-}
-
 const (
 	HASH_FIELD = "time,hash,type,name,text"
 )
@@ -180,30 +146,30 @@ const HASH = "hash"
 func HashAction(arg ...Any) ice.Actions {
 	return ice.Actions{ice.CTX_INIT: AutoConfig(arg...), ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
 		INPUTS: {Hand: func(m *ice.Message, arg ...string) { HashInputs(m, arg) }},
-		CREATE: {Name: "create", Help: "创建", Hand: func(m *ice.Message, arg ...string) { HashCreate(m, arg) }},
+		CREATE: {Hand: func(m *ice.Message, arg ...string) { HashCreate(m, arg) }},
-		REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) { HashRemove(m, arg) }},
+		REMOVE: {Hand: func(m *ice.Message, arg ...string) { HashRemove(m, arg) }},
 		MODIFY: {Hand: func(m *ice.Message, arg ...string) { HashModify(m, arg) }},
 		SELECT: {Hand: func(m *ice.Message, arg ...string) { HashSelect(m, arg...) }},
-		PRUNES: {Name: "prunes before@date", Help: "清理", Hand: func(m *ice.Message, arg ...string) { HashPrunes(m, nil) }},
+		PRUNES: {Name: "prunes before@date", Hand: func(m *ice.Message, arg ...string) { HashPrunes(m, nil) }},
-		EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) { HashExport(m, arg) }},
+		EXPORT: {Hand: func(m *ice.Message, arg ...string) { HashExport(m, arg) }},
-		IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) { HashImport(m, arg) }},
+		IMPORT: {Hand: func(m *ice.Message, arg ...string) { HashImport(m, arg) }},
 	}
 }
-func HashCloseAction(args ...Any) ice.Actions {
+func HashStatusAction(arg ...Any) ice.Actions {
-	return ice.MergeActions(HashAction(args...), ice.Actions{
+	return ice.MergeActions(ice.Actions{
-		ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
+		PRUNES: &ice.Action{Hand: func(m *ice.Message, arg ...string) {
-	})
-}
-func HashStatusAction(args ...Any) ice.Actions {
-	list := HashAction(args...)
-	list[PRUNES] = &ice.Action{Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
 			m.OptionFields(m.Config(FIELD))
 			m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "error")
 			m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "close")
 			m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "stop")
 			m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "end")
-	}}
+		}},
-	return list
+	}, HashAction(arg...))
+}
+func HashCloseAction(args ...Any) ice.Actions {
+	return ice.MergeActions(HashAction(args...), ice.Actions{
+		ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
+	})
 }
 func HashStatusCloseAction(args ...Any) ice.Actions {
 	return ice.MergeActions(HashStatusAction(args...), ice.Actions{
@@ -264,9 +230,9 @@ func HashSelect(m *ice.Message, arg ...string) *ice.Message {
 	return m.StatusTime()
 }
 func HashPrunes(m *ice.Message, cb func(Maps) bool) *ice.Message {
-	expire := kit.Time(kit.Select(m.Time("-72h"), m.Option("before")))
+	expire := kit.Select(m.Time("-72h"), m.Option("before"))
 	m.Cmd("", func(value Maps) {
-		if kit.Time(value[TIME]) > expire {
+		if value[TIME] > expire {
 			return
 		}
 		if cb != nil && !cb(value) {
@@ -318,14 +284,13 @@ func HashSelectField(m *ice.Message, key string, field string) (value string) {
 	})
 	return
 }
-func HashSelectDetail(m *ice.Message, key string, cb Any) bool {
+func HashSelectDetail(m *ice.Message, key string, cb Any) (has bool) {
 	defer RLock(m, m.PrefixKey(), "")()
-	has := false
 	Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) {
 		_mdb_select(m, cb, key, value, nil, nil)
 		has = true
 	})
-	return has
+	return
 }
 func HashSelectUpdate(m *ice.Message, key string, cb Any) *ice.Message {
 	defer Lock(m, m.PrefixKey(), "")()
@@ -345,7 +310,6 @@ func HashSelectClose(m *ice.Message) *ice.Message {
 	HashSelectValue(m, func(value ice.Map) {
 		target := value[TARGET]
 		if c, ok := target.(io.Closer); ok {
-			m.Logs(DELETE, TARGET, m.PrefixKey())
 			c.Close()
 		}
 		delete(value, TARGET)

base/mdb/mdb.shy

@@ -1,7 +0,0 @@
-chapter "mdb"
-
-field "插件" mdb.plugin
-field "渲染" mdb.render
-field "引擎" mdb.engine
-field "搜索" mdb.search
-

base/mdb/plugin.go

@@ -6,6 +6,4 @@ import (
 
 const PLUGIN = "plugin"
 
-func init() {
+func init() { Index.MergeCommands(ice.Commands{PLUGIN: {Help: "插件", Actions: RenderAction()}}) }
-	Index.MergeCommands(ice.Commands{PLUGIN: {Name: "plugin type name text auto", Help: "插件", Actions: RenderAction()}})
-}

base/mdb/render.go

@@ -7,9 +7,7 @@ import (
 
 const RENDER = "render"
 
-func init() {
+func init() { Index.MergeCommands(ice.Commands{RENDER: {Help: "渲染", Actions: RenderAction()}}) }
-	Index.MergeCommands(ice.Commands{RENDER: {Name: "render type name text auto", Help: "渲染", Actions: RenderAction()}})
-}
 
 func RenderAction(args ...ice.Any) ice.Actions {
 	return ice.MergeActions(ice.Actions{
@@ -20,27 +18,24 @@ func RenderAction(args ...ice.Any) ice.Actions {
 			if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
 				cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
 			} else {
-				ls := kit.Simple(args)
+				kit.Fetch(kit.Simple(args), func(key, value string) { m.Config(key, value) })
-				for i := 0; i < len(ls); i += 2 {
-					m.Config(ls[i], ls[i+1])
-				}
 			}
 		}},
-		CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+		CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) {
 			m.Option(TYPE, kit.Ext(m.Option(TYPE)))
-			m.Option(NAME, kit.Select(m.Option(TYPE), m.Option(NAME)))
+			m.OptionDefault(NAME, m.Option(TYPE))
 			m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple(TYPE, NAME, TEXT))
 		}},
-		SELECT: {Name: "select type name text auto", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
+		SELECT: {Name: "select type name text auto create", Hand: func(m *ice.Message, arg ...string) {
-			if len(arg) > 1 {
+			if len(arg) < 2 || arg[0] == "" || arg[1] == "" {
+				HashSelect(m, arg...)
+				return
+			}
 			for _, k := range kit.Split(arg[0]) {
 				HashSelect(m.Spawn(ice.OptionFields("")), k).Tables(func(value ice.Maps) {
 					m.Cmdy(kit.Keys(value[TEXT], value[NAME]), m.CommandKey(), k, arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
 				})
 			}
-				return
-			}
-			HashSelect(m, arg...)
 		}},
 	})
 }

base/mdb/search.go

@@ -8,40 +8,28 @@ import (
 const SEARCH = "search"
 
 func init() {
-	Index.MergeCommands(ice.Commands{SEARCH: {Name: "search type name text auto", Help: "搜索", Actions: RenderAction()}})
+	Index.MergeCommands(ice.Commands{SEARCH: {Help: "搜索", Actions: RenderAction()}})
 	ice.AddMerges(func(c *ice.Context, key string, cmd *ice.Command, sub string, action *ice.Action) (ice.Handler, ice.Handler) {
 		switch sub {
 		case SEARCH:
-			return func(m *ice.Message, arg ...string) { m.Cmd(SEARCH, CREATE, m.CommandKey(), m.PrefixKey()) }, nil
+			return func(m *ice.Message, arg ...string) { m.Cmd(sub, CREATE, m.CommandKey(), m.PrefixKey()) }, nil
 		}
 		return nil, nil
 	})
 }
-func SearchAction() ice.Actions {
+func SearchAction() ice.Actions { return ice.Actions{SEARCH: {Hand: func(m *ice.Message, arg ...string) { HashSelectSearch(m, arg) }}} }
-	return ice.Actions{
+func HashSearchAction(arg ...Any) ice.Actions { return ice.MergeActions(HashAction(arg...), SearchAction()) }
-		SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) { HashSelectSearch(m, arg) }},
-	}
-}
-func HashSearchAction(arg ...Any) ice.Actions {
-	return ice.MergeActions(HashAction(arg...), SearchAction())
-}
 func HashSelectSearch(m *ice.Message, args []string, keys ...string) *ice.Message {
+	if args[0] != m.CommandKey() {
+		return m
+	}
 	if len(keys) == 0 {
-		ls := kit.Split(m.Config(FIELD))
+		keys = kit.Filters(kit.Split(m.Config(FIELD)), TIME, HASH)
-		for _, k := range ls {
-			switch k {
-			case TIME, HASH:
-			default:
-				keys = append(keys, k)
 	}
-		}
-	}
-	if args[0] == m.CommandKey() {
 	HashSelectValue(m, func(value ice.Map) {
 		if args[1] == "" || args[1] == value[keys[1]] {
 			m.PushSearch(kit.SimpleKV("", value[keys[0]], value[keys[1]], value[keys[2]]), value)
 		}
 	})
-	}
 	return m
 }

type.go

@@ -127,9 +127,15 @@ func (c *Context) Register(s *Context, x Server, n ...string) *Context {
 	return s
 }
 func (c *Context) MergeCommands(Commands Commands) *Context {
-	for _, cmd := range Commands {
+	for key, cmd := range Commands {
 		if cmd.Hand == nil && cmd.RawHand == nil {
 			cmd.RawHand = logs.FileLines(2)
+			if cmd.Actions != nil {
+				if action, ok := cmd.Actions[SELECT]; ok {
+					cmd.Name = kit.Select(strings.Replace(action.Name, SELECT, key, 1), cmd.Name)
+					cmd.Help = kit.Select(action.Help, cmd.Help)
+				}
+			}
 		}
 	}
 	configs := Configs{}