use istio client-go library instead of knative (#1661)

use istio client-go library instead of knative
bump kubernetes dependency version
change code coverage to codecov

vendor/sigs.k8s.io/controller-tools/pkg/genall/help/pretty/print.go

@@ -0,0 +1,304 @@
+package pretty
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/fatih/color"
+)
+
+// NB(directxman12): this isn't particularly elegant, but it's also
+// sufficiently simple as to be maintained here.   Man (roff) would've
+// probably worked, but it's not necessarily on Windows by default.
+
+// Span is a chunk of content that is writable to an output, but knows how to
+// calculate its apparent visual "width" on the terminal (not to be confused
+// with the raw length, which may include zero-width coloring sequences).
+type Span interface {
+	// VisualLength reports the "width" as perceived by the user on the terminal
+	// (i.e. widest line, ignoring ANSI escape characters).
+	VisualLength() int
+	// WriteTo writes the full span contents to the given writer.
+	WriteTo(io.Writer) error
+}
+
+// Table is a Span that writes its data in table form, with sizing controlled
+// by the given table calculator.  Rows are started with StartRow, followed by
+// some calls to Column, followed by a call to EndRow.  Once all rows are
+// added, the table can be used as a Span.
+type Table struct {
+	Sizing *TableCalculator
+
+	cellsByRow [][]Span
+	colSizes   []int
+}
+
+// StartRow starts a new row.
+// It must eventually be followed by EndRow.
+func (t *Table) StartRow() {
+	t.cellsByRow = append(t.cellsByRow, []Span(nil))
+}
+
+// EndRow ends the currently started row.
+func (t *Table) EndRow() {
+	lastRow := t.cellsByRow[len(t.cellsByRow)-1]
+	sizes := make([]int, len(lastRow))
+	for i, cell := range lastRow {
+		sizes[i] = cell.VisualLength()
+	}
+	t.Sizing.AddRowSizes(sizes...)
+}
+
+// Column adds the given span as a new column to the current row.
+func (t *Table) Column(contents Span) {
+	currentRowInd := len(t.cellsByRow) - 1
+	t.cellsByRow[currentRowInd] = append(t.cellsByRow[currentRowInd], contents)
+}
+
+// SkipRow prints a span without having it contribute to the table calculation.
+func (t *Table) SkipRow(contents Span) {
+	t.cellsByRow = append(t.cellsByRow, []Span{contents})
+}
+
+func (t *Table) WriteTo(out io.Writer) error {
+	if t.colSizes == nil {
+		t.colSizes = t.Sizing.ColumnWidths()
+	}
+
+	for _, cells := range t.cellsByRow {
+		currentPosition := 0
+		for colInd, cell := range cells {
+			colSize := t.colSizes[colInd]
+			diff := colSize - cell.VisualLength()
+
+			if err := cell.WriteTo(out); err != nil {
+				return err
+			}
+
+			if diff > 0 {
+				if err := writePadding(out, columnPadding, diff); err != nil {
+					return err
+				}
+			}
+			currentPosition += colSize
+		}
+
+		if _, err := fmt.Fprint(out, "\n"); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (t *Table) VisualLength() int {
+	if t.colSizes == nil {
+		t.colSizes = t.Sizing.ColumnWidths()
+	}
+
+	res := 0
+	for _, colSize := range t.colSizes {
+		res += colSize
+	}
+	return res
+}
+
+// Text is a span that simply contains raw text.  It's a good starting point.
+type Text string
+
+func (t Text) VisualLength() int { return len(t) }
+func (t Text) WriteTo(w io.Writer) error {
+	_, err := w.Write([]byte(t))
+	return err
+}
+
+// indented is a span that indents all lines by the given number of tabs.
+type indented struct {
+	Amount  int
+	Content Span
+}
+
+func (i *indented) VisualLength() int { return i.Content.VisualLength() }
+func (i *indented) WriteTo(w io.Writer) error {
+	var out bytes.Buffer
+	if err := i.Content.WriteTo(&out); err != nil {
+		return err
+	}
+
+	lines := bytes.Split(out.Bytes(), []byte("\n"))
+	for lineInd, line := range lines {
+		if lineInd != 0 {
+			if _, err := w.Write([]byte("\n")); err != nil {
+				return err
+			}
+		}
+		if len(line) == 0 {
+			continue
+		}
+
+		if err := writePadding(w, indentPadding, i.Amount); err != nil {
+			return err
+		}
+		if _, err := w.Write(line); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Indented returns a span that indents all lines by the given number of tabs.
+func Indented(amt int, content Span) Span {
+	return &indented{Amount: amt, Content: content}
+}
+
+// fromWriter is a span that takes content from a function expecting a Writer.
+type fromWriter struct {
+	cache      []byte
+	cacheError error
+	run        func(io.Writer) error
+}
+
+func (f *fromWriter) VisualLength() int {
+	if f.cache == nil {
+		var buf bytes.Buffer
+		if err := f.run(&buf); err != nil {
+			f.cacheError = err
+		}
+		f.cache = buf.Bytes()
+	}
+	return len(f.cache)
+}
+func (f *fromWriter) WriteTo(w io.Writer) error {
+	if f.cache != nil {
+		if f.cacheError != nil {
+			return f.cacheError
+		}
+		_, err := w.Write(f.cache)
+		return err
+	}
+	return f.run(w)
+}
+
+// FromWriter returns a span that takes content from a function expecting a Writer.
+func FromWriter(run func(io.Writer) error) Span {
+	return &fromWriter{run: run}
+}
+
+// Decoration represents a terminal decoration.
+type Decoration color.Color
+
+// Containing returns a Span that has the given decoration applied.
+func (d Decoration) Containing(contents Span) Span {
+	return &decorated{
+		Contents:   contents,
+		Attributes: color.Color(d),
+	}
+}
+
+// decorated is a span that has some terminal decoration applied.
+type decorated struct {
+	Contents   Span
+	Attributes color.Color
+}
+
+func (d *decorated) VisualLength() int { return d.Contents.VisualLength() }
+func (d *decorated) WriteTo(w io.Writer) error {
+	oldOut := color.Output
+	color.Output = w
+	defer func() { color.Output = oldOut }()
+
+	d.Attributes.Set()
+	defer color.Unset()
+
+	return d.Contents.WriteTo(w)
+}
+
+// SpanWriter is a span that contains multiple sub-spans.
+type SpanWriter struct {
+	contents []Span
+}
+
+func (m *SpanWriter) VisualLength() int {
+	res := 0
+	for _, span := range m.contents {
+		res += span.VisualLength()
+	}
+	return res
+}
+func (m *SpanWriter) WriteTo(w io.Writer) error {
+	for _, span := range m.contents {
+		if err := span.WriteTo(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Print adds a new span to this SpanWriter.
+func (m *SpanWriter) Print(s Span) {
+	m.contents = append(m.contents, s)
+}
+
+// lines is a span that adds some newlines, optionally followed by some content.
+type lines struct {
+	content      Span
+	amountBefore int
+}
+
+func (l *lines) VisualLength() int {
+	if l.content == nil {
+		return 0
+	}
+	return l.content.VisualLength()
+}
+func (l *lines) WriteTo(w io.Writer) error {
+	if err := writePadding(w, linesPadding, l.amountBefore); err != nil {
+		return err
+	}
+	if l.content != nil {
+		if err := l.content.WriteTo(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Newlines returns a span just containing some newlines.
+func Newlines(amt int) Span {
+	return &lines{amountBefore: amt}
+}
+
+// Line returns a span that emits a newline, followed by the given content.
+func Line(content Span) Span {
+	return &lines{amountBefore: 1, content: content}
+}
+
+var (
+	columnPadding = []byte("                                                                       ")
+	indentPadding = []byte("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t")
+	linesPadding  = []byte("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
+)
+
+// writePadding writes out padding of the given type in the given amount to the writer.
+// Each byte in the padding buffer contributes 1 to the amount -- the padding being
+// a buffer is just for efficiency.
+func writePadding(out io.Writer, typ []byte, amt int) error {
+	if amt <= len(typ) {
+		_, err := out.Write(typ[:amt])
+		return err
+	}
+
+	num := amt / len(typ)
+	rem := amt % len(typ)
+	for i := 0; i < num; i++ {
+		if _, err := out.Write(typ); err != nil {
+			return err
+		}
+	}
+
+	if _, err := out.Write(typ[:rem]); err != nil {
+		return err
+	}
+	return nil
+}