diff options
Diffstat (limited to 'vendor/github.com/nicksnyder/go-i18n/i18n/language')
14 files changed, 2945 insertions, 0 deletions
diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/generate.sh b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/generate.sh new file mode 100644 index 000000000..a9fae846a --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/generate.sh @@ -0,0 +1,5 @@ +#!/bin/sh +go build && ./codegen -cout ../pluralspec_gen.go -tout ../pluralspec_gen_test.go && \ + gofmt -w=true ../pluralspec_gen.go && \ + gofmt -w=true ../pluralspec_gen_test.go && \ + rm codegen diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/main.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/main.go new file mode 100644 index 000000000..5d6b6ad4f --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/main.go @@ -0,0 +1,132 @@ +package main + +import ( + "encoding/xml" + "flag" + "fmt" + "io/ioutil" + "os" + "text/template" +) + +var usage = `%[1]s generates Go code to support CLDR plural rules. + +Usage: %[1]s [options] + +Options: + +` + +func main() { + flag.Usage = func() { + fmt.Fprintf(os.Stderr, usage, os.Args[0]) + flag.PrintDefaults() + } + var in, cout, tout string + flag.StringVar(&in, "i", "plurals.xml", "the input XML file containing CLDR plural rules") + flag.StringVar(&cout, "cout", "", "the code output file") + flag.StringVar(&tout, "tout", "", "the test output file") + flag.BoolVar(&verbose, "v", false, "verbose output") + flag.Parse() + + buf, err := ioutil.ReadFile(in) + if err != nil { + fatalf("failed to read file: %s", err) + } + + var data SupplementalData + if err := xml.Unmarshal(buf, &data); err != nil { + fatalf("failed to unmarshal xml: %s", err) + } + + count := 0 + for _, pg := range data.PluralGroups { + count += len(pg.SplitLocales()) + } + infof("parsed %d locales", count) + + if cout != "" { + file := openWritableFile(cout) + if err := codeTemplate.Execute(file, data); err != nil { + fatalf("unable to execute code template because %s", err) + } else { + infof("generated %s", cout) + } + } else { + infof("not generating code file (use -cout)") + } + + if tout != "" { + file := openWritableFile(tout) + if err := testTemplate.Execute(file, data); err != nil { + fatalf("unable to execute test template because %s", err) + } else { + infof("generated %s", tout) + } + } else { + infof("not generating test file (use -tout)") + } +} + +func openWritableFile(name string) *os.File { + file, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644) + if err != nil { + fatalf("failed to write file %s because %s", name, err) + } + return file +} + +var codeTemplate = template.Must(template.New("spec").Parse(`package language +// This file is generated by i18n/language/codegen/generate.sh + +func init() { +{{range .PluralGroups}} + registerPluralSpec({{printf "%#v" .SplitLocales}}, &PluralSpec{ + Plurals: newPluralSet({{range $i, $e := .PluralRules}}{{if $i}}, {{end}}{{$e.CountTitle}}{{end}}), + PluralFunc: func(ops *operands) Plural { {{range .PluralRules}}{{if .GoCondition}} + // {{.Condition}} + if {{.GoCondition}} { + return {{.CountTitle}} + }{{end}}{{end}} + return Other + }, + }){{end}} +} +`)) + +var testTemplate = template.Must(template.New("spec").Parse(`package language +// This file is generated by i18n/language/codegen/generate.sh + +import "testing" + +{{range .PluralGroups}} +func Test{{.Name}}(t *testing.T) { + var tests []pluralTest + {{range .PluralRules}} + {{if .IntegerExamples}}tests = appendIntegerTests(tests, {{.CountTitle}}, {{printf "%#v" .IntegerExamples}}){{end}} + {{if .DecimalExamples}}tests = appendDecimalTests(tests, {{.CountTitle}}, {{printf "%#v" .DecimalExamples}}){{end}} + {{end}} + locales := {{printf "%#v" .SplitLocales}} + for _, locale := range locales { + runTests(t, locale, tests) + } +} +{{end}} +`)) + +func infof(format string, args ...interface{}) { + fmt.Fprintf(os.Stderr, format+"\n", args...) +} + +var verbose bool + +func verbosef(format string, args ...interface{}) { + if verbose { + infof(format, args...) + } +} + +func fatalf(format string, args ...interface{}) { + infof("fatal: "+format+"\n", args...) + os.Exit(1) +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/plurals.xml b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/plurals.xml new file mode 100644 index 000000000..cdd0b5296 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/plurals.xml @@ -0,0 +1,230 @@ +<?xml version="1.0" encoding="UTF-8" ?> +<!DOCTYPE supplementalData SYSTEM "../../common/dtd/ldmlSupplemental.dtd"> +<!-- +Copyright © 1991-2015 Unicode, Inc. +CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/) +For terms of use, see http://www.unicode.org/copyright.html +--> +<supplementalData> + <version number="$Revision: 12002 $"/> + <plurals type="cardinal"> + <!-- For a canonicalized list, use GeneratedPluralSamples --> + + <!-- 1: other --> + + <pluralRules locales="bm bo dz id ig ii in ja jbo jv jw kde kea km ko lkt lo ms my nqo root sah ses sg th to vi wo yo zh"> + <pluralRule count="other"> @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 2: one,other --> + + <pluralRules locales="am as bn fa gu hi kn mr zu"> + <pluralRule count="one">i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ff fr hy kab"> + <pluralRule count="one">i = 0,1 @integer 0, 1 @decimal 0.0~1.5</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ast ca de en et fi fy gl it ji nl sv sw ur yi"> + <pluralRule count="one">i = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="other"> @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="si"> + <pluralRule count="one">n = 0,1 or i = 0 and f = 1 @integer 0, 1 @decimal 0.0, 0.1, 1.0, 0.00, 0.01, 1.00, 0.000, 0.001, 1.000, 0.0000, 0.0001, 1.0000</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.2~0.9, 1.1~1.8, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ak bh guw ln mg nso pa ti wa"> + <pluralRule count="one">n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="tzm"> + <pluralRule count="one">n = 0..1 or n = 11..99 @integer 0, 1, 11~24 @decimal 0.0, 1.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0</pluralRule> + <pluralRule count="other"> @integer 2~10, 100~106, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="pt"> + <pluralRule count="one">n = 0..2 and n != 2 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="af asa az bem bez bg brx ce cgg chr ckb dv ee el eo es eu fo fur gsw ha haw hu jgo jmc ka kaj kcg kk kkj kl ks ksb ku ky lb lg mas mgo ml mn nah nb nd ne nn nnh no nr ny nyn om or os pap ps rm rof rwk saq sdh seh sn so sq ss ssy st syr ta te teo tig tk tn tr ts ug uz ve vo vun wae xh xog"> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="other"> @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="pt_PT"> + <pluralRule count="one">n = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="other"> @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="da"> + <pluralRule count="one">n = 1 or t != 0 and i = 0,1 @integer 1 @decimal 0.1~1.6</pluralRule> + <pluralRule count="other"> @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 2.0~3.4, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="is"> + <pluralRule count="one">t = 0 and i % 10 = 1 and i % 100 != 11 or t != 0 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1~1.6, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="other"> @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="mk"> + <pluralRule count="one">v = 0 and i % 10 = 1 or f % 10 = 1 @integer 1, 11, 21, 31, 41, 51, 61, 71, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="other"> @integer 0, 2~10, 12~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.2~1.0, 1.2~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="fil tl"> + <pluralRule count="one">v = 0 and i = 1,2,3 or v = 0 and i % 10 != 4,6,9 or v != 0 and f % 10 != 4,6,9 @integer 0~3, 5, 7, 8, 10~13, 15, 17, 18, 20, 21, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.3, 0.5, 0.7, 0.8, 1.0~1.3, 1.5, 1.7, 1.8, 2.0, 2.1, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @integer 4, 6, 9, 14, 16, 19, 24, 26, 104, 1004, … @decimal 0.4, 0.6, 0.9, 1.4, 1.6, 1.9, 2.4, 2.6, 10.4, 100.4, 1000.4, …</pluralRule> + </pluralRules> + + <!-- 3: zero,one,other --> + + <pluralRules locales="lv prg"> + <pluralRule count="zero">n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer 0, 10~20, 30, 40, 50, 60, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="one">n % 10 = 1 and n % 100 != 11 or v = 2 and f % 10 = 1 and f % 100 != 11 or v != 2 and f % 10 = 1 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.0, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="other"> @integer 2~9, 22~29, 102, 1002, … @decimal 0.2~0.9, 1.2~1.9, 10.2, 100.2, 1000.2, …</pluralRule> + </pluralRules> + <pluralRules locales="lag"> + <pluralRule count="zero">n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000</pluralRule> + <pluralRule count="one">i = 0,1 and n != 0 @integer 1 @decimal 0.1~1.6</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ksh"> + <pluralRule count="zero">n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000</pluralRule> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="other"> @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 3: one,two,other --> + + <pluralRules locales="iu kw naq se sma smi smj smn sms"> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="two">n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000</pluralRule> + <pluralRule count="other"> @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 3: one,few,other --> + + <pluralRules locales="shi"> + <pluralRule count="one">i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04</pluralRule> + <pluralRule count="few">n = 2..10 @integer 2~10 @decimal 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 2.00, 3.00, 4.00, 5.00, 6.00, 7.00, 8.00</pluralRule> + <pluralRule count="other"> @integer 11~26, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~1.9, 2.1~2.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="mo ro"> + <pluralRule count="one">i = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="few">v != 0 or n = 0 or n != 1 and n % 100 = 1..19 @integer 0, 2~16, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @integer 20~35, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + </pluralRules> + <pluralRules locales="bs hr sh sr"> + <pluralRule count="one">v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="few">v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …</pluralRule> + <pluralRule count="other"> @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 4: one,two,few,other --> + + <pluralRules locales="gd"> + <pluralRule count="one">n = 1,11 @integer 1, 11 @decimal 1.0, 11.0, 1.00, 11.00, 1.000, 11.000, 1.0000</pluralRule> + <pluralRule count="two">n = 2,12 @integer 2, 12 @decimal 2.0, 12.0, 2.00, 12.00, 2.000, 12.000, 2.0000</pluralRule> + <pluralRule count="few">n = 3..10,13..19 @integer 3~10, 13~19 @decimal 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 3.00</pluralRule> + <pluralRule count="other"> @integer 0, 20~34, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="sl"> + <pluralRule count="one">v = 0 and i % 100 = 1 @integer 1, 101, 201, 301, 401, 501, 601, 701, 1001, …</pluralRule> + <pluralRule count="two">v = 0 and i % 100 = 2 @integer 2, 102, 202, 302, 402, 502, 602, 702, 1002, …</pluralRule> + <pluralRule count="few">v = 0 and i % 100 = 3..4 or v != 0 @integer 3, 4, 103, 104, 203, 204, 303, 304, 403, 404, 503, 504, 603, 604, 703, 704, 1003, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + </pluralRules> + <pluralRules locales="dsb hsb"> + <pluralRule count="one">v = 0 and i % 100 = 1 or f % 100 = 1 @integer 1, 101, 201, 301, 401, 501, 601, 701, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="two">v = 0 and i % 100 = 2 or f % 100 = 2 @integer 2, 102, 202, 302, 402, 502, 602, 702, 1002, … @decimal 0.2, 1.2, 2.2, 3.2, 4.2, 5.2, 6.2, 7.2, 10.2, 100.2, 1000.2, …</pluralRule> + <pluralRule count="few">v = 0 and i % 100 = 3..4 or f % 100 = 3..4 @integer 3, 4, 103, 104, 203, 204, 303, 304, 403, 404, 503, 504, 603, 604, 703, 704, 1003, … @decimal 0.3, 0.4, 1.3, 1.4, 2.3, 2.4, 3.3, 3.4, 4.3, 4.4, 5.3, 5.4, 6.3, 6.4, 7.3, 7.4, 10.3, 100.3, 1000.3, …</pluralRule> + <pluralRule count="other"> @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 4: one,two,many,other --> + + <pluralRules locales="he iw"> + <pluralRule count="one">i = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="two">i = 2 and v = 0 @integer 2</pluralRule> + <pluralRule count="many">v = 0 and n != 0..10 and n % 10 = 0 @integer 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + <pluralRule count="other"> @integer 0, 3~17, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 4: one,few,many,other --> + + <pluralRules locales="cs sk"> + <pluralRule count="one">i = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="few">i = 2..4 and v = 0 @integer 2~4</pluralRule> + <pluralRule count="many">v != 0 @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + </pluralRules> + <pluralRules locales="pl"> + <pluralRule count="one">i = 1 and v = 0 @integer 1</pluralRule> + <pluralRule count="few">v = 0 and i % 10 = 2..4 and i % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, …</pluralRule> + <pluralRule count="many">v = 0 and i != 1 and i % 10 = 0..1 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 12..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + <pluralRule count="other"> @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="be"> + <pluralRule count="one">n % 10 = 1 and n % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 71.0, 81.0, 101.0, 1001.0, …</pluralRule> + <pluralRule count="few">n % 10 = 2..4 and n % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 2.0, 3.0, 4.0, 22.0, 23.0, 24.0, 32.0, 33.0, 102.0, 1002.0, …</pluralRule> + <pluralRule count="many">n % 10 = 0 or n % 10 = 5..9 or n % 100 = 11..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.1, 1000.1, …</pluralRule> + </pluralRules> + <pluralRules locales="lt"> + <pluralRule count="one">n % 10 = 1 and n % 100 != 11..19 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 71.0, 81.0, 101.0, 1001.0, …</pluralRule> + <pluralRule count="few">n % 10 = 2..9 and n % 100 != 11..19 @integer 2~9, 22~29, 102, 1002, … @decimal 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 22.0, 102.0, 1002.0, …</pluralRule> + <pluralRule count="many">f != 0 @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.1, 1000.1, …</pluralRule> + <pluralRule count="other"> @integer 0, 10~20, 30, 40, 50, 60, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="mt"> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="few">n = 0 or n % 100 = 2..10 @integer 0, 2~10, 102~107, 1002, … @decimal 0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 102.0, 1002.0, …</pluralRule> + <pluralRule count="many">n % 100 = 11..19 @integer 11~19, 111~117, 1011, … @decimal 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 111.0, 1011.0, …</pluralRule> + <pluralRule count="other"> @integer 20~35, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ru uk"> + <pluralRule count="one">v = 0 and i % 10 = 1 and i % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, …</pluralRule> + <pluralRule count="few">v = 0 and i % 10 = 2..4 and i % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, …</pluralRule> + <pluralRule count="many">v = 0 and i % 10 = 0 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 11..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …</pluralRule> + <pluralRule count="other"> @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + + <!-- 5: one,two,few,many,other --> + + <pluralRules locales="br"> + <pluralRule count="one">n % 10 = 1 and n % 100 != 11,71,91 @integer 1, 21, 31, 41, 51, 61, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 81.0, 101.0, 1001.0, …</pluralRule> + <pluralRule count="two">n % 10 = 2 and n % 100 != 12,72,92 @integer 2, 22, 32, 42, 52, 62, 82, 102, 1002, … @decimal 2.0, 22.0, 32.0, 42.0, 52.0, 62.0, 82.0, 102.0, 1002.0, …</pluralRule> + <pluralRule count="few">n % 10 = 3..4,9 and n % 100 != 10..19,70..79,90..99 @integer 3, 4, 9, 23, 24, 29, 33, 34, 39, 43, 44, 49, 103, 1003, … @decimal 3.0, 4.0, 9.0, 23.0, 24.0, 29.0, 33.0, 34.0, 103.0, 1003.0, …</pluralRule> + <pluralRule count="many">n != 0 and n % 1000000 = 0 @integer 1000000, … @decimal 1000000.0, 1000000.00, 1000000.000, …</pluralRule> + <pluralRule count="other"> @integer 0, 5~8, 10~20, 100, 1000, 10000, 100000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="ga"> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="two">n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000</pluralRule> + <pluralRule count="few">n = 3..6 @integer 3~6 @decimal 3.0, 4.0, 5.0, 6.0, 3.00, 4.00, 5.00, 6.00, 3.000, 4.000, 5.000, 6.000, 3.0000, 4.0000, 5.0000, 6.0000</pluralRule> + <pluralRule count="many">n = 7..10 @integer 7~10 @decimal 7.0, 8.0, 9.0, 10.0, 7.00, 8.00, 9.00, 10.00, 7.000, 8.000, 9.000, 10.000, 7.0000, 8.0000, 9.0000, 10.0000</pluralRule> + <pluralRule count="other"> @integer 0, 11~25, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="gv"> + <pluralRule count="one">v = 0 and i % 10 = 1 @integer 1, 11, 21, 31, 41, 51, 61, 71, 101, 1001, …</pluralRule> + <pluralRule count="two">v = 0 and i % 10 = 2 @integer 2, 12, 22, 32, 42, 52, 62, 72, 102, 1002, …</pluralRule> + <pluralRule count="few">v = 0 and i % 100 = 0,20,40,60,80 @integer 0, 20, 40, 60, 80, 100, 120, 140, 1000, 10000, 100000, 1000000, …</pluralRule> + <pluralRule count="many">v != 0 @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + <pluralRule count="other"> @integer 3~10, 13~19, 23, 103, 1003, …</pluralRule> + </pluralRules> + + <!-- 6: zero,one,two,few,many,other --> + + <pluralRules locales="ar"> + <pluralRule count="zero">n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000</pluralRule> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="two">n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000</pluralRule> + <pluralRule count="few">n % 100 = 3..10 @integer 3~10, 103~110, 1003, … @decimal 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 103.0, 1003.0, …</pluralRule> + <pluralRule count="many">n % 100 = 11..99 @integer 11~26, 111, 1011, … @decimal 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 111.0, 1011.0, …</pluralRule> + <pluralRule count="other"> @integer 100~102, 200~202, 300~302, 400~402, 500~502, 600, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + <pluralRules locales="cy"> + <pluralRule count="zero">n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000</pluralRule> + <pluralRule count="one">n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000</pluralRule> + <pluralRule count="two">n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000</pluralRule> + <pluralRule count="few">n = 3 @integer 3 @decimal 3.0, 3.00, 3.000, 3.0000</pluralRule> + <pluralRule count="many">n = 6 @integer 6 @decimal 6.0, 6.00, 6.000, 6.0000</pluralRule> + <pluralRule count="other"> @integer 4, 5, 7~20, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …</pluralRule> + </pluralRules> + </plurals> +</supplementalData> diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/xml.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/xml.go new file mode 100644 index 000000000..9d39053c2 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/codegen/xml.go @@ -0,0 +1,143 @@ +package main + +import ( + "encoding/xml" + "fmt" + "regexp" + "strings" +) + +// SupplementalData is the top level struct of plural.xml +type SupplementalData struct { + XMLName xml.Name `xml:"supplementalData"` + PluralGroups []PluralGroup `xml:"plurals>pluralRules"` +} + +// PluralGroup is a group of locales with the same plural rules. +type PluralGroup struct { + Locales string `xml:"locales,attr"` + PluralRules []PluralRule `xml:"pluralRule"` +} + +// Name returns a unique name for this plural group. +func (pg *PluralGroup) Name() string { + n := strings.Title(pg.Locales) + return strings.Replace(n, " ", "", -1) +} + +// SplitLocales returns all the locales in the PluralGroup as a slice. +func (pg *PluralGroup) SplitLocales() []string { + return strings.Split(pg.Locales, " ") +} + +// PluralRule is the rule for a single plural form. +type PluralRule struct { + Count string `xml:"count,attr"` + Rule string `xml:",innerxml"` +} + +// CountTitle returns the title case of the PluralRule's count. +func (pr *PluralRule) CountTitle() string { + return strings.Title(pr.Count) +} + +// Condition returns the condition where the PluralRule applies. +func (pr *PluralRule) Condition() string { + i := strings.Index(pr.Rule, "@") + return pr.Rule[:i] +} + +// Examples returns the integer and decimal exmaples for the PLuralRule. +func (pr *PluralRule) Examples() (integer []string, decimal []string) { + ex := strings.Replace(pr.Rule, ", …", "", -1) + ddelim := "@decimal" + if i := strings.Index(ex, ddelim); i > 0 { + dex := strings.TrimSpace(ex[i+len(ddelim):]) + decimal = strings.Split(dex, ", ") + ex = ex[:i] + } + idelim := "@integer" + if i := strings.Index(ex, idelim); i > 0 { + iex := strings.TrimSpace(ex[i+len(idelim):]) + integer = strings.Split(iex, ", ") + } + return integer, decimal +} + +// IntegerExamples returns the integer exmaples for the PLuralRule. +func (pr *PluralRule) IntegerExamples() []string { + integer, _ := pr.Examples() + return integer +} + +// DecimalExamples returns the decimal exmaples for the PLuralRule. +func (pr *PluralRule) DecimalExamples() []string { + _, decimal := pr.Examples() + return decimal +} + +var relationRegexp = regexp.MustCompile("([niftvw])(?: % ([0-9]+))? (!=|=)(.*)") + +// GoCondition converts the XML condition to valid Go code. +func (pr *PluralRule) GoCondition() string { + var ors []string + for _, and := range strings.Split(pr.Condition(), "or") { + var ands []string + for _, relation := range strings.Split(and, "and") { + parts := relationRegexp.FindStringSubmatch(relation) + if parts == nil { + continue + } + lvar, lmod, op, rhs := strings.Title(parts[1]), parts[2], parts[3], strings.TrimSpace(parts[4]) + if op == "=" { + op = "==" + } + lvar = "ops." + lvar + var rhor []string + var rany []string + for _, rh := range strings.Split(rhs, ",") { + if parts := strings.Split(rh, ".."); len(parts) == 2 { + from, to := parts[0], parts[1] + if lvar == "ops.N" { + if lmod != "" { + rhor = append(rhor, fmt.Sprintf("ops.NmodInRange(%s, %s, %s)", lmod, from, to)) + } else { + rhor = append(rhor, fmt.Sprintf("ops.NinRange(%s, %s)", from, to)) + } + } else if lmod != "" { + rhor = append(rhor, fmt.Sprintf("intInRange(%s %% %s, %s, %s)", lvar, lmod, from, to)) + } else { + rhor = append(rhor, fmt.Sprintf("intInRange(%s, %s, %s)", lvar, from, to)) + } + } else { + rany = append(rany, rh) + } + } + + if len(rany) > 0 { + rh := strings.Join(rany, ",") + if lvar == "ops.N" { + if lmod != "" { + rhor = append(rhor, fmt.Sprintf("ops.NmodEqualsAny(%s, %s)", lmod, rh)) + } else { + rhor = append(rhor, fmt.Sprintf("ops.NequalsAny(%s)", rh)) + } + } else if lmod != "" { + rhor = append(rhor, fmt.Sprintf("intEqualsAny(%s %% %s, %s)", lvar, lmod, rh)) + } else { + rhor = append(rhor, fmt.Sprintf("intEqualsAny(%s, %s)", lvar, rh)) + } + } + r := strings.Join(rhor, " || ") + if len(rhor) > 1 { + r = "(" + r + ")" + } + if op == "!=" { + r = "!" + r + } + ands = append(ands, r) + } + ors = append(ors, strings.Join(ands, " && ")) + } + return strings.Join(ors, " ||\n") +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/language.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/language.go new file mode 100644 index 000000000..9a155efc5 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/language.go @@ -0,0 +1,99 @@ +// Package language defines languages that implement CLDR pluralization. +package language + +import ( + "fmt" + "strings" +) + +// Language is a written human language. +type Language struct { + // Tag uniquely identifies the language as defined by RFC 5646. + // + // Most language tags are a two character language code (ISO 639-1) + // optionally followed by a dash and a two character country code (ISO 3166-1). + // (e.g. en, pt-br) + Tag string + *PluralSpec +} + +func (l *Language) String() string { + return l.Tag +} + +// MatchingTags returns the set of language tags that map to this Language. +// e.g. "zh-hans-cn" yields {"zh", "zh-hans", "zh-hans-cn"} +// BUG: This should be computed once and stored as a field on Language for efficiency, +// but this would require changing how Languages are constructed. +func (l *Language) MatchingTags() []string { + parts := strings.Split(l.Tag, "-") + var prefix, matches []string + for _, part := range parts { + prefix = append(prefix, part) + match := strings.Join(prefix, "-") + matches = append(matches, match) + } + return matches +} + +// Parse returns a slice of supported languages found in src or nil if none are found. +// It can parse language tags and Accept-Language headers. +func Parse(src string) []*Language { + var langs []*Language + start := 0 + for end, chr := range src { + switch chr { + case ',', ';', '.': + tag := strings.TrimSpace(src[start:end]) + if spec := getPluralSpec(tag); spec != nil { + langs = append(langs, &Language{NormalizeTag(tag), spec}) + } + start = end + 1 + } + } + if start > 0 { + tag := strings.TrimSpace(src[start:]) + if spec := getPluralSpec(tag); spec != nil { + langs = append(langs, &Language{NormalizeTag(tag), spec}) + } + return dedupe(langs) + } + if spec := getPluralSpec(src); spec != nil { + langs = append(langs, &Language{NormalizeTag(src), spec}) + } + return langs +} + +func dedupe(langs []*Language) []*Language { + found := make(map[string]struct{}, len(langs)) + deduped := make([]*Language, 0, len(langs)) + for _, lang := range langs { + if _, ok := found[lang.Tag]; !ok { + found[lang.Tag] = struct{}{} + deduped = append(deduped, lang) + } + } + return deduped +} + +// MustParse is similar to Parse except it panics instead of retuning a nil Language. +func MustParse(src string) []*Language { + langs := Parse(src) + if len(langs) == 0 { + panic(fmt.Errorf("unable to parse language from %q", src)) + } + return langs +} + +// Add adds support for a new language. +func Add(l *Language) { + tag := NormalizeTag(l.Tag) + pluralSpecs[tag] = l.PluralSpec +} + +// NormalizeTag returns a language tag with all lower-case characters +// and dashes "-" instead of underscores "_" +func NormalizeTag(tag string) string { + tag = strings.ToLower(tag) + return strings.Replace(tag, "_", "-", -1) +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/language_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/language_test.go new file mode 100644 index 000000000..2949bfe4a --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/language_test.go @@ -0,0 +1,85 @@ +package language + +import ( + "reflect" + "testing" +) + +func TestParse(t *testing.T) { + tests := []struct { + src string + lang []*Language + }{ + {"en", []*Language{{"en", pluralSpecs["en"]}}}, + {"en-US", []*Language{{"en-us", pluralSpecs["en"]}}}, + {"en_US", []*Language{{"en-us", pluralSpecs["en"]}}}, + {"en-GB", []*Language{{"en-gb", pluralSpecs["en"]}}}, + {"zh-CN", []*Language{{"zh-cn", pluralSpecs["zh"]}}}, + {"zh-TW", []*Language{{"zh-tw", pluralSpecs["zh"]}}}, + {"pt-BR", []*Language{{"pt-br", pluralSpecs["pt"]}}}, + {"pt_BR", []*Language{{"pt-br", pluralSpecs["pt"]}}}, + {"pt-PT", []*Language{{"pt-pt", pluralSpecs["pt-pt"]}}}, + {"pt_PT", []*Language{{"pt-pt", pluralSpecs["pt-pt"]}}}, + {"zh-Hans-CN", []*Language{{"zh-hans-cn", pluralSpecs["zh"]}}}, + {"zh-Hant-TW", []*Language{{"zh-hant-tw", pluralSpecs["zh"]}}}, + {"en-US-en-US", []*Language{{"en-us-en-us", pluralSpecs["en"]}}}, + {".en-US..en-US.", []*Language{{"en-us", pluralSpecs["en"]}}}, + { + "it, xx-zz, xx-ZZ, zh, en-gb;q=0.8, en;q=0.7, es-ES;q=0.6, de-xx", + []*Language{ + {"it", pluralSpecs["it"]}, + {"zh", pluralSpecs["zh"]}, + {"en-gb", pluralSpecs["en"]}, + {"en", pluralSpecs["en"]}, + {"es-es", pluralSpecs["es"]}, + {"de-xx", pluralSpecs["de"]}, + }, + }, + { + "it-qq,xx,xx-zz,xx-ZZ,zh,en-gb;q=0.8,en;q=0.7,es-ES;q=0.6,de-xx", + []*Language{ + {"it-qq", pluralSpecs["it"]}, + {"zh", pluralSpecs["zh"]}, + {"en-gb", pluralSpecs["en"]}, + {"en", pluralSpecs["en"]}, + {"es-es", pluralSpecs["es"]}, + {"de-xx", pluralSpecs["de"]}, + }, + }, + {"en.json", []*Language{{"en", pluralSpecs["en"]}}}, + {"en-US.json", []*Language{{"en-us", pluralSpecs["en"]}}}, + {"en-us.json", []*Language{{"en-us", pluralSpecs["en"]}}}, + {"en-xx.json", []*Language{{"en-xx", pluralSpecs["en"]}}}, + {"xx-Yyen-US", nil}, + {"en US", nil}, + {"", nil}, + {"-", nil}, + {"_", nil}, + {"-en", nil}, + {"_en", nil}, + {"-en-", nil}, + {"_en_", nil}, + {"xx", nil}, + } + for _, test := range tests { + lang := Parse(test.src) + if !reflect.DeepEqual(lang, test.lang) { + t.Errorf("Parse(%q) = %s expected %s", test.src, lang, test.lang) + } + } +} + +func TestMatchingTags(t *testing.T) { + tests := []struct { + lang *Language + matches []string + }{ + {&Language{"zh-hans-cn", nil}, []string{"zh", "zh-hans", "zh-hans-cn"}}, + {&Language{"foo", nil}, []string{"foo"}}, + } + for _, test := range tests { + if actual := test.lang.MatchingTags(); !reflect.DeepEqual(test.matches, actual) { + t.Errorf("matchingTags(%q) = %q expected %q", test.lang.Tag, actual, test.matches) + } + } +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands.go new file mode 100644 index 000000000..877bcc89d --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands.go @@ -0,0 +1,119 @@ +package language + +import ( + "fmt" + "strconv" + "strings" +) + +// http://unicode.org/reports/tr35/tr35-numbers.html#Operands +type operands struct { + N float64 // absolute value of the source number (integer and decimals) + I int64 // integer digits of n + V int64 // number of visible fraction digits in n, with trailing zeros + W int64 // number of visible fraction digits in n, without trailing zeros + F int64 // visible fractional digits in n, with trailing zeros + T int64 // visible fractional digits in n, without trailing zeros +} + +// NmodEqualAny returns true if o represents an integer equal to any of the arguments. +func (o *operands) NequalsAny(any ...int64) bool { + for _, i := range any { + if o.I == i && o.T == 0 { + return true + } + } + return false +} + +// NmodEqualAny returns true if o represents an integer equal to any of the arguments modulo mod. +func (o *operands) NmodEqualsAny(mod int64, any ...int64) bool { + modI := o.I % mod + for _, i := range any { + if modI == i && o.T == 0 { + return true + } + } + return false +} + +// NmodInRange returns true if o represents an integer in the closed interval [from, to]. +func (o *operands) NinRange(from, to int64) bool { + return o.T == 0 && from <= o.I && o.I <= to +} + +// NmodInRange returns true if o represents an integer in the closed interval [from, to] modulo mod. +func (o *operands) NmodInRange(mod, from, to int64) bool { + modI := o.I % mod + return o.T == 0 && from <= modI && modI <= to +} + +func newOperands(v interface{}) (*operands, error) { + switch v := v.(type) { + case int: + return newOperandsInt64(int64(v)), nil + case int8: + return newOperandsInt64(int64(v)), nil + case int16: + return newOperandsInt64(int64(v)), nil + case int32: + return newOperandsInt64(int64(v)), nil + case int64: + return newOperandsInt64(v), nil + case string: + return newOperandsString(v) + case float32, float64: + return nil, fmt.Errorf("floats should be formatted into a string") + default: + return nil, fmt.Errorf("invalid type %T; expected integer or string", v) + } +} + +func newOperandsInt64(i int64) *operands { + if i < 0 { + i = -i + } + return &operands{float64(i), i, 0, 0, 0, 0} +} + +func newOperandsString(s string) (*operands, error) { + if s[0] == '-' { + s = s[1:] + } + n, err := strconv.ParseFloat(s, 64) + if err != nil { + return nil, err + } + ops := &operands{N: n} + parts := strings.SplitN(s, ".", 2) + ops.I, err = strconv.ParseInt(parts[0], 10, 64) + if err != nil { + return nil, err + } + if len(parts) == 1 { + return ops, nil + } + fraction := parts[1] + ops.V = int64(len(fraction)) + for i := ops.V - 1; i >= 0; i-- { + if fraction[i] != '0' { + ops.W = i + 1 + break + } + } + if ops.V > 0 { + f, err := strconv.ParseInt(fraction, 10, 0) + if err != nil { + return nil, err + } + ops.F = f + } + if ops.W > 0 { + t, err := strconv.ParseInt(fraction[:ops.W], 10, 0) + if err != nil { + return nil, err + } + ops.T = t + } + return ops, nil +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands_test.go new file mode 100644 index 000000000..29030876a --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/operands_test.go @@ -0,0 +1,45 @@ +package language + +import ( + "reflect" + "testing" +) + +func TestNewOperands(t *testing.T) { + tests := []struct { + input interface{} + ops *operands + err bool + }{ + {int64(0), &operands{0.0, 0, 0, 0, 0, 0}, false}, + {int64(1), &operands{1.0, 1, 0, 0, 0, 0}, false}, + {"0", &operands{0.0, 0, 0, 0, 0, 0}, false}, + {"1", &operands{1.0, 1, 0, 0, 0, 0}, false}, + {"1.0", &operands{1.0, 1, 1, 0, 0, 0}, false}, + {"1.00", &operands{1.0, 1, 2, 0, 0, 0}, false}, + {"1.3", &operands{1.3, 1, 1, 1, 3, 3}, false}, + {"1.30", &operands{1.3, 1, 2, 1, 30, 3}, false}, + {"1.03", &operands{1.03, 1, 2, 2, 3, 3}, false}, + {"1.230", &operands{1.23, 1, 3, 2, 230, 23}, false}, + {"20.0230", &operands{20.023, 20, 4, 3, 230, 23}, false}, + {20.0230, nil, true}, + } + for _, test := range tests { + ops, err := newOperands(test.input) + if err != nil && !test.err { + t.Errorf("newOperands(%#v) unexpected error: %s", test.input, err) + } else if err == nil && test.err { + t.Errorf("newOperands(%#v) returned %#v; expected error", test.input, ops) + } else if !reflect.DeepEqual(ops, test.ops) { + t.Errorf("newOperands(%#v) returned %#v; expected %#v", test.input, ops, test.ops) + } + } +} + +func BenchmarkNewOperand(b *testing.B) { + for i := 0; i < b.N; i++ { + if _, err := newOperands("1234.56780000"); err != nil { + b.Fatal(err) + } + } +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural.go new file mode 100644 index 000000000..1f3ea5c69 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural.go @@ -0,0 +1,40 @@ +package language + +import ( + "fmt" +) + +// Plural represents a language pluralization form as defined here: +// http://cldr.unicode.org/index/cldr-spec/plural-rules +type Plural string + +// All defined plural categories. +const ( + Invalid Plural = "invalid" + Zero = "zero" + One = "one" + Two = "two" + Few = "few" + Many = "many" + Other = "other" +) + +// NewPlural returns src as a Plural +// or Invalid and a non-nil error if src is not a valid Plural. +func NewPlural(src string) (Plural, error) { + switch src { + case "zero": + return Zero, nil + case "one": + return One, nil + case "two": + return Two, nil + case "few": + return Few, nil + case "many": + return Many, nil + case "other": + return Other, nil + } + return Invalid, fmt.Errorf("invalid plural category %s", src) +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural_test.go new file mode 100644 index 000000000..6336d29b2 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/plural_test.go @@ -0,0 +1,28 @@ +package language + +import ( + "testing" +) + +func TestNewPlural(t *testing.T) { + tests := []struct { + src string + plural Plural + err bool + }{ + {"zero", Zero, false}, + {"one", One, false}, + {"two", Two, false}, + {"few", Few, false}, + {"many", Many, false}, + {"other", Other, false}, + {"asdf", Invalid, true}, + } + for _, test := range tests { + plural, err := NewPlural(test.src) + wrongErr := (err != nil && !test.err) || (err == nil && test.err) + if plural != test.plural || wrongErr { + t.Errorf("NewPlural(%#v) returned %#v,%#v; expected %#v", test.src, plural, err, test.plural) + } + } +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec.go new file mode 100644 index 000000000..fc3522682 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec.go @@ -0,0 +1,74 @@ +package language + +import "strings" + +// PluralSpec defines the CLDR plural rules for a language. +// http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html +// http://unicode.org/reports/tr35/tr35-numbers.html#Operands +type PluralSpec struct { + Plurals map[Plural]struct{} + PluralFunc func(*operands) Plural +} + +var pluralSpecs = make(map[string]*PluralSpec) + +func normalizePluralSpecID(id string) string { + id = strings.Replace(id, "_", "-", -1) + id = strings.ToLower(id) + return id +} + +func registerPluralSpec(ids []string, ps *PluralSpec) { + for _, id := range ids { + id = normalizePluralSpecID(id) + pluralSpecs[id] = ps + } +} + +// Plural returns the plural category for number as defined by +// the language's CLDR plural rules. +func (ps *PluralSpec) Plural(number interface{}) (Plural, error) { + ops, err := newOperands(number) + if err != nil { + return Invalid, err + } + return ps.PluralFunc(ops), nil +} + +// getPluralSpec returns the PluralSpec that matches the longest prefix of tag. +// It returns nil if no PluralSpec matches tag. +func getPluralSpec(tag string) *PluralSpec { + tag = NormalizeTag(tag) + subtag := tag + for { + if spec := pluralSpecs[subtag]; spec != nil { + return spec + } + end := strings.LastIndex(subtag, "-") + if end == -1 { + return nil + } + subtag = subtag[:end] + } +} + +func newPluralSet(plurals ...Plural) map[Plural]struct{} { + set := make(map[Plural]struct{}, len(plurals)) + for _, plural := range plurals { + set[plural] = struct{}{} + } + return set +} + +func intInRange(i, from, to int64) bool { + return from <= i && i <= to +} + +func intEqualsAny(i int64, any ...int64) bool { + for _, a := range any { + if i == a { + return true + } + } + return false +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen.go new file mode 100644 index 000000000..c9b4f2667 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen.go @@ -0,0 +1,567 @@ +package language + +// This file is generated by i18n/language/codegen/generate.sh + +func init() { + + registerPluralSpec([]string{"bm", "bo", "dz", "id", "ig", "ii", "in", "ja", "jbo", "jv", "jw", "kde", "kea", "km", "ko", "lkt", "lo", "ms", "my", "nqo", "root", "sah", "ses", "sg", "th", "to", "vi", "wo", "yo", "zh"}, &PluralSpec{ + Plurals: newPluralSet(Other), + PluralFunc: func(ops *operands) Plural { + return Other + }, + }) + registerPluralSpec([]string{"am", "as", "bn", "fa", "gu", "hi", "kn", "mr", "zu"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // i = 0 or n = 1 + if intEqualsAny(ops.I, 0) || + ops.NequalsAny(1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"ff", "fr", "hy", "kab"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // i = 0,1 + if intEqualsAny(ops.I, 0, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"ast", "ca", "de", "en", "et", "fi", "fy", "gl", "it", "ji", "nl", "sv", "sw", "ur", "yi"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // i = 1 and v = 0 + if intEqualsAny(ops.I, 1) && intEqualsAny(ops.V, 0) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"si"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0,1 or i = 0 and f = 1 + if ops.NequalsAny(0, 1) || + intEqualsAny(ops.I, 0) && intEqualsAny(ops.F, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"ak", "bh", "guw", "ln", "mg", "nso", "pa", "ti", "wa"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0..1 + if ops.NinRange(0, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"tzm"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0..1 or n = 11..99 + if ops.NinRange(0, 1) || + ops.NinRange(11, 99) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"pt"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0..2 and n != 2 + if ops.NinRange(0, 2) && !ops.NequalsAny(2) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"af", "asa", "az", "bem", "bez", "bg", "brx", "ce", "cgg", "chr", "ckb", "dv", "ee", "el", "eo", "es", "eu", "fo", "fur", "gsw", "ha", "haw", "hu", "jgo", "jmc", "ka", "kaj", "kcg", "kk", "kkj", "kl", "ks", "ksb", "ku", "ky", "lb", "lg", "mas", "mgo", "ml", "mn", "nah", "nb", "nd", "ne", "nn", "nnh", "no", "nr", "ny", "nyn", "om", "or", "os", "pap", "ps", "rm", "rof", "rwk", "saq", "sdh", "seh", "sn", "so", "sq", "ss", "ssy", "st", "syr", "ta", "te", "teo", "tig", "tk", "tn", "tr", "ts", "ug", "uz", "ve", "vo", "vun", "wae", "xh", "xog"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 + if ops.NequalsAny(1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"pt_PT"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 and v = 0 + if ops.NequalsAny(1) && intEqualsAny(ops.V, 0) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"da"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 or t != 0 and i = 0,1 + if ops.NequalsAny(1) || + !intEqualsAny(ops.T, 0) && intEqualsAny(ops.I, 0, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"is"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // t = 0 and i % 10 = 1 and i % 100 != 11 or t != 0 + if intEqualsAny(ops.T, 0) && intEqualsAny(ops.I%10, 1) && !intEqualsAny(ops.I%100, 11) || + !intEqualsAny(ops.T, 0) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"mk"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 10 = 1 or f % 10 = 1 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 1) || + intEqualsAny(ops.F%10, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"fil", "tl"}, &PluralSpec{ + Plurals: newPluralSet(One, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i = 1,2,3 or v = 0 and i % 10 != 4,6,9 or v != 0 and f % 10 != 4,6,9 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I, 1, 2, 3) || + intEqualsAny(ops.V, 0) && !intEqualsAny(ops.I%10, 4, 6, 9) || + !intEqualsAny(ops.V, 0) && !intEqualsAny(ops.F%10, 4, 6, 9) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"lv", "prg"}, &PluralSpec{ + Plurals: newPluralSet(Zero, One, Other), + PluralFunc: func(ops *operands) Plural { + // n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 + if ops.NmodEqualsAny(10, 0) || + ops.NmodInRange(100, 11, 19) || + intEqualsAny(ops.V, 2) && intInRange(ops.F%100, 11, 19) { + return Zero + } + // n % 10 = 1 and n % 100 != 11 or v = 2 and f % 10 = 1 and f % 100 != 11 or v != 2 and f % 10 = 1 + if ops.NmodEqualsAny(10, 1) && !ops.NmodEqualsAny(100, 11) || + intEqualsAny(ops.V, 2) && intEqualsAny(ops.F%10, 1) && !intEqualsAny(ops.F%100, 11) || + !intEqualsAny(ops.V, 2) && intEqualsAny(ops.F%10, 1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"lag"}, &PluralSpec{ + Plurals: newPluralSet(Zero, One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0 + if ops.NequalsAny(0) { + return Zero + } + // i = 0,1 and n != 0 + if intEqualsAny(ops.I, 0, 1) && !ops.NequalsAny(0) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"ksh"}, &PluralSpec{ + Plurals: newPluralSet(Zero, One, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0 + if ops.NequalsAny(0) { + return Zero + } + // n = 1 + if ops.NequalsAny(1) { + return One + } + return Other + }, + }) + registerPluralSpec([]string{"iu", "kw", "naq", "se", "sma", "smi", "smj", "smn", "sms"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 + if ops.NequalsAny(1) { + return One + } + // n = 2 + if ops.NequalsAny(2) { + return Two + } + return Other + }, + }) + registerPluralSpec([]string{"shi"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Other), + PluralFunc: func(ops *operands) Plural { + // i = 0 or n = 1 + if intEqualsAny(ops.I, 0) || + ops.NequalsAny(1) { + return One + } + // n = 2..10 + if ops.NinRange(2, 10) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"mo", "ro"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Other), + PluralFunc: func(ops *operands) Plural { + // i = 1 and v = 0 + if intEqualsAny(ops.I, 1) && intEqualsAny(ops.V, 0) { + return One + } + // v != 0 or n = 0 or n != 1 and n % 100 = 1..19 + if !intEqualsAny(ops.V, 0) || + ops.NequalsAny(0) || + !ops.NequalsAny(1) && ops.NmodInRange(100, 1, 19) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"bs", "hr", "sh", "sr"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 1) && !intEqualsAny(ops.I%100, 11) || + intEqualsAny(ops.F%10, 1) && !intEqualsAny(ops.F%100, 11) { + return One + } + // v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 + if intEqualsAny(ops.V, 0) && intInRange(ops.I%10, 2, 4) && !intInRange(ops.I%100, 12, 14) || + intInRange(ops.F%10, 2, 4) && !intInRange(ops.F%100, 12, 14) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"gd"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1,11 + if ops.NequalsAny(1, 11) { + return One + } + // n = 2,12 + if ops.NequalsAny(2, 12) { + return Two + } + // n = 3..10,13..19 + if ops.NinRange(3, 10) || ops.NinRange(13, 19) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"sl"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 100 = 1 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%100, 1) { + return One + } + // v = 0 and i % 100 = 2 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%100, 2) { + return Two + } + // v = 0 and i % 100 = 3..4 or v != 0 + if intEqualsAny(ops.V, 0) && intInRange(ops.I%100, 3, 4) || + !intEqualsAny(ops.V, 0) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"dsb", "hsb"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 100 = 1 or f % 100 = 1 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%100, 1) || + intEqualsAny(ops.F%100, 1) { + return One + } + // v = 0 and i % 100 = 2 or f % 100 = 2 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%100, 2) || + intEqualsAny(ops.F%100, 2) { + return Two + } + // v = 0 and i % 100 = 3..4 or f % 100 = 3..4 + if intEqualsAny(ops.V, 0) && intInRange(ops.I%100, 3, 4) || + intInRange(ops.F%100, 3, 4) { + return Few + } + return Other + }, + }) + registerPluralSpec([]string{"he", "iw"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Many, Other), + PluralFunc: func(ops *operands) Plural { + // i = 1 and v = 0 + if intEqualsAny(ops.I, 1) && intEqualsAny(ops.V, 0) { + return One + } + // i = 2 and v = 0 + if intEqualsAny(ops.I, 2) && intEqualsAny(ops.V, 0) { + return Two + } + // v = 0 and n != 0..10 and n % 10 = 0 + if intEqualsAny(ops.V, 0) && !ops.NinRange(0, 10) && ops.NmodEqualsAny(10, 0) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"cs", "sk"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // i = 1 and v = 0 + if intEqualsAny(ops.I, 1) && intEqualsAny(ops.V, 0) { + return One + } + // i = 2..4 and v = 0 + if intInRange(ops.I, 2, 4) && intEqualsAny(ops.V, 0) { + return Few + } + // v != 0 + if !intEqualsAny(ops.V, 0) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"pl"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // i = 1 and v = 0 + if intEqualsAny(ops.I, 1) && intEqualsAny(ops.V, 0) { + return One + } + // v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + if intEqualsAny(ops.V, 0) && intInRange(ops.I%10, 2, 4) && !intInRange(ops.I%100, 12, 14) { + return Few + } + // v = 0 and i != 1 and i % 10 = 0..1 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 12..14 + if intEqualsAny(ops.V, 0) && !intEqualsAny(ops.I, 1) && intInRange(ops.I%10, 0, 1) || + intEqualsAny(ops.V, 0) && intInRange(ops.I%10, 5, 9) || + intEqualsAny(ops.V, 0) && intInRange(ops.I%100, 12, 14) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"be"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n % 10 = 1 and n % 100 != 11 + if ops.NmodEqualsAny(10, 1) && !ops.NmodEqualsAny(100, 11) { + return One + } + // n % 10 = 2..4 and n % 100 != 12..14 + if ops.NmodInRange(10, 2, 4) && !ops.NmodInRange(100, 12, 14) { + return Few + } + // n % 10 = 0 or n % 10 = 5..9 or n % 100 = 11..14 + if ops.NmodEqualsAny(10, 0) || + ops.NmodInRange(10, 5, 9) || + ops.NmodInRange(100, 11, 14) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"lt"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n % 10 = 1 and n % 100 != 11..19 + if ops.NmodEqualsAny(10, 1) && !ops.NmodInRange(100, 11, 19) { + return One + } + // n % 10 = 2..9 and n % 100 != 11..19 + if ops.NmodInRange(10, 2, 9) && !ops.NmodInRange(100, 11, 19) { + return Few + } + // f != 0 + if !intEqualsAny(ops.F, 0) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"mt"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 + if ops.NequalsAny(1) { + return One + } + // n = 0 or n % 100 = 2..10 + if ops.NequalsAny(0) || + ops.NmodInRange(100, 2, 10) { + return Few + } + // n % 100 = 11..19 + if ops.NmodInRange(100, 11, 19) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"ru", "uk"}, &PluralSpec{ + Plurals: newPluralSet(One, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 10 = 1 and i % 100 != 11 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 1) && !intEqualsAny(ops.I%100, 11) { + return One + } + // v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + if intEqualsAny(ops.V, 0) && intInRange(ops.I%10, 2, 4) && !intInRange(ops.I%100, 12, 14) { + return Few + } + // v = 0 and i % 10 = 0 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 11..14 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 0) || + intEqualsAny(ops.V, 0) && intInRange(ops.I%10, 5, 9) || + intEqualsAny(ops.V, 0) && intInRange(ops.I%100, 11, 14) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"br"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n % 10 = 1 and n % 100 != 11,71,91 + if ops.NmodEqualsAny(10, 1) && !ops.NmodEqualsAny(100, 11, 71, 91) { + return One + } + // n % 10 = 2 and n % 100 != 12,72,92 + if ops.NmodEqualsAny(10, 2) && !ops.NmodEqualsAny(100, 12, 72, 92) { + return Two + } + // n % 10 = 3..4,9 and n % 100 != 10..19,70..79,90..99 + if (ops.NmodInRange(10, 3, 4) || ops.NmodEqualsAny(10, 9)) && !(ops.NmodInRange(100, 10, 19) || ops.NmodInRange(100, 70, 79) || ops.NmodInRange(100, 90, 99)) { + return Few + } + // n != 0 and n % 1000000 = 0 + if !ops.NequalsAny(0) && ops.NmodEqualsAny(1000000, 0) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"ga"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n = 1 + if ops.NequalsAny(1) { + return One + } + // n = 2 + if ops.NequalsAny(2) { + return Two + } + // n = 3..6 + if ops.NinRange(3, 6) { + return Few + } + // n = 7..10 + if ops.NinRange(7, 10) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"gv"}, &PluralSpec{ + Plurals: newPluralSet(One, Two, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // v = 0 and i % 10 = 1 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 1) { + return One + } + // v = 0 and i % 10 = 2 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%10, 2) { + return Two + } + // v = 0 and i % 100 = 0,20,40,60,80 + if intEqualsAny(ops.V, 0) && intEqualsAny(ops.I%100, 0, 20, 40, 60, 80) { + return Few + } + // v != 0 + if !intEqualsAny(ops.V, 0) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"ar"}, &PluralSpec{ + Plurals: newPluralSet(Zero, One, Two, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0 + if ops.NequalsAny(0) { + return Zero + } + // n = 1 + if ops.NequalsAny(1) { + return One + } + // n = 2 + if ops.NequalsAny(2) { + return Two + } + // n % 100 = 3..10 + if ops.NmodInRange(100, 3, 10) { + return Few + } + // n % 100 = 11..99 + if ops.NmodInRange(100, 11, 99) { + return Many + } + return Other + }, + }) + registerPluralSpec([]string{"cy"}, &PluralSpec{ + Plurals: newPluralSet(Zero, One, Two, Few, Many, Other), + PluralFunc: func(ops *operands) Plural { + // n = 0 + if ops.NequalsAny(0) { + return Zero + } + // n = 1 + if ops.NequalsAny(1) { + return One + } + // n = 2 + if ops.NequalsAny(2) { + return Two + } + // n = 3 + if ops.NequalsAny(3) { + return Few + } + // n = 6 + if ops.NequalsAny(6) { + return Many + } + return Other + }, + }) +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen_test.go new file mode 100644 index 000000000..c8ec41fd4 --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_gen_test.go @@ -0,0 +1,645 @@ +package language + +// This file is generated by i18n/language/codegen/generate.sh + +import "testing" + +func TestBmBoDzIdIgIiInJaJboJvJwKdeKeaKmKoLktLoMsMyNqoRootSahSesSgThToViWoYoZh(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Other, []string{"0~15", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"bm", "bo", "dz", "id", "ig", "ii", "in", "ja", "jbo", "jv", "jw", "kde", "kea", "km", "ko", "lkt", "lo", "ms", "my", "nqo", "root", "sah", "ses", "sg", "th", "to", "vi", "wo", "yo", "zh"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestAmAsBnFaGuHiKnMrZu(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0~1.0", "0.00~0.04"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"1.1~2.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"am", "as", "bn", "fa", "gu", "hi", "kn", "mr", "zu"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestFfFrHyKab(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0~1.5"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"2.0~3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ff", "fr", "hy", "kab"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestAstCaDeEnEtFiFyGlItJiNlSvSwUrYi(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~16", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ast", "ca", "de", "en", "et", "fi", "fy", "gl", "it", "ji", "nl", "sv", "sw", "ur", "yi"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestSi(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0", "0.1", "1.0", "0.00", "0.01", "1.00", "0.000", "0.001", "1.000", "0.0000", "0.0001", "1.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.2~0.9", "1.1~1.8", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"si"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestAkBhGuwLnMgNsoPaTiWa(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0", "1.0", "0.00", "1.00", "0.000", "1.000", "0.0000", "1.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ak", "bh", "guw", "ln", "mg", "nso", "pa", "ti", "wa"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestTzm(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1", "11~24"}) + tests = appendDecimalTests(tests, One, []string{"0.0", "1.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "19.0", "20.0", "21.0", "22.0", "23.0", "24.0"}) + + tests = appendIntegerTests(tests, Other, []string{"2~10", "100~106", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"tzm"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestPt(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0", "1.0", "0.00", "1.00", "0.000", "1.000", "0.0000", "1.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"pt"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestAfAsaAzBemBezBgBrxCeCggChrCkbDvEeElEoEsEuFoFurGswHaHawHuJgoJmcKaKajKcgKkKkjKlKsKsbKuKyLbLgMasMgoMlMnNahNbNdNeNnNnhNoNrNyNynOmOrOsPapPsRmRofRwkSaqSdhSehSnSoSqSsSsyStSyrTaTeTeoTigTkTnTrTsUgUzVeVoVunWaeXhXog(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~16", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~0.9", "1.1~1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"af", "asa", "az", "bem", "bez", "bg", "brx", "ce", "cgg", "chr", "ckb", "dv", "ee", "el", "eo", "es", "eu", "fo", "fur", "gsw", "ha", "haw", "hu", "jgo", "jmc", "ka", "kaj", "kcg", "kk", "kkj", "kl", "ks", "ksb", "ku", "ky", "lb", "lg", "mas", "mgo", "ml", "mn", "nah", "nb", "nd", "ne", "nn", "nnh", "no", "nr", "ny", "nyn", "om", "or", "os", "pap", "ps", "rm", "rof", "rwk", "saq", "sdh", "seh", "sn", "so", "sq", "ss", "ssy", "st", "syr", "ta", "te", "teo", "tig", "tk", "tn", "tr", "ts", "ug", "uz", "ve", "vo", "vun", "wae", "xh", "xog"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestPt_PT(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~16", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"pt_PT"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestDa(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"0.1~1.6"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~16", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "2.0~3.4", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"da"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestIs(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"0.1~1.6", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~16", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"is"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestMk(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "11", "21", "31", "41", "51", "61", "71", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "2~10", "12~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "0.2~1.0", "1.2~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"mk"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestFilTl(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0~3", "5", "7", "8", "10~13", "15", "17", "18", "20", "21", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, One, []string{"0.0~0.3", "0.5", "0.7", "0.8", "1.0~1.3", "1.5", "1.7", "1.8", "2.0", "2.1", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, Other, []string{"4", "6", "9", "14", "16", "19", "24", "26", "104", "1004"}) + tests = appendDecimalTests(tests, Other, []string{"0.4", "0.6", "0.9", "1.4", "1.6", "1.9", "2.4", "2.6", "10.4", "100.4", "1000.4"}) + + locales := []string{"fil", "tl"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestLvPrg(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Zero, []string{"0", "10~20", "30", "40", "50", "60", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Zero, []string{"0.0", "10.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"0.1", "1.0", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Other, []string{"2~9", "22~29", "102", "1002"}) + tests = appendDecimalTests(tests, Other, []string{"0.2~0.9", "1.2~1.9", "10.2", "100.2", "1000.2"}) + + locales := []string{"lv", "prg"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestLag(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Zero, []string{"0"}) + tests = appendDecimalTests(tests, Zero, []string{"0.0", "0.00", "0.000", "0.0000"}) + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"0.1~1.6"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"2.0~3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"lag"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestKsh(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Zero, []string{"0"}) + tests = appendDecimalTests(tests, Zero, []string{"0.0", "0.00", "0.000", "0.0000"}) + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"2~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ksh"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestIuKwNaqSeSmaSmiSmjSmnSms(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Two, []string{"2"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "2.00", "2.000", "2.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "3~17", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~0.9", "1.1~1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"iu", "kw", "naq", "se", "sma", "smi", "smj", "smn", "sms"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestShi(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"0", "1"}) + tests = appendDecimalTests(tests, One, []string{"0.0~1.0", "0.00~0.04"}) + + tests = appendIntegerTests(tests, Few, []string{"2~10"}) + tests = appendDecimalTests(tests, Few, []string{"2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "2.00", "3.00", "4.00", "5.00", "6.00", "7.00", "8.00"}) + + tests = appendIntegerTests(tests, Other, []string{"11~26", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"1.1~1.9", "2.1~2.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"shi"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestMoRo(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Few, []string{"0", "2~16", "101", "1001"}) + tests = appendDecimalTests(tests, Few, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, Other, []string{"20~35", "100", "1000", "10000", "100000", "1000000"}) + + locales := []string{"mo", "ro"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestBsHrShSr(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Few, []string{"2~4", "22~24", "32~34", "42~44", "52~54", "62", "102", "1002"}) + tests = appendDecimalTests(tests, Few, []string{"0.2~0.4", "1.2~1.4", "2.2~2.4", "3.2~3.4", "4.2~4.4", "5.2", "10.2", "100.2", "1000.2"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "0.5~1.0", "1.5~2.0", "2.5~2.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"bs", "hr", "sh", "sr"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestGd(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "11"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "11.0", "1.00", "11.00", "1.000", "11.000", "1.0000"}) + + tests = appendIntegerTests(tests, Two, []string{"2", "12"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "12.0", "2.00", "12.00", "2.000", "12.000", "2.0000"}) + + tests = appendIntegerTests(tests, Few, []string{"3~10", "13~19"}) + tests = appendDecimalTests(tests, Few, []string{"3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "19.0", "3.00"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "20~34", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~0.9", "1.1~1.6", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"gd"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestSl(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "101", "201", "301", "401", "501", "601", "701", "1001"}) + + tests = appendIntegerTests(tests, Two, []string{"2", "102", "202", "302", "402", "502", "602", "702", "1002"}) + + tests = appendIntegerTests(tests, Few, []string{"3", "4", "103", "104", "203", "204", "303", "304", "403", "404", "503", "504", "603", "604", "703", "704", "1003"}) + tests = appendDecimalTests(tests, Few, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + + locales := []string{"sl"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestDsbHsb(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "101", "201", "301", "401", "501", "601", "701", "1001"}) + tests = appendDecimalTests(tests, One, []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Two, []string{"2", "102", "202", "302", "402", "502", "602", "702", "1002"}) + tests = appendDecimalTests(tests, Two, []string{"0.2", "1.2", "2.2", "3.2", "4.2", "5.2", "6.2", "7.2", "10.2", "100.2", "1000.2"}) + + tests = appendIntegerTests(tests, Few, []string{"3", "4", "103", "104", "203", "204", "303", "304", "403", "404", "503", "504", "603", "604", "703", "704", "1003"}) + tests = appendDecimalTests(tests, Few, []string{"0.3", "0.4", "1.3", "1.4", "2.3", "2.4", "3.3", "3.4", "4.3", "4.4", "5.3", "5.4", "6.3", "6.4", "7.3", "7.4", "10.3", "100.3", "1000.3"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "0.5~1.0", "1.5~2.0", "2.5~2.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"dsb", "hsb"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestHeIw(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Two, []string{"2"}) + + tests = appendIntegerTests(tests, Many, []string{"20", "30", "40", "50", "60", "70", "80", "90", "100", "1000", "10000", "100000", "1000000"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "3~17", "101", "1001"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"he", "iw"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestCsSk(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Few, []string{"2~4"}) + + tests = appendDecimalTests(tests, Many, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + + locales := []string{"cs", "sk"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestPl(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + + tests = appendIntegerTests(tests, Few, []string{"2~4", "22~24", "32~34", "42~44", "52~54", "62", "102", "1002"}) + + tests = appendIntegerTests(tests, Many, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"pl"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestBe(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "71.0", "81.0", "101.0", "1001.0"}) + + tests = appendIntegerTests(tests, Few, []string{"2~4", "22~24", "32~34", "42~44", "52~54", "62", "102", "1002"}) + tests = appendDecimalTests(tests, Few, []string{"2.0", "3.0", "4.0", "22.0", "23.0", "24.0", "32.0", "33.0", "102.0", "1002.0"}) + + tests = appendIntegerTests(tests, Many, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Many, []string{"0.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "11.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.1", "100.1", "1000.1"}) + + locales := []string{"be"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestLt(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "71.0", "81.0", "101.0", "1001.0"}) + + tests = appendIntegerTests(tests, Few, []string{"2~9", "22~29", "102", "1002"}) + tests = appendDecimalTests(tests, Few, []string{"2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "22.0", "102.0", "1002.0"}) + + tests = appendDecimalTests(tests, Many, []string{"0.1~0.9", "1.1~1.7", "10.1", "100.1", "1000.1"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "10~20", "30", "40", "50", "60", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0", "10.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"lt"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestMt(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Few, []string{"0", "2~10", "102~107", "1002"}) + tests = appendDecimalTests(tests, Few, []string{"0.0", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "10.0", "102.0", "1002.0"}) + + tests = appendIntegerTests(tests, Many, []string{"11~19", "111~117", "1011"}) + tests = appendDecimalTests(tests, Many, []string{"11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "111.0", "1011.0"}) + + tests = appendIntegerTests(tests, Other, []string{"20~35", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"mt"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestRuUk(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"}) + + tests = appendIntegerTests(tests, Few, []string{"2~4", "22~24", "32~34", "42~44", "52~54", "62", "102", "1002"}) + + tests = appendIntegerTests(tests, Many, []string{"0", "5~19", "100", "1000", "10000", "100000", "1000000"}) + + tests = appendDecimalTests(tests, Other, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ru", "uk"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestBr(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "21", "31", "41", "51", "61", "81", "101", "1001"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "81.0", "101.0", "1001.0"}) + + tests = appendIntegerTests(tests, Two, []string{"2", "22", "32", "42", "52", "62", "82", "102", "1002"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "22.0", "32.0", "42.0", "52.0", "62.0", "82.0", "102.0", "1002.0"}) + + tests = appendIntegerTests(tests, Few, []string{"3", "4", "9", "23", "24", "29", "33", "34", "39", "43", "44", "49", "103", "1003"}) + tests = appendDecimalTests(tests, Few, []string{"3.0", "4.0", "9.0", "23.0", "24.0", "29.0", "33.0", "34.0", "103.0", "1003.0"}) + + tests = appendIntegerTests(tests, Many, []string{"1000000"}) + tests = appendDecimalTests(tests, Many, []string{"1000000.0", "1000000.00", "1000000.000"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "5~8", "10~20", "100", "1000", "10000", "100000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~0.9", "1.1~1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0"}) + + locales := []string{"br"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestGa(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Two, []string{"2"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "2.00", "2.000", "2.0000"}) + + tests = appendIntegerTests(tests, Few, []string{"3~6"}) + tests = appendDecimalTests(tests, Few, []string{"3.0", "4.0", "5.0", "6.0", "3.00", "4.00", "5.00", "6.00", "3.000", "4.000", "5.000", "6.000", "3.0000", "4.0000", "5.0000", "6.0000"}) + + tests = appendIntegerTests(tests, Many, []string{"7~10"}) + tests = appendDecimalTests(tests, Many, []string{"7.0", "8.0", "9.0", "10.0", "7.00", "8.00", "9.00", "10.00", "7.000", "8.000", "9.000", "10.000", "7.0000", "8.0000", "9.0000", "10.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"0", "11~25", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.0~0.9", "1.1~1.6", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ga"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestGv(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, One, []string{"1", "11", "21", "31", "41", "51", "61", "71", "101", "1001"}) + + tests = appendIntegerTests(tests, Two, []string{"2", "12", "22", "32", "42", "52", "62", "72", "102", "1002"}) + + tests = appendIntegerTests(tests, Few, []string{"0", "20", "40", "60", "80", "100", "120", "140", "1000", "10000", "100000", "1000000"}) + + tests = appendDecimalTests(tests, Many, []string{"0.0~1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + tests = appendIntegerTests(tests, Other, []string{"3~10", "13~19", "23", "103", "1003"}) + + locales := []string{"gv"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestAr(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Zero, []string{"0"}) + tests = appendDecimalTests(tests, Zero, []string{"0.0", "0.00", "0.000", "0.0000"}) + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Two, []string{"2"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "2.00", "2.000", "2.0000"}) + + tests = appendIntegerTests(tests, Few, []string{"3~10", "103~110", "1003"}) + tests = appendDecimalTests(tests, Few, []string{"3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "103.0", "1003.0"}) + + tests = appendIntegerTests(tests, Many, []string{"11~26", "111", "1011"}) + tests = appendDecimalTests(tests, Many, []string{"11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "111.0", "1011.0"}) + + tests = appendIntegerTests(tests, Other, []string{"100~102", "200~202", "300~302", "400~402", "500~502", "600", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"ar"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} + +func TestCy(t *testing.T) { + var tests []pluralTest + + tests = appendIntegerTests(tests, Zero, []string{"0"}) + tests = appendDecimalTests(tests, Zero, []string{"0.0", "0.00", "0.000", "0.0000"}) + + tests = appendIntegerTests(tests, One, []string{"1"}) + tests = appendDecimalTests(tests, One, []string{"1.0", "1.00", "1.000", "1.0000"}) + + tests = appendIntegerTests(tests, Two, []string{"2"}) + tests = appendDecimalTests(tests, Two, []string{"2.0", "2.00", "2.000", "2.0000"}) + + tests = appendIntegerTests(tests, Few, []string{"3"}) + tests = appendDecimalTests(tests, Few, []string{"3.0", "3.00", "3.000", "3.0000"}) + + tests = appendIntegerTests(tests, Many, []string{"6"}) + tests = appendDecimalTests(tests, Many, []string{"6.0", "6.00", "6.000", "6.0000"}) + + tests = appendIntegerTests(tests, Other, []string{"4", "5", "7~20", "100", "1000", "10000", "100000", "1000000"}) + tests = appendDecimalTests(tests, Other, []string{"0.1~0.9", "1.1~1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"}) + + locales := []string{"cy"} + for _, locale := range locales { + runTests(t, locale, tests) + } +} diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go new file mode 100644 index 000000000..34931b7bb --- /dev/null +++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go @@ -0,0 +1,733 @@ +package language + +import ( + "fmt" + "strconv" + "strings" + "testing" +) + +const onePlusEpsilon = "1.00000000000000000000000000000001" + +func TestGetPluralSpec(t *testing.T) { + tests := []struct { + src string + spec *PluralSpec + }{ + {"pl", pluralSpecs["pl"]}, + {"en", pluralSpecs["en"]}, + {"en-US", pluralSpecs["en"]}, + {"en_US", pluralSpecs["en"]}, + {"en-GB", pluralSpecs["en"]}, + {"zh-CN", pluralSpecs["zh"]}, + {"zh-TW", pluralSpecs["zh"]}, + {"pt-BR", pluralSpecs["pt"]}, + {"pt_BR", pluralSpecs["pt"]}, + {"pt-PT", pluralSpecs["pt-pt"]}, + {"pt_PT", pluralSpecs["pt-pt"]}, + {"zh-Hans-CN", pluralSpecs["zh"]}, + {"zh-Hant-TW", pluralSpecs["zh"]}, + {"zh-CN", pluralSpecs["zh"]}, + {"zh-TW", pluralSpecs["zh"]}, + {"zh-Hans", pluralSpecs["zh"]}, + {"zh-Hant", pluralSpecs["zh"]}, + {"ko-KR", pluralSpecs["ko"]}, + {"ko_KR", pluralSpecs["ko"]}, + {"ko-KP", pluralSpecs["ko"]}, + {"ko_KP", pluralSpecs["ko"]}, + {"en-US-en-US", pluralSpecs["en"]}, + {"th", pluralSpecs["th"]}, + {"th-TH", pluralSpecs["th"]}, + {"hr", pluralSpecs["hr"]}, + {"bs", pluralSpecs["bs"]}, + {"sr", pluralSpecs["sr"]}, + {"ti", pluralSpecs["ti"]}, + {"vi", pluralSpecs["vi"]}, + {"vi-VN", pluralSpecs["vi"]}, + {"mk", pluralSpecs["mk"]}, + {"mk-MK", pluralSpecs["mk"]}, + {"lv", pluralSpecs["lv"]}, + {"lv-LV", pluralSpecs["lv"]}, + {".en-US..en-US.", nil}, + {"zh, en-gb;q=0.8, en;q=0.7", nil}, + {"zh,en-gb;q=0.8,en;q=0.7", nil}, + {"xx, en-gb;q=0.8, en;q=0.7", nil}, + {"xx,en-gb;q=0.8,en;q=0.7", nil}, + {"xx-YY,xx;q=0.8,en-US,en;q=0.8,de;q=0.6,nl;q=0.4", nil}, + {"/foo/es/en.json", nil}, + {"xx-Yyen-US", nil}, + {"en US", nil}, + {"", nil}, + {"-", nil}, + {"_", nil}, + {".", nil}, + {"-en", nil}, + {"_en", nil}, + {"-en-", nil}, + {"_en_", nil}, + {"xx", nil}, + } + for _, test := range tests { + spec := getPluralSpec(test.src) + if spec != test.spec { + t.Errorf("getPluralSpec(%q) = %q expected %q", test.src, spec, test.spec) + } + } +} + +type pluralTest struct { + num interface{} + plural Plural +} + +func appendIntegerTests(tests []pluralTest, plural Plural, examples []string) []pluralTest { + for _, ex := range expandExamples(examples) { + i, err := strconv.ParseInt(ex, 10, 64) + if err != nil { + panic(err) + } + tests = append(tests, pluralTest{ex, plural}, pluralTest{i, plural}) + } + return tests +} + +func appendDecimalTests(tests []pluralTest, plural Plural, examples []string) []pluralTest { + for _, ex := range expandExamples(examples) { + tests = append(tests, pluralTest{ex, plural}) + } + return tests +} + +func expandExamples(examples []string) []string { + var expanded []string + for _, ex := range examples { + if parts := strings.Split(ex, "~"); len(parts) == 2 { + for ex := parts[0]; ; ex = increment(ex) { + expanded = append(expanded, ex) + if ex == parts[1] { + break + } + } + } else { + expanded = append(expanded, ex) + } + } + return expanded +} + +func increment(dec string) string { + runes := []rune(dec) + carry := true + for i := len(runes) - 1; carry && i >= 0; i-- { + switch runes[i] { + case '.': + continue + case '9': + runes[i] = '0' + default: + runes[i]++ + carry = false + } + } + if carry { + runes = append([]rune{'1'}, runes...) + } + return string(runes) +} + +// +// Below here are tests that were manually written before tests were automatically generated. +// These are kept around as sanity checks for our code generation. +// + +func TestArabic(t *testing.T) { + tests := []pluralTest{ + {0, Zero}, + {"0", Zero}, + {"0.0", Zero}, + {"0.00", Zero}, + {1, One}, + {"1", One}, + {"1.0", One}, + {"1.00", One}, + {onePlusEpsilon, Other}, + {2, Two}, + {"2", Two}, + {"2.0", Two}, + {"2.00", Two}, + {3, Few}, + {"3", Few}, + {"3.0", Few}, + {"3.00", Few}, + {10, Few}, + {"10", Few}, + {"10.0", Few}, + {"10.00", Few}, + {103, Few}, + {"103", Few}, + {"103.0", Few}, + {"103.00", Few}, + {110, Few}, + {"110", Few}, + {"110.0", Few}, + {"110.00", Few}, + {11, Many}, + {"11", Many}, + {"11.0", Many}, + {"11.00", Many}, + {99, Many}, + {"99", Many}, + {"99.0", Many}, + {"99.00", Many}, + {111, Many}, + {"111", Many}, + {"111.0", Many}, + {"111.00", Many}, + {199, Many}, + {"199", Many}, + {"199.0", Many}, + {"199.00", Many}, + {100, Other}, + {"100", Other}, + {"100.0", Other}, + {"100.00", Other}, + {102, Other}, + {"102", Other}, + {"102.0", Other}, + {"102.00", Other}, + {200, Other}, + {"200", Other}, + {"200.0", Other}, + {"200.00", Other}, + {202, Other}, + {"202", Other}, + {"202.0", Other}, + {"202.00", Other}, + } + tests = appendFloatTests(tests, 0.1, 0.9, Other) + tests = appendFloatTests(tests, 1.1, 1.9, Other) + tests = appendFloatTests(tests, 2.1, 2.9, Other) + tests = appendFloatTests(tests, 3.1, 3.9, Other) + tests = appendFloatTests(tests, 4.1, 4.9, Other) + runTests(t, "ar", tests) +} + +func TestBelarusian(t *testing.T) { + tests := []pluralTest{ + {0, Many}, + {1, One}, + {2, Few}, + {3, Few}, + {4, Few}, + {5, Many}, + {19, Many}, + {20, Many}, + {21, One}, + {11, Many}, + {52, Few}, + {101, One}, + {"0.1", Other}, + {"0.7", Other}, + {"1.5", Other}, + {"1.0", One}, + {onePlusEpsilon, Other}, + {"2.0", Few}, + {"10.0", Many}, + } + runTests(t, "be", tests) +} + +func TestBurmese(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "my", tests) +} + +func TestCatalan(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {"0", Other}, + {1, One}, + {"1", One}, + {"1.0", Other}, + {onePlusEpsilon, Other}, + {2, Other}, + {"2", Other}, + } + tests = appendIntTests(tests, 2, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "ca", tests) +} + +func TestChinese(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "zh", tests) +} + +func TestCzech(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {"0", Other}, + {1, One}, + {"1", One}, + {onePlusEpsilon, Many}, + {2, Few}, + {"2", Few}, + {3, Few}, + {"3", Few}, + {4, Few}, + {"4", Few}, + {5, Other}, + {"5", Other}, + } + tests = appendFloatTests(tests, 0, 10, Many) + runTests(t, "cs", tests) +} + +func TestDanish(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, One}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.1, 1.9, One) + tests = appendFloatTests(tests, 2.0, 10.0, Other) + runTests(t, "da", tests) +} + +func TestDutch(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 10.0, Other) + runTests(t, "nl", tests) +} + +func TestEnglish(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 10.0, Other) + runTests(t, "en", tests) +} + +func TestFrench(t *testing.T) { + tests := []pluralTest{ + {0, One}, + {1, One}, + {onePlusEpsilon, One}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 1.9, One) + tests = appendFloatTests(tests, 2.0, 10.0, Other) + runTests(t, "fr", tests) +} + +func TestGerman(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 10.0, Other) + runTests(t, "de", tests) +} + +func TestIcelandic(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {2, Other}, + {11, Other}, + {21, One}, + {111, Other}, + {"0.0", Other}, + {"0.1", One}, + {"2.0", Other}, + } + runTests(t, "is", tests) +} + +func TestIndonesian(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "id", tests) +} + +func TestItalian(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 10.0, Other) + runTests(t, "it", tests) +} + +func TestKorean(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "ko", tests) +} + +func TestLatvian(t *testing.T) { + tests := []pluralTest{ + {0, Zero}, + {"0", Zero}, + {"0.1", One}, + {1, One}, + {"1", One}, + {onePlusEpsilon, One}, + {"10.0", Zero}, + {"10.1", One}, + {"10.2", Other}, + {21, One}, + } + tests = appendFloatTests(tests, 0.2, 0.9, Other) + tests = appendFloatTests(tests, 1.2, 1.9, Other) + tests = appendIntTests(tests, 2, 9, Other) + tests = appendIntTests(tests, 10, 20, Zero) + tests = appendIntTests(tests, 22, 29, Other) + runTests(t, "lv", tests) +} + +func TestJapanese(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "ja", tests) +} + +func TestLithuanian(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {2, Few}, + {3, Few}, + {9, Few}, + {10, Other}, + {11, Other}, + {"0.1", Many}, + {"0.7", Many}, + {"1.0", One}, + {onePlusEpsilon, Many}, + {"2.0", Few}, + {"10.0", Other}, + } + runTests(t, "lt", tests) +} + +func TestMalay(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "ms", tests) +} + +func TestPolish(t *testing.T) { + tests := []pluralTest{ + {0, Many}, + {1, One}, + {2, Few}, + {3, Few}, + {4, Few}, + {5, Many}, + {19, Many}, + {20, Many}, + {10, Many}, + {11, Many}, + {52, Few}, + {"0.1", Other}, + {"0.7", Other}, + {"1.5", Other}, + {"1.0", Other}, + {onePlusEpsilon, Other}, + {"2.0", Other}, + {"10.0", Other}, + } + runTests(t, "pl", tests) +} + +func TestPortuguese(t *testing.T) { + tests := []pluralTest{ + {0, One}, + {"0.0", One}, + {1, One}, + {"1.0", One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.1, 0.9, Other) + tests = appendFloatTests(tests, 1.1, 10.0, Other) + runTests(t, "pt", tests) +} + +func TestMacedonian(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {"1.1", One}, + {"2.1", One}, + {onePlusEpsilon, One}, + {2, Other}, + {"2.2", Other}, + {11, One}, + } + runTests(t, "mk", tests) +} + +func TestPortugueseEuropean(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {"0.0", Other}, + {"0.1", Other}, + {"0.01", Other}, + {1, One}, + {"1", One}, + {"1.1", Other}, + {"1.01", Other}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 2.0, 10.0, Other) + runTests(t, "pt-pt", tests) +} + +func TestRussian(t *testing.T) { + tests := []pluralTest{ + {0, Many}, + {1, One}, + {2, Few}, + {3, Few}, + {4, Few}, + {5, Many}, + {19, Many}, + {20, Many}, + {21, One}, + {11, Many}, + {52, Few}, + {101, One}, + {"0.1", Other}, + {"0.7", Other}, + {"1.5", Other}, + {"1.0", Other}, + {onePlusEpsilon, Other}, + {"2.0", Other}, + {"10.0", Other}, + } + runTests(t, "ru", tests) +} + +func TestSpanish(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {"1", One}, + {"1.0", One}, + {"1.00", One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 0.9, Other) + tests = appendFloatTests(tests, 1.1, 10.0, Other) + runTests(t, "es", tests) +} + +func TestNorweigan(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {"1", One}, + {"1.0", One}, + {"1.00", One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 0.9, Other) + tests = appendFloatTests(tests, 1.1, 10.0, Other) + runTests(t, "no", tests) +} + +func TestBulgarian(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {2, Other}, + {3, Other}, + {9, Other}, + {10, Other}, + {11, Other}, + {"0.1", Other}, + {"0.7", Other}, + {"1.0", One}, + {"1.001", Other}, + {onePlusEpsilon, Other}, + {"1.1", Other}, + {"2.0", Other}, + {"10.0", Other}, + } + runTests(t, "bg", tests) +} + +func TestSwedish(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {onePlusEpsilon, Other}, + {2, Other}, + } + tests = appendFloatTests(tests, 0.0, 10.0, Other) + runTests(t, "sv", tests) +} + +func TestThai(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "th", tests) +} + +func TestVietnamese(t *testing.T) { + tests := appendIntTests(nil, 0, 10, Other) + tests = appendFloatTests(tests, 0, 10, Other) + runTests(t, "vi", tests) +} + +func TestTurkish(t *testing.T) { + tests := []pluralTest{ + {0, Other}, + {1, One}, + {"1", One}, + {"1.0", One}, + {"1.00", One}, + {"1.001", Other}, + {"1.100", Other}, + {"1.101", Other}, + {onePlusEpsilon, Other}, + {2, Other}, + {"0.7", Other}, + {"2.0", Other}, + } + runTests(t, "tr", tests) +} + +func TestUkrainian(t *testing.T) { + tests := []pluralTest{ + {0, Many}, + {1, One}, + {2, Few}, + {3, Few}, + {4, Few}, + {5, Many}, + {19, Many}, + {20, Many}, + {21, One}, + {11, Many}, + {52, Few}, + {101, One}, + {"0.1", Other}, + {"0.7", Other}, + {"1.5", Other}, + {"1.0", Other}, + {onePlusEpsilon, Other}, + {"2.0", Other}, + {"10.0", Other}, + } + runTests(t, "uk", tests) +} + +func TestCroatian(t *testing.T) { + tests := makeCroatianBosnianSerbianTests() + runTests(t, "hr", tests) +} + +func TestBosnian(t *testing.T) { + tests := makeCroatianBosnianSerbianTests() + runTests(t, "bs", tests) +} + +func TestSerbian(t *testing.T) { + tests := makeCroatianBosnianSerbianTests() + runTests(t, "sr", tests) +} + +func makeCroatianBosnianSerbianTests() []pluralTest { + return []pluralTest{ + {1, One}, + {"0.1", One}, + {21, One}, + {101, One}, + {1001, One}, + {51, One}, + {"1.1", One}, + {"5.1", One}, + {"100.1", One}, + {"1000.1", One}, + {2, Few}, + {"0.2", Few}, + {22, Few}, + {"1.2", Few}, + {24, Few}, + {"2.4", Few}, + {102, Few}, + {"100.2", Few}, + {1002, Few}, + {"1000.2", Few}, + {5, Other}, + {"0.5", Other}, + {0, Other}, + {100, Other}, + {19, Other}, + {"0.0", Other}, + {"100.0", Other}, + {"1000.0", Other}, + } +} + +func TestTigrinya(t *testing.T) { + tests := []pluralTest{ + {0, One}, + {1, One}, + } + tests = appendIntTests(tests, 2, 10, Other) + tests = appendFloatTests(tests, 1.1, 10.0, Other) + runTests(t, "ti", tests) +} + +func appendIntTests(tests []pluralTest, from, to int, p Plural) []pluralTest { + for i := from; i <= to; i++ { + tests = append(tests, pluralTest{i, p}) + } + return tests +} + +func appendFloatTests(tests []pluralTest, from, to float64, p Plural) []pluralTest { + stride := 0.1 + format := "%.1f" + for f := from; f < to; f += stride { + tests = append(tests, pluralTest{fmt.Sprintf(format, f), p}) + } + tests = append(tests, pluralTest{fmt.Sprintf(format, to), p}) + return tests +} + +func runTests(t *testing.T, pluralSpecID string, tests []pluralTest) { + pluralSpecID = normalizePluralSpecID(pluralSpecID) + if spec := pluralSpecs[pluralSpecID]; spec != nil { + for _, test := range tests { + if plural, err := spec.Plural(test.num); plural != test.plural { + t.Errorf("%s: PluralCategory(%#v) returned %s, %v; expected %s", pluralSpecID, test.num, plural, err, test.plural) + } + } + } else { + t.Errorf("could not find plural spec for locale %s", pluralSpecID) + } + +} |