parser.go

package risorxpath

import (
	"context"

	"github.com/risor-io/risor/object"
	"github.com/risor-io/risor/op"
	"github.com/speedata/goxpath"
	"github.com/speedata/risorxml"
)

type xpathParser struct {
	// The XPath parser.
	value *goxpath.Parser
	ctx   *xpathContext
}

func (xp *xpathParser) evaluate(ctx context.Context, args ...object.Object) object.Object {
	if len(args) != 1 {
		return object.ArgsErrorf("args error: xpath.evaluate() takes exactly 1 argument (%d given)", len(args))
	}
	firstArg := args[0]

	if firstArg.Type() != "string" {
		return object.TypeErrorf("xpath.evaluate() takes a string as argument, got %s", firstArg.Type())
	}
	seq, err := xp.value.Evaluate(firstArg.Interface().(string))
	if err != nil {
		return object.NewError(err)
	}
	seqList := newSequence(nil)
	for _, itm := range seq {
		seqList.seq = append(seqList.seq, itm)
	}
	return seqList
}

func (xp *xpathParser) setVariable(ctx context.Context, args ...object.Object) object.Object {
	if len(args) != 2 {
		return object.ArgsErrorf("args error: xpath.set_variable() takes exactly 2 arguments (%d given)", len(args))
	}
	firstArg := args[0]
	secondArg := args[1]
	if firstArg.Type() != "string" {
		return object.TypeErrorf("xpath.set_variable() takes a string as first argument, got %s", firstArg.Type())
	}
	if secondArg.Type() != "list" {
		return object.TypeErrorf("xpath.set_variable() takes a list as second argument, got %s", secondArg.Type())
	}
	varname := firstArg.Interface().(string)

	seq := goxpath.Sequence{}
	for _, itm := range secondArg.Interface().([]any) {
		switch t := itm.(type) {
		case string:
			seq = append(seq, itm)
		case goxpath.Sequence:
			seq = append(seq, t...)
		default:
			seq = append(seq, itm)
		}
	}

	xp.value.SetVariable(varname, seq)
	return nil
}

// Type of the object.
func (xp *xpathParser) Type() object.Type {
	return "xpath.parser"
}

// Inspect returns a string representation of the given object.
func (xp *xpathParser) Inspect() string {
	return "xpath.parser"
}

// Interface converts the given object to a native Go value.
func (xp *xpathParser) Interface() interface{} {
	return xp.value
}

// Returns True if the given object is equal to this object.
func (xp *xpathParser) Equals(other object.Object) object.Object {
	return object.NewBool(xp.value == other.(*xpathParser).value)
}

// GetAttr returns the attribute with the given name from this object.
func (xp *xpathParser) GetAttr(name string) (object.Object, bool) {
	switch name {
	case "evaluate":
		if xp.ctx != nil && xp.ctx.namespaces != nil {
			for k, v := range xp.ctx.namespaces.Interface().(map[string]any) {
				xp.ctx.value.Namespaces[k] = v.(string)
			}
		}
		return object.NewBuiltin("xpath.evaluate", xp.evaluate), true
	case "ctx":
		if xp.ctx != nil {
			return xp.ctx, true
		}
		xp.ctx = &xpathContext{
			value: xp.value.Ctx,
		}
		return xp.ctx, true
	case "set_variable":
		return object.NewBuiltin("xpath.set_variable", xp.setVariable), true
	case "xml_document":
		return &risorxml.XMLDocument{Value: xp.value.XMLDocument()}, true
	}

	return nil, false
}

// SetAttr sets the attribute with the given name on this object.
func (xp *xpathParser) SetAttr(name string, value object.Object) error {
	return object.Errorf("xpath.parser: cannot set attribute %s", name)
}

// IsTruthy returns true if the object is considered "truthy".
func (xp *xpathParser) IsTruthy() bool {
	return true
}

// RunOperation runs an operation on this object with the given
// right-hand side object.
func (xp *xpathParser) RunOperation(opType op.BinaryOpType, right object.Object) object.Object {
	return object.TypeErrorf("xpath.parser: cannot run operation %s on %s", opType, xp.Type())
}

// Cost returns the incremental processing cost of this object.
func (xp *xpathParser) Cost() int {
	return 0
}