Support config file

Godeps/Godeps.json

@@ -17,10 +17,26 @@
 			"Rev": "d5cac425555ca5cf00694df246e04f05e6a55150"
 			"Rev": "d5cac425555ca5cf00694df246e04f05e6a55150"
 		},
 		},
 		{
 		{
+			"ImportPath": "github.com/fatih/camelcase",
+			"Rev": "332844f2fb0193cce955f4687646abbdcc43ceeb"
+		},
+		{
+			"ImportPath": "github.com/fatih/structs",
+			"Rev": "a9f7daa9c2729e97450c2da2feda19130a367d8f"
+		},
+		{
 			"ImportPath": "github.com/gorilla/websocket",
 			"ImportPath": "github.com/gorilla/websocket",
 			"Rev": "b6ab76f1fe9803ee1d59e7e5b2a797c1fe897ce5"
 			"Rev": "b6ab76f1fe9803ee1d59e7e5b2a797c1fe897ce5"
 		},
 		},
 		{
 		{
+			"ImportPath": "github.com/hashicorp/go-multierror",
+			"Rev": "56912fb08d85084aa318edcf2bba735b97cf35c5"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/hcl",
+			"Rev": "54864211433d45cb780682431585b3e573b49e4a"
+		},
+		{
 			"ImportPath": "github.com/kr/pty",
 			"ImportPath": "github.com/kr/pty",
 			"Comment": "release.r56-28-g5cf931e",
 			"Comment": "release.r56-28-g5cf931e",
 			"Rev": "5cf931ef8f76dccd0910001d74a58a7fca84a83d"
 			"Rev": "5cf931ef8f76dccd0910001d74a58a7fca84a83d"

Godeps/_workspace/src/github.com/fatih/camelcase/.travis.yml

+language: go
+go: 1.4
+

Godeps/_workspace/src/github.com/fatih/camelcase/LICENSE.md

+The MIT License (MIT)
+
+Copyright (c) 2015 Fatih Arslan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Godeps/_workspace/src/github.com/fatih/camelcase/README.md

+# CamelCase [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/camelcase) [![Build Status](http://img.shields.io/travis/fatih/camelcase.svg?style=flat-square)](https://travis-ci.org/fatih/camelcase)
+
+CamelCase is a Golang (Go) package to split the words of a camelcase type
+string into a slice of words. It can be used to convert a camelcase word (lower
+or upper case) into any type of word.
+
+## Install
+
+```bash
+go get github.com/fatih/camelcase
+```
+
+## Usage and examples
+
+```go
+splitted := camelcase.Split("GolangPackage")
+
+fmt.Println(splitted[0], splitted[1]) // prints: "Golang", "Package"
+```
+
+Both lower camel case and upper camel case are supported. For more info please
+check: [http://en.wikipedia.org/wiki/CamelCase](http://en.wikipedia.org/wiki/CamelCase)
+
+Below are some example cases:
+
+```
+lowercase =>       ["lowercase"]
+Class =>           ["Class"]
+MyClass =>         ["My", "Class"]
+MyC =>             ["My", "C"]
+HTML =>            ["HTML"]
+PDFLoader =>       ["PDF", "Loader"]
+AString =>         ["A", "String"]
+SimpleXMLParser => ["Simple", "XML", "Parser"]
+vimRPCPlugin =>    ["vim", "RPC", "Plugin"]
+GL11Version =>     ["GL", "11", "Version"]
+99Bottles =>       ["99", "Bottles"]
+May5 =>            ["May", "5"]
+BFG9000 =>         ["BFG", "9000"]
+```

Godeps/_workspace/src/github.com/fatih/camelcase/camelcase.go

+// Package camelcase is a micro package to split the words of a camelcase type
+// string into a slice of words.
+package camelcase
+
+import "unicode"
+
+// Split splits the camelcase word and returns a list of words. It also
+// supports digits.  Both lower camel case and upper camel case are supported.
+// For more info please check:  http://en.wikipedia.org/wiki/CamelCase
+//
+// Below are some example cases:
+//   lowercase =>       ["lowercase"]
+//   Class =>           ["Class"]
+//   MyClass =>         ["My", "Class"]
+//   MyC =>             ["My", "C"]
+//   HTML =>            ["HTML"]
+//   PDFLoader =>       ["PDF", "Loader"]
+//   AString =>         ["A", "String"]
+//   SimpleXMLParser => ["Simple", "XML", "Parser"]
+//   vimRPCPlugin =>    ["vim", "RPC", "Plugin"]
+//   GL11Version =>     ["GL", "11", "Version"]
+//   99Bottles =>       ["99", "Bottles"]
+//   May5 =>            ["May", "5"]
+//   BFG9000 =>         ["BFG", "9000"]
+func Split(src string) []string {
+	if src == "" {
+		return []string{}
+	}
+
+	splitIndex := []int{}
+	for i, r := range src {
+		// we don't care about first index
+		if i == 0 {
+			continue
+		}
+
+		// search till we find an upper case
+		if unicode.IsLower(r) {
+			continue
+		}
+
+		prevRune := rune(src[i-1])
+
+		// for cases like: GL11Version, BFG9000
+		if unicode.IsDigit(r) && !unicode.IsDigit(prevRune) {
+			splitIndex = append(splitIndex, i)
+			continue
+		}
+
+		if !unicode.IsDigit(r) && !unicode.IsUpper(prevRune) {
+			// for cases like: MyC
+			if i+1 == len(src) {
+				splitIndex = append(splitIndex, i)
+				continue
+			}
+
+			// for cases like: SimpleXMLParser, eclipseRCPExt
+			if unicode.IsUpper(rune(src[i+1])) {
+				splitIndex = append(splitIndex, i)
+				continue
+			}
+		}
+
+		// If the next char is lower case, we have found a split index
+		if i+1 != len(src) && unicode.IsLower(rune(src[i+1])) {
+			splitIndex = append(splitIndex, i)
+		}
+	}
+
+	// nothing to split, such as "hello", "Class", "HTML"
+	if len(splitIndex) == 0 {
+		return []string{src}
+	}
+
+	// now split the input string into pieces
+	splitted := make([]string, len(splitIndex)+1)
+	for i := 0; i < len(splitIndex)+1; i++ {
+		if i == 0 {
+			// first index
+			splitted[i] = src[:splitIndex[0]]
+		} else if i == len(splitIndex) {
+			// last index
+			splitted[i] = src[splitIndex[i-1]:]
+		} else {
+			// between first and last index
+			splitted[i] = src[splitIndex[i-1]:splitIndex[i]]
+		}
+	}
+
+	return splitted
+}

Godeps/_workspace/src/github.com/fatih/camelcase/camelcase_test.go

+package camelcase
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSplit(t *testing.T) {
+	var testCases = []struct {
+		input  string
+		output []string
+	}{
+		{input: "", output: []string{}},
+		{input: "lowercase", output: []string{"lowercase"}},
+		{input: "Class", output: []string{"Class"}},
+		{input: "MyClass", output: []string{"My", "Class"}},
+		{input: "MyC", output: []string{"My", "C"}},
+		{input: "HTML", output: []string{"HTML"}},
+		{input: "PDFLoader", output: []string{"PDF", "Loader"}},
+		{input: "AString", output: []string{"A", "String"}},
+		{input: "SimpleXMLParser", output: []string{"Simple", "XML", "Parser"}},
+		{input: "vimRPCPlugin", output: []string{"vim", "RPC", "Plugin"}},
+		{input: "GL11Version", output: []string{"GL", "11", "Version"}},
+		{input: "99Bottles", output: []string{"99", "Bottles"}},
+		{input: "May5", output: []string{"May", "5"}},
+		{input: "BFG9000", output: []string{"BFG", "9000"}},
+	}
+
+	for _, c := range testCases {
+		res := Split(c.input)
+		if !reflect.DeepEqual(res, c.output) {
+			t.Errorf("input: '%s'\n\twant: %v\n\tgot : %v\n", c.input, c.output, res)
+		}
+	}
+}

Godeps/_workspace/src/github.com/fatih/structs/.gitignore

+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test

Godeps/_workspace/src/github.com/fatih/structs/.travis.yml

+language: go
+go: 1.3
+before_install:
+- go get github.com/axw/gocov/gocov
+- go get github.com/mattn/goveralls
+- go get code.google.com/p/go.tools/cmd/cover
+script:
+- $HOME/gopath/bin/goveralls -repotoken $COVERALLS_TOKEN
+env:
+  global:
+  - secure: hkc+92KPmMFqIH9n4yWdnH1JpZjahmOyDJwpTh8Yl0JieJNG0XEXpOqNao27eA0cLF+UHdyjFeGcPUJKNmgE46AoQjtovt+ICjCXKR2yF6S2kKJcUOz/Vd6boZF7qHV06jjxyxOebpID5iSoW6UfFr001bFxpd3jaSLFTzSHWRQ=

Godeps/_workspace/src/github.com/fatih/structs/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2014 Fatih Arslan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file

Godeps/_workspace/src/github.com/fatih/structs/README.md

+# Structs [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/structs) [![Build Status](http://img.shields.io/travis/fatih/structs.svg?style=flat-square)](https://travis-ci.org/fatih/structs) [![Coverage Status](http://img.shields.io/coveralls/fatih/structs.svg?style=flat-square)](https://coveralls.io/r/fatih/structs)
+
+Structs contains various utilities to work with Go (Golang) structs. It was
+initially used by me to convert a struct into a `map[string]interface{}`. With
+time I've added other utilities for structs.  It's basically a high level
+package based on primitives from the reflect package. Feel free to add new
+functions or improve the existing code.
+
+## Install
+
+```bash
+go get github.com/fatih/structs
+```
+
+## Usage and Examples
+
+Just like the standard lib `strings`, `bytes` and co packages, `structs` has
+many global functions to manipulate or organize your struct data. Lets define
+and declare a struct:
+
+```go
+type Server struct {
+	Name        string `json:"name,omitempty"`
+	ID          int
+	Enabled     bool
+	users       []string // not exported
+	http.Server          // embedded
+}
+
+server := &Server{
+	Name:    "gopher",
+	ID:      123456,
+	Enabled: true,
+}
+```
+
+```go
+// Convert a struct to a map[string]interface{}
+// => {"Name":"gopher", "ID":123456, "Enabled":true}
+m := structs.Map(server)
+
+// Convert the values of a struct to a []interface{}
+// => ["gopher", 123456, true]
+v := structs.Values(server)
+
+// Convert the names of a struct to a []string
+// (see "Names methods" for more info about fields)
+n := structs.Names(server)
+
+// Convert the values of a struct to a []*Field
+// (see "Field methods" for more info about fields)
+f := structs.Fields(server)
+
+// Return the struct name => "Server"
+n := structs.Name(server)
+
+// Check if any field of a struct is initialized or not.
+h := structs.HasZero(server)
+
+// Check if all fields of a struct is initialized or not.
+z := structs.IsZero(server)
+
+// Check if server is a struct or a pointer to struct
+i := structs.IsStruct(server)
+```
+
+### Struct methods
+
+The structs functions can be also used as independent methods by creating a new
+`*structs.Struct`. This is handy if you want to have more control over the
+structs (such as retrieving a single Field).
+
+```go
+// Create a new struct type:
+s := structs.New(server)
+
+m := s.Map()              // Get a map[string]interface{}
+v := s.Values()           // Get a []interface{}
+f := s.Fields()           // Get a []*Field
+n := s.Names()            // Get a []string
+f := s.Field(name)        // Get a *Field based on the given field name
+f, ok := s.FieldOk(name)  // Get a *Field based on the given field name
+n := s.Name()             // Get the struct name
+h := s.HasZero()          // Check if any field is initialized
+z := s.IsZero()           // Check if all fields are initialized
+```
+
+### Field methods
+
+We can easily examine a single Field for more detail. Below you can see how we
+get and interact with various field methods:
+
+
+```go
+s := structs.New(server)
+
+// Get the Field struct for the "Name" field
+name := s.Field("Name")
+
+// Get the underlying value,  value => "gopher"
+value := name.Value().(string)
+
+// Set the field's value
+name.Set("another gopher")
+
+// Get the field's kind, kind =>  "string"
+name.Kind()
+
+// Check if the field is exported or not
+if name.IsExported() {
+	fmt.Println("Name field is exported")
+}
+
+// Check if the value is a zero value, such as "" for string, 0 for int
+if !name.IsZero() {
+	fmt.Println("Name is initialized")
+}
+
+// Check if the field is an anonymous (embedded) field
+if !name.IsEmbedded() {
+	fmt.Println("Name is not an embedded field")
+}
+
+// Get the Field's tag value for tag name "json", tag value => "name,omitempty"
+tagValue := name.Tag("json")
+```
+
+Nested structs are supported too:
+
+```go
+addrField := s.Field("Server").Field("Addr")
+
+// Get the value for addr
+a := addrField.Value().(string)
+
+// Or get all fields
+httpServer := s.Field("Server").Fields()
+```
+
+We can also get a slice of Fields from the Struct type to iterate over all
+fields. This is handy if you wish to examine all fields:
+
+```go
+// Convert the fields of a struct to a []*Field
+fields := s.Fields()
+
+for _, f := range fields {
+	fmt.Printf("field name: %+v\n", f.Name())
+
+	if f.IsExported() {
+		fmt.Printf("value   : %+v\n", f.Value())
+		fmt.Printf("is zero : %+v\n", f.IsZero())
+	}
+}
+```
+
+## Credits
+
+ * [Fatih Arslan](https://github.com/fatih)
+ * [Cihangir Savas](https://github.com/cihangir)
+
+## License
+
+The MIT License (MIT) - see LICENSE.md for more details

Godeps/_workspace/src/github.com/fatih/structs/field.go

+package structs
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+var (
+	errNotExported = errors.New("field is not exported")
+	errNotSettable = errors.New("field is not settable")
+)
+
+// Field represents a single struct field that encapsulates high level
+// functions around the field.
+type Field struct {
+	value      reflect.Value
+	field      reflect.StructField
+	defaultTag string
+}
+
+// Tag returns the value associated with key in the tag string. If there is no
+// such key in the tag, Tag returns the empty string.
+func (f *Field) Tag(key string) string {
+	return f.field.Tag.Get(key)
+}
+
+// Value returns the underlying value of of the field. It panics if the field
+// is not exported.
+func (f *Field) Value() interface{} {
+	return f.value.Interface()
+}
+
+// IsEmbedded returns true if the given field is an anonymous field (embedded)
+func (f *Field) IsEmbedded() bool {
+	return f.field.Anonymous
+}
+
+// IsExported returns true if the given field is exported.
+func (f *Field) IsExported() bool {
+	return f.field.PkgPath == ""
+}
+
+// IsZero returns true if the given field is not initalized (has a zero value).
+// It panics if the field is not exported.
+func (f *Field) IsZero() bool {
+	zero := reflect.Zero(f.value.Type()).Interface()
+	current := f.Value()
+
+	return reflect.DeepEqual(current, zero)
+}
+
+// Name returns the name of the given field
+func (f *Field) Name() string {
+	return f.field.Name
+}
+
+// Kind returns the fields kind, such as "string", "map", "bool", etc ..
+func (f *Field) Kind() reflect.Kind {
+	return f.value.Kind()
+}
+
+// Set sets the field to given value v. It retuns an error if the field is not
+// settable (not addresable or not exported) or if the given value's type
+// doesn't match the fields type.
+func (f *Field) Set(val interface{}) error {
+	// we can't set unexported fields, so be sure this field is exported
+	if !f.IsExported() {
+		return errNotExported
+	}
+
+	// do we get here? not sure...
+	if !f.value.CanSet() {
+		return errNotSettable
+	}
+
+	given := reflect.ValueOf(val)
+
+	if f.value.Kind() != given.Kind() {
+		return fmt.Errorf("wrong kind. got: %s want: %s", given.Kind(), f.value.Kind())
+	}
+
+	f.value.Set(given)
+	return nil
+}
+
+// Fields returns a slice of Fields. This is particular handy to get the fields
+// of a nested struct . A struct tag with the content of "-" ignores the
+// checking of that particular field. Example:
+//
+//   // Field is ignored by this package.
+//   Field *http.Request `structs:"-"`
+//
+// It panics if field is not exported or if field's kind is not struct
+func (f *Field) Fields() []*Field {
+	return getFields(f.value, f.defaultTag)
+}
+
+// Field returns the field from a nested struct. It panics if the nested struct
+// is not exported or if the field was not found.
+func (f *Field) Field(name string) *Field {
+	field, ok := f.FieldOk(name)
+	if !ok {
+		panic("field not found")
+	}
+
+	return field
+}
+
+// Field returns the field from a nested struct. The boolean returns true if
+// the field was found. It panics if the nested struct is not exported or if
+// the field was not found.
+func (f *Field) FieldOk(name string) (*Field, bool) {
+	v := strctVal(f.value.Interface())
+	t := v.Type()
+
+	field, ok := t.FieldByName(name)
+	if !ok {
+		return nil, false
+	}
+
+	return &Field{
+		field: field,
+		value: v.FieldByName(name),
+	}, true
+}

Godeps/_workspace/src/github.com/fatih/structs/field_test.go

+package structs
+
+import (
+	"reflect"
+	"testing"
+)
+
+// A test struct that defines all cases
+type Foo struct {
+	A    string
+	B    int    `structs:"y"`
+	C    bool   `json:"c"`
+	d    string // not exported
+	E    *Baz
+	x    string `xml:"x"` // not exported, with tag
+	Y    []string
+	Z    map[string]interface{}
+	*Bar // embedded
+}
+
+type Baz struct {
+	A string
+	B int
+}
+
+type Bar struct {
+	E string
+	F int
+	g []string
+}
+
+func newStruct() *Struct {
+	b := &Bar{
+		E: "example",
+		F: 2,
+		g: []string{"zeynep", "fatih"},
+	}
+
+	// B and x is not initialized for testing
+	f := &Foo{
+		A: "gopher",
+		C: true,
+		d: "small",
+		E: nil,
+		Y: []string{"example"},
+		Z: nil,
+	}
+	f.Bar = b
+
+	return New(f)
+}
+
+func TestField_Set(t *testing.T) {
+	s := newStruct()
+
+	f := s.Field("A")
+	err := f.Set("fatih")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if f.Value().(string) != "fatih" {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(string), "fatih")
+	}
+
+	f = s.Field("Y")
+	err = f.Set([]string{"override", "with", "this"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	sliceLen := len(f.Value().([]string))
+	if sliceLen != 3 {
+		t.Errorf("Setted values slice length is wrong: %d, want: %d", sliceLen, 3)
+	}
+
+	f = s.Field("C")
+	err = f.Set(false)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if f.Value().(bool) {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(bool), false)
+	}
+
+	// let's pass a different type
+	f = s.Field("A")
+	err = f.Set(123) // Field A is of type string, but we are going to pass an integer
+	if err == nil {
+		t.Error("Setting a field's value with a different type than the field's type should return an error")
+	}
+
+	// old value should be still there :)
+	if f.Value().(string) != "fatih" {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(string), "fatih")
+	}
+
+	// let's access an unexported field, which should give an error
+	f = s.Field("d")
+	err = f.Set("large")
+	if err != errNotExported {
+		t.Error(err)
+	}
+
+	// let's set a pointer to struct
+	b := &Bar{
+		E: "gopher",
+		F: 2,
+	}
+
+	f = s.Field("Bar")
+	err = f.Set(b)
+	if err != nil {
+		t.Error(err)
+	}
+
+	baz := &Baz{
+		A: "helloWorld",
+		B: 42,
+	}
+
+	f = s.Field("E")
+	err = f.Set(baz)
+	if err != nil {
+		t.Error(err)
+	}
+
+	ba := s.Field("E").Value().(*Baz)
+
+	if ba.A != "helloWorld" {
+		t.Errorf("could not set baz. Got: %s Want: helloWorld", ba.A)
+	}
+}
+
+func TestField(t *testing.T) {
+	s := newStruct()
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Retrieveing a non existing field from the struct should panic")
+		}
+	}()
+
+	_ = s.Field("no-field")
+}
+
+func TestField_Kind(t *testing.T) {
+	s := newStruct()
+
+	f := s.Field("A")
+	if f.Kind() != reflect.String {
+		t.Errorf("Field A has wrong kind: %s want: %s", f.Kind(), reflect.String)
+	}
+
+	f = s.Field("B")
+	if f.Kind() != reflect.Int {
+		t.Errorf("Field B has wrong kind: %s want: %s", f.Kind(), reflect.Int)
+	}
+
+	// unexported
+	f = s.Field("d")
+	if f.Kind() != reflect.String {
+		t.Errorf("Field d has wrong kind: %s want: %s", f.Kind(), reflect.String)
+	}
+}
+
+func TestField_Tag(t *testing.T) {
+	s := newStruct()
+
+	v := s.Field("B").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a non existing tag should return empty, got: %s", v)
+	}
+
+	v = s.Field("C").Tag("json")
+	if v != "c" {
+		t.Errorf("Field's tag value of the existing field C should return 'c', got: %s", v)
+	}
+
+	v = s.Field("d").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a non exported field should return empty, got: %s", v)
+	}
+
+	v = s.Field("x").Tag("xml")
+	if v != "x" {
+		t.Errorf("Field's tag value of a non exported field with a tag should return 'x', got: %s", v)
+	}
+
+	v = s.Field("A").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a existing field without a tag should return empty, got: %s", v)
+	}
+}
+
+func TestField_Value(t *testing.T) {
+	s := newStruct()
+
+	v := s.Field("A").Value()
+	val, ok := v.(string)
+	if !ok {
+		t.Errorf("Field's value of a A should be string")
+	}
+
+	if val != "gopher" {
+		t.Errorf("Field's value of a existing tag should return 'gopher', got: %s", val)
+	}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Value of a non exported field from the field should panic")
+		}
+	}()
+
+	// should panic
+	_ = s.Field("d").Value()
+}
+
+func TestField_IsEmbedded(t *testing.T) {
+	s := newStruct()
+
+	if !s.Field("Bar").IsEmbedded() {
+		t.Errorf("Fields 'Bar' field is an embedded field")
+	}
+
+	if s.Field("d").IsEmbedded() {
+		t.Errorf("Fields 'd' field is not an embedded field")
+	}
+}
+
+func TestField_IsExported(t *testing.T) {
+	s := newStruct()
+
+	if !s.Field("Bar").IsExported() {
+		t.Errorf("Fields 'Bar' field is an exported field")
+	}
+
+	if !s.Field("A").IsExported() {
+		t.Errorf("Fields 'A' field is an exported field")
+	}
+
+	if s.Field("d").IsExported() {
+		t.Errorf("Fields 'd' field is not an exported field")
+	}
+}
+
+func TestField_IsZero(t *testing.T) {
+	s := newStruct()
+
+	if s.Field("A").IsZero() {
+		t.Errorf("Fields 'A' field is an initialized field")
+	}
+
+	if !s.Field("B").IsZero() {
+		t.Errorf("Fields 'B' field is not an initialized field")
+	}
+}
+
+func TestField_Name(t *testing.T) {
+	s := newStruct()
+
+	if s.Field("A").Name() != "A" {
+		t.Errorf("Fields 'A' field should have the name 'A'")
+	}
+}
+
+func TestField_Field(t *testing.T) {
+	s := newStruct()
+
+	e := s.Field("Bar").Field("E")
+
+	val, ok := e.Value().(string)
+	if !ok {
+		t.Error("The value of the field 'e' inside 'Bar' struct should be string")
+	}
+
+	if val != "example" {
+		t.Errorf("The value of 'e' should be 'example, got: %s", val)
+	}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Field of a non existing nested struct should panic")
+		}
+	}()
+
+	_ = s.Field("Bar").Field("e")
+}
+
+func TestField_Fields(t *testing.T) {
+	s := newStruct()
+	fields := s.Field("Bar").Fields()
+
+	if len(fields) != 3 {
+		t.Errorf("We expect 3 fields in embedded struct, was: %d", len(fields))
+	}
+}
+
+func TestField_FieldOk(t *testing.T) {
+	s := newStruct()
+
+	b, ok := s.FieldOk("Bar")
+	if !ok {
+		t.Error("The field 'Bar' should exists.")
+	}
+
+	e, ok := b.FieldOk("E")
+	if !ok {
+		t.Error("The field 'E' should exists.")
+	}
+
+	val, ok := e.Value().(string)
+	if !ok {
+		t.Error("The value of the field 'e' inside 'Bar' struct should be string")
+	}
+
+	if val != "example" {
+		t.Errorf("The value of 'e' should be 'example, got: %s", val)
+	}
+}

Godeps/_workspace/src/github.com/fatih/structs/structs_example_test.go

+package structs
+
+import (
+	"fmt"
+	"time"
+)
+
+func ExampleNew() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	server := &Server{
+		Name:    "Arslan",
+		ID:      123456,
+		Enabled: true,
+	}
+
+	s := New(server)
+
+	fmt.Printf("Name        : %v\n", s.Name())
+	fmt.Printf("Values      : %v\n", s.Values())
+	fmt.Printf("Value of ID : %v\n", s.Field("ID").Value())
+	// Output:
+	// Name        : Server
+	// Values      : [Arslan 123456 true]
+	// Value of ID : 123456
+
+}
+
+func ExampleMap() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	s := &Server{
+		Name:    "Arslan",
+		ID:      123456,
+		Enabled: true,
+	}
+
+	m := Map(s)
+
+	fmt.Printf("%#v\n", m["Name"])
+	fmt.Printf("%#v\n", m["ID"])
+	fmt.Printf("%#v\n", m["Enabled"])
+	// Output:
+	// "Arslan"
+	// 123456
+	// true
+
+}
+
+func ExampleMap_tags() {
+	// Custom tags can change the map keys instead of using the fields name
+	type Server struct {
+		Name    string `structs:"server_name"`
+		ID      int32  `structs:"server_id"`
+		Enabled bool   `structs:"enabled"`
+	}
+
+	s := &Server{
+		Name: "Zeynep",
+		ID:   789012,
+	}
+
+	m := Map(s)
+
+	// access them by the custom tags defined above
+	fmt.Printf("%#v\n", m["server_name"])
+	fmt.Printf("%#v\n", m["server_id"])
+	fmt.Printf("%#v\n", m["enabled"])
+	// Output:
+	// "Zeynep"
+	// 789012
+	// false
+
+}
+
+func ExampleMap_nested() {
+	// By default field with struct types are processed too. We can stop
+	// processing them via "omitnested" tag option.
+	type Server struct {
+		Name string    `structs:"server_name"`
+		ID   int32     `structs:"server_id"`
+		Time time.Time `structs:"time,omitnested"` // do not convert to map[string]interface{}
+	}
+
+	const shortForm = "2006-Jan-02"
+	t, _ := time.Parse("2006-Jan-02", "2013-Feb-03")
+
+	s := &Server{
+		Name: "Zeynep",
+		ID:   789012,
+		Time: t,
+	}
+
+	m := Map(s)
+
+	// access them by the custom tags defined above
+	fmt.Printf("%v\n", m["server_name"])
+	fmt.Printf("%v\n", m["server_id"])
+	fmt.Printf("%v\n", m["time"].(time.Time))
+	// Output:
+	// Zeynep
+	// 789012
+	// 2013-02-03 00:00:00 +0000 UTC
+}
+
+func ExampleMap_omitEmpty() {
+	// By default field with struct types of zero values are processed too. We
+	// can stop processing them via "omitempty" tag option.
+	type Server struct {
+		Name     string `structs:",omitempty"`
+		ID       int32  `structs:"server_id,omitempty"`
+		Location string
+	}
+
+	// Only add location
+	s := &Server{
+		Location: "Tokyo",
+	}
+
+	m := Map(s)
+
+	// map contains only the Location field
+	fmt.Printf("%v\n", m)
+	// Output:
+	// map[Location:Tokyo]
+}
+
+func ExampleValues() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	s := &Server{
+		Name:    "Fatih",
+		ID:      135790,
+		Enabled: false,
+	}
+
+	m := Values(s)
+
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Fatih 135790 false]
+}
+
+func ExampleValues_omitEmpty() {
+	// By default field with struct types of zero values are processed too. We
+	// can stop processing them via "omitempty" tag option.
+	type Server struct {
+		Name     string `structs:",omitempty"`
+		ID       int32  `structs:"server_id,omitempty"`
+		Location string
+	}
+
+	// Only add location
+	s := &Server{
+		Location: "Ankara",
+	}
+
+	m := Values(s)
+
+	// values contains only the Location field
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Ankara]
+}
+
+func ExampleValues_tags() {
+	type Location struct {
+		City    string
+		Country string
+	}
+
+	type Server struct {
+		Name     string
+		ID       int32
+		Enabled  bool
+		Location Location `structs:"-"` // values from location are not included anymore
+	}
+
+	s := &Server{
+		Name:     "Fatih",
+		ID:       135790,
+		Enabled:  false,
+		Location: Location{City: "Ankara", Country: "Turkey"},
+	}
+
+	// Let get all values from the struct s. Note that we don't include values
+	// from the Location field
+	m := Values(s)
+
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Fatih 135790 false]
+}
+
+func ExampleFields() {
+	type Access struct {
+		Name         string
+		LastAccessed time.Time
+		Number       int
+	}
+
+	s := &Access{
+		Name:         "Fatih",
+		LastAccessed: time.Now(),
+		Number:       1234567,
+	}
+
+	fields := Fields(s)
+
+	for i, field := range fields {
+		fmt.Printf("[%d] %+v\n", i, field.Name())
+	}
+
+	// Output:
+	// [0] Name
+	// [1] LastAccessed
+	// [2] Number
+}
+
+func ExampleFields_nested() {
+	type Person struct {
+		Name   string
+		Number int
+	}
+
+	type Access struct {
+		Person        Person
+		HasPermission bool
+		LastAccessed  time.Time
+	}
+
+	s := &Access{
+		Person:        Person{Name: "fatih", Number: 1234567},
+		LastAccessed:  time.Now(),
+		HasPermission: true,
+	}
+
+	// Let's get all fields from the struct s.
+	fields := Fields(s)
+
+	for _, field := range fields {
+		if field.Name() == "Person" {
+			fmt.Printf("Access.Person.Name: %+v\n", field.Field("Name").Value())
+		}
+	}
+
+	// Output:
+	// Access.Person.Name: fatih
+}
+
+func ExampleField() {
+	type Person struct {
+		Name   string
+		Number int
+	}
+
+	type Access struct {
+		Person        Person
+		HasPermission bool
+		LastAccessed  time.Time
+	}
+
+	access := &Access{
+		Person:        Person{Name: "fatih", Number: 1234567},
+		LastAccessed:  time.Now(),
+		HasPermission: true,
+	}
+
+	// Create a new Struct type
+	s := New(access)
+
+	// Get the Field type for "Person" field
+	p := s.Field("Person")
+
+	// Get the underlying "Name field" and print the value of it
+	name := p.Field("Name")
+
+	fmt.Printf("Value of Person.Access.Name: %+v\n", name.Value())
+
+	// Output:
+	// Value of Person.Access.Name: fatih
+
+}
+
+func ExampleIsZero() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	// Nothing is initalized
+	a := &Server{}
+	isZeroA := IsZero(a)
+
+	// Name and Enabled is initialized, but not ID
+	b := &Server{
+		Name:    "Golang",
+		Enabled: true,
+	}
+	isZeroB := IsZero(b)
+
+	fmt.Printf("%#v\n", isZeroA)
+	fmt.Printf("%#v\n", isZeroB)
+	// Output:
+	// true
+	// false
+}
+
+func ExampleHasZero() {
+	// Let's define an Access struct. Note that the "Enabled" field is not
+	// going to be checked because we added the "structs" tag to the field.
+	type Access struct {
+		Name         string
+		LastAccessed time.Time
+		Number       int
+		Enabled      bool `structs:"-"`
+	}
+
+	// Name and Number is not initialized.
+	a := &Access{
+		LastAccessed: time.Now(),
+	}
+	hasZeroA := HasZero(a)
+
+	// Name and Number is initialized.
+	b := &Access{
+		Name:         "Fatih",
+		LastAccessed: time.Now(),
+		Number:       12345,
+	}
+	hasZeroB := HasZero(b)
+
+	fmt.Printf("%#v\n", hasZeroA)
+	fmt.Printf("%#v\n", hasZeroB)
+	// Output:
+	// true
+	// false
+}

Godeps/_workspace/src/github.com/fatih/structs/tags.go

+package structs
+
+import "strings"
+
+// tagOptions contains a slice of tag options
+type tagOptions []string
+
+// Has returns true if the given optiton is available in tagOptions
+func (t tagOptions) Has(opt string) bool {
+	for _, tagOpt := range t {
+		if tagOpt == opt {
+			return true
+		}
+	}
+
+	return false
+}
+
+// parseTag splits a struct field's tag into its name and a list of options
+// which comes after a name. A tag is in the form of: "name,option1,option2".
+// The name can be neglectected.
+func parseTag(tag string) (string, tagOptions) {
+	// tag is one of followings:
+	// ""
+	// "name"
+	// "name,opt"
+	// "name,opt,opt2"
+	// ",opt"
+
+	res := strings.Split(tag, ",")
+	return res[0], res[1:]
+}

Godeps/_workspace/src/github.com/fatih/structs/tags_test.go

+package structs
+
+import "testing"
+
+func TestParseTag_Name(t *testing.T) {
+	tags := []struct {
+		tag string
+		has bool
+	}{
+		{"", false},
+		{"name", true},
+		{"name,opt", true},
+		{"name , opt, opt2", false}, // has a single whitespace
+		{", opt, opt2", false},
+	}
+
+	for _, tag := range tags {
+		name, _ := parseTag(tag.tag)
+
+		if (name != "name") && tag.has {
+			t.Errorf("Parse tag should return name: %#v", tag)
+		}
+	}
+}
+
+func TestParseTag_Opts(t *testing.T) {
+	tags := []struct {
+		opts string
+		has  bool
+	}{
+		{"name", false},
+		{"name,opt", true},
+		{"name , opt, opt2", false}, // has a single whitespace
+		{",opt, opt2", true},
+		{", opt3, opt4", false},
+	}
+
+	// search for "opt"
+	for _, tag := range tags {
+		_, opts := parseTag(tag.opts)
+
+		if opts.Has("opt") != tag.has {
+			t.Errorf("Tag opts should have opt: %#v", tag)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/README.md

+# go-multierror
+
+`go-multierror` is a package for Go that provides a mechanism for
+representing a list of `error` values as a single `error`.
+
+This allows a function in Go to return an `error` that might actually
+be a list of errors. If the caller knows this, they can unwrap the
+list and access the errors. If the caller doesn't know, the error
+formats to a nice human-readable format.
+
+`go-multierror` implements the
+[errwrap](https://github.com/hashicorp/errwrap) interface so that it can
+be used with that library, as well.
+
+## Installation and Docs
+
+Install using `go get github.com/hashicorp/go-multierror`.
+
+Full documentation is available at
+http://godoc.org/github.com/hashicorp/go-multierror
+
+## Usage
+
+go-multierror is easy to use and purposely built to be unobtrusive in
+existing Go applications/libraries that may not be aware of it.
+
+**Building a list of errors**
+
+The `Append` function is used to create a list of errors. This function
+behaves a lot like the Go built-in `append` function: it doesn't matter
+if the first argument is nil, a `multierror.Error`, or any other `error`,
+the function behaves as you would expect.
+
+```go
+var result error
+
+if err := step1(); err != nil {
+	result = multierror.Append(result, err)
+}
+if err := step2(); err != nil {
+	result = multierror.Append(result, err)
+}
+
+return result
+```
+
+**Customizing the formatting of the errors**
+
+By specifying a custom `ErrorFormat`, you can customize the format
+of the `Error() string` function:
+
+```go
+var result *multierror.Error
+
+// ... accumulate errors here, maybe using Append
+
+if result != nil {
+	result.ErrorFormat = func([]error) string {
+		return "errors!"
+	}
+}
+```
+
+**Accessing the list of errors**
+
+`multierror.Error` implements `error` so if the caller doesn't know about
+multierror, it will work just fine. But if you're aware a multierror might
+be returned, you can use type switches to access the list of errors:
+
+```go
+if err := something(); err != nil {
+	if merr, ok := err.(*multierror.Error); ok {
+		// Use merr.Errors
+	}
+}
+```
+
+**Returning a multierror only if there are errors**
+
+If you build a `multierror.Error`, you can use the `ErrorOrNil` function
+to return an `error` implementation only if there are errors to return:
+
+```go
+var result *multierror.Error
+
+// ... accumulate errors here
+
+// Return the `error` only if errors were added to the multierror, otherwise
+// return nil since there are no errors.
+return result.ErrorOrNil()
+```

Godeps/_workspace/src/github.com/hashicorp/go-multierror/append.go

+package multierror
+
+// Append is a helper function that will append more errors
+// onto an Error in order to create a larger multi-error.
+//
+// If err is not a multierror.Error, then it will be turned into
+// one. If any of the errs are multierr.Error, they will be flattened
+// one level into err.
+func Append(err error, errs ...error) *Error {
+	switch err := err.(type) {
+	case *Error:
+		// Typed nils can reach here, so initialize if we are nil
+		if err == nil {
+			err = new(Error)
+		}
+
+		err.Errors = append(err.Errors, errs...)
+		return err
+	default:
+		newErrs := make([]error, 0, len(errs)+1)
+		if err != nil {
+			newErrs = append(newErrs, err)
+		}
+		newErrs = append(newErrs, errs...)
+
+		return &Error{
+			Errors: newErrs,
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/append_test.go

+package multierror
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestAppend_Error(t *testing.T) {
+	original := &Error{
+		Errors: []error{errors.New("foo")},
+	}
+
+	result := Append(original, errors.New("bar"))
+	if len(result.Errors) != 2 {
+		t.Fatalf("wrong len: %d", len(result.Errors))
+	}
+
+	original = &Error{}
+	result = Append(original, errors.New("bar"))
+	if len(result.Errors) != 1 {
+		t.Fatalf("wrong len: %d", len(result.Errors))
+	}
+
+	// Test when a typed nil is passed
+	var e *Error
+	result = Append(e, errors.New("baz"))
+	if len(result.Errors) != 1 {
+		t.Fatalf("wrong len: %d", len(result.Errors))
+	}
+}
+
+func TestAppend_NilError(t *testing.T) {
+	var err error
+	result := Append(err, errors.New("bar"))
+	if len(result.Errors) != 1 {
+		t.Fatalf("wrong len: %d", len(result.Errors))
+	}
+}
+func TestAppend_NonError(t *testing.T) {
+	original := errors.New("foo")
+	result := Append(original, errors.New("bar"))
+	if len(result.Errors) != 2 {
+		t.Fatalf("wrong len: %d", len(result.Errors))
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/flatten.go

+package multierror
+
+// Flatten flattens the given error, merging any *Errors together into
+// a single *Error.
+func Flatten(err error) error {
+	// If it isn't an *Error, just return the error as-is
+	if _, ok := err.(*Error); !ok {
+		return err
+	}
+
+	// Otherwise, make the result and flatten away!
+	flatErr := new(Error)
+	flatten(err, flatErr)
+	return flatErr
+}
+
+func flatten(err error, flatErr *Error) {
+	switch err := err.(type) {
+	case *Error:
+		for _, e := range err.Errors {
+			flatten(e, flatErr)
+		}
+	default:
+		flatErr.Errors = append(flatErr.Errors, err)
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/flatten_test.go

+package multierror
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestFlatten(t *testing.T) {
+	original := &Error{
+		Errors: []error{
+			errors.New("one"),
+			&Error{
+				Errors: []error{
+					errors.New("two"),
+					&Error{
+						Errors: []error{
+							errors.New("three"),
+						},
+					},
+				},
+			},
+		},
+	}
+
+	expected := strings.TrimSpace(`
+3 error(s) occurred:
+
+* one
+* two
+* three
+	`)
+	actual := fmt.Sprintf("%s", Flatten(original))
+
+	if expected != actual {
+		t.Fatalf("expected: %s, got: %s", expected, actual)
+	}
+}
+
+func TestFlatten_nonError(t *testing.T) {
+	err := errors.New("foo")
+	actual := Flatten(err)
+	if !reflect.DeepEqual(actual, err) {
+		t.Fatalf("bad: %#v", actual)
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/format.go

+package multierror
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ErrorFormatFunc is a function callback that is called by Error to
+// turn the list of errors into a string.
+type ErrorFormatFunc func([]error) string
+
+// ListFormatFunc is a basic formatter that outputs the number of errors
+// that occurred along with a bullet point list of the errors.
+func ListFormatFunc(es []error) string {
+	points := make([]string, len(es))
+	for i, err := range es {
+		points[i] = fmt.Sprintf("* %s", err)
+	}
+
+	return fmt.Sprintf(
+		"%d error(s) occurred:\n\n%s",
+		len(es), strings.Join(points, "\n"))
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/format_test.go

+package multierror
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestListFormatFunc(t *testing.T) {
+	expected := `2 error(s) occurred:
+
+* foo
+* bar`
+
+	errors := []error{
+		errors.New("foo"),
+		errors.New("bar"),
+	}
+
+	actual := ListFormatFunc(errors)
+	if actual != expected {
+		t.Fatalf("bad: %#v", actual)
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/multierror.go

+package multierror
+
+import (
+	"fmt"
+)
+
+// Error is an error type to track multiple errors. This is used to
+// accumulate errors in cases and return them as a single "error".
+type Error struct {
+	Errors      []error
+	ErrorFormat ErrorFormatFunc
+}
+
+func (e *Error) Error() string {
+	fn := e.ErrorFormat
+	if fn == nil {
+		fn = ListFormatFunc
+	}
+
+	return fn(e.Errors)
+}
+
+// ErrorOrNil returns an error interface if this Error represents
+// a list of errors, or returns nil if the list of errors is empty. This
+// function is useful at the end of accumulation to make sure that the value
+// returned represents the existence of errors.
+func (e *Error) ErrorOrNil() error {
+	if e == nil {
+		return nil
+	}
+	if len(e.Errors) == 0 {
+		return nil
+	}
+
+	return e
+}
+
+func (e *Error) GoString() string {
+	return fmt.Sprintf("*%#v", *e)
+}
+
+// WrappedErrors returns the list of errors that this Error is wrapping.
+// It is an implementatin of the errwrap.Wrapper interface so that
+// multierror.Error can be used with that library.
+//
+// This method is not safe to be called concurrently and is no different
+// than accessing the Errors field directly. It is implementd only to
+// satisfy the errwrap.Wrapper interface.
+func (e *Error) WrappedErrors() []error {
+	return e.Errors
+}

Godeps/_workspace/src/github.com/hashicorp/go-multierror/multierror_test.go

+package multierror
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestError_Impl(t *testing.T) {
+	var _ error = new(Error)
+}
+
+func TestErrorError_custom(t *testing.T) {
+	errors := []error{
+		errors.New("foo"),
+		errors.New("bar"),
+	}
+
+	fn := func(es []error) string {
+		return "foo"
+	}
+
+	multi := &Error{Errors: errors, ErrorFormat: fn}
+	if multi.Error() != "foo" {
+		t.Fatalf("bad: %s", multi.Error())
+	}
+}
+
+func TestErrorError_default(t *testing.T) {
+	expected := `2 error(s) occurred:
+
+* foo
+* bar`
+
+	errors := []error{
+		errors.New("foo"),
+		errors.New("bar"),
+	}
+
+	multi := &Error{Errors: errors}
+	if multi.Error() != expected {
+		t.Fatalf("bad: %s", multi.Error())
+	}
+}
+
+func TestErrorErrorOrNil(t *testing.T) {
+	err := new(Error)
+	if err.ErrorOrNil() != nil {
+		t.Fatalf("bad: %#v", err.ErrorOrNil())
+	}
+
+	err.Errors = []error{errors.New("foo")}
+	if v := err.ErrorOrNil(); v == nil {
+		t.Fatal("should not be nil")
+	} else if !reflect.DeepEqual(v, err) {
+		t.Fatalf("bad: %#v", v)
+	}
+}
+
+func TestErrorWrappedErrors(t *testing.T) {
+	errors := []error{
+		errors.New("foo"),
+		errors.New("bar"),
+	}
+
+	multi := &Error{Errors: errors}
+	if !reflect.DeepEqual(multi.Errors, multi.WrappedErrors()) {
+		t.Fatalf("bad: %s", multi.WrappedErrors())
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/.gitignore

+y.output

Godeps/_workspace/src/github.com/hashicorp/hcl/Makefile

+TEST?=./...
+
+default: test
+
+fmt: generate
+	go fmt ./...
+
+test: generate
+	go test $(TEST) $(TESTARGS)
+
+generate:
+	go generate ./...
+
+updatedeps:
+	go get -u golang.org/x/tools/cmd/stringer
+
+.PHONY: default generate test updatedeps

Godeps/_workspace/src/github.com/hashicorp/hcl/README.md

+# HCL
+
+HCL (HashiCorp Configuration Language) is a configuration language built
+by HashiCorp. The goal of HCL is to build a structured configuration language
+that is both human and machine friendly for use with command-line tools, but
+specifically targeted towards DevOps tools, servers, etc.
+
+HCL is also fully JSON compatible. That is, JSON can be used as completely
+valid input to a system expecting HCL. This helps makes systems
+interoperable with other systems.
+
+HCL is heavily inspired by
+[libucl](https://github.com/vstakhov/libucl),
+nginx configuration, and others similar.
+
+## Why?
+
+A common question when viewing HCL is to ask the question: why not
+JSON, YAML, etc.?
+
+Prior to HCL, the tools we built at [HashiCorp](http://www.hashicorp.com)
+used a variety of configuration languages from full programming languages
+such as Ruby to complete data structure languages such as JSON. What we
+learned is that some people wanted human-friendly configuration languages
+and some people wanted machine-friendly languages.
+
+JSON fits a nice balance in this, but is fairly verbose and most
+importantly doesn't support comments. With YAML, we found that beginners
+had a really hard time determining what the actual structure was, and
+ended up guessing more than not whether to use a hyphen, colon, etc.
+in order to represent some configuration key.
+
+Full programming languages such as Ruby enable complex behavior
+a configuration language shouldn't usually allow, and also forces
+people to learn some set of Ruby.
+
+Because of this, we decided to create our own configuration language
+that is JSON-compatible. Our configuration language (HCL) is designed
+to be written and modified by humans. The API for HCL allows JSON
+as an input so that it is also machine-friendly (machines can generate
+JSON instead of trying to generate HCL).
+
+Our goal with HCL is not to alienate other configuration languages.
+It is instead to provide HCL as a specialized language for our tools,
+and JSON as the interoperability layer.
+
+## Syntax
+
+The complete grammar
+[can be found here](https://github.com/hashicorp/hcl/blob/master/hcl/parse.y),
+if you're more comfortable reading specifics, but a high-level overview
+of the syntax and grammar are listed here.
+
+  * Single line comments start with `#` or `//`
+
+  * Multi-line comments are wrapped in `/*` and `*/`. Nested block comments
+    are not allowed. A multi-line comment (also known as a block comment)
+    terminates at the first `*/` found.
+
+  * Values are assigned with the syntax `key = value` (whitespace doesn't
+    matter). The value can be any primitive: a string, number, boolean,
+    object, or list.
+
+  * Strings are double-quoted and can contain any UTF-8 characters.
+    Example: `"Hello, World"`
+
+  * Numbers are assumed to be base 10. If you prefix a number with 0x,
+    it is treated as a hexadecimal. If it is prefixed with 0, it is
+    treated as an octal. Numbers can be in scientific notation: "1e10".
+
+  * Boolean values: `true`, `false`
+
+  * Arrays can be made by wrapping it in `[]`. Example:
+    `["foo", "bar", 42]`. Arrays can contain primitives
+    and other arrays, but cannot contain objects. Objects must
+    use the block syntax shown below.
+
+Objects and nested objects are created using the structure shown below:
+
+```
+variable "ami" {
+    description = "the AMI to use"
+}
+```

Godeps/_workspace/src/github.com/hashicorp/hcl/decoder_test.go

+package hcl
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestDecode_interface(t *testing.T) {
+	cases := []struct {
+		File string
+		Err  bool
+		Out  interface{}
+	}{
+		{
+			"basic.hcl",
+			false,
+			map[string]interface{}{
+				"foo": "bar",
+				"bar": "${file(\"bing/bong.txt\")}",
+			},
+		},
+		{
+			"basic_squish.hcl",
+			false,
+			map[string]interface{}{
+				"foo":     "bar",
+				"bar":     "${file(\"bing/bong.txt\")}",
+				"foo-bar": "baz",
+			},
+		},
+		{
+			"empty.hcl",
+			false,
+			map[string]interface{}{
+				"resource": []map[string]interface{}{
+					map[string]interface{}{
+						"foo": []map[string]interface{}{
+							map[string]interface{}{},
+						},
+					},
+				},
+			},
+		},
+		{
+			"escape.hcl",
+			false,
+			map[string]interface{}{
+				"foo": "bar\"baz\\n",
+			},
+		},
+		{
+			"float.hcl",
+			false,
+			map[string]interface{}{
+				"a": 1.02,
+			},
+		},
+		{
+			"multiline_bad.hcl",
+			false,
+			map[string]interface{}{"foo": "bar\nbaz\n"},
+		},
+		{
+			"multiline.json",
+			false,
+			map[string]interface{}{"foo": "bar\nbaz"},
+		},
+		{
+			"scientific.json",
+			false,
+			map[string]interface{}{
+				"a": 1e-10,
+				"b": 1e+10,
+				"c": 1e10,
+				"d": 1.2e-10,
+				"e": 1.2e+10,
+				"f": 1.2e10,
+			},
+		},
+		{
+			"scientific.hcl",
+			false,
+			map[string]interface{}{
+				"a": 1e-10,
+				"b": 1e+10,
+				"c": 1e10,
+				"d": 1.2e-10,
+				"e": 1.2e+10,
+				"f": 1.2e10,
+			},
+		},
+		{
+			"terraform_heroku.hcl",
+			false,
+			map[string]interface{}{
+				"name": "terraform-test-app",
+				"config_vars": []map[string]interface{}{
+					map[string]interface{}{
+						"FOO": "bar",
+					},
+				},
+			},
+		},
+		{
+			"structure_multi.hcl",
+			false,
+			map[string]interface{}{
+				"foo": []map[string]interface{}{
+					map[string]interface{}{
+						"baz": []map[string]interface{}{
+							map[string]interface{}{"key": 7},
+						},
+					},
+					map[string]interface{}{
+						"bar": []map[string]interface{}{
+							map[string]interface{}{"key": 12},
+						},
+					},
+				},
+			},
+		},
+		{
+			"structure_multi.json",
+			false,
+			map[string]interface{}{
+				"foo": []map[string]interface{}{
+					map[string]interface{}{
+						"baz": []map[string]interface{}{
+							map[string]interface{}{"key": 7},
+						},
+						"bar": []map[string]interface{}{
+							map[string]interface{}{"key": 12},
+						},
+					},
+				},
+			},
+		},
+		{
+			"structure_list.hcl",
+			false,
+			map[string]interface{}{
+				"foo": []map[string]interface{}{
+					map[string]interface{}{
+						"key": 7,
+					},
+					map[string]interface{}{
+						"key": 12,
+					},
+				},
+			},
+		},
+		{
+			"structure_list.json",
+			false,
+			map[string]interface{}{
+				"foo": []interface{}{
+					map[string]interface{}{
+						"key": 7,
+					},
+					map[string]interface{}{
+						"key": 12,
+					},
+				},
+			},
+		},
+		{
+			"structure_list_deep.json",
+			false,
+			map[string]interface{}{
+				"bar": []map[string]interface{}{
+					map[string]interface{}{
+						"foo": []map[string]interface{}{
+							map[string]interface{}{
+								"name": "terraform_example",
+								"ingress": []interface{}{
+									map[string]interface{}{
+										"from_port": 22,
+									},
+									map[string]interface{}{
+										"from_port": 80,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+
+		{
+			"nested_block_comment.hcl",
+			false,
+			map[string]interface{}{
+				"bar": "value",
+			},
+		},
+
+		{
+			"unterminated_block_comment.hcl",
+			true,
+			nil,
+		},
+	}
+
+	for _, tc := range cases {
+		d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.File))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		var out interface{}
+		err = Decode(&out, string(d))
+		if (err != nil) != tc.Err {
+			t.Fatalf("Input: %s\n\nError: %s", tc.File, err)
+		}
+
+		if !reflect.DeepEqual(out, tc.Out) {
+			t.Fatalf("Input: %s\n\nActual: %#v\n\nExpected: %#v", tc.File, out, tc.Out)
+		}
+	}
+}
+
+func TestDecode_equal(t *testing.T) {
+	cases := []struct {
+		One, Two string
+	}{
+		{
+			"basic.hcl",
+			"basic.json",
+		},
+		{
+			"float.hcl",
+			"float.json",
+		},
+		/*
+			{
+				"structure.hcl",
+				"structure.json",
+			},
+		*/
+		{
+			"structure.hcl",
+			"structure_flat.json",
+		},
+		{
+			"terraform_heroku.hcl",
+			"terraform_heroku.json",
+		},
+	}
+
+	for _, tc := range cases {
+		p1 := filepath.Join(fixtureDir, tc.One)
+		p2 := filepath.Join(fixtureDir, tc.Two)
+
+		d1, err := ioutil.ReadFile(p1)
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		d2, err := ioutil.ReadFile(p2)
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		var i1, i2 interface{}
+		err = Decode(&i1, string(d1))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		err = Decode(&i2, string(d2))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		if !reflect.DeepEqual(i1, i2) {
+			t.Fatalf(
+				"%s != %s\n\n%#v\n\n%#v",
+				tc.One, tc.Two,
+				i1, i2)
+		}
+	}
+}
+
+func TestDecode_flatMap(t *testing.T) {
+	var val map[string]map[string]string
+
+	err := Decode(&val, testReadFile(t, "structure_flatmap.hcl"))
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	expected := map[string]map[string]string{
+		"foo": map[string]string{
+			"foo": "bar",
+			"key": "7",
+		},
+	}
+
+	if !reflect.DeepEqual(val, expected) {
+		t.Fatalf("Actual: %#v\n\nExpected: %#v", val, expected)
+	}
+}
+
+func TestDecode_structure(t *testing.T) {
+	type V struct {
+		Key int
+		Foo string
+	}
+
+	var actual V
+
+	err := Decode(&actual, testReadFile(t, "flat.hcl"))
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	expected := V{
+		Key: 7,
+		Foo: "bar",
+	}
+
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Actual: %#v\n\nExpected: %#v", actual, expected)
+	}
+}
+
+func TestDecode_structurePtr(t *testing.T) {
+	type V struct {
+		Key int
+		Foo string
+	}
+
+	var actual *V
+
+	err := Decode(&actual, testReadFile(t, "flat.hcl"))
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	expected := &V{
+		Key: 7,
+		Foo: "bar",
+	}
+
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Actual: %#v\n\nExpected: %#v", actual, expected)
+	}
+}
+
+func TestDecode_structureArray(t *testing.T) {
+	// This test is extracted from a failure in Consul (consul.io),
+	// hence the interesting structure naming.
+
+	type KeyPolicyType string
+
+	type KeyPolicy struct {
+		Prefix string `hcl:",key"`
+		Policy KeyPolicyType
+	}
+
+	type Policy struct {
+		Keys []KeyPolicy `hcl:"key,expand"`
+	}
+
+	expected := Policy{
+		Keys: []KeyPolicy{
+			KeyPolicy{
+				Prefix: "",
+				Policy: "read",
+			},
+			KeyPolicy{
+				Prefix: "foo/",
+				Policy: "write",
+			},
+			KeyPolicy{
+				Prefix: "foo/bar/",
+				Policy: "read",
+			},
+			KeyPolicy{
+				Prefix: "foo/bar/baz",
+				Policy: "deny",
+			},
+		},
+	}
+
+	files := []string{
+		"decode_policy.hcl",
+		"decode_policy.json",
+	}
+
+	for _, f := range files {
+		var actual Policy
+
+		err := Decode(&actual, testReadFile(t, f))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("Input: %s\n\nActual: %#v\n\nExpected: %#v", f, actual, expected)
+		}
+	}
+}
+
+func TestDecode_structureMap(t *testing.T) {
+	// This test is extracted from a failure in Terraform (terraform.io),
+	// hence the interesting structure naming.
+
+	type hclVariable struct {
+		Default     interface{}
+		Description string
+		Fields      []string `hcl:",decodedFields"`
+	}
+
+	type rawConfig struct {
+		Variable map[string]hclVariable
+	}
+
+	expected := rawConfig{
+		Variable: map[string]hclVariable{
+			"foo": hclVariable{
+				Default:     "bar",
+				Description: "bar",
+				Fields:      []string{"Default", "Description"},
+			},
+
+			"amis": hclVariable{
+				Default: []map[string]interface{}{
+					map[string]interface{}{
+						"east": "foo",
+					},
+				},
+				Fields: []string{"Default"},
+			},
+		},
+	}
+
+	files := []string{
+		"decode_tf_variable.hcl",
+		"decode_tf_variable.json",
+	}
+
+	for _, f := range files {
+		var actual rawConfig
+
+		err := Decode(&actual, testReadFile(t, f))
+		if err != nil {
+			t.Fatalf("Input: %s\n\nerr: %s", f, err)
+		}
+
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("Input: %s\n\nActual: %#v\n\nExpected: %#v", f, actual, expected)
+		}
+	}
+}
+
+func TestDecode_interfaceNonPointer(t *testing.T) {
+	var value interface{}
+	err := Decode(value, testReadFile(t, "basic_int_string.hcl"))
+	if err == nil {
+		t.Fatal("should error")
+	}
+}
+
+func TestDecode_intString(t *testing.T) {
+	var value struct {
+		Count int
+	}
+
+	err := Decode(&value, testReadFile(t, "basic_int_string.hcl"))
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if value.Count != 3 {
+		t.Fatalf("bad: %#v", value.Count)
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl.go

+// hcl is a package for decoding HCL into usable Go structures.
+//
+// hcl input can come in either pure HCL format or JSON format.
+// It can be parsed into an AST, and then decoded into a structure,
+// or it can be decoded directly from a string into a structure.
+//
+// If you choose to parse HCL into a raw AST, the benefit is that you
+// can write custom visitor implementations to implement custom
+// semantic checks. By default, HCL does not perform any semantic
+// checks.
+package hcl

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/hcl_test.go

+package hcl
+
+// This is the directory where our test fixtures are.
+const fixtureDir = "./test-fixtures"

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/lex.go

+package hcl
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"unicode"
+	"unicode/utf8"
+)
+
+//go:generate go tool yacc -p "hcl" parse.y
+
+// The parser expects the lexer to return 0 on EOF.
+const lexEOF = 0
+
+// The parser uses the type <prefix>Lex as a lexer.  It must provide
+// the methods Lex(*<prefix>SymType) int and Error(string).
+type hclLex struct {
+	Input string
+
+	lastNumber        bool
+	pos               int
+	width             int
+	col, line         int
+	lastCol, lastLine int
+	err               error
+}
+
+// The parser calls this method to get each new token.
+func (x *hclLex) Lex(yylval *hclSymType) int {
+	for {
+		c := x.next()
+		if c == lexEOF {
+			return lexEOF
+		}
+
+		// Ignore all whitespace except a newline which we handle
+		// specially later.
+		if unicode.IsSpace(c) {
+			x.lastNumber = false
+			continue
+		}
+
+		// Consume all comments
+		switch c {
+		case '#':
+			fallthrough
+		case '/':
+			// Starting comment
+			if !x.consumeComment(c) {
+				return lexEOF
+			}
+			continue
+		}
+
+		// If it is a number, lex the number
+		if c >= '0' && c <= '9' {
+			x.lastNumber = true
+			x.backup()
+			return x.lexNumber(yylval)
+		}
+
+		// This is a hacky way to find 'e' and lex it, but it works.
+		if x.lastNumber {
+			switch c {
+			case 'e':
+				fallthrough
+			case 'E':
+				switch x.next() {
+				case '+':
+					return EPLUS
+				case '-':
+					return EMINUS
+				default:
+					x.backup()
+					return EPLUS
+				}
+			}
+		}
+		x.lastNumber = false
+
+		switch c {
+		case '.':
+			return PERIOD
+		case '-':
+			return MINUS
+		case ',':
+			return x.lexComma()
+		case '=':
+			return EQUAL
+		case '[':
+			return LEFTBRACKET
+		case ']':
+			return RIGHTBRACKET
+		case '{':
+			return LEFTBRACE
+		case '}':
+			return RIGHTBRACE
+		case '"':
+			return x.lexString(yylval)
+		case '<':
+			return x.lexHeredoc(yylval)
+		default:
+			x.backup()
+			return x.lexId(yylval)
+		}
+	}
+}
+
+func (x *hclLex) consumeComment(c rune) bool {
+	single := c == '#'
+	if !single {
+		c = x.next()
+		if c != '/' && c != '*' {
+			x.backup()
+			x.createErr(fmt.Sprintf("comment expected, got '%c'", c))
+			return false
+		}
+
+		single = c == '/'
+	}
+
+	nested := 1
+	for {
+		c = x.next()
+		if c == lexEOF {
+			x.backup()
+			if single {
+				// Single line comments can end with an EOF
+				return true
+			}
+
+			// Multi-line comments must end with a */
+			x.createErr(fmt.Sprintf("end of multi-line comment expected, got EOF"))
+			return false
+		}
+
+		// Single line comments continue until a '\n'
+		if single {
+			if c == '\n' {
+				return true
+			}
+
+			continue
+		}
+
+		// Multi-line comments continue until a '*/'
+		switch c {
+		case '/':
+			c = x.next()
+			if c == '*' {
+				nested++
+			} else {
+				x.backup()
+			}
+		case '*':
+			c = x.next()
+			if c == '/' {
+				return true
+			} else {
+				x.backup()
+			}
+		default:
+			// Continue
+		}
+	}
+}
+
+// lexComma reads the comma
+func (x *hclLex) lexComma() int {
+	for {
+		c := x.peek()
+
+		// Consume space
+		if unicode.IsSpace(c) {
+			x.next()
+			continue
+		}
+
+		if c == ']' {
+			return COMMAEND
+		}
+
+		break
+	}
+
+	return COMMA
+}
+
+// lexId lexes an identifier
+func (x *hclLex) lexId(yylval *hclSymType) int {
+	var b bytes.Buffer
+	first := true
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if !unicode.IsDigit(c) && !unicode.IsLetter(c) &&
+			c != '_' && c != '-' && c != '.' {
+			x.backup()
+
+			if first {
+				x.createErr("Invalid identifier")
+				return lexEOF
+			}
+
+			break
+		}
+
+		first = false
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	yylval.str = b.String()
+
+	switch yylval.str {
+	case "true":
+		yylval.b = true
+		return BOOL
+	case "false":
+		yylval.b = false
+		return BOOL
+	}
+
+	return IDENTIFIER
+}
+
+// lexHeredoc extracts a string from the input in heredoc format
+func (x *hclLex) lexHeredoc(yylval *hclSymType) int {
+	if x.next() != '<' {
+		x.createErr("Heredoc must start with <<")
+		return lexEOF
+	}
+
+	// Now determine the marker
+	var buf bytes.Buffer
+	for {
+		c := x.next()
+		if c == lexEOF {
+			return lexEOF
+		}
+
+		// Newline signals the end of the marker
+		if c == '\n' {
+			break
+		}
+
+		if _, err := buf.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	marker := buf.String()
+	if marker == "" {
+		x.createErr("Heredoc must have a marker, e.g. <<FOO")
+		return lexEOF
+	}
+
+	check := true
+	buf.Reset()
+	for {
+		c := x.next()
+
+		// If we're checking, then check to see if we see the marker
+		if check {
+			check = false
+
+			var cs []rune
+			for _, r := range marker {
+				if r != c {
+					break
+				}
+
+				cs = append(cs, c)
+				c = x.next()
+			}
+			if len(cs) == len(marker) {
+				break
+			}
+
+			if len(cs) > 0 {
+				for _, c := range cs {
+					if _, err := buf.WriteRune(c); err != nil {
+						return lexEOF
+					}
+				}
+			}
+		}
+
+		if c == lexEOF {
+			return lexEOF
+		}
+
+		// If we hit a newline, then reset to check
+		if c == '\n' {
+			check = true
+		}
+
+		if _, err := buf.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	yylval.str = buf.String()
+	return STRING
+}
+
+// lexNumber lexes out a number
+func (x *hclLex) lexNumber(yylval *hclSymType) int {
+	var b bytes.Buffer
+	gotPeriod := false
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if c == '.' {
+			if gotPeriod {
+				x.backup()
+				break
+			}
+
+			gotPeriod = true
+		} else if c < '0' || c > '9' {
+			x.backup()
+			break
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			x.createErr(fmt.Sprintf("Internal error: %s", err))
+			return lexEOF
+		}
+	}
+
+	if !gotPeriod {
+		v, err := strconv.ParseInt(b.String(), 0, 0)
+		if err != nil {
+			x.createErr(fmt.Sprintf("Expected number: %s", err))
+			return lexEOF
+		}
+
+		yylval.num = int(v)
+		return NUMBER
+	}
+
+	f, err := strconv.ParseFloat(b.String(), 64)
+	if err != nil {
+		x.createErr(fmt.Sprintf("Expected float: %s", err))
+		return lexEOF
+	}
+
+	yylval.f = float64(f)
+	return FLOAT
+}
+
+// lexString extracts a string from the input
+func (x *hclLex) lexString(yylval *hclSymType) int {
+	braces := 0
+
+	var b bytes.Buffer
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		// String end
+		if c == '"' && braces == 0 {
+			break
+		}
+
+		// If we hit a newline, then its an error
+		if c == '\n' {
+			x.createErr(fmt.Sprintf("Newline before string closed"))
+			return lexEOF
+		}
+
+		// If we're escaping a quote, then escape the quote
+		if c == '\\' {
+			n := x.next()
+			switch n {
+			case '"':
+				c = n
+			case 'n':
+				c = '\n'
+			case '\\':
+				c = n
+			default:
+				x.backup()
+			}
+		}
+
+		// If we're starting into variable, mark it
+		if braces == 0 && c == '$' && x.peek() == '{' {
+			braces += 1
+
+			if _, err := b.WriteRune(c); err != nil {
+				return lexEOF
+			}
+			c = x.next()
+		} else if braces > 0 && c == '{' {
+			braces += 1
+		}
+		if braces > 0 && c == '}' {
+			braces -= 1
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	yylval.str = b.String()
+	return STRING
+}
+
+// Return the next rune for the lexer.
+func (x *hclLex) next() rune {
+	if int(x.pos) >= len(x.Input) {
+		x.width = 0
+		return lexEOF
+	}
+
+	r, w := utf8.DecodeRuneInString(x.Input[x.pos:])
+	x.width = w
+	x.pos += x.width
+
+	x.col += 1
+	if x.line == 0 {
+		x.line = 1
+	}
+	if r == '\n' {
+		x.line += 1
+		x.col = 0
+	}
+
+	return r
+}
+
+// peek returns but does not consume the next rune in the input
+func (x *hclLex) peek() rune {
+	r := x.next()
+	x.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per next.
+func (x *hclLex) backup() {
+	x.col -= 1
+	x.pos -= x.width
+}
+
+// createErr records the given error
+func (x *hclLex) createErr(msg string) {
+	x.err = fmt.Errorf("Line %d, column %d: %s", x.line, x.col, msg)
+}
+
+// The parser calls this method on a parse error.
+func (x *hclLex) Error(s string) {
+	x.createErr(s)
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/lex_test.go

+package hcl
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestLex(t *testing.T) {
+	cases := []struct {
+		Input  string
+		Output []int
+	}{
+		{
+			"comment.hcl",
+			[]int{IDENTIFIER, EQUAL, STRING, lexEOF},
+		},
+		{
+			"comment_single.hcl",
+			[]int{lexEOF},
+		},
+		{
+			"complex_key.hcl",
+			[]int{IDENTIFIER, EQUAL, STRING, lexEOF},
+		},
+		{
+			"multiple.hcl",
+			[]int{
+				IDENTIFIER, EQUAL, STRING,
+				IDENTIFIER, EQUAL, NUMBER,
+				lexEOF,
+			},
+		},
+		{
+			"list.hcl",
+			[]int{
+				IDENTIFIER, EQUAL, LEFTBRACKET,
+				NUMBER, COMMA, NUMBER, COMMA, STRING,
+				RIGHTBRACKET, lexEOF,
+			},
+		},
+		{
+			"old.hcl",
+			[]int{IDENTIFIER, EQUAL, LEFTBRACE, STRING, lexEOF},
+		},
+		{
+			"structure_basic.hcl",
+			[]int{
+				IDENTIFIER, LEFTBRACE,
+				IDENTIFIER, EQUAL, NUMBER,
+				STRING, EQUAL, NUMBER,
+				STRING, EQUAL, NUMBER,
+				RIGHTBRACE, lexEOF,
+			},
+		},
+		{
+			"structure.hcl",
+			[]int{
+				IDENTIFIER, IDENTIFIER, STRING, LEFTBRACE,
+				IDENTIFIER, EQUAL, NUMBER,
+				IDENTIFIER, EQUAL, STRING,
+				RIGHTBRACE, lexEOF,
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Input))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		l := &hclLex{Input: string(d)}
+		var actual []int
+		for {
+			token := l.Lex(new(hclSymType))
+			actual = append(actual, token)
+
+			if token == lexEOF {
+				break
+			}
+
+			if len(actual) > 500 {
+				t.Fatalf("Input:%s\n\nExausted.", tc.Input)
+			}
+		}
+
+		if !reflect.DeepEqual(actual, tc.Output) {
+			t.Fatalf(
+				"Input: %s\n\nBad: %#v\n\nExpected: %#v",
+				tc.Input, actual, tc.Output)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/object.go

+package hcl
+
+import (
+	"fmt"
+	"strings"
+)
+
+//go:generate stringer -type=ValueType
+
+// ValueType is an enum represnting the type of a value in
+// a LiteralNode.
+type ValueType byte
+
+const (
+	ValueTypeUnknown ValueType = iota
+	ValueTypeFloat
+	ValueTypeInt
+	ValueTypeString
+	ValueTypeBool
+	ValueTypeNil
+	ValueTypeList
+	ValueTypeObject
+)
+
+// Object represents any element of HCL: an object itself, a list,
+// a literal, etc.
+type Object struct {
+	Key   string
+	Type  ValueType
+	Value interface{}
+	Next  *Object
+}
+
+// GoString is an implementation of the GoStringer interface.
+func (o *Object) GoString() string {
+	return fmt.Sprintf("*%#v", *o)
+}
+
+// Get gets all the objects that match the given key.
+//
+// It returns the resulting objects as a single Object structure with
+// the linked list populated.
+func (o *Object) Get(k string, insensitive bool) *Object {
+	if o.Type != ValueTypeObject {
+		return nil
+	}
+
+	for _, o := range o.Elem(true) {
+		if o.Key != k {
+			if !insensitive || !strings.EqualFold(o.Key, k) {
+				continue
+			}
+		}
+
+		return o
+	}
+
+	return nil
+}
+
+// Elem returns all the elements that are part of this object.
+func (o *Object) Elem(expand bool) []*Object {
+	if !expand {
+		result := make([]*Object, 0, 1)
+		current := o
+		for current != nil {
+			obj := *current
+			obj.Next = nil
+			result = append(result, &obj)
+
+			current = current.Next
+		}
+
+		return result
+	}
+
+	if o.Value == nil {
+		return nil
+	}
+
+	switch o.Type {
+	case ValueTypeList:
+		return o.Value.([]*Object)
+	case ValueTypeObject:
+		result := make([]*Object, 0, 5)
+		for _, obj := range o.Elem(false) {
+			result = append(result, obj.Value.([]*Object)...)
+		}
+		return result
+	default:
+		return []*Object{o}
+	}
+}
+
+// Len returns the number of objects in this object structure.
+func (o *Object) Len() (i int) {
+	current := o
+	for current != nil {
+		i += 1
+		current = current.Next
+	}
+
+	return
+}
+
+// ObjectList is a list of objects.
+type ObjectList []*Object
+
+// Flat returns a flattened list structure of the objects.
+func (l ObjectList) Flat() []*Object {
+	m := make(map[string]*Object)
+	result := make([]*Object, 0, len(l))
+	for _, obj := range l {
+		prev, ok := m[obj.Key]
+		if !ok {
+			m[obj.Key] = obj
+			result = append(result, obj)
+			continue
+		}
+
+		for prev.Next != nil {
+			prev = prev.Next
+		}
+		prev.Next = obj
+	}
+
+	return result
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/parse.go

+package hcl
+
+import (
+	"sync"
+
+	"github.com/hashicorp/go-multierror"
+)
+
+// hclErrors are the errors built up from parsing. These should not
+// be accessed directly.
+var hclErrors []error
+var hclLock sync.Mutex
+var hclResult *Object
+
+// Parse parses the given string and returns the result.
+func Parse(v string) (*Object, error) {
+	hclLock.Lock()
+	defer hclLock.Unlock()
+	hclErrors = nil
+	hclResult = nil
+
+	// Parse
+	lex := &hclLex{Input: v}
+	hclParse(lex)
+
+	// If we have an error in the lexer itself, return it
+	if lex.err != nil {
+		return nil, lex.err
+	}
+
+	// Build up the errors
+	var err error
+	if len(hclErrors) > 0 {
+		err = &multierror.Error{Errors: hclErrors}
+		hclResult = nil
+	}
+
+	return hclResult, err
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/parse.y

+// This is the yacc input for creating the parser for HCL.
+
+%{
+package hcl
+
+import (
+	"fmt"
+	"strconv"
+)
+
+%}
+
+%union {
+	b        bool
+	f        float64
+	num      int
+	str      string
+	obj      *Object
+	objlist  []*Object
+}
+
+%type   <f> float
+%type   <num> int
+%type   <objlist> list listitems objectlist
+%type   <obj> block number object objectitem
+%type   <obj> listitem
+%type   <str> blockId exp objectkey
+
+%token  <b> BOOL
+%token  <f> FLOAT
+%token  <num> NUMBER
+%token  <str> COMMA COMMAEND IDENTIFIER EQUAL NEWLINE STRING MINUS
+%token  <str> LEFTBRACE RIGHTBRACE LEFTBRACKET RIGHTBRACKET PERIOD
+%token  <str> EPLUS EMINUS
+
+%%
+
+top:
+   {
+        hclResult = &Object{Type: ValueTypeObject}
+    }
+|   objectlist
+	{
+		hclResult = &Object{
+			Type:  ValueTypeObject,
+			Value: ObjectList($1).Flat(),
+		}
+	}
+
+objectlist:
+	objectitem
+	{
+		$$ = []*Object{$1}
+	}
+|	objectlist objectitem
+	{
+		$$ = append($1, $2)
+	}
+
+object:
+	LEFTBRACE objectlist RIGHTBRACE
+	{
+		$$ = &Object{
+			Type:  ValueTypeObject,
+			Value: ObjectList($2).Flat(),
+		}
+	}
+|	LEFTBRACE RIGHTBRACE
+	{
+		$$ = &Object{
+			Type: ValueTypeObject,
+		}
+	}
+
+objectkey:
+	IDENTIFIER
+	{
+		$$ = $1
+	}
+|	STRING
+	{
+		$$ = $1
+	}
+
+objectitem:
+	objectkey EQUAL number
+	{
+		$$ = $3
+		$$.Key = $1
+	}
+|	objectkey EQUAL BOOL
+	{
+		$$ = &Object{
+			Key:   $1,
+			Type:  ValueTypeBool,
+			Value: $3,
+		}
+	}
+|	objectkey EQUAL STRING
+	{
+		$$ = &Object{
+			Key:   $1,
+			Type:  ValueTypeString,
+			Value: $3,
+		}
+	}
+|	objectkey EQUAL object
+	{
+		$3.Key = $1
+		$$ = $3
+	}
+|	objectkey EQUAL list
+	{
+		$$ = &Object{
+			Key:   $1,
+			Type:  ValueTypeList,
+			Value: $3,
+		}
+	}
+|	block
+	{
+		$$ = $1
+	}
+
+block:
+	blockId object
+	{
+		$2.Key = $1
+		$$ = $2
+	}
+|	blockId block
+	{
+		$$ = &Object{
+			Key:   $1,
+			Type:  ValueTypeObject,
+			Value: []*Object{$2},
+		}
+	}
+
+blockId:
+	IDENTIFIER
+	{
+		$$ = $1
+	}
+|	STRING
+	{
+		$$ = $1
+	}
+
+list:
+	LEFTBRACKET listitems RIGHTBRACKET
+	{
+		$$ = $2
+	}
+|	LEFTBRACKET RIGHTBRACKET
+	{
+		$$ = nil
+	}
+
+listitems:
+	listitem
+	{
+		$$ = []*Object{$1}
+	}
+|	listitems COMMA listitem
+	{
+		$$ = append($1, $3)
+	}
+|	listitems COMMAEND
+	{
+		$$ = $1
+	}
+
+listitem:
+	number
+	{
+		$$ = $1
+	}
+|	STRING
+	{
+		$$ = &Object{
+			Type:  ValueTypeString,
+			Value: $1,
+		}
+	}
+
+number:
+	int
+	{
+		$$ = &Object{
+			Type:  ValueTypeInt,
+			Value: $1,
+		}
+	}
+|	float
+	{
+		$$ = &Object{
+			Type:  ValueTypeFloat,
+			Value: $1,
+		}
+	}
+|   int exp
+    {
+		fs := fmt.Sprintf("%d%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &Object{
+			Type:  ValueTypeFloat,
+			Value: f,
+		}
+    }
+|   float exp
+    {
+		fs := fmt.Sprintf("%f%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &Object{
+			Type:  ValueTypeFloat,
+			Value: f,
+		}
+    }
+
+int:
+	MINUS int
+	{
+		$$ = $2 * -1
+	}
+|	NUMBER
+	{
+		$$ = $1
+	}
+
+float:
+	 MINUS float
+	{
+		$$ = $2 * -1
+	}
+|	FLOAT
+	{
+		$$ = $1
+	}
+
+exp:
+    EPLUS NUMBER
+    {
+        $$ = "e" + strconv.FormatInt(int64($2), 10)
+    }
+|   EMINUS NUMBER
+    {
+        $$ = "e-" + strconv.FormatInt(int64($2), 10)
+    }
+
+%%

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/parse_test.go

+package hcl
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"testing"
+)
+
+func TestParse(t *testing.T) {
+	cases := []struct {
+		Name string
+		Err  bool
+	}{
+		{
+			"assign_colon.hcl",
+			true,
+		},
+		{
+			"comment.hcl",
+			false,
+		},
+		{
+			"comment_single.hcl",
+			false,
+		},
+		{
+			"empty.hcl",
+			false,
+		},
+		{
+			"list_comma.hcl",
+			false,
+		},
+		{
+			"multiple.hcl",
+			false,
+		},
+		{
+			"structure.hcl",
+			false,
+		},
+		{
+			"structure_basic.hcl",
+			false,
+		},
+		{
+			"structure_empty.hcl",
+			false,
+		},
+		{
+			"complex.hcl",
+			false,
+		},
+		{
+			"assign_deep.hcl",
+			true,
+		},
+		{
+			"types.hcl",
+			false,
+		},
+	}
+
+	for _, tc := range cases {
+		d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Name))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		_, err = Parse(string(d))
+		if (err != nil) != tc.Err {
+			t.Fatalf("Input: %s\n\nError: %s", tc.Name, err)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/assign_colon.hcl

+resource = [{
+	"foo": {
+		"bar": {},
+		"baz": [1, 2, "foo"],
+	}
+}]

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/assign_deep.hcl

+resource = [{
+	foo = [{
+		bar = {}
+	}]
+}]

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/comment.hcl

+// Foo
+
+/* Bar */
+
+/*
+/*
+Baz
+*/
+
+# Another
+
+# Multiple
+# Lines
+
+foo = "bar"

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/comment_single.hcl

+# Hello

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/complex.hcl

+// This comes from Terraform, as a test
+variable "foo" {
+    default = "bar"
+    description = "bar"
+}
+
+provider "aws" {
+  access_key = "foo"
+  secret_key = "bar"
+}
+
+provider "do" {
+  api_key = "${var.foo}"
+}
+
+resource "aws_security_group" "firewall" {
+    count = 5
+}
+
+resource aws_instance "web" {
+    ami = "${var.foo}"
+    security_groups = [
+        "foo",
+        "${aws_security_group.firewall.foo}"
+    ]
+
+    network_interface {
+        device_index = 0
+        description = "Main network interface"
+    }
+}
+
+resource "aws_instance" "db" {
+    security_groups = "${aws_security_group.firewall.*.id}"
+    VPC = "foo"
+
+    depends_on = ["aws_instance.web"]
+}
+
+output "web_ip" {
+    value = "${aws_instance.web.private_ip}"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/complex_key.hcl

+foo.bar = "baz"

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/list.hcl

+foo = [1, 2, "foo"]

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/list_comma.hcl

+foo = [1, 2, "foo",]

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/multiple.hcl

+foo = "bar"
+key = 7

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/old.hcl

+default = {
+    "eu-west-1": "ami-b1cf19c6",
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/structure.hcl

+// This is a test structure for the lexer
+foo bar "baz" {
+	key = 7
+	foo = "bar"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/structure_basic.hcl

+foo {
+	value = 7
+	"value" = 8
+	"complex::value" = 9
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/structure_empty.hcl

+resource "foo" "bar" {}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/test-fixtures/types.hcl

+foo = "bar"
+bar = 7
+baz = [1,2,3]
+foo = -12
+bar = 3.14159
+foo = true
+bar = false

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl/valuetype_string.go

+// generated by stringer -type=ValueType; DO NOT EDIT
+
+package hcl
+
+import "fmt"
+
+const _ValueType_name = "ValueTypeUnknownValueTypeFloatValueTypeIntValueTypeStringValueTypeBoolValueTypeNilValueTypeListValueTypeObject"
+
+var _ValueType_index = [...]uint8{0, 16, 30, 42, 57, 70, 82, 95, 110}
+
+func (i ValueType) String() string {
+	if i >= ValueType(len(_ValueType_index)-1) {
+		return fmt.Sprintf("ValueType(%d)", i)
+	}
+	return _ValueType_name[_ValueType_index[i]:_ValueType_index[i+1]]
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/hcl_test.go

+package hcl
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"testing"
+)
+
+// This is the directory where our test fixtures are.
+const fixtureDir = "./test-fixtures"
+
+func testReadFile(t *testing.T, n string) string {
+	d, err := ioutil.ReadFile(filepath.Join(fixtureDir, n))
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return string(d)
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/json_test.go

+package json
+
+// This is the directory where our test fixtures are.
+const fixtureDir = "./test-fixtures"

Godeps/_workspace/src/github.com/hashicorp/hcl/json/lex.go

+package json
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"unicode"
+	"unicode/utf8"
+)
+
+//go:generate go tool yacc -p "json" parse.y
+
+// This marks the end of the lexer
+const lexEOF = 0
+
+// The parser uses the type <prefix>Lex as a lexer.  It must provide
+// the methods Lex(*<prefix>SymType) int and Error(string).
+type jsonLex struct {
+	Input string
+
+	pos       int
+	width     int
+	col, line int
+	err       error
+}
+
+// The parser calls this method to get each new token.
+func (x *jsonLex) Lex(yylval *jsonSymType) int {
+	for {
+		c := x.next()
+		if c == lexEOF {
+			return lexEOF
+		}
+
+		// Ignore all whitespace except a newline which we handle
+		// specially later.
+		if unicode.IsSpace(c) {
+			continue
+		}
+
+		// If it is a number, lex the number
+		if c >= '0' && c <= '9' {
+			x.backup()
+			return x.lexNumber(yylval)
+		}
+
+		switch c {
+		case 'e':
+			fallthrough
+		case 'E':
+			switch x.next() {
+			case '+':
+				return EPLUS
+			case '-':
+				return EMINUS
+			default:
+				x.backup()
+				return EPLUS
+			}
+		case '.':
+			return PERIOD
+		case '-':
+			return MINUS
+		case ':':
+			return COLON
+		case ',':
+			return COMMA
+		case '[':
+			return LEFTBRACKET
+		case ']':
+			return RIGHTBRACKET
+		case '{':
+			return LEFTBRACE
+		case '}':
+			return RIGHTBRACE
+		case '"':
+			return x.lexString(yylval)
+		default:
+			x.backup()
+			return x.lexId(yylval)
+		}
+	}
+}
+
+// lexId lexes an identifier
+func (x *jsonLex) lexId(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	first := true
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if !unicode.IsDigit(c) && !unicode.IsLetter(c) && c != '_' && c != '-' {
+			x.backup()
+
+			if first {
+				x.createErr("Invalid identifier")
+				return lexEOF
+			}
+
+			break
+		}
+
+		first = false
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	switch v := b.String(); v {
+	case "true":
+		return TRUE
+	case "false":
+		return FALSE
+	case "null":
+		return NULL
+	default:
+		x.createErr(fmt.Sprintf("Invalid identifier: %s", v))
+		return lexEOF
+	}
+}
+
+// lexNumber lexes out a number
+func (x *jsonLex) lexNumber(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	gotPeriod := false
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if c == '.' {
+			if gotPeriod {
+				x.backup()
+				break
+			}
+
+			gotPeriod = true
+		} else if c < '0' || c > '9' {
+			x.backup()
+			break
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			x.createErr(fmt.Sprintf("Internal error: %s", err))
+			return lexEOF
+		}
+	}
+
+	if !gotPeriod {
+		v, err := strconv.ParseInt(b.String(), 0, 0)
+		if err != nil {
+			x.createErr(fmt.Sprintf("Expected number: %s", err))
+			return lexEOF
+		}
+
+		yylval.num = int(v)
+		return NUMBER
+	}
+
+	f, err := strconv.ParseFloat(b.String(), 64)
+	if err != nil {
+		x.createErr(fmt.Sprintf("Expected float: %s", err))
+		return lexEOF
+	}
+
+	yylval.f = float64(f)
+	return FLOAT
+}
+
+// lexString extracts a string from the input
+func (x *jsonLex) lexString(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		// String end
+		if c == '"' {
+			break
+		}
+
+		// If we're escaping a quote, then escape the quote
+		if c == '\\' {
+			n := x.next()
+			switch n {
+			case '"':
+				c = n
+			case 'n':
+				c = '\n'
+			case '\\':
+				c = n
+			default:
+				x.backup()
+			}
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	yylval.str = b.String()
+	return STRING
+}
+
+// Return the next rune for the lexer.
+func (x *jsonLex) next() rune {
+	if int(x.pos) >= len(x.Input) {
+		x.width = 0
+		return lexEOF
+	}
+
+	r, w := utf8.DecodeRuneInString(x.Input[x.pos:])
+	x.width = w
+	x.pos += x.width
+
+	x.col += 1
+	if x.line == 0 {
+		x.line = 1
+	}
+	if r == '\n' {
+		x.line += 1
+		x.col = 0
+	}
+
+	return r
+}
+
+// peek returns but does not consume the next rune in the input
+func (x *jsonLex) peek() rune {
+	r := x.next()
+	x.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per next.
+func (x *jsonLex) backup() {
+	x.col -= 1
+	x.pos -= x.width
+}
+
+// createErr records the given error
+func (x *jsonLex) createErr(msg string) {
+	x.err = fmt.Errorf("Line %d, column %d: %s", x.line, x.col, msg)
+}
+
+// The parser calls this method on a parse error.
+func (x *jsonLex) Error(s string) {
+	x.createErr(s)
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/lex_test.go

+package json
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestLexJson(t *testing.T) {
+	cases := []struct {
+		Input  string
+		Output []int
+	}{
+		{
+			"basic.json",
+			[]int{
+				LEFTBRACE,
+				STRING, COLON, STRING,
+				RIGHTBRACE,
+				lexEOF,
+			},
+		},
+		{
+			"array.json",
+			[]int{
+				LEFTBRACE,
+				STRING, COLON, LEFTBRACKET,
+				NUMBER, COMMA, NUMBER, COMMA, STRING,
+				RIGHTBRACKET, COMMA,
+				STRING, COLON, STRING,
+				RIGHTBRACE,
+				lexEOF,
+			},
+		},
+		{
+			"object.json",
+			[]int{
+				LEFTBRACE,
+				STRING, COLON, LEFTBRACE,
+				STRING, COLON, LEFTBRACKET,
+				NUMBER, COMMA, NUMBER,
+				RIGHTBRACKET,
+				RIGHTBRACE,
+				RIGHTBRACE,
+				lexEOF,
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Input))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		l := &jsonLex{Input: string(d)}
+		var actual []int
+		for {
+			token := l.Lex(new(jsonSymType))
+			actual = append(actual, token)
+
+			if token == lexEOF {
+				break
+			}
+
+			if len(actual) > 500 {
+				t.Fatalf("Input:%s\n\nExausted.", tc.Input)
+			}
+		}
+
+		if !reflect.DeepEqual(actual, tc.Output) {
+			t.Fatalf(
+				"Input: %s\n\nBad: %#v\n\nExpected: %#v",
+				tc.Input, actual, tc.Output)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/parse.go

+package json
+
+import (
+	"sync"
+
+	"github.com/hashicorp/hcl/hcl"
+	"github.com/hashicorp/go-multierror"
+)
+
+// jsonErrors are the errors built up from parsing. These should not
+// be accessed directly.
+var jsonErrors []error
+var jsonLock sync.Mutex
+var jsonResult *hcl.Object
+
+// Parse parses the given string and returns the result.
+func Parse(v string) (*hcl.Object, error) {
+	jsonLock.Lock()
+	defer jsonLock.Unlock()
+	jsonErrors = nil
+	jsonResult = nil
+
+	// Parse
+	lex := &jsonLex{Input: v}
+	jsonParse(lex)
+
+	// If we have an error in the lexer itself, return it
+	if lex.err != nil {
+		return nil, lex.err
+	}
+
+	// Build up the errors
+	var err error
+	if len(jsonErrors) > 0 {
+		err = &multierror.Error{Errors: jsonErrors}
+		jsonResult = nil
+	}
+
+	return jsonResult, err
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/parse.y

+// This is the yacc input for creating the parser for HCL JSON.
+
+%{
+package json
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/hashicorp/hcl/hcl"
+)
+
+%}
+
+%union {
+	f        float64
+	num      int
+	str      string
+	obj      *hcl.Object
+	objlist  []*hcl.Object
+}
+
+%type	<f> float
+%type	<num> int
+%type	<obj> number object pair value
+%type	<objlist> array elements members
+%type	<str> exp
+
+%token  <f> FLOAT
+%token  <num> NUMBER
+%token  <str> COLON COMMA IDENTIFIER EQUAL NEWLINE STRING
+%token  <str> LEFTBRACE RIGHTBRACE LEFTBRACKET RIGHTBRACKET
+%token  <str> TRUE FALSE NULL MINUS PERIOD EPLUS EMINUS
+
+%%
+
+top:
+	object
+	{
+		jsonResult = $1
+	}
+
+object:
+	LEFTBRACE members RIGHTBRACE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeObject,
+			Value: hcl.ObjectList($2).Flat(),
+		}
+	}
+|	LEFTBRACE RIGHTBRACE
+	{
+		$$ = &hcl.Object{Type: hcl.ValueTypeObject}
+	}
+
+members:
+	pair
+	{
+		$$ = []*hcl.Object{$1}
+	}
+|	members COMMA pair
+	{
+		$$ = append($1, $3)
+	}
+
+pair:
+	STRING COLON value
+	{
+		$3.Key = $1
+		$$ = $3
+	}
+
+value:
+	STRING
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeString,
+			Value: $1,
+		}
+	}
+|	number
+	{
+		$$ = $1
+	}
+|	object
+	{
+		$$ = $1
+	}
+|	array
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeList,
+			Value: $1,
+		}
+	}
+|	TRUE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeBool,
+			Value: true,
+		}
+	}
+|	FALSE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeBool,
+			Value: false,
+		}
+	}
+|	NULL
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeNil,
+			Value: nil,
+		}
+	}
+
+array:
+	LEFTBRACKET RIGHTBRACKET
+	{
+		$$ = nil
+	}
+|	LEFTBRACKET elements RIGHTBRACKET
+	{
+		$$ = $2
+	}
+
+elements:
+	value
+	{
+		$$ = []*hcl.Object{$1}
+	}
+|	elements COMMA value
+	{
+		$$ = append($1, $3)
+	}
+
+number:
+	int
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeInt,
+			Value: $1,
+		}
+	}
+|	float
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: $1,
+		}
+	}
+|   int exp
+    {
+		fs := fmt.Sprintf("%d%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: f,
+		}
+    }
+|   float exp
+    {
+		fs := fmt.Sprintf("%f%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: f,
+		}
+    }
+
+int:
+	MINUS int
+	{
+		$$ = $2 * -1
+	}
+|	NUMBER
+	{
+		$$ = $1
+	}
+
+float:
+	 MINUS float
+	{
+		$$ = $2 * -1
+	}
+|	FLOAT
+	{
+		$$ = $1
+	}
+
+exp:
+    EPLUS NUMBER
+    {
+        $$ = "e" + strconv.FormatInt(int64($2), 10)
+    }
+|   EMINUS NUMBER
+    {
+        $$ = "e-" + strconv.FormatInt(int64($2), 10)
+    }
+
+%%

Godeps/_workspace/src/github.com/hashicorp/hcl/json/parse_test.go

+package json
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"testing"
+)
+
+func TestParse(t *testing.T) {
+	cases := []struct {
+		Name string
+		Err  bool
+	}{
+		{
+			"basic.json",
+			false,
+		},
+		{
+			"object.json",
+			false,
+		},
+		{
+			"array.json",
+			false,
+		},
+		{
+			"types.json",
+			false,
+		},
+	}
+
+	for _, tc := range cases {
+		d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Name))
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		_, err = Parse(string(d))
+		if (err != nil) != tc.Err {
+			t.Fatalf("Input: %s\n\nError: %s", tc.Name, err)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/test-fixtures/array.json

+{
+	"foo": [1, 2, "bar"],
+	"bar": "baz"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/test-fixtures/basic.json

+{
+	"foo": "bar"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/test-fixtures/object.json

+{
+	"foo": {
+		"bar": [1,2]
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/json/test-fixtures/types.json

+{
+	"foo": "bar",
+	"bar": 7,
+	"baz": [1,2,3],
+	"foo": -12,
+	"bar": 3.14159,
+    "foo": true,
+    "bar": false,
+    "foo": null
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/lex.go

+package hcl
+
+import (
+	"unicode"
+)
+
+type lexModeValue byte
+
+const (
+	lexModeUnknown lexModeValue = iota
+	lexModeHcl
+	lexModeJson
+)
+
+// lexMode returns whether we're going to be parsing in JSON
+// mode or HCL mode.
+func lexMode(v string) lexModeValue {
+	for _, r := range v {
+		if unicode.IsSpace(r) {
+			continue
+		}
+
+		if r == '{' {
+			return lexModeJson
+		} else {
+			return lexModeHcl
+		}
+	}
+
+	return lexModeHcl
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/lex_test.go

+package hcl
+
+import (
+	"testing"
+)
+
+func TestLexMode(t *testing.T) {
+	cases := []struct {
+		Input string
+		Mode  lexModeValue
+	}{
+		{
+			"",
+			lexModeHcl,
+		},
+		{
+			"foo",
+			lexModeHcl,
+		},
+		{
+			"{}",
+			lexModeJson,
+		},
+		{
+			"  {}",
+			lexModeJson,
+		},
+	}
+
+	for i, tc := range cases {
+		actual := lexMode(tc.Input)
+
+		if actual != tc.Mode {
+			t.Fatalf("%d: %#v", i, actual)
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/parse.go

+package hcl
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/hcl"
+	"github.com/hashicorp/hcl/json"
+)
+
+// Parse parses the given input and returns the root object.
+//
+// The input format can be either HCL or JSON.
+func Parse(input string) (*hcl.Object, error) {
+	switch lexMode(input) {
+	case lexModeHcl:
+		return hcl.Parse(input)
+	case lexModeJson:
+		return json.Parse(input)
+	}
+
+	return nil, fmt.Errorf("unknown config format")
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/basic.hcl

+foo = "bar"
+bar = "${file("bing/bong.txt")}"

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/basic.json

+{
+	"foo": "bar",
+    "bar": "${file(\"bing/bong.txt\")}"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/basic_int_string.hcl

+count = "3"

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/basic_squish.hcl

+foo="bar"
+bar="${file("bing/bong.txt")}"
+foo-bar="baz"

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/decode_policy.hcl

+key "" {
+	policy = "read"
+}
+
+key "foo/" {
+	policy = "write"
+}
+
+key "foo/bar/" {
+	policy = "read"
+}
+
+key "foo/bar/baz" {
+	policy = "deny"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/decode_policy.json

+{
+    "key": {
+        "": {
+            "policy": "read"
+        },
+
+        "foo/": {
+            "policy": "write"
+        },
+
+        "foo/bar/": {
+            "policy": "read"
+        },
+
+        "foo/bar/baz": {
+            "policy": "deny"
+        }
+    }
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/decode_tf_variable.hcl

+variable "foo" {
+    default = "bar"
+    description = "bar"
+}
+
+variable "amis" {
+    default = {
+        east = "foo"
+    }
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/decode_tf_variable.json

+{
+    "variable": {
+        "foo": {
+            "default": "bar",
+            "description": "bar"
+        },
+
+        "amis": {
+            "default": {
+                "east": "foo"
+            }
+        }
+    }
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/empty.hcl

+resource "foo" {}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/escape.hcl

+foo = "bar\"baz\\n"

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/flat.hcl

+foo = "bar"
+Key = 7

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/float.hcl

+a = 1.02

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/float.json

+{
+	"a": 1.02
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/multiline.json

+{
+    "foo": "bar\nbaz"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/multiline_bad.hcl

+foo = <<EOF
+bar
+baz
+EOF

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/nested_block_comment.hcl

+/*
+foo = "bar/*"
+*/
+
+bar = "value"

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/scientific.hcl

+a = 1e-10
+b = 1e+10
+c = 1e10
+d = 1.2e-10
+e = 1.2e+10
+f = 1.2e10

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/scientific.json

+{
+    "a": 1e-10,
+    "b": 1e+10,
+    "c": 1e10,
+    "d": 1.2e-10,
+    "e": 1.2e+10,
+    "f": 1.2e10
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure.hcl

+// This is a test structure for the lexer
+foo "baz" {
+	key = 7
+	foo = "bar"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure.json

+{
+	"foo": [{
+		"baz": [{
+			"key": 7,
+			"foo": "bar"
+		}]
+	}]
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure2.hcl

+// This is a test structure for the lexer
+foo "baz" {
+	key = 7
+	foo = "bar"
+}
+
+foo {
+	key = 7
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure2.json

+{
+	"foo": [{
+		"baz": {
+			"key": 7,
+			"foo": "bar"
+		}
+    }, {
+		"key": 7
+	}]
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure_flat.json

+{
+	"foo": {
+		"baz": {
+			"key": 7,
+			"foo": "bar"
+		}
+	}
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure_flatmap.hcl

+foo {
+	key = 7
+}
+
+foo {
+	foo = "bar"
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure_list.hcl

+foo {
+    key = 7
+}
+foo {
+    key = 12
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure_list.json

+{
+	"foo": [{
+        "key": 7
+    }, {
+        "key": 12
+    }]
+}

Godeps/_workspace/src/github.com/hashicorp/hcl/test-fixtures/structure_list_deep.json

+{
+    "bar": {
+        "foo": {
+            "name": "terraform_example",
+            "ingress": [
+                {
+                    "from_port": 22
+                },
+                {
+                    "from_port": 80
+                }
+            ]
+        }
+    }
+}
+