message.go

Documentation: golang.org/x/text/message

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package message // import "golang.org/x/text/message"
     6  
     7  import (
     8  	"io"
     9  	"os"
    10  
    11  	// Include features to facilitate generated catalogs.
    12  	_ "golang.org/x/text/feature/plural"
    13  
    14  	"golang.org/x/text/internal/number"
    15  	"golang.org/x/text/language"
    16  	"golang.org/x/text/message/catalog"
    17  )
    18  
    19  // A Printer implements language-specific formatted I/O analogous to the fmt
    20  // package.
    21  type Printer struct {
    22  	// the language
    23  	tag language.Tag
    24  
    25  	toDecimal    number.Formatter
    26  	toScientific number.Formatter
    27  
    28  	cat catalog.Catalog
    29  }
    30  
    31  type options struct {
    32  	cat catalog.Catalog
    33  	// TODO:
    34  	// - allow %s to print integers in written form (tables are likely too large
    35  	//   to enable this by default).
    36  	// - list behavior
    37  	//
    38  }
    39  
    40  // An Option defines an option of a Printer.
    41  type Option func(o *options)
    42  
    43  // Catalog defines the catalog to be used.
    44  func Catalog(c catalog.Catalog) Option {
    45  	return func(o *options) { o.cat = c }
    46  }
    47  
    48  // NewPrinter returns a Printer that formats messages tailored to language t.
    49  func NewPrinter(t language.Tag, opts ...Option) *Printer {
    50  	options := &options{
    51  		cat: DefaultCatalog,
    52  	}
    53  	for _, o := range opts {
    54  		o(options)
    55  	}
    56  	p := &Printer{
    57  		tag: t,
    58  		cat: options.cat,
    59  	}
    60  	p.toDecimal.InitDecimal(t)
    61  	p.toScientific.InitScientific(t)
    62  	return p
    63  }
    64  
    65  // Sprint is like fmt.Sprint, but using language-specific formatting.
    66  func (p *Printer) Sprint(a ...interface{}) string {
    67  	pp := newPrinter(p)
    68  	pp.doPrint(a)
    69  	s := pp.String()
    70  	pp.free()
    71  	return s
    72  }
    73  
    74  // Fprint is like fmt.Fprint, but using language-specific formatting.
    75  func (p *Printer) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
    76  	pp := newPrinter(p)
    77  	pp.doPrint(a)
    78  	n64, err := io.Copy(w, &pp.Buffer)
    79  	pp.free()
    80  	return int(n64), err
    81  }
    82  
    83  // Print is like fmt.Print, but using language-specific formatting.
    84  func (p *Printer) Print(a ...interface{}) (n int, err error) {
    85  	return p.Fprint(os.Stdout, a...)
    86  }
    87  
    88  // Sprintln is like fmt.Sprintln, but using language-specific formatting.
    89  func (p *Printer) Sprintln(a ...interface{}) string {
    90  	pp := newPrinter(p)
    91  	pp.doPrintln(a)
    92  	s := pp.String()
    93  	pp.free()
    94  	return s
    95  }
    96  
    97  // Fprintln is like fmt.Fprintln, but using language-specific formatting.
    98  func (p *Printer) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
    99  	pp := newPrinter(p)
   100  	pp.doPrintln(a)
   101  	n64, err := io.Copy(w, &pp.Buffer)
   102  	pp.free()
   103  	return int(n64), err
   104  }
   105  
   106  // Println is like fmt.Println, but using language-specific formatting.
   107  func (p *Printer) Println(a ...interface{}) (n int, err error) {
   108  	return p.Fprintln(os.Stdout, a...)
   109  }
   110  
   111  // Sprintf is like fmt.Sprintf, but using language-specific formatting.
   112  func (p *Printer) Sprintf(key Reference, a ...interface{}) string {
   113  	pp := newPrinter(p)
   114  	lookupAndFormat(pp, key, a)
   115  	s := pp.String()
   116  	pp.free()
   117  	return s
   118  }
   119  
   120  // Fprintf is like fmt.Fprintf, but using language-specific formatting.
   121  func (p *Printer) Fprintf(w io.Writer, key Reference, a ...interface{}) (n int, err error) {
   122  	pp := newPrinter(p)
   123  	lookupAndFormat(pp, key, a)
   124  	n, err = w.Write(pp.Bytes())
   125  	pp.free()
   126  	return n, err
   127  
   128  }
   129  
   130  // Printf is like fmt.Printf, but using language-specific formatting.
   131  func (p *Printer) Printf(key Reference, a ...interface{}) (n int, err error) {
   132  	pp := newPrinter(p)
   133  	lookupAndFormat(pp, key, a)
   134  	n, err = os.Stdout.Write(pp.Bytes())
   135  	pp.free()
   136  	return n, err
   137  }
   138  
   139  func lookupAndFormat(p *printer, r Reference, a []interface{}) {
   140  	p.fmt.Reset(a)
   141  	switch v := r.(type) {
   142  	case string:
   143  		if p.catContext.Execute(v) == catalog.ErrNotFound {
   144  			p.Render(v)
   145  			return
   146  		}
   147  	case key:
   148  		if p.catContext.Execute(v.id) == catalog.ErrNotFound &&
   149  			p.catContext.Execute(v.fallback) == catalog.ErrNotFound {
   150  			p.Render(v.fallback)
   151  			return
   152  		}
   153  	default:
   154  		panic("key argument is not a Reference")
   155  	}
   156  }
   157  
   158  type rawPrinter struct {
   159  	p *printer
   160  }
   161  
   162  func (p rawPrinter) Render(msg string)     { p.p.WriteString(msg) }
   163  func (p rawPrinter) Arg(i int) interface{} { return nil }
   164  
   165  // Arg implements catmsg.Renderer.
   166  func (p *printer) Arg(i int) interface{} { // TODO, also return "ok" bool
   167  	i--
   168  	if uint(i) < uint(len(p.fmt.Args)) {
   169  		return p.fmt.Args[i]
   170  	}
   171  	return nil
   172  }
   173  
   174  // Render implements catmsg.Renderer.
   175  func (p *printer) Render(msg string) {
   176  	p.doPrintf(msg)
   177  }
   178  
   179  // A Reference is a string or a message reference.
   180  type Reference interface {
   181  	// TODO: also allow []string
   182  }
   183  
   184  // Key creates a message Reference for a message where the given id is used for
   185  // message lookup and the fallback is returned when no matches are found.
   186  func Key(id string, fallback string) Reference {
   187  	return key{id, fallback}
   188  }
   189  
   190  type key struct {
   191  	id, fallback string
   192  }
   193
View as plain text