asl.go

package parser

import (
	"errors"
	"slices"
)

// ASL represents an Abstract Syntax List of a gemtext document.
type ASL struct {
	elems []Element
}

var aslErrs = struct {
	nTooLarge error
}{
	errors.New("n larger than number of elements"),
}

func NewASL(elems ...Element) ASL {
	return ASL{elems: elems}
}

// Clone returns a clone of asl.
func (asl *ASL) Clone() ASL {
	return ASL{elems: asl.elems}
}

// InsertFirst inserts elems at the start of the list.
func (asl *ASL) InsertFirst(elems ...Element) {
	asl.elems = slices.Insert(asl.elems, 0, elems...)
}

// InsertLast inserts elems at the end of the list.
func (asl *ASL) InsertLast(elems ...Element) {
	asl.elems = slices.Insert(asl.elems, len(asl.elems), elems...)
}

// InsertAfter inserts elems after the first element where f returns true. Does
// nothing if f returns false for all elements.
func (asl *ASL) InsertAfter(elems []Element, f func(Element) bool) {
	i := slices.IndexFunc(asl.elems, f)
	if i == -1 {
		return
	}

	asl.elems = slices.Insert(asl.elems, i+1, elems...)
}

// InsertBefore inserts elems before the first element where f returns true.
// Does nothing if f returns false for all elements.
func (asl *ASL) InsertBefore(elems []Element, f func(Element) bool) {
	i := slices.IndexFunc(asl.elems, f)
	if i == -1 {
		return
	}

	asl.elems = slices.Insert(asl.elems, i, elems...)
}

// DeleteFirst deletes the first n elements of the list. Returns an error if n
// is larger than the number of elements asl currently has.
func (asl *ASL) DeleteFirst(n uint) error {
	end := 0 + int(n)
	if end > len(asl.elems) {
		return aslErrs.nTooLarge
	}

	asl.elems = slices.Delete(asl.elems, 0, end)
	return nil
}

// DeleteLast deletes the last n elements of the list. Returns an error if n is
// larger than the number of elements asl currently has.
func (asl *ASL) DeleteLast(n uint) error {
	end := len(asl.elems)
	start := end - int(n)
	if start < 0 {
		return aslErrs.nTooLarge
	}

	asl.elems = slices.Delete(asl.elems, start, end)
	return nil
}

// DeleteAll deletes all elements where f returns true. Does nothing if f
// returns false for all elements.
func (asl *ASL) DeleteAll(f func(Element) bool) {
	asl.elems = slices.DeleteFunc(asl.elems, f)
}

// Replace replaces the first element where f returns true with elems. Does
// nothing if f returns false for all elements.
func (asl *ASL) Replace(elems []Element, f func(Element) bool) {
	i := slices.IndexFunc(asl.elems, f)
	if i == -1 {
		return
	}

	asl.elems = slices.Replace(asl.elems, i, i+1, elems...)
}

// Visit iterates over all elements that asl has, passing each element to f.
func (asl *ASL) Visit(f func(Element)) {
	for e := range slices.Values(asl.elems) {
		f(e)
	}
}

// Possible methods to add later:
// InsertBetween
// DeleteBetween
// ReplaceAll