what-an-hour-and-a-half-looks-like-when-wasted.go

package main

/*
package unibox

import (
	"bytes"
	"strings"
	"unicode/utf8"
)

// p := `𝕒A𝕓B𝕔C`
// fmt.Println(`trace:`, p)
// for i := -3; i < len(p)+3; i++ {
// 	fmt.Println(`  pat:`, p)
// 	fmt.Println(`  pad:`, unibox.MarkEdge(p, i))
// 	fmt.Println(`  pad:`, unibox.MarkLine(p, i))
// }

type Marker interface {
	MarkUnderflow() rune
	MarkLeft() rune
	Mark() rune
	Line() rune
	MarkRight() rune
	MarkOverflow() rune
}

type runeMarker struct {
	mu, ml, m, l, mr, mo rune
}

func (r *runeMarker) MarkUnderflow() rune { return r.mu }
func (r *runeMarker) MarkLeft() rune      { return r.ml }
func (r *runeMarker) Mark() rune          { return r.m }
func (r *runeMarker) Line() rune          { return r.l }
func (r *runeMarker) MarkRight() rune     { return r.mr }
func (r *runeMarker) MarkOverflow() rune  { return r.mo }

var (
	EdgeMarker = &runeMarker{'╙', '└', '┴', '─', '┘', '╜'}
	LineMarker = &runeMarker{'┹', '┵', '┴', '─', '┶', '┺'}
)

func MarkEdge(pat string, off int) string {
	return MarkWith(pat, off, EdgeMarker)
}

func MarkLine(pat string, off int) string {
	return MarkWith(pat, off, LineMarker)
}

func MarkRunes(pat string, off int, mu, ml, m, l, mr, mo rune) string {
	rm := runeMarker{mu, ml, m, l, mr, mo}
	return MarkWith(pat, off, &rm)
}

func MarkWith(pat string, off int, m Marker) string {
	l := m.Line()
	if off < 0 {
		return string(m.MarkUnderflow()) +
			strings.Repeat(string(l), utf8.RuneCountInString(pat)-1)
	}
	if off >= len(pat) {
		return strings.Repeat(
			string(l), utf8.RuneCountInString(pat)-1) + string(m.MarkOverflow())
	}

	var buf bytes.Buffer
	for idx, r := range pat {
		box := l
		switch {
		case idx == 0 && off < utf8.RuneLen(r):
			box, off = m.MarkLeft(), len(pat)*2
		case utf8.RuneLen(r)+idx > off:
			if off == len(pat) {
				box, off = m.MarkRight(), len(pat)*2
			} else {
				box, off = m.Mark(), len(pat)*2
			}
		}
		buf.WriteRune(box)
	}
	return buf.String()
}
*/

import (
	"bytes"
	"fmt"
	"strings"
	"unicode/utf8"
)

// // Trace is like Scan but will trace the scan to the given writer and return a
// // partial result on error.
// func Trace(w io.Writer, p string) (toks []token.Token, err error) {
// 	rl := utf8.RuneCountInString(p)
// 	l := utf8.RuneCountInString(p)
// 	if l < 12 {
// 		l = 12
// 	}
// 	bar := strings.Repeat(`─`, l-rl)
// 	ls := strconv.Itoa(l)
//
// 	top := `╔═════╤═════╤═` + strings.Repeat(`═`, l) +
// 		`═╤════════════════════════════════╗`
// 	if _, err = fmt.Fprintf(w, "%v\n", top); err != nil {
// 		return nil, err
// 	}
//
// 	head := fmt.Sprintf("║ %v │ %v │ %-"+ls+"v │ %-30v ║",
// 		`Off`, `Pos`, `Pattern (`+ls+`)`, `Token`)
// 	if _, err = fmt.Fprintln(w, head); err != nil {
// 		return nil, err
// 	}
//
// 	col := `╠═════╪═════╪═` + strings.Repeat(`═`, l) +
// 		`═╪════════════════════════════════╣`
// 	if _, err = fmt.Fprintf(w, "%v\n", col); err != nil {
// 		return nil, err
// 	}
//
// 	var s Scanner
// 	if err = s.Reset(p); err != nil {
// 		return nil, err
// 	}
// 	for s.More() {
// 		tok := s.Scan()
// 		toks = append(toks, tok)
// 		tokPad := strings.Repeat(`─`, 8-len(tok.Lex.String()))
// 		tokCol := fmt.Sprintf("%v╼%s╾ %-16q", tokPad, tok.Lex, tok.Lit)
// 		pad := trace(p, s.off)
// 		fmt.Fprintf(w, "║ %3.1d │ %3.1d │ %-"+ls+"v ├%-31v ║\n",
// 			s.off, s.pos, p, tokCol)
// 		if s.More() {
// 			fmt.Fprintf(w, "║─────┼─────┼─%v%v─┼────────────────────────────────╢\n", pad, bar)
// 		} else {
// 			fmt.Fprintf(w, "╙─────┴─────┴─%v%v─┴────────────────────────────────╜\n", pad, bar)
// 		}
// 	}
// 	return toks, s.Err()
// }

func tracePad(pat string, off int) string {
	return tracePadWith(pat, off, '╙', '└', '┴', '─', '┘', '╜')
}

func tracePadWith(pat string, off int, neg, ml, m, nf, mr, eof rune) string {
	if off < 0 {
		return string(neg) + strings.Repeat(
			string(nf), utf8.RuneCountInString(pat)-1)
	}
	if off >= len(pat) {
		return strings.Repeat(
			string(nf), utf8.RuneCountInString(pat)-1) + string(eof)
	}

	var buf bytes.Buffer
	for idx, r := range pat {
		box := nf
		switch {
		case idx == 0 && off < utf8.RuneLen(r):
			box, off = ml, len(pat)*2
		case utf8.RuneLen(r)+idx > off:
			if off == len(pat) {
				box, off = mr, len(pat)*2
			} else {
				box, off = m, len(pat)*2
			}
		}
		buf.WriteRune(box)
	}
	return buf.String()
}

func main() {
	p := `𝕒A𝕓B𝕔C𝕕`
	fmt.Println(`trace:`, p)
	for i := -1; i < len(p)+1; i++ {
		fmt.Printf(" %2.1d %v\n", i, p)
		fmt.Printf("    %v\n", tracePad(p, i))
	}

	// ╔═════╤═════╤══════════════════════════════════════════════════╤════════════════════════════════╗
	// ║ Off │ Pos │ Pattern (48)                                     │ Token                          ║
	// ╠═════╪═════╪══════════════════════════════════════════════════╪════════════════════════════════╣
	// ║   0 │   1 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼─└────────────────────────────────────────────────┼────────────────────────────────╢
	// ║   1 │   2 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼──┴───────────────────────────────────────────────┼────────────────────────────────╢
	// ║   5 │   6 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "rgs"                ║
	// ║─────┼─────┼──────┴───────────────────────────────────────────┼────────────────────────────────╢
	// ║   6 │   7 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼───────┴──────────────────────────────────────────┼────────────────────────────────╢
	// ║  11 │  12 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "orgs"               ║
	// ║─────┼─────┼────────────┴─────────────────────────────────────┼────────────────────────────────╢
	// ║  12 │  13 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼─────────────┴────────────────────────────────────┼────────────────────────────────╢
	// ║  17 │  18 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "eams"               ║
	// ║─────┼─────┼──────────────────┴───────────────────────────────┼────────────────────────────────╢
	// ║  18 │  19 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼───────────────────┴──────────────────────────────┼────────────────────────────────╢
	// ║  23 │  24 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "team"               ║
	// ║─────┼─────┼────────────────────────┴─────────────────────────┼────────────────────────────────╢
	// ║  41 │  42 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "[a-zA-Z0-9]{3-12}"  ║
	// ║─────┼─────┼──────────────────────────────────────────┴───────┼────────────────────────────────╢
	// ║  42 │  43 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼───────────────────────────────────────────┴──────┼────────────────────────────────╢
	// ║  43 │  44 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├──╼FSLASH╾ "/"                  ║
	// ║─────┼─────┼────────────────────────────────────────────┴─────┼────────────────────────────────╢
	// ║  48 │  48 │ /orgs/:orgs/teams/:team([a-zA-Z0-9]{3-12})/users ├─────╼LIT╾ "sers"               ║
	// ╙─────┴─────┴────────────────────────────────────────────────╜─┴────────────────────────────────╜

}