Merge lp:~brice-figureau/xmlpath/namespace-support into lp:xmlpath

[Brice figureau]

This patch provides xml namespace support to the xmlpath library.

Unmerged revisions

5. By <email address hidden> on 2014-02-18

Experimental support for XML Namespaces

This patch adds support for XML Namespaces. The user
needs to submit the list of known Namespaces during
the path compilation.

=== modified file 'all_test.go'
--- all_test.go	2013-06-14 04:31:38 +0000
+++ all_test.go	2014-02-18 18:51:14 +0000
@@ -279,6 +279,79 @@
 </library>
 `)
 
+func (s *BasicSuite) TestNamespace(c *C) {
+	node, err := xmlpath.Parse(bytes.NewBuffer(namespaceXml))
+	c.Assert(err, IsNil)
+	for _, test := range namespaceTable {
+		cmt := Commentf("xml path: %s", test.path)
+		path, err := xmlpath.CompileWithNamespace(test.path, namespaces)
+		if want, ok := test.result.(cerror); ok {
+			c.Assert(err, ErrorMatches, string(want), cmt)
+			c.Assert(path, IsNil, cmt)
+			continue
+		}
+		c.Assert(err, IsNil)
+		switch want := test.result.(type) {
+		case string:
+			got, ok := path.String(node)
+			c.Assert(ok, Equals, true, cmt)
+			c.Assert(got, Equals, want, cmt)
+			c.Assert(path.Exists(node), Equals, true, cmt)
+			iter := path.Iter(node)
+			iter.Next()
+			node := iter.Node()
+			c.Assert(node.String(), Equals, want, cmt)
+			c.Assert(string(node.Bytes()), Equals, want, cmt)
+		case []string:
+			var alls []string
+			var allb []string
+			iter := path.Iter(node)
+			for iter.Next() {
+				alls = append(alls, iter.Node().String())
+				allb = append(allb, string(iter.Node().Bytes()))
+			}
+			c.Assert(alls, DeepEquals, want, cmt)
+			c.Assert(allb, DeepEquals, want, cmt)
+			s, sok := path.String(node)
+			b, bok := path.Bytes(node)
+			if len(want) == 0 {
+				c.Assert(sok, Equals, false, cmt)
+				c.Assert(bok, Equals, false, cmt)
+				c.Assert(s, Equals, "")
+				c.Assert(b, IsNil)
+			} else {
+				c.Assert(sok, Equals, true, cmt)
+				c.Assert(bok, Equals, true, cmt)
+				c.Assert(s, Equals, alls[0], cmt)
+				c.Assert(string(b), Equals, alls[0], cmt)
+				c.Assert(path.Exists(node), Equals, true, cmt)
+			}
+		case exists:
+			wantb := bool(want)
+			ok := path.Exists(node)
+			c.Assert(ok, Equals, wantb, cmt)
+			_, ok = path.String(node)
+			c.Assert(ok, Equals, wantb, cmt)
+		}
+	}
+}
+
+var namespaceXml = []byte(`<s:Envelope xml:lang="en-US" xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:w="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd" xmlns:rsp="http://schemas.microsoft.com/wbem/wsman/1/windows/shell" xmlns:p="http://schemas.microsoft.com/wbem/wsman/1/wsman.xsd"><s:Header><a:Action>http://schemas.microsoft.com/wbem/wsman/1/windows/shell/ReceiveResponse</a:Action><a:MessageID>uuid:AAD46BD4-6315-4C3C-93D4-94A55773287D</a:MessageID><a:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:To><a:RelatesTo>uuid:18A52A06-9027-41DC-8850-3F244595AF62</a:RelatesTo></s:Header><s:Body><rsp:ReceiveResponse><rsp:Stream Name="stdout" CommandId="1A6DEE6B-EC68-4DD6-87E9-030C0048ECC4">VGhhdCdzIGFsbCBmb2xrcyEhIQ==</rsp:Stream><rsp:Stream Name="stderr" CommandId="1A6DEE6B-EC68-4DD6-87E9-030C0048ECC4">VGhpcyBpcyBzdGRlcnIsIEknbSBwcmV0dHkgc3VyZSE=</rsp:Stream><rsp:CommandState CommandId="1A6DEE6B-EC68-4DD6-87E9-030C0048ECC4" State="http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Running"></rsp:CommandState></rsp:ReceiveResponse></s:Body></s:Envelope>`)
+
+var namespaces = []xmlpath.Namespace {
+	{ "a", "http://schemas.xmlsoap.org/ws/2004/08/addressing" },
+	{ "rsp", "http://schemas.microsoft.com/wbem/wsman/1/windows/shell" },
+}
+
+var namespaceTable = []struct{ path string; result interface{} }{
+	{ "//a:To", "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous" },
+	{ "//rsp:Stream[@Name='stdout']", "VGhhdCdzIGFsbCBmb2xrcyEhIQ==" },
+	{ "//rsp:CommandState/@CommandId", "1A6DEE6B-EC68-4DD6-87E9-030C0048ECC4" },
+	{ "//*[@State='http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done']", exists(false) },
+	{ "//rsp:Stream", []string{ "VGhhdCdzIGFsbCBmb2xrcyEhIQ==", "VGhpcyBpcyBzdGRlcnIsIEknbSBwcmV0dHkgc3VyZSE=" }},
+	{ "//s:Header", cerror(`.*: unknown namespace prefix: s`) },
+}
+
 func (s *BasicSuite) BenchmarkParse(c *C) {
 	for i := 0; i < c.N; i++ {
 		_, err := xmlpath.Parse(bytes.NewBuffer(instancesXml))
 
=== modified file 'doc.go'
--- doc.go	2013-06-07 19:21:41 +0000
+++ doc.go	2014-02-18 18:51:14 +0000
@@ -17,7 +17,8 @@
 //     - All node types except for namespace are supported
 //     - Predicates are restricted to [N], [path], and [path=literal] forms
 //     - Only a single predicate is supported per path step
-//     - Richer expressions and namespaces are not supported
+//     - Namespaces are experimentally supported
+//     - Richer expressions
 //
 // For example, assuming the following document:
 //
@@ -70,4 +71,25 @@
 //             fmt.Println("Found:", value)
 //     }
 //
+// To use xmlpath with namespaces, it is required to give the supported set of namespace
+// when compiling:
+// 
+// 
+//    var namespaces = []xmlpath.Namespace {
+//        { "s", "http://www.w3.org/2003/05/soap-envelope" },
+//        { "a", "http://schemas.xmlsoap.org/ws/2004/08/addressing" },
+//    }
+//    path, err := xmlpath.CompileWithNamespace("/s:Header/a:To", namespaces)
+//    if err != nil {
+//            log.Fatal(err)
+//    }
+//    root, err := xmlpath.Parse(file)
+//    if err != nil {
+//            log.Fatal(err)
+//    }
+//    if value, ok := path.String(root); ok {
+//            fmt.Println("Found:", value)
+//    }
+// 
+
 package xmlpath
 
=== modified file 'path.go'
--- path.go	2013-06-07 19:21:41 +0000
+++ path.go	2014-02-18 18:51:14 +0000
@@ -6,6 +6,12 @@
 	"unicode/utf8"
 )
 
+// Namespace represents a given XML Namespace
+type Namespace struct {
+	Prefix string
+	Uri    string
+}
+
 // Path is a compiled path that can be applied to a context
 // node to obtain a matching node set.
 // A single Path can be applied concurrently to any number
@@ -339,17 +345,19 @@
 }
 
 type pathStep struct {
-	root bool
-	axis string
-	name string
-	kind nodeKind
-	pred *pathPredicate
+	root   bool
+	axis   string
+	name   string
+	prefix string
+	uri    string
+	kind   nodeKind
+	pred   *pathPredicate
 }
 
 func (step *pathStep) match(node *Node) bool {
 	return node.kind != endNode &&
 		(step.kind == anyNode || step.kind == node.kind) &&
-		(step.name == "*" || node.name.Local == step.name)
+		(step.name == "*" || (node.name.Local == step.name && (node.name.Space != "" && node.name.Space == step.uri || node.name.Space == "")))
 }
 
 // MustCompile returns the compiled path, and panics if
@@ -364,7 +372,20 @@
 
 // Compile returns the compiled path.
 func Compile(path string) (*Path, error) {
-	c := pathCompiler{path, 0}
+	c := pathCompiler{path, 0, []Namespace{} }
+	if path == "" {
+		return nil, c.errorf("empty path")
+	}
+	p, err := c.parsePath()
+	if err != nil {
+		return nil, err
+	}
+	return p, nil
+}
+
+// Compile the path with the knowledge of the given namespaces
+func CompileWithNamespace(path string, ns []Namespace) (*Path, error) {
+	c := pathCompiler{path, 0, ns}
 	if path == "" {
 		return nil, c.errorf("empty path")
 	}
@@ -378,6 +399,7 @@
 type pathCompiler struct {
 	path  string
 	i     int
+	ns	  []Namespace
 }
 
 func (c *pathCompiler) errorf(format string, args ...interface{}) error {
@@ -425,26 +447,45 @@
 			} else {
 				if c.skipByte(':') {
 					if !c.skipByte(':') {
-						return nil, c.errorf("missing ':'")
-					}
-					switch step.name {
-					case "attribute":
-						step.kind = attrNode
-					case "self", "child", "parent":
-					case "descendant", "descendant-or-self":
-					case "ancestor", "ancestor-or-self":
-					case "following", "following-sibling":
-					case "preceding", "preceding-sibling":
-					default:
-						return nil, c.errorf("unsupported axis: %q", step.name)
-					}
-					step.axis = step.name
+						mark = c.i
+						if c.skipName() {
+							step.prefix = step.name
+							step.name = c.path[mark:c.i]
+							// check prefix
+							found := false
+							for _, ns := range c.ns {
+								if ns.Prefix == step.prefix {
+									step.uri = ns.Uri
+									found = true
+									break
+								}
+							}
+							if !found {
+								return nil, c.errorf("unknown namespace prefix: %s", step.prefix)
+							}
+						} else {
+							return nil, c.errorf("missing name after namespace prefix")
+						}
+					} else {
+						switch step.name {
+						case "attribute":
+							step.kind = attrNode
+						case "self", "child", "parent":
+						case "descendant", "descendant-or-self":
+						case "ancestor", "ancestor-or-self":
+						case "following", "following-sibling":
+						case "preceding", "preceding-sibling":
+						default:
+							return nil, c.errorf("unsupported axis: %q", step.name)
+						}
+						step.axis = step.name
 
-					mark = c.i
-					if !c.skipName() {
-						return nil, c.errorf("missing name")
+						mark = c.i
+						if !c.skipName() {
+							return nil, c.errorf("missing name")
+						}
+						step.name = c.path[mark:c.i]
 					}
-					step.name = c.path[mark:c.i]
 				}
 				if c.skipByte('(') {
 					conflict := step.kind != anyNode