Implement more functions, lots of bug fixes

Author: pgundlach

Readme.md

@@ -0,0 +1,57 @@
+package goxpath
+
+import "fmt"
+
+const nsArray = "http://www.w3.org/2005/xpath-functions/array"
+
+// XPathArray represents an XPath 3.1 array.
+type XPathArray struct {
+	Members []Sequence
+}
+
+// Get returns the member at the given 1-based index.
+func (a *XPathArray) Get(pos int) (Sequence, error) {
+	if pos < 1 || pos > len(a.Members) {
+		return nil, fmt.Errorf("array index %d out of bounds (size %d)", pos, len(a.Members))
+	}
+	return a.Members[pos-1], nil
+}
+
+// Size returns the number of members in the array.
+func (a *XPathArray) Size() int {
+	return len(a.Members)
+}
+
+func fnArrayGet(ctx *Context, args []Sequence) (Sequence, error) {
+	if len(args[0]) != 1 {
+		return nil, fmt.Errorf("array:get expects a single array as first argument")
+	}
+	arr, ok := args[0][0].(*XPathArray)
+	if !ok {
+		return nil, fmt.Errorf("array:get expects an array as first argument, got %T", args[0][0])
+	}
+	if len(args[1]) != 1 {
+		return nil, fmt.Errorf("array:get expects a single integer as second argument")
+	}
+	pos, err := NumberValue(args[1])
+	if err != nil {
+		return nil, err
+	}
+	return arr.Get(int(pos))
+}
+
+func fnArraySize(ctx *Context, args []Sequence) (Sequence, error) {
+	if len(args[0]) != 1 {
+		return nil, fmt.Errorf("array:size expects a single array as first argument")
+	}
+	arr, ok := args[0][0].(*XPathArray)
+	if !ok {
+		return nil, fmt.Errorf("array:size expects an array as first argument, got %T", args[0][0])
+	}
+	return Sequence{arr.Size()}, nil
+}
+
+func init() {
+	RegisterFunction(&Function{Name: "get", Namespace: nsArray, F: fnArrayGet, MinArg: 2, MaxArg: 2})
+	RegisterFunction(&Function{Name: "size", Namespace: nsArray, F: fnArraySize, MinArg: 1, MaxArg: 1})
+}

array.go

@@ -2,6 +2,8 @@ package goxpath
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -10,6 +12,136 @@ var (
 	ErrConversion = fmt.Errorf("conversion failed")
 )
 
+// XSDuration represents an xs:duration value with separate date and time components.
+type XSDuration struct {
+	Negative bool
+	Years    int
+	Months   int
+	Days     int
+	Hours    int
+	Minutes  int
+	Seconds  float64
+}
+
+func (d XSDuration) String() string {
+	var sb strings.Builder
+	if d.Negative {
+		sb.WriteByte('-')
+	}
+	sb.WriteByte('P')
+	if d.Years != 0 {
+		fmt.Fprintf(&sb, "%dY", d.Years)
+	}
+	if d.Months != 0 {
+		fmt.Fprintf(&sb, "%dM", d.Months)
+	}
+	if d.Days != 0 {
+		fmt.Fprintf(&sb, "%dD", d.Days)
+	}
+	if d.Hours != 0 || d.Minutes != 0 || d.Seconds != 0 {
+		sb.WriteByte('T')
+		if d.Hours != 0 {
+			fmt.Fprintf(&sb, "%dH", d.Hours)
+		}
+		if d.Minutes != 0 {
+			fmt.Fprintf(&sb, "%dM", d.Minutes)
+		}
+		if d.Seconds != 0 {
+			s := strconv.FormatFloat(d.Seconds, 'f', -1, 64)
+			sb.WriteString(s)
+			sb.WriteByte('S')
+		}
+	}
+	if sb.Len() == 1 || (d.Negative && sb.Len() == 2) {
+		sb.WriteString("T0S")
+	}
+	return sb.String()
+}
+
+// ParseXSDuration parses an ISO 8601 duration string (e.g. "P1Y2M3DT4H5M6.5S", "-P1Y").
+func ParseXSDuration(s string) (XSDuration, error) {
+	var d XSDuration
+	orig := s
+	if len(s) == 0 {
+		return d, fmt.Errorf("FORG0001: empty duration string")
+	}
+	if s[0] == '-' {
+		d.Negative = true
+		s = s[1:]
+	}
+	if len(s) == 0 || s[0] != 'P' {
+		return d, fmt.Errorf("FORG0001: duration must start with 'P': %q", orig)
+	}
+	s = s[1:]
+	inTimePart := false
+	for len(s) > 0 {
+		if s[0] == 'T' {
+			inTimePart = true
+			s = s[1:]
+			continue
+		}
+		// Read a number (possibly decimal)
+		numEnd := 0
+		for numEnd < len(s) && (s[numEnd] >= '0' && s[numEnd] <= '9' || s[numEnd] == '.') {
+			numEnd++
+		}
+		if numEnd == 0 || numEnd >= len(s) {
+			return d, fmt.Errorf("FORG0001: invalid duration format: %q", orig)
+		}
+		numStr := s[:numEnd]
+		designator := s[numEnd]
+		s = s[numEnd+1:]
+
+		if designator == 'S' || strings.Contains(numStr, ".") {
+			f, err := strconv.ParseFloat(numStr, 64)
+			if err != nil {
+				return d, fmt.Errorf("FORG0001: invalid number in duration: %q", orig)
+			}
+			if designator == 'S' {
+				d.Seconds = f
+			} else {
+				return d, fmt.Errorf("FORG0001: decimal only allowed for seconds: %q", orig)
+			}
+		} else {
+			n, err := strconv.Atoi(numStr)
+			if err != nil {
+				return d, fmt.Errorf("FORG0001: invalid number in duration: %q", orig)
+			}
+			switch designator {
+			case 'Y':
+				d.Years = n
+			case 'M':
+				if inTimePart {
+					d.Minutes = n
+				} else {
+					d.Months = n
+				}
+			case 'D':
+				d.Days = n
+			case 'H':
+				d.Hours = n
+			default:
+				return d, fmt.Errorf("FORG0001: unexpected designator '%c' in duration: %q", designator, orig)
+			}
+		}
+	}
+	return d, nil
+}
+
+// XSQName represents an xs:QName value with namespace URI, prefix, and local name.
+type XSQName struct {
+	Namespace string
+	Prefix    string
+	Localname string
+}
+
+func (q XSQName) String() string {
+	if q.Prefix != "" {
+		return q.Prefix + ":" + q.Localname
+	}
+	return q.Localname
+}
+
 // ToXSInteger converts the item to an xs:integer.
 func ToXSInteger(itm Item) (int, error) {
 	switch t := itm.(type) {
@@ -38,6 +170,95 @@ func xsTime(ctx *Context, args []Sequence) (Sequence, error) {
 	return Sequence{XSTime(t)}, nil
 }
 
+func xsDouble(ctx *Context, args []Sequence) (Sequence, error) {
+	nv, err := NumberValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+	return Sequence{nv}, nil
+}
+
+func xsDate(ctx *Context, args []Sequence) (Sequence, error) {
+	firstarg, err := StringValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+
+	formats := []string{
+		"2006-01-02-07:00",
+		"2006-01-02+07:00",
+		"2006-01-02Z",
+		"2006-01-02",
+	}
+
+	for _, format := range formats {
+		t, err := time.Parse(format, firstarg)
+		if err == nil {
+			return Sequence{XSDate(t)}, nil
+		}
+	}
+
+	return nil, fmt.Errorf("FORG0001: cannot cast %q to xs:date", firstarg)
+}
+
+func xsInteger(ctx *Context, args []Sequence) (Sequence, error) {
+	nv, err := NumberValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+	return Sequence{int(nv)}, nil
+}
+
+func xsString(ctx *Context, args []Sequence) (Sequence, error) {
+	sv, err := StringValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+	return Sequence{sv}, nil
+}
+
+func xsDateTime(ctx *Context, args []Sequence) (Sequence, error) {
+	firstarg, err := StringValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+
+	formats := []string{
+		"2006-01-02T15:04:05.999999999-07:00",
+		"2006-01-02T15:04:05.999999999Z",
+		"2006-01-02T15:04:05.999999999",
+		"2006-01-02T15:04:05-07:00",
+		"2006-01-02T15:04:05Z",
+		"2006-01-02T15:04:05",
+	}
+
+	for _, format := range formats {
+		t, err := time.Parse(format, firstarg)
+		if err == nil {
+			return Sequence{XSDateTime(t)}, nil
+		}
+	}
+	return nil, fmt.Errorf("FORG0001: cannot cast %q to xs:dateTime", firstarg)
+}
+
+func xsDuration(ctx *Context, args []Sequence) (Sequence, error) {
+	firstarg, err := StringValue(args[0])
+	if err != nil {
+		return nil, err
+	}
+	d, err := ParseXSDuration(firstarg)
+	if err != nil {
+		return nil, err
+	}
+	return Sequence{d}, nil
+}
+
 func init() {
 	RegisterFunction(&Function{Name: "time", Namespace: nsXS, F: xsTime, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "dateTime", Namespace: nsXS, F: xsDateTime, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "double", Namespace: nsXS, F: xsDouble, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "duration", Namespace: nsXS, F: xsDuration, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "date", Namespace: nsXS, F: xsDate, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "integer", Namespace: nsXS, F: xsInteger, MinArg: 1, MaxArg: 1})
+	RegisterFunction(&Function{Name: "string", Namespace: nsXS, F: xsString, MinArg: 1, MaxArg: 1})
 }