From 54d3d47daf9190275bbdaf8703b84969a4593451 Mon Sep 17 00:00:00 2001 From: Corey Hulen Date: Fri, 24 Mar 2017 23:31:34 -0700 Subject: PLT-6076 Adding viper libs for config file changes (#5871) * Adding viper libs for config file changes * Removing the old fsnotify lib * updating some missing libs --- vendor/golang.org/x/text/message/message.go | 185 ++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 vendor/golang.org/x/text/message/message.go (limited to 'vendor/golang.org/x/text/message/message.go') diff --git a/vendor/golang.org/x/text/message/message.go b/vendor/golang.org/x/text/message/message.go new file mode 100644 index 000000000..32ff3ef90 --- /dev/null +++ b/vendor/golang.org/x/text/message/message.go @@ -0,0 +1,185 @@ +// Copyright 2015 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 message implements formatted I/O for localized strings with functions +// analogous to the fmt's print functions. +// +// NOTE: Under construction. See https://golang.org/design/12750-localization +// and its corresponding proposal issue https://golang.org/issues/12750. +package message // import "golang.org/x/text/message" + +import ( + "fmt" + "io" + "strings" + + "golang.org/x/text/internal/format" + "golang.org/x/text/language" +) + +// A Printer implements language-specific formatted I/O analogous to the fmt +// package. Only one goroutine may use a Printer at the same time. +type Printer struct { + tag language.Tag + + cat *Catalog + + // NOTE: limiting one goroutine per Printer allows for many optimizations + // and simplifications. We can consider removing this restriction down the + // road if it the benefits do not seem to outweigh the disadvantages. +} + +// NewPrinter returns a Printer that formats messages tailored to language t. +func NewPrinter(t language.Tag) *Printer { + return DefaultCatalog.Printer(t) +} + +// Sprint is like fmt.Sprint, but using language-specific formatting. +func (p *Printer) Sprint(a ...interface{}) string { + return fmt.Sprint(p.bindArgs(a)...) +} + +// Fprint is like fmt.Fprint, but using language-specific formatting. +func (p *Printer) Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, p.bindArgs(a)...) +} + +// Print is like fmt.Print, but using language-specific formatting. +func (p *Printer) Print(a ...interface{}) (n int, err error) { + return fmt.Print(p.bindArgs(a)...) +} + +// Sprintln is like fmt.Sprintln, but using language-specific formatting. +func (p *Printer) Sprintln(a ...interface{}) string { + return fmt.Sprintln(p.bindArgs(a)...) +} + +// Fprintln is like fmt.Fprintln, but using language-specific formatting. +func (p *Printer) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, p.bindArgs(a)...) +} + +// Println is like fmt.Println, but using language-specific formatting. +func (p *Printer) Println(a ...interface{}) (n int, err error) { + return fmt.Println(p.bindArgs(a)...) +} + +// Sprintf is like fmt.Sprintf, but using language-specific formatting. +func (p *Printer) Sprintf(key Reference, a ...interface{}) string { + msg, hasSub := p.lookup(key) + if !hasSub { + return fmt.Sprintf(msg) // work around limitation of fmt + } + return fmt.Sprintf(msg, p.bindArgs(a)...) +} + +// Fprintf is like fmt.Fprintf, but using language-specific formatting. +func (p *Printer) Fprintf(w io.Writer, key Reference, a ...interface{}) (n int, err error) { + msg, hasSub := p.lookup(key) + if !hasSub { + return fmt.Fprintf(w, msg) // work around limitation of fmt + } + return fmt.Fprintf(w, msg, p.bindArgs(a)...) +} + +// Printf is like fmt.Printf, but using language-specific formatting. +func (p *Printer) Printf(key Reference, a ...interface{}) (n int, err error) { + msg, hasSub := p.lookup(key) + if !hasSub { + return fmt.Printf(msg) // work around limitation of fmt + } + return fmt.Printf(msg, p.bindArgs(a)...) +} + +func (p *Printer) lookup(r Reference) (msg string, hasSub bool) { + var id string + switch v := r.(type) { + case string: + id, msg = v, v + case key: + id, msg = v.id, v.fallback + default: + panic("key argument is not a Reference") + } + if s, ok := p.cat.get(p.tag, id); ok { + msg = s + } + // fmt does not allow all arguments to be dropped in a format string. It + // only allows arguments to be dropped if at least one of the substitutions + // uses the positional marker (e.g. %[1]s). This hack works around this. + // TODO: This is only an approximation of the parsing of substitution + // patterns. Make more precise once we know if we can get by with fmt's + // formatting, which may not be the case. + for i := 0; i < len(msg)-1; i++ { + if msg[i] == '%' { + for i++; i < len(msg); i++ { + if strings.IndexByte("[]#+- *01234567890.", msg[i]) < 0 { + break + } + } + if i < len(msg) && msg[i] != '%' { + hasSub = true + break + } + } + } + return msg, hasSub +} + +// A Reference is a string or a message reference. +type Reference interface { +} + +// Key creates a message Reference for a message where the given id is used for +// message lookup and the fallback is returned when no matches are found. +func Key(id string, fallback string) Reference { + return key{id, fallback} +} + +type key struct { + id, fallback string +} + +// bindArgs wraps arguments with implementation of fmt.Formatter, if needed. +func (p *Printer) bindArgs(a []interface{}) []interface{} { + out := make([]interface{}, len(a)) + for i, x := range a { + switch v := x.(type) { + case fmt.Formatter: + // Wrap the value with a Formatter that augments the State with + // language-specific attributes. + out[i] = &value{v, p} + + // NOTE: as we use fmt.Formatter, we can't distinguish between + // regular and localized formatters, so we always need to wrap it. + + // TODO: handle + // - numbers + // - lists + // - time? + default: + out[i] = x + } + } + return out +} + +// state implements "golang.org/x/text/internal/format".State. +type state struct { + fmt.State + p *Printer +} + +func (s *state) Language() language.Tag { return s.p.tag } + +var _ format.State = &state{} + +type value struct { + x fmt.Formatter + p *Printer +} + +func (v *value) Format(s fmt.State, verb rune) { + v.x.Format(&state{s, v.p}, verb) +} -- cgit v1.2.3-1-g7c22