Checking in vendor folder for ease of using go get.

vendor/golang.org/x/text/number/doc.go

@@ -0,0 +1,28 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package number formats numbers according to the customs of different locales.
+//
+// The number formats of this package allow for greater formatting flexibility
+// than passing values to message.Printf calls as is. It currently supports the
+// builtin Go types and anything that implements the Convert interface
+// (currently internal).
+//
+//    p := message.NewPrinter(language.English)
+//
+//    p.Printf("%v bottles of beer on the wall.", number.Decimal(1234))
+//    // Prints: 1,234 bottles of beer on the wall.
+//
+//    p.Printf("%v of gophers lose too much fur", number.Percent(0.12))
+//    // Prints: 12% of gophers lose too much fur.
+//
+//    p := message.NewPrinter(language.Dutch)
+//
+//    p.Printf("There are %v bikes per household.", number.Decimal(1.2))
+//    // Prints: Er zijn 1,2 fietsen per huishouden.
+//
+//
+// The width and scale specified in the formatting directives override the
+// configuration of the formatter.
+package number

vendor/golang.org/x/text/number/examples_test.go

@@ -0,0 +1,28 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number_test
+
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+	"golang.org/x/text/number"
+)
+
+func ExampleMaxIntegerDigits() {
+	const year = 1999
+	p := message.NewPrinter(language.English)
+	p.Println("Year:", number.Decimal(year, number.MaxIntegerDigits(2)))
+
+	// Output:
+	// Year: 99
+}
+
+func ExampleIncrementString() {
+	p := message.NewPrinter(language.English)
+
+	p.Println(number.Decimal(1.33, number.IncrementString("0.50")))
+
+	// Output: 1.50
+}

vendor/golang.org/x/text/number/format.go

@@ -0,0 +1,122 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/text/feature/plural"
+	"golang.org/x/text/internal/format"
+	"golang.org/x/text/internal/number"
+	"golang.org/x/text/language"
+)
+
+// A FormatFunc formates a number.
+type FormatFunc func(x interface{}, opts ...Option) Formatter
+
+// NewFormat creates a FormatFunc based on another FormatFunc and new options.
+// Use NewFormat to cash the creation of formatters.
+func NewFormat(format FormatFunc, opts ...Option) FormatFunc {
+	o := *format(nil).options
+	n := len(o.options)
+	o.options = append(o.options[:n:n], opts...)
+	return func(x interface{}, opts ...Option) Formatter {
+		return newFormatter(&o, opts, x)
+	}
+}
+
+type options struct {
+	verbs      string
+	initFunc   initFunc
+	options    []Option
+	pluralFunc func(t language.Tag, scale int) (f plural.Form, n int)
+}
+
+type optionFlag uint16
+
+const (
+	hasScale optionFlag = 1 << iota
+	hasPrecision
+	noSeparator
+	exact
+)
+
+type initFunc func(f *number.Formatter, t language.Tag)
+
+func newFormatter(o *options, opts []Option, value interface{}) Formatter {
+	if len(opts) > 0 {
+		n := *o
+		n.options = opts
+		o = &n
+	}
+	return Formatter{o, value}
+}
+
+func newOptions(verbs string, f initFunc) *options {
+	return &options{verbs: verbs, initFunc: f}
+}
+
+type Formatter struct {
+	*options
+	value interface{}
+}
+
+// Format implements format.Formatter. It is for internal use only for now.
+func (f Formatter) Format(state format.State, verb rune) {
+	// TODO: consider implementing fmt.Formatter instead and using the following
+	// piece of code. This allows numbers to be rendered mostly as expected
+	// when using fmt. But it may get weird with the spellout options and we
+	// may need more of format.State over time.
+	// lang := language.Und
+	// if s, ok := state.(format.State); ok {
+	// 	lang = s.Language()
+	// }
+
+	lang := state.Language()
+	if !strings.Contains(f.verbs, string(verb)) {
+		fmt.Fprintf(state, "%%!%s(%T=%v)", string(verb), f.value, f.value)
+		return
+	}
+	var p number.Formatter
+	f.initFunc(&p, lang)
+	for _, o := range f.options.options {
+		o(lang, &p)
+	}
+	if w, ok := state.Width(); ok {
+		p.FormatWidth = uint16(w)
+	}
+	if prec, ok := state.Precision(); ok {
+		switch verb {
+		case 'd':
+			p.SetScale(0)
+		case 'f':
+			p.SetScale(prec)
+		case 'e':
+			p.SetPrecision(prec + 1)
+		case 'g':
+			p.SetPrecision(prec)
+		}
+	}
+	var d number.Decimal
+	d.Convert(p.RoundingContext, f.value)
+	state.Write(p.Format(nil, &d))
+}
+
+// Digits returns information about which logical digits will be presented to
+// the user. This information is relevant, for instance, to determine plural
+// forms.
+func (f Formatter) Digits(buf []byte, tag language.Tag, scale int) number.Digits {
+	var p number.Formatter
+	f.initFunc(&p, tag)
+	if scale >= 0 {
+		// TODO: this only works well for decimal numbers, which is generally
+		// fine.
+		p.SetScale(scale)
+	}
+	var d number.Decimal
+	d.Convert(p.RoundingContext, f.value)
+	return number.FormatDigits(&d, p.RoundingContext)
+}

vendor/golang.org/x/text/number/format_test.go

@@ -0,0 +1,112 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number
+
+import (
+	"fmt"
+	"testing"
+
+	"golang.org/x/text/feature/plural"
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+)
+
+func TestWrongVerb(t *testing.T) {
+	testCases := []struct {
+		f    Formatter
+		fmt  string
+		want string
+	}{{
+		f:    Decimal(12),
+		fmt:  "%e",
+		want: "%!e(int=12)",
+	}, {
+		f:    Scientific(12),
+		fmt:  "%f",
+		want: "%!f(int=12)",
+	}, {
+		f:    Engineering(12),
+		fmt:  "%f",
+		want: "%!f(int=12)",
+	}, {
+		f:    Percent(12),
+		fmt:  "%e",
+		want: "%!e(int=12)",
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			tag := language.Und
+			got := message.NewPrinter(tag).Sprintf(tc.fmt, tc.f)
+			if got != tc.want {
+				t.Errorf("got %q; want %q", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestDigits(t *testing.T) {
+	testCases := []struct {
+		f     Formatter
+		scale int
+		want  string
+	}{{
+		f:     Decimal(3),
+		scale: 0,
+		want:  "digits:[3] exp:1 comma:0 end:1",
+	}, {
+		f:     Decimal(3.1),
+		scale: 0,
+		want:  "digits:[3] exp:1 comma:0 end:1",
+	}, {
+		f:     Scientific(3.1),
+		scale: 0,
+		want:  "digits:[3] exp:1 comma:1 end:1",
+	}, {
+		f:     Scientific(3.1),
+		scale: 3,
+		want:  "digits:[3 1] exp:1 comma:1 end:4",
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			d := tc.f.Digits(nil, language.Croatian, tc.scale)
+			got := fmt.Sprintf("digits:%d exp:%d comma:%d end:%d", d.Digits, d.Exp, d.Comma, d.End)
+			if got != tc.want {
+				t.Errorf("got %v; want %v", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestPluralIntegration(t *testing.T) {
+	testCases := []struct {
+		f    Formatter
+		want string
+	}{{
+		f:    Decimal(1),
+		want: "one: 1",
+	}, {
+		f:    Decimal(5),
+		want: "other: 5",
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			message.Set(language.English, "num %f", plural.Selectf(1, "%f",
+				"one", "one: %f",
+				"other", "other: %f"))
+
+			p := message.NewPrinter(language.English)
+
+			// Indirect the call to p.Sprintf through the variable f
+			// to avoid Go tip failing a vet check.
+			// TODO: remove once vet check has been fixed. See Issue #22936.
+			f := p.Sprintf
+			got := f("num %f", tc.f)
+
+			if got != tc.want {
+				t.Errorf("got %q; want %q", got, tc.want)
+			}
+		})
+	}
+}

vendor/golang.org/x/text/number/number.go

@@ -0,0 +1,77 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number
+
+// TODO:
+//    p.Printf("The gauge was at %v.", number.Spell(number.Percent(23)))
+//    // Prints: The gauge was at twenty-three percent.
+//
+//    p.Printf("From here to %v!", number.Spell(math.Inf()))
+//    // Prints: From here to infinity!
+//
+
+import (
+	"golang.org/x/text/internal/number"
+)
+
+const (
+	decimalVerbs    = "vfgd"
+	scientificVerbs = "veg"
+)
+
+// Decimal formats a number as a floating point decimal.
+func Decimal(x interface{}, opts ...Option) Formatter {
+	return newFormatter(decimalOptions, opts, x)
+}
+
+var decimalOptions = newOptions(decimalVerbs, (*number.Formatter).InitDecimal)
+
+// Scientific formats a number in scientific format.
+func Scientific(x interface{}, opts ...Option) Formatter {
+	return newFormatter(scientificOptions, opts, x)
+}
+
+var scientificOptions = newOptions(scientificVerbs, (*number.Formatter).InitScientific)
+
+// Engineering formats a number using engineering notation, which is like
+// scientific notation, but with the exponent normalized to multiples of 3.
+func Engineering(x interface{}, opts ...Option) Formatter {
+	return newFormatter(engineeringOptions, opts, x)
+}
+
+var engineeringOptions = newOptions(scientificVerbs, (*number.Formatter).InitEngineering)
+
+// Percent formats a number as a percentage. A value of 1.0 means 100%.
+func Percent(x interface{}, opts ...Option) Formatter {
+	return newFormatter(percentOptions, opts, x)
+}
+
+var percentOptions = newOptions(decimalVerbs, (*number.Formatter).InitPercent)
+
+// PerMille formats a number as a per mille indication. A value of 1.0 means
+// 1000‰.
+func PerMille(x interface{}, opts ...Option) Formatter {
+	return newFormatter(perMilleOptions, opts, x)
+}
+
+var perMilleOptions = newOptions(decimalVerbs, (*number.Formatter).InitPerMille)
+
+// TODO:
+// - Shortest: akin to verb 'g' of 'G'
+//
+// TODO: RBNF forms:
+// - Compact: 1M 3.5T
+// - CompactBinary: 1Mi 3.5Ti
+// - Long: 1 million
+// - Ordinal:
+// - Roman: MCMIIXX
+// - RomanSmall: mcmiixx
+// - Text: numbers as it typically appears in running text, allowing
+//   language-specific choices for when to use numbers and when to use words.
+// - Spell?: spelled-out number. Maybe just allow as an option?
+
+// NOTE: both spelled-out numbers and ordinals, to render correctly, need
+// detailed linguistic information from the translated string into which they
+// are substituted. We will need to implement that first.

vendor/golang.org/x/text/number/number_test.go

@@ -0,0 +1,190 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number
+
+import (
+	"strings"
+	"testing"
+
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+)
+
+func TestFormatter(t *testing.T) {
+	overrides := map[string]string{
+		"en": "*e#######0",
+		"nl": "*n#######0",
+	}
+	testCases := []struct {
+		desc string
+		tag  string
+		f    Formatter
+		want string
+	}{{
+		desc: "decimal",
+		f:    Decimal(3),
+		want: "3",
+	}, {
+		desc: "decimal fraction",
+		f:    Decimal(0.123),
+		want: "0.123",
+	}, {
+		desc: "separators",
+		f:    Decimal(1234.567),
+		want: "1,234.567",
+	}, {
+		desc: "no separators",
+		f:    Decimal(1234.567, NoSeparator()),
+		want: "1234.567",
+	}, {
+		desc: "max integer",
+		f:    Decimal(1973, MaxIntegerDigits(2)),
+		want: "73",
+	}, {
+		desc: "max integer overflow",
+		f:    Decimal(1973, MaxIntegerDigits(1000)),
+		want: "1,973",
+	}, {
+		desc: "min integer",
+		f:    Decimal(12, MinIntegerDigits(5)),
+		want: "00,012",
+	}, {
+		desc: "max fraction zero",
+		f:    Decimal(0.12345, MaxFractionDigits(0)),
+		want: "0",
+	}, {
+		desc: "max fraction 2",
+		f:    Decimal(0.12, MaxFractionDigits(2)),
+		want: "0.12",
+	}, {
+		desc: "min fraction 2",
+		f:    Decimal(0.12, MaxFractionDigits(2)),
+		want: "0.12",
+	}, {
+		desc: "max fraction overflow",
+		f:    Decimal(0.125, MaxFractionDigits(1e6)),
+		want: "0.125",
+	}, {
+		desc: "min integer overflow",
+		f:    Decimal(0, MinIntegerDigits(1e6)),
+		want: strings.Repeat("000,", 255/3-1) + "000",
+	}, {
+		desc: "min fraction overflow",
+		f:    Decimal(0, MinFractionDigits(1e6)),
+		want: "0." + strings.Repeat("0", 255), // TODO: fraction separators
+	}, {
+		desc: "format width",
+		f:    Decimal(123, FormatWidth(10)),
+		want: "       123",
+	}, {
+		desc: "format width pad option before",
+		f:    Decimal(123, Pad('*'), FormatWidth(10)),
+		want: "*******123",
+	}, {
+		desc: "format width pad option after",
+		f:    Decimal(123, FormatWidth(10), Pad('*')),
+		want: "*******123",
+	}, {
+		desc: "format width illegal",
+		f:    Decimal(123, FormatWidth(-1)),
+		want: "123",
+	}, {
+		desc: "increment",
+		f:    Decimal(10.33, IncrementString("0.5")),
+		want: "10.5",
+	}, {
+		desc: "increment",
+		f:    Decimal(10, IncrementString("ppp")),
+		want: "10",
+	}, {
+		desc: "increment and scale",
+		f:    Decimal(10.33, IncrementString("0.5"), Scale(2)),
+		want: "10.50",
+	}, {
+		desc: "pattern overrides en",
+		tag:  "en",
+		f:    Decimal(101, PatternOverrides(overrides)),
+		want: "eeeee101",
+	}, {
+		desc: "pattern overrides nl",
+		tag:  "nl",
+		f:    Decimal(101, PatternOverrides(overrides)),
+		want: "nnnnn101",
+	}, {
+		desc: "pattern overrides de",
+		tag:  "de",
+		f:    Decimal(101, PatternOverrides(overrides)),
+		want: "101",
+	}, {
+		desc: "language selection",
+		tag:  "bn",
+		f:    Decimal(123456.78, Scale(2)),
+		want: "১,২৩,৪৫৬.৭৮",
+	}, {
+		desc: "scale",
+		f:    Decimal(1234.567, Scale(2)),
+		want: "1,234.57",
+	}, {
+		desc: "scientific",
+		f:    Scientific(3.00),
+		want: "3\u202f×\u202f10⁰",
+	}, {
+		desc: "scientific",
+		f:    Scientific(1234),
+		want: "1.234\u202f×\u202f10³",
+	}, {
+		desc: "scientific",
+		f:    Scientific(1234, Scale(2)),
+		want: "1.23\u202f×\u202f10³",
+	}, {
+		desc: "engineering",
+		f:    Engineering(12345),
+		want: "12.345\u202f×\u202f10³",
+	}, {
+		desc: "engineering scale",
+		f:    Engineering(12345, Scale(2)),
+		want: "12.34\u202f×\u202f10³",
+	}, {
+		desc: "engineering precision(4)",
+		f:    Engineering(12345, Precision(4)),
+		want: "12.34\u202f×\u202f10³",
+	}, {
+		desc: "engineering precision(2)",
+		f:    Engineering(1234.5, Precision(2)),
+		want: "1.2\u202f×\u202f10³",
+	}, {
+		desc: "percent",
+		f:    Percent(0.12),
+		want: "12%",
+	}, {
+		desc: "permille",
+		f:    PerMille(0.123),
+		want: "123‰",
+	}, {
+		desc: "percent rounding",
+		f:    PerMille(0.12345),
+		want: "123‰",
+	}, {
+		desc: "percent fraction",
+		f:    PerMille(0.12345, Scale(2)),
+		want: "123.45‰",
+	}, {
+		desc: "percent fraction",
+		f:    PerMille(0.12344, Scale(1)),
+		want: "123.4‰",
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			tag := language.Und
+			if tc.tag != "" {
+				tag = language.MustParse(tc.tag)
+			}
+			got := message.NewPrinter(tag).Sprint(tc.f)
+			if got != tc.want {
+				t.Errorf("got %q; want %q", got, tc.want)
+			}
+		})
+	}
+}

vendor/golang.org/x/text/number/option.go

@@ -0,0 +1,177 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package number
+
+import (
+	"fmt"
+
+	"golang.org/x/text/internal/number"
+	"golang.org/x/text/language"
+)
+
+// An Option configures a Formatter.
+type Option option
+
+type option func(tag language.Tag, f *number.Formatter)
+
+// TODO: SpellOut requires support of the ICU RBNF format.
+// func SpellOut() Option
+
+// NoSeparator causes a number to be displayed without grouping separators.
+func NoSeparator() Option {
+	return func(t language.Tag, f *number.Formatter) {
+		f.GroupingSize = [2]uint8{}
+	}
+}
+
+// MaxIntegerDigits limits the number of integer digits, eliminating the
+// most significant digits.
+func MaxIntegerDigits(max int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		if max >= 1<<8 {
+			max = (1 << 8) - 1
+		}
+		f.MaxIntegerDigits = uint8(max)
+	}
+}
+
+// MinIntegerDigits specifies the minimum number of integer digits, adding
+// leading zeros when needed.
+func MinIntegerDigits(min int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		if min >= 1<<8 {
+			min = (1 << 8) - 1
+		}
+		f.MinIntegerDigits = uint8(min)
+	}
+}
+
+// MaxFractionDigits specifies the maximum number of fractional digits.
+func MaxFractionDigits(max int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		if max >= 1<<15 {
+			max = (1 << 15) - 1
+		}
+		f.MaxFractionDigits = int16(max)
+	}
+}
+
+// MinFractionDigits specifies the minimum number of fractional digits.
+func MinFractionDigits(min int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		if min >= 1<<8 {
+			min = (1 << 8) - 1
+		}
+		f.MinFractionDigits = uint8(min)
+	}
+}
+
+// Precision sets the maximum number of significant digits. A negative value
+// means exact.
+func Precision(prec int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		f.SetPrecision(prec)
+	}
+}
+
+// Scale simultaneously sets MinFractionDigits and MaxFractionDigits to the
+// given value.
+func Scale(decimals int) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		f.SetScale(decimals)
+	}
+}
+
+// IncrementString sets the incremental value to which numbers should be
+// rounded. For instance: Increment("0.05") will cause 1.44 to round to 1.45.
+// IncrementString also sets scale to the scale of the increment.
+func IncrementString(decimal string) Option {
+	increment := 0
+	scale := 0
+	d := decimal
+	p := 0
+	for ; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ {
+		increment *= 10
+		increment += int(d[p]) - '0'
+	}
+	if p < len(d) && d[p] == '.' {
+		for p++; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ {
+			increment *= 10
+			increment += int(d[p]) - '0'
+			scale++
+		}
+	}
+	if p < len(d) {
+		increment = 0
+		scale = 0
+	}
+	return func(t language.Tag, f *number.Formatter) {
+		f.Increment = uint32(increment)
+		f.IncrementScale = uint8(scale)
+		f.SetScale(scale)
+	}
+}
+
+func noop(language.Tag, *number.Formatter) {}
+
+// PatternOverrides allows users to specify alternative patterns for specific
+// languages. The Pattern will be overridden for all languages in a subgroup as
+// well. The function will panic for invalid input. It is best to create this
+// option at startup time.
+// PatternOverrides must be the first Option passed to a formatter.
+func PatternOverrides(patterns map[string]string) Option {
+	// TODO: make it so that it does not have to be the first option.
+	// TODO: use -x-nochild to indicate it does not override child tags.
+	m := map[language.Tag]*number.Pattern{}
+	for k, v := range patterns {
+		tag := language.MustParse(k)
+		p, err := number.ParsePattern(v)
+		if err != nil {
+			panic(fmt.Errorf("number: PatternOverrides: %v", err))
+		}
+		m[tag] = p
+	}
+	return func(t language.Tag, f *number.Formatter) {
+		// TODO: Use language grouping relation instead of parent relation.
+		// TODO: Should parent implement the grouping relation?
+		for lang := t; ; lang = t.Parent() {
+			if p, ok := m[lang]; ok {
+				f.Pattern = *p
+				break
+			}
+			if lang == language.Und {
+				break
+			}
+		}
+	}
+}
+
+// FormatWidth sets the total format width.
+func FormatWidth(n int) Option {
+	if n <= 0 {
+		return noop
+	}
+	return func(t language.Tag, f *number.Formatter) {
+		f.FormatWidth = uint16(n)
+		if f.PadRune == 0 {
+			f.PadRune = ' '
+		}
+	}
+}
+
+// Pad sets the rune to be used for filling up to the format width.
+func Pad(r rune) Option {
+	return func(t language.Tag, f *number.Formatter) {
+		f.PadRune = r
+	}
+}
+
+// TODO:
+// - FormatPosition (using type aliasing?)
+// - Multiplier: find a better way to represent and figure out what to do
+//   with clashes with percent/permille.
+// - NumberingSystem(nu string): not accessable in number.Info now. Also, should
+//      this be keyed by language or generic?
+// - SymbolOverrides(symbols map[string]map[number.SymbolType]string) Option