insert.go

package editpro

import (
	"bytes"
	"errors"
	"fmt"
)

// InsertPosition identifies a file boundary or a line-relative insertion point.
type InsertPosition uint8

const (
	InsertStart InsertPosition = iota
	InsertEnd
	InsertBeforeLine
	InsertAfterLine
)

var (
	ErrInvalidPosition = errors.New("invalid insert position")
	ErrInvalidLine     = errors.New("line number must be greater than zero")
	ErrLineNotFound    = errors.New("line does not exist")
	ErrInvalidEOL      = errors.New("line ending must be LF or CRLF")
)

// InsertOptions controls line-oriented insertion. Line numbers are 1-based.
// Raw inserts Content exactly. Otherwise Content is separated from adjacent
// lines using EOL, or the source file's first detected line ending when EOL is nil.
type InsertOptions struct {
	Position InsertPosition
	Line     int
	Raw      bool
	EOL      []byte
}

// InsertResult describes an insertion without performing file I/O.
type InsertResult struct {
	Data    []byte
	Offset  int
	Changed bool
}

// Insert inserts content at a file boundary or relative to a source line.
func Insert(src, content []byte, opts InsertOptions) (InsertResult, error) {
	if !opts.Raw && len(opts.EOL) > 0 && !bytes.Equal(opts.EOL, []byte("\n")) && !bytes.Equal(opts.EOL, []byte("\r\n")) {
		return InsertResult{}, ErrInvalidEOL
	}
	offset, targetEndedWithEOL, err := insertionOffset(src, opts)
	if err != nil {
		return InsertResult{}, err
	}
	if len(content) == 0 {
		return InsertResult{Data: src, Offset: offset}, nil
	}

	prefix, suffix := []byte(nil), []byte(nil)
	if !opts.Raw {
		eol := opts.EOL
		if len(eol) == 0 {
			eol = detectEOL(src)
		}
		switch opts.Position {
		case InsertStart, InsertBeforeLine:
			if offset < len(src) && !endsWithEOL(content) {
				suffix = eol
			}
		case InsertEnd:
			if len(src) > 0 && !endsWithEOL(src) {
				prefix = eol
			}
		case InsertAfterLine:
			if offset < len(src) {
				if !endsWithEOL(content) {
					suffix = eol
				}
			} else if len(src) > 0 && !targetEndedWithEOL {
				prefix = eol
			}
		}
	}

	data := make([]byte, 0, len(src)+len(prefix)+len(content)+len(suffix))
	data = append(data, src[:offset]...)
	data = append(data, prefix...)
	data = append(data, content...)
	data = append(data, suffix...)
	data = append(data, src[offset:]...)
	return InsertResult{Data: data, Offset: offset, Changed: true}, nil
}

func insertionOffset(src []byte, opts InsertOptions) (offset int, targetEndedWithEOL bool, err error) {
	switch opts.Position {
	case InsertStart:
		return 0, false, nil
	case InsertEnd:
		return len(src), endsWithEOL(src), nil
	case InsertBeforeLine, InsertAfterLine:
		if opts.Line < 1 {
			return 0, false, ErrInvalidLine
		}
		start, ok := lineStart(src, opts.Line)
		if !ok {
			return 0, false, fmt.Errorf("%w: %d", ErrLineNotFound, opts.Line)
		}
		if opts.Position == InsertBeforeLine {
			return start, false, nil
		}
		if i := bytes.IndexByte(src[start:], '\n'); i >= 0 {
			return start + i + 1, true, nil
		}
		return len(src), false, nil
	default:
		return 0, false, ErrInvalidPosition
	}
}

func lineStart(src []byte, line int) (int, bool) {
	if line == 1 {
		return 0, true
	}
	offset := 0
	for current := 1; current < line; current++ {
		i := bytes.IndexByte(src[offset:], '\n')
		if i < 0 {
			return 0, false
		}
		offset += i + 1
	}
	return offset, true
}

func detectEOL(src []byte) []byte {
	if i := bytes.IndexByte(src, '\n'); i > 0 && src[i-1] == '\r' {
		return []byte("\r\n")
	}
	return []byte("\n")
}

func endsWithEOL(data []byte) bool {
	return len(data) > 0 && data[len(data)-1] == '\n'
}