blob: bb1f85b946a4aeb11b87340064f525a2935bad66 [file] [log] [blame]
// 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 pipeline
import (
"fmt"
"go/build"
"io"
"path/filepath"
"regexp"
"sort"
"strings"
"text/template"
"golang.org/x/text/collate"
"golang.org/x/text/feature/plural"
"golang.org/x/text/internal"
"golang.org/x/text/internal/catmsg"
"golang.org/x/text/internal/gen"
"golang.org/x/text/language"
"golang.org/x/tools/go/loader"
)
var transRe = regexp.MustCompile(`messages\.(.*)\.json`)
// Generate writes a Go file that defines a Catalog with translated messages.
// Translations are retrieved from s.Messages, not s.Translations, so it
// is assumed Merge has been called.
func (s *State) Generate() error {
path := s.Config.GenPackage
if path == "" {
path = "."
}
isDir := path[0] == '.'
prog, err := loadPackages(&loader.Config{}, []string{path})
if err != nil {
return wrap(err, "could not load package")
}
pkgs := prog.InitialPackages()
if len(pkgs) != 1 {
return errorf("more than one package selected: %v", pkgs)
}
pkg := pkgs[0].Pkg.Name()
cw, err := s.generate()
if err != nil {
return err
}
if !isDir {
gopath := filepath.SplitList(build.Default.GOPATH)[0]
path = filepath.Join(gopath, "src", filepath.FromSlash(pkgs[0].Pkg.Path()))
}
if filepath.IsAbs(s.Config.GenFile) {
path = s.Config.GenFile
} else {
path = filepath.Join(path, s.Config.GenFile)
}
cw.WriteGoFile(path, pkg) // TODO: WriteGoFile should return error.
return err
}
// WriteGen writes a Go file with the given package name to w that defines a
// Catalog with translated messages. Translations are retrieved from s.Messages,
// not s.Translations, so it is assumed Merge has been called.
func (s *State) WriteGen(w io.Writer, pkg string) error {
cw, err := s.generate()
if err != nil {
return err
}
_, err = cw.WriteGo(w, pkg, "")
return err
}
// Generate is deprecated; use (*State).Generate().
func Generate(w io.Writer, pkg string, extracted *Messages, trans ...Messages) (n int, err error) {
s := State{
Extracted: *extracted,
Translations: trans,
}
cw, err := s.generate()
if err != nil {
return 0, err
}
return cw.WriteGo(w, pkg, "")
}
func (s *State) generate() (*gen.CodeWriter, error) {
// Build up index of translations and original messages.
translations := map[language.Tag]map[string]Message{}
languages := []language.Tag{}
usedKeys := map[string]int{}
for _, loc := range s.Messages {
tag := loc.Language
if _, ok := translations[tag]; !ok {
translations[tag] = map[string]Message{}
languages = append(languages, tag)
}
for _, m := range loc.Messages {
if !m.Translation.IsEmpty() {
for _, id := range m.ID {
if _, ok := translations[tag][id]; ok {
warnf("Duplicate translation in locale %q for message %q", tag, id)
}
translations[tag][id] = m
}
}
}
}
// Verify completeness and register keys.
internal.SortTags(languages)
langVars := []string{}
for _, tag := range languages {
langVars = append(langVars, strings.Replace(tag.String(), "-", "_", -1))
dict := translations[tag]
for _, msg := range s.Extracted.Messages {
for _, id := range msg.ID {
if trans, ok := dict[id]; ok && !trans.Translation.IsEmpty() {
if _, ok := usedKeys[msg.Key]; !ok {
usedKeys[msg.Key] = len(usedKeys)
}
break
}
// TODO: log missing entry.
warnf("%s: Missing entry for %q.", tag, id)
}
}
}
cw := gen.NewCodeWriter()
x := &struct {
Fallback language.Tag
Languages []string
}{
Fallback: s.Extracted.Language,
Languages: langVars,
}
if err := lookup.Execute(cw, x); err != nil {
return nil, wrap(err, "error")
}
keyToIndex := []string{}
for k := range usedKeys {
keyToIndex = append(keyToIndex, k)
}
sort.Strings(keyToIndex)
fmt.Fprint(cw, "var messageKeyToIndex = map[string]int{\n")
for _, k := range keyToIndex {
fmt.Fprintf(cw, "%q: %d,\n", k, usedKeys[k])
}
fmt.Fprint(cw, "}\n\n")
for i, tag := range languages {
dict := translations[tag]
a := make([]string, len(usedKeys))
for _, msg := range s.Extracted.Messages {
for _, id := range msg.ID {
if trans, ok := dict[id]; ok && !trans.Translation.IsEmpty() {
m, err := assemble(&msg, &trans.Translation)
if err != nil {
return nil, wrap(err, "error")
}
_, leadWS, trailWS := trimWS(msg.Key)
if leadWS != "" || trailWS != "" {
m = catmsg.Affix{
Message: m,
Prefix: leadWS,
Suffix: trailWS,
}
}
// TODO: support macros.
data, err := catmsg.Compile(tag, nil, m)
if err != nil {
return nil, wrap(err, "error")
}
key := usedKeys[msg.Key]
if d := a[key]; d != "" && d != data {
warnf("Duplicate non-consistent translation for key %q, picking the one for message %q", msg.Key, id)
}
a[key] = string(data)
break
}
}
}
index := []uint32{0}
p := 0
for _, s := range a {
p += len(s)
index = append(index, uint32(p))
}
cw.WriteVar(langVars[i]+"Index", index)
cw.WriteConst(langVars[i]+"Data", strings.Join(a, ""))
}
return cw, nil
}
func assemble(m *Message, t *Text) (msg catmsg.Message, err error) {
keys := []string{}
for k := range t.Var {
keys = append(keys, k)
}
sort.Strings(keys)
var a []catmsg.Message
for _, k := range keys {
t := t.Var[k]
m, err := assemble(m, &t)
if err != nil {
return nil, err
}
a = append(a, &catmsg.Var{Name: k, Message: m})
}
if t.Select != nil {
s, err := assembleSelect(m, t.Select)
if err != nil {
return nil, err
}
a = append(a, s)
}
if t.Msg != "" {
sub, err := m.Substitute(t.Msg)
if err != nil {
return nil, err
}
a = append(a, catmsg.String(sub))
}
switch len(a) {
case 0:
return nil, errorf("generate: empty message")
case 1:
return a[0], nil
default:
return catmsg.FirstOf(a), nil
}
}
func assembleSelect(m *Message, s *Select) (msg catmsg.Message, err error) {
cases := []string{}
for c := range s.Cases {
cases = append(cases, c)
}
sortCases(cases)
caseMsg := []interface{}{}
for _, c := range cases {
cm := s.Cases[c]
m, err := assemble(m, &cm)
if err != nil {
return nil, err
}
caseMsg = append(caseMsg, c, m)
}
ph := m.Placeholder(s.Arg)
switch s.Feature {
case "plural":
// TODO: only printf-style selects are supported as of yet.
return plural.Selectf(ph.ArgNum, ph.String, caseMsg...), nil
}
return nil, errorf("unknown feature type %q", s.Feature)
}
func sortCases(cases []string) {
// TODO: implement full interface.
sort.Slice(cases, func(i, j int) bool {
switch {
case cases[i] != "other" && cases[j] == "other":
return true
case cases[i] == "other" && cases[j] != "other":
return false
}
// the following code relies on '<' < '=' < any letter.
return cmpNumeric(cases[i], cases[j]) == -1
})
}
var cmpNumeric = collate.New(language.Und, collate.Numeric).CompareString
var lookup = template.Must(template.New("gen").Parse(`
import (
"golang.org/x/text/language"
"golang.org/x/text/message"
"golang.org/x/text/message/catalog"
)
type dictionary struct {
index []uint32
data string
}
func (d *dictionary) Lookup(key string) (data string, ok bool) {
p, ok := messageKeyToIndex[key]
if !ok {
return "", false
}
start, end := d.index[p], d.index[p+1]
if start == end {
return "", false
}
return d.data[start:end], true
}
func init() {
dict := map[string]catalog.Dictionary{
{{range .Languages}}"{{.}}": &dictionary{index: {{.}}Index, data: {{.}}Data },
{{end}}
}
fallback := language.MustParse("{{.Fallback}}")
cat, err := catalog.NewFromMap(dict, catalog.Fallback(fallback))
if err != nil {
panic(err)
}
message.DefaultCatalog = cat
}
`))