count.go

package main

import (
	"bufio"
	"fmt"
	"io"
	"unicode"
)

type Counts struct {
	Bytes int
	Words int
	Lines int
}

func (c *Counts) Add(other Counts) {
	c.Bytes += other.Bytes
	c.Words += other.Words
	c.Lines += other.Lines
}

func (c Counts) Println(w io.Writer, options DisplayOptions, name string) {
	if options.PrintLines() {
		fmt.Fprint(w, c.Lines, "\t")
	}

	if options.PrintWords() {
		fmt.Fprint(w, c.Words, "\t")
	}

	if options.PrintBytes() {
		fmt.Fprint(w, c.Bytes, "\t")
	}

	if options.Filename {
		fmt.Fprint(w, name, "\t")
	}

	fmt.Fprintln(w, "")
}

func CountWords(r io.Reader) int {
	scanner := bufio.NewScanner(r)
	scanner.Split(bufio.ScanWords)

	wordCount := 0

	for scanner.Scan() {
		wordCount++
	}

	return wordCount
}

func CountLines(r io.Reader) int {
	linesCount := 0
	reader := bufio.NewReader(r)

	for {
		rune, _, err := reader.ReadRune()
		if err != nil {
			break
		}

		if rune == '\n' {
			linesCount++
		}
	}

	return linesCount
}

func CountBytes(r io.Reader) int {
	bytes, _ := io.Copy(io.Discard, r)
	return int(bytes)
}

func GetCounts(r io.Reader) Counts {
	bytesReader, bytesWriter := io.Pipe()
	wordsReader, wordsWriter := io.Pipe()
	linesReader, linesWriter := io.Pipe()

	w := io.MultiWriter(bytesWriter, wordsWriter, linesWriter)

	chBytes := make(chan int)
	chWords := make(chan int)
	chLines := make(chan int)

	go func() {
		defer close(chBytes)
		chBytes <- CountBytes(bytesReader)
	}()

	go func() {
		defer close(chWords)
		chWords <- CountWords(wordsReader)
	}()

	go func() {
		defer close(chLines)
		chLines <- CountLines(linesReader)
	}()

	io.Copy(w, r)
	bytesWriter.Close()
	wordsWriter.Close()
	linesWriter.Close()

	byteCount := <-chBytes
	wordsCount := <-chWords
	linesCount := <-chLines

	return Counts{
		Bytes: byteCount,
		Words: wordsCount,
		Lines: linesCount,
	}
}

func GetCountsSinglePass(r io.Reader) Counts {
	linesCount := 0
	bytesCount := 0
	wordsCount := 0

	isInsideWord := false

	reader := bufio.NewReader(r)

	for {
		r, size, err := reader.ReadRune()
		if err != nil {
			break
		}

		bytesCount += size

		if r == '\n' {
			linesCount++
		}

		if unicode.IsSpace(r) {
			isInsideWord = false
			continue
		}

		if isInsideWord {
			continue
		}

		wordsCount++
		isInsideWord = true
	}

	return Counts{
		Lines: linesCount,
		Bytes: bytesCount,
		Words: wordsCount,
	}
}

func AddCounts(a Counts, b Counts) Counts {
	return Counts{
		Bytes: a.Bytes + b.Bytes,
		Words: a.Words + b.Words,
		Lines: a.Lines + b.Lines,
	}
}