report.go

package main

// What a finding is, and how it reaches the screen.

import (
	"fmt"
	"io"
	"sort"
	"strings"
)

type Severity int

const (
	// Note is worth knowing and not worth worrying about.
	Note Severity = iota
	// Warn narrows down who you are or where you go.
	Warn
	// Alarm puts you somewhere specific, or is actively broadcasting.
	Alarm
)

func (s Severity) tag() string {
	switch s {
	case Alarm:
		return "TELLS  "
	case Warn:
		return "NARROWS"
	}
	return "NOTE   "
}

type Finding struct {
	Severity Severity
	Title    string
	Lines    []string
	// Advice is what somebody does about it. A finding without it is a
	// finding nobody acts on.
	Advice string
}

type Report struct {
	Findings []Finding
	// Gaps are the things this run could not read. They print first,
	// because they change how everything under them should be read.
	Gaps []string
}

func (r *Report) add(f Finding) { r.Findings = append(r.Findings, f) }

func (r *Report) worst() Severity {
	worst := Note
	for _, f := range r.Findings {
		if f.Severity > worst {
			worst = f.Severity
		}
	}
	return worst
}

const (
	indent = "             "
	wrap   = 62
)

func (r *Report) render(out io.Writer, title string) {
	fmt.Fprintf(out, "\n  %s\n  %s\n\n", title, strings.Repeat("=", min(len(title), wrap+13)))

	for _, g := range r.Gaps {
		block(out, "UNREAD ", "Something here could not be read", nil, g)
	}

	// Loudest first. Somebody who reads the first screen and stops should
	// have read the part that mattered.
	sorted := make([]Finding, len(r.Findings))
	copy(sorted, r.Findings)
	sort.SliceStable(sorted, func(i, j int) bool {
		return sorted[i].Severity > sorted[j].Severity
	})
	for _, f := range sorted {
		block(out, f.Severity.tag(), f.Title, f.Lines, f.Advice)
	}

	fmt.Fprintln(out, "    Nothing was changed. This only reads.")
	fmt.Fprintln(out)
}

func block(out io.Writer, tag, title string, lines []string, advice string) {
	fmt.Fprintf(out, "    [%s] %s\n", tag, title)
	for _, line := range lines {
		fmt.Fprintf(out, "%s%s\n", indent, strings.TrimRight(line, " "))
	}
	if advice != "" {
		if len(lines) > 0 {
			fmt.Fprintln(out)
		}
		for _, line := range wrapText(advice, wrap) {
			fmt.Fprintf(out, "%s%s\n", indent, line)
		}
	}
	fmt.Fprintln(out)
}

// maskName hides a network name well enough that a report pasted into a
// chat is not a list of the places you go, and leaves enough that you can
// recognise your own. Hiding it completely would defeat the point: the
// whole exercise is working out which of these you want gone.
func maskName(ssid string, reveal bool) string {
	if reveal {
		return ssid
	}
	// Word by word, so the shape of the name survives. "Casa Martinez"
	// stays two words, which is what makes it recognisable to its owner and
	// useless to anybody else.
	words := strings.Split(ssid, " ")
	for i, word := range words {
		words[i] = maskWord(word)
	}
	return strings.Join(words, " ")
}

func maskWord(s string) string {
	r := []rune(s)
	switch {
	case len(r) == 0:
		return ""
	case len(r) <= 2:
		return string(r[0]) + strings.Repeat("*", len(r)-1)
	}
	return string(r[0]) + strings.Repeat("*", len(r)-2) + string(r[len(r)-1])
}

func wrapText(s string, width int) []string {
	words := strings.Fields(s)
	if len(words) == 0 {
		return nil
	}
	var lines []string
	line := words[0]
	for _, w := range words[1:] {
		if len(line)+1+len(w) > width {
			lines = append(lines, line)
			line = w
			continue
		}
		line += " " + w
	}
	return append(lines, line)
}

func plural(n int, one, many string) string {
	if n == 1 {
		return fmt.Sprintf("%d %s", n, one)
	}
	return fmt.Sprintf("%d %s", n, many)
}

// atMost keeps a list readable. Somebody with two hundred saved networks
// does not need all two hundred printed to understand the point.
func atMost(lines []string, n int) []string {
	if len(lines) <= n {
		return lines
	}
	kept := make([]string, 0, n+1)
	kept = append(kept, lines[:n]...)
	return append(kept, fmt.Sprintf("... and %d more", len(lines)-n))
}