ires 0.1.3 → 0.1.4

data/ext/vendor/golang.org/x/text/feature/plural/plural.go

@@ -0,0 +1,258 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run gen.go gen_common.go
+
+// Package plural provides utilities for handling linguistic plurals in text.
+//
+// The definitions in this package are based on the plural rule handling defined
+// in CLDR. See
+// http://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules for
+// details.
+package plural
+
+import (
+	"golang.org/x/text/internal/number"
+	"golang.org/x/text/language"
+)
+
+// Rules defines the plural rules for all languages for a certain plural type.
+//
+//
+// This package is UNDER CONSTRUCTION and its API may change.
+type Rules struct {
+	rules          []pluralCheck
+	index          []byte
+	langToIndex    []byte
+	inclusionMasks []uint64
+}
+
+var (
+	// Cardinal defines the plural rules for numbers indicating quantities.
+	Cardinal *Rules = cardinal
+
+	// Ordinal defines the plural rules for numbers indicating position
+	// (first, second, etc.).
+	Ordinal *Rules = ordinal
+
+	ordinal = &Rules{
+		ordinalRules,
+		ordinalIndex,
+		ordinalLangToIndex,
+		ordinalInclusionMasks[:],
+	}
+
+	cardinal = &Rules{
+		cardinalRules,
+		cardinalIndex,
+		cardinalLangToIndex,
+		cardinalInclusionMasks[:],
+	}
+)
+
+// getIntApprox converts the digits in slice digits[start:end] to an integer
+// according to the following rules:
+//	- Let i be asInt(digits[start:end]), where out-of-range digits are assumed
+//	  to be zero.
+//	- Result n is big if i / 10^nMod > 1.
+//	- Otherwise the result is i % 10^nMod.
+//
+// For example, if digits is {1, 2, 3} and start:end is 0:5, then the result
+// for various values of nMod is:
+//	- when nMod == 2, n == big
+//	- when nMod == 3, n == big
+//	- when nMod == 4, n == big
+//	- when nMod == 5, n == 12300
+//	- when nMod == 6, n == 12300
+//	- when nMod == 7, n == 12300
+func getIntApprox(digits []byte, start, end, nMod, big int) (n int) {
+	// Leading 0 digits just result in 0.
+	p := start
+	if p < 0 {
+		p = 0
+	}
+	// Range only over the part for which we have digits.
+	mid := end
+	if mid >= len(digits) {
+		mid = len(digits)
+	}
+	// Check digits more significant that nMod.
+	if q := end - nMod; q > 0 {
+		if q > mid {
+			q = mid
+		}
+		for ; p < q; p++ {
+			if digits[p] != 0 {
+				return big
+			}
+		}
+	}
+	for ; p < mid; p++ {
+		n = 10*n + int(digits[p])
+	}
+	// Multiply for trailing zeros.
+	for ; p < end; p++ {
+		n *= 10
+	}
+	return n
+}
+
+// MatchDigits computes the plural form for the given language and the given
+// decimal floating point digits. The digits are stored in big-endian order and
+// are of value byte(0) - byte(9). The floating point position is indicated by
+// exp and the number of visible decimals is scale. All leading and trailing
+// zeros may be omitted from digits.
+//
+// The following table contains examples of possible arguments to represent
+// the given numbers.
+//      decimal    digits              exp    scale
+//      123        []byte{1, 2, 3}     3      0
+//      123.4      []byte{1, 2, 3, 4}  3      1
+//      123.40     []byte{1, 2, 3, 4}  3      2
+//      100000     []byte{1}           6      0
+//      100000.00  []byte{1}           6      3
+func (p *Rules) MatchDigits(t language.Tag, digits []byte, exp, scale int) Form {
+	index, _ := language.CompactIndex(t)
+
+	// Differentiate up to including mod 1000000 for the integer part.
+	n := getIntApprox(digits, 0, exp, 6, 1000000)
+
+	// Differentiate up to including mod 100 for the fractional part.
+	f := getIntApprox(digits, exp, exp+scale, 2, 100)
+
+	return matchPlural(p, index, n, f, scale)
+}
+
+func (p *Rules) matchDisplayDigits(t language.Tag, d *number.Digits) (Form, int) {
+	n := getIntApprox(d.Digits, 0, int(d.Exp), 6, 1000000)
+	return p.MatchDigits(t, d.Digits, int(d.Exp), d.NumFracDigits()), n
+}
+
+func validForms(p *Rules, t language.Tag) (forms []Form) {
+	index, _ := language.CompactIndex(t)
+	offset := p.langToIndex[index]
+	rules := p.rules[p.index[offset]:p.index[offset+1]]
+
+	forms = append(forms, Other)
+	last := Other
+	for _, r := range rules {
+		if cat := Form(r.cat & formMask); cat != andNext && last != cat {
+			forms = append(forms, cat)
+			last = cat
+		}
+	}
+	return forms
+}
+
+func (p *Rules) matchComponents(t language.Tag, n, f, scale int) Form {
+	index, _ := language.CompactIndex(t)
+	return matchPlural(p, index, n, f, scale)
+}
+
+// MatchPlural returns the plural form for the given language and plural
+// operands (as defined in
+// http://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules):
+//  where
+//  	n  absolute value of the source number (integer and decimals)
+//  input
+//  	i  integer digits of n.
+//  	v  number of visible fraction digits in n, with trailing zeros.
+//  	w  number of visible fraction digits in n, without trailing zeros.
+//  	f  visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
+//  	t  visible fractional digits in n, without trailing zeros.
+//
+// If any of the operand values is too large to fit in an int, it is okay to
+// pass the value modulo 10,000,000.
+func (p *Rules) MatchPlural(lang language.Tag, i, v, w, f, t int) Form {
+	index, _ := language.CompactIndex(lang)
+	return matchPlural(p, index, i, f, v)
+}
+
+func matchPlural(p *Rules, index int, n, f, v int) Form {
+	nMask := p.inclusionMasks[n%maxMod]
+	// Compute the fMask inline in the rules below, as it is relatively rare.
+	// fMask := p.inclusionMasks[f%maxMod]
+	vMask := p.inclusionMasks[v%maxMod]
+
+	// Do the matching
+	offset := p.langToIndex[index]
+	rules := p.rules[p.index[offset]:p.index[offset+1]]
+	for i := 0; i < len(rules); i++ {
+		rule := rules[i]
+		setBit := uint64(1 << rule.setID)
+		var skip bool
+		switch op := opID(rule.cat >> opShift); op {
+		case opI: // i = x
+			skip = n >= numN || nMask&setBit == 0
+
+		case opI | opNotEqual: // i != x
+			skip = n < numN && nMask&setBit != 0
+
+		case opI | opMod: // i % m = x
+			skip = nMask&setBit == 0
+
+		case opI | opMod | opNotEqual: // i % m != x
+			skip = nMask&setBit != 0
+
+		case opN: // n = x
+			skip = f != 0 || n >= numN || nMask&setBit == 0
+
+		case opN | opNotEqual: // n != x
+			skip = f == 0 && n < numN && nMask&setBit != 0
+
+		case opN | opMod: // n % m = x
+			skip = f != 0 || nMask&setBit == 0
+
+		case opN | opMod | opNotEqual: // n % m != x
+			skip = f == 0 && nMask&setBit != 0
+
+		case opF: // f = x
+			skip = f >= numN || p.inclusionMasks[f%maxMod]&setBit == 0
+
+		case opF | opNotEqual: // f != x
+			skip = f < numN && p.inclusionMasks[f%maxMod]&setBit != 0
+
+		case opF | opMod: // f % m = x
+			skip = p.inclusionMasks[f%maxMod]&setBit == 0
+
+		case opF | opMod | opNotEqual: // f % m != x
+			skip = p.inclusionMasks[f%maxMod]&setBit != 0
+
+		case opV: // v = x
+			skip = v < numN && vMask&setBit == 0
+
+		case opV | opNotEqual: // v != x
+			skip = v < numN && vMask&setBit != 0
+
+		case opW: // w == 0
+			skip = f != 0
+
+		case opW | opNotEqual: // w != 0
+			skip = f == 0
+
+		// Hard-wired rules that cannot be handled by our algorithm.
+
+		case opBretonM:
+			skip = f != 0 || n == 0 || n%1000000 != 0
+
+		case opAzerbaijan00s:
+			// 100,200,300,400,500,600,700,800,900
+			skip = n == 0 || n >= 1000 || n%100 != 0
+
+		case opItalian800:
+			skip = (f != 0 || n >= numN || nMask&setBit == 0) && n != 800
+		}
+		if skip {
+			// advance over AND entries.
+			for ; i < len(rules) && rules[i].cat&formMask == andNext; i++ {
+			}
+			continue
+		}
+		// return if we have a final entry.
+		if cat := rule.cat & formMask; cat != andNext {
+			return Form(cat)
+		}
+	}
+	return Other
+}

data/ext/vendor/golang.org/x/text/feature/plural/plural_test.go

@@ -0,0 +1,216 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package plural
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/text/language"
+)
+
+func TestGetIntApprox(t *testing.T) {
+	const big = 1234567890
+	testCases := []struct {
+		digits string
+		start  int
+		end    int
+		nMod   int
+		want   int
+	}{
+		{"123", 0, 1, 1, 1},
+		{"123", 0, 2, 1, big},
+		{"123", 0, 2, 2, 12},
+		{"123", 3, 4, 2, 0},
+		{"12345", 3, 4, 2, 4},
+		{"40", 0, 1, 2, 4},
+		{"1", 0, 7, 2, big},
+
+		{"123", 0, 5, 2, big},
+		{"123", 0, 5, 3, big},
+		{"123", 0, 5, 4, big},
+		{"123", 0, 5, 5, 12300},
+		{"123", 0, 5, 6, 12300},
+		{"123", 0, 5, 7, 12300},
+
+		// Translation of examples in MatchDigits.
+		// Integer parts
+		{"123", 0, 3, 3, 123},  // 123
+		{"1234", 0, 3, 3, 123}, // 123.4
+		{"1", 0, 6, 8, 100000}, // 100000
+
+		// Fraction parts
+		{"123", 3, 3, 3, 0},   // 123
+		{"1234", 3, 4, 3, 4},  // 123.4
+		{"1234", 3, 5, 3, 40}, // 123.40
+		{"1", 6, 8, 8, 0},     // 100000.00
+	}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%s:%d:%d/%d", tc.digits, tc.start, tc.end, tc.nMod), func(t *testing.T) {
+			got := getIntApprox(mkDigits(tc.digits), tc.start, tc.end, tc.nMod, big)
+			if got != tc.want {
+				t.Errorf("got %d; want %d", got, tc.want)
+			}
+		})
+	}
+}
+
+func mkDigits(s string) []byte {
+	b := []byte(s)
+	for i := range b {
+		b[i] -= '0'
+	}
+	return b
+}
+
+func TestValidForms(t *testing.T) {
+	testCases := []struct {
+		tag  language.Tag
+		want []Form
+	}{
+		{language.AmericanEnglish, []Form{Other, One}},
+		{language.Portuguese, []Form{Other, One}},
+		{language.Latvian, []Form{Other, Zero, One}},
+		{language.Arabic, []Form{Other, Zero, One, Two, Few, Many}},
+		{language.Russian, []Form{Other, One, Few, Many}},
+	}
+	for _, tc := range testCases {
+		got := validForms(cardinal, tc.tag)
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("validForms(%v): got %v; want %v", tc.tag, got, tc.want)
+		}
+	}
+}
+
+func TestOrdinal(t *testing.T) {
+	testPlurals(t, Ordinal, ordinalTests)
+}
+
+func TestCardinal(t *testing.T) {
+	testPlurals(t, Cardinal, cardinalTests)
+}
+
+func testPlurals(t *testing.T, p *Rules, testCases []pluralTest) {
+	for _, tc := range testCases {
+		for _, loc := range strings.Split(tc.locales, " ") {
+			tag := language.MustParse(loc)
+			// Test integers
+			for _, s := range tc.integer {
+				a := strings.Split(s, "~")
+				from := parseUint(t, a[0])
+				to := from
+				if len(a) > 1 {
+					to = parseUint(t, a[1])
+				}
+				for n := from; n <= to; n++ {
+					t.Run(fmt.Sprintf("%s/int(%d)", loc, n), func(t *testing.T) {
+						if f := p.matchComponents(tag, n, 0, 0); f != Form(tc.form) {
+							t.Errorf("matchComponents: got %v; want %v", f, Form(tc.form))
+						}
+						digits := []byte(fmt.Sprint(n))
+						for i := range digits {
+							digits[i] -= '0'
+						}
+						if f := p.MatchDigits(tag, digits, len(digits), 0); f != Form(tc.form) {
+							t.Errorf("MatchDigits: got %v; want %v", f, Form(tc.form))
+						}
+					})
+				}
+			}
+			// Test decimals
+			for _, s := range tc.decimal {
+				a := strings.Split(s, "~")
+				from, scale := parseFixedPoint(t, a[0])
+				to := from
+				if len(a) > 1 {
+					var toScale int
+					if to, toScale = parseFixedPoint(t, a[1]); toScale != scale {
+						t.Fatalf("%s:%s: non-matching scales %d versus %d", loc, s, scale, toScale)
+					}
+				}
+				m := 1
+				for i := 0; i < scale; i++ {
+					m *= 10
+				}
+				for n := from; n <= to; n++ {
+					num := fmt.Sprintf("%[1]d.%0[3]*[2]d", n/m, n%m, scale)
+					name := fmt.Sprintf("%s:dec(%s)", loc, num)
+					t.Run(name, func(t *testing.T) {
+						ff := n % m
+						tt := ff
+						w := scale
+						for tt > 0 && tt%10 == 0 {
+							w--
+							tt /= 10
+						}
+						if f := p.MatchPlural(tag, n/m, scale, w, ff, tt); f != Form(tc.form) {
+							t.Errorf("MatchPlural: got %v; want %v", f, Form(tc.form))
+						}
+						if f := p.matchComponents(tag, n/m, n%m, scale); f != Form(tc.form) {
+							t.Errorf("matchComponents: got %v; want %v", f, Form(tc.form))
+						}
+						exp := strings.IndexByte(num, '.')
+						digits := []byte(strings.Replace(num, ".", "", 1))
+						for i := range digits {
+							digits[i] -= '0'
+						}
+						if f := p.MatchDigits(tag, digits, exp, scale); f != Form(tc.form) {
+							t.Errorf("MatchDigits: got %v; want %v", f, Form(tc.form))
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func parseUint(t *testing.T, s string) int {
+	val, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return int(val)
+}
+
+func parseFixedPoint(t *testing.T, s string) (val, scale int) {
+	p := strings.Index(s, ".")
+	s = strings.Replace(s, ".", "", 1)
+	v, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return int(v), len(s) - p
+}
+
+func BenchmarkPluralSimpleCases(b *testing.B) {
+	p := Cardinal
+	en, _ := language.CompactIndex(language.English)
+	zh, _ := language.CompactIndex(language.Chinese)
+	for i := 0; i < b.N; i++ {
+		matchPlural(p, en, 0, 0, 0)  // 0
+		matchPlural(p, en, 1, 0, 0)  // 1
+		matchPlural(p, en, 2, 12, 3) // 2.120
+		matchPlural(p, zh, 0, 0, 0)  // 0
+		matchPlural(p, zh, 1, 0, 0)  // 1
+		matchPlural(p, zh, 2, 12, 3) // 2.120
+	}
+}
+
+func BenchmarkPluralComplexCases(b *testing.B) {
+	p := Cardinal
+	ar, _ := language.CompactIndex(language.Arabic)
+	lv, _ := language.CompactIndex(language.Latvian)
+	for i := 0; i < b.N; i++ {
+		matchPlural(p, lv, 0, 19, 2)    // 0.19
+		matchPlural(p, lv, 11, 0, 3)    // 11.000
+		matchPlural(p, lv, 100, 123, 4) // 0.1230
+		matchPlural(p, ar, 0, 0, 0)     // 0
+		matchPlural(p, ar, 110, 0, 0)   // 110
+		matchPlural(p, ar, 99, 99, 2)   // 99.99
+	}
+}