byline

package main

import (
	"fmt"
	"io"
	"regexp"
	"strconv"
	"strings"

	"github.com/msoap/byline"
)

func main() {
	reader := strings.NewReader(`ID,NAME,PRICE
A001,name one,12.3
A002,second row;7.1
A003,three row;15.51
Total: ....
Some text
`)

	sum := 0.0
	lr := byline.NewReader(reader).
		SetFS(regexp.MustCompile(`[,;]`)).
		AWKMode(func(line string, fields []string, vars byline.AWKVars) (string, error) {
			if vars.NR == 1 {
				// skip first line
				return "", byline.ErrOmitLine
			}

			if vars.NF > 0 && strings.HasPrefix(fields[0], "Total:") {
				// skip rest of file
				return "", io.EOF
			}

			if vars.NF < 3 {
				return "", fmt.Errorf("csv parse failed for %q", line)
			}

			if price, err := strconv.ParseFloat(fields[2], 10); err != nil {
				return "", err
			} else if price < 10 {
				return "", byline.ErrOmitLine
			} else {
				sum += price
			}

			return fmt.Sprintf("line:%d. %s - %s", vars.NR, fields[0], fields[1]), nil
		})

	result, err := lr.ReadAllString()
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Print(result)
	fmt.Printf("Sum: %.2f", sum)
}

Output:

line:2. A001 - name one
line:4. A003 - three row
Sum: 27.81

package main

import (
	"fmt"
	"strings"

	"github.com/msoap/byline"
)

func main() {
	reader := strings.NewReader(`1 1 1
2 2 2
3 3 3
`)

	spacesCount, bytesCount, linesCount := 0, 0, 0
	err := byline.NewReader(reader).
		Each(func(line []byte) {
			linesCount++
			bytesCount += len(line)
			for _, b := range line {
				if b == ' ' {
					spacesCount++
				}
			}
		}).Discard()

	if err == nil {
		fmt.Printf("spaces: %d, bytes: %d, lines: %d\n", spacesCount, bytesCount, linesCount)
	}
}

Output:

spaces: 6, bytes: 18, lines: 3

package main

import (
	"fmt"
	"strings"

	"github.com/msoap/byline"
)

func main() {
	reader := strings.NewReader(`111
222
333
`)

	result := []string{}
	err := byline.NewReader(reader).
		EachString(func(line string) {
			result = append(result, line)
		}).Discard()

	if err == nil {
		fmt.Printf("%q\n", result)
	}
}

Output:

["111\n" "222\n" "333\n"]

package main

import (
	"fmt"
	"os"
	"regexp"

	"github.com/msoap/byline"
)

type StateMachine struct {
	beginRe *regexp.Regexp
	endRe   *regexp.Regexp
	inBlock bool
}

func (sm *StateMachine) SMFilter(line []byte) bool {
	switch {
	case sm.beginRe.Match(line):
		sm.inBlock = true
		return true
	case sm.inBlock && sm.endRe.Match(line):
		sm.inBlock = false
		return true
	default:
		return sm.inBlock
	}
}

func main() {
	file, err := os.Open("byline.go")
	if err != nil {
		fmt.Println(err)
		return
	}

	// get all lines between "^type..." and "^}"
	sm := StateMachine{
		beginRe: regexp.MustCompile(`^type `),
		endRe:   regexp.MustCompile(`^}\s+$`),
	}

	lr := byline.NewReader(file).Grep(sm.SMFilter).Map(func(line []byte) []byte {
		// and remove comments
		return regexp.MustCompile(`\s+//.+`).ReplaceAll(line, []byte{})
	})

	result, err := lr.ReadAllString()
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Print("\n" + result)
}

Output:

type Reader struct {
	scanner     *bufio.Scanner
	buffer      bytes.Buffer
	existsData  bool
	filterFuncs []func(line []byte) ([]byte, error)
	awkVars     AWKVars
}
type AWKVars struct {
	NR int
	NF int
	RS byte
	FS *regexp.Regexp
}

package main

import (
	"fmt"
	"regexp"
	"strings"

	"github.com/msoap/byline"
)

func main() {
	reader := strings.NewReader(`ID,NAME,PRICE
A001,name one,12.3
A002,second row;7.1
A003,three row;15.51
Total: ....
Some text
`)

	result, err := byline.NewReader(reader).GrepByRegexp(regexp.MustCompile(`^A\d+,`)).ReadAllString()
	fmt.Print("\n"+result, err)
}

Output:

A001,name one,12.3
A002,second row;7.1
A003,three row;15.51
<nil>

package main

import (
	"fmt"
	"io"
	"strings"

	"github.com/msoap/byline"
)

func main() {
	reader := strings.NewReader(`
100000
200000
300000
end ...
Some text
`)

	result, err := byline.NewReader(reader).
		MapStringErr(func(line string) (string, error) {
			switch {
			case line == "" || line == "\n":
				return "", byline.ErrOmitLine
			case strings.HasPrefix(line, "end "):
				return "", io.EOF
			default:
				return "<" + line, nil
			}
		}).
		ReadAllString()

	fmt.Print("\n"+result, err)
}

Output:

<100000
<200000
<300000
<nil>