move: log parsers

logparser/v5/pipe/parse/record.go

@@ -0,0 +1,116 @@
+package parse
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/inancgumus/learngo/logparser/v5/pipe"
+)
+
+const fieldsLength = 4
+
+// record stores fields of a log line.
+type record struct {
+	Domain  string
+	Page    string
+	Visits  int
+	Uniques int
+}
+
+// Str gets a string field by name.
+func (r record) Str(field string) string {
+	switch field {
+	case "domain":
+		return r.Domain
+	case "page":
+		return r.Page
+	}
+	panic(fieldErr(field))
+}
+
+// Int gets an integer field by name.
+func (r record) Int(field string) int {
+	switch field {
+	case "visits":
+		return r.Visits
+	case "uniques":
+		return r.Uniques
+	}
+	panic(fieldErr(field))
+}
+
+// Sum the numeric fields with another record.
+func (r record) Sum(other pipe.Record) pipe.Record {
+	if other == nil {
+		return r
+	}
+	r.Visits += other.(record).Visits
+	r.Uniques += other.(record).Uniques
+	return r
+}
+
+// UnmarshalText to a *record.
+func (r *record) UnmarshalText(p []byte) (err error) {
+	fields := strings.Fields(string(p))
+	if len(fields) != fieldsLength {
+		return fmt.Errorf("wrong number of fields %q", fields)
+	}
+
+	r.Domain, r.Page = fields[0], fields[1]
+
+	if r.Visits, err = parseStr("visits", fields[2]); err != nil {
+		return err
+	}
+	if r.Uniques, err = parseStr("uniques", fields[3]); err != nil {
+		return err
+	}
+	return validate(*r)
+}
+
+// UnmarshalJSON to a *record.
+func (r *record) UnmarshalJSON(data []byte) error {
+	// `methodless` doesn't have any methods including UnmarshalJSON.
+	// This trick prevents the stack-overflow (infinite loop).
+	type methodless record
+
+	var m methodless
+	if err := json.Unmarshal(data, &m); err != nil {
+		return err
+	}
+
+	// Cast back to the record and save.
+	*r = record(m)
+
+	return validate(*r)
+}
+
+// parseStr helps UnmarshalText for string to positive int parsing.
+func parseStr(name, v string) (int, error) {
+	n, err := strconv.Atoi(v)
+	if err != nil {
+		return 0, fmt.Errorf("Record.UnmarshalText %q: %v", name, err)
+	}
+	return n, nil
+}
+
+// validate whether a parsed record is valid or not.
+func validate(r record) (err error) {
+	switch {
+	case r.Domain == "":
+		err = errors.New("record.domain cannot be empty")
+	case r.Page == "":
+		err = errors.New("record.page cannot be empty")
+	case r.Visits < 0:
+		err = errors.New("record.visits cannot be negative")
+	case r.Uniques < 0:
+		err = errors.New("record.uniques cannot be negative")
+	}
+	return
+}
+
+func fieldErr(field string) error {
+	return fmt.Errorf("record field: %q does not exist", field)
+}