消息模板匹配器

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.PatternParsed `zero:"pattern_matched"`
+}

extension/rate/rate.go

@@ -26,7 +26,7 @@ func NewManager[K comparable](interval time.Duration, burst int) *LimiterManager
 }
 
 // Delete 删除对应限速器
-func (l *LimiterManager[K]) Delete(key K)  {
+func (l *LimiterManager[K]) Delete(key K) {
 	l.limiters.Delete(key)
 }
 

extension/single/single.go

@@ -4,6 +4,7 @@ import (
 	"runtime"
 
 	"github.com/RomiChan/syncx"
+
 	zero "github.com/wdvxdr1123/ZeroBot"
 )
 

pattern.go

@@ -0,0 +1,268 @@
+package zero
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/wdvxdr1123/ZeroBot/message"
+)
+
+const (
+	KeyPattern = "pattern_matched"
+)
+
+// AsRule build PatternRule
+func (p *Pattern) AsRule() Rule {
+	return func(ctx *Ctx) bool {
+		if len(ctx.Event.Message) == 0 {
+			return false
+		}
+		if !p.cleanRedundantAt {
+			return patternMatch(ctx, *p, ctx.Event.Message)
+		}
+
+		// copy messages
+		msgs := make([]message.Segment, 0, len(ctx.Event.Message))
+		msgs = append(msgs, ctx.Event.Message[0])
+		for i := 1; i < len(ctx.Event.Message); i++ {
+			if ctx.Event.Message[i-1].Type == "reply" && ctx.Event.Message[i].Type == "at" {
+				// [reply][at]
+				reply := ctx.GetMessage(ctx.Event.Message[i-1].Data["id"])
+				if reply.MessageID.ID() != 0 && reply.Sender != nil && reply.Sender.ID != 0 && strconv.FormatInt(reply.Sender.ID, 10) == ctx.Event.Message[i].Data["qq"] {
+					continue
+				}
+			}
+			msgs = append(msgs, ctx.Event.Message[i])
+		}
+		return patternMatch(ctx, *p, msgs)
+	}
+}
+
+type Pattern struct {
+	cleanRedundantAt bool
+	segments         []PatternSegment
+}
+
+func NewPattern(cleanRedundantAt ...bool) *Pattern {
+	clean := true
+	if len(cleanRedundantAt) > 0 {
+		clean = cleanRedundantAt[0]
+	}
+	pattern := Pattern{
+		cleanRedundantAt: clean,
+		segments:         make([]PatternSegment, 0, 4),
+	}
+	return &pattern
+}
+
+type PatternSegment struct {
+	typ      string
+	optional bool
+	parse    Parser
+}
+
+type Parser func(msg *message.Segment) PatternParsed
+
+// SetOptional set previous segment is optional, is v is empty, optional will be true
+// if Pattern is empty, panic
+func (p *Pattern) SetOptional(v ...bool) *Pattern {
+	if len(p.segments) == 0 {
+		panic("pattern is empty")
+	}
+	if len(v) == 1 {
+		p.segments[len(p.segments)-1].optional = v[0]
+	} else {
+		p.segments[len(p.segments)-1].optional = true
+	}
+	return p
+}
+
+// PatternParsed PatternRule parse result
+type PatternParsed struct {
+	value any
+	msg   *message.Segment
+}
+
+// Text 获取正则表达式匹配到的文本数组
+func (p PatternParsed) Text() []string {
+	if p.value == nil {
+		return nil
+	}
+	return p.value.([]string)
+}
+
+// At 获取被@者ID
+func (p PatternParsed) At() string {
+	if p.value == nil {
+		return ""
+	}
+	return p.value.(string)
+}
+
+// Image 获取图片URL
+func (p PatternParsed) Image() string {
+	if p.value == nil {
+		return ""
+	}
+	return p.value.(string)
+}
+
+// Reply 获取被回复的消息ID
+func (p PatternParsed) Reply() string {
+	if p.value == nil {
+		return ""
+	}
+	return p.value.(string)
+}
+
+// Raw 获取原始消息
+func (p PatternParsed) Raw() *message.Segment {
+	return p.msg
+}
+
+func (p *Pattern) Add(typ string, optional bool, parse Parser) *Pattern {
+	pattern := &PatternSegment{
+		typ:      typ,
+		optional: optional,
+		parse:    parse,
+	}
+	p.segments = append(p.segments, *pattern)
+	return p
+}
+
+// Text use regex to search a 'text' segment
+func (p *Pattern) Text(regex string) *Pattern {
+	p.Add("text", false, NewTextParser(regex))
+	return p
+}
+
+func NewTextParser(regex string) Parser {
+	re := regexp.MustCompile(regex)
+	return func(msg *message.Segment) PatternParsed {
+		s := msg.Data["text"]
+		s = strings.Trim(s, " \n\r\t")
+		matchString := re.MatchString(s)
+		if matchString {
+			return PatternParsed{
+				value: re.FindStringSubmatch(s),
+				msg:   msg,
+			}
+		}
+
+		return PatternParsed{}
+	}
+}
+
+// At use regex to match an 'at' segment, if id is not empty, only match specific target
+func (p *Pattern) At(id ...message.ID) *Pattern {
+	if len(id) > 1 {
+		panic("at pattern only support one id")
+	}
+	p.Add("at", false, NewAtParser(id...))
+	return p
+}
+
+func NewAtParser(id ...message.ID) Parser {
+	return func(msg *message.Segment) PatternParsed {
+		if len(id) == 0 || len(id) == 1 && id[0].String() == msg.Data["qq"] {
+			return PatternParsed{
+				value: msg.Data["qq"],
+				msg:   msg,
+			}
+		}
+		return PatternParsed{}
+	}
+}
+
+// Image use regex to match an 'at' segment, if id is not empty, only match specific target
+func (p *Pattern) Image() *Pattern {
+	p.Add("image", false, NewImageParser())
+	return p
+}
+
+func NewImageParser() Parser {
+	return func(msg *message.Segment) PatternParsed {
+		return PatternParsed{
+			value: msg.Data["file"],
+			msg:   msg,
+		}
+	}
+}
+
+// Reply type zero.PatternReplyMatched
+func (p *Pattern) Reply() *Pattern {
+	p.Add("reply", false, NewReplyParser())
+	return p
+}
+
+func NewReplyParser() Parser {
+	return func(msg *message.Segment) PatternParsed {
+		return PatternParsed{
+			value: msg.Data["id"],
+			msg:   msg,
+		}
+	}
+}
+
+// Any match any segment
+func (p *Pattern) Any() *Pattern {
+	p.Add("any", false, NewAnyParser())
+	return p
+}
+
+func NewAnyParser() Parser {
+	return func(msg *message.Segment) PatternParsed {
+		parsed := PatternParsed{
+			value: nil,
+			msg:   msg,
+		}
+		switch {
+		case msg.Data["text"] != "":
+			parsed.value = msg.Data["text"]
+		case msg.Data["qq"] != "":
+			parsed.value = msg.Data["qq"]
+		case msg.Data["file"] != "":
+			parsed.value = msg.Data["file"]
+		case msg.Data["id"] != "":
+			parsed.value = msg.Data["id"]
+		default:
+			parsed.value = msg.Data
+		}
+		return parsed
+	}
+}
+
+func (s *PatternSegment) matchType(msg message.Segment) bool {
+	return s.typ == msg.Type || s.typ == "any"
+}
+func mustMatchAllPatterns(pattern Pattern) bool {
+	for _, p := range pattern.segments {
+		if p.optional {
+			return false
+		}
+	}
+	return true
+}
+func patternMatch(ctx *Ctx, pattern Pattern, msgs []message.Segment) bool {
+	if mustMatchAllPatterns(pattern) && len(pattern.segments) != len(msgs) {
+		return false
+	}
+	patternState := make([]PatternParsed, len(pattern.segments))
+
+	j := 0
+	for i := range pattern.segments {
+		if j < len(msgs) && pattern.segments[i].matchType(msgs[j]) {
+			patternState[i] = pattern.segments[i].parse(&msgs[j])
+		}
+		if patternState[i].value == nil {
+			if pattern.segments[i].optional {
+				continue
+			}
+			return false
+		}
+		j++
+	}
+	ctx.State[KeyPattern] = patternState
+	return true
+}