edit.go

// Package editpro provides byte-exact text editing primitives and safe file helpers.
package editpro

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

var (
	ErrEmptyOld       = errors.New("old text must not be empty")
	ErrNoMatch        = errors.New("old text was not found")
	ErrInvalidLimit   = errors.New("replacement limit must not be negative")
	ErrInvalidExpect  = errors.New("expected match count must not be negative")
	ErrResultTooLarge = errors.New("replacement result is too large")
)

// ReplaceOptions controls a byte-exact, non-overlapping replacement.
// Limit == 0 replaces every match. ExpectedMatches == 0 disables the check.
type ReplaceOptions struct {
	Limit           int
	ExpectedMatches int
	RequireMatch    bool
}

// ReplaceResult describes a replacement without performing file I/O.
type ReplaceResult struct {
	Data     []byte
	Matches  int
	Replaced int
	Changed  bool
}

// Replace replaces old with replacement using byte-exact, non-overlapping matches.
// When no change is needed, Data aliases src.
func Replace(src, old, replacement []byte, opts ReplaceOptions) (ReplaceResult, error) {
	if len(old) == 0 {
		return ReplaceResult{}, ErrEmptyOld
	}
	if opts.Limit < 0 {
		return ReplaceResult{}, ErrInvalidLimit
	}
	if opts.ExpectedMatches < 0 {
		return ReplaceResult{}, ErrInvalidExpect
	}

	matches := bytes.Count(src, old)
	if opts.ExpectedMatches > 0 && matches != opts.ExpectedMatches {
		return ReplaceResult{}, fmt.Errorf("expected %d matches, found %d", opts.ExpectedMatches, matches)
	}
	if opts.RequireMatch && matches == 0 {
		return ReplaceResult{}, ErrNoMatch
	}

	replaced := matches
	if opts.Limit > 0 && replaced > opts.Limit {
		replaced = opts.Limit
	}
	if replaced == 0 || bytes.Equal(old, replacement) {
		return ReplaceResult{Data: src, Matches: matches, Replaced: replaced}, nil
	}

	data, err := replaceKnownCount(src, old, replacement, replaced)
	if err != nil {
		return ReplaceResult{}, err
	}
	return ReplaceResult{
		Data:     data,
		Matches:  matches,
		Replaced: replaced,
		Changed:  true,
	}, nil
}

// replaceKnownCount avoids the second Count performed by bytes.Replace. The
// caller has already validated that count non-overlapping matches exist.
func replaceKnownCount(src, old, replacement []byte, count int) ([]byte, error) {
	delta := len(replacement) - len(old)
	resultLen := len(src)
	if delta > 0 {
		maxInt := int(^uint(0) >> 1)
		if count > (maxInt-resultLen)/delta {
			return nil, ErrResultTooLarge
		}
		resultLen += count * delta
	} else {
		resultLen += count * delta
	}

	result := make([]byte, 0, resultLen)
	offset := 0
	for range count {
		i := bytes.Index(src[offset:], old)
		result = append(result, src[offset:offset+i]...)
		result = append(result, replacement...)
		offset += i + len(old)
	}
	result = append(result, src[offset:]...)
	return result, nil
}