cxpath.go

package cxpath

import (
	"fmt"
	"io"
	"iter"
	"os"

	"github.com/speedata/goxpath"
)

// A Context stores the current state of the XPath parser.
type Context struct {
	P     *goxpath.Parser
	Seq   goxpath.Sequence
	Error error
}

// NewFromFile returns a new context from a file name.
func NewFromFile(filename string) (*Context, error) {
	r, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer r.Close()
	return NewFromReader(r)
}

// NewFromReader returns a new context from a reader.
func NewFromReader(r io.Reader) (*Context, error) {
	p, err := goxpath.NewParser(r)
	if err != nil {
		return nil, err
	}
	ctx := Context{
		P: p,
	}
	return &ctx, nil
}

// String returns the string value of the current sequence.
func (ctx *Context) String() string {
	return ctx.Seq.Stringvalue()
}

// Int returns the number value as an integer
func (ctx *Context) Int() int {
	i, err := ctx.Seq.IntValue()
	if err != nil {
		ctx.Error = err
	}
	return i
}

// Bool returns the boolean value of the sequence.
func (ctx *Context) Bool() bool {
	b, err := goxpath.BooleanValue(ctx.Seq)
	if err != nil {
		ctx.Error = err
	}
	return b
}

// SetNamespace sets a prefix/URI pair for XPath queries.
func (ctx *Context) SetNamespace(prefix, uri string) *Context {
	ctx.P.Ctx.Namespaces[prefix] = uri
	return ctx
}

// Root returns the top most element of the XML file.
func (ctx *Context) Root() *Context {
	newContext := Context{
		P: &goxpath.Parser{
			Ctx: goxpath.CopyContext(ctx.P.Ctx),
		},
	}
	newContext.Seq, newContext.Error = newContext.P.Ctx.Root()
	return &newContext
}

// Each can be used as an iterator which returns a Context for each item in the
// resulting sequence.
func (ctx *Context) Each(eval string) iter.Seq[*Context] {
	p := &goxpath.Parser{
		Ctx: goxpath.CopyContext(ctx.P.Ctx),
	}
	seq, err := safeEvaluate(p, eval)

	return func(yield func(*Context) bool) {
		if err != nil {
			errCtx := &Context{
				P:     p,
				Error: err,
			}
			yield(errCtx)
			return
		}
		for _, itm := range seq {
			newContext := Context{
				P: &goxpath.Parser{
					Ctx: goxpath.CopyContext(ctx.P.Ctx),
				},
				Seq: goxpath.Sequence{itm},
			}
			newContext.P.Ctx.SetContextSequence(newContext.Seq)
			if !yield(&newContext) {
				return
			}
		}
	}
}

// Eval executes the given XPath expression relative to the current context. It
// returns a new Context, so the old one is still available for further use.
func (ctx *Context) Eval(eval string) *Context {
	newContext := Context{
		P: &goxpath.Parser{
			Ctx: goxpath.CopyContext(ctx.P.Ctx),
		},
	}
	newContext.Seq, newContext.Error = safeEvaluate(newContext.P, eval)
	return &newContext
}

// safeEvaluate wraps Parser.Evaluate and recovers from panics that goxpath may
// raise for invalid XPath expressions.
func safeEvaluate(p *goxpath.Parser, expr string) (seq goxpath.Sequence, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("xpath evaluation panic: %v", r)
		}
	}()
	return p.Evaluate(expr)
}