From 621e49bb465f500cc46d47e39e828cf76d6381d7 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 24 Jul 2018 14:35:44 +0200 Subject: update vendor --- vendor/golang.org/x/text/date/gen.go | 329 +++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 vendor/golang.org/x/text/date/gen.go (limited to 'vendor/golang.org/x/text/date/gen.go') diff --git a/vendor/golang.org/x/text/date/gen.go b/vendor/golang.org/x/text/date/gen.go new file mode 100644 index 0000000..6f4ae07 --- /dev/null +++ b/vendor/golang.org/x/text/date/gen.go @@ -0,0 +1,329 @@ +// 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. + +// +build ignore + +package main + +import ( + "flag" + "log" + "strconv" + "strings" + + "golang.org/x/text/internal/cldrtree" + "golang.org/x/text/internal/gen" + "golang.org/x/text/language" + "golang.org/x/text/unicode/cldr" +) + +var ( + draft = flag.String("draft", + "contributed", + `Minimal draft requirements (approved, contributed, provisional, unconfirmed).`) +) + +// TODO: +// - Compile format patterns. +// - Compress the large amount of redundancy in metazones. +// - Split trees (with shared buckets) with data that is enough for default +// formatting of Go Time values and and tables that are needed for larger +// variants. +// - zone to metaZone mappings (in supplemental) +// - Add more enum values and also some key maps for some of the elements. + +func main() { + gen.Init() + + r := gen.OpenCLDRCoreZip() + defer r.Close() + + d := &cldr.Decoder{} + d.SetDirFilter("supplemental", "main") + d.SetSectionFilter("dates") + data, err := d.DecodeZip(r) + if err != nil { + log.Fatalf("DecodeZip: %v", err) + } + + dates := cldrtree.New("dates") + buildCLDRTree(data, dates) + + w := gen.NewCodeWriter() + if err := dates.Gen(w); err != nil { + log.Fatal(err) + } + gen.WriteCLDRVersion(w) + w.WriteGoFile("tables.go", "date") + + w = gen.NewCodeWriter() + if err := dates.GenTestData(w); err != nil { + log.Fatal(err) + } + w.WriteGoFile("data_test.go", "date") +} + +func buildCLDRTree(data *cldr.CLDR, dates *cldrtree.Builder) { + context := cldrtree.Enum("context") + widthMap := func(s string) string { + // Align era with width values. + if r, ok := map[string]string{ + "eraAbbr": "abbreviated", + "eraNarrow": "narrow", + "eraNames": "wide", + }[s]; ok { + s = r + } + // Prefix width to disambiguate with some overlapping length values. + return "width" + strings.Title(s) + } + width := cldrtree.EnumFunc("width", widthMap, "abbreviated", "narrow", "wide") + length := cldrtree.Enum("length", "short", "long") + month := cldrtree.Enum("month", "leap7") + relTime := cldrtree.EnumFunc("relTime", func(s string) string { + x, err := strconv.ParseInt(s, 10, 8) + if err != nil { + log.Fatal("Invalid number:", err) + } + return []string{ + "before2", + "before1", + "current", + "after1", + "after2", + "after3", + }[x+2] + }) + // Disambiguate keys like 'months' and 'sun'. + cycleType := cldrtree.EnumFunc("cycleType", func(s string) string { + return s + "CycleType" + }) + field := cldrtree.EnumFunc("field", func(s string) string { + return s + "Field" + }) + timeType := cldrtree.EnumFunc("timeType", func(s string) string { + if s == "" { + return "genericTime" + } + return s + "Time" + }, "generic") + + zoneType := []cldrtree.Option{cldrtree.SharedType(), timeType} + metaZoneType := []cldrtree.Option{cldrtree.SharedType(), timeType} + + for _, lang := range data.Locales() { + tag := language.Make(lang) + ldml := data.RawLDML(lang) + if ldml.Dates == nil { + continue + } + x := dates.Locale(tag) + if x := x.Index(ldml.Dates.Calendars); x != nil { + for _, cal := range ldml.Dates.Calendars.Calendar { + x := x.IndexFromType(cal) + if x := x.Index(cal.Months); x != nil { + for _, mc := range cal.Months.MonthContext { + x := x.IndexFromType(mc, context) + for _, mw := range mc.MonthWidth { + x := x.IndexFromType(mw, width) + for _, m := range mw.Month { + x.SetValue(m.Yeartype+m.Type, m, month) + } + } + } + } + if x := x.Index(cal.MonthPatterns); x != nil { + for _, mc := range cal.MonthPatterns.MonthPatternContext { + x := x.IndexFromType(mc, context) + for _, mw := range mc.MonthPatternWidth { + // Value is always leap, so no need to create a + // subindex. + for _, m := range mw.MonthPattern { + x.SetValue(mw.Type, m, width) + } + } + } + } + if x := x.Index(cal.CyclicNameSets); x != nil { + for _, cns := range cal.CyclicNameSets.CyclicNameSet { + x := x.IndexFromType(cns, cycleType) + for _, cc := range cns.CyclicNameContext { + x := x.IndexFromType(cc, context) + for _, cw := range cc.CyclicNameWidth { + x := x.IndexFromType(cw, width) + for _, c := range cw.CyclicName { + x.SetValue(c.Type, c) + } + } + } + } + } + if x := x.Index(cal.Days); x != nil { + for _, dc := range cal.Days.DayContext { + x := x.IndexFromType(dc, context) + for _, dw := range dc.DayWidth { + x := x.IndexFromType(dw, width) + for _, d := range dw.Day { + x.SetValue(d.Type, d) + } + } + } + } + if x := x.Index(cal.Quarters); x != nil { + for _, qc := range cal.Quarters.QuarterContext { + x := x.IndexFromType(qc, context) + for _, qw := range qc.QuarterWidth { + x := x.IndexFromType(qw, width) + for _, q := range qw.Quarter { + x.SetValue(q.Type, q) + } + } + } + } + if x := x.Index(cal.DayPeriods); x != nil { + for _, dc := range cal.DayPeriods.DayPeriodContext { + x := x.IndexFromType(dc, context) + for _, dw := range dc.DayPeriodWidth { + x := x.IndexFromType(dw, width) + for _, d := range dw.DayPeriod { + x.IndexFromType(d).SetValue(d.Alt, d) + } + } + } + } + if x := x.Index(cal.Eras); x != nil { + opts := []cldrtree.Option{width, cldrtree.SharedType()} + if x := x.Index(cal.Eras.EraNames, opts...); x != nil { + for _, e := range cal.Eras.EraNames.Era { + x.IndexFromAlt(e).SetValue(e.Type, e) + } + } + if x := x.Index(cal.Eras.EraAbbr, opts...); x != nil { + for _, e := range cal.Eras.EraAbbr.Era { + x.IndexFromAlt(e).SetValue(e.Type, e) + } + } + if x := x.Index(cal.Eras.EraNarrow, opts...); x != nil { + for _, e := range cal.Eras.EraNarrow.Era { + x.IndexFromAlt(e).SetValue(e.Type, e) + } + } + } + if x := x.Index(cal.DateFormats); x != nil { + for _, dfl := range cal.DateFormats.DateFormatLength { + x := x.IndexFromType(dfl, length) + for _, df := range dfl.DateFormat { + for _, p := range df.Pattern { + x.SetValue(p.Alt, p) + } + } + } + } + if x := x.Index(cal.TimeFormats); x != nil { + for _, tfl := range cal.TimeFormats.TimeFormatLength { + x := x.IndexFromType(tfl, length) + for _, tf := range tfl.TimeFormat { + for _, p := range tf.Pattern { + x.SetValue(p.Alt, p) + } + } + } + } + if x := x.Index(cal.DateTimeFormats); x != nil { + for _, dtfl := range cal.DateTimeFormats.DateTimeFormatLength { + x := x.IndexFromType(dtfl, length) + for _, dtf := range dtfl.DateTimeFormat { + for _, p := range dtf.Pattern { + x.SetValue(p.Alt, p) + } + } + } + // TODO: + // - appendItems + // - intervalFormats + } + } + } + // TODO: this is a lot of data and is probably relatively little used. + // Store this somewhere else. + if x := x.Index(ldml.Dates.Fields); x != nil { + for _, f := range ldml.Dates.Fields.Field { + x := x.IndexFromType(f, field) + for _, d := range f.DisplayName { + x.Index(d).SetValue(d.Alt, d) + } + for _, r := range f.Relative { + x.Index(r).SetValue(r.Type, r, relTime) + } + for _, rt := range f.RelativeTime { + x := x.Index(rt).IndexFromType(rt) + for _, p := range rt.RelativeTimePattern { + x.SetValue(p.Count, p) + } + } + for _, rp := range f.RelativePeriod { + x.Index(rp).SetValue(rp.Alt, rp) + } + } + } + if x := x.Index(ldml.Dates.TimeZoneNames); x != nil { + format := x.IndexWithName("zoneFormat") + for _, h := range ldml.Dates.TimeZoneNames.HourFormat { + format.SetValue(h.Element(), h) + } + for _, g := range ldml.Dates.TimeZoneNames.GmtFormat { + format.SetValue(g.Element(), g) + } + for _, g := range ldml.Dates.TimeZoneNames.GmtZeroFormat { + format.SetValue(g.Element(), g) + } + for _, r := range ldml.Dates.TimeZoneNames.RegionFormat { + x.Index(r).SetValue(r.Type, r, timeType) + } + + set := func(x *cldrtree.Index, e []*cldr.Common, zone string) { + for _, n := range e { + x.Index(n, zoneType...).SetValue(zone, n) + } + } + zoneWidth := []cldrtree.Option{length, cldrtree.SharedType()} + zs := x.IndexWithName("zone") + for _, z := range ldml.Dates.TimeZoneNames.Zone { + for _, l := range z.Long { + x := zs.Index(l, zoneWidth...) + set(x, l.Generic, z.Type) + set(x, l.Standard, z.Type) + set(x, l.Daylight, z.Type) + } + for _, s := range z.Short { + x := zs.Index(s, zoneWidth...) + set(x, s.Generic, z.Type) + set(x, s.Standard, z.Type) + set(x, s.Daylight, z.Type) + } + } + set = func(x *cldrtree.Index, e []*cldr.Common, zone string) { + for _, n := range e { + x.Index(n, metaZoneType...).SetValue(zone, n) + } + } + zoneWidth = []cldrtree.Option{length, cldrtree.SharedType()} + zs = x.IndexWithName("metaZone") + for _, z := range ldml.Dates.TimeZoneNames.Metazone { + for _, l := range z.Long { + x := zs.Index(l, zoneWidth...) + set(x, l.Generic, z.Type) + set(x, l.Standard, z.Type) + set(x, l.Daylight, z.Type) + } + for _, s := range z.Short { + x := zs.Index(s, zoneWidth...) + set(x, s.Generic, z.Type) + set(x, s.Standard, z.Type) + set(x, s.Daylight, z.Type) + } + } + } + } +} -- cgit v1.2.3