Simplify matcher
diff --git a/matcher/matcher.go b/matcher/matcher.go
index 3b496b2..1630b1a 100644
--- a/matcher/matcher.go
+++ b/matcher/matcher.go
@@ -93,109 +93,61 @@
return &ast.Token{Wrap: wrap}
}
- // If this node matches the pattern
- if m.Match(node) {
- // For TermGroups that contain a matching Term, preserve unmatched operands
- if tg, ok := node.(*ast.TermGroup); ok {
- // Check if any operand matches the pattern exactly
- hasExactMatch := false
- for _, op := range tg.Operands {
- if m.matchNode(op, m.pattern.Root) {
- hasExactMatch = true
- break
- }
- }
-
- // If we have an exact match, replace matching operands
- if hasExactMatch {
- hasMatch := false
- newOperands := make([]ast.Node, 0, len(tg.Operands))
- for _, op := range tg.Operands {
- if m.matchNode(op, m.pattern.Root) {
- if !hasMatch {
- newOperands = append(newOperands, m.cloneNode(m.replacement.Root))
- hasMatch = true
- } else {
- newOperands = append(newOperands, m.replaceNode(op))
- }
- } else {
- newOperands = append(newOperands, m.replaceNode(op))
- }
- }
- return &ast.TermGroup{
- Operands: newOperands,
- Relation: tg.Relation,
- }
- }
- // Otherwise, replace the entire TermGroup
- return m.cloneNode(m.replacement.Root)
- }
- // For other nodes, return the replacement
- return m.cloneNode(m.replacement.Root)
- }
-
- // Otherwise recursively process children
- switch n := node.(type) {
- case *ast.TermGroup:
- // Check if any operand matches the pattern exactly
- hasExactMatch := false
- for _, op := range n.Operands {
- if m.matchNode(op, m.pattern.Root) {
- hasExactMatch = true
- break
+ // Handle TermGroup nodes
+ if tg, ok := node.(*ast.TermGroup); ok {
+ // Check if any operand matches the pattern
+ hasMatch := false
+ newOperands := make([]ast.Node, 0, len(tg.Operands))
+ for _, op := range tg.Operands {
+ if !hasMatch && m.matchNode(op, m.pattern.Root) {
+ newOperands = append(newOperands, m.cloneNode(m.replacement.Root))
+ hasMatch = true
+ } else {
+ newOperands = append(newOperands, m.replaceNode(op))
}
}
-
- // If we have an exact match, replace matching operands
- if hasExactMatch {
- hasMatch := false
- newOperands := make([]ast.Node, 0, len(n.Operands))
- for _, op := range n.Operands {
- if m.matchNode(op, m.pattern.Root) {
- if !hasMatch {
- newOperands = append(newOperands, m.cloneNode(m.replacement.Root))
- hasMatch = true
- } else {
- newOperands = append(newOperands, m.replaceNode(op))
- }
- } else {
- newOperands = append(newOperands, m.replaceNode(op))
- }
- }
+ // If we found a match, return the modified TermGroup
+ if hasMatch {
return &ast.TermGroup{
Operands: newOperands,
- Relation: n.Relation,
+ Relation: tg.Relation,
}
}
- // Otherwise, recursively process operands
- newOperands := make([]ast.Node, len(n.Operands))
- for i, op := range n.Operands {
- newOperands[i] = m.replaceNode(op)
+ // If this TermGroup matches the pattern exactly, replace it
+ if m.matchNode(node, m.pattern.Root) {
+ return m.cloneNode(m.replacement.Root)
}
+ // Otherwise, return the modified TermGroup
return &ast.TermGroup{
Operands: newOperands,
- Relation: n.Relation,
+ Relation: tg.Relation,
}
+ }
- case *ast.CatchallNode:
+ // Handle CatchallNode nodes
+ if c, ok := node.(*ast.CatchallNode); ok {
newNode := &ast.CatchallNode{
- NodeType: n.NodeType,
- RawContent: n.RawContent,
+ NodeType: c.NodeType,
+ RawContent: c.RawContent,
}
- if n.Wrap != nil {
- newNode.Wrap = m.replaceNode(n.Wrap)
+ if c.Wrap != nil {
+ newNode.Wrap = m.replaceNode(c.Wrap)
}
- if len(n.Operands) > 0 {
- newNode.Operands = make([]ast.Node, len(n.Operands))
- for i, op := range n.Operands {
+ if len(c.Operands) > 0 {
+ newNode.Operands = make([]ast.Node, len(c.Operands))
+ for i, op := range c.Operands {
newNode.Operands[i] = m.replaceNode(op)
}
}
return newNode
-
- default:
- return node
}
+
+ // If this node matches the pattern exactly, replace it
+ if m.matchNode(node, m.pattern.Root) {
+ return m.cloneNode(m.replacement.Root)
+ }
+
+ return node
}
// simplifyNode removes unnecessary wrappers and empty nodes
@@ -276,120 +228,97 @@
return false
}
- // Handle pattern being a Token
- if pToken, ok := pattern.(*ast.Token); ok {
- if nToken, ok := node.(*ast.Token); ok {
- return m.matchNode(nToken.Wrap, pToken.Wrap)
- }
- return false
+ // Handle wrapped nodes (Token and CatchallNode)
+ if m.tryMatchWrapped(node, pattern) {
+ return true
}
- // Handle pattern being a Term
- if pTerm, ok := pattern.(*ast.Term); ok {
- // Direct term to term matching
- if t, ok := node.(*ast.Term); ok {
- return t.Foundry == pTerm.Foundry &&
- t.Key == pTerm.Key &&
- t.Layer == pTerm.Layer &&
- t.Match == pTerm.Match &&
- (pTerm.Value == "" || t.Value == pTerm.Value)
+ switch p := pattern.(type) {
+ case *ast.Token:
+ if n, ok := node.(*ast.Token); ok {
+ return m.matchNode(n.Wrap, p.Wrap)
}
- // If node is a Token, check its wrap
- if tkn, ok := node.(*ast.Token); ok {
- if tkn.Wrap == nil {
- return false
- }
- return m.matchNode(tkn.Wrap, pattern)
- }
- // If node is a TermGroup, check its operands
- if tg, ok := node.(*ast.TermGroup); ok {
- for _, op := range tg.Operands {
- if m.matchNode(op, pattern) {
- return true
- }
- }
- return false
- }
- // If node is a CatchallNode, check its wrap and operands
- if c, ok := node.(*ast.CatchallNode); ok {
- if c.Wrap != nil && m.matchNode(c.Wrap, pattern) {
- return true
- }
- for _, op := range c.Operands {
- if m.matchNode(op, pattern) {
- return true
- }
- }
- return false
- }
- return false
- }
- // Handle pattern being a TermGroup
- if pGroup, ok := pattern.(*ast.TermGroup); ok {
- // For OR relations, check if any operand matches the node
- if pGroup.Relation == ast.OrRelation {
- for _, pOp := range pGroup.Operands {
+ case *ast.Term:
+ return m.matchTerm(node, p)
+
+ case *ast.TermGroup:
+ if p.Relation == ast.OrRelation {
+ // For OR relations, check if any operand matches
+ for _, pOp := range p.Operands {
if m.matchNode(node, pOp) {
return true
}
}
- return false
+ } else if tg, ok := node.(*ast.TermGroup); ok && tg.Relation == p.Relation {
+ // For AND relations, all pattern operands must match in any order
+ return m.matchAndTermGroup(tg, p)
}
-
- // For AND relations, node must be a TermGroup with matching relation
- if tg, ok := node.(*ast.TermGroup); ok {
- if tg.Relation != pGroup.Relation {
- return false
- }
- // Check that all pattern operands match in any order
- if len(tg.Operands) < len(pGroup.Operands) {
- return false
- }
- matched := make([]bool, len(tg.Operands))
- for _, pOp := range pGroup.Operands {
- found := false
- for j, tOp := range tg.Operands {
- if !matched[j] && m.matchNode(tOp, pOp) {
- matched[j] = true
- found = true
- break
- }
- }
- if !found {
- return false
- }
- }
- return true
- }
-
- // If node is a Token, check its wrap
- if tkn, ok := node.(*ast.Token); ok {
- if tkn.Wrap == nil {
- return false
- }
- return m.matchNode(tkn.Wrap, pattern)
- }
-
- // If node is a CatchallNode, check its wrap and operands
- if c, ok := node.(*ast.CatchallNode); ok {
- if c.Wrap != nil && m.matchNode(c.Wrap, pattern) {
- return true
- }
- for _, op := range c.Operands {
- if m.matchNode(op, pattern) {
- return true
- }
- }
- return false
- }
-
- return false
}
return false
}
+// tryMatchWrapped attempts to match a node that might wrap other nodes
+func (m *Matcher) tryMatchWrapped(node, pattern ast.Node) bool {
+ switch n := node.(type) {
+ case *ast.Token:
+ if n.Wrap != nil {
+ return m.matchNode(n.Wrap, pattern)
+ }
+ case *ast.CatchallNode:
+ if n.Wrap != nil && m.matchNode(n.Wrap, pattern) {
+ return true
+ }
+ for _, op := range n.Operands {
+ if m.matchNode(op, pattern) {
+ return true
+ }
+ }
+ case *ast.TermGroup:
+ for _, op := range n.Operands {
+ if m.matchNode(op, pattern) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// matchTerm checks if a node matches a term pattern
+func (m *Matcher) matchTerm(node ast.Node, pattern *ast.Term) bool {
+ if t, ok := node.(*ast.Term); ok {
+ return t.Foundry == pattern.Foundry &&
+ t.Key == pattern.Key &&
+ t.Layer == pattern.Layer &&
+ t.Match == pattern.Match &&
+ (pattern.Value == "" || t.Value == pattern.Value)
+ }
+ return m.tryMatchWrapped(node, pattern)
+}
+
+// matchAndTermGroup checks if a TermGroup matches an AND pattern
+func (m *Matcher) matchAndTermGroup(node *ast.TermGroup, pattern *ast.TermGroup) bool {
+ if len(node.Operands) < len(pattern.Operands) {
+ return false
+ }
+ matched := make([]bool, len(node.Operands))
+ for _, pOp := range pattern.Operands {
+ found := false
+ for j, tOp := range node.Operands {
+ if !matched[j] && m.matchNode(tOp, pOp) {
+ matched[j] = true
+ found = true
+ break
+ }
+ }
+ if !found {
+ return false
+ }
+ }
+ return true
+}
+
// cloneNode creates a deep copy of a node
func (m *Matcher) cloneNode(node ast.Node) ast.Node {
if node == nil {