locales

package module
v0.0.0-...-afc58ac Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 16, 2024 License: MIT Imports: 15 Imported by: 0

README ¶

locales

Project status Build Status

GoDoc

License

Locales is a set of locales generated from the Unicode CLDR Project which can be used independently or within an i18n package; these were built for use with, but not exclusive to, Universal Translator.

Features

  • Rules generated from the latest CLDR data, v36.0.1
  • Contains Cardinal, Ordinal and Range Plural Rules
  • Contains Month, Weekday and Timezone translations built in
  • Contains Date & Time formatting functions
  • Contains Number, Currency, Accounting and Percent formatting functions
  • Supports the "Gregorian" calendar only ( my time isn't unlimited, had to draw the line somewhere )

Full Tests

I could sure use your help adding tests for every locale, it is a huge undertaking and I just don't have the free time to do it all at the moment; any help would be greatly appreciated!!!! please see issue for details.

Installation

Use go get

go get github.com/moisespsena-go/locales

NOTES

You'll notice most return types are []byte, this is because most of the time the results will be concatenated with a larger body of text and can avoid some allocations if already appending to a byte array, otherwise just cast as string.

Usage

package main

import (
	"fmt"
	"time"

	"github.com/moisespsena-go/locales/currency"
	"github.com/moisespsena-go/locales/named/en_CA"
)

func main() {

	loc, _ := time.LoadLocation("America/Toronto")
	datetime := time.Date(2016, 02, 03, 9, 0, 1, 0, loc)

	l := en_CA.New()

	// Dates
	fmt.Println(l.FmtDateFull(datetime))
	fmt.Println(l.FmtDateLong(datetime))
	fmt.Println(l.FmtDateMedium(datetime))
	fmt.Println(l.FmtDateShort(datetime))

	// Times
	fmt.Println(l.FmtTimeFull(datetime))
	fmt.Println(l.FmtTimeLong(datetime))
	fmt.Println(l.FmtTimeMedium(datetime))
	fmt.Println(l.FmtTimeShort(datetime))

	// Months Wide
	fmt.Println(l.MonthWide(time.January))
	fmt.Println(l.MonthWide(time.February))
	fmt.Println(l.MonthWide(time.March))
	// ...

	// Months Abbreviated
	fmt.Println(l.MonthAbbreviated(time.January))
	fmt.Println(l.MonthAbbreviated(time.February))
	fmt.Println(l.MonthAbbreviated(time.March))
	// ...

	// Months Narrow
	fmt.Println(l.MonthNarrow(time.January))
	fmt.Println(l.MonthNarrow(time.February))
	fmt.Println(l.MonthNarrow(time.March))
	// ...

	// Weekdays Wide
	fmt.Println(l.WeekdayWide(time.Sunday))
	fmt.Println(l.WeekdayWide(time.Monday))
	fmt.Println(l.WeekdayWide(time.Tuesday))
	// ...

	// Weekdays Abbreviated
	fmt.Println(l.WeekdayAbbreviated(time.Sunday))
	fmt.Println(l.WeekdayAbbreviated(time.Monday))
	fmt.Println(l.WeekdayAbbreviated(time.Tuesday))
	// ...

	// Weekdays Short
	fmt.Println(l.WeekdayShort(time.Sunday))
	fmt.Println(l.WeekdayShort(time.Monday))
	fmt.Println(l.WeekdayShort(time.Tuesday))
	// ...

	// Weekdays Narrow
	fmt.Println(l.WeekdayNarrow(time.Sunday))
	fmt.Println(l.WeekdayNarrow(time.Monday))
	fmt.Println(l.WeekdayNarrow(time.Tuesday))
	// ...

	var f64 float64

	f64 = -10356.4523

	// Number
	fmt.Println(l.FmtNumber(f64, 2))

	// Currency
	fmt.Println(l.FmtCurrency(f64, 2, currency.CAD))
	fmt.Println(l.FmtCurrency(f64, 2, currency.USD))

	// Accounting
	fmt.Println(l.FmtAccounting(f64, 2, currency.CAD))
	fmt.Println(l.FmtAccounting(f64, 2, currency.USD))

	f64 = 78.12

	// Percent
	fmt.Println(l.FmtPercent(f64, 0))

	// Plural Rules for locale, so you know what rules you must cover
	fmt.Println(l.PluralsCardinal())
	fmt.Println(l.PluralsOrdinal())

	// Cardinal Plural Rules
	fmt.Println(l.CardinalPluralRule(1, 0))
	fmt.Println(l.CardinalPluralRule(1.0, 0))
	fmt.Println(l.CardinalPluralRule(1.0, 1))
	fmt.Println(l.CardinalPluralRule(3, 0))

	// Ordinal Plural Rules
	fmt.Println(l.OrdinalPluralRule(21, 0)) // 21st
	fmt.Println(l.OrdinalPluralRule(22, 0)) // 22nd
	fmt.Println(l.OrdinalPluralRule(33, 0)) // 33rd
	fmt.Println(l.OrdinalPluralRule(34, 0)) // 34th

	// Range Plural Rules
	fmt.Println(l.RangePluralRule(1, 0, 1, 0)) // 1-1
	fmt.Println(l.RangePluralRule(1, 0, 2, 0)) // 1-2
	fmt.Println(l.RangePluralRule(5, 0, 8, 0)) // 5-8
}

NOTES:

These rules were generated from the Unicode CLDR Project, if you encounter any issues I strongly encourage contributing to the CLDR project to get the locale information corrected and the next time these locales are regenerated the fix will come with.

I do however realize that time constraints are often important and so there are two options:

  1. Create your own locale, copy, paste and modify, and ensure it complies with the Translator interface.
  2. Add an exception in the locale generation code directly and once regenerated, fix will be in place.

Please to not make fixes inside the locale files, they WILL get overwritten when the locales are regenerated.

License

Distributed under MIT License, please see license file in code for more details.

Documentation ¶

Index ¶

Constants ¶

View Source 
const (
	DurationShort DurationMode = iota
	DurationLong

	HoursInDay   = 24
	HoursInMonth = HoursInDay * 30
	HoursInYear  = HoursInMonth * 12
)

Variables ¶

View Source 
var (
	DefaultAndListJoinPattern = NewListPattern("{0} and {1}", "{0}, {1}", "{0}, {1}", "{0} and {1}")
	DefaultOrListJoinPattern  = NewListPattern("{0} or {1}", "{0}, {1}", "{0}, {1}", "{0} or {1}")
)
View Source 
var ComputedNumberFormatOptions = NumberFormatOptions{
	Decimal: ".",
	Group:   "",
	Minus:   "-",
}
View Source 
var DefaultDurationSpec = DurationSpec{
	LongSep:  " ",
	ShortSep: "",
	Year: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Other: "%vY",
			Per:   "%v/Y",
		},
		&CounterFormat{
			"Years",
			"%d year",
			"%d years",
			"%v per year",
		},
	},
	Month: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Other: "%vM",
			Per:   "%v/M",
		},
		&CounterFormat{
			"Months",
			"%d month",
			"%d months",
			"%v per month",
		},
	},
	Day: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Other: "%vd",
			Per:   "%v/d",
		},
		&CounterFormat{
			"Days",
			"%d day",
			"%d days",
			"%v per day",
		},
	},
	Hour: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Other: "%dh",
			Per:   "%v/h",
		},
		&CounterFormat{
			"Hours",
			"%d hour",
			"%d hours",
			"%v per hour",
		},
	},
	Minute: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Other: "%dm",
			Per:   "%v/m",
		},
		&CounterFormat{
			"minutes",
			"%d minute",
			"%d minutes",
			"%v per minute",
		},
	},
	Second: DurationSpecPair{
		Masculine,
		&CounterFormat{
			Label: "sec",
			Other: "%vs",
			Per:   "%v/s",
		},
		&CounterFormat{
			"Seconds",
			"%v second",
			"%v seconds",
			"%v per second",
		},
	},
}
View Source 
var NumberForamtters = map[reflect.Type]NumberFormatter{
	reflect.TypeOf(big.Rat{}): func(value interface{}, precision int, minus, thousand string, decimalStr string) string {
		var rat, _ = value.(*big.Rat)
		if rat == nil {
			var v2 any = value
			rat = v2.(*big.Rat)
		}

		if precision > 0 {
			return value.(*big.Rat).FloatString(precision)
		} else {
			return value.(*big.Rat).String()
		}
	},

	reflect.TypeOf(decimal.Decimal{}): func(value interface{}, precision int, minus, thousand string, decimalStr string) string {
		if precision > 0 {
			return value.(*decimal.Decimal).StringFixed(int32(precision))
		} else {
			return value.(*decimal.Decimal).String()
		}
	},
}

Functions ¶

func F ¶ 

func F(n float64, v uint64) (f int64)

F returns the visible fractional digits in N, with trailing zeros.

func FmtAccounting ¶ 

func FmtAccounting(t CurrencyWithNumberTranslator, level CurrencyLevel, currency currency.Type, num decimal.Decimal, precision int) string

FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'pt' in accounting notation.

func FmtCurrency ¶ 

func FmtCurrency(t CurrencyWithNumberTranslator, level CurrencyLevel, currency currency.Type, num decimal.Decimal, precision int) string

FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'pt'

func FormatNumber ¶ 

func FormatNumber(value interface{}, precision int, minus, thousand string, decimalStr string) string

FormatNumber is a base function of the library which formats a number with custom precision and separators. FormatNumber supports various types of value by runtime reflection. If you don't need runtime type evaluation, please refer to FormatNumberInt or FormatNumberFloat64. (supported value types : int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, *big.Rat) (also supported value types : decimal.Decimal, *decimal.Decimal *apd.Decimal)

func FormatNumberString ¶ 

func FormatNumberString(x string, precision int, minus, thousand string, decimalStr string) string

func FormatNumberT ¶ 

func FormatNumberT(t Translator, value interface{}, precision int) string

func FormatTime ¶ 

func FormatTime(t TimeTranslator, format string, T time.Time) string

func FormatTimeEra ¶ 

func FormatTimeEra(t TimeTranslator, format string, T time.Time, eraScore int8) string

func T ¶ 

func T(n float64, v uint64) (t int64)

T returns the visible fractional digits in N, without trailing zeros.

func UnformatNumber ¶ 

func UnformatNumber(t Translator, n string, precision int) string

UnformatNumber takes a string of the number to strip currency info on and precision for decimals. It pulls the currency descripter from the LocaleInfo map and uses it to return an unformatted value based on thous sep and decimal sep

func W ¶ 

func W(n float64, v uint64) (w int64)

W returns the number of visible fraction digits in N, without trailing zeros.

Types ¶

type CounterFormat ¶ 

type CounterFormat struct {
	Label, One, Other, Per string
}

func (*CounterFormat) Dump ¶ 

func (f *CounterFormat) Dump(pkg string, out io.Writer)

func (*CounterFormat) Get ¶ 

func (f *CounterFormat) Get(qnt uint64, defaul ...*CounterFormat) (v string)

func (*CounterFormat) GetF ¶ 

func (f *CounterFormat) GetF(qnt float64, defaul ...*CounterFormat) (v string)

func (*CounterFormat) Perf ¶ 

func (f *CounterFormat) Perf(qnt any) (v string)

type Currency ¶ 

type Currency struct {
	Names   map[PluralRule]string
	Symbols CurrencySymbols
}

type CurrencyAccountingFormatterByExp ¶ 

type CurrencyAccountingFormatterByExp struct {
	CurrencyFmt   map[uint8]*CurrencyAccountingFormatterByExpPlural
	AccountingFmt map[uint8]*CurrencyAccountingFormatterByExpPlural
}

func (*CurrencyAccountingFormatterByExp) Dump ¶ 

func (f *CurrencyAccountingFormatterByExp) Dump(pkg string, out io.Writer)

type CurrencyAccountingFormatterByExpPlural ¶ 

type CurrencyAccountingFormatterByExpPlural struct {
	Rules map[PluralRule]*NumberFormatProperties
}

func (*CurrencyAccountingFormatterByExpPlural) Dump ¶ 

func (t *CurrencyAccountingFormatterByExpPlural) Dump(pkg string, out io.Writer)

type CurrencyFormat ¶ 

type CurrencyFormat struct {
	Raw                   string
	ThousandsLen          int
	DigitsLen             int
	SecondaryThousandsLen int
	MinDecimalLen         int
	SymbolDirection       Direction
	SymbolPrefix          string
	SymbolSuffix          string
	Prefix                string
	Suffix                string
}

func (*CurrencyFormat) Dump ¶ 

func (f *CurrencyFormat) Dump(pkg string, out io.Writer)

func (*CurrencyFormat) Exec ¶ 

func (f *CurrencyFormat) Exec(symbol, value string) string

func (*CurrencyFormat) Format ¶ 

func (f *CurrencyFormat) Format(t NumberTranslator, cur *Currency, num string, v uint64) string

Format returns the currency representation of 'num' with digits/precision of 'v' for '{{ .Locale }}'

func (*CurrencyFormat) Parse ¶ 

func (f *CurrencyFormat) Parse(numberFormat string)

type CurrencyFormatters ¶ 

type CurrencyFormatters struct {
	CurrencyFmt,
	AccountingFmt *NumberFormatProperties

	Short CurrencyAccountingFormatterByExp
}

func (*CurrencyFormatters) Accounting ¶ 

func (f *CurrencyFormatters) Accounting(t CurrencyWithNumberTranslator, level CurrencyLevel, cur *Currency, num decimal.Decimal, v int) string

func (*CurrencyFormatters) Currency ¶ 

func (f *CurrencyFormatters) Currency(t CurrencyWithNumberTranslator, level CurrencyLevel, cur *Currency, num decimal.Decimal, v int) string

func (*CurrencyFormatters) Dump ¶ 

func (f *CurrencyFormatters) Dump(pkg string, out io.Writer)

func (*CurrencyFormatters) Format ¶ 

func (f *CurrencyFormatters) Format(cf *NumberFormatProperties, t CurrencyWithNumberTranslator, cur *Currency, num decimal.Decimal, precision int) string

func (*CurrencyFormatters) Get ¶ 

func (f *CurrencyFormatters) Get(defaul *NumberFormatProperties, short map[uint8]*CurrencyAccountingFormatterByExpPlural, level CurrencyLevel, num decimal.Decimal) (cf *NumberFormatProperties, n decimal.Decimal)

func (*CurrencyFormatters) GetAccounting ¶ 

func (f *CurrencyFormatters) GetAccounting(level CurrencyLevel, num decimal.Decimal) (cf *NumberFormatProperties, n decimal.Decimal)

func (*CurrencyFormatters) GetCurrency ¶ 

func (f *CurrencyFormatters) GetCurrency(level CurrencyLevel, num decimal.Decimal) (cf *NumberFormatProperties, n decimal.Decimal)

func (*CurrencyFormatters) IsZero ¶ 

func (f *CurrencyFormatters) IsZero() bool

type CurrencyLevel ¶ 

type CurrencyLevel uint8
const (
	CurrencyLong CurrencyLevel = iota
	CurrencyShort
)

type CurrencySpec ¶ 

type CurrencySpec struct {
	CurrenciesValue []Currency
	Formatters      *CurrencyFormatters
}

func (*CurrencySpec) Currencies ¶ 

func (c *CurrencySpec) Currencies() []Currency

func (*CurrencySpec) CurrencyFormatters ¶ 

func (c *CurrencySpec) CurrencyFormatters() *CurrencyFormatters

type CurrencySymbolLevel ¶ 

type CurrencySymbolLevel uint8
const (
	CurrencySymbolStd CurrencySymbolLevel = 1 + iota
	CurrencySymbolISO
	CurrencySymbolName
	CurrencySymbolNarrow
)

type CurrencySymbols ¶ 

type CurrencySymbols struct {
	Default string
	Narrow  string
}

type CurrencyTranslator ¶ 

type CurrencyTranslator interface {
	Currencies() []Currency

	CurrencyFormatters() *CurrencyFormatters
}

type CurrencyWithNumberTranslator ¶ 

type CurrencyWithNumberTranslator interface {
	CurrencyTranslator
	NumberTranslator
}

type Direction ¶ 

type Direction uint8
const (
	Left Direction = iota
	Right
)

type DurationMode ¶ 

type DurationMode uint8

type DurationSpec ¶ 

type DurationSpec struct {
	LongSep, ShortSep string
	Century           DurationSpecPair
	Decade            DurationSpecPair
	Year              DurationSpecPair
	Month             DurationSpecPair
	Week              DurationSpecPair
	Day               DurationSpecPair
	Hour              DurationSpecPair
	Minute            DurationSpecPair
	Second            DurationSpecPair
	Millisecond       DurationSpecPair
	Microsecond       DurationSpecPair
	Nanosecond        DurationSpecPair
}

func (*DurationSpec) Dump ¶ 

func (s *DurationSpec) Dump(pkg string, out io.Writer)

func (*DurationSpec) Format ¶ 

func (d *DurationSpec) Format(mode DurationMode, dur time.Duration) string

type DurationSpecPair ¶ 

type DurationSpecPair struct {
	Gender      Gender
	Short, Long *CounterFormat
}

func (*DurationSpecPair) Dump ¶ 

func (s *DurationSpecPair) Dump(pkg string, out io.Writer)

func (*DurationSpecPair) Of ¶ 

func (p *DurationSpecPair) Of(mode DurationMode) *CounterFormat

type DurationSpecValue ¶ 

type DurationSpecValue struct {
	D    time.Duration
	Spec *DurationSpec
}

func (DurationSpecValue) Format ¶ 

func (d DurationSpecValue) Format(f fmt.State, verb rune)

type DurationTranslator ¶ 

type DurationTranslator interface {
	GetDurationSpec() *DurationSpec
}

type DurationValue ¶ 

type DurationValue struct {
	Translator Translator
	Value      time.Duration
}

func (DurationValue) Format ¶ 

func (d DurationValue) Format(f fmt.State, verb rune)

type Gender ¶ 

type Gender uint8
const (
	Masculine Gender = iota
	Feminine
)

func (Gender) String ¶ 

func (g Gender) String() string

type JoinType ¶ 

type JoinType uint8
const (
	And JoinType = iota
	Or
)

type ListJoinToken ¶ 

type ListJoinToken uint8
const (
	ListJoinA ListJoinToken = iota
	ListJoinSep
	ListJoinB
)

func (ListJoinToken) String ¶ 

func (t ListJoinToken) String() string

type ListPattern ¶ 

type ListPattern struct {
	Two,
	Start,
	Middle,
	End *ListPatternSpec
}

func NewListPattern ¶ 

func NewListPattern(two, start, middle, end string) *ListPattern

func NewListPatternFromSlice ¶ 

func NewListPatternFromSlice(def []string) *ListPattern

func (*ListPattern) FormatTo ¶ 

func (p *ListPattern) FormatTo(w io.Writer, itens ...string)

func (*ListPattern) ToSlice ¶ 

func (p *ListPattern) ToSlice() []string

type ListPatternSpec ¶ 

type ListPatternSpec struct {
	Pattern string
	Sep     string
	Tokens  [3]ListJoinToken
}

func NewListPatternSpec ¶ 

func NewListPatternSpec(pattern string) *ListPatternSpec

func (*ListPatternSpec) Format ¶ 

func (s *ListPatternSpec) Format(itens ...string) string

func (*ListPatternSpec) String ¶ 

func (s *ListPatternSpec) String() string

type ListPatterns ¶ 

type ListPatterns struct {
	AndP, OrP *ListPattern
}

func NewListPatternsFromSlice ¶ 

func NewListPatternsFromSlice(s [][]string) *ListPatterns

func (*ListPatterns) And ¶ 

func (p *ListPatterns) And(w io.Writer, itens ...string)

func (*ListPatterns) AndS ¶ 

func (p *ListPatterns) AndS(itens ...string) string

func (*ListPatterns) Do ¶ 

func (p *ListPatterns) Do(w io.Writer, typ JoinType, itens ...string)

func (*ListPatterns) DoS ¶ 

func (p *ListPatterns) DoS(typ JoinType, itens ...string) string

func (*ListPatterns) Or ¶ 

func (p *ListPatterns) Or(w io.Writer, itens ...string)

func (*ListPatterns) OrS ¶ 

func (p *ListPatterns) OrS(itens ...string) string

func (*ListPatterns) ToSlice ¶ 

func (f *ListPatterns) ToSlice() [][]string

type MiscPatterns ¶ 

type MiscPatterns struct {
	Approximately,
	AtLeast,
	AtMost,
	Range string
}

type NumberFlag ¶ 

type NumberFlag uint8
const (
	PercentNumber NumberFlag = 1 + iota
	MilleNumber
	CurrencyNumber
)

type NumberFormatOptions ¶ 

type NumberFormatOptions struct {
	Minus                    string
	Group                    string
	Decimal                  string
	Symbol                   string
	Infinity                 string
	Percent                  string
	Zero                     string
	Precision                int
	DefaultPrecisionDisabled bool
}

type NumberFormatProperties ¶ 

type NumberFormatProperties struct {
	Pos,
	Neg NumberPatternProperties
}

func MustParseNumberFormatPatterns ¶ 

func MustParseNumberFormatPatterns(pattern string) *NumberFormatProperties

func (NumberFormatProperties) Dump ¶ 

func (f NumberFormatProperties) Dump(pkg string, out io.Writer)

func (*NumberFormatProperties) Format ¶ 

func (f *NumberFormatProperties) Format(value decimal.Decimal, opts NumberFormatOptions) string

func (*NumberFormatProperties) FormatAny ¶ 

func (f *NumberFormatProperties) FormatAny(value any, opts NumberFormatOptions) (s string, err error)

func (*NumberFormatProperties) FormatS ¶ 

func (f *NumberFormatProperties) FormatS(s string, opts NumberFormatOptions) (ret string)

func (*NumberFormatProperties) Parse ¶ 

func (p *NumberFormatProperties) Parse(value string) (err error)

func (NumberFormatProperties) String ¶ 

func (f NumberFormatProperties) String() string

type NumberFormatter ¶ 

type NumberFormatter func(value interface{}, precision int, minus, thousand string, decimalStr string) string

type NumberPatternProperties ¶ 

type NumberPatternProperties struct {
	// Pattern Raw pattern value
	Pattern string

	Prefix string
	Padding,
	ScientificNotation string

	// MinimumIntegerDigits non-negative integer Number value indicating the minimum integer
	//        digits to be used. Numbers will be padded with leading zeroes if necessary.
	MinimumIntegerDigits,

	MinimumFractionDigits,
	MaximumFractionDigits,

	MinimumSignificantDigits,
	MaximumSignificantDigits,
	PrimaryGroupingSize,
	SecondaryGroupingSize int
	Suffix string

	// RoundIncrement Decimal round increment or null
	RoundIncrement float64

	Type NumberFlag

	CurrencySymbol CurrencySymbolLevel

	DivExp uint8
}

func (NumberPatternProperties) Dump ¶ 

func (f NumberPatternProperties) Dump(pkg string, out io.Writer)

func (*NumberPatternProperties) Format ¶ 

func (f *NumberPatternProperties) Format(value decimal.Decimal, opts NumberFormatOptions) (ret string)

func (*NumberPatternProperties) FormatS ¶ 

func (f *NumberPatternProperties) FormatS(s string, opts NumberFormatOptions) (ret string)

func (NumberPatternProperties) Neg ¶ 

func (f NumberPatternProperties) Neg() NumberPatternProperties

func (*NumberPatternProperties) Parse ¶ 

func (p *NumberPatternProperties) Parse(pattern string) (err error)

*

func (*NumberPatternProperties) Template ¶ 

func (f *NumberPatternProperties) Template(opts NumberFormatOptions) (prefix, suffix string, precision int)

type NumberSpec ¶ 

type NumberSpec struct {
	GroupValue,
	DecimalValue,
	MinusValue string
}

func (*NumberSpec) Decimal ¶ 

func (n *NumberSpec) Decimal() string

func (*NumberSpec) Group ¶ 

func (n *NumberSpec) Group() string

func (*NumberSpec) Minus ¶ 

func (n *NumberSpec) Minus() string

type NumberTranslator ¶ 

type NumberTranslator interface {
	Group() string

	Decimal() string

	Minus() string
}

type PluralRule ¶ 

type PluralRule int

PluralRule denotes the type of plural rules 

const (
	PluralRuleUnknown PluralRule = iota
	PluralRuleZero               // zero
	PluralRuleOne                // one - singular
	PluralRuleTwo                // two - dual
	PluralRuleFew                // few - paucal
	PluralRuleMany               // many - also used for fractions if they have a separate class
	PluralRuleOther              // other - required—general plural form—also used if the language only has a single form
)

PluralRule's

func (PluralRule) String ¶ 

func (p PluralRule) String() string

String returns the string value of PluralRule

type TimeRangeValue ¶ 

type TimeRangeValue struct {
	Translator Translator
	Formatter  TimestampFormat
	From, To   time.Time
}

func NewTimeRangeValue ¶ 

func NewTimeRangeValue(translator Translator, from time.Time, to time.Time) *TimeRangeValue

func NewdDateRangeValue ¶ 

func NewdDateRangeValue(translator Translator, from time.Time, to time.Time) *TimeRangeValue

func (TimeRangeValue) Format ¶ 

func (t TimeRangeValue) Format(f fmt.State, verb rune)

func (TimeRangeValue) ToString ¶ 

func (t TimeRangeValue) ToString() string

type TimeSpec ¶ 

type TimeSpec struct {
	Separator string

	// returns the locales wide months
	MonthsWideValue []string

	// returns the locales abbreviated months
	MonthsAbbreviatedValue []string

	// returns the locales narrow months
	MonthsNarrowValue []string

	// returns the locales wide weekdays
	WeekdaysWideValue []string

	// returns the locales abbreviated weekdays
	WeekdaysAbbreviatedValue []string

	// WeekdaysNarrowreturns the locales narrow weekdays
	WeekdaysNarrowValue []string

	// returns the locales short weekdays
	WeekdaysShortValue []string

	PeriodsAbbreviatedValue []string

	PeriodsShortValue []string

	PeriodsNarrowValue []string

	PeriodsWideValue []string

	ErasWideValue []string

	ErasAbbreviatedValue []string

	ErasNarrowValue []string

	TimezonesValue map[string]string
}

func (*TimeSpec) ErasAbbreviated ¶ 

func (t *TimeSpec) ErasAbbreviated() []string

func (*TimeSpec) ErasNarrow ¶ 

func (t *TimeSpec) ErasNarrow() []string

func (*TimeSpec) ErasWide ¶ 

func (t *TimeSpec) ErasWide() []string

func (*TimeSpec) MonthAbbreviated ¶ 

func (t *TimeSpec) MonthAbbreviated(m time.Month) string

func (*TimeSpec) MonthNarrow ¶ 

func (t *TimeSpec) MonthNarrow(m time.Month) string

func (*TimeSpec) MonthWide ¶ 

func (t *TimeSpec) MonthWide(m time.Month) string

func (*TimeSpec) MonthsAbbreviated ¶ 

func (t *TimeSpec) MonthsAbbreviated() []string

func (*TimeSpec) MonthsNarrow ¶ 

func (t *TimeSpec) MonthsNarrow() []string

func (*TimeSpec) MonthsWide ¶ 

func (t *TimeSpec) MonthsWide() []string

func (*TimeSpec) PeriodsAbbreviated ¶ 

func (t *TimeSpec) PeriodsAbbreviated() []string

func (*TimeSpec) PeriodsNarrow ¶ 

func (t *TimeSpec) PeriodsNarrow() []string

func (*TimeSpec) PeriodsShort ¶ 

func (t *TimeSpec) PeriodsShort() []string

func (*TimeSpec) PeriodsWide ¶ 

func (t *TimeSpec) PeriodsWide() []string

func (*TimeSpec) TimeSeparator ¶ 

func (t *TimeSpec) TimeSeparator() string

func (*TimeSpec) Timezones ¶ 

func (t *TimeSpec) Timezones() map[string]string

func (*TimeSpec) WeekdayAbbreviated ¶ 

func (t *TimeSpec) WeekdayAbbreviated(d time.Weekday) string

func (*TimeSpec) WeekdayNarrow ¶ 

func (t *TimeSpec) WeekdayNarrow(d time.Weekday) string

func (*TimeSpec) WeekdayShort ¶ 

func (t *TimeSpec) WeekdayShort(d time.Weekday) string

func (*TimeSpec) WeekdayWide ¶ 

func (t *TimeSpec) WeekdayWide(d time.Weekday) string

func (*TimeSpec) WeekdaysAbbreviated ¶ 

func (t *TimeSpec) WeekdaysAbbreviated() []string

func (*TimeSpec) WeekdaysNarrow ¶ 

func (t *TimeSpec) WeekdaysNarrow() []string

func (*TimeSpec) WeekdaysShort ¶ 

func (t *TimeSpec) WeekdaysShort() []string

func (*TimeSpec) WeekdaysWide ¶ 

func (t *TimeSpec) WeekdaysWide() []string

type TimeTranslator ¶ 

type TimeTranslator interface {
	TimeSeparator() string

	// returns the locales wide months
	MonthsWide() []string
	MonthWide(time.Month) string

	// returns the locales abbreviated months
	MonthsAbbreviated() []string
	MonthAbbreviated(time.Month) string

	// returns the locales narrow months
	MonthsNarrow() []string
	MonthNarrow(time.Month) string

	// returns the locales wide weekdays
	WeekdaysWide() []string
	WeekdayWide(d time.Weekday) string

	// returns the locales abbreviated weekdays
	WeekdaysAbbreviated() []string
	WeekdayAbbreviated(d time.Weekday) string

	// WeekdaysNarrowreturns the locales narrow weekdays
	WeekdaysNarrow() []string
	WeekdayNarrow(d time.Weekday) string

	// returns the locales short weekdays
	WeekdaysShort() []string
	WeekdayShort(d time.Weekday) string

	PeriodsAbbreviated() []string
	PeriodsShort() []string
	PeriodsWide() []string
	PeriodsNarrow() []string

	ErasWide() []string
	ErasAbbreviated() []string
	ErasNarrow() []string

	Timezones() map[string]string

	// returns the short date representation of 't' for locale
	FmtDateShort(t time.Time) string

	// returns the medium date representation of 't' for locale
	FmtDateMedium(t time.Time) string

	//  returns the long date representation of 't' for locale
	FmtDateLong(t time.Time) string

	// returns the full date representation of 't' for locale
	FmtDateFull(t time.Time) string

	// returns the short time representation of 't' for locale
	FmtTimeShort(t time.Time) string

	// returns the medium time representation of 't' for locale
	FmtTimeMedium(t time.Time) string

	// returns the long time representation of 't' for locale
	FmtTimeLong(t time.Time) string

	// returns the full time representation of 't' for locale
	FmtTimeFull(t time.Time) string

	// DateFullLayout returns the full date layout for '{{ .Locale }}'
	DateFullLayout() string

	// DateLongLayout returns the long date layout for '{{ .Locale }}'
	DateLongLayout() string

	// DateMediumLayout returns the medium date layout for '{{ .Locale }}'
	DateMediumLayout() string

	// DateShortLayout returns the short date layout for '{{ .Locale }}'
	DateShortLayout() string

	// TimeFullLayout returns the full time layout for '{{ .Locale }}'
	TimeFullLayout() string

	// TimeLongLayout returns the full long layout for '{{ .Locale }}'
	TimeLongLayout() string

	// TimeMediumLayout returns the medium time layout for '{{ .Locale }}'
	TimeMediumLayout() string

	// TimeShortLayout returns the short time layout for '{{ .Locale }}'
	TimeShortLayout() string
}

type TimeValue ¶ 

type TimeValue struct {
	Translator TimeTranslator
	Formatter  TimestampFormat
	Value      time.Time
}

func NewDateTimeValue ¶ 

func NewDateTimeValue(translator TimeTranslator, value time.Time) *TimeValue

func NewDateValue ¶ 

func NewDateValue(translator TimeTranslator, value time.Time) *TimeValue

func NewTimeValue ¶ 

func NewTimeValue(translator TimeTranslator, value time.Time) *TimeValue

func (TimeValue) Format ¶ 

func (t TimeValue) Format(f fmt.State, verb rune)

func (TimeValue) ToString ¶ 

func (t TimeValue) ToString() string

type TimestampFormat ¶ 

type TimestampFormat uint8
const (
	TFNone TimestampFormat = 0
	TFDate TimestampFormat = 1 << iota
	TFTime
	TFFull
	TFLong
	TFMedium
	TFShort
	TFTimeFirst

	DateTime = TFDate | TFTime
)

func (TimestampFormat) Clear ¶ 

func (f TimestampFormat) Clear(flag TimestampFormat) TimestampFormat

func (*TimestampFormat) EraScore ¶ 

func (f *TimestampFormat) EraScore() int8

func (TimestampFormat) Format ¶ 

func (f TimestampFormat) Format(Tr TimeTranslator, t time.Time) string

func (TimestampFormat) FormatSep ¶ 

func (f TimestampFormat) FormatSep(Tr TimeTranslator, t time.Time, dateTimeSep string) string

func (TimestampFormat) Has ¶ 

func (f TimestampFormat) Has(flag TimestampFormat) bool

func (TimestampFormat) Layout ¶ 

func (f TimestampFormat) Layout() TimestampFormat

func (TimestampFormat) Layouts ¶ 

func (f TimestampFormat) Layouts(t TimeTranslator) (s []string)

func (*TimestampFormat) Parse ¶ 

func (f *TimestampFormat) Parse(s string)

func (*TimestampFormat) ParseAppend ¶ 

func (f *TimestampFormat) ParseAppend(p string)

func (*TimestampFormat) ParseAppendArray ¶ 

func (f *TimestampFormat) ParseAppendArray(p ...string)

func (TimestampFormat) Set ¶ 

func (f TimestampFormat) Set(flag TimestampFormat) TimestampFormat

func (*TimestampFormat) String ¶ 

func (f *TimestampFormat) String() string

func (TimestampFormat) Toggle ¶ 

func (f TimestampFormat) Toggle(flag TimestampFormat) TimestampFormat

type Translator ¶ 

type Translator interface {

	// Locale returns the string value of the translator
	Locale() string

	// returns an array of cardinal plural rules associated
	// with this translator
	PluralsCardinal() []PluralRule

	// returns an array of ordinal plural rules associated
	// with this translator
	PluralsOrdinal() []PluralRule

	// returns an array of range plural rules associated
	// with this translator
	PluralsRange() []PluralRule

	// returns the cardinal PluralRule given 'num' and digits/precision of 'v' for locale
	CardinalPluralRule(num float64, v uint64) PluralRule

	// returns the ordinal PluralRule given 'num' and digits/precision of 'v' for locale
	OrdinalPluralRule(num float64, v uint64) PluralRule

	// returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for locale
	RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) PluralRule

	ListPatterns() *ListPatterns

	GetMiscPatterns() *MiscPatterns

	NumberTranslator
	CurrencyTranslator
	TimeTranslator
	DurationTranslator
}

Translator encapsulates an instance of a locale NOTE: some values are returned as a []byte just in case the caller wishes to add more and can help avoid allocations; otherwise just cast as string

type TranslatorSpec ¶ 

type TranslatorSpec struct {
}

Source Files ¶

View all Source files

Directories ¶

Path Synopsis
named
af
af_NA
af_ZA
agq
agq_CM
ak
ak_GH
am
am_ET
ar
ar_001
ar_AE
ar_BH
ar_DJ
ar_DZ
ar_EG
ar_EH
ar_ER
ar_IL
ar_IQ
ar_JO
ar_KM
ar_KW
ar_LB
ar_LY
ar_MA
ar_MR
ar_OM
ar_PS
ar_QA
ar_SA
ar_SD
ar_SO
ar_SS
ar_SY
ar_TD
ar_TN
ar_YE
as
as_IN
asa
asa_TZ
ast
ast_ES
az
az_Cyrl
az_Cyrl_AZ
az_Latn
az_Latn_AZ
bas
bas_CM
be
be_BY
be_TARASK
bem
bem_ZM
bez
bez_TZ
bg
bg_BG
bm
bm_ML
bn
bn_BD
bn_IN
bo
bo_CN
bo_IN
br
br_FR
brx
brx_IN
bs
bs_Cyrl
bs_Cyrl_BA
bs_Latn
bs_Latn_BA
ca
ca_AD
ca_ES
ca_ES_VALENCIA
ca_FR
ca_IT
ccp
ccp_BD
ccp_IN
ce
ce_RU
ceb
ceb_PH
cgg
cgg_UG
chr
chr_US
ckb
ckb_IQ
ckb_IR
cs
cs_CZ
currency
cy
cy_GB
da
da_DK
da_GL
dav
dav_KE
de
de_AT
de_BE
de_CH
de_DE
de_IT
de_LI
de_LU
dje
dje_NE
doi
doi_IN
dsb
dsb_DE
dua
dua_CM
dyo
dyo_SN
dz
dz_BT
ebu
ebu_KE
ee
ee_GH
ee_TG
el
el_CY
el_GR
en
en_001
en_150
en_AE
en_AG
en_AI
en_AS
en_AT
en_AU
en_BB
en_BE
en_BI
en_BM
en_BS
en_BW
en_BZ
en_CA
en_CC
en_CH
en_CK
en_CM
en_CX
en_CY
en_DE
en_DG
en_DK
en_DM
en_ER
en_FI
en_FJ
en_FK
en_FM
en_GB
en_GD
en_GG
en_GH
en_GI
en_GM
en_GU
en_GY
en_HK
en_IE
en_IL
en_IM
en_IN
en_IO
en_JE
en_JM
en_KE
en_KI
en_KN
en_KY
en_LC
en_LR
en_LS
en_MG
en_MH
en_MO
en_MP
en_MS
en_MT
en_MU
en_MV
en_MW
en_MY
en_NA
en_NF
en_NG
en_NL
en_NR
en_NU
en_NZ
en_PG
en_PH
en_PK
en_PN
en_PR
en_PW
en_RW
en_SB
en_SC
en_SD
en_SE
en_SG
en_SH
en_SI
en_SL
en_SS
en_SX
en_SZ
en_TC
en_TK
en_TO
en_TT
en_TV
en_TZ
en_UG
en_UM
en_US
en_US_POSIX
en_VC
en_VG
en_VI
en_VU
en_WS
en_ZA
en_ZM
en_ZW
eo
eo_001
es
es_419
es_AR
es_BO
es_BR
es_BZ
es_CL
es_CO
es_CR
es_CU
es_DO
es_EA
es_EC
es_ES
es_GQ
es_GT
es_HN
es_IC
es_MX
es_NI
es_PA
es_PE
es_PH
es_PR
es_PY
es_SV
es_US
es_UY
es_VE
et
et_EE
eu
eu_ES
ewo
ewo_CM
fa
fa_AF
fa_IR
ff
ff_Adlm
ff_Adlm_BF
ff_Adlm_CM
ff_Adlm_GH
ff_Adlm_GM
ff_Adlm_GN
ff_Adlm_GW
ff_Adlm_LR
ff_Adlm_MR
ff_Adlm_NE
ff_Adlm_NG
ff_Adlm_SL
ff_Adlm_SN
ff_Latn
ff_Latn_BF
ff_Latn_CM
ff_Latn_GH
ff_Latn_GM
ff_Latn_GN
ff_Latn_GW
ff_Latn_LR
ff_Latn_MR
ff_Latn_NE
ff_Latn_NG
ff_Latn_SL
ff_Latn_SN
fi
fi_FI
fil
fil_PH
fo
fo_DK
fo_FO
fr
fr_BE
fr_BF
fr_BI
fr_BJ
fr_BL
fr_CA
fr_CD
fr_CF
fr_CG
fr_CH
fr_CI
fr_CM
fr_DJ
fr_DZ
fr_FR
fr_GA
fr_GF
fr_GN
fr_GP
fr_GQ
fr_HT
fr_KM
fr_LU
fr_MA
fr_MC
fr_MF
fr_MG
fr_ML
fr_MQ
fr_MR
fr_MU
fr_NC
fr_NE
fr_PF
fr_PM
fr_RE
fr_RW
fr_SC
fr_SN
fr_SY
fr_TD
fr_TG
fr_TN
fr_VU
fr_WF
fr_YT
fur
fur_IT
fy
fy_NL
ga
ga_GB
ga_IE
gd
gd_GB
gl
gl_ES
gsw
gsw_CH
gsw_FR
gsw_LI
gu
gu_IN
guz
guz_KE
gv
gv_IM
ha
ha_GH
ha_NE
ha_NG
haw
haw_US
he
he_IL
hi
hi_IN
hi_Latn
hi_Latn_IN
hr
hr_BA
hr_HR
hsb
hsb_DE
hu
hu_HU
hy
hy_AM
ia
ia_001
id
id_ID
ig
ig_NG
ii
ii_CN
is
is_IS
it
it_CH
it_IT
it_SM
it_VA
ja
ja_JP
jgo
jgo_CM
jmc
jmc_TZ
jv
jv_ID
ka
ka_GE
kab
kab_DZ
kam
kam_KE
kde
kde_TZ
kea
kea_CV
kgp
kgp_BR
khq
khq_ML
ki
ki_KE
kk
kk_KZ
kkj
kkj_CM
kl
kl_GL
kln
kln_KE
km
km_KH
kn
kn_IN
ko
ko_KP
ko_KR
kok
kok_IN
ks
ks_Arab
ks_Arab_IN
ks_Deva
ks_Deva_IN
ksb
ksb_TZ
ksf
ksf_CM
ksh
ksh_DE
ku
ku_TR
kw
kw_GB
ky
ky_KG
lag
lag_TZ
lb
lb_LU
lg
lg_UG
lkt
lkt_US
ln
ln_AO
ln_CD
ln_CF
ln_CG
lo
lo_LA
lrc
lrc_IQ
lrc_IR
lt
lt_LT
lu
lu_CD
luo
luo_KE
luy
luy_KE
lv
lv_LV
mai
mai_IN
mas
mas_KE
mas_TZ
mer
mer_KE
mfe
mfe_MU
mg
mg_MG
mgh
mgh_MZ
mgo
mgo_CM
mi
mi_NZ
mk
mk_MK
ml
ml_IN
mn
mn_MN
mni
mni_Beng
mni_Beng_IN
mr
mr_IN
ms
ms_BN
ms_ID
ms_MY
ms_SG
mt
mt_MT
mua
mua_CM
my
my_MM
mzn
mzn_IR
naq
naq_NA
nb
nb_NO
nb_SJ
nd
nd_ZW
nds
nds_DE
nds_NL
ne
ne_IN
ne_NP
nl
nl_AW
nl_BE
nl_BQ
nl_CW
nl_NL
nl_SR
nl_SX
nmg
nmg_CM
nn
nn_NO
nnh
nnh_CM
no
nus
nus_SS
nyn
nyn_UG
om
om_ET
om_KE
or
or_IN
os
os_GE
os_RU
pa
pa_Arab
pa_Arab_PK
pa_Guru
pa_Guru_IN
pcm
pcm_NG
pl
pl_PL
ps
ps_AF
ps_PK
pt
pt_AO
pt_BR
pt_CH
pt_CV
pt_GQ
pt_GW
pt_LU
pt_MO
pt_MZ
pt_PT
pt_ST
pt_TL
qu
qu_BO
qu_EC
qu_PE
rm
rm_CH
rn
rn_BI
ro
ro_MD
ro_RO
rof
rof_TZ
root
ru
ru_BY
ru_KG
ru_KZ
ru_MD
ru_RU
ru_UA
rw
rw_RW
rwk
rwk_TZ
sa
sa_IN
sah
sah_RU
saq
saq_KE
sat
sat_Olck
sat_Olck_IN
sbp
sbp_TZ
sc
sc_IT
sd
sd_Arab
sd_Arab_PK
sd_Deva
sd_Deva_IN
se
se_FI
se_NO
se_SE
seh
seh_MZ
ses
ses_ML
sg
sg_CF
shi
shi_Latn
shi_Latn_MA
shi_Tfng
shi_Tfng_MA
si
si_LK
sk
sk_SK
sl
sl_SI
smn
smn_FI
sn
sn_ZW
so
so_DJ
so_ET
so_KE
so_SO
sq
sq_AL
sq_MK
sq_XK
sr
sr_Cyrl
sr_Cyrl_BA
sr_Cyrl_ME
sr_Cyrl_RS
sr_Cyrl_XK
sr_Latn
sr_Latn_BA
sr_Latn_ME
sr_Latn_RS
sr_Latn_XK
su
su_Latn
su_Latn_ID
sv
sv_AX
sv_FI
sv_SE
sw
sw_CD
sw_KE
sw_TZ
sw_UG
ta
ta_IN
ta_LK
ta_MY
ta_SG
te
te_IN
teo
teo_KE
teo_UG
tg
tg_TJ
th
th_TH
ti
ti_ER
ti_ET
tk
tk_TM
to
to_TO
tr
tr_CY
tr_TR
tt
tt_RU
twq
twq_NE
tzm
tzm_MA
ug
ug_CN
uk
uk_UA
ur
ur_IN
ur_PK
uz
uz_Arab
uz_Arab_AF
uz_Cyrl
uz_Cyrl_UZ
uz_Latn
uz_Latn_UZ
vai
vai_Latn
vai_Latn_LR
vai_Vaii
vai_Vaii_LR
vi
vi_VN
vun
vun_TZ
wae
wae_CH
wo
wo_SN
xh
xh_ZA
xog
xog_UG
yav
yav_CM
yi
yi_001
yo
yo_BJ
yo_NG
yrl
yrl_BR
yrl_CO
yrl_VE
yue
yue_Hans
yue_Hans_CN
yue_Hant
yue_Hant_HK
zgh
zgh_MA
zh
zh_Hans
zh_Hans_CN
zh_Hans_HK
zh_Hans_MO
zh_Hans_SG
zh_Hant
zh_Hant_HK
zh_Hant_MO
zh_Hant_TW
zu
zu_ZA

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.