func ExampleParse_errors() {
for _, s := range []string{"Foo", "Bar", "Foobar"} {
_, err := language.Parse(s)
if err != nil {
if inv, ok := err.(language.ValueError); ok {
fmt.Println(inv.Subtag())
} else {
fmt.Println(s)
}
}
}
for _, s := range []string{"en", "aa-Uuuu", "AC", "ac-u"} {
_, err := language.Parse(s)
switch e := err.(type) {
case language.ValueError:
fmt.Printf("%s: culprit %q\n", s, e.Subtag())
case nil:
// No error.
default:
// A syntax error.
fmt.Printf("%s: ill-formed\n", s)
}
}
// Output:
// foo
// Foobar
// aa-Uuuu: culprit "Uuuu"
// AC: culprit "ac"
// ac-u: ill-formed
}
func preferredLanguages() []language.Tag {
var langs []language.Tag
// langs = append(langs, language.MustParse("es_MX"))
nav := js.Global.Get("navigator")
if cordova.IsMobile() {
var wg sync.WaitGroup
wg.Add(1)
nav.Get("globalization").Call("getPreferredLanguage",
func(l string) {
defer wg.Done()
if tag, err := language.Parse(l); err == nil {
langs = append(langs, tag)
}
}, func() {
defer wg.Done()
// ignore any error
})
wg.Wait()
}
if languages := js.Global.Get("navigator").Get("languages"); languages != nil {
for i := 0; i < languages.Length(); i++ {
if tag, err := language.Parse(languages.Index(i).String()); err == nil {
langs = append(langs, tag)
}
}
}
if tag, err := language.Parse(js.Global.Get("navigator").Get("language").String()); err == nil {
langs = append(langs, tag)
}
return langs
}
// Translate one or more strings of text from a source language to a target
// language. All inputs must be in the same language.
//
// The target parameter supplies the language to translate to. The supported
// languages are listed at
// https://cloud.google.com/translate/v2/translate-reference#supported_languages.
// You can also call the SupportedLanguages method.
//
// The returned Translations appear in the same order as the inputs.
func (c *Client) Translate(ctx context.Context, inputs []string, target language.Tag, opts *Options) ([]Translation, error) {
call := c.raw.Translations.List(inputs, target.String()).Context(ctx)
if opts != nil {
if s := opts.Source; s != language.Und {
call.Source(s.String())
}
if f := opts.Format; f != "" {
call.Format(string(f))
}
if m := opts.Model; m != "" {
call.Model(m)
}
}
res, err := call.Do()
if err != nil {
return nil, err
}
var ts []Translation
for _, t := range res.Translations {
var source language.Tag
if t.DetectedSourceLanguage != "" {
source, err = language.Parse(t.DetectedSourceLanguage)
if err != nil {
return nil, err
}
}
ts = append(ts, Translation{
Text: t.TranslatedText,
Source: source,
Model: t.Model,
})
}
return ts, nil
}
func getLangs() (tags []language.Tag) {
for _, t := range strings.Split(*langs, ",") {
tag, err := language.Parse(t)
if err != nil {
fatalf("gotext: could not parse language %q: %v", t, err)
}
tags = append(tags, tag)
}
return tags
}
// Language returns the users language code.
// Eg. "en", "es", etc
func Language() string {
l := locale()
tag, err := language.Parse(l)
if err != nil {
return defaultLanguage
}
base, _ := tag.Base()
return base.String()
}
// Region returns the users region code.
// Eg. "US", "GB", etc
func Region() string {
l := locale()
tag, err := language.Parse(l)
if err != nil {
return defaultRegion
}
region, _ := tag.Region()
return region.String()
}
// Init 初始化 locale 包并返回当前系统默认的本地化语言信息。
func Init() (language.Tag, error) {
for id, messages := range locales {
tag := language.MustParse(id)
for key, val := range messages {
message.SetString(tag, key, val)
}
}
localeName, err := getLocaleName()
if err != nil {
return language.Und, err
}
return language.Parse(localeName)
}
// 对一些堂量的基本检测。
func TestConsts(t *testing.T) {
a := assert.New(t)
a.True(version.SemVerValid(Version))
a.True(len(Name) > 0)
a.True(is.URL(RepoURL))
a.True(is.URL(OfficialURL))
a.True(len(ConfigFilename) > 0).True(strings.IndexAny(ConfigFilename, "/\\") < 0)
a.True(len(DefaultTitle) > 0)
a.True(len(DefaultGroupName) > 0).True(strings.IndexAny(DefaultGroupName, "/\\") < 0)
a.True(len(Profile) > 0).True(strings.IndexAny(Profile, "/\\") < 0)
tag, err := language.Parse(DefaultLocale)
a.NotError(err).NotEqual(tag, language.Und)
}
// parseCollation parses XML files in the collation directory of the CLDR core.zip file.
func parseCollation(b *build.Builder) {
d := &cldr.Decoder{}
d.SetDirFilter("collation")
data := decodeCLDR(d)
for _, loc := range data.Locales() {
x, err := data.LDML(loc)
failOnError(err)
if skipLang(x.Identity.Language.Type) {
continue
}
cs := x.Collations.Collation
sl := cldr.MakeSlice(&cs)
if len(types.s) == 0 {
sl.SelectAnyOf("type", x.Collations.Default())
} else if !types.all {
sl.SelectAnyOf("type", types.s...)
}
sl.SelectOnePerGroup("alt", altInclude())
for _, c := range cs {
id, err := language.Parse(loc)
if err != nil {
fmt.Fprintf(os.Stderr, "invalid locale: %q", err)
continue
}
// Support both old- and new-style defaults.
d := c.Type
if x.Collations.DefaultCollation == nil {
d = x.Collations.Default()
} else {
d = x.Collations.DefaultCollation.Data()
}
// We assume tables are being built either for search or collation,
// but not both. For search the default is always "search".
if d != c.Type && c.Type != "search" {
typ := c.Type
if len(c.Type) > 8 {
typ = typeMap[c.Type]
}
id, err = id.SetTypeForKey("co", typ)
failOnError(err)
}
t := b.Tailoring(id)
c.Process(processor{t})
}
}
}
// TypeCheck implements the Expr interface.
func (expr *CollateExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error) {
_, err := language.Parse(expr.Locale)
if err != nil {
return nil, errors.Wrapf(err, "invalid locale %s", expr.Locale)
}
subExpr, err := expr.Expr.TypeCheck(ctx, TypeString)
if err != nil {
return nil, err
}
switch t := subExpr.ResolvedType().(type) {
case tString, TCollatedString:
expr.Expr = subExpr
expr.typ = TCollatedString{expr.Locale}
return expr, nil
default:
return nil, fmt.Errorf("incompatible type for COLLATE: %s", t)
}
}
//Read all .ini files in dir, where the filenames are BCP 47 tags
//Use the language matcher to get the best match for the locale preference
func InitI18n(locale, dir string) {
pref := language.Make(locale) // falls back to en-US on parse error
files, err := ioutil.ReadDir(dir)
if err != nil {
log.Fatal(err)
}
serverLangs := make([]language.Tag, 1)
serverLangs[0] = language.AmericanEnglish // en-US fallback
for _, file := range files {
if filepath.Ext(file.Name()) == ".ini" {
name := strings.TrimSuffix(file.Name(), ".ini")
tag, err := language.Parse(name)
if err == nil {
serverLangs = append(serverLangs, tag)
}
}
}
matcher := language.NewMatcher(serverLangs)
tag, _, _ := matcher.Match(pref)
fname := filepath.Join(dir, tag.String()+".ini")
conf, err := configparser.Read(fname)
if err != nil {
log.Fatal("cannot read translation file for", tag.String(), err)
}
formats, err := conf.Section("formats")
if err != nil {
log.Fatal("Cannot read formats sections in translations for", tag.String(), err)
}
translations, err := conf.Section("strings")
if err != nil {
log.Fatal("Cannot read strings sections in translations for", tag.String(), err)
}
i18nProvider = &i18n{
translation_dir: dir,
formats: formats.Options(),
translations: translations.Options(),
locale: tag,
}
}
// SupportedLanguages returns a list of supported languages for translation.
// The target parameter is the language to use to return localized, human
// readable names of supported languages.
func (c *Client) SupportedLanguages(ctx context.Context, target language.Tag) ([]Language, error) {
call := c.raw.Languages.List().Context(ctx).Target(target.String())
res, err := call.Do()
if err != nil {
return nil, err
}
var ls []Language
for _, l := range res.Languages {
tag, err := language.Parse(l.Language)
if err != nil {
return nil, err
}
ls = append(ls, Language{
Name: l.Name,
Tag: tag,
})
}
return ls, nil
}
// DetectLanguage attempts to determine the language of the inputs. Each input
// string may be in a different language.
//
// Each slice of Detections in the return value corresponds with one input
// string. A slice of Detections holds multiple hypotheses for the language of
// a single input string.
func (c *Client) DetectLanguage(ctx context.Context, inputs []string) ([][]Detection, error) {
call := c.raw.Detections.List(inputs).Context(ctx)
res, err := call.Do()
if err != nil {
return nil, err
}
var result [][]Detection
for _, raws := range res.Detections {
var ds []Detection
for _, rd := range raws {
tag, err := language.Parse(rd.Language)
if err != nil {
return nil, err
}
ds = append(ds, Detection{
Language: tag,
Confidence: rd.Confidence,
IsReliable: rd.IsReliable,
})
}
result = append(result, ds)
}
return result, nil
}
func newColumnTableDef(
name Name, typ ColumnType, qualifications []NamedColumnQualification,
) (*ColumnTableDef, error) {
d := &ColumnTableDef{
Name: name,
Type: typ,
}
d.Nullable.Nullability = SilentNull
for _, c := range qualifications {
switch t := c.Qualification.(type) {
case ColumnCollation:
locale := string(t)
_, err := language.Parse(locale)
if err != nil {
return nil, errors.Wrapf(err, "invalid locale %s", locale)
}
switch s := d.Type.(type) {
case *StringColType:
d.Type = &CollatedStringColType{s.Name, s.N, locale}
case *CollatedStringColType:
return nil, errors.Errorf("multiple COLLATE declarations for column %q", name)
default:
return nil, errors.Errorf("COLLATE declaration for non-string-typed column %q", name)
}
case *ColumnDefault:
if d.HasDefaultExpr() {
return nil, errors.Errorf("multiple default values specified for column %q", name)
}
d.DefaultExpr.Expr = t.Expr
d.DefaultExpr.ConstraintName = c.Name
case NotNullConstraint:
if d.Nullable.Nullability == Null {
return nil, errors.Errorf("conflicting NULL/NOT NULL declarations for column %q", name)
}
d.Nullable.Nullability = NotNull
d.Nullable.ConstraintName = c.Name
case NullConstraint:
if d.Nullable.Nullability == NotNull {
return nil, errors.Errorf("conflicting NULL/NOT NULL declarations for column %q", name)
}
d.Nullable.Nullability = Null
d.Nullable.ConstraintName = c.Name
case PrimaryKeyConstraint:
d.PrimaryKey = true
d.UniqueConstraintName = c.Name
case UniqueConstraint:
d.Unique = true
d.UniqueConstraintName = c.Name
case *ColumnCheckConstraint:
d.CheckExprs = append(d.CheckExprs, ColumnTableDefCheckExpr{
Expr: t.Expr,
ConstraintName: c.Name,
})
case *ColumnFKConstraint:
if d.HasFKConstraint() {
return nil, errors.Errorf("multiple foreign key constraints specified for column %q", name)
}
d.References.Table = t.Table
d.References.Col = t.Col
d.References.ConstraintName = c.Name
case *ColumnFamilyConstraint:
if d.HasColumnFamily() {
return nil, errors.Errorf("multiple column families specified for column %q", name)
}
d.Family.Name = t.Family
d.Family.Create = t.Create
d.Family.IfNotExists = t.IfNotExists
default:
panic(fmt.Sprintf("unexpected column qualification: %T", c))
}
}
return d, nil
}
// GetLocale creates a new language Tag from a locale
func GetLocaleTag(locale string) (language.Tag, error) {
return language.Parse(locale)
}
func checkLocale(locale string) error {
_, err := language.Parse(locale)
return err
}
func main() {
tag, err := locale.Init()
if err != nil {
warn.Println(err)
info.Println("无法获取系统语言，使用默认的本化语言：", app.DefaultLocale)
tag, err = language.Parse(app.DefaultLocale)
if err != nil {
erro.Println(err)
return
}
}
locale.SetLocale(tag)
h := flag.Bool("h", false, locale.Sprintf(locale.FlagHUsage))
v := flag.Bool("v", false, locale.Sprintf(locale.FlagVUsage))
l := flag.Bool("l", false, locale.Sprintf(locale.FlagLUsage))
g := flag.Bool("g", false, locale.Sprintf(locale.FlagGUsage))
pprofType := flag.String("pprof", "", locale.Sprintf(locale.FlagPprofUsage))
flag.Usage = usage
flag.Parse()
switch {
case *h:
flag.Usage()
return
case *v:
locale.Printf(locale.FlagVersionBuildWith, app.Name, app.Version, runtime.Version())
return
case *l:
locale.Printf(locale.FlagSupportedLangs, input.Langs())
return
case *g:
path, err := getConfigFile()
if err != nil {
erro.Println(err)
return
}
if err = genConfigFile(path); err != nil {
erro.Println(err)
return
}
info.Println(locale.Sprintf(locale.FlagConfigWritedSuccess, path))
return
}
// 指定了 pprof 参数
if len(*pprofType) > 0 {
profile := filepath.Join("./", app.Profile)
f, err := os.Create(profile)
if err != nil { // 不能创建文件，则忽略 pprof 相关操作
warn.Println(err)
goto RUN
}
defer func() {
if err = f.Close(); err != nil {
erro.Println(err)
return
}
info.Println(locale.Sprintf(locale.FlagPprofWritedSuccess, profile))
}()
switch strings.ToLower(*pprofType) {
case "mem":
defer func() {
if err = pprof.Lookup("heap").WriteTo(f, 1); err != nil {
warn.Println(err)
}
}()
case "cpu":
if err := pprof.StartCPUProfile(f); err != nil {
warn.Println(err)
}
defer pprof.StopCPUProfile()
default:
erro.Println(locale.Sprintf(locale.FlagInvalidPprrof))
return
}
}
RUN:
run()
}
