When using the xpath library with data-formats that know the data-type of a node (e.g. JSON or Protocol buffer it would be nice to have access to this native underlying value. This has the benefit of being able to parse data with unknown a-priori format and/or data-types.

The above can be done by adding an interface

type NodeNavigatorNativeData interface {
	// NativeValue gets the native value of current node.
	NativeValue() interface{}
}

or, alternatively, change the return type of Value() in the NodeNavigator interface. The naming is subject to discussion.

Please let me know what you think and I can submit a PR for either way.

As I mentioned in https://github.com/antchfx/xpath/issues/44, I need reverse() function which is part of xpath 2.0.

I did a quick prototyping. I'd like to have main contributors (@zhengchun ?) take a look to see if I'm completely off or not, before I create a pull request:

Below is the prototype diff (Not many tests added yet). Note the diff is large-ish because I renamed the existing functionQuery to scalarFunctionQuery to differentiate it from my newly added selectFunctionQuery (which currently only has reverse function but I think we can merge unionQuery and logicalQuery into selectFunctionQuery eventually, tell me if I'm crazy)

diff --git a/build.go b/build.go
index be1214c..d6ff928 100644
--- a/build.go
+++ b/build.go
@@ -173,7 +173,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: startwithFunc(arg1, arg2)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: startwithFunc(arg1, arg2)}
 	case "ends-with":
 		arg1, err := b.processNode(root.Args[0])
 		if err != nil {
@@ -183,7 +183,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: endwithFunc(arg1, arg2)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: endwithFunc(arg1, arg2)}
 	case "contains":
 		arg1, err := b.processNode(root.Args[0])
 		if err != nil {
@@ -194,7 +194,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			return nil, err
 		}
 
-		qyOutput = &functionQuery{Input: b.firstInput, Func: containsFunc(arg1, arg2)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: containsFunc(arg1, arg2)}
 	case "substring":
 		//substring( string , start [, length] )
 		if len(root.Args) < 2 {
@@ -215,7 +215,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 				return nil, err
 			}
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: substringFunc(arg1, arg2, arg3)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: substringFunc(arg1, arg2, arg3)}
 	case "substring-before", "substring-after":
 		//substring-xxxx( haystack, needle )
 		if len(root.Args) != 2 {
@@ -231,7 +231,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if arg2, err = b.processNode(root.Args[1]); err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{
+		qyOutput = &scalarFunctionQuery{
 			Input: b.firstInput,
 			Func:  substringIndFunc(arg1, arg2, root.FuncName == "substring-after"),
 		}
@@ -244,7 +244,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: stringLengthFunc(arg1)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: stringLengthFunc(arg1)}
 	case "normalize-space":
 		if len(root.Args) == 0 {
 			return nil, errors.New("xpath: normalize-space function must have at least one parameter")
@@ -253,7 +253,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: argQuery, Func: normalizespaceFunc}
+		qyOutput = &scalarFunctionQuery{Input: argQuery, Func: normalizespaceFunc}
 	case "replace":
 		//replace( string , string, string )
 		if len(root.Args) != 3 {
@@ -272,7 +272,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if arg3, err = b.processNode(root.Args[2]); err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: replaceFunc(arg1, arg2, arg3)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: replaceFunc(arg1, arg2, arg3)}
 	case "translate":
 		//translate( string , string, string )
 		if len(root.Args) != 3 {
@@ -291,7 +291,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if arg3, err = b.processNode(root.Args[2]); err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: translateFunc(arg1, arg2, arg3)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: translateFunc(arg1, arg2, arg3)}
 	case "not":
 		if len(root.Args) == 0 {
 			return nil, errors.New("xpath: not function must have at least one parameter")
@@ -300,7 +300,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: argQuery, Func: notFunc}
+		qyOutput = &scalarFunctionQuery{Input: argQuery, Func: notFunc}
 	case "name", "local-name", "namespace-uri":
 		if len(root.Args) > 1 {
 			return nil, fmt.Errorf("xpath: %s function must have at most one parameter", root.FuncName)
@@ -317,24 +317,24 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		}
 		switch root.FuncName {
 		case "name":
-			qyOutput = &functionQuery{Input: b.firstInput, Func: nameFunc(arg)}
+			qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: nameFunc(arg)}
 		case "local-name":
-			qyOutput = &functionQuery{Input: b.firstInput, Func: localNameFunc(arg)}
+			qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: localNameFunc(arg)}
 		case "namespace-uri":
-			qyOutput = &functionQuery{Input: b.firstInput, Func: namespaceFunc(arg)}
+			qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: namespaceFunc(arg)}
 		}
 	case "true", "false":
 		val := root.FuncName == "true"
-		qyOutput = &functionQuery{
+		qyOutput = &scalarFunctionQuery{
 			Input: b.firstInput,
 			Func: func(_ query, _ iterator) interface{} {
 				return val
 			},
 		}
 	case "last":
-		qyOutput = &functionQuery{Input: b.firstInput, Func: lastFunc}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: lastFunc}
 	case "position":
-		qyOutput = &functionQuery{Input: b.firstInput, Func: positionFunc}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: positionFunc}
 	case "boolean", "number", "string":
 		inp := b.firstInput
 		if len(root.Args) > 1 {
@@ -347,7 +347,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			}
 			inp = argQuery
 		}
-		f := &functionQuery{Input: inp}
+		f := &scalarFunctionQuery{Input: inp}
 		switch root.FuncName {
 		case "boolean":
 			f.Func = booleanFunc
@@ -368,7 +368,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: argQuery, Func: countFunc}
+		qyOutput = &scalarFunctionQuery{Input: argQuery, Func: countFunc}
 	case "sum":
 		if len(root.Args) == 0 {
 			return nil, fmt.Errorf("xpath: sum(node-sets) function must with have parameters node-sets")
@@ -377,7 +377,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		qyOutput = &functionQuery{Input: argQuery, Func: sumFunc}
+		qyOutput = &scalarFunctionQuery{Input: argQuery, Func: sumFunc}
 	case "ceiling", "floor", "round":
 		if len(root.Args) == 0 {
 			return nil, fmt.Errorf("xpath: ceiling(node-sets) function must with have parameters node-sets")
@@ -386,7 +386,7 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 		if err != nil {
 			return nil, err
 		}
-		f := &functionQuery{Input: argQuery}
+		f := &scalarFunctionQuery{Input: argQuery}
 		switch root.FuncName {
 		case "ceiling":
 			f.Func = ceilingFunc
@@ -408,7 +408,16 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			}
 			args = append(args, q)
 		}
-		qyOutput = &functionQuery{Input: b.firstInput, Func: concatFunc(args...)}
+		qyOutput = &scalarFunctionQuery{Input: b.firstInput, Func: concatFunc(args...)}
+    case "reverse":
+        if len(root.Args) == 0 {
+            return nil, fmt.Errorf("xpath: reverse(node-sets) function must with have parameters node-sets")
+        }
+        argQuery, err := b.processNode(root.Args[0])
+        if err != nil {
+            return nil, err
+        }
+        qyOutput = &selectFunctionQuery{Input: argQuery, Func: reverseFunc}
 	default:
 		return nil, fmt.Errorf("not yet support this function %s()", root.FuncName)
 	}
@@ -464,7 +473,7 @@ func (b *builder) processOperatorNode(root *operatorNode) (query, error) {
 		qyOutput = &booleanQuery{Left: left, Right: right, IsOr: isOr}
 	case "|":
 		qyOutput = &unionQuery{Left: left, Right: right}
-	}
+    }
 	return qyOutput, nil
 }
 
diff --git a/func.go b/func.go
index 1edeb1d..12d0ec2 100644
--- a/func.go
+++ b/func.go
@@ -526,8 +526,28 @@ func concatFunc(args ...query) func(query, iterator) interface{} {
 
 // https://github.com/antchfx/xpath/issues/43
 func functionArgs(q query) query {
-	if _, ok := q.(*functionQuery); ok {
+	if _, ok := q.(*scalarFunctionQuery); ok {
 		return q
 	}
 	return q.Clone()
 }
+
+func reverseFunc(q query, t iterator) func() NodeNavigator {
+    var list []NodeNavigator
+    for {
+        node := q.Select(t)
+        if node == nil {
+            break
+        }
+        list = append(list, node.Copy())
+    }
+    i := len(list) - 1
+    return func() NodeNavigator {
+        if i < 0 {
+            return nil
+        }
+        node := list[i]
+        i--
+        return node
+    }
+}
diff --git a/query.go b/query.go
index afeb890..115fdc8 100644
--- a/query.go
+++ b/query.go
@@ -590,25 +590,48 @@ func (f *filterQuery) Clone() query {
 	return &filterQuery{Input: f.Input.Clone(), Predicate: f.Predicate.Clone()}
 }
 
-// functionQuery is an XPath function that call a function to returns
+// scalarFunctionQuery is an XPath function that call a function to returns
 // value of current NodeNavigator node.
-type functionQuery struct {
+type scalarFunctionQuery struct {
 	Input query                             // Node Set
 	Func  func(query, iterator) interface{} // The xpath function.
 }
 
-func (f *functionQuery) Select(t iterator) NodeNavigator {
+func (f *scalarFunctionQuery) Select(t iterator) NodeNavigator {
 	return nil
 }
 
 // Evaluate call a specified function that will returns the
 // following value type: number,string,boolean.
-func (f *functionQuery) Evaluate(t iterator) interface{} {
+func (f *scalarFunctionQuery) Evaluate(t iterator) interface{} {
 	return f.Func(f.Input, t)
 }
 
-func (f *functionQuery) Clone() query {
-	return &functionQuery{Input: f.Input.Clone(), Func: f.Func}
+func (f *scalarFunctionQuery) Clone() query {
+	return &scalarFunctionQuery{Input: f.Input.Clone(), Func: f.Func}
+}
+
+type selectFunctionQuery struct {
+    Input    query
+    Func     func(query, iterator) func() NodeNavigator
+    iterator func() NodeNavigator
+}
+
+func (f *selectFunctionQuery) Select(t iterator) NodeNavigator {
+    if f.iterator == nil {
+        f.iterator = f.Func(f.Input, t)
+    }
+    return f.iterator()
+}
+
+func (f *selectFunctionQuery) Evaluate(t iterator) interface{} {
+    // QUESTION: when is this ever called?
+    f.iterator = f.Func(f.Input, t)
+    return f
+}
+
+func (f *selectFunctionQuery) Clone() query {
+    return &selectFunctionQuery{Input: f.Input.Clone(), Func: f.Func}
 }
 
 // constantQuery is an XPath constant operand.
diff --git a/xpath_test.go b/xpath_test.go
index 7b7d14b..edb222d 100644
--- a/xpath_test.go
+++ b/xpath_test.go
@@ -1,9 +1,9 @@
 package xpath
 
 import (
-	"bytes"
-	"strings"
-	"testing"
+    "bytes"
+    "strings"
+    "testing"
 )
 
 var (
@@ -729,3 +729,12 @@ func example() *TNode {
 
 	return xhtml
 }
+
+func TestReverse(t *testing.T) {
+    list := selectNodes(html, "reverse(//li)")
+    if len(list) != 4 { t.Fatal("reverse(//li) should return 4 <li> nodes") }
+    if list[0].Value() != "" { t.Fatal("reverse(//li)[0].Value() should be ''") }
+    if list[1].Value() != "login" { t.Fatal("reverse(//li)[0].Value() should be 'login'") }
+    if list[2].Value() != "about" { t.Fatal("reverse(//li)[0].Value() should be 'about'") }
+    if list[3].Value() != "Home" { t.Fatal("reverse(//li)[0].Value() should be 'Home'") }
+}

Thank you very much!

If we use the test condition below it will panic. It panics because in this case substring returns false (boolen), so when it try to compare false = '' it fails. If we remove the compare condition it works fine, but should substring work as boolen condition?

Panic: testXPath2(t, html, "//title[substring(child::*,0) = '']", 0)

Work: testXPath2(t, html, "//title[substring(child::*,0)]", 0)

See details in https://github.com/antchfx/xpath/issues/57.

Also created a number of assert???? helpers in assert_test.go and moved assertPanic into it.

In the following document:

<?xml version="1.0"?>
<root>
	<foo>
		<bar attr="b"/>
	</foo>
</root>

the xpath expression /foo/bar@attr matches <bar/> instead of attr="b"

Test case in https://github.com/antchfx/xpath/pull/8 instantiated in https://github.com/antchfx/xquery/pull/19

I know it sounds odd at first but please hear me out.

I've been searching for an XML-2.0-compatible Go based XML manipulation tool/lib for a long long time, and I believe there is no such tool/lib exist. I can go on and on about the tools that I looked into before, but please do let me know if I'm wrong, that there is indeed such Go based XML manipulation tool/lib out there, which can satisfy the following simple requirements,

• locate XML node with XPath 1.0/2.0 query
• do basic xml node manipulation like, add/delete/change attribute, create/insert/append/delete ChildNode, etc

I saw that this xpath package already has functions like addAttribute, createChildNode, so the first step making xpath into a dom manipulation tool is simple, just expose those ready-made functions as public, and adding the missing functionalities would be step 2.

What would you say?

Using xmlquery, the following program outputs preceding-sibling::*[2] not found, even though both the XPath expressions are correct, and should evaluate to node b and c respectively:

package main

import "strings"
import "github.com/antchfx/xmlquery"

func main() {
	doc, _ := xmlquery.Parse(strings.NewReader(`<root>
<a>
<b id="b"></b>
<c id="c"></c>
<d id="d"></d>
</a>
</root>`))

	if node := xmlquery.FindOne(doc, `//*[@id="d"]/preceding-sibling::*[2]`); node == nil {
		println("preceding-sibling::*[2] not found")
	}

	if node := xmlquery.FindOne(doc, `//*[@id="d"]/preceding-sibling::*[1]`); node == nil {
		println("preceding-sibling::*[1] not found")
	}
}

Maybe related to https://github.com/antchfx/xpath/issues/36?

Given the following document:

<root>
<para> text <img/> text </para>
</root>

Given the context node selected by //para

When selecting child nodes using ./child::node()

Then, only the <img/> node is selected instead of all three nodes including the two text nodes. I believe this is a similar issue to #11: the default predicate for all queries is to select only element nodes.

This PR fixes #7 (from xmlquery repository).

While working on it I discovered another bug that fails to parse a filter if it is after self or parent step element. I fixed it without opening another issue because it is part of the xpath example in #7.

Usecase: http://xpather.com/Kp2lY28A

I am using a xpath to select all p elements containing sup elements between tables.

for i := 1; i < 10; i++ {
	xp := fmt.Sprintf("//table[%v]/following-sibling::p[child::sup][count(.|//table[%v]/preceding-sibling::p[child::sup])=count(//table[%v]/preceding-sibling::p[child::sup])]", i, i+1, i+1)
	expr, err := xpath.Compile(xp)
	if err != nil {
		logger.Log.Error(err)
		return nil, "", err
	}
	iter := expr.Evaluate(htmlquery.CreateXPathNavigator(dc)).(*xpath.NodeIterator)
	for iter.MoveNext() {
		logger.Log.Debug(iter.Current().Value())
	}
}

The final xpath is //table[1]/following-sibling::p[child::sup][count(.|//table[2]/preceding-sibling::p[child::sup])=count(//table[2]/preceding-sibling::p[child::sup])]. When I test this xpath in the usecase it returns the correct values. Am I using a xpath which isn't supported or is it a bug somewhere in this library?

I have the following example document:

<?xml version="1.0"?>
<root>
	<foo>
		<bar a="b"/>
	</foo>
	<li>
		<a class="tag" href=""/>
	</li>
	<p class='meta'>
	</p>
</root>

with the following xpath expression: //root/p[@class='meta']

The expression does not find the <p/> node while the XPath tester can.

use xmlquery find func, use string comparison size exist error, i think cmpStringStringF have bug。

example: test data: ab find expr: /res/value[data > "a"] expected: b output: a

`// operator.go func cmpNodeSetString(t iterator, op string, m, n interface{}) bool {

a := m.(query)
b := n.(string)
for {
	node := a.Select(t)
	if node == nil {
		break
	}
           // this is errror
	if cmpStringStringF(op, b, node.Value()) {
		return true
	}
            // this is should 
	//if cmpStringStringF(op, node.Value(),b) {
	//	return true
	//}
}
return false

}`

<root>
	<test foo="bar">First</test>
	<test foo="bar">Second</test>
	<test foo="xyz">Third</test>
</root>

Test:

• [x] [//test[@foo='bar'])/[last()]`

This from https://github.com/antchfx/xpath/issues/76

expected:

<test foo="bar">Second</test>

actually:

not found

• [ ] //test[@foo='bar'][last()]

expected

<test foo="bar">Second</test>

actually:

not found

Hello,

first of all, thanks for your amazing work, it's really useful to me.

I'm having an issue when using the last() function on a subgroup, for example on a result of another filter.

For example, this piece of code:

package main

import (
	"fmt"
	"github.com/antchfx/xmlquery"
	"strings"
)

func main() {
	xml := `
	<root>
		<test foo="bar">First</test>
		<test foo="bar">Second</test>
		<test foo="xyz">Third</test>
	</root>
	`

	doc, err := xmlquery.Parse(strings.NewReader(xml))
	if err != nil {
		panic(err)
	}

	tests, err := xmlquery.QueryAll(doc, `(//test[@foo="bar"])[last()]`)
	if err != nil {
		panic(err)
	}
	for _, test := range tests {
		fmt.Println(test.InnerText())
	}
}

I would expect this to print "Second", but it prints nothing, because the output from the query has no elements.

Am I doing something wrong, or is this an issue on the last() function?

Thank you!

I'm wondering why the current() function hasn't been implemented, and if it would make much time to do so.

I'm currently in the situation where I would need a query like //cd[@title=current()/@ref]. The node navigator used for the expression evaluate isn't the document root, but a previously selected node.

Changed type of field text of struct scanner into slice of rune to support cyrillic symbols. Since the Cyrillic character is encoded in two bytes, the length of the string does not equal the number of characters. Therefore, an error occurred when using Cyrillic characters.