file.go

package editpro

import (
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
)

var ErrSymlink = errors.New("refusing to replace a symbolic link")

// WriteOptions controls safe file replacement.
type WriteOptions struct {
	// NoSync skips syncing temporary file contents before replacement.
	NoSync bool
}

// EditFile applies Replace and commits a changed result through a same-directory
// temporary file. Symbolic links are rejected to avoid replacing the link itself.
func EditFile(path string, old, replacement []byte, editOpts ReplaceOptions, writeOpts WriteOptions) (ReplaceResult, error) {
	src, err := readRegularFile(path)
	if err != nil {
		return ReplaceResult{}, err
	}
	result, err := Replace(src, old, replacement, editOpts)
	if err != nil || !result.Changed {
		return result, err
	}
	if err := writeFile(path, result.Data, writeOpts); err != nil {
		return ReplaceResult{}, err
	}
	return result, nil
}

// InsertFile applies Insert and safely commits a changed result.
func InsertFile(path string, content []byte, insertOpts InsertOptions, writeOpts WriteOptions) (InsertResult, error) {
	src, err := readRegularFile(path)
	if err != nil {
		return InsertResult{}, err
	}
	result, err := Insert(src, content, insertOpts)
	if err != nil || !result.Changed {
		return result, err
	}
	if err := writeFile(path, result.Data, writeOpts); err != nil {
		return InsertResult{}, err
	}
	return result, nil
}

func writeFile(path string, data []byte, opts WriteOptions) (err error) {
	info, err := os.Lstat(path)
	if err != nil {
		return err
	}
	if info.Mode()&os.ModeSymlink != 0 {
		return ErrSymlink
	}
	if !info.Mode().IsRegular() {
		return fmt.Errorf("destination is not a regular file: %s", path)
	}
	mode := info.Mode().Perm()

	dir := filepath.Dir(path)
	tmp, err := os.CreateTemp(dir, ".editpro-*")
	if err != nil {
		return err
	}
	tmpName := tmp.Name()
	committed := false
	defer func() {
		if !committed {
			_ = tmp.Close()
			_ = os.Remove(tmpName)
		}
	}()

	if err = tmp.Chmod(mode); err != nil {
		return err
	}
	if _, err = writeAll(tmp, data); err != nil {
		return err
	}
	if !opts.NoSync {
		if err = tmp.Sync(); err != nil {
			return err
		}
	}
	if err = tmp.Close(); err != nil {
		return err
	}
	if err = replaceFile(tmpName, path); err != nil {
		return err
	}
	committed = true
	return nil
}

func readRegularFile(path string) ([]byte, error) {
	info, err := os.Lstat(path)
	if err != nil {
		return nil, err
	}
	if info.Mode()&os.ModeSymlink != 0 {
		return nil, ErrSymlink
	}
	if !info.Mode().IsRegular() {
		return nil, fmt.Errorf("source is not a regular file: %s", path)
	}
	return os.ReadFile(path)
}

func writeAll(w io.Writer, data []byte) (int, error) {
	written := 0
	for written < len(data) {
		n, err := w.Write(data[written:])
		written += n
		if err != nil {
			return written, err
		}
		if n == 0 {
			return written, io.ErrShortWrite
		}
	}
	return written, nil
}