Upgrade k8s.io/client-go to version 2

vendor/golang.org/x/text/secure/precis/options.go

@@ -6,10 +6,10 @@ package precis
 
 import (
 	"golang.org/x/text/cases"
-	"golang.org/x/text/language"
 	"golang.org/x/text/runes"
 	"golang.org/x/text/transform"
 	"golang.org/x/text/unicode/norm"
+	"golang.org/x/text/width"
 )
 
 // An Option is used to define the behavior and rules of a Profile.
@@ -20,12 +20,11 @@ type options struct {
 	foldWidth bool
 
 	// Enforcement options
-	asciiLower    bool
-	cases         transform.SpanningTransformer
+	cases         transform.Transformer
 	disallow      runes.Set
-	norm          transform.SpanningTransformer
-	additional    []func() transform.SpanningTransformer
-	width         transform.SpanningTransformer
+	norm          norm.Form
+	additional    []func() transform.Transformer
+	width         *width.Transformer
 	disallowEmpty bool
 	bidiRule      bool
 
@@ -37,11 +36,6 @@ func getOpts(o ...Option) (res options) {
 	for _, f := range o {
 		f(&res)
 	}
-	// Using a SpanningTransformer, instead of norm.Form prevents an allocation
-	// down the road.
-	if res.norm == nil {
-		res.norm = norm.NFC
-	}
 	return
 }
 
@@ -80,36 +74,11 @@ var (
 	}
 )
 
-// TODO: move this logic to package transform
-
-type spanWrap struct{ transform.Transformer }
-
-func (s spanWrap) Span(src []byte, atEOF bool) (n int, err error) {
-	return 0, transform.ErrEndOfSpan
-}
-
-// TODO: allow different types? For instance:
-//     func() transform.Transformer
-//     func() transform.SpanningTransformer
-//     func([]byte) bool  // validation only
-//
-// Also, would be great if we could detect if a transformer is reentrant.
-
 // The AdditionalMapping option defines the additional mapping rule for the
 // Profile by applying Transformer's in sequence.
 func AdditionalMapping(t ...func() transform.Transformer) Option {
 	return func(o *options) {
-		for _, f := range t {
-			sf := func() transform.SpanningTransformer {
-				return f().(transform.SpanningTransformer)
-			}
-			if _, ok := f().(transform.SpanningTransformer); !ok {
-				sf = func() transform.SpanningTransformer {
-					return spanWrap{f()}
-				}
-			}
-			o.additional = append(o.additional, sf)
-		}
+		o.additional = t
 	}
 }
 
@@ -124,26 +93,10 @@ func Norm(f norm.Form) Option {
 // provided to determine the type of case folding used.
 func FoldCase(opts ...cases.Option) Option {
 	return func(o *options) {
-		o.asciiLower = true
 		o.cases = cases.Fold(opts...)
 	}
 }
 
-// The LowerCase option defines a Profile's case mapping rule. Options can be
-// provided to determine the type of case folding used.
-func LowerCase(opts ...cases.Option) Option {
-	return func(o *options) {
-		o.asciiLower = true
-		if len(opts) == 0 {
-			o.cases = cases.Lower(language.Und, cases.HandleFinalSigma(false))
-			return
-		}
-
-		opts = append([]cases.Option{cases.HandleFinalSigma(false)}, opts...)
-		o.cases = cases.Lower(language.Und, opts...)
-	}
-}
-
 // The Disallow option further restricts a Profile's allowed characters beyond
 // what is disallowed by the underlying string class.
 func Disallow(set runes.Set) Option {

vendor/golang.org/x/text/secure/precis/profile.go

@@ -5,12 +5,9 @@
 package precis
 
 import (
-	"bytes"
 	"errors"
 	"unicode/utf8"
 
-	"golang.org/x/text/cases"
-	"golang.org/x/text/language"
 	"golang.org/x/text/runes"
 	"golang.org/x/text/secure/bidirule"
 	"golang.org/x/text/transform"
@@ -93,80 +90,32 @@ type buffers struct {
 	next int
 }
 
-func (b *buffers) apply(t transform.SpanningTransformer) (err error) {
-	n, err := t.Span(b.src, true)
-	if err != transform.ErrEndOfSpan {
-		return err
-	}
+func (b *buffers) init(n int) {
+	b.buf[0] = make([]byte, 0, n)
+	b.buf[1] = make([]byte, 0, n)
+}
+
+func (b *buffers) apply(t transform.Transformer) (err error) {
+	// TODO: use Span, once available.
 	x := b.next & 1
-	if b.buf[x] == nil {
-		b.buf[x] = make([]byte, 0, 8+len(b.src)+len(b.src)>>2)
-	}
-	span := append(b.buf[x][:0], b.src[:n]...)
-	b.src, _, err = transform.Append(t, span, b.src[n:])
+	b.src, _, err = transform.Append(t, b.buf[x][:0], b.src)
 	b.buf[x] = b.src
 	b.next++
 	return err
 }
 
-// Pre-allocate transformers when possible. In some cases this avoids allocation.
-var (
-	foldWidthT transform.SpanningTransformer = width.Fold
-	lowerCaseT transform.SpanningTransformer = cases.Lower(language.Und, cases.HandleFinalSigma(false))
-)
-
-// TODO: make this a method on profile.
-
-func (b *buffers) enforce(p *Profile, src []byte, comparing bool) (str []byte, err error) {
+func (b *buffers) enforce(p *Profile, src []byte) (str []byte, err error) {
 	b.src = src
 
-	ascii := true
-	for _, c := range src {
-		if c >= utf8.RuneSelf {
-			ascii = false
-			break
-		}
-	}
-	// ASCII fast path.
-	if ascii {
-		for _, f := range p.options.additional {
-			if err = b.apply(f()); err != nil {
-				return nil, err
-			}
-		}
-		switch {
-		case p.options.asciiLower || (comparing && p.options.ignorecase):
-			for i, c := range b.src {
-				if 'A' <= c && c <= 'Z' {
-					b.src[i] = c ^ 1<<5
-				}
-			}
-		case p.options.cases != nil:
-			b.apply(p.options.cases)
-		}
-		c := checker{p: p}
-		if _, err := c.span(b.src, true); err != nil {
-			return nil, err
-		}
-		if p.disallow != nil {
-			for _, c := range b.src {
-				if p.disallow.Contains(rune(c)) {
-					return nil, errDisallowedRune
-				}
-			}
-		}
-		if p.options.disallowEmpty && len(b.src) == 0 {
-			return nil, errEmptyString
-		}
-		return b.src, nil
-	}
-
 	// These transforms are applied in the order defined in
 	// https://tools.ietf.org/html/rfc7564#section-7
 
 	// TODO: allow different width transforms options.
-	if p.options.foldWidth || (p.options.ignorecase && comparing) {
-		b.apply(foldWidthT)
+	if p.options.foldWidth {
+		// TODO: use Span, once available.
+		if err = b.apply(width.Fold); err != nil {
+			return nil, err
+		}
 	}
 	for _, f := range p.options.additional {
 		if err = b.apply(f()); err != nil {
@@ -174,14 +123,24 @@ func (b *buffers) enforce(p *Profile, src []byte, comparing bool) (str []byte, e
 		}
 	}
 	if p.options.cases != nil {
-		b.apply(p.options.cases)
+		if err = b.apply(p.options.cases); err != nil {
+			return nil, err
+		}
 	}
-	if comparing && p.options.ignorecase {
-		b.apply(lowerCaseT)
+	if n := p.norm.QuickSpan(b.src); n < len(b.src) {
+		x := b.next & 1
+		n = copy(b.buf[x], b.src[:n])
+		b.src, _, err = transform.Append(p.norm, b.buf[x][:n], b.src[n:])
+		b.buf[x] = b.src
+		b.next++
+		if err != nil {
+			return nil, err
+		}
 	}
-	b.apply(p.norm)
-	if p.options.bidiRule && !bidirule.Valid(b.src) {
-		return nil, bidirule.ErrInvalid
+	if p.options.bidiRule {
+		if err := b.apply(bidirule.New()); err != nil {
+			return nil, err
+		}
 	}
 	c := checker{p: p}
 	if _, err := c.span(b.src, true); err != nil {
@@ -196,6 +155,9 @@ func (b *buffers) enforce(p *Profile, src []byte, comparing bool) (str []byte, e
 			i += size
 		}
 	}
+
+	// TODO: Add the disallow empty rule with a dummy transformer?
+
 	if p.options.disallowEmpty && len(b.src) == 0 {
 		return nil, errEmptyString
 	}
@@ -206,16 +168,19 @@ func (b *buffers) enforce(p *Profile, src []byte, comparing bool) (str []byte, e
 // It returns an error if the input string is invalid.
 func (p *Profile) Append(dst, src []byte) ([]byte, error) {
 	var buf buffers
-	b, err := buf.enforce(p, src, false)
+	buf.init(8 + len(src) + len(src)>>2)
+	b, err := buf.enforce(p, src)
 	if err != nil {
 		return nil, err
 	}
 	return append(dst, b...), nil
 }
 
-func processBytes(p *Profile, b []byte, key bool) ([]byte, error) {
+// Bytes returns a new byte slice with the result of applying the profile to b.
+func (p *Profile) Bytes(b []byte) ([]byte, error) {
 	var buf buffers
-	b, err := buf.enforce(p, b, key)
+	buf.init(8 + len(b) + len(b)>>2)
+	b, err := buf.enforce(p, b)
 	if err != nil {
 		return nil, err
 	}
@@ -227,62 +192,39 @@ func processBytes(p *Profile, b []byte, key bool) ([]byte, error) {
 	return b, nil
 }
 
-// Bytes returns a new byte slice with the result of applying the profile to b.
-func (p *Profile) Bytes(b []byte) ([]byte, error) {
-	return processBytes(p, b, false)
-}
-
-// AppendCompareKey appends the result of applying p to src (including any
-// optional rules to make strings comparable or useful in a map key such as
-// applying lowercasing) writing the result to dst. It returns an error if the
-// input string is invalid.
-func (p *Profile) AppendCompareKey(dst, src []byte) ([]byte, error) {
+// String returns a string with the result of applying the profile to s.
+func (p *Profile) String(s string) (string, error) {
 	var buf buffers
-	b, err := buf.enforce(p, src, true)
-	if err != nil {
-		return nil, err
-	}
-	return append(dst, b...), nil
-}
-
-func processString(p *Profile, s string, key bool) (string, error) {
-	var buf buffers
-	b, err := buf.enforce(p, []byte(s), key)
+	buf.init(8 + len(s) + len(s)>>2)
+	b, err := buf.enforce(p, []byte(s))
 	if err != nil {
 		return "", err
 	}
 	return string(b), nil
 }
 
-// String returns a string with the result of applying the profile to s.
-func (p *Profile) String(s string) (string, error) {
-	return processString(p, s, false)
-}
-
-// CompareKey returns a string that can be used for comparison, hashing, or
-// collation.
-func (p *Profile) CompareKey(s string) (string, error) {
-	return processString(p, s, true)
-}
-
 // Compare enforces both strings, and then compares them for bit-string identity
 // (byte-for-byte equality). If either string cannot be enforced, the comparison
 // is false.
 func (p *Profile) Compare(a, b string) bool {
-	var buf buffers
-
-	akey, err := buf.enforce(p, []byte(a), true)
+	a, err := p.String(a)
+	if err != nil {
+		return false
+	}
+	b, err = p.String(b)
 	if err != nil {
 		return false
 	}
 
-	buf = buffers{}
-	bkey, err := buf.enforce(p, []byte(b), true)
-	if err != nil {
-		return false
+	// TODO: This is out of order. Need to extract the transformation logic and
+	// put this in where the normal case folding would go (but only for
+	// comparison).
+	if p.options.ignorecase {
+		a = width.Fold.String(a)
+		b = width.Fold.String(a)
 	}
 
-	return bytes.Compare(akey, bkey) == 0
+	return a == b
 }
 
 // Allowed returns a runes.Set containing every rune that is a member of the

vendor/golang.org/x/text/secure/precis/profiles.go

@@ -19,51 +19,38 @@ var (
 	OpaqueString          *Profile = opaquestring      // Implements the OpaqueString profile defined in RFC 7613 for passwords and other secure labels.
 )
 
+// TODO: mvl: "Ultimately, I would manually define the structs for the internal
+// profiles. This avoid pulling in unneeded tables when they are not used."
 var (
-	nickname = &Profile{
-		options: getOpts(
-			AdditionalMapping(func() transform.Transformer {
-				return &nickAdditionalMapping{}
-			}),
-			IgnoreCase,
-			Norm(norm.NFKC),
-			DisallowEmpty,
-		),
-		class: freeform,
-	}
-	usernameCaseMap = &Profile{
-		options: getOpts(
-			FoldWidth,
-			LowerCase(),
-			Norm(norm.NFC),
-			BidiRule,
-		),
-		class: identifier,
-	}
-	usernameNoCaseMap = &Profile{
-		options: getOpts(
-			FoldWidth,
-			Norm(norm.NFC),
-			BidiRule,
-		),
-		class: identifier,
-	}
-	opaquestring = &Profile{
-		options: getOpts(
-			AdditionalMapping(func() transform.Transformer {
-				return mapSpaces
-			}),
-			Norm(norm.NFC),
-			DisallowEmpty,
-		),
-		class: freeform,
-	}
+	nickname = NewFreeform(
+		AdditionalMapping(func() transform.Transformer {
+			return &nickAdditionalMapping{}
+		}),
+		IgnoreCase,
+		Norm(norm.NFKC),
+		DisallowEmpty,
+	)
+	usernameCaseMap = NewIdentifier(
+		FoldWidth,
+		FoldCase(),
+		Norm(norm.NFC),
+		BidiRule,
+	)
+	usernameNoCaseMap = NewIdentifier(
+		FoldWidth,
+		Norm(norm.NFC),
+		BidiRule,
+	)
+	opaquestring = NewFreeform(
+		AdditionalMapping(func() transform.Transformer {
+			return runes.Map(func(r rune) rune {
+				if unicode.Is(unicode.Zs, r) {
+					return ' '
+				}
+				return r
+			})
+		}),
+		Norm(norm.NFC),
+		DisallowEmpty,
+	)
 )
-
-// mapSpaces is a shared value of a runes.Map transformer.
-var mapSpaces transform.Transformer = runes.Map(func(r rune) rune {
-	if unicode.Is(unicode.Zs, r) {
-		return ' '
-	}
-	return r
-})