消息模板匹配器

extension/model.go

@@ -1,5 +1,7 @@
 package extension
 
+import zero "github.com/wdvxdr1123/ZeroBot"
+
 // PrefixModel is model of zero.PrefixRule
 type PrefixModel struct {
 	Prefix string `zero:"prefix"`
@@ -32,3 +34,8 @@ type FullMatchModel struct {
 type RegexModel struct {
 	Matched []string `zero:"regex_matched"`
 }
+
+// PatternModel is model of zero.PatternRule
+type PatternModel struct {
+	Matched []zero.PatternMatched `zero:"pattern_matched"`
+}

rules.go

@@ -11,6 +11,10 @@ import (
 	"github.com/wdvxdr1123/ZeroBot/utils/helper"
 )
 
+const (
+	KEY_PATTERN = "pattern_matched"
+)
+
 // Type check the ctx.Event's type
 func Type(type_ string) Rule {
 	t := strings.SplitN(type_, "/", 3)
@@ -122,6 +126,136 @@ func RegexRule(regexPattern string) Rule {
 	}
 }
 
+type PatternSegment struct {
+	Type    string
+	Matcher func(ctx *Ctx, msg message.MessageSegment) bool
+}
+
+type Pattern []PatternSegment
+
+// PatternMatched save PatternRule context
+type PatternMatched map[string]interface{}
+
+func (p PatternMatched) AsText() PatternTextMatched {
+	return PatternTextMatched{
+		Groups: p["groups"].([]string),
+	}
+}
+func (p PatternMatched) AsAt() PatternAtMatched {
+	return PatternAtMatched{UID: p["qq"].(int64)}
+}
+func (p PatternMatched) AsImage() PatternImageMatched {
+	return PatternImageMatched{File: p["file"].(string)}
+}
+func (p PatternMatched) AsReply() PatternReplyMatched {
+	return PatternReplyMatched{MessageID: p["file"].(string)}
+}
+
+type PatternImageMatched = struct {
+	File string
+}
+type PatternAtMatched = struct {
+	UID int64
+}
+type PatternTextMatched = struct {
+	Groups []string
+}
+type PatternReplyMatched = struct {
+	MessageID string
+}
+
+// PatternText type zero.PatternTextMatched
+func PatternText(regex string) PatternSegment {
+	re := regexp.MustCompile(regex)
+	return PatternSegment{
+		Type: "text",
+		Matcher: func(ctx *Ctx, msg message.MessageSegment) bool {
+			s := msg.Data["text"]
+			s = strings.Trim(s, " \n\r\t")
+			matchString := re.MatchString(s)
+			if matchString {
+				if _, ok := ctx.State[KEY_PATTERN]; !ok {
+					ctx.State[KEY_PATTERN] = make([]PatternMatched, 0, 1)
+				}
+
+				ctx.State[KEY_PATTERN] = append(ctx.State[KEY_PATTERN].([]PatternMatched),
+					PatternMatched{
+						"groups": re.FindStringSubmatch(s),
+					})
+			}
+			return matchString
+		},
+	}
+}
+
+// PatternAt type zero.PatternAtMatched
+func PatternAt() PatternSegment {
+	return PatternSegment{
+		Type: "at",
+		Matcher: func(ctx *Ctx, msg message.MessageSegment) bool {
+			if _, ok := ctx.State[KEY_PATTERN]; !ok {
+				ctx.State[KEY_PATTERN] = make([]PatternMatched, 0, 1)
+			}
+			qq, _ := strconv.ParseInt(msg.Data["qq"], 10, 64)
+			ctx.State[KEY_PATTERN] = append(ctx.State[KEY_PATTERN].([]PatternMatched),
+				PatternMatched{
+					"qq": qq,
+				})
+			return true
+		},
+	}
+}
+
+// PatternImage type zero.PatternImageMatched
+func PatternImage() PatternSegment {
+	return PatternSegment{
+		Type: "image",
+		Matcher: func(ctx *Ctx, msg message.MessageSegment) bool {
+			if _, ok := ctx.State[KEY_PATTERN]; !ok {
+				ctx.State[KEY_PATTERN] = make([]PatternMatched, 0, 1)
+			}
+			ctx.State[KEY_PATTERN] = append(ctx.State[KEY_PATTERN].([]PatternMatched), PatternMatched{
+				"file": msg.Data["file"],
+			})
+			return true
+		},
+	}
+}
+
+// PatternReply type zero.PatternReplyMatched
+func PatternReply() PatternSegment {
+	return PatternSegment{
+		Type: "reply",
+		Matcher: func(ctx *Ctx, msg message.MessageSegment) bool {
+			if _, ok := ctx.State[KEY_PATTERN]; !ok {
+				ctx.State[KEY_PATTERN] = make([]PatternMatched, 0, 1)
+			}
+			ctx.State[KEY_PATTERN] = append(ctx.State[KEY_PATTERN].([]PatternMatched), PatternMatched{
+				"id": msg.Data["id"],
+			})
+			return true
+		},
+	}
+}
+func patternMatch(ctx *Ctx, pattern []PatternSegment, msgs []message.MessageSegment) bool {
+	if len(pattern) != len(msgs) {
+		return false
+	}
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i].Type != (msgs[i].Type) || !pattern[i].Matcher(ctx, msgs[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// PatternRule check if the message can be matched by the pattern
+func PatternRule(pattern ...PatternSegment) Rule {
+	return func(ctx *Ctx) bool {
+		return patternMatch(ctx, pattern, ctx.Event.Message)
+	}
+}
+
 // ReplyRule check if the message is replying some message
 func ReplyRule(messageID int64) Rule {
 	return func(ctx *Ctx) bool {