main_test.go

@@ -1,205 +1,97 @@
 package main
 
 import (
-	"strings"
 	"testing"
 )
 
-// type Type int
+type Type int
-
-// const (
-// 	TypeUnknown Type = iota
-
-// 	TypeNode
-// 	TypeText
-// 	TypeAttribute
-// )
-
-// // type Attribute struct {
-// // 	Name  []rune
-// // 	Value []rune
-// // }
-
-// type Node struct {
-// 	Parent   *Node
-// 	Children []*Node
-
-// 	Attributes []*Node
-
-// 	Name  []rune
-// 	Value []rune
-
-// 	Type Type
-// }
-
-type Selection int
 
 const (
-	SelUnknown     Selection = iota
+	TypeChild Type = iota
-	SelRoot                  // 根节点
+	TypeChildren
-	SelSelf                  // 自身
+	TypeAllChildren
-	SelParent                // 父节点
-	SelChildren              // 孩子
-	SelAllChildRen           // 所有子孙
-	SelMethod                // 函数类型
-	SelAttribute             // 属性
 )
 
-type Predicates struct {
-	Name []rune
-}
-
 type Node struct {
-	Name  []rune // Axis
+	Prev *Node
-	Value []rune // Name(Axis)::Value
+	Next *Node
-	Next  *Node
+	Name []rune
-	Sel   Selection
+	Type Type
-	Pred  []*Predicates
 }
 
-// compile 编译
+// func extractPath(cur *Node) string {
-func compile(spath string) (head *Node, tail *Node) {
+// 	var path []byte
-	var path []rune = []rune(strings.TrimSpace(spath))
+
+// 	if cur.Next.Next == nil {
+// 		return "/"
+// 	}
+
+// 	for ; cur != nil; cur = cur.Next {
+// 		path = append(path, cur.Name...)
+// 		if cur.Next.Next == nil {
+// 			break
+// 		}
+// 		path = append(path, '/')
+// 	}
+// 	return string(path)
+// }
+
+func toString(root *Node) string {
+	var content string
+
+	for root != nil {
+
+		content += string(root.Name)
+		if root.Type == TypeAllChildren {
+			content += "//"
+		} else {
+			content += "/"
+		}
+		root = root.Next
+	}
+
+	return content
+}
+
+func xPath(spath string) string {
+
+	var path []rune = []rune(spath)
 	path = append(path, ' ')
 
-	var cur *Node
+	root := &Node{}
-	if path[0] == '/' {
+	cur := root
-		head = &Node{}
-		head.Sel = SelRoot
-		head.Next = cur
-	} else {
-		head = cur
-	}
 
-	// for i := 0; i < len(spath); i++ {
+	for i := 0; i < len(spath); i++ {
-	var i = 0
-	c := path[i]
-	switch c {
-	case '/':
-		if path[i+1] == '/' {
-			i++
-			head.Sel = SelAllChildRen
-		} else {
-			head.Sel = SelChildren
-		}
-	case '.':
-		head.Sel = SelSelf
-	case '(':
-		// 进入递归
-		i++
-		start, end := getBrackets(path, len(spath), &i)
-		h, t := compile(string(path[start:end]))
-		cur.Next = h
-		cur = t
-	case '|':
-		// 递归
-	default:
-		head.Sel = SelUnknown
-	}
-
-	return head, cur
-}
-
-func getPredicates(path []rune, limit int, ii *int, cur *Node) []*Predicates {
-	return nil
-}
-
-func getAxes(path []rune, limit int, ii *int, cur *Node) {
-	i := *ii
-
-	for ; i < limit; i++ {
 		c := path[i]
 		switch c {
-		case '[':
-			cur.Pred = getPredicates(path, limit, ii, cur)
-			return
 		case '/':
-			return
+			if path[i+1] == '/' {
-		case ':':
+				cur.Type = TypeAllChildren
-			if path[i+1] == ':' {
 				i++
-
-				return
-			}
-			panic("':' error")
-		case '@': //
-			cur.Sel = SelAttribute
-			cur.Name = getAttributeName(path, limit, ii)
-		case '.': // 获取节点
-			if path[i+1] == '.' {
-				i++
-				cur.Sel = SelParent
 			} else {
-				cur.Sel = SelSelf
+				cur.Type = TypeChild
 			}
-			return
+
-		case '(': // function
+			if len(cur.Name) == 0 {
-			s, e := getBrackets(path, limit, ii)
+				continue
-			cur.Value = path[s:e]
+			}
-			cur.Sel = SelMethod
+
-			return
+			cur.Next = &Node{Prev: cur}
-		case '\\': // 转义
+			cur = cur.Next
-			i++
+		// case '(': 先拿括号
-			fallthrough
+
 		default:
 			cur.Name = append(cur.Name, c)
 		}
 	}
-}
 
-func getAttributeName(path []rune, limit int, ii *int) []rune {
+	return toString(root)
-	i := *ii
-	for start := i; i < limit; i++ {
-		if c, ok := Escape(path, &i); !ok {
-			switch {
-			case c >= ' ' && c <= '/':
-				fallthrough
-			case c >= ':' && c <= '@':
-				fallthrough
-			case c >= '[' && c <= '`':
-				fallthrough
-			case c >= '{' && c <= '~':
-				return path[start:i]
-			default:
-				panic("get attribute error")
-			}
-		}
-	}
-	panic("get attribute error")
-}
-
-func getBrackets(path []rune, limit int, ii *int) (start int, end int) {
-	i := *ii
-	open := 1
-	for start := i; i < limit; i++ {
-		if c, ok := Escape(path, &i); !ok {
-			switch c {
-			case '(':
-				open++
-			case ')':
-				open--
-			}
-			if open == 0 {
-				return start, i
-			}
-		}
-	}
-	panic("can't find ')' close?")
-}
-
-// Escape
-func Escape(data []rune, i *int) (rune, bool) {
-	if data[*i] == '\\' {
-		*i++
-		return data[*i], true
-	}
-	return data[*i], false
 }
 
 func TestMain(t *testing.T) {
-	t.Error(compile("/a/../../b/../c//.//"))
+	// t.Error(xPath("/a/../../b/../c//.//"))
 	// 	t.Error(xPath("/a/./b/../../c/"))
 	// 	t.Error(xPath("/"))
-	// t.Error(xPath("/a/./b/../../c/"))
+	t.Error(xPath("/a/./b/../../c/"))
 	// t.Error(xPath("/a//b////c/d//././/.."))
 }