ires 0.1.3 → 0.1.4

data/ext/vendor/golang.org/x/text/secure/precis/gen.go

@@ -0,0 +1,310 @@
+// Copyright 2015 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.
+
+// Unicode table generator.
+// Data read from the web.
+
+// +build ignore
+
+package main
+
+import (
+	"flag"
+	"log"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/triegen"
+	"golang.org/x/text/internal/ucd"
+	"golang.org/x/text/unicode/norm"
+	"golang.org/x/text/unicode/rangetable"
+)
+
+var outputFile = flag.String("output", "tables.go", "output file for generated tables; default tables.go")
+
+var assigned, disallowedRunes *unicode.RangeTable
+
+var runeCategory = map[rune]category{}
+
+var overrides = map[category]category{
+	viramaModifier: viramaJoinT,
+	greek:          greekJoinT,
+	hebrew:         hebrewJoinT,
+}
+
+func setCategory(r rune, cat category) {
+	if c, ok := runeCategory[r]; ok {
+		if override, ok := overrides[c]; cat == joiningT && ok {
+			cat = override
+		} else {
+			log.Fatalf("%U: multiple categories for rune (%v and %v)", r, c, cat)
+		}
+	}
+	runeCategory[r] = cat
+}
+
+func init() {
+	if numCategories > 1<<propShift {
+		log.Fatalf("Number of categories is %d; may at most be %d", numCategories, 1<<propShift)
+	}
+}
+
+func main() {
+	gen.Init()
+
+	// Load data
+	runes := []rune{}
+	// PrecisIgnorableProperties: https://tools.ietf.org/html/rfc7564#section-9.13
+	ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
+		if p.String(1) == "Default_Ignorable_Code_Point" {
+			runes = append(runes, p.Rune(0))
+		}
+	})
+	ucd.Parse(gen.OpenUCDFile("PropList.txt"), func(p *ucd.Parser) {
+		switch p.String(1) {
+		case "Noncharacter_Code_Point":
+			runes = append(runes, p.Rune(0))
+		}
+	})
+	// OldHangulJamo: https://tools.ietf.org/html/rfc5892#section-2.9
+	ucd.Parse(gen.OpenUCDFile("HangulSyllableType.txt"), func(p *ucd.Parser) {
+		switch p.String(1) {
+		case "L", "V", "T":
+			runes = append(runes, p.Rune(0))
+		}
+	})
+
+	disallowedRunes = rangetable.New(runes...)
+	assigned = rangetable.Assigned(unicode.Version)
+
+	// Load category data.
+	runeCategory['l'] = latinSmallL
+	ucd.Parse(gen.OpenUCDFile("UnicodeData.txt"), func(p *ucd.Parser) {
+		const cccVirama = 9
+		if p.Int(ucd.CanonicalCombiningClass) == cccVirama {
+			setCategory(p.Rune(0), viramaModifier)
+		}
+	})
+	ucd.Parse(gen.OpenUCDFile("Scripts.txt"), func(p *ucd.Parser) {
+		switch p.String(1) {
+		case "Greek":
+			setCategory(p.Rune(0), greek)
+		case "Hebrew":
+			setCategory(p.Rune(0), hebrew)
+		case "Hiragana", "Katakana", "Han":
+			setCategory(p.Rune(0), japanese)
+		}
+	})
+
+	// Set the rule categories associated with exceptions. This overrides any
+	// previously set categories. The original categories are manually
+	// reintroduced in the categoryTransitions table.
+	for r, e := range exceptions {
+		if e.cat != 0 {
+			runeCategory[r] = e.cat
+		}
+	}
+	cat := map[string]category{
+		"L": joiningL,
+		"D": joiningD,
+		"T": joiningT,
+
+		"R": joiningR,
+	}
+	ucd.Parse(gen.OpenUCDFile("extracted/DerivedJoiningType.txt"), func(p *ucd.Parser) {
+		switch v := p.String(1); v {
+		case "L", "D", "T", "R":
+			setCategory(p.Rune(0), cat[v])
+		}
+	})
+
+	writeTables()
+	gen.Repackage("gen_trieval.go", "trieval.go", "precis")
+}
+
+type exception struct {
+	prop property
+	cat  category
+}
+
+func init() {
+	// Programmatically add the Arabic and Indic digits to the exceptions map.
+	// See comment in the exceptions map below why these are marked disallowed.
+	for i := rune(0); i <= 9; i++ {
+		exceptions[0x0660+i] = exception{
+			prop: disallowed,
+			cat:  arabicIndicDigit,
+		}
+		exceptions[0x06F0+i] = exception{
+			prop: disallowed,
+			cat:  extendedArabicIndicDigit,
+		}
+	}
+}
+
+// The Exceptions class as defined in RFC 5892
+// https://tools.ietf.org/html/rfc5892#section-2.6
+var exceptions = map[rune]exception{
+	0x00DF: {prop: pValid},
+	0x03C2: {prop: pValid},
+	0x06FD: {prop: pValid},
+	0x06FE: {prop: pValid},
+	0x0F0B: {prop: pValid},
+	0x3007: {prop: pValid},
+
+	// ContextO|J rules are marked as disallowed, taking a "guilty until proven
+	// innocent" approach. The main reason for this is that the check for
+	// whether a context rule should be applied can be moved to the logic for
+	// handing disallowed runes, taken it off the common path. The exception to
+	// this rule is for katakanaMiddleDot, as the rule logic is handled without
+	// using a rule function.
+
+	// ContextJ (Join control)
+	0x200C: {prop: disallowed, cat: zeroWidthNonJoiner},
+	0x200D: {prop: disallowed, cat: zeroWidthJoiner},
+
+	// ContextO
+	0x00B7: {prop: disallowed, cat: middleDot},
+	0x0375: {prop: disallowed, cat: greekLowerNumeralSign},
+	0x05F3: {prop: disallowed, cat: hebrewPreceding}, // punctuation Geresh
+	0x05F4: {prop: disallowed, cat: hebrewPreceding}, // punctuation Gershayim
+	0x30FB: {prop: pValid, cat: katakanaMiddleDot},
+
+	// These are officially ContextO, but the implementation does not require
+	// special treatment of these, so we simply mark them as valid.
+	0x0660: {prop: pValid},
+	0x0661: {prop: pValid},
+	0x0662: {prop: pValid},
+	0x0663: {prop: pValid},
+	0x0664: {prop: pValid},
+	0x0665: {prop: pValid},
+	0x0666: {prop: pValid},
+	0x0667: {prop: pValid},
+	0x0668: {prop: pValid},
+	0x0669: {prop: pValid},
+	0x06F0: {prop: pValid},
+	0x06F1: {prop: pValid},
+	0x06F2: {prop: pValid},
+	0x06F3: {prop: pValid},
+	0x06F4: {prop: pValid},
+	0x06F5: {prop: pValid},
+	0x06F6: {prop: pValid},
+	0x06F7: {prop: pValid},
+	0x06F8: {prop: pValid},
+	0x06F9: {prop: pValid},
+
+	0x0640: {prop: disallowed},
+	0x07FA: {prop: disallowed},
+	0x302E: {prop: disallowed},
+	0x302F: {prop: disallowed},
+	0x3031: {prop: disallowed},
+	0x3032: {prop: disallowed},
+	0x3033: {prop: disallowed},
+	0x3034: {prop: disallowed},
+	0x3035: {prop: disallowed},
+	0x303B: {prop: disallowed},
+}
+
+// LetterDigits: https://tools.ietf.org/html/rfc5892#section-2.1
+// r in {Ll, Lu, Lo, Nd, Lm, Mn, Mc}.
+func isLetterDigits(r rune) bool {
+	return unicode.In(r,
+		unicode.Ll, unicode.Lu, unicode.Lm, unicode.Lo, // Letters
+		unicode.Mn, unicode.Mc, // Modifiers
+		unicode.Nd, // Digits
+	)
+}
+
+func isIdDisAndFreePVal(r rune) bool {
+	return unicode.In(r,
+		// OtherLetterDigits: https://tools.ietf.org/html/rfc7564#section-9.18
+		// r in in {Lt, Nl, No, Me}
+		unicode.Lt, unicode.Nl, unicode.No, // Other letters / numbers
+		unicode.Me, // Modifiers
+
+		// Spaces: https://tools.ietf.org/html/rfc7564#section-9.14
+		// r in in {Zs}
+		unicode.Zs,
+
+		// Symbols: https://tools.ietf.org/html/rfc7564#section-9.15
+		// r in {Sm, Sc, Sk, So}
+		unicode.Sm, unicode.Sc, unicode.Sk, unicode.So,
+
+		// Punctuation: https://tools.ietf.org/html/rfc7564#section-9.16
+		// r in {Pc, Pd, Ps, Pe, Pi, Pf, Po}
+		unicode.Pc, unicode.Pd, unicode.Ps, unicode.Pe,
+		unicode.Pi, unicode.Pf, unicode.Po,
+	)
+}
+
+// HasCompat: https://tools.ietf.org/html/rfc7564#section-9.17
+func hasCompat(r rune) bool {
+	return !norm.NFKC.IsNormalString(string(r))
+}
+
+// From https://tools.ietf.org/html/rfc5892:
+//
+// If .cp. .in. Exceptions Then Exceptions(cp);
+//   Else If .cp. .in. BackwardCompatible Then BackwardCompatible(cp);
+//   Else If .cp. .in. Unassigned Then UNASSIGNED;
+//   Else If .cp. .in. ASCII7 Then PVALID;
+//   Else If .cp. .in. JoinControl Then CONTEXTJ;
+//   Else If .cp. .in. OldHangulJamo Then DISALLOWED;
+//   Else If .cp. .in. PrecisIgnorableProperties Then DISALLOWED;
+//   Else If .cp. .in. Controls Then DISALLOWED;
+//   Else If .cp. .in. HasCompat Then ID_DIS or FREE_PVAL;
+//   Else If .cp. .in. LetterDigits Then PVALID;
+//   Else If .cp. .in. OtherLetterDigits Then ID_DIS or FREE_PVAL;
+//   Else If .cp. .in. Spaces Then ID_DIS or FREE_PVAL;
+//   Else If .cp. .in. Symbols Then ID_DIS or FREE_PVAL;
+//   Else If .cp. .in. Punctuation Then ID_DIS or FREE_PVAL;
+//   Else DISALLOWED;
+
+func writeTables() {
+	propTrie := triegen.NewTrie("derivedProperties")
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile(*outputFile, "precis")
+	gen.WriteUnicodeVersion(w)
+
+	// Iterate over all the runes...
+	for i := rune(0); i < unicode.MaxRune; i++ {
+		r := rune(i)
+
+		if !utf8.ValidRune(r) {
+			continue
+		}
+
+		e, ok := exceptions[i]
+		p := e.prop
+		switch {
+		case ok:
+		case !unicode.In(r, assigned):
+			p = unassigned
+		case r >= 0x0021 && r <= 0x007e: // Is ASCII 7
+			p = pValid
+		case unicode.In(r, disallowedRunes, unicode.Cc):
+			p = disallowed
+		case hasCompat(r):
+			p = idDisOrFreePVal
+		case isLetterDigits(r):
+			p = pValid
+		case isIdDisAndFreePVal(r):
+			p = idDisOrFreePVal
+		default:
+			p = disallowed
+		}
+		cat := runeCategory[r]
+		// Don't set category for runes that are disallowed.
+		if p == disallowed {
+			cat = exceptions[r].cat
+		}
+		propTrie.Insert(r, uint64(p)|uint64(cat))
+	}
+	sz, err := propTrie.Gen(w)
+	if err != nil {
+		log.Fatal(err)
+	}
+	w.Size += sz
+}

data/ext/vendor/golang.org/x/text/secure/precis/gen_trieval.go

@@ -0,0 +1,68 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+// entry is the entry of a trie table
+// 7..6   property (unassigned, disallowed, maybe, valid)
+// 5..0   category
+type entry uint8
+
+const (
+	propShift = 6
+	propMask  = 0xc0
+	catMask   = 0x3f
+)
+
+func (e entry) property() property { return property(e & propMask) }
+func (e entry) category() category { return category(e & catMask) }
+
+type property uint8
+
+// The order of these constants matter. A Profile may consider runes to be
+// allowed either from pValid or idDisOrFreePVal.
+const (
+	unassigned property = iota << propShift
+	disallowed
+	idDisOrFreePVal // disallowed for Identifier, pValid for FreeForm
+	pValid
+)
+
+// compute permutations of all properties and specialCategories.
+type category uint8
+
+const (
+	other category = iota
+
+	// Special rune types
+	joiningL
+	joiningD
+	joiningT
+	joiningR
+	viramaModifier
+	viramaJoinT // Virama + JoiningT
+	latinSmallL // U+006c
+	greek
+	greekJoinT // Greek + JoiningT
+	hebrew
+	hebrewJoinT // Hebrew + JoiningT
+	japanese    // hirigana, katakana, han
+
+	// Special rune types associated with contextual rules defined in
+	// https://tools.ietf.org/html/rfc5892#appendix-A.
+	// ContextO
+	zeroWidthNonJoiner // rule 1
+	zeroWidthJoiner    // rule 2
+	// ContextJ
+	middleDot                // rule 3
+	greekLowerNumeralSign    // rule 4
+	hebrewPreceding          // rule 5 and 6
+	katakanaMiddleDot        // rule 7
+	arabicIndicDigit         // rule 8
+	extendedArabicIndicDigit // rule 9
+
+	numCategories
+)

data/ext/vendor/golang.org/x/text/secure/precis/nickname.go

@@ -0,0 +1,72 @@
+// Copyright 2015 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 precis
+
+import (
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+type nickAdditionalMapping struct {
+	// TODO: This transformer needs to be stateless somehow…
+	notStart  bool
+	prevSpace bool
+}
+
+func (t *nickAdditionalMapping) Reset() {
+	t.prevSpace = false
+	t.notStart = false
+}
+
+func (t *nickAdditionalMapping) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	// RFC 8266 §2.1.  Rules
+	//
+	// 2.  Additional Mapping Rule: The additional mapping rule consists of
+	//     the following sub-rules.
+	//
+	//     a.  Map any instances of non-ASCII space to SPACE (U+0020); a
+	//         non-ASCII space is any Unicode code point having a general
+	//         category of "Zs", naturally with the exception of SPACE
+	//         (U+0020).  (The inclusion of only ASCII space prevents
+	//         confusion with various non-ASCII space code points, many of
+	//         which are difficult to reproduce across different input
+	//         methods.)
+	//
+	//     b.  Remove any instances of the ASCII space character at the
+	//         beginning or end of a nickname (e.g., "stpeter " is mapped to
+	//         "stpeter").
+	//
+	//     c.  Map interior sequences of more than one ASCII space character
+	//         to a single ASCII space character (e.g., "St  Peter" is
+	//         mapped to "St Peter").
+	for nSrc < len(src) {
+		r, size := utf8.DecodeRune(src[nSrc:])
+		if size == 0 { // Incomplete UTF-8 encoding
+			if !atEOF {
+				return nDst, nSrc, transform.ErrShortSrc
+			}
+			size = 1
+		}
+		if unicode.Is(unicode.Zs, r) {
+			t.prevSpace = true
+		} else {
+			if t.prevSpace && t.notStart {
+				dst[nDst] = ' '
+				nDst += 1
+			}
+			if size != copy(dst[nDst:], src[nSrc:nSrc+size]) {
+				nDst += size
+				return nDst, nSrc, transform.ErrShortDst
+			}
+			nDst += size
+			t.prevSpace = false
+			t.notStart = true
+		}
+		nSrc += size
+	}
+	return nDst, nSrc, nil
+}