line.go

package file

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"os"
)

// LineFunc stands for a handler for each line string.
type LineFunc func(line string) (err error)

//revive:disable:error-naming It's not a real error
var (
	// QuitRead indicates the arbitrary error means to quit from reading.
	QuitRead = errors.New("file: quit read by line")
)

// ReadFileLines reads all lines from the given file (the line ending chars are not included).
func ReadFileLines(path string) (lines []string, err error) {
	err = readFileByLine(path, func(l string) error {
		lines = append(lines, l)
		return nil
	})
	return
}

// CountFileLines counts all lines from the given file (the line ending chars are not included).
func CountFileLines(path string) (count int, err error) {
	err = readFileByLine(path, func(l string) error {
		count++
		return nil
	})
	return
}

// WriteFileLines writes the given lines as a text file.
func WriteFileLines(path string, lines []string) error {
	return openFileWriteLines(path, createFileFlag, lines)
}

// AppendFileLines appends the given lines to the end of a text file.
func AppendFileLines(path string, lines []string) error {
	return openFileWriteLines(path, appendFileFlag, lines)
}

// ReadFirstLines reads the top n lines from the given file (the line ending chars are not included), or lesser lines if the given file doesn't contain enough line ending chars.
func ReadFirstLines(path string, n int) (lines []string, err error) {
	var f *os.File
	if f, err = os.Open(path); err != nil {
		return
	}
	defer f.Close()
	return extractIOTopLines(f, n)
}

// ReadLastLines reads the bottom n lines from the given file (the line ending chars are not included), or lesser lines if the given file doesn't contain enough line ending chars.
func ReadLastLines(path string, n int) (lines []string, err error) {
	var f *os.File
	if f, err = os.Open(path); err != nil {
		return
	}
	defer f.Close()
	return extractIOBottomLines(f, n)
}

// extractIOTopLines extracts the top n lines from the given stream (the line ending chars are not included), or lesser lines if the given stream doesn't contain enough line ending chars.
func extractIOTopLines(rd io.Reader, n int) ([]string, error) {
	if n <= 0 {
		return nil, errors.New("n should be greater than 0")
	}
	result := make([]string, 0)
	if err := readIOByLine(rd, func(line string) error {
		result = append(result, line)
		n--
		if n <= 0 {
			return QuitRead
		}
		return nil
	}); err != nil {
		return nil, err
	}
	return result, nil
}

// extractIOBottomLines extracts the bottom n lines from the given stream (the line ending chars are not included), or lesser lines if the given stream doesn't contain enough line ending chars.
func extractIOBottomLines(rd io.Reader, n int) ([]string, error) {
	if n <= 0 {
		return nil, errors.New("n should be greater than 0")
	}
	var (
		result = make([]string, n, n)
		cnt    int
	)
	if err := readIOByLine(rd, func(line string) error {
		result[cnt%n] = line
		cnt++
		return nil
	}); err != nil {
		return nil, err
	}
	if cnt <= n {
		return result[0:cnt], nil
	}
	pos := cnt % n
	return append(result[pos:], result[0:pos]...), nil
}

// readFileByLine iterates the given file by lines (the line ending chars are not included).
func readFileByLine(path string, callback LineFunc) (err error) {
	var file *os.File
	if file, err = os.Open(path); err != nil {
		return
	}
	defer file.Close()
	return readIOByLine(file, callback)
}

func openFileWriteLines(path string, flag int, lines []string) error {
	file, err := os.OpenFile(path, flag, filePerm)
	if err != nil {
		return err
	}
	defer file.Close()
	return writeIOLines(file, lines)
}

// writeIOLines writes the given lines to a Writer.
func writeIOLines(wr io.Writer, lines []string) error {
	w := bufio.NewWriter(wr)
	defer w.Flush()
	for _, line := range lines {
		if _, err := fmt.Fprintln(w, line); err != nil {
			return err
		}
	}
	return nil
}

// readIOByLine iterates the given Reader by lines (the line ending chars are not included).
func readIOByLine(rd io.Reader, callback LineFunc) (err error) {
	readLine := func(r *bufio.Reader) (string, error) {
		var (
			err      error
			line, ln []byte
			isPrefix = true
		)
		for isPrefix && err == nil {
			line, isPrefix, err = r.ReadLine()
			ln = append(ln, line...)
		}
		return string(ln), err
	}
	r := bufio.NewReader(rd)
	s, e := readLine(r)
	for e == nil {
		if err = callback(s); err != nil {
			break
		}
		s, e = readLine(r)
	}

	if err == QuitRead {
		err = nil
	}
	return
}