summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/language/examples_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/language/examples_test.go')
-rw-r--r--vendor/golang.org/x/text/language/examples_test.go413
1 files changed, 413 insertions, 0 deletions
diff --git a/vendor/golang.org/x/text/language/examples_test.go b/vendor/golang.org/x/text/language/examples_test.go
new file mode 100644
index 0000000..d5e8176
--- /dev/null
+++ b/vendor/golang.org/x/text/language/examples_test.go
@@ -0,0 +1,413 @@
+// Copyright 2013 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 language_test
+
+import (
+ "fmt"
+ "net/http"
+
+ "golang.org/x/text/language"
+)
+
+func ExampleCanonType() {
+ p := func(id string) {
+ fmt.Printf("Default(%s) -> %s\n", id, language.Make(id))
+ fmt.Printf("BCP47(%s) -> %s\n", id, language.BCP47.Make(id))
+ fmt.Printf("Macro(%s) -> %s\n", id, language.Macro.Make(id))
+ fmt.Printf("All(%s) -> %s\n", id, language.All.Make(id))
+ }
+ p("en-Latn")
+ p("sh")
+ p("zh-cmn")
+ p("bjd")
+ p("iw-Latn-fonipa-u-cu-usd")
+ // Output:
+ // Default(en-Latn) -> en-Latn
+ // BCP47(en-Latn) -> en
+ // Macro(en-Latn) -> en-Latn
+ // All(en-Latn) -> en
+ // Default(sh) -> sr-Latn
+ // BCP47(sh) -> sh
+ // Macro(sh) -> sh
+ // All(sh) -> sr-Latn
+ // Default(zh-cmn) -> cmn
+ // BCP47(zh-cmn) -> cmn
+ // Macro(zh-cmn) -> zh
+ // All(zh-cmn) -> zh
+ // Default(bjd) -> drl
+ // BCP47(bjd) -> drl
+ // Macro(bjd) -> bjd
+ // All(bjd) -> drl
+ // Default(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+ // BCP47(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+ // Macro(iw-Latn-fonipa-u-cu-usd) -> iw-Latn-fonipa-u-cu-usd
+ // All(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+}
+
+func ExampleTag_Base() {
+ fmt.Println(language.Make("und").Base())
+ fmt.Println(language.Make("und-US").Base())
+ fmt.Println(language.Make("und-NL").Base())
+ fmt.Println(language.Make("und-419").Base()) // Latin America
+ fmt.Println(language.Make("und-ZZ").Base())
+ // Output:
+ // en Low
+ // en High
+ // nl High
+ // es Low
+ // en Low
+}
+
+func ExampleTag_Script() {
+ en := language.Make("en")
+ sr := language.Make("sr")
+ sr_Latn := language.Make("sr_Latn")
+ fmt.Println(en.Script())
+ fmt.Println(sr.Script())
+ // Was a script explicitly specified?
+ _, c := sr.Script()
+ fmt.Println(c == language.Exact)
+ _, c = sr_Latn.Script()
+ fmt.Println(c == language.Exact)
+ // Output:
+ // Latn High
+ // Cyrl Low
+ // false
+ // true
+}
+
+func ExampleTag_Region() {
+ ru := language.Make("ru")
+ en := language.Make("en")
+ fmt.Println(ru.Region())
+ fmt.Println(en.Region())
+ // Output:
+ // RU Low
+ // US Low
+}
+
+func ExampleRegion_TLD() {
+ us := language.MustParseRegion("US")
+ gb := language.MustParseRegion("GB")
+ uk := language.MustParseRegion("UK")
+ bu := language.MustParseRegion("BU")
+
+ fmt.Println(us.TLD())
+ fmt.Println(gb.TLD())
+ fmt.Println(uk.TLD())
+ fmt.Println(bu.TLD())
+
+ fmt.Println(us.Canonicalize().TLD())
+ fmt.Println(gb.Canonicalize().TLD())
+ fmt.Println(uk.Canonicalize().TLD())
+ fmt.Println(bu.Canonicalize().TLD())
+ // Output:
+ // US <nil>
+ // UK <nil>
+ // UK <nil>
+ // ZZ language: region is not a valid ccTLD
+ // US <nil>
+ // UK <nil>
+ // UK <nil>
+ // MM <nil>
+}
+
+func ExampleCompose() {
+ nl, _ := language.ParseBase("nl")
+ us, _ := language.ParseRegion("US")
+ de := language.Make("de-1901-u-co-phonebk")
+ jp := language.Make("ja-JP")
+ fi := language.Make("fi-x-ing")
+
+ u, _ := language.ParseExtension("u-nu-arabic")
+ x, _ := language.ParseExtension("x-piglatin")
+
+ // Combine a base language and region.
+ fmt.Println(language.Compose(nl, us))
+ // Combine a base language and extension.
+ fmt.Println(language.Compose(nl, x))
+ // Replace the region.
+ fmt.Println(language.Compose(jp, us))
+ // Combine several tags.
+ fmt.Println(language.Compose(us, nl, u))
+
+ // Replace the base language of a tag.
+ fmt.Println(language.Compose(de, nl))
+ fmt.Println(language.Compose(de, nl, u))
+ // Remove the base language.
+ fmt.Println(language.Compose(de, language.Base{}))
+ // Remove all variants.
+ fmt.Println(language.Compose(de, []language.Variant{}))
+ // Remove all extensions.
+ fmt.Println(language.Compose(de, []language.Extension{}))
+ fmt.Println(language.Compose(fi, []language.Extension{}))
+ // Remove all variants and extensions.
+ fmt.Println(language.Compose(de.Raw()))
+
+ // An error is gobbled or returned if non-nil.
+ fmt.Println(language.Compose(language.ParseRegion("ZA")))
+ fmt.Println(language.Compose(language.ParseRegion("HH")))
+
+ // Compose uses the same Default canonicalization as Make.
+ fmt.Println(language.Compose(language.Raw.Parse("en-Latn-UK")))
+
+ // Call compose on a different CanonType for different results.
+ fmt.Println(language.All.Compose(language.Raw.Parse("en-Latn-UK")))
+
+ // Output:
+ // nl-US <nil>
+ // nl-x-piglatin <nil>
+ // ja-US <nil>
+ // nl-US-u-nu-arabic <nil>
+ // nl-1901-u-co-phonebk <nil>
+ // nl-1901-u-nu-arabic <nil>
+ // und-1901-u-co-phonebk <nil>
+ // de-u-co-phonebk <nil>
+ // de-1901 <nil>
+ // fi <nil>
+ // de <nil>
+ // und-ZA <nil>
+ // und language: subtag "HH" is well-formed but unknown
+ // en-Latn-GB <nil>
+ // en-GB <nil>
+}
+
+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 ExampleParent() {
+ p := func(tag string) {
+ fmt.Printf("parent(%v): %v\n", tag, language.Make(tag).Parent())
+ }
+ p("zh-CN")
+
+ // Australian English inherits from World English.
+ p("en-AU")
+
+ // If the tag has a different maximized script from its parent, a tag with
+ // this maximized script is inserted. This allows different language tags
+ // which have the same base language and script in common to inherit from
+ // a common set of settings.
+ p("zh-HK")
+
+ // If the maximized script of the parent is not identical, CLDR will skip
+ // inheriting from it, as it means there will not be many entries in common
+ // and inheriting from it is nonsensical.
+ p("zh-Hant")
+
+ // The parent of a tag with variants and extensions is the tag with all
+ // variants and extensions removed.
+ p("de-1994-u-co-phonebk")
+
+ // Remove default script.
+ p("de-Latn-LU")
+
+ // Output:
+ // parent(zh-CN): zh
+ // parent(en-AU): en-001
+ // parent(zh-HK): zh-Hant
+ // parent(zh-Hant): und
+ // parent(de-1994-u-co-phonebk): de
+ // parent(de-Latn-LU): de
+}
+
+// ExampleMatcher_bestMatch gives some examples of getting the best match of
+// a set of tags to any of the tags of given set.
+func ExampleMatcher() {
+ // This is the set of tags from which we want to pick the best match. These
+ // can be, for example, the supported languages for some package.
+ tags := []language.Tag{
+ language.English,
+ language.BritishEnglish,
+ language.French,
+ language.Afrikaans,
+ language.BrazilianPortuguese,
+ language.EuropeanPortuguese,
+ language.Croatian,
+ language.SimplifiedChinese,
+ language.Raw.Make("iw-IL"),
+ language.Raw.Make("iw"),
+ language.Raw.Make("he"),
+ }
+ m := language.NewMatcher(tags)
+
+ // A simple match.
+ fmt.Println(m.Match(language.Make("fr")))
+
+ // Australian English is closer to British than American English.
+ fmt.Println(m.Match(language.Make("en-AU")))
+
+ // Default to the first tag passed to the Matcher if there is no match.
+ fmt.Println(m.Match(language.Make("ar")))
+
+ // Get the default tag.
+ fmt.Println(m.Match())
+
+ fmt.Println("----")
+
+ // Someone specifying sr-Latn is probably fine with getting Croatian.
+ fmt.Println(m.Match(language.Make("sr-Latn")))
+
+ // We match SimplifiedChinese, but with Low confidence.
+ fmt.Println(m.Match(language.TraditionalChinese))
+
+ // Serbian in Latin script is a closer match to Croatian than Traditional
+ // Chinese to Simplified Chinese.
+ fmt.Println(m.Match(language.TraditionalChinese, language.Make("sr-Latn")))
+
+ fmt.Println("----")
+
+ // In case a multiple variants of a language are available, the most spoken
+ // variant is typically returned.
+ fmt.Println(m.Match(language.Portuguese))
+
+ // Pick the first value passed to Match in case of a tie.
+ fmt.Println(m.Match(language.Dutch, language.Make("fr-BE"), language.Make("af-NA")))
+ fmt.Println(m.Match(language.Dutch, language.Make("af-NA"), language.Make("fr-BE")))
+
+ fmt.Println("----")
+
+ // If a Matcher is initialized with a language and it's deprecated version,
+ // it will distinguish between them.
+ fmt.Println(m.Match(language.Raw.Make("iw")))
+
+ // However, for non-exact matches, it will treat deprecated versions as
+ // equivalent and consider other factors first.
+ fmt.Println(m.Match(language.Raw.Make("he-IL")))
+
+ fmt.Println("----")
+
+ // User settings passed to the Unicode extension are ignored for matching
+ // and preserved in the returned tag.
+ fmt.Println(m.Match(language.Make("de-u-co-phonebk"), language.Make("fr-u-cu-frf")))
+
+ // Even if the matching language is different.
+ fmt.Println(m.Match(language.Make("de-u-co-phonebk"), language.Make("br-u-cu-frf")))
+
+ // If there is no matching language, the options of the first preferred tag are used.
+ fmt.Println(m.Match(language.Make("de-u-co-phonebk")))
+
+ // Output:
+ // fr 2 Exact
+ // en-GB 1 High
+ // en 0 No
+ // en 0 No
+ // ----
+ // hr 6 High
+ // zh-Hans 7 Low
+ // hr 6 High
+ // ----
+ // pt-BR 4 High
+ // fr 2 High
+ // af 3 High
+ // ----
+ // iw 9 Exact
+ // he 10 Exact
+ // ----
+ // fr-u-cu-frf 2 Exact
+ // fr-u-cu-frf 2 High
+ // en-u-co-phonebk 0 No
+
+ // TODO: "he" should be "he-u-rg-IL High"
+}
+
+func ExampleMatchStrings() {
+ // languages supported by this service:
+ matcher := language.NewMatcher([]language.Tag{
+ language.English, language.Dutch, language.German,
+ })
+
+ http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+ lang, _ := r.Cookie("lang")
+ tag, _ := language.MatchStrings(matcher, lang.String(), r.Header.Get("Accept-Language"))
+
+ fmt.Println("User language:", tag)
+ })
+}
+
+func ExampleComprehends() {
+ // Various levels of comprehensibility.
+ fmt.Println(language.Comprehends(language.English, language.English))
+ fmt.Println(language.Comprehends(language.AmericanEnglish, language.BritishEnglish))
+
+ // An explicit Und results in no match.
+ fmt.Println(language.Comprehends(language.English, language.Und))
+
+ fmt.Println("----")
+
+ // There is usually no mutual comprehensibility between different scripts.
+ fmt.Println(language.Comprehends(language.Make("en-Dsrt"), language.English))
+
+ // One exception is for Traditional versus Simplified Chinese, albeit with
+ // a low confidence.
+ fmt.Println(language.Comprehends(language.TraditionalChinese, language.SimplifiedChinese))
+
+ fmt.Println("----")
+
+ // A Swiss German speaker will often understand High German.
+ fmt.Println(language.Comprehends(language.Make("gsw"), language.Make("de")))
+
+ // The converse is not generally the case.
+ fmt.Println(language.Comprehends(language.Make("de"), language.Make("gsw")))
+
+ // Output:
+ // Exact
+ // High
+ // No
+ // ----
+ // No
+ // Low
+ // ----
+ // High
+ // No
+}
+
+func ExampleTag_values() {
+ us := language.MustParseRegion("US")
+ en := language.MustParseBase("en")
+
+ lang, _, region := language.AmericanEnglish.Raw()
+ fmt.Println(lang == en, region == us)
+
+ lang, _, region = language.BritishEnglish.Raw()
+ fmt.Println(lang == en, region == us)
+
+ // Tags can be compared for exact equivalence using '=='.
+ en_us, _ := language.Compose(en, us)
+ fmt.Println(en_us == language.AmericanEnglish)
+
+ // Output:
+ // true true
+ // true false
+ // true
+}