move: log parser

interfaces/log-parser/refactor-notes/refactor-00/changes.md

@@ -0,0 +1,34 @@
+## CHANGES
+
+### PROBLEM
++ adding new fields makes the code complex
++ needs to update: `result`, `parser`, `summarizer`
++ needs to add new fields to `parser`: `totalVisits` + `totalUniques`
++ in `parse()`: repeating line errors
+  + if we parsing out of it we'd need to have *parser — superfluous
+
+### SOLUTION
++ move all the result related logic to result.go
+
++ move `parser.go/result` -> `result.go`
+  + move `parser.go/parsing` logic -> `result.go`
+
++ add `addResult` -> `result.go`
+  + remove `parser struct`'s: `totalVisits`, `totalUniques`
+  + change `update()`'s last line: `p.sum[r.domain] = addResult`
+
++ remove `(line #d)` errors from `result.go`
+  + add: `return r, err` — named params are error prone
+  + always check for the error first
+    + `if r.visits < 0 || err != nil` -> `if err != nil || r.visits < 0`
+
++ `parser.go`: check the `parseFields()`:
+    ```golang
+    r, err := parseFields(line)
+    if err != nil {
+        p.lerr = fmt.Errorf("line %d: %v", p.lines, err)
+    }```
+
++ - `parser.go` and `summarize.go`
+  - remove `total int`
+  - let `summarize()` calculate the totals

interfaces/log-parser/refactor-notes/refactor-00/main.go

@@ -0,0 +1,36 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	p := newParser()
+
+	in := bufio.NewScanner(os.Stdin)
+	for in.Scan() {
+		parsed := parse(p, in.Text())
+		update(p, parsed)
+	}
+
+	summarize(p)
+	dumpErrs([]error{in.Err(), err(p)})
+}
+
+// dumpErrs simplifies handling multiple errors
+func dumpErrs(errs []error) {
+	for _, err := range errs {
+		if err != nil {
+			fmt.Println("> Err:", err)
+		}
+	}
+}

interfaces/log-parser/refactor-notes/refactor-00/parser.go

@@ -0,0 +1,74 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+)
+
+// parser keeps track of the parsing
+type parser struct {
+	sum     map[string]result // metrics per domain
+	domains []string          // unique domain names
+	lines   int               // number of parsed lines (for the error messages)
+	lerr    error             // the last error occurred
+
+	// totalVisits  int               // total visits for all domains
+	// totalUniques int               // total uniques for all domains
+}
+
+// newParser constructs, initializes and returns a new parser
+func newParser() *parser {
+	return &parser{sum: make(map[string]result)}
+}
+
+// parse a log line and return the result
+func parse(p *parser, line string) (r result) {
+	if p.lerr != nil {
+		return
+	}
+
+	p.lines++
+
+	r, err := parseResult(line)
+	if err != nil {
+		p.lerr = fmt.Errorf("line %d: %v", p.lines, err)
+	}
+
+	return r
+}
+
+// update the parsing results
+func update(p *parser, r result) {
+	if p.lerr != nil {
+		return
+	}
+
+	// Collect the unique domains
+	cur, ok := p.sum[r.domain]
+	if !ok {
+		p.domains = append(p.domains, r.domain)
+	}
+
+	// Keep track of total and per domain visits
+	// p.totalVisits += r.visits
+	// p.totalUniques += r.uniques
+
+	// create and assign a new copy of `visit`
+	// p.sum[r.domain] = result{
+	// 	domain:  r.domain,
+	// 	visits:  r.visits + cur.visits,
+	// 	uniques: r.uniques + cur.uniques,
+	// }
+	p.sum[r.domain] = addResult(r, cur)
+}
+
+// err returns the last error encountered
+func err(p *parser) error {
+	return p.lerr
+}

interfaces/log-parser/refactor-notes/refactor-00/result.go

@@ -0,0 +1,53 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const fieldsLength = 4
+
+// result stores the parsed result for a domain
+type result struct {
+	domain, page    string
+	visits, uniques int
+	// add more metrics if needed
+}
+
+// parseResult from a log line
+func parseResult(line string) (r result, err error) {
+	fields := strings.Fields(line)
+	if len(fields) != fieldsLength {
+		return r, fmt.Errorf("wrong input: %v", fields)
+	}
+
+	r.domain = fields[0]
+	r.page = fields[1]
+
+	r.visits, err = strconv.Atoi(fields[2])
+	if err != nil || r.visits < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[2])
+	}
+
+	r.uniques, err = strconv.Atoi(fields[3])
+	if err != nil || r.uniques < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[3])
+	}
+
+	return r, nil
+}
+
+// addResult to another one
+func addResult(r, other result) result {
+	r.visits += other.visits
+	r.uniques += other.uniques
+	return r
+}

interfaces/log-parser/refactor-notes/refactor-00/summarize.go

@@ -0,0 +1,43 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+const (
+	//          DOMAINS PAGES VISITS UNIQUES
+	//             ^      ^     ^    ^
+	//             |      |     |    |
+	header     = "%-25s %-10s %10s %10s\n"
+	line       = "%-25s %-10s %10d %10d\n"
+	footer     = "\n%-36s %10d %10d\n" // -> "" VISITS UNIQUES
+	dash       = "-"
+	dashLength = 58
+)
+
+// summarize summarizes and prints the parsing result
+func summarize(p *parser) {
+	sort.Strings(p.domains)
+
+	fmt.Printf(header, "DOMAIN", "PAGES", "VISITS", "UNIQUES")
+	fmt.Println(strings.Repeat("-", dashLength))
+
+	var total result
+
+	for _, domain := range p.domains {
+		r := p.sum[domain]
+		total = addResult(total, r)
+
+		fmt.Printf(line, r.domain, r.page, r.visits, r.uniques)
+	}
+	fmt.Printf(footer, "TOTAL", total.visits, total.uniques)
+}

interfaces/log-parser/refactor-notes/refactor-01/changes.md

@@ -0,0 +1,61 @@
+### PROBLEM
++ `main.go` (api client) does a lot of things:
+  + read the log input
+  + parse line by line
+  + updates the results
+  + display the results
+
++ inflexible:
+  + filter by extension (can change)
+  + group by domain (can change) — group by page?
+
+## SOLUTION
++ hide the parsing api from the client
+
++ move `main.go/scanner` -> `parser.go/parse()`
+  + add `main.go`: err handling from `parse()`
+
++ `parser.go/parse()` -> return err directly
+  + remove: `if p.lerr != nil { return }` from parse() and update()
+  + remove: `dumpErrs`
+  + remove: `parser.go/err()`
+  + remove `parser.go/lerr`
+    + return `in.Err()` from `parse()`
+
+  + remove: `p.lines++`
+    + `return r, fmt.Errorf("line %d: %v", p.lines, err)`
+    + remove: `lines int`
+    + `parse()` and `parse()` becomes:
+    ```golang
+    func parse(p *parser, line string) (result, error) {
+        return parseFields(line)
+    }
+
+    func parse(p *parser) {
+        // ...
+        r, err := parse(p, in.Text())
+		if err != nil {
+			return fmt.Errorf("line %d: %v", p.lines, err)
+        }
+        // ...
+    }
+    ```
+
+    + remove `parse()`
+    + call `parseFields` directly in `parse()`:
+    ```go
+	var (
+		l  = 1
+		in = bufio.NewScanner(os.Stdin)
+	)
+
+	for in.Scan() {
+		r, err := parseFields(in.Text())
+		if err != nil {
+			return fmt.Errorf("line %d: %v", l, err)
+		}
+
+		update(p, r)
+		l++
+    }
+    ```

interfaces/log-parser/refactor-notes/refactor-01/main.go

@@ -0,0 +1,23 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	p := newParser()
+
+	if err := parse(p); err != nil {
+		fmt.Println("> Err:", err)
+		return
+	}
+
+	summarize(p)
+}

interfaces/log-parser/refactor-notes/refactor-01/parser.go

@@ -0,0 +1,57 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// parser keeps track of the parsing
+type parser struct {
+	sum     map[string]result // metrics per domain
+	domains []string          // unique domain names
+}
+
+// newParser constructs, initializes and returns a new parser
+func newParser() *parser {
+	return &parser{sum: make(map[string]result)}
+}
+
+// parse the log lines and return results
+func parse(p *parser) error {
+	var (
+		l  = 1
+		in = bufio.NewScanner(os.Stdin)
+	)
+
+	for in.Scan() {
+		r, err := parseResult(in.Text())
+		if err != nil {
+			return fmt.Errorf("line %d: %v", l, err)
+		}
+
+		l++
+
+		update(p, r)
+	}
+
+	return in.Err()
+}
+
+// update the parsing results
+func update(p *parser, r result) {
+	// Collect the unique domains
+	if _, ok := p.sum[r.domain]; !ok {
+		p.domains = append(p.domains, r.domain)
+	}
+
+	// create and assign a new copy of `visit`
+	p.sum[r.domain] = addResult(r, p.sum[r.domain])
+}

interfaces/log-parser/refactor-notes/refactor-01/result.go

@@ -0,0 +1,53 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const fieldsLength = 4
+
+// result stores the parsed result for a domain
+type result struct {
+	domain, page    string
+	visits, uniques int
+	// add more metrics if needed
+}
+
+// parseResult from a log line
+func parseResult(line string) (r result, err error) {
+	fields := strings.Fields(line)
+	if len(fields) != fieldsLength {
+		return r, fmt.Errorf("wrong input: %v", fields)
+	}
+
+	r.domain = fields[0]
+	r.page = fields[1]
+
+	r.visits, err = strconv.Atoi(fields[2])
+	if err != nil || r.visits < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[2])
+	}
+
+	r.uniques, err = strconv.Atoi(fields[3])
+	if err != nil || r.uniques < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[3])
+	}
+
+	return r, nil
+}
+
+// addResult to another one
+func addResult(r, other result) result {
+	r.visits += other.visits
+	r.uniques += other.uniques
+	return r
+}

interfaces/log-parser/refactor-notes/refactor-01/summarize.go

@@ -0,0 +1,48 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// summarize summarizes and prints the parsing result
+// + violation: accesses the parsing internals: p.domains + p.sum + p.total
+// + give it the []result only.
+// + let it calculate the total.
+const (
+
+	//          DOMAINS PAGES VISITS UNIQUES
+	//             ^      ^     ^    ^
+	//             |      |     |    |
+	header     = "%-25s %-10s %10s %10s\n"
+	line       = "%-25s %-10s %10d %10d\n"
+	footer     = "\n%-36s %10d %10d\n" // -> "" VISITS UNIQUES
+	dash       = "-"
+	dashLength = 58
+)
+
+// summarize summarizes and prints the parsing result
+func summarize(p *parser) {
+	sort.Strings(p.domains)
+
+	fmt.Printf(header, "DOMAIN", "PAGES", "VISITS", "UNIQUES")
+	fmt.Println(strings.Repeat("-", dashLength))
+
+	var total result
+
+	for _, domain := range p.domains {
+		r := p.sum[domain]
+		total = addResult(total, r)
+
+		fmt.Printf(line, r.domain, r.page, r.visits, r.uniques)
+	}
+	fmt.Printf(footer, "TOTAL", total.visits, total.uniques)
+}

interfaces/log-parser/refactor-notes/refactor-02/changes.md

@@ -0,0 +1,20 @@
+### PROBLEM
++ `summarize()` knows a lot about the internals of the `parser`.
+  + coupled to the `parser`.
+
+## SOLUTION
++ remove: `parser.go` `sum` and `domains` fields
+  + remove: `parser.go/newParser()`
+  + change: `parser.go/parse(p *parser) error` -> `parse() ([]result, error)`
+  + initialize: `sum` inside `parse()`
+  + remove: `update()`
+  + call: `sum` update in the `parse()`
+  + collect the grouped results and return them from `parser()`
+
++ `summarize(p *parser)` -> `summarize([]result)`
++ in `summarize()`
+  + `sort.Slice`
+  + range over `[]result`
+
++ `main.go`
+  + just: `res, err := parse()`

interfaces/log-parser/refactor-notes/refactor-02/main.go

@@ -0,0 +1,22 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	res, err := parse()
+	if err != nil {
+		fmt.Println("> Err:", err)
+		return
+	}
+
+	summarize(res)
+}

interfaces/log-parser/refactor-notes/refactor-02/parser.go

@@ -0,0 +1,48 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// parser keeps track of the parsing
+type parser struct {
+}
+
+// parse the log lines and return results
+func parse() ([]result, error) {
+	var (
+		l   = 1
+		in  = bufio.NewScanner(os.Stdin)
+		sum = make(map[string]result)
+	)
+
+	// parse the log lines
+	for in.Scan() {
+		r, err := parseResult(in.Text())
+		if err != nil {
+			return nil, fmt.Errorf("line %d: %v", l, err)
+		}
+
+		l++
+
+		// group the log lines by domain
+		sum[r.domain] = addResult(r, sum[r.domain])
+	}
+
+	// collect the grouped results
+	res := make([]result, 0, len(sum))
+	for _, r := range sum {
+		res = append(res, r)
+	}
+
+	return res, in.Err()
+}

interfaces/log-parser/refactor-notes/refactor-02/result.go

@@ -0,0 +1,53 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const fieldsLength = 4
+
+// result stores the parsed result for a domain
+type result struct {
+	domain, page    string
+	visits, uniques int
+	// add more metrics if needed
+}
+
+// parseResult from a log line
+func parseResult(line string) (r result, err error) {
+	fields := strings.Fields(line)
+	if len(fields) != fieldsLength {
+		return r, fmt.Errorf("wrong input: %v", fields)
+	}
+
+	r.domain = fields[0]
+	r.page = fields[1]
+
+	r.visits, err = strconv.Atoi(fields[2])
+	if err != nil || r.visits < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[2])
+	}
+
+	r.uniques, err = strconv.Atoi(fields[3])
+	if err != nil || r.uniques < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[3])
+	}
+
+	return r, nil
+}
+
+// addResult to another one
+func addResult(r, other result) result {
+	r.visits += other.visits
+	r.uniques += other.uniques
+	return r
+}

interfaces/log-parser/refactor-notes/refactor-02/summarize.go

@@ -0,0 +1,49 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// summarize summarizes and prints the parsing result
+// + violation: accesses the parsing internals: p.domains + p.sum + p.total
+// + give it the []result only.
+// + let it calculate the total.
+const (
+
+	//          DOMAINS PAGES VISITS UNIQUES
+	//             ^      ^     ^    ^
+	//             |      |     |    |
+	header     = "%-25s %-10s %10s %10s\n"
+	line       = "%-25s %-10s %10d %10d\n"
+	footer     = "\n%-36s %10d %10d\n" // -> "" VISITS UNIQUES
+	dash       = "-"
+	dashLength = 58
+)
+
+// summarize summarizes and prints the parsing result
+func summarize(res []result) {
+	// sort.Strings(p.domains)
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].domain <= res[j].domain
+	})
+
+	fmt.Printf(header, "DOMAIN", "PAGES", "VISITS", "UNIQUES")
+	fmt.Println(strings.Repeat("-", dashLength))
+
+	var total result
+
+	for _, r := range res {
+		total = addResult(total, r)
+		fmt.Printf(line, r.domain, r.page, r.visits, r.uniques)
+	}
+	fmt.Printf(footer, "TOTAL", total.visits, total.uniques)
+}

interfaces/log-parser/refactor-notes/refactor-03-deprecated/changes.md

@@ -0,0 +1,14 @@
+### PROBLEM
++ `parser.go/parse()` also does updating. back to square one.
+  + we need to extract the reusable behavior: scanning.
+
++ inflexible:
+  + adding a filter is hard. needs to change the `scan()` code.
+  + adding a grouper is also hard. domain grouping is hardcoded.
+
+## SOLUTION
++ 
+
+## IDEAS:
+
++ make domain filter accept variadic args

interfaces/log-parser/refactor-notes/refactor-03-deprecated/main.go

@@ -0,0 +1,36 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+)
+
+/*
+p := pipeline{
+	read:     textReader(os.Stdin),
+	write:    textWriter(os.Stdout),
+	filterBy: notUsing(domainExtFilter("io")),
+	groupBy:  domainGrouper,
+}
+
+if err := start(p); err != nil {
+	fmt.Println("> Err:", err)
+}
+*/
+
+func main() {
+	p := newParser()
+
+	if err := parse(p); err != nil {
+		fmt.Println("> Err:", err)
+		return
+	}
+
+	summarize(p)
+}

interfaces/log-parser/refactor-notes/refactor-03-deprecated/parser.go

@@ -0,0 +1,40 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+// parser keeps track of the parsing
+type parser struct {
+	sum     map[string]result // metrics per domain
+	domains []string          // unique domain names
+}
+
+// newParser constructs, initializes and returns a new parser
+func newParser() *parser {
+	return &parser{sum: make(map[string]result)}
+}
+
+// parse all the log lines and update the results
+func parse(p *parser) error {
+	process := func(r result) {
+		update(p, r)
+	}
+
+	err := scan(process)
+
+	return err
+}
+
+func update(p *parser, r result) {
+	// Collect the unique domains
+	if _, ok := p.sum[r.domain]; !ok {
+		p.domains = append(p.domains, r.domain)
+	}
+
+	// create and assign a new copy of `visit`
+	p.sum[r.domain] = addResult(r, p.sum[r.domain])
+}

interfaces/log-parser/refactor-notes/refactor-03-deprecated/result.go

@@ -0,0 +1,53 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const fieldsLength = 4
+
+// result stores the parsed result for a domain
+type result struct {
+	domain, page    string
+	visits, uniques int
+	// add more metrics if needed
+}
+
+// parseResult from a log line
+func parseResult(line string) (r result, err error) {
+	fields := strings.Fields(line)
+	if len(fields) != fieldsLength {
+		return r, fmt.Errorf("wrong input: %v", fields)
+	}
+
+	r.domain = fields[0]
+	r.page = fields[1]
+
+	r.visits, err = strconv.Atoi(fields[2])
+	if err != nil || r.visits < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[2])
+	}
+
+	r.uniques, err = strconv.Atoi(fields[3])
+	if err != nil || r.uniques < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[3])
+	}
+
+	return r, nil
+}
+
+// addResult to another one
+func addResult(r, other result) result {
+	r.visits += other.visits
+	r.uniques += other.uniques
+	return r
+}

interfaces/log-parser/refactor-notes/refactor-03-deprecated/scanner.go

@@ -0,0 +1,35 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+type processFn func(r result)
+
+func scan(process processFn) error {
+	var (
+		l  = 1
+		in = bufio.NewScanner(os.Stdin)
+	)
+
+	for in.Scan() {
+		r, err := parseResult(in.Text())
+		if err != nil {
+			return fmt.Errorf("line %d: %v", l, err)
+		}
+
+		l++
+
+		process(r)
+	}
+	return in.Err()
+}

interfaces/log-parser/refactor-notes/refactor-03-deprecated/summarize.go

@@ -0,0 +1,48 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// summarize summarizes and prints the parsing result
+// + violation: accesses the parsing internals: p.domains + p.sum + p.total
+// + give it the []result only.
+// + let it calculate the total.
+const (
+
+	//          DOMAINS PAGES VISITS UNIQUES
+	//             ^      ^     ^    ^
+	//             |      |     |    |
+	header     = "%-25s %-10s %10s %10s\n"
+	line       = "%-25s %-10s %10d %10d\n"
+	footer     = "\n%-36s %10d %10d\n" // -> "" VISITS UNIQUES
+	dash       = "-"
+	dashLength = 58
+)
+
+// summarize summarizes and prints the parsing result
+func summarize(p *parser) {
+	sort.Strings(p.domains)
+
+	fmt.Printf(header, "DOMAIN", "PAGES", "VISITS", "UNIQUES")
+	fmt.Println(strings.Repeat("-", dashLength))
+
+	var total result
+
+	for _, domain := range p.domains {
+		r := p.sum[domain]
+		total = addResult(total, r)
+
+		fmt.Printf(line, r.domain, r.page, r.visits, r.uniques)
+	}
+	fmt.Printf(footer, "TOTAL", total.visits, total.uniques)
+}

interfaces/log-parser/refactor-notes/refactor-03/changes.md

@@ -0,0 +1,7 @@
+### PROBLEM
++ ...
+
+## SOLUTION
++ `parser struct` -> `pipeline struct`
++ `parse()` -> `pipe(pipeline)`
+

interfaces/log-parser/refactor-notes/refactor-03/main.go

@@ -0,0 +1,29 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	pipes := pipeline{
+		// read:     textParser(),
+		// write:    textSummary(),
+		// filterBy: notUsing(domainExtFilter("io", "com")),
+		// groupBy:  domainGrouper,
+	}
+
+	res, err := pipe(pipes)
+	if err != nil {
+		fmt.Println("> Err:", err)
+		return
+	}
+
+	summarize(res)
+}

interfaces/log-parser/refactor-notes/refactor-03/parser.go

@@ -0,0 +1,48 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// pipeline determines the behavior of log processing
+type pipeline struct {
+}
+
+// pipe the log lines through funcs and produce a result
+func pipe(opts pipeline) ([]result, error) {
+	var (
+		l   = 1
+		in  = bufio.NewScanner(os.Stdin)
+		sum = make(map[string]result)
+	)
+
+	// parse the log lines
+	for in.Scan() {
+		r, err := parseResult(in.Text())
+		if err != nil {
+			return nil, fmt.Errorf("line %d: %v", l, err)
+		}
+
+		l++
+
+		// group the log lines by domain
+		sum[r.domain] = addResult(r, sum[r.domain])
+	}
+
+	// collect the grouped results
+	res := make([]result, 0, len(sum))
+	for _, r := range sum {
+		res = append(res, r)
+	}
+
+	return res, in.Err()
+}

interfaces/log-parser/refactor-notes/refactor-03/result.go

@@ -0,0 +1,53 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const fieldsLength = 4
+
+// result stores the parsed result for a domain
+type result struct {
+	domain, page    string
+	visits, uniques int
+	// add more metrics if needed
+}
+
+// parseResult from a log line
+func parseResult(line string) (r result, err error) {
+	fields := strings.Fields(line)
+	if len(fields) != fieldsLength {
+		return r, fmt.Errorf("wrong input: %v", fields)
+	}
+
+	r.domain = fields[0]
+	r.page = fields[1]
+
+	r.visits, err = strconv.Atoi(fields[2])
+	if err != nil || r.visits < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[2])
+	}
+
+	r.uniques, err = strconv.Atoi(fields[3])
+	if err != nil || r.uniques < 0 {
+		return r, fmt.Errorf("wrong input: %q", fields[3])
+	}
+
+	return r, nil
+}
+
+// addResult to another one
+func addResult(r, other result) result {
+	r.visits += other.visits
+	r.uniques += other.uniques
+	return r
+}

interfaces/log-parser/refactor-notes/refactor-03/summarize.go

@@ -0,0 +1,48 @@
+// For more tutorials: https://blog.learngoprogramming.com
+//
+// Copyright © 2018 Inanc Gumus
+// Learn Go Programming Course
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+//
+
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// summarize summarizes and prints the parsing result
+// + violation: accesses the parsing internals: p.domains + p.sum + p.total
+// + give it the []result only.
+// + let it calculate the total.
+const (
+
+	//          DOMAINS PAGES VISITS UNIQUES
+	//             ^      ^     ^    ^
+	//             |      |     |    |
+	header     = "%-25s %-10s %10s %10s\n"
+	line       = "%-25s %-10s %10d %10d\n"
+	footer     = "\n%-36s %10d %10d\n" // -> "" VISITS UNIQUES
+	dash       = "-"
+	dashLength = 58
+)
+
+// summarize summarizes and prints the parsing result
+func summarize(res []result) {
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].domain <= res[j].domain
+	})
+
+	fmt.Printf(header, "DOMAIN", "PAGES", "VISITS", "UNIQUES")
+	fmt.Println(strings.Repeat("-", dashLength))
+
+	var total result
+
+	for _, r := range res {
+		total = addResult(total, r)
+		fmt.Printf(line, r.domain, r.page, r.visits, r.uniques)
+	}
+	fmt.Printf(footer, "TOTAL", total.visits, total.uniques)
+}