http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/doc.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/doc.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/doc.go deleted file mode 100644 index 1d3fb86..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/doc.go +++ /dev/null @@ -1,156 +0,0 @@ -// Copyright 2015 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package properties provides functions for reading and writing -// ISO-8859-1 and UTF-8 encoded .properties files and has -// support for recursive property expansion. -// -// Java properties files are ISO-8859-1 encoded and use Unicode -// literals for characters outside the ISO character set. Unicode -// literals can be used in UTF-8 encoded properties files but -// aren't necessary. -// -// To load a single properties file use MustLoadFile(): -// -// p := properties.MustLoadFile(filename, properties.UTF8) -// -// To load multiple properties files use MustLoadFiles() -// which loads the files in the given order and merges the -// result. Missing properties files can be ignored if the -// 'ignoreMissing' flag is set to true. -// -// Filenames can contain environment variables which are expanded -// before loading. -// -// f1 := "/etc/myapp/myapp.conf" -// f2 := "/home/${USER}/myapp.conf" -// p := MustLoadFiles([]string{f1, f2}, properties.UTF8, true) -// -// All of the different key/value delimiters ' ', ':' and '=' are -// supported as well as the comment characters '!' and '#' and -// multi-line values. -// -// ! this is a comment -// # and so is this -// -// # the following expressions are equal -// key value -// key=value -// key:value -// key = value -// key : value -// key = val\ -// ue -// -// Properties stores all comments preceding a key and provides -// GetComments() and SetComments() methods to retrieve and -// update them. The convenience functions GetComment() and -// SetComment() allow access to the last comment. The -// WriteComment() method writes properties files including -// the comments and with the keys in the original order. -// This can be used for sanitizing properties files. -// -// Property expansion is recursive and circular references -// and malformed expressions are not allowed and cause an -// error. Expansion of environment variables is supported. -// -// # standard property -// key = value -// -// # property expansion: key2 = value -// key2 = ${key} -// -// # recursive expansion: key3 = value -// key3 = ${key2} -// -// # circular reference (error) -// key = ${key} -// -// # malformed expression (error) -// key = ${ke -// -// # refers to the users' home dir -// home = ${HOME} -// -// # local key takes precendence over env var: u = foo -// USER = foo -// u = ${USER} -// -// The default property expansion format is ${key} but can be -// changed by setting different pre- and postfix values on the -// Properties object. -// -// p := properties.NewProperties() -// p.Prefix = "#[" -// p.Postfix = "]#" -// -// Properties provides convenience functions for getting typed -// values with default values if the key does not exist or the -// type conversion failed. -// -// # Returns true if the value is either "1", "on", "yes" or "true" -// # Returns false for every other value and the default value if -// # the key does not exist. -// v = p.GetBool("key", false) -// -// # Returns the value if the key exists and the format conversion -// # was successful. Otherwise, the default value is returned. -// v = p.GetInt64("key", 999) -// v = p.GetUint64("key", 999) -// v = p.GetFloat64("key", 123.0) -// v = p.GetString("key", "def") -// v = p.GetDuration("key", 999) -// -// As an alterantive properties may be applied with the standard -// library's flag implementation at any time. -// -// # Standard configuration -// v = flag.Int("key", 999, "help message") -// flag.Parse() -// -// # Merge p into the flag set -// p.MustFlag(flag.CommandLine) -// -// Properties provides several MustXXX() convenience functions -// which will terminate the app if an error occurs. The behavior -// of the failure is configurable and the default is to call -// log.Fatal(err). To have the MustXXX() functions panic instead -// of logging the error set a different ErrorHandler before -// you use the Properties package. -// -// properties.ErrorHandler = properties.PanicHandler -// -// # Will panic instead of logging an error -// p := properties.MustLoadFile("config.properties") -// -// You can also provide your own ErrorHandler function. The only requirement -// is that the error handler function must exit after handling the error. -// -// properties.ErrorHandler = func(err error) { -// fmt.Println(err) -// os.Exit(1) -// } -// -// # Will write to stdout and then exit -// p := properties.MustLoadFile("config.properties") -// -// Properties can also be loaded into a struct via the `Decode` -// method, e.g. -// -// type S struct { -// A string `properties:"a,default=foo"` -// D time.Duration `properties:"timeout,default=5s"` -// E time.Time `properties:"expires,layout=2006-01-02,default=2015-01-01"` -// } -// -// See `Decode()` method for the full documentation. -// -// The following documents provide a description of the properties -// file format. -// -// http://en.wikipedia.org/wiki/.properties -// -// http://docs.oracle.com/javase/7/docs/api/java/util/Properties.html#load%28java.io.Reader%29 -// -package properties
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/example_test.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/example_test.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/example_test.go deleted file mode 100644 index 38bf04f..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/example_test.go +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "fmt" - "log" -) - -func ExampleLoad_iso88591() { - buf := []byte("key = ISO-8859-1 value with unicode literal \\u2318 and umlaut \xE4") // 0xE4 == ä - p, _ := Load(buf, ISO_8859_1) - v, ok := p.Get("key") - fmt.Println(ok) - fmt.Println(v) - // Output: - // true - // ISO-8859-1 value with unicode literal â and umlaut ä -} - -func ExampleLoad_utf8() { - p, _ := Load([]byte("key = UTF-8 value with unicode character â and umlaut ä"), UTF8) - v, ok := p.Get("key") - fmt.Println(ok) - fmt.Println(v) - // Output: - // true - // UTF-8 value with unicode character â and umlaut ä -} - -func ExampleProperties_GetBool() { - var input = ` - key=1 - key2=On - key3=YES - key4=true` - p, _ := Load([]byte(input), ISO_8859_1) - fmt.Println(p.GetBool("key", false)) - fmt.Println(p.GetBool("key2", false)) - fmt.Println(p.GetBool("key3", false)) - fmt.Println(p.GetBool("key4", false)) - fmt.Println(p.GetBool("keyX", false)) - // Output: - // true - // true - // true - // true - // false -} - -func ExampleProperties_GetString() { - p, _ := Load([]byte("key=value"), ISO_8859_1) - v := p.GetString("another key", "default value") - fmt.Println(v) - // Output: - // default value -} - -func Example() { - // Decode some key/value pairs with expressions - p, err := Load([]byte("key=value\nkey2=${key}"), ISO_8859_1) - if err != nil { - log.Fatal(err) - } - - // Get a valid key - if v, ok := p.Get("key"); ok { - fmt.Println(v) - } - - // Get an invalid key - if _, ok := p.Get("does not exist"); !ok { - fmt.Println("invalid key") - } - - // Get a key with a default value - v := p.GetString("does not exist", "some value") - fmt.Println(v) - - // Dump the expanded key/value pairs of the Properties - fmt.Println("Expanded key/value pairs") - fmt.Println(p) - - // Output: - // value - // invalid key - // some value - // Expanded key/value pairs - // key = value - // key2 = value -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate.go deleted file mode 100644 index 1e97290..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate.go +++ /dev/null @@ -1,30 +0,0 @@ -package properties - -import "flag" - -// MustFlag sets flags that are skipped by dst.Parse when p contains -// the respective key for flag.Flag.Name. -// -// It's use is recommended with command line arguments as in: -// flag.Parse() -// p.MustFlag(flag.CommandLine) -func (p *Properties) MustFlag(dst *flag.FlagSet) { - m := make(map[string]*flag.Flag) - dst.VisitAll(func(f *flag.Flag) { - m[f.Name] = f - }) - dst.Visit(func(f *flag.Flag) { - delete(m, f.Name) // overridden - }) - - for name, f := range m { - v, ok := p.Get(name) - if !ok { - continue - } - - if err := f.Value.Set(v); err != nil { - ErrorHandler(err) - } - } -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate_test.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate_test.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate_test.go deleted file mode 100644 index 90daaa2..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/integrate_test.go +++ /dev/null @@ -1,70 +0,0 @@ -package properties - -import ( - "flag" - "fmt" - "testing" -) - -// TestFlag verifies Properties.MustFlag without flag.FlagSet.Parse -func TestFlag(t *testing.T) { - f := flag.NewFlagSet("src", flag.PanicOnError) - gotS := f.String("s", "?", "string flag") - gotI := f.Int("i", -1, "int flag") - - p := NewProperties() - p.Set("s", "t") - p.Set("i", "9") - p.MustFlag(f) - - if want := "t"; *gotS != want { - t.Errorf("Got string s=%q, want %q", *gotS, want) - } - if want := 9; *gotI != want { - t.Errorf("Got int i=%d, want %d", *gotI, want) - } -} - -// TestFlagOverride verifies Properties.MustFlag with flag.FlagSet.Parse. -func TestFlagOverride(t *testing.T) { - f := flag.NewFlagSet("src", flag.PanicOnError) - gotA := f.Int("a", 1, "remain default") - gotB := f.Int("b", 2, "customized") - gotC := f.Int("c", 3, "overridden") - - f.Parse([]string{"-c", "4"}) - - p := NewProperties() - p.Set("b", "5") - p.Set("c", "6") - p.MustFlag(f) - - if want := 1; *gotA != want { - t.Errorf("Got remain default a=%d, want %d", *gotA, want) - } - if want := 5; *gotB != want { - t.Errorf("Got customized b=%d, want %d", *gotB, want) - } - if want := 4; *gotC != want { - t.Errorf("Got overriden c=%d, want %d", *gotC, want) - } -} - -func ExampleProperties_MustFlag() { - x := flag.Int("x", 0, "demo customize") - y := flag.Int("y", 0, "demo override") - - // Demo alternative for flag.Parse(): - flag.CommandLine.Parse([]string{"-y", "10"}) - fmt.Printf("flagged as x=%d, y=%d\n", *x, *y) - - p := NewProperties() - p.Set("x", "7") - p.Set("y", "42") // note discard - p.MustFlag(flag.CommandLine) - fmt.Printf("configured to x=%d, y=%d\n", *x, *y) - - // Output: - // flagged as x=0, y=10 - // configured to x=7, y=10 -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/lex.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/lex.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/lex.go deleted file mode 100644 index 1ae7a45..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/lex.go +++ /dev/null @@ -1,409 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. -// -// Parts of the lexer are from the template/text/parser package -// For these parts the following applies: -// -// Copyright 2011 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 of the go 1.2 -// distribution. - -package properties - -import ( - "fmt" - "strconv" - "strings" - "unicode/utf8" -) - -// item represents a token or text string returned from the scanner. -type item struct { - typ itemType // The type of this item. - pos int // The starting position, in bytes, of this item in the input string. - val string // The value of this item. -} - -func (i item) String() string { - switch { - case i.typ == itemEOF: - return "EOF" - case i.typ == itemError: - return i.val - case len(i.val) > 10: - return fmt.Sprintf("%.10q...", i.val) - } - return fmt.Sprintf("%q", i.val) -} - -// itemType identifies the type of lex items. -type itemType int - -const ( - itemError itemType = iota // error occurred; value is text of error - itemEOF - itemKey // a key - itemValue // a value - itemComment // a comment -) - -// defines a constant for EOF -const eof = -1 - -// permitted whitespace characters space, FF and TAB -const whitespace = " \f\t" - -// stateFn represents the state of the scanner as a function that returns the next state. -type stateFn func(*lexer) stateFn - -// lexer holds the state of the scanner. -type lexer struct { - input string // the string being scanned - state stateFn // the next lexing function to enter - pos int // current position in the input - start int // start position of this item - width int // width of last rune read from input - lastPos int // position of most recent item returned by nextItem - runes []rune // scanned runes for this item - items chan item // channel of scanned items -} - -// next returns the next rune in the input. -func (l *lexer) next() rune { - if int(l.pos) >= len(l.input) { - l.width = 0 - return eof - } - r, w := utf8.DecodeRuneInString(l.input[l.pos:]) - l.width = w - l.pos += l.width - return r -} - -// peek returns but does not consume the next rune in the input. -func (l *lexer) peek() rune { - r := l.next() - l.backup() - return r -} - -// backup steps back one rune. Can only be called once per call of next. -func (l *lexer) backup() { - l.pos -= l.width -} - -// emit passes an item back to the client. -func (l *lexer) emit(t itemType) { - item := item{t, l.start, string(l.runes)} - l.items <- item - l.start = l.pos - l.runes = l.runes[:0] -} - -// ignore skips over the pending input before this point. -func (l *lexer) ignore() { - l.start = l.pos -} - -// appends the rune to the current value -func (l *lexer) appendRune(r rune) { - l.runes = append(l.runes, r) -} - -// accept consumes the next rune if it's from the valid set. -func (l *lexer) accept(valid string) bool { - if strings.IndexRune(valid, l.next()) >= 0 { - return true - } - l.backup() - return false -} - -// acceptRun consumes a run of runes from the valid set. -func (l *lexer) acceptRun(valid string) { - for strings.IndexRune(valid, l.next()) >= 0 { - } - l.backup() -} - -// acceptRunUntil consumes a run of runes up to a terminator. -func (l *lexer) acceptRunUntil(term rune) { - for term != l.next() { - } - l.backup() -} - -// hasText returns true if the current parsed text is not empty. -func (l *lexer) isNotEmpty() bool { - return l.pos > l.start -} - -// lineNumber reports which line we're on, based on the position of -// the previous item returned by nextItem. Doing it this way -// means we don't have to worry about peek double counting. -func (l *lexer) lineNumber() int { - return 1 + strings.Count(l.input[:l.lastPos], "\n") -} - -// errorf returns an error token and terminates the scan by passing -// back a nil pointer that will be the next state, terminating l.nextItem. -func (l *lexer) errorf(format string, args ...interface{}) stateFn { - l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)} - return nil -} - -// nextItem returns the next item from the input. -func (l *lexer) nextItem() item { - item := <-l.items - l.lastPos = item.pos - return item -} - -// lex creates a new scanner for the input string. -func lex(input string) *lexer { - l := &lexer{ - input: input, - items: make(chan item), - runes: make([]rune, 0, 32), - } - go l.run() - return l -} - -// run runs the state machine for the lexer. -func (l *lexer) run() { - for l.state = lexBeforeKey(l); l.state != nil; { - l.state = l.state(l) - } -} - -// state functions - -// lexBeforeKey scans until a key begins. -func lexBeforeKey(l *lexer) stateFn { - switch r := l.next(); { - case isEOF(r): - l.emit(itemEOF) - return nil - - case isEOL(r): - l.ignore() - return lexBeforeKey - - case isComment(r): - return lexComment - - case isWhitespace(r): - l.acceptRun(whitespace) - l.ignore() - return lexKey - - default: - l.backup() - return lexKey - } -} - -// lexComment scans a comment line. The comment character has already been scanned. -func lexComment(l *lexer) stateFn { - l.acceptRun(whitespace) - l.ignore() - for { - switch r := l.next(); { - case isEOF(r): - l.ignore() - l.emit(itemEOF) - return nil - case isEOL(r): - l.emit(itemComment) - return lexBeforeKey - default: - l.appendRune(r) - } - } -} - -// lexKey scans the key up to a delimiter -func lexKey(l *lexer) stateFn { - var r rune - -Loop: - for { - switch r = l.next(); { - - case isEscape(r): - err := l.scanEscapeSequence() - if err != nil { - return l.errorf(err.Error()) - } - - case isEndOfKey(r): - l.backup() - break Loop - - case isEOF(r): - break Loop - - default: - l.appendRune(r) - } - } - - if len(l.runes) > 0 { - l.emit(itemKey) - } - - if isEOF(r) { - l.emit(itemEOF) - return nil - } - - return lexBeforeValue -} - -// lexBeforeValue scans the delimiter between key and value. -// Leading and trailing whitespace is ignored. -// We expect to be just after the key. -func lexBeforeValue(l *lexer) stateFn { - l.acceptRun(whitespace) - l.accept(":=") - l.acceptRun(whitespace) - l.ignore() - return lexValue -} - -// lexValue scans text until the end of the line. We expect to be just after the delimiter. -func lexValue(l *lexer) stateFn { - for { - switch r := l.next(); { - case isEscape(r): - r := l.peek() - if isEOL(r) { - l.next() - l.acceptRun(whitespace) - } else { - err := l.scanEscapeSequence() - if err != nil { - return l.errorf(err.Error()) - } - } - - case isEOL(r): - l.emit(itemValue) - l.ignore() - return lexBeforeKey - - case isEOF(r): - l.emit(itemValue) - l.emit(itemEOF) - return nil - - default: - l.appendRune(r) - } - } -} - -// scanEscapeSequence scans either one of the escaped characters -// or a unicode literal. We expect to be after the escape character. -func (l *lexer) scanEscapeSequence() error { - switch r := l.next(); { - - case isEscapedCharacter(r): - l.appendRune(decodeEscapedCharacter(r)) - return nil - - case atUnicodeLiteral(r): - return l.scanUnicodeLiteral() - - case isEOF(r): - return fmt.Errorf("premature EOF") - - // silently drop the escape character and append the rune as is - default: - l.appendRune(r) - return nil - } -} - -// scans a unicode literal in the form \uXXXX. We expect to be after the \u. -func (l *lexer) scanUnicodeLiteral() error { - // scan the digits - d := make([]rune, 4) - for i := 0; i < 4; i++ { - d[i] = l.next() - if d[i] == eof || !strings.ContainsRune("0123456789abcdefABCDEF", d[i]) { - return fmt.Errorf("invalid unicode literal") - } - } - - // decode the digits into a rune - r, err := strconv.ParseInt(string(d), 16, 0) - if err != nil { - return err - } - - l.appendRune(rune(r)) - return nil -} - -// decodeEscapedCharacter returns the unescaped rune. We expect to be after the escape character. -func decodeEscapedCharacter(r rune) rune { - switch r { - case 'f': - return '\f' - case 'n': - return '\n' - case 'r': - return '\r' - case 't': - return '\t' - default: - return r - } -} - -// atUnicodeLiteral reports whether we are at a unicode literal. -// The escape character has already been consumed. -func atUnicodeLiteral(r rune) bool { - return r == 'u' -} - -// isComment reports whether we are at the start of a comment. -func isComment(r rune) bool { - return r == '#' || r == '!' -} - -// isEndOfKey reports whether the rune terminates the current key. -func isEndOfKey(r rune) bool { - return strings.ContainsRune(" \f\t\r\n:=", r) -} - -// isEOF reports whether we are at EOF. -func isEOF(r rune) bool { - return r == eof -} - -// isEOL reports whether we are at a new line character. -func isEOL(r rune) bool { - return r == '\n' || r == '\r' -} - -// isEscape reports whether the rune is the escape character which -// prefixes unicode literals and other escaped characters. -func isEscape(r rune) bool { - return r == '\\' -} - -// isEscapedCharacter reports whether we are at one of the characters that need escaping. -// The escape character has already been consumed. -func isEscapedCharacter(r rune) bool { - return strings.ContainsRune(" :=fnrt", r) -} - -// isWhitespace reports whether the rune is a whitespace character. -func isWhitespace(r rune) bool { - return strings.ContainsRune(whitespace, r) -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/load.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/load.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/load.go deleted file mode 100644 index 431d462..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/load.go +++ /dev/null @@ -1,124 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "fmt" - "io/ioutil" - "os" -) - -// Encoding specifies encoding of the input data. -type Encoding uint - -const ( - // UTF8 interprets the input data as UTF-8. - UTF8 Encoding = 1 << iota - - // ISO_8859_1 interprets the input data as ISO-8859-1. - ISO_8859_1 -) - -// Load reads a buffer into a Properties struct. -func Load(buf []byte, enc Encoding) (*Properties, error) { - return loadBuf(buf, enc) -} - -// LoadFile reads a file into a Properties struct. -func LoadFile(filename string, enc Encoding) (*Properties, error) { - return loadFiles([]string{filename}, enc, false) -} - -// LoadFiles reads multiple files in the given order into -// a Properties struct. If 'ignoreMissing' is true then -// non-existent files will not be reported as error. -func LoadFiles(filenames []string, enc Encoding, ignoreMissing bool) (*Properties, error) { - return loadFiles(filenames, enc, ignoreMissing) -} - -// MustLoadFile reads a file into a Properties struct and -// panics on error. -func MustLoadFile(filename string, enc Encoding) *Properties { - return mustLoadFiles([]string{filename}, enc, false) -} - -// MustLoadFiles reads multiple files in the given order into -// a Properties struct and panics on error. If 'ignoreMissing' -// is true then non-existent files will not be reported as error. -func MustLoadFiles(filenames []string, enc Encoding, ignoreMissing bool) *Properties { - return mustLoadFiles(filenames, enc, ignoreMissing) -} - -// ---------------------------------------------------------------------------- - -func loadBuf(buf []byte, enc Encoding) (*Properties, error) { - p, err := parse(convert(buf, enc)) - if err != nil { - return nil, err - } - - return p, p.check() -} - -func loadFiles(filenames []string, enc Encoding, ignoreMissing bool) (*Properties, error) { - buff := make([]byte, 0, 4096) - - for _, filename := range filenames { - f, err := expandFilename(filename) - if err != nil { - return nil, err - } - - buf, err := ioutil.ReadFile(f) - if err != nil { - if ignoreMissing && os.IsNotExist(err) { - // TODO(frank): should we log that we are skipping the file? - continue - } - return nil, err - } - - // concatenate the buffers and add a new line in case - // the previous file didn't end with a new line - buff = append(append(buff, buf...), '\n') - } - - return loadBuf(buff, enc) -} - -func mustLoadFiles(filenames []string, enc Encoding, ignoreMissing bool) *Properties { - p, err := loadFiles(filenames, enc, ignoreMissing) - if err != nil { - ErrorHandler(err) - } - return p -} - -// expandFilename expands ${ENV_VAR} expressions in a filename. -// If the environment variable does not exist then it will be replaced -// with an empty string. Malformed expressions like "${ENV_VAR" will -// be reported as error. -func expandFilename(filename string) (string, error) { - return expand(filename, make(map[string]bool), "${", "}", make(map[string]string)) -} - -// Interprets a byte buffer either as an ISO-8859-1 or UTF-8 encoded string. -// For ISO-8859-1 we can convert each byte straight into a rune since the -// first 256 unicode code points cover ISO-8859-1. -func convert(buf []byte, enc Encoding) string { - switch enc { - case UTF8: - return string(buf) - case ISO_8859_1: - runes := make([]rune, len(buf)) - for i, b := range buf { - runes[i] = rune(b) - } - return string(runes) - default: - ErrorHandler(fmt.Errorf("unsupported encoding %v", enc)) - } - panic("ErrorHandler should exit") -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/load_test.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/load_test.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/load_test.go deleted file mode 100644 index e6dae8d..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/load_test.go +++ /dev/null @@ -1,137 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "fmt" - "io/ioutil" - "os" - "strings" - - . "github.com/magiconair/properties/_third_party/gopkg.in/check.v1" -) - -type LoadSuite struct { - tempFiles []string -} - -var ( - _ = Suite(&LoadSuite{}) -) - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadFailsWithNotExistingFile(c *C) { - _, err := LoadFile("doesnotexist.properties", ISO_8859_1) - c.Assert(err, NotNil) - c.Assert(err, ErrorMatches, "open.*no such file or directory") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadFilesFailsOnNotExistingFile(c *C) { - _, err := LoadFiles([]string{"doesnotexist.properties"}, ISO_8859_1, false) - c.Assert(err, NotNil) - c.Assert(err, ErrorMatches, "open.*no such file or directory") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadFilesDoesNotFailOnNotExistingFileAndIgnoreMissing(c *C) { - p, err := LoadFiles([]string{"doesnotexist.properties"}, ISO_8859_1, true) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 0) -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoad(c *C) { - filename := s.makeFile(c, "key=value") - p := MustLoadFile(filename, ISO_8859_1) - - c.Assert(p.Len(), Equals, 1) - assertKeyValues(c, "", p, "key", "value") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadFiles(c *C) { - filename := s.makeFile(c, "key=value") - filename2 := s.makeFile(c, "key2=value2") - p := MustLoadFiles([]string{filename, filename2}, ISO_8859_1, false) - assertKeyValues(c, "", p, "key", "value", "key2", "value2") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadExpandedFile(c *C) { - filename := s.makeFilePrefix(c, os.Getenv("USER"), "key=value") - filename = strings.Replace(filename, os.Getenv("USER"), "${USER}", -1) - p := MustLoadFile(filename, ISO_8859_1) - assertKeyValues(c, "", p, "key", "value") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TestLoadFilesAndIgnoreMissing(c *C) { - filename := s.makeFile(c, "key=value") - filename2 := s.makeFile(c, "key2=value2") - p := MustLoadFiles([]string{filename, filename + "foo", filename2, filename2 + "foo"}, ISO_8859_1, true) - assertKeyValues(c, "", p, "key", "value", "key2", "value2") -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) SetUpSuite(c *C) { - s.tempFiles = make([]string, 0) -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) TearDownSuite(c *C) { - for _, path := range s.tempFiles { - err := os.Remove(path) - if err != nil { - fmt.Printf("os.Remove: %v", err) - } - } -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) makeFile(c *C, data string) string { - return s.makeFilePrefix(c, "properties", data) -} - -// ---------------------------------------------------------------------------- - -func (s *LoadSuite) makeFilePrefix(c *C, prefix, data string) string { - f, err := ioutil.TempFile("", prefix) - if err != nil { - fmt.Printf("ioutil.TempFile: %v", err) - c.FailNow() - } - - // remember the temp file so that we can remove it later - s.tempFiles = append(s.tempFiles, f.Name()) - - n, err := fmt.Fprint(f, data) - if err != nil { - fmt.Printf("fmt.Fprintln: %v", err) - c.FailNow() - } - if n != len(data) { - fmt.Printf("Data size mismatch. expected=%d wrote=%d\n", len(data), n) - c.FailNow() - } - - err = f.Close() - if err != nil { - fmt.Printf("f.Close: %v", err) - c.FailNow() - } - - return f.Name() -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/parser.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/parser.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/parser.go deleted file mode 100644 index bb71fb9..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/parser.go +++ /dev/null @@ -1,95 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "fmt" - "runtime" -) - -type parser struct { - lex *lexer -} - -func parse(input string) (properties *Properties, err error) { - p := &parser{lex: lex(input)} - defer p.recover(&err) - - properties = NewProperties() - key := "" - comments := []string{} - - for { - token := p.expectOneOf(itemComment, itemKey, itemEOF) - switch token.typ { - case itemEOF: - goto done - case itemComment: - comments = append(comments, token.val) - continue - case itemKey: - key = token.val - if _, ok := properties.m[key]; !ok { - properties.k = append(properties.k, key) - } - } - - token = p.expectOneOf(itemValue, itemEOF) - if len(comments) > 0 { - properties.c[key] = comments - comments = []string{} - } - switch token.typ { - case itemEOF: - properties.m[key] = "" - goto done - case itemValue: - properties.m[key] = token.val - } - } - -done: - return properties, nil -} - -func (p *parser) errorf(format string, args ...interface{}) { - format = fmt.Sprintf("properties: Line %d: %s", p.lex.lineNumber(), format) - panic(fmt.Errorf(format, args...)) -} - -func (p *parser) expect(expected itemType) (token item) { - token = p.lex.nextItem() - if token.typ != expected { - p.unexpected(token) - } - return token -} - -func (p *parser) expectOneOf(expected ...itemType) (token item) { - token = p.lex.nextItem() - for _, v := range expected { - if token.typ == v { - return token - } - } - p.unexpected(token) - panic("unexpected token") -} - -func (p *parser) unexpected(token item) { - p.errorf(token.String()) -} - -// recover is the handler that turns panics into returns from the top level of Parse. -func (p *parser) recover(errp *error) { - e := recover() - if e != nil { - if _, ok := e.(runtime.Error); ok { - panic(e) - } - *errp = e.(error) - } - return -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties.go deleted file mode 100644 index bd5cba1..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties.go +++ /dev/null @@ -1,746 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -// BUG(frank): Set() does not check for invalid unicode literals since this is currently handled by the lexer. -// BUG(frank): Write() does not allow to configure the newline character. Therefore, on Windows LF is used. - -import ( - "fmt" - "io" - "log" - "os" - "regexp" - "strconv" - "strings" - "time" - "unicode/utf8" -) - -// ErrorHandlerFunc defines the type of function which handles failures -// of the MustXXX() functions. An error handler function must exit -// the application after handling the error. -type ErrorHandlerFunc func(error) - -// ErrorHandler is the function which handles failures of the MustXXX() -// functions. The default is LogFatalHandler. -var ErrorHandler = LogFatalHandler - -// LogFatalHandler handles the error by logging a fatal error and exiting. -func LogFatalHandler(err error) { - log.Fatal(err) -} - -// PanicHandler handles the error by panicking. -func PanicHandler(err error) { - panic(err) -} - -// ----------------------------------------------------------------------------- - -// A Properties contains the key/value pairs from the properties input. -// All values are stored in unexpanded form and are expanded at runtime -type Properties struct { - // Pre-/Postfix for property expansion. - Prefix string - Postfix string - - // DisableExpansion controls the expansion of properties on Get() - // and the check for circular references on Set(). When set to - // true Properties behaves like a simple key/value store and does - // not check for circular references on Get() or on Set(). - DisableExpansion bool - - // Stores the key/value pairs - m map[string]string - - // Stores the comments per key. - c map[string][]string - - // Stores the keys in order of appearance. - k []string -} - -// NewProperties creates a new Properties struct with the default -// configuration for "${key}" expressions. -func NewProperties() *Properties { - return &Properties{ - Prefix: "${", - Postfix: "}", - m: map[string]string{}, - c: map[string][]string{}, - k: []string{}, - } -} - -// Get returns the expanded value for the given key if exists. -// Otherwise, ok is false. -func (p *Properties) Get(key string) (value string, ok bool) { - v, ok := p.m[key] - if p.DisableExpansion { - return v, ok - } - if !ok { - return "", false - } - - expanded, err := p.expand(v) - - // we guarantee that the expanded value is free of - // circular references and malformed expressions - // so we panic if we still get an error here. - if err != nil { - ErrorHandler(fmt.Errorf("%s in %q", err, key+" = "+v)) - } - - return expanded, true -} - -// MustGet returns the expanded value for the given key if exists. -// Otherwise, it panics. -func (p *Properties) MustGet(key string) string { - if v, ok := p.Get(key); ok { - return v - } - ErrorHandler(invalidKeyError(key)) - panic("ErrorHandler should exit") -} - -// ---------------------------------------------------------------------------- - -// ClearComments removes the comments for all keys. -func (p *Properties) ClearComments() { - p.c = map[string][]string{} -} - -// ---------------------------------------------------------------------------- - -// GetComment returns the last comment before the given key or an empty string. -func (p *Properties) GetComment(key string) string { - comments, ok := p.c[key] - if !ok || len(comments) == 0 { - return "" - } - return comments[len(comments)-1] -} - -// ---------------------------------------------------------------------------- - -// GetComments returns all comments that appeared before the given key or nil. -func (p *Properties) GetComments(key string) []string { - if comments, ok := p.c[key]; ok { - return comments - } - return nil -} - -// ---------------------------------------------------------------------------- - -// SetComment sets the comment for the key. -func (p *Properties) SetComment(key, comment string) { - p.c[key] = []string{comment} -} - -// ---------------------------------------------------------------------------- - -// SetComments sets the comments for the key. If the comments are nil then -// all comments for this key are deleted. -func (p *Properties) SetComments(key string, comments []string) { - if comments == nil { - delete(p.c, key) - return - } - p.c[key] = comments -} - -// ---------------------------------------------------------------------------- - -// GetBool checks if the expanded value is one of '1', 'yes', -// 'true' or 'on' if the key exists. The comparison is case-insensitive. -// If the key does not exist the default value is returned. -func (p *Properties) GetBool(key string, def bool) bool { - v, err := p.getBool(key) - if err != nil { - return def - } - return v -} - -// MustGetBool checks if the expanded value is one of '1', 'yes', -// 'true' or 'on' if the key exists. The comparison is case-insensitive. -// If the key does not exist the function panics. -func (p *Properties) MustGetBool(key string) bool { - v, err := p.getBool(key) - if err != nil { - ErrorHandler(err) - } - return v -} - -func (p *Properties) getBool(key string) (value bool, err error) { - if v, ok := p.Get(key); ok { - return boolVal(v), nil - } - return false, invalidKeyError(key) -} - -func boolVal(v string) bool { - v = strings.ToLower(v) - return v == "1" || v == "true" || v == "yes" || v == "on" -} - -// ---------------------------------------------------------------------------- - -// GetDuration parses the expanded value as an time.Duration (in ns) if the -// key exists. If key does not exist or the value cannot be parsed the default -// value is returned. In almost all cases you want to use GetParsedDuration(). -func (p *Properties) GetDuration(key string, def time.Duration) time.Duration { - v, err := p.getInt64(key) - if err != nil { - return def - } - return time.Duration(v) -} - -// MustGetDuration parses the expanded value as an time.Duration (in ns) if -// the key exists. If key does not exist or the value cannot be parsed the -// function panics. In almost all cases you want to use MustGetParsedDuration(). -func (p *Properties) MustGetDuration(key string) time.Duration { - v, err := p.getInt64(key) - if err != nil { - ErrorHandler(err) - } - return time.Duration(v) -} - -// ---------------------------------------------------------------------------- - -// GetParsedDuration parses the expanded value with time.ParseDuration() if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. -func (p *Properties) GetParsedDuration(key string, def time.Duration) time.Duration { - s, ok := p.Get(key) - if !ok { - return def - } - v, err := time.ParseDuration(s) - if err != nil { - return def - } - return v -} - -// MustGetParsedDuration parses the expanded value with time.ParseDuration() if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -func (p *Properties) MustGetParsedDuration(key string) time.Duration { - s, ok := p.Get(key) - if !ok { - ErrorHandler(invalidKeyError(key)) - } - v, err := time.ParseDuration(s) - if err != nil { - ErrorHandler(err) - } - return v -} - -// ---------------------------------------------------------------------------- - -// GetFloat64 parses the expanded value as a float64 if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. -func (p *Properties) GetFloat64(key string, def float64) float64 { - v, err := p.getFloat64(key) - if err != nil { - return def - } - return v -} - -// MustGetFloat64 parses the expanded value as a float64 if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -func (p *Properties) MustGetFloat64(key string) float64 { - v, err := p.getFloat64(key) - if err != nil { - ErrorHandler(err) - } - return v -} - -func (p *Properties) getFloat64(key string) (value float64, err error) { - if v, ok := p.Get(key); ok { - value, err = strconv.ParseFloat(v, 64) - if err != nil { - return 0, err - } - return value, nil - } - return 0, invalidKeyError(key) -} - -// ---------------------------------------------------------------------------- - -// GetInt parses the expanded value as an int if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. If the value does not fit into an int the -// function panics with an out of range error. -func (p *Properties) GetInt(key string, def int) int { - v, err := p.getInt64(key) - if err != nil { - return def - } - return intRangeCheck(key, v) -} - -// MustGetInt parses the expanded value as an int if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -// If the value does not fit into an int the function panics with -// an out of range error. -func (p *Properties) MustGetInt(key string) int { - v, err := p.getInt64(key) - if err != nil { - ErrorHandler(err) - } - return intRangeCheck(key, v) -} - -// ---------------------------------------------------------------------------- - -// GetInt64 parses the expanded value as an int64 if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. -func (p *Properties) GetInt64(key string, def int64) int64 { - v, err := p.getInt64(key) - if err != nil { - return def - } - return v -} - -// MustGetInt64 parses the expanded value as an int if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -func (p *Properties) MustGetInt64(key string) int64 { - v, err := p.getInt64(key) - if err != nil { - ErrorHandler(err) - } - return v -} - -func (p *Properties) getInt64(key string) (value int64, err error) { - if v, ok := p.Get(key); ok { - value, err = strconv.ParseInt(v, 10, 64) - if err != nil { - return 0, err - } - return value, nil - } - return 0, invalidKeyError(key) -} - -// ---------------------------------------------------------------------------- - -// GetUint parses the expanded value as an uint if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. If the value does not fit into an int the -// function panics with an out of range error. -func (p *Properties) GetUint(key string, def uint) uint { - v, err := p.getUint64(key) - if err != nil { - return def - } - return uintRangeCheck(key, v) -} - -// MustGetUint parses the expanded value as an int if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -// If the value does not fit into an int the function panics with -// an out of range error. -func (p *Properties) MustGetUint(key string) uint { - v, err := p.getUint64(key) - if err != nil { - ErrorHandler(err) - } - return uintRangeCheck(key, v) -} - -// ---------------------------------------------------------------------------- - -// GetUint64 parses the expanded value as an uint64 if the key exists. -// If key does not exist or the value cannot be parsed the default -// value is returned. -func (p *Properties) GetUint64(key string, def uint64) uint64 { - v, err := p.getUint64(key) - if err != nil { - return def - } - return v -} - -// MustGetUint64 parses the expanded value as an int if the key exists. -// If key does not exist or the value cannot be parsed the function panics. -func (p *Properties) MustGetUint64(key string) uint64 { - v, err := p.getUint64(key) - if err != nil { - ErrorHandler(err) - } - return v -} - -func (p *Properties) getUint64(key string) (value uint64, err error) { - if v, ok := p.Get(key); ok { - value, err = strconv.ParseUint(v, 10, 64) - if err != nil { - return 0, err - } - return value, nil - } - return 0, invalidKeyError(key) -} - -// ---------------------------------------------------------------------------- - -// GetString returns the expanded value for the given key if exists or -// the default value otherwise. -func (p *Properties) GetString(key, def string) string { - if v, ok := p.Get(key); ok { - return v - } - return def -} - -// MustGetString returns the expanded value for the given key if exists or -// panics otherwise. -func (p *Properties) MustGetString(key string) string { - if v, ok := p.Get(key); ok { - return v - } - ErrorHandler(invalidKeyError(key)) - panic("ErrorHandler should exit") -} - -// ---------------------------------------------------------------------------- - -// Filter returns a new properties object which contains all properties -// for which the key matches the pattern. -func (p *Properties) Filter(pattern string) (*Properties, error) { - re, err := regexp.Compile(pattern) - if err != nil { - return nil, err - } - - return p.FilterRegexp(re), nil -} - -// FilterRegexp returns a new properties object which contains all properties -// for which the key matches the regular expression. -func (p *Properties) FilterRegexp(re *regexp.Regexp) *Properties { - pp := NewProperties() - for _, k := range p.k { - if re.MatchString(k) { - pp.Set(k, p.m[k]) - } - } - return pp -} - -// FilterPrefix returns a new properties object with a subset of all keys -// with the given prefix. -func (p *Properties) FilterPrefix(prefix string) *Properties { - pp := NewProperties() - for _, k := range p.k { - if strings.HasPrefix(k, prefix) { - pp.Set(k, p.m[k]) - } - } - return pp -} - -// FilterStripPrefix returns a new properties object with a subset of all keys -// with the given prefix and the prefix removed from the keys. -func (p *Properties) FilterStripPrefix(prefix string) *Properties { - pp := NewProperties() - n := len(prefix) - for _, k := range p.k { - if len(k) > len(prefix) && strings.HasPrefix(k, prefix) { - pp.Set(k[n:], p.m[k]) - } - } - return pp -} - -// Len returns the number of keys. -func (p *Properties) Len() int { - return len(p.m) -} - -// Keys returns all keys in the same order as in the input. -func (p *Properties) Keys() []string { - keys := make([]string, len(p.k)) - for i, k := range p.k { - keys[i] = k - } - return keys -} - -// Set sets the property key to the corresponding value. -// If a value for key existed before then ok is true and prev -// contains the previous value. If the value contains a -// circular reference or a malformed expression then -// an error is returned. -// An empty key is silently ignored. -func (p *Properties) Set(key, value string) (prev string, ok bool, err error) { - if key == "" { - return "", false, nil - } - - // if expansion is disabled we allow circular references - if p.DisableExpansion { - prev, ok = p.Get(key) - p.m[key] = value - return prev, ok, nil - } - - // to check for a circular reference we temporarily need - // to set the new value. If there is an error then revert - // to the previous state. Only if all tests are successful - // then we add the key to the p.k list. - prev, ok = p.Get(key) - p.m[key] = value - - // now check for a circular reference - _, err = p.expand(value) - if err != nil { - - // revert to the previous state - if ok { - p.m[key] = prev - } else { - delete(p.m, key) - } - - return "", false, err - } - - if !ok { - p.k = append(p.k, key) - } - - return prev, ok, nil -} - -// MustSet sets the property key to the corresponding value. -// If a value for key existed before then ok is true and prev -// contains the previous value. An empty key is silently ignored. -func (p *Properties) MustSet(key, value string) (prev string, ok bool) { - prev, ok, err := p.Set(key, value) - if err != nil { - ErrorHandler(err) - } - return prev, ok -} - -// String returns a string of all expanded 'key = value' pairs. -func (p *Properties) String() string { - var s string - for _, key := range p.k { - value, _ := p.Get(key) - s = fmt.Sprintf("%s%s = %s\n", s, key, value) - } - return s -} - -// Write writes all unexpanded 'key = value' pairs to the given writer. -// Write returns the number of bytes written and any write error encountered. -func (p *Properties) Write(w io.Writer, enc Encoding) (n int, err error) { - return p.WriteComment(w, "", enc) -} - -// WriteComment writes all unexpanced 'key = value' pairs to the given writer. -// If prefix is not empty then comments are written with a blank line and the -// given prefix. The prefix should be either "# " or "! " to be compatible with -// the properties file format. Otherwise, the properties parser will not be -// able to read the file back in. It returns the number of bytes written and -// any write error encountered. -func (p *Properties) WriteComment(w io.Writer, prefix string, enc Encoding) (n int, err error) { - var x int - - for _, key := range p.k { - value := p.m[key] - - if prefix != "" { - if comments, ok := p.c[key]; ok { - // don't print comments if they are all empty - allEmpty := true - for _, c := range comments { - if c != "" { - allEmpty = false - break - } - } - - if !allEmpty { - // add a blank line between entries but not at the top - if len(comments) > 0 && n > 0 { - x, err = fmt.Fprintln(w) - if err != nil { - return - } - n += x - } - - for _, c := range comments { - x, err = fmt.Fprintf(w, "%s%s\n", prefix, encode(c, "", enc)) - if err != nil { - return - } - n += x - } - } - } - } - - x, err = fmt.Fprintf(w, "%s = %s\n", encode(key, " :", enc), encode(value, "", enc)) - if err != nil { - return - } - n += x - } - return -} - -// ---------------------------------------------------------------------------- - -// Delete removes the key and its comments. -func (p *Properties) Delete(key string) { - delete(p.m, key) - delete(p.c, key) - newKeys := []string{} - for _, k := range p.k { - if k != key { - newKeys = append(newKeys, key) - } - } - p.k = newKeys -} - -// ---------------------------------------------------------------------------- - -// check expands all values and returns an error if a circular reference or -// a malformed expression was found. -func (p *Properties) check() error { - for _, value := range p.m { - if _, err := p.expand(value); err != nil { - return err - } - } - return nil -} - -func (p *Properties) expand(input string) (string, error) { - // no pre/postfix -> nothing to expand - if p.Prefix == "" && p.Postfix == "" { - return input, nil - } - - return expand(input, make(map[string]bool), p.Prefix, p.Postfix, p.m) -} - -// expand recursively expands expressions of '(prefix)key(postfix)' to their corresponding values. -// The function keeps track of the keys that were already expanded and stops if it -// detects a circular reference or a malformed expression of the form '(prefix)key'. -func expand(s string, keys map[string]bool, prefix, postfix string, values map[string]string) (string, error) { - start := strings.Index(s, prefix) - if start == -1 { - return s, nil - } - - keyStart := start + len(prefix) - keyLen := strings.Index(s[keyStart:], postfix) - if keyLen == -1 { - return "", fmt.Errorf("malformed expression") - } - - end := keyStart + keyLen + len(postfix) - 1 - key := s[keyStart : keyStart+keyLen] - - // fmt.Printf("s:%q pp:%q start:%d end:%d keyStart:%d keyLen:%d key:%q\n", s, prefix + "..." + postfix, start, end, keyStart, keyLen, key) - - if _, ok := keys[key]; ok { - return "", fmt.Errorf("circular reference") - } - - val, ok := values[key] - if !ok { - val = os.Getenv(key) - } - - // remember that we've seen the key - keys[key] = true - - return expand(s[:start]+val+s[end+1:], keys, prefix, postfix, values) -} - -// encode encodes a UTF-8 string to ISO-8859-1 and escapes some characters. -func encode(s string, special string, enc Encoding) string { - switch enc { - case UTF8: - return encodeUtf8(s, special) - case ISO_8859_1: - return encodeIso(s, special) - default: - panic(fmt.Sprintf("unsupported encoding %v", enc)) - } -} - -func encodeUtf8(s string, special string) string { - v := "" - for pos := 0; pos < len(s); { - r, w := utf8.DecodeRuneInString(s[pos:]) - pos += w - v += escape(r, special) - } - return v -} - -func encodeIso(s string, special string) string { - var r rune - var w int - var v string - for pos := 0; pos < len(s); { - switch r, w = utf8.DecodeRuneInString(s[pos:]); { - case r < 1<<8: // single byte rune -> escape special chars only - v += escape(r, special) - case r < 1<<16: // two byte rune -> unicode literal - v += fmt.Sprintf("\\u%04x", r) - default: // more than two bytes per rune -> can't encode - v += "?" - } - pos += w - } - return v -} - -func escape(r rune, special string) string { - switch r { - case '\f': - return "\\f" - case '\n': - return "\\n" - case '\r': - return "\\r" - case '\t': - return "\\t" - default: - if strings.ContainsRune(special, r) { - return "\\" + string(r) - } - return string(r) - } -} - -func invalidKeyError(key string) error { - return fmt.Errorf("unknown property: %s", key) -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go deleted file mode 100644 index dc74385..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go +++ /dev/null @@ -1,906 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "bytes" - "flag" - "fmt" - "math" - "os" - "strings" - "testing" - "time" - - . "github.com/magiconair/properties/_third_party/gopkg.in/check.v1" -) - -func Test(t *testing.T) { TestingT(t) } - -type TestSuite struct { - prevHandler ErrorHandlerFunc -} - -var ( - _ = Suite(&TestSuite{}) - verbose = flag.Bool("verbose", false, "Verbose output") -) - -// -------------------------------------------------------------------- - -func (s *TestSuite) SetUpSuite(c *C) { - s.prevHandler = ErrorHandler - ErrorHandler = PanicHandler -} - -// -------------------------------------------------------------------- - -func (s *TestSuite) TearDownSuite(c *C) { - ErrorHandler = s.prevHandler -} - -// ---------------------------------------------------------------------------- - -// define test cases in the form of -// {"input", "key1", "value1", "key2", "value2", ...} -var complexTests = [][]string{ - // whitespace prefix - {" key=value", "key", "value"}, // SPACE prefix - {"\fkey=value", "key", "value"}, // FF prefix - {"\tkey=value", "key", "value"}, // TAB prefix - {" \f\tkey=value", "key", "value"}, // mix prefix - - // multiple keys - {"key1=value1\nkey2=value2\n", "key1", "value1", "key2", "value2"}, - {"key1=value1\rkey2=value2\r", "key1", "value1", "key2", "value2"}, - {"key1=value1\r\nkey2=value2\r\n", "key1", "value1", "key2", "value2"}, - - // blank lines - {"\nkey=value\n", "key", "value"}, - {"\rkey=value\r", "key", "value"}, - {"\r\nkey=value\r\n", "key", "value"}, - - // escaped chars in key - {"k\\ ey = value", "k ey", "value"}, - {"k\\:ey = value", "k:ey", "value"}, - {"k\\=ey = value", "k=ey", "value"}, - {"k\\fey = value", "k\fey", "value"}, - {"k\\ney = value", "k\ney", "value"}, - {"k\\rey = value", "k\rey", "value"}, - {"k\\tey = value", "k\tey", "value"}, - - // escaped chars in value - {"key = v\\ alue", "key", "v alue"}, - {"key = v\\:alue", "key", "v:alue"}, - {"key = v\\=alue", "key", "v=alue"}, - {"key = v\\falue", "key", "v\falue"}, - {"key = v\\nalue", "key", "v\nalue"}, - {"key = v\\ralue", "key", "v\ralue"}, - {"key = v\\talue", "key", "v\talue"}, - - // silently dropped escape character - {"k\\zey = value", "kzey", "value"}, - {"key = v\\zalue", "key", "vzalue"}, - - // unicode literals - {"key\\u2318 = value", "keyâ", "value"}, - {"k\\u2318ey = value", "kâey", "value"}, - {"key = value\\u2318", "key", "valueâ"}, - {"key = valu\\u2318e", "key", "valuâe"}, - - // multiline values - {"key = valueA,\\\n valueB", "key", "valueA,valueB"}, // SPACE indent - {"key = valueA,\\\n\f\f\fvalueB", "key", "valueA,valueB"}, // FF indent - {"key = valueA,\\\n\t\t\tvalueB", "key", "valueA,valueB"}, // TAB indent - {"key = valueA,\\\n \f\tvalueB", "key", "valueA,valueB"}, // mix indent - - // comments - {"# this is a comment\n! and so is this\nkey1=value1\nkey#2=value#2\n\nkey!3=value!3\n# and another one\n! and the final one", "key1", "value1", "key#2", "value#2", "key!3", "value!3"}, - - // expansion tests - {"key=value\nkey2=${key}", "key", "value", "key2", "value"}, - {"key=value\nkey2=aa${key}", "key", "value", "key2", "aavalue"}, - {"key=value\nkey2=${key}bb", "key", "value", "key2", "valuebb"}, - {"key=value\nkey2=aa${key}bb", "key", "value", "key2", "aavaluebb"}, - {"key=value\nkey2=${key}\nkey3=${key2}", "key", "value", "key2", "value", "key3", "value"}, - {"key=${USER}", "key", os.Getenv("USER")}, - {"key=${USER}\nUSER=value", "key", "value", "USER", "value"}, -} - -// ---------------------------------------------------------------------------- - -var commentTests = []struct { - input, key, value string - comments []string -}{ - {"key=value", "key", "value", nil}, - {"#\nkey=value", "key", "value", []string{""}}, - {"#comment\nkey=value", "key", "value", []string{"comment"}}, - {"# comment\nkey=value", "key", "value", []string{"comment"}}, - {"# comment\nkey=value", "key", "value", []string{"comment"}}, - {"# comment\n\nkey=value", "key", "value", []string{"comment"}}, - {"# comment1\n# comment2\nkey=value", "key", "value", []string{"comment1", "comment2"}}, - {"# comment1\n\n# comment2\n\nkey=value", "key", "value", []string{"comment1", "comment2"}}, - {"!comment\nkey=value", "key", "value", []string{"comment"}}, - {"! comment\nkey=value", "key", "value", []string{"comment"}}, - {"! comment\nkey=value", "key", "value", []string{"comment"}}, - {"! comment\n\nkey=value", "key", "value", []string{"comment"}}, - {"! comment1\n! comment2\nkey=value", "key", "value", []string{"comment1", "comment2"}}, - {"! comment1\n\n! comment2\n\nkey=value", "key", "value", []string{"comment1", "comment2"}}, -} - -// ---------------------------------------------------------------------------- - -var errorTests = []struct { - input, msg string -}{ - // unicode literals - {"key\\u1 = value", "invalid unicode literal"}, - {"key\\u12 = value", "invalid unicode literal"}, - {"key\\u123 = value", "invalid unicode literal"}, - {"key\\u123g = value", "invalid unicode literal"}, - {"key\\u123", "invalid unicode literal"}, - - // circular references - {"key=${key}", "circular reference"}, - {"key1=${key2}\nkey2=${key1}", "circular reference"}, - - // malformed expressions - {"key=${ke", "malformed expression"}, - {"key=valu${ke", "malformed expression"}, -} - -// ---------------------------------------------------------------------------- - -var writeTests = []struct { - input, output, encoding string -}{ - // ISO-8859-1 tests - {"key = value", "key = value\n", "ISO-8859-1"}, - {"key = value \\\n continued", "key = value continued\n", "ISO-8859-1"}, - {"keyâ = value", "key\\u2318 = value\n", "ISO-8859-1"}, - {"ke\\ \\:y = value", "ke\\ \\:y = value\n", "ISO-8859-1"}, - - // UTF-8 tests - {"key = value", "key = value\n", "UTF-8"}, - {"key = value \\\n continued", "key = value continued\n", "UTF-8"}, - {"keyâ = valueâ", "keyâ = valueâ\n", "UTF-8"}, - {"ke\\ \\:y = value", "ke\\ \\:y = value\n", "UTF-8"}, -} - -// ---------------------------------------------------------------------------- - -var writeCommentTests = []struct { - input, output, encoding string -}{ - // ISO-8859-1 tests - {"key = value", "key = value\n", "ISO-8859-1"}, - {"#\nkey = value", "key = value\n", "ISO-8859-1"}, - {"#\n#\n#\nkey = value", "key = value\n", "ISO-8859-1"}, - {"# comment\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"}, - {"\n# comment\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"}, - {"# comment\n\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"}, - {"# comment1\n# comment2\nkey = value", "# comment1\n# comment2\nkey = value\n", "ISO-8859-1"}, - {"#comment1\nkey1 = value1\n#comment2\nkey2 = value2", "# comment1\nkey1 = value1\n\n# comment2\nkey2 = value2\n", "ISO-8859-1"}, - - // UTF-8 tests - {"key = value", "key = value\n", "UTF-8"}, - {"# commentâ\nkey = valueâ", "# commentâ\nkey = valueâ\n", "UTF-8"}, - {"\n# commentâ\nkey = valueâ", "# commentâ\nkey = valueâ\n", "UTF-8"}, - {"# commentâ\n\nkey = valueâ", "# commentâ\nkey = valueâ\n", "UTF-8"}, - {"# comment1â\n# comment2â\nkey = valueâ", "# comment1â\n# comment2â\nkey = valueâ\n", "UTF-8"}, - {"#comment1â\nkey1 = value1â\n#comment2â\nkey2 = value2â", "# comment1â\nkey1 = value1â\n\n# comment2â\nkey2 = value2â\n", "UTF-8"}, -} - -// ---------------------------------------------------------------------------- - -var boolTests = []struct { - input, key string - def, value bool -}{ - // valid values for TRUE - {"key = 1", "key", false, true}, - {"key = on", "key", false, true}, - {"key = On", "key", false, true}, - {"key = ON", "key", false, true}, - {"key = true", "key", false, true}, - {"key = True", "key", false, true}, - {"key = TRUE", "key", false, true}, - {"key = yes", "key", false, true}, - {"key = Yes", "key", false, true}, - {"key = YES", "key", false, true}, - - // valid values for FALSE (all other) - {"key = 0", "key", true, false}, - {"key = off", "key", true, false}, - {"key = false", "key", true, false}, - {"key = no", "key", true, false}, - - // non existent key - {"key = true", "key2", false, false}, -} - -// ---------------------------------------------------------------------------- - -var durationTests = []struct { - input, key string - def, value time.Duration -}{ - // valid values - {"key = 1", "key", 999, 1}, - {"key = 0", "key", 999, 0}, - {"key = -1", "key", 999, -1}, - {"key = 0123", "key", 999, 123}, - - // invalid values - {"key = 0xff", "key", 999, 999}, - {"key = 1.0", "key", 999, 999}, - {"key = a", "key", 999, 999}, - - // non existent key - {"key = 1", "key2", 999, 999}, -} - -// ---------------------------------------------------------------------------- - -var parsedDurationTests = []struct { - input, key string - def, value time.Duration -}{ - // valid values - {"key = -1ns", "key", 999, -1 * time.Nanosecond}, - {"key = 300ms", "key", 999, 300 * time.Millisecond}, - {"key = 5s", "key", 999, 5 * time.Second}, - {"key = 3h", "key", 999, 3 * time.Hour}, - {"key = 2h45m", "key", 999, 2*time.Hour + 45*time.Minute}, - - // invalid values - {"key = 0xff", "key", 999, 999}, - {"key = 1.0", "key", 999, 999}, - {"key = a", "key", 999, 999}, - {"key = 1", "key", 999, 999}, - {"key = 0", "key", 999, 0}, - - // non existent key - {"key = 1", "key2", 999, 999}, -} - -// ---------------------------------------------------------------------------- - -var floatTests = []struct { - input, key string - def, value float64 -}{ - // valid values - {"key = 1.0", "key", 999, 1.0}, - {"key = 0.0", "key", 999, 0.0}, - {"key = -1.0", "key", 999, -1.0}, - {"key = 1", "key", 999, 1}, - {"key = 0", "key", 999, 0}, - {"key = -1", "key", 999, -1}, - {"key = 0123", "key", 999, 123}, - - // invalid values - {"key = 0xff", "key", 999, 999}, - {"key = a", "key", 999, 999}, - - // non existent key - {"key = 1", "key2", 999, 999}, -} - -// ---------------------------------------------------------------------------- - -var int64Tests = []struct { - input, key string - def, value int64 -}{ - // valid values - {"key = 1", "key", 999, 1}, - {"key = 0", "key", 999, 0}, - {"key = -1", "key", 999, -1}, - {"key = 0123", "key", 999, 123}, - - // invalid values - {"key = 0xff", "key", 999, 999}, - {"key = 1.0", "key", 999, 999}, - {"key = a", "key", 999, 999}, - - // non existent key - {"key = 1", "key2", 999, 999}, -} - -// ---------------------------------------------------------------------------- - -var uint64Tests = []struct { - input, key string - def, value uint64 -}{ - // valid values - {"key = 1", "key", 999, 1}, - {"key = 0", "key", 999, 0}, - {"key = 0123", "key", 999, 123}, - - // invalid values - {"key = -1", "key", 999, 999}, - {"key = 0xff", "key", 999, 999}, - {"key = 1.0", "key", 999, 999}, - {"key = a", "key", 999, 999}, - - // non existent key - {"key = 1", "key2", 999, 999}, -} - -// ---------------------------------------------------------------------------- - -var stringTests = []struct { - input, key string - def, value string -}{ - // valid values - {"key = abc", "key", "def", "abc"}, - - // non existent key - {"key = abc", "key2", "def", "def"}, -} - -// ---------------------------------------------------------------------------- - -var keysTests = []struct { - input string - keys []string -}{ - {"", []string{}}, - {"key = abc", []string{"key"}}, - {"key = abc\nkey2=def", []string{"key", "key2"}}, - {"key2 = abc\nkey=def", []string{"key2", "key"}}, - {"key = abc\nkey=def", []string{"key"}}, -} - -// ---------------------------------------------------------------------------- - -var filterTests = []struct { - input string - pattern string - keys []string - err string -}{ - {"", "", []string{}, ""}, - {"", "abc", []string{}, ""}, - {"key=value", "", []string{"key"}, ""}, - {"key=value", "key=", []string{}, ""}, - {"key=value\nfoo=bar", "", []string{"foo", "key"}, ""}, - {"key=value\nfoo=bar", "f", []string{"foo"}, ""}, - {"key=value\nfoo=bar", "fo", []string{"foo"}, ""}, - {"key=value\nfoo=bar", "foo", []string{"foo"}, ""}, - {"key=value\nfoo=bar", "fooo", []string{}, ""}, - {"key=value\nkey2=value2\nfoo=bar", "ey", []string{"key", "key2"}, ""}, - {"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}, ""}, - {"key=value\nkey2=value2\nfoo=bar", "^key", []string{"key", "key2"}, ""}, - {"key=value\nkey2=value2\nfoo=bar", "^(key|foo)", []string{"foo", "key", "key2"}, ""}, - {"key=value\nkey2=value2\nfoo=bar", "[ abc", nil, "error parsing regexp.*"}, -} - -// ---------------------------------------------------------------------------- - -var filterPrefixTests = []struct { - input string - prefix string - keys []string -}{ - {"", "", []string{}}, - {"", "abc", []string{}}, - {"key=value", "", []string{"key"}}, - {"key=value", "key=", []string{}}, - {"key=value\nfoo=bar", "", []string{"foo", "key"}}, - {"key=value\nfoo=bar", "f", []string{"foo"}}, - {"key=value\nfoo=bar", "fo", []string{"foo"}}, - {"key=value\nfoo=bar", "foo", []string{"foo"}}, - {"key=value\nfoo=bar", "fooo", []string{}}, - {"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}}, -} - -// ---------------------------------------------------------------------------- - -var filterStripPrefixTests = []struct { - input string - prefix string - keys []string -}{ - {"", "", []string{}}, - {"", "abc", []string{}}, - {"key=value", "", []string{"key"}}, - {"key=value", "key=", []string{}}, - {"key=value\nfoo=bar", "", []string{"foo", "key"}}, - {"key=value\nfoo=bar", "f", []string{"foo"}}, - {"key=value\nfoo=bar", "fo", []string{"foo"}}, - {"key=value\nfoo=bar", "foo", []string{"foo"}}, - {"key=value\nfoo=bar", "fooo", []string{}}, - {"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}}, -} - -// ---------------------------------------------------------------------------- - -var setTests = []struct { - input string - key, value string - prev string - ok bool - err string - keys []string -}{ - {"", "", "", "", false, "", []string{}}, - {"", "key", "value", "", false, "", []string{"key"}}, - {"key=value", "key2", "value2", "", false, "", []string{"key", "key2"}}, - {"key=value", "abc", "value3", "", false, "", []string{"key", "abc"}}, - {"key=value", "key", "value3", "value", true, "", []string{"key"}}, -} - -// ---------------------------------------------------------------------------- - -// TestBasic tests basic single key/value combinations with all possible -// whitespace, delimiter and newline permutations. -func (s *TestSuite) TestBasic(c *C) { - testWhitespaceAndDelimiterCombinations(c, "key", "") - testWhitespaceAndDelimiterCombinations(c, "key", "value") - testWhitespaceAndDelimiterCombinations(c, "key", "value ") -} - -func (s *TestSuite) TestComplex(c *C) { - for _, test := range complexTests { - testKeyValue(c, test[0], test[1:]...) - } -} - -func (s *TestSuite) TestErrors(c *C) { - for _, test := range errorTests { - _, err := Load([]byte(test.input), ISO_8859_1) - c.Assert(err, NotNil) - c.Assert(strings.Contains(err.Error(), test.msg), Equals, true, Commentf("Expected %q got %q", test.msg, err.Error())) - } -} - -func (s *TestSuite) TestDisableExpansion(c *C) { - input := "key=value\nkey2=${key}" - p, err := parse(input) - p.DisableExpansion = true - c.Assert(err, IsNil) - c.Assert(p.MustGet("key"), Equals, "value") - c.Assert(p.MustGet("key2"), Equals, "${key}") - - // with expansion disabled we can introduce circular references - p.Set("keyA", "${keyB}") - p.Set("keyB", "${keyA}") - c.Assert(p.MustGet("keyA"), Equals, "${keyB}") - c.Assert(p.MustGet("keyB"), Equals, "${keyA}") -} - -func (s *TestSuite) TestMustGet(c *C) { - input := "key = value\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGet("key"), Equals, "value") - c.Assert(func() { p.MustGet("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetBool(c *C) { - for _, test := range boolTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetBool(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetBool(c *C) { - input := "key = true\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetBool("key"), Equals, true) - c.Assert(func() { p.MustGetBool("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetDuration(c *C) { - for _, test := range durationTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetDuration(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetDuration(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetDuration("key"), Equals, time.Duration(123)) - c.Assert(func() { p.MustGetDuration("key2") }, PanicMatches, "strconv.ParseInt: parsing.*") - c.Assert(func() { p.MustGetDuration("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetParsedDuration(c *C) { - for _, test := range parsedDurationTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetParsedDuration(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetParsedDuration(c *C) { - input := "key = 123ms\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetParsedDuration("key"), Equals, 123*time.Millisecond) - c.Assert(func() { p.MustGetParsedDuration("key2") }, PanicMatches, "time: invalid duration ghi") - c.Assert(func() { p.MustGetParsedDuration("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetFloat64(c *C) { - for _, test := range floatTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetFloat64(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetFloat64(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetFloat64("key"), Equals, float64(123)) - c.Assert(func() { p.MustGetFloat64("key2") }, PanicMatches, "strconv.ParseFloat: parsing.*") - c.Assert(func() { p.MustGetFloat64("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetInt(c *C) { - for _, test := range int64Tests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetInt(test.key, int(test.def)), Equals, int(test.value)) - } -} - -func (s *TestSuite) TestMustGetInt(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetInt("key"), Equals, int(123)) - c.Assert(func() { p.MustGetInt("key2") }, PanicMatches, "strconv.ParseInt: parsing.*") - c.Assert(func() { p.MustGetInt("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetInt64(c *C) { - for _, test := range int64Tests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetInt64(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetInt64(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetInt64("key"), Equals, int64(123)) - c.Assert(func() { p.MustGetInt64("key2") }, PanicMatches, "strconv.ParseInt: parsing.*") - c.Assert(func() { p.MustGetInt64("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetUint(c *C) { - for _, test := range uint64Tests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetUint(test.key, uint(test.def)), Equals, uint(test.value)) - } -} - -func (s *TestSuite) TestMustGetUint(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetUint("key"), Equals, uint(123)) - c.Assert(func() { p.MustGetUint64("key2") }, PanicMatches, "strconv.ParseUint: parsing.*") - c.Assert(func() { p.MustGetUint64("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetUint64(c *C) { - for _, test := range uint64Tests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetUint64(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetUint64(c *C) { - input := "key = 123\nkey2 = ghi" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetUint64("key"), Equals, uint64(123)) - c.Assert(func() { p.MustGetUint64("key2") }, PanicMatches, "strconv.ParseUint: parsing.*") - c.Assert(func() { p.MustGetUint64("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestGetString(c *C) { - for _, test := range stringTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, 1) - c.Assert(p.GetString(test.key, test.def), Equals, test.value) - } -} - -func (s *TestSuite) TestMustGetString(c *C) { - input := `key = value` - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetString("key"), Equals, "value") - c.Assert(func() { p.MustGetString("invalid") }, PanicMatches, "unknown property: invalid") -} - -func (s *TestSuite) TestComment(c *C) { - for _, test := range commentTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.MustGetString(test.key), Equals, test.value) - c.Assert(p.GetComments(test.key), DeepEquals, test.comments) - if test.comments != nil { - c.Assert(p.GetComment(test.key), Equals, test.comments[len(test.comments)-1]) - } else { - c.Assert(p.GetComment(test.key), Equals, "") - } - - // test setting comments - if len(test.comments) > 0 { - // set single comment - p.ClearComments() - c.Assert(len(p.c), Equals, 0) - p.SetComment(test.key, test.comments[0]) - c.Assert(p.GetComment(test.key), Equals, test.comments[0]) - - // set multiple comments - p.ClearComments() - c.Assert(len(p.c), Equals, 0) - p.SetComments(test.key, test.comments) - c.Assert(p.GetComments(test.key), DeepEquals, test.comments) - - // clear comments for a key - p.SetComments(test.key, nil) - c.Assert(p.GetComment(test.key), Equals, "") - c.Assert(p.GetComments(test.key), IsNil) - } - } -} - -func (s *TestSuite) TestFilter(c *C) { - for _, test := range filterTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - pp, err := p.Filter(test.pattern) - if err != nil { - c.Assert(err, ErrorMatches, test.err) - continue - } - c.Assert(pp, NotNil) - c.Assert(pp.Len(), Equals, len(test.keys)) - for _, key := range test.keys { - v1, ok1 := p.Get(key) - v2, ok2 := pp.Get(key) - c.Assert(ok1, Equals, true) - c.Assert(ok2, Equals, true) - c.Assert(v1, Equals, v2) - } - } -} - -func (s *TestSuite) TestFilterPrefix(c *C) { - for _, test := range filterPrefixTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - pp := p.FilterPrefix(test.prefix) - c.Assert(pp, NotNil) - c.Assert(pp.Len(), Equals, len(test.keys)) - for _, key := range test.keys { - v1, ok1 := p.Get(key) - v2, ok2 := pp.Get(key) - c.Assert(ok1, Equals, true) - c.Assert(ok2, Equals, true) - c.Assert(v1, Equals, v2) - } - } -} - -func (s *TestSuite) TestKeys(c *C) { - for _, test := range keysTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - c.Assert(p.Len(), Equals, len(test.keys)) - c.Assert(len(p.Keys()), Equals, len(test.keys)) - c.Assert(p.Keys(), DeepEquals, test.keys) - } -} - -func (s *TestSuite) TestSet(c *C) { - for _, test := range setTests { - p, err := parse(test.input) - c.Assert(err, IsNil) - prev, ok, err := p.Set(test.key, test.value) - if test.err != "" { - c.Assert(err, ErrorMatches, test.err) - continue - } - - c.Assert(err, IsNil) - c.Assert(ok, Equals, test.ok) - if ok { - c.Assert(prev, Equals, test.prev) - } - c.Assert(p.Keys(), DeepEquals, test.keys) - } -} - -func (s *TestSuite) TestMustSet(c *C) { - input := "key=${key}" - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(func() { p.MustSet("key", "${key}") }, PanicMatches, "circular reference .*") -} - -func (s *TestSuite) TestWrite(c *C) { - for _, test := range writeTests { - p, err := parse(test.input) - - buf := new(bytes.Buffer) - var n int - switch test.encoding { - case "UTF-8": - n, err = p.Write(buf, UTF8) - case "ISO-8859-1": - n, err = p.Write(buf, ISO_8859_1) - } - c.Assert(err, IsNil) - s := string(buf.Bytes()) - c.Assert(n, Equals, len(test.output), Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s)) - c.Assert(s, Equals, test.output, Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s)) - } -} - -func (s *TestSuite) TestWriteComment(c *C) { - for _, test := range writeCommentTests { - p, err := parse(test.input) - - buf := new(bytes.Buffer) - var n int - switch test.encoding { - case "UTF-8": - n, err = p.WriteComment(buf, "# ", UTF8) - case "ISO-8859-1": - n, err = p.WriteComment(buf, "# ", ISO_8859_1) - } - c.Assert(err, IsNil) - s := string(buf.Bytes()) - c.Assert(n, Equals, len(test.output), Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s)) - c.Assert(s, Equals, test.output, Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s)) - } -} - -func (s *TestSuite) TestCustomExpansionExpression(c *C) { - testKeyValuePrePostfix(c, "*[", "]*", "key=value\nkey2=*[key]*", "key", "value", "key2", "value") -} - -func (s *TestSuite) TestPanicOn32BitIntOverflow(c *C) { - is32Bit = true - var min, max int64 = math.MinInt32 - 1, math.MaxInt32 + 1 - input := fmt.Sprintf("min=%d\nmax=%d", min, max) - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetInt64("min"), Equals, min) - c.Assert(p.MustGetInt64("max"), Equals, max) - c.Assert(func() { p.MustGetInt("min") }, PanicMatches, ".* out of range") - c.Assert(func() { p.MustGetInt("max") }, PanicMatches, ".* out of range") -} - -func (s *TestSuite) TestPanicOn32BitUintOverflow(c *C) { - is32Bit = true - var max uint64 = math.MaxUint32 + 1 - input := fmt.Sprintf("max=%d", max) - p, err := parse(input) - c.Assert(err, IsNil) - c.Assert(p.MustGetUint64("max"), Equals, max) - c.Assert(func() { p.MustGetUint("max") }, PanicMatches, ".* out of range") -} - -func (s *TestSuite) TestDeleteKey(c *C) { - input := "#comments should also be gone\nkey=to-be-deleted\nsecond=key" - p, err := parse(input) - c.Assert(err, IsNil) - c.Check(len(p.m), Equals, 2) - c.Check(len(p.c), Equals, 1) - c.Check(len(p.k), Equals, 2) - p.Delete("key") - c.Check(len(p.m), Equals, 1) - c.Check(len(p.c), Equals, 0) - c.Check(len(p.k), Equals, 1) -} - -func (s *TestSuite) TestDeleteUnknownKey(c *C) { - input := "#comments should also be gone\nkey=to-be-deleted" - p, err := parse(input) - c.Assert(err, IsNil) - c.Check(len(p.m), Equals, 1) - c.Check(len(p.c), Equals, 1) - c.Check(len(p.k), Equals, 1) - p.Delete("wrong-key") - c.Check(len(p.m), Equals, 1) - c.Check(len(p.c), Equals, 1) - c.Check(len(p.k), Equals, 1) -} - -// ---------------------------------------------------------------------------- - -// tests all combinations of delimiters, leading and/or trailing whitespace and newlines. -func testWhitespaceAndDelimiterCombinations(c *C, key, value string) { - whitespace := []string{"", " ", "\f", "\t"} - delimiters := []string{"", " ", "=", ":"} - newlines := []string{"", "\r", "\n", "\r\n"} - for _, dl := range delimiters { - for _, ws1 := range whitespace { - for _, ws2 := range whitespace { - for _, nl := range newlines { - // skip the one case where there is nothing between a key and a value - if ws1 == "" && dl == "" && ws2 == "" && value != "" { - continue - } - - input := fmt.Sprintf("%s%s%s%s%s%s", key, ws1, dl, ws2, value, nl) - testKeyValue(c, input, key, value) - } - } - } - } -} - -// tests whether key/value pairs exist for a given input. -// keyvalues is expected to be an even number of strings of "key", "value", ... -func testKeyValue(c *C, input string, keyvalues ...string) { - testKeyValuePrePostfix(c, "${", "}", input, keyvalues...) -} - -// tests whether key/value pairs exist for a given input. -// keyvalues is expected to be an even number of strings of "key", "value", ... -func testKeyValuePrePostfix(c *C, prefix, postfix, input string, keyvalues ...string) { - printf("%q\n", input) - - p, err := Load([]byte(input), ISO_8859_1) - c.Assert(err, IsNil) - p.Prefix = prefix - p.Postfix = postfix - assertKeyValues(c, input, p, keyvalues...) -} - -// tests whether key/value pairs exist for a given input. -// keyvalues is expected to be an even number of strings of "key", "value", ... -func assertKeyValues(c *C, input string, p *Properties, keyvalues ...string) { - c.Assert(p, NotNil) - c.Assert(2*p.Len(), Equals, len(keyvalues), Commentf("Odd number of key/value pairs.")) - - for i := 0; i < len(keyvalues); i += 2 { - key, value := keyvalues[i], keyvalues[i+1] - v, ok := p.Get(key) - c.Assert(ok, Equals, true, Commentf("No key %q found (input=%q)", key, input)) - c.Assert(v, Equals, value, Commentf("Value %q does not match %q (input=%q)", v, value, input)) - } -} - -// prints to stderr if the -verbose flag was given. -func printf(format string, args ...interface{}) { - if *verbose { - fmt.Fprintf(os.Stderr, format, args...) - } -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go deleted file mode 100644 index 6df4e6c..0000000 --- a/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright 2013-2014 Frank Schroeder. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package properties - -import ( - "fmt" - "math" -) - -// make this a var to overwrite it in a test -var is32Bit = ^uint(0) == math.MaxUint32 - -// intRangeCheck checks if the value fits into the int type and -// panics if it does not. -func intRangeCheck(key string, v int64) int { - if is32Bit && (v < math.MinInt32 || v > math.MaxInt32) { - panic(fmt.Sprintf("Value %d for key %s out of range", v, key)) - } - return int(v) -} - -// uintRangeCheck checks if the value fits into the uint type and -// panics if it does not. -func uintRangeCheck(key string, v uint64) uint { - if is32Bit && v > math.MaxUint32 { - panic(fmt.Sprintf("Value %d for key %s out of range", v, key)) - } - return uint(v) -} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml index ac7bfea..03d626f 100644 --- a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml +++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml @@ -2,7 +2,6 @@ language: go go: - tip before_install: - - go get github.com/axw/gocov/gocov - go get github.com/mattn/goveralls - go get golang.org/x/tools/cmd/cover script: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go index c7996c6..44ec640 100644 --- a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go +++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go @@ -168,7 +168,7 @@ func TestInsert(t *testing.T) { var result int rows.Scan(&result) if result != 123 { - t.Errorf("Fetched %q; expected %q", 123, result) + t.Errorf("Expected %d for fetched result, but %d:", 123, result) } } @@ -233,7 +233,7 @@ func TestUpdate(t *testing.T) { var result int rows.Scan(&result) if result != 234 { - t.Errorf("Fetched %q; expected %q", 234, result) + t.Errorf("Expected %d for fetched result, but %d:", 234, result) } } http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/4ae9684f/newt/Godeps/_workspace/src/github.com/spf13/cast/cast.go ---------------------------------------------------------------------- diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cast/cast.go b/newt/Godeps/_workspace/src/github.com/spf13/cast/cast.go index 0bc8d48..de5a686 100644 --- a/newt/Godeps/_workspace/src/github.com/spf13/cast/cast.go +++ b/newt/Godeps/_workspace/src/github.com/spf13/cast/cast.go @@ -27,6 +27,11 @@ func ToFloat64(i interface{}) float64 { return v } +func ToInt64(i interface{}) int64 { + v, _ := ToInt64E(i) + return v +} + func ToInt(i interface{}) int { v, _ := ToIntE(i) return v
