Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 doc.go // Package xml is XML testing package that supports XML comparison utility. // The package consists of ToStruct and StructToXML utils that help sort XML // elements as per their nesting level. ToStruct function converts an XML // document into a sorted tree node structure, while StructToXML converts the // sorted XML nodes into a sorted XML document. SortXML function should be // used to sort an XML document. It can be configured to ignore indentation package xml	469 B	2025-05-25 12:27
📄 sort.go package xml import ( "bytes" "encoding/xml" "io" "strings" ) type xmlAttrSlice []xml.Attr func (x xmlAttrSlice) Len() int { return len(x) } func (x xmlAttrSlice) Less(i, j int) bool { spaceI, spaceJ := x[i].Name.Space, x[j].Name.Space localI, localJ := x[i].Name.Local, x[j].Name.Local valueI, valueJ := x[i].Value, x[j].Value spaceCmp := strings.Compare(spaceI, spaceJ) localCmp := strings.Compare(localI, localJ) valueCmp := strings.Compare(valueI, valueJ) if spaceCmp == -1 \|\| (spaceCmp == 0 && (localCmp == -1 \|\| (localCmp == 0 && valueCmp == -1))) { return true } return false } func (x xmlAttrSlice) Swap(i, j int) { x[i], x[j] = x[j], x[i] } // SortXML sorts the reader's XML elements func SortXML(r io.Reader, ignoreIndentation bool) (string, error) { var buf bytes.Buffer d := xml.NewDecoder(r) root, err := ToStruct(d, nil, ignoreIndentation) if err != nil { return buf.String(), err } e := xml.NewEncoder(&buf) err = StructToXML(e, root, true) return buf.String(), err }	1019 B	2025-05-25 12:27
📄 sort_test.go package xml import ( "bytes" "reflect" "testing" ) func TestSortXML(t *testing.T) { xmlInput := bytes.NewReader([]byte(`<Root><cde>xyz</cde><abc>123</abc><xyz><item>1</item></xyz></Root>`)) sortedXML, err := SortXML(xmlInput, false) expectedsortedXML := `<Root><abc>123</abc><cde>xyz</cde><xyz><item>1</item></xyz></Root>` if err != nil { t.Fatalf("expected no error, got %v", err) } if !reflect.DeepEqual(sortedXML, expectedsortedXML) { t.Errorf("expect match\nexpect: %+v\nactual: %+v\n", expectedsortedXML, sortedXML) } }	542 B	2025-05-25 12:27
📄 xmlToStruct.go package xml import ( "encoding/xml" "fmt" "io" "sort" "strings" ) // A Node contains the values to be encoded or decoded. type Node struct { Name xml.Name `json:",omitempty"` Children map[string][]Node `json:",omitempty"` Text string `json:",omitempty"` Attr []xml.Attr `json:",omitempty"` namespaces map[string]string parent Node } // NewXMLElement returns a pointer to a new Node initialized to default values. func NewXMLElement(name xml.Name) Node { return &Node{ Name: name, Children: map[string][]Node{}, Attr: []xml.Attr{}, } } // AddChild adds child to the Node. func (n Node) AddChild(child Node) { child.parent = n if _, ok := n.Children[child.Name.Local]; !ok { // flattened will have multiple children with same tag name n.Children[child.Name.Local] = []Node{} } n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child) } // ToStruct converts a xml.Decoder stream to Node with nested values. func ToStruct(d xml.Decoder, s xml.StartElement, ignoreIndentation bool) (Node, error) { out := &Node{} for { tok, err := d.Token() if err != nil { if err == io.EOF { break } else { return out, err } } if tok == nil { break } switch typed := tok.(type) { case xml.CharData: text := string(typed.Copy()) if ignoreIndentation { text = strings.TrimSpace(text) } if len(text) != 0 { out.Text = text } case xml.StartElement: el := typed.Copy() out.Attr = el.Attr if out.Children == nil { out.Children = map[string][]Node{} } name := typed.Name.Local slice := out.Children[name] if slice == nil { slice = []Node{} } node, e := ToStruct(d, &el, ignoreIndentation) out.findNamespaces() if e != nil { return out, e } node.Name = typed.Name node.findNamespaces() // Add attributes onto the node node.Attr = el.Attr tempOut := out // Save into a temp variable, simply because out gets squashed during // loop iterations node.parent = &tempOut slice = append(slice, node) out.Children[name] = slice case xml.EndElement: if s != nil && s.Name.Local == typed.Name.Local { // matching end token return out, nil } out = &Node{} } } return out, nil } func (n Node) findNamespaces() { ns := map[string]string{} for _, a := range n.Attr { if a.Name.Space == "xmlns" { ns[a.Value] = a.Name.Local } } n.namespaces = ns } func (n Node) findElem(name string) (string, bool) { for node := n; node != nil; node = node.parent { for _, a := range node.Attr { namespace := a.Name.Space if v, ok := node.namespaces[namespace]; ok { namespace = v } if name == fmt.Sprintf("%s:%s", namespace, a.Name.Local) { return a.Value, true } } } return "", false } // StructToXML writes an Node to a xml.Encoder as tokens. func StructToXML(e xml.Encoder, node Node, sorted bool) error { var err error // Sort Attributes attrs := node.Attr if sorted { sortedAttrs := make([]xml.Attr, len(attrs)) for _, k := range node.Attr { sortedAttrs = append(sortedAttrs, k) } sort.Sort(xmlAttrSlice(sortedAttrs)) attrs = sortedAttrs } st := xml.StartElement{Name: node.Name, Attr: attrs} e.EncodeToken(st) // return fmt.Errorf("encoder string : %s, %s, %s", node.Name.Local, node.Name.Space, st.Attr) if node.Text != "" { e.EncodeToken(xml.CharData([]byte(node.Text))) } else if sorted { sortedNames := []string{} for k := range node.Children { sortedNames = append(sortedNames, k) } sort.Strings(sortedNames) for _, k := range sortedNames { // we should sort the []xml.Node for each key if len >1 flattenedNodes := node.Children[k] // Meaning this has multiple nodes if len(flattenedNodes) > 1 { // sort flattened nodes flattenedNodes, err = sortFlattenedNodes(flattenedNodes) if err != nil { return err } } for _, v := range flattenedNodes { err = StructToXML(e, v, sorted) if err != nil { return err } } } } else { for _, c := range node.Children { for _, v := range c { err = StructToXML(e, v, sorted) if err != nil { return err } } } } e.EncodeToken(xml.EndElement{Name: node.Name}) return e.Flush() } // sortFlattenedNodes sorts nodes with nodes having same element tag // but overall different values. The function will return list of pointer to // Node and an error. // // Overall sort order is followed is: // Nodes with concrete value (no nested node as value) are given precedence // and are added to list after sorting them // // Next nested nodes within a flattened list are given precedence. // // Next nodes within a flattened map are sorted based on either key or value // which ever has lower value and then added to the global sorted list. // If value was initially chosen, but has nested nodes; key will be chosen as comparable // as it is unique and will always have concrete data ie. string. func sortFlattenedNodes(nodes []Node) ([]Node, error) { var sortedNodes []Node // concreteNodeMap stores concrete value associated with a list of nodes // This is possible in case multiple members of a flatList has same values. concreteNodeMap := make(map[string][]Node, 0) // flatListNodeMap stores flat list or wrapped list members associated with a list of nodes // This will have only flattened list with members that are Nodes and not concrete values. flatListNodeMap := make(map[string][]Node, 0) // flatMapNodeMap stores flat map or map entry members associated with a list of nodes // This will have only flattened map concrete value members. It is possible to limit this // to concrete value as map key is expected to be concrete. flatMapNodeMap := make(map[string][]Node, 0) // nodes with concrete value are prioritized and appended based on sorting order sortedNodesWithConcreteValue := []string{} // list with nested nodes are second in priority and appended based on sorting order sortedNodesWithListValue := []string{} // map are last in priority and appended based on sorting order sortedNodesWithMapValue := []string{} for _, node := range nodes { // node has no children element, then we consider it as having concrete value if len(node.Children) == 0 { sortedNodesWithConcreteValue = append(sortedNodesWithConcreteValue, node.Text) if v, ok := concreteNodeMap[node.Text]; ok { concreteNodeMap[node.Text] = append(v, node) } else { concreteNodeMap[node.Text] = []Node{node} } } // if node has a single child, then it is a flattened list node if len(node.Children) == 1 { for _, nestedNodes := range node.Children { nestedNodeName := nestedNodes[0].Name.Local // append to sorted node name for list value sortedNodesWithListValue = append(sortedNodesWithListValue, nestedNodeName) if v, ok := flatListNodeMap[nestedNodeName]; ok { flatListNodeMap[nestedNodeName] = append(v, nestedNodes[0]) } else { flatListNodeMap[nestedNodeName] = []Node{nestedNodes[0]} } } } // if node has two children, then it is a flattened map node if len(node.Children) == 2 { nestedPair := []Node{} for _, k := range node.Children { nestedPair = append(nestedPair, k[0]) } comparableValues := []string{nestedPair[0].Name.Local, nestedPair[1].Name.Local} sort.Strings(comparableValues) comparableValue := comparableValues[0] for _, nestedNode := range nestedPair { if comparableValue == nestedNode.Name.Local && len(nestedNode.Children) != 0 { // if value was selected and is nested node, skip it and use key instead comparableValue = comparableValues[1] continue } // now we are certain there is no nested node if comparableValue == nestedNode.Name.Local { // get chardata for comparison comparableValue = nestedNode.Text sortedNodesWithMapValue = append(sortedNodesWithMapValue, comparableValue) if v, ok := flatMapNodeMap[comparableValue]; ok { flatMapNodeMap[comparableValue] = append(v, node) } else { flatMapNodeMap[comparableValue] = []Node{node} } break } } } // we don't support multiple same name nodes in an xml doc except for in flattened maps, list. if len(node.Children) > 2 { return nodes, fmt.Errorf("malformed xml: multiple nodes with same key name exist, " + "but are not associated with flattened maps (2 children) or list (0 or 1 child)") } } // sort concrete value node name list and append corresponding nodes // to sortedNodes sort.Strings(sortedNodesWithConcreteValue) for _, name := range sortedNodesWithConcreteValue { for _, node := range concreteNodeMap[name] { sortedNodes = append(sortedNodes, node) } } // sort nested nodes with a list and append corresponding nodes // to sortedNodes sort.Strings(sortedNodesWithListValue) for _, name := range sortedNodesWithListValue { // if two nested nodes have same name, then sort them separately. if len(flatListNodeMap[name]) > 1 { // return nodes, fmt.Errorf("flat list node name are %s %v", flatListNodeMap[name][0].Name.Local, len(flatListNodeMap[name])) nestedFlattenedList, err := sortFlattenedNodes(flatListNodeMap[name]) if err != nil { return nodes, err } // append the identical but sorted nodes for _, nestedNode := range nestedFlattenedList { sortedNodes = append(sortedNodes, nestedNode) } } else { // append the sorted nodes sortedNodes = append(sortedNodes, flatListNodeMap[name][0]) } } // sorted nodes with a map and append corresponding nodes to sortedNodes sort.Strings(sortedNodesWithMapValue) for _, name := range sortedNodesWithMapValue { sortedNodes = append(sortedNodes, flatMapNodeMap[name][0]) } return sortedNodes, nil }	9.63 KB	2025-05-25 12:27

Terminal