271 lines
7.1 KiB
Go
271 lines
7.1 KiB
Go
package processor
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"modify/processor/xpath"
|
|
"strings"
|
|
|
|
"github.com/antchfx/xmlquery"
|
|
lua "github.com/yuin/gopher-lua"
|
|
)
|
|
|
|
// XMLProcessor implements the Processor interface for XML documents
|
|
type XMLProcessor struct{}
|
|
|
|
// ProcessContent implements the Processor interface for XMLProcessor
|
|
func (p *XMLProcessor) ProcessContent(content string, path string, luaExpr string) (string, int, int, error) {
|
|
// Parse XML document
|
|
// We can't really use encoding/xml here because it requires a pre defined struct
|
|
// And we HAVE TO parse dynamic unknown XML
|
|
doc, err := xmlquery.Parse(strings.NewReader(content))
|
|
if err != nil {
|
|
return content, 0, 0, fmt.Errorf("error parsing XML: %v", err)
|
|
}
|
|
|
|
// Find nodes matching the XPath pattern
|
|
nodes, err := xpath.Get(doc, path)
|
|
if err != nil {
|
|
return content, 0, 0, fmt.Errorf("error executing XPath: %v", err)
|
|
}
|
|
|
|
matchCount := len(nodes)
|
|
if matchCount == 0 {
|
|
return content, 0, 0, nil
|
|
}
|
|
|
|
// Apply modifications to each node
|
|
modCount := 0
|
|
for _, node := range nodes {
|
|
L, err := NewLuaState()
|
|
if err != nil {
|
|
return content, 0, 0, fmt.Errorf("error creating Lua state: %v", err)
|
|
}
|
|
defer L.Close()
|
|
|
|
err = p.ToLua(L, node)
|
|
if err != nil {
|
|
return content, modCount, matchCount, fmt.Errorf("error converting to Lua: %v", err)
|
|
}
|
|
|
|
err = L.DoString(BuildLuaScript(luaExpr))
|
|
if err != nil {
|
|
return content, modCount, matchCount, fmt.Errorf("error executing Lua: %v", err)
|
|
}
|
|
|
|
result, err := p.FromLua(L)
|
|
if err != nil {
|
|
return content, modCount, matchCount, fmt.Errorf("error getting result from Lua: %v", err)
|
|
}
|
|
log.Printf("%#v", result)
|
|
|
|
modified := false
|
|
modified = L.GetGlobal("modified").String() == "true"
|
|
if !modified {
|
|
log.Printf("No changes made to node at path: %s", node.Data)
|
|
continue
|
|
}
|
|
|
|
// Apply modification based on the result
|
|
if updatedValue, ok := result.(string); ok {
|
|
// If the result is a simple string, update the node value directly
|
|
xpath.Set(doc, path, updatedValue)
|
|
} else if nodeData, ok := result.(map[string]interface{}); ok {
|
|
// If the result is a map, apply more complex updates
|
|
updateNodeFromMap(node, nodeData)
|
|
}
|
|
|
|
modCount++
|
|
}
|
|
|
|
// Serialize the modified XML document to string
|
|
if doc.FirstChild != nil && doc.FirstChild.Type == xmlquery.DeclarationNode {
|
|
// If we have an XML declaration, start with it
|
|
declaration := doc.FirstChild.OutputXML(true)
|
|
// Remove the firstChild (declaration) before serializing the rest of the document
|
|
doc.FirstChild = doc.FirstChild.NextSibling
|
|
return declaration + doc.OutputXML(true), modCount, matchCount, nil
|
|
}
|
|
|
|
return doc.OutputXML(true), modCount, matchCount, nil
|
|
}
|
|
|
|
// ToLua converts XML node values to Lua variables
|
|
func (p *XMLProcessor) ToLua(L *lua.LState, data interface{}) error {
|
|
// Check if data is an xmlquery.Node
|
|
node, ok := data.(*xmlquery.Node)
|
|
if !ok {
|
|
return fmt.Errorf("expected xmlquery.Node, got %T", data)
|
|
}
|
|
|
|
// Create a simple table with essential data
|
|
table := L.NewTable()
|
|
|
|
// For element nodes, just provide basic info
|
|
L.SetField(table, "type", lua.LString(nodeTypeToString(node.Type)))
|
|
L.SetField(table, "name", lua.LString(node.Data))
|
|
L.SetField(table, "value", lua.LString(node.InnerText()))
|
|
|
|
// Add attributes if any
|
|
if len(node.Attr) > 0 {
|
|
attrs := L.NewTable()
|
|
for _, attr := range node.Attr {
|
|
L.SetField(attrs, attr.Name.Local, lua.LString(attr.Value))
|
|
}
|
|
L.SetField(table, "attr", attrs)
|
|
}
|
|
|
|
L.SetGlobal("v", table)
|
|
return nil
|
|
}
|
|
|
|
// FromLua gets modified values from Lua
|
|
func (p *XMLProcessor) FromLua(L *lua.LState) (interface{}, error) {
|
|
luaValue := L.GetGlobal("v")
|
|
|
|
// Handle string values directly
|
|
if luaValue.Type() == lua.LTString {
|
|
return luaValue.String(), nil
|
|
}
|
|
|
|
// Handle tables (for attributes and more complex updates)
|
|
if luaValue.Type() == lua.LTTable {
|
|
return luaTableToMap(L, luaValue.(*lua.LTable)), nil
|
|
}
|
|
|
|
return luaValue.String(), nil
|
|
}
|
|
|
|
// Simple helper to convert a Lua table to a Go map
|
|
func luaTableToMap(L *lua.LState, table *lua.LTable) map[string]interface{} {
|
|
result := make(map[string]interface{})
|
|
|
|
table.ForEach(func(k, v lua.LValue) {
|
|
if k.Type() == lua.LTString {
|
|
key := k.String()
|
|
|
|
if v.Type() == lua.LTTable {
|
|
result[key] = luaTableToMap(L, v.(*lua.LTable))
|
|
} else {
|
|
result[key] = v.String()
|
|
}
|
|
}
|
|
})
|
|
|
|
return result
|
|
}
|
|
|
|
// Simple helper to convert node type to string
|
|
func nodeTypeToString(nodeType xmlquery.NodeType) string {
|
|
switch nodeType {
|
|
case xmlquery.ElementNode:
|
|
return "element"
|
|
case xmlquery.TextNode:
|
|
return "text"
|
|
case xmlquery.AttributeNode:
|
|
return "attribute"
|
|
default:
|
|
return "other"
|
|
}
|
|
}
|
|
|
|
// Helper function to update an XML node from a map
|
|
func updateNodeFromMap(node *xmlquery.Node, data map[string]interface{}) {
|
|
// Update node value if present
|
|
if value, ok := data["value"]; ok {
|
|
if strValue, ok := value.(string); ok {
|
|
// For element nodes, replace text content
|
|
if node.Type == xmlquery.ElementNode {
|
|
// Find the first text child if it exists
|
|
var textNode *xmlquery.Node
|
|
for child := node.FirstChild; child != nil; child = child.NextSibling {
|
|
if child.Type == xmlquery.TextNode {
|
|
textNode = child
|
|
break
|
|
}
|
|
}
|
|
|
|
if textNode != nil {
|
|
// Update existing text node
|
|
textNode.Data = strValue
|
|
} else {
|
|
// Create new text node
|
|
newText := &xmlquery.Node{
|
|
Type: xmlquery.TextNode,
|
|
Data: strValue,
|
|
Parent: node,
|
|
}
|
|
|
|
// Insert at beginning of children
|
|
if node.FirstChild != nil {
|
|
newText.NextSibling = node.FirstChild
|
|
node.FirstChild.PrevSibling = newText
|
|
node.FirstChild = newText
|
|
} else {
|
|
node.FirstChild = newText
|
|
node.LastChild = newText
|
|
}
|
|
}
|
|
} else if node.Type == xmlquery.TextNode {
|
|
// Directly update text node
|
|
node.Data = strValue
|
|
} else if node.Type == xmlquery.AttributeNode {
|
|
// Update attribute value
|
|
if node.Parent != nil {
|
|
for i, attr := range node.Parent.Attr {
|
|
if attr.Name.Local == node.Data {
|
|
node.Parent.Attr[i].Value = strValue
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update attributes if present
|
|
if attrs, ok := data["attr"].(map[string]interface{}); ok && node.Type == xmlquery.ElementNode {
|
|
for name, value := range attrs {
|
|
if strValue, ok := value.(string); ok {
|
|
// Look for existing attribute
|
|
found := false
|
|
for i, attr := range node.Attr {
|
|
if attr.Name.Local == name {
|
|
node.Attr[i].Value = strValue
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// Add new attribute if not found
|
|
if !found {
|
|
node.Attr = append(node.Attr, xmlquery.Attr{
|
|
Name: struct {
|
|
Space, Local string
|
|
}{Local: name},
|
|
Value: strValue,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper function to get a string representation of node type
|
|
func nodeTypeName(nodeType xmlquery.NodeType) string {
|
|
switch nodeType {
|
|
case xmlquery.ElementNode:
|
|
return "element"
|
|
case xmlquery.TextNode:
|
|
return "text"
|
|
case xmlquery.AttributeNode:
|
|
return "attribute"
|
|
case xmlquery.CommentNode:
|
|
return "comment"
|
|
case xmlquery.DeclarationNode:
|
|
return "declaration"
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|