segments.go

package protopath

import "slices"

// Segments represents a parsed proto path value.
type Segments []Segment

// Parse convert the given string path to slice of segments and validates all of them.
func Parse(path string) (Segments, error) {
	if len(path) == 0 {
		return Segments{Segment{encoded: path, decoded: path, isValid: true}}, nil
	}
	ss := Segments{}
	for len(path) > 0 {
		s := decodeFirstPathSegment(path)
		ss = append(ss, s)
		if !s.IsValid() {
			if len(ss) == 1 { // first segment
				return ss, &ErrInvalidSegment{Encoded: s.Encoded()}
			}
			return ss, &ErrInPath{Path: ss.PrecedingSegments(-1).Encode(), Cause: &ErrInvalidSegment{Encoded: s.Encoded()}}
		}
		path = path[len(s.encoded):]
		next, hasNext := nextByte(path)
		if !hasNext {
			continue
		}
		if next == '.' {
			path = path[1:]
			// case for paths `...foo.` that should result in segments: ..., `foo`, ``
			// case for paths `...foo.[bar]...` that should result in segments: ..., `foo`, ``, `[bar]`, ...
			if next, hasNext = nextByte(path); !hasNext || next == '[' {
				ss = append(ss, Segment{encoded: path[0:0], decoded: "", isValid: true})
			}
		}
	}
	return ss, nil
}

// Encode encodes slice of segments into string path.
func (ss Segments) Encode() string {
	if len(ss) == 0 {
		return ""
	}
	l := 0
	for _, s := range ss {
		l += len(s.encoded)
	}
	e := append(make([]byte, 0, l), ss[0].encoded...)
	for _, s := range ss[1:] {
		e = joinPath(e, s.encoded)
	}
	return string(e)
}

// First returns the first segment in path.
func (ss Segments) First() Segment {
	if len(ss) == 0 {
		return Segment{}
	}
	return ss[0]
}

// Last returns the last segment in path.
func (ss Segments) Last() Segment {
	if len(ss) == 0 {
		return Segment{}
	}
	return ss[len(ss)-1]
}

// Index returns the n'th segment in path. Negative indexes returns segments starting from the back.
func (ss Segments) Index(n int) Segment {
	if n < 0 {
		n += len(ss)
	}
	if n < 0 || n >= len(ss) {
		return Segment{}
	}
	return ss[n]
}

// PrecedingSegments returns a slice of segments composed of the segments before a segment with the provided index.
func (ss Segments) PrecedingSegments(n int) Segments {
	if n < 0 {
		n += len(ss)
	}
	if n < 0 || n >= len(ss) {
		return nil
	}
	return slices.Clone(ss[:n])
}

// PrecedingSegmentsWithCurrent returns a slice of segments that includes a segment with the provided index and all segments before it.
func (ss Segments) PrecedingSegmentsWithCurrent(n int) Segments {
	if n < 0 {
		n += len(ss)
	}
	if n < 0 || n >= len(ss) {
		return nil
	}
	return slices.Clone(ss[:n+1])
}

// FollowingSegments returns a slice of segments composed of the segments after a segment with the provided index.
func (ss Segments) FollowingSegments(n int) Segments {
	if n < 0 {
		n += len(ss)
	}
	if n < 0 || n >= len(ss) {
		return nil
	}
	return slices.Clone(ss[n+1:])
}

// FollowingSegmentsWithCurrent returns a slice of segments that includes a segment with the provided index and all segments after it.
func (ss Segments) FollowingSegmentsWithCurrent(n int) Segments {
	if n < 0 {
		n += len(ss)
	}
	if n < 0 || n >= len(ss) {
		return nil
	}
	return slices.Clone(ss[n:])
}

func (ss Segments) Equal(o Segments) bool {
	return slices.EqualFunc(ss, o, func(i, j Segment) bool {
		return i.Equal(j)
	})
}

func (ss Segments) Compare(o Segments) int {
	return slices.CompareFunc(ss, o, func(i, j Segment) int {
		return i.Compare(j)
	})
}

func joinPath(first []byte, second string) []byte {
	if len(second) > 0 && second[0] == '[' { // second starts with '['
		if len(first) == 0 {
			return append([]byte{'[', ']'}, second...)
		}
		return append(first, second...)
	}
	return append(append(first, '.'), second...)
}

// JoinPaths create a new encoded path by concatenating all provided paths.
func JoinPaths(paths ...string) string {
	if len(paths) == 0 {
		return ""
	}
	l := 0
	for _, p := range paths {
		l += len(p)
	}
	p := append(make([]byte, 0, l), paths[0]...)
	for _, o := range paths[1:] {
		p = joinPath(p, o)
	}
	return string(p)
}