ires 0.1.3 → 0.1.4

data/ext/vendor/golang.org/x/text/collate/tools/colcmp/col.go

@@ -0,0 +1,97 @@
+// Copyright 2012 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 main
+
+import (
+	"log"
+	"unicode/utf16"
+
+	"golang.org/x/text/collate"
+	"golang.org/x/text/language"
+)
+
+// Input holds an input string in both UTF-8 and UTF-16 format.
+type Input struct {
+	index int // used for restoring to original random order
+	UTF8  []byte
+	UTF16 []uint16
+	key   []byte // used for sorting
+}
+
+func (i Input) String() string {
+	return string(i.UTF8)
+}
+
+func makeInput(s8 []byte, s16 []uint16) Input {
+	return Input{UTF8: s8, UTF16: s16}
+}
+
+func makeInputString(s string) Input {
+	return Input{
+		UTF8:  []byte(s),
+		UTF16: utf16.Encode([]rune(s)),
+	}
+}
+
+// Collator is an interface for architecture-specific implementations of collation.
+type Collator interface {
+	// Key generates a sort key for the given input.  Implemenations
+	// may return nil if a collator does not support sort keys.
+	Key(s Input) []byte
+
+	// Compare returns -1 if a < b, 1 if a > b and 0 if a == b.
+	Compare(a, b Input) int
+}
+
+// CollatorFactory creates a Collator for a given language tag.
+type CollatorFactory struct {
+	name        string
+	makeFn      func(tag string) (Collator, error)
+	description string
+}
+
+var collators = []CollatorFactory{}
+
+// AddFactory registers f as a factory for an implementation of Collator.
+func AddFactory(f CollatorFactory) {
+	collators = append(collators, f)
+}
+
+func getCollator(name, locale string) Collator {
+	for _, f := range collators {
+		if f.name == name {
+			col, err := f.makeFn(locale)
+			if err != nil {
+				log.Fatal(err)
+			}
+			return col
+		}
+	}
+	log.Fatalf("collator of type %q not found", name)
+	return nil
+}
+
+// goCollator is an implemention of Collator using go's own collator.
+type goCollator struct {
+	c   *collate.Collator
+	buf collate.Buffer
+}
+
+func init() {
+	AddFactory(CollatorFactory{"go", newGoCollator, "Go's native collator implementation."})
+}
+
+func newGoCollator(loc string) (Collator, error) {
+	c := &goCollator{c: collate.New(language.Make(loc))}
+	return c, nil
+}
+
+func (c *goCollator) Key(b Input) []byte {
+	return c.c.Key(&c.buf, b.UTF8)
+}
+
+func (c *goCollator) Compare(a, b Input) int {
+	return c.c.Compare(a.UTF8, b.UTF8)
+}

data/ext/vendor/golang.org/x/text/collate/tools/colcmp/colcmp.go

@@ -0,0 +1,529 @@
+// Copyright 2012 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 main // import "golang.org/x/text/collate/tools/colcmp"
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"runtime/pprof"
+	"sort"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	"golang.org/x/text/unicode/norm"
+)
+
+var (
+	doNorm  = flag.Bool("norm", false, "normalize input strings")
+	cases   = flag.Bool("case", false, "generate case variants")
+	verbose = flag.Bool("verbose", false, "print results")
+	debug   = flag.Bool("debug", false, "output debug information")
+	locales = flag.String("locale", "en_US", "the locale to use. May be a comma-separated list for some commands.")
+	col     = flag.String("col", "go", "collator to test")
+	gold    = flag.String("gold", "go", "collator used as the gold standard")
+	usecmp  = flag.Bool("usecmp", false,
+		`use comparison instead of sort keys when sorting.  Must be "test", "gold" or "both"`)
+	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+	exclude    = flag.String("exclude", "", "exclude errors that contain any of the characters")
+	limit      = flag.Int("limit", 5000000, "maximum number of samples to generate for one run")
+)
+
+func failOnError(err error) {
+	if err != nil {
+		log.Panic(err)
+	}
+}
+
+// Test holds test data for testing a locale-collator pair.
+// Test also provides functionality that is commonly used by the various commands.
+type Test struct {
+	ctxt    *Context
+	Name    string
+	Locale  string
+	ColName string
+
+	Col        Collator
+	UseCompare bool
+
+	Input    []Input
+	Duration time.Duration
+
+	start time.Time
+	msg   string
+	count int
+}
+
+func (t *Test) clear() {
+	t.Col = nil
+	t.Input = nil
+}
+
+const (
+	msgGeneratingInput = "generating input"
+	msgGeneratingKeys  = "generating keys"
+	msgSorting         = "sorting"
+)
+
+var lastLen = 0
+
+func (t *Test) SetStatus(msg string) {
+	if *debug || *verbose {
+		fmt.Printf("%s: %s...\n", t.Name, msg)
+	} else if t.ctxt.out != nil {
+		fmt.Fprint(t.ctxt.out, strings.Repeat(" ", lastLen))
+		fmt.Fprint(t.ctxt.out, strings.Repeat("\b", lastLen))
+		fmt.Fprint(t.ctxt.out, msg, "...")
+		lastLen = len(msg) + 3
+		fmt.Fprint(t.ctxt.out, strings.Repeat("\b", lastLen))
+	}
+}
+
+// Start is used by commands to signal the start of an operation.
+func (t *Test) Start(msg string) {
+	t.SetStatus(msg)
+	t.count = 0
+	t.msg = msg
+	t.start = time.Now()
+}
+
+// Stop is used by commands to signal the end of an operation.
+func (t *Test) Stop() (time.Duration, int) {
+	d := time.Now().Sub(t.start)
+	t.Duration += d
+	if *debug || *verbose {
+		fmt.Printf("%s: %s done. (%.3fs /%dK ops)\n", t.Name, t.msg, d.Seconds(), t.count/1000)
+	}
+	return d, t.count
+}
+
+// generateKeys generates sort keys for all the inputs.
+func (t *Test) generateKeys() {
+	for i, s := range t.Input {
+		b := t.Col.Key(s)
+		t.Input[i].key = b
+		if *debug {
+			fmt.Printf("%s (%X): %X\n", string(s.UTF8), s.UTF16, b)
+		}
+	}
+}
+
+// Sort sorts the inputs. It generates sort keys if this is required by the
+// chosen sort method.
+func (t *Test) Sort() (tkey, tsort time.Duration, nkey, nsort int) {
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		failOnError(err)
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+	if t.UseCompare || t.Col.Key(t.Input[0]) == nil {
+		t.Start(msgSorting)
+		sort.Sort(&testCompare{*t})
+		tsort, nsort = t.Stop()
+	} else {
+		t.Start(msgGeneratingKeys)
+		t.generateKeys()
+		t.count = len(t.Input)
+		tkey, nkey = t.Stop()
+		t.Start(msgSorting)
+		sort.Sort(t)
+		tsort, nsort = t.Stop()
+	}
+	return
+}
+
+func (t *Test) Swap(a, b int) {
+	t.Input[a], t.Input[b] = t.Input[b], t.Input[a]
+}
+
+func (t *Test) Less(a, b int) bool {
+	t.count++
+	return bytes.Compare(t.Input[a].key, t.Input[b].key) == -1
+}
+
+func (t Test) Len() int {
+	return len(t.Input)
+}
+
+type testCompare struct {
+	Test
+}
+
+func (t *testCompare) Less(a, b int) bool {
+	t.count++
+	return t.Col.Compare(t.Input[a], t.Input[b]) == -1
+}
+
+type testRestore struct {
+	Test
+}
+
+func (t *testRestore) Less(a, b int) bool {
+	return t.Input[a].index < t.Input[b].index
+}
+
+// GenerateInput generates input phrases for the locale tested by t.
+func (t *Test) GenerateInput() {
+	t.Input = nil
+	if t.ctxt.lastLocale != t.Locale {
+		gen := phraseGenerator{}
+		gen.init(t.Locale)
+		t.SetStatus(msgGeneratingInput)
+		t.ctxt.lastInput = nil // allow the previous value to be garbage collected.
+		t.Input = gen.generate(*doNorm)
+		t.ctxt.lastInput = t.Input
+		t.ctxt.lastLocale = t.Locale
+	} else {
+		t.Input = t.ctxt.lastInput
+		for i := range t.Input {
+			t.Input[i].key = nil
+		}
+		sort.Sort(&testRestore{*t})
+	}
+}
+
+// Context holds all tests and settings translated from command line options.
+type Context struct {
+	test []*Test
+	last *Test
+
+	lastLocale string
+	lastInput  []Input
+
+	out io.Writer
+}
+
+func (ts *Context) Printf(format string, a ...interface{}) {
+	ts.assertBuf()
+	fmt.Fprintf(ts.out, format, a...)
+}
+
+func (ts *Context) Print(a ...interface{}) {
+	ts.assertBuf()
+	fmt.Fprint(ts.out, a...)
+}
+
+// assertBuf sets up an io.Writer for output, if it doesn't already exist.
+// In debug and verbose mode, output is buffered so that the regular output
+// will not interfere with the additional output.  Otherwise, output is
+// written directly to stdout for a more responsive feel.
+func (ts *Context) assertBuf() {
+	if ts.out != nil {
+		return
+	}
+	if *debug || *verbose {
+		ts.out = &bytes.Buffer{}
+	} else {
+		ts.out = os.Stdout
+	}
+}
+
+// flush flushes the contents of ts.out to stdout, if it is not stdout already.
+func (ts *Context) flush() {
+	if ts.out != nil {
+		if _, ok := ts.out.(io.ReadCloser); !ok {
+			io.Copy(os.Stdout, ts.out.(io.Reader))
+		}
+	}
+}
+
+// parseTests creates all tests from command lines and returns
+// a Context to hold them.
+func parseTests() *Context {
+	ctxt := &Context{}
+	colls := strings.Split(*col, ",")
+	for _, loc := range strings.Split(*locales, ",") {
+		loc = strings.TrimSpace(loc)
+		for _, name := range colls {
+			name = strings.TrimSpace(name)
+			col := getCollator(name, loc)
+			ctxt.test = append(ctxt.test, &Test{
+				ctxt:       ctxt,
+				Locale:     loc,
+				ColName:    name,
+				UseCompare: *usecmp,
+				Col:        col,
+			})
+		}
+	}
+	return ctxt
+}
+
+func (c *Context) Len() int {
+	return len(c.test)
+}
+
+func (c *Context) Test(i int) *Test {
+	if c.last != nil {
+		c.last.clear()
+	}
+	c.last = c.test[i]
+	return c.last
+}
+
+func parseInput(args []string) []Input {
+	input := []Input{}
+	for _, s := range args {
+		rs := []rune{}
+		for len(s) > 0 {
+			var r rune
+			r, _, s, _ = strconv.UnquoteChar(s, '\'')
+			rs = append(rs, r)
+		}
+		s = string(rs)
+		if *doNorm {
+			s = norm.NFD.String(s)
+		}
+		input = append(input, makeInputString(s))
+	}
+	return input
+}
+
+// A Command is an implementation of a colcmp command.
+type Command struct {
+	Run   func(cmd *Context, args []string)
+	Usage string
+	Short string
+	Long  string
+}
+
+func (cmd Command) Name() string {
+	return strings.SplitN(cmd.Usage, " ", 2)[0]
+}
+
+var commands = []*Command{
+	cmdSort,
+	cmdBench,
+	cmdRegress,
+}
+
+const sortHelp = `
+Sort sorts a given list of strings.  Strings are separated by whitespace.
+`
+
+var cmdSort = &Command{
+	Run:   runSort,
+	Usage: "sort <string>*",
+	Short: "sort a given list of strings",
+	Long:  sortHelp,
+}
+
+func runSort(ctxt *Context, args []string) {
+	input := parseInput(args)
+	if len(input) == 0 {
+		log.Fatalf("Nothing to sort.")
+	}
+	if ctxt.Len() > 1 {
+		ctxt.Print("COLL  LOCALE RESULT\n")
+	}
+	for i := 0; i < ctxt.Len(); i++ {
+		t := ctxt.Test(i)
+		t.Input = append(t.Input, input...)
+		t.Sort()
+		if ctxt.Len() > 1 {
+			ctxt.Printf("%-5s %-5s  ", t.ColName, t.Locale)
+		}
+		for _, s := range t.Input {
+			ctxt.Print(string(s.UTF8), " ")
+		}
+		ctxt.Print("\n")
+	}
+}
+
+const benchHelp = `
+Bench runs a benchmark for the given list of collator implementations.
+If no collator implementations are given, the go collator will be used.
+`
+
+var cmdBench = &Command{
+	Run:   runBench,
+	Usage: "bench",
+	Short: "benchmark a given list of collator implementations",
+	Long:  benchHelp,
+}
+
+func runBench(ctxt *Context, args []string) {
+	ctxt.Printf("%-7s %-5s %-6s %-24s %-24s %-5s %s\n", "LOCALE", "COLL", "N", "KEYS", "SORT", "AVGLN", "TOTAL")
+	for i := 0; i < ctxt.Len(); i++ {
+		t := ctxt.Test(i)
+		ctxt.Printf("%-7s %-5s ", t.Locale, t.ColName)
+		t.GenerateInput()
+		ctxt.Printf("%-6s ", fmt.Sprintf("%dK", t.Len()/1000))
+		tkey, tsort, nkey, nsort := t.Sort()
+		p := func(dur time.Duration, n int) {
+			s := ""
+			if dur > 0 {
+				s = fmt.Sprintf("%6.3fs ", dur.Seconds())
+				if n > 0 {
+					s += fmt.Sprintf("%15s", fmt.Sprintf("(%4.2f ns/op)", float64(dur)/float64(n)))
+				}
+			}
+			ctxt.Printf("%-24s ", s)
+		}
+		p(tkey, nkey)
+		p(tsort, nsort)
+
+		total := 0
+		for _, s := range t.Input {
+			total += len(s.key)
+		}
+		ctxt.Printf("%-5d ", total/t.Len())
+		ctxt.Printf("%6.3fs\n", t.Duration.Seconds())
+		if *debug {
+			for _, s := range t.Input {
+				fmt.Print(string(s.UTF8), " ")
+			}
+			fmt.Println()
+		}
+	}
+}
+
+const regressHelp = `
+Regress runs a monkey test by comparing the results of randomly generated tests
+between two implementations of a collator. The user may optionally pass a list
+of strings to regress against instead of the default test set.
+`
+
+var cmdRegress = &Command{
+	Run:   runRegress,
+	Usage: "regress -gold=<col> -test=<col> [string]*",
+	Short: "run a monkey test between two collators",
+	Long:  regressHelp,
+}
+
+const failedKeyCompare = `
+%s:%d: incorrect comparison result for input:
+    a:   %q (%.4X)
+    key: %s
+    b:   %q (%.4X)
+    key: %s
+    Compare(a, b) = %d; want %d.
+
+  gold keys:
+	a:   %s
+	b:   %s
+`
+
+const failedCompare = `
+%s:%d: incorrect comparison result for input:
+    a:   %q (%.4X)
+    b:   %q (%.4X)
+    Compare(a, b) = %d; want %d.
+`
+
+func keyStr(b []byte) string {
+	buf := &bytes.Buffer{}
+	for _, v := range b {
+		fmt.Fprintf(buf, "%.2X ", v)
+	}
+	return buf.String()
+}
+
+func runRegress(ctxt *Context, args []string) {
+	input := parseInput(args)
+	for i := 0; i < ctxt.Len(); i++ {
+		t := ctxt.Test(i)
+		if len(input) > 0 {
+			t.Input = append(t.Input, input...)
+		} else {
+			t.GenerateInput()
+		}
+		t.Sort()
+		count := 0
+		gold := getCollator(*gold, t.Locale)
+		for i := 1; i < len(t.Input); i++ {
+			ia := t.Input[i-1]
+			ib := t.Input[i]
+			if bytes.IndexAny(ib.UTF8, *exclude) != -1 {
+				i++
+				continue
+			}
+			if bytes.IndexAny(ia.UTF8, *exclude) != -1 {
+				continue
+			}
+			goldCmp := gold.Compare(ia, ib)
+			if cmp := bytes.Compare(ia.key, ib.key); cmp != goldCmp {
+				count++
+				a := string(ia.UTF8)
+				b := string(ib.UTF8)
+				fmt.Printf(failedKeyCompare, t.Locale, i-1, a, []rune(a), keyStr(ia.key), b, []rune(b), keyStr(ib.key), cmp, goldCmp, keyStr(gold.Key(ia)), keyStr(gold.Key(ib)))
+			} else if cmp := t.Col.Compare(ia, ib); cmp != goldCmp {
+				count++
+				a := string(ia.UTF8)
+				b := string(ib.UTF8)
+				fmt.Printf(failedCompare, t.Locale, i-1, a, []rune(a), b, []rune(b), cmp, goldCmp)
+			}
+		}
+		if count > 0 {
+			ctxt.Printf("Found %d inconsistencies in %d entries.\n", count, t.Len()-1)
+		}
+	}
+}
+
+const helpTemplate = `
+colcmp is a tool for testing and benchmarking collation
+
+Usage: colcmp command [arguments]
+
+The commands are:
+{{range .}}
+    {{.Name | printf "%-11s"}} {{.Short}}{{end}}
+
+Use "col help [topic]" for more information about that topic.
+`
+
+const detailedHelpTemplate = `
+Usage: colcmp {{.Usage}}
+
+{{.Long | trim}}
+`
+
+func runHelp(args []string) {
+	t := template.New("help")
+	t.Funcs(template.FuncMap{"trim": strings.TrimSpace})
+	if len(args) < 1 {
+		template.Must(t.Parse(helpTemplate))
+		failOnError(t.Execute(os.Stderr, &commands))
+	} else {
+		for _, cmd := range commands {
+			if cmd.Name() == args[0] {
+				template.Must(t.Parse(detailedHelpTemplate))
+				failOnError(t.Execute(os.Stderr, cmd))
+				os.Exit(0)
+			}
+		}
+		log.Fatalf("Unknown command %q. Run 'colcmp help'.", args[0])
+	}
+	os.Exit(0)
+}
+
+func main() {
+	flag.Parse()
+	log.SetFlags(0)
+
+	ctxt := parseTests()
+
+	if flag.NArg() < 1 {
+		runHelp(nil)
+	}
+	args := flag.Args()[1:]
+	if flag.Arg(0) == "help" {
+		runHelp(args)
+	}
+	for _, cmd := range commands {
+		if cmd.Name() == flag.Arg(0) {
+			cmd.Run(ctxt, args)
+			ctxt.flush()
+			return
+		}
+	}
+	runHelp(flag.Args())
+}