NEW PROVIDER: OctoDNS (#309)

* govendor gopkg.in/yaml.v2
* Ignore YAML and BIND test data litter.  Create README.txt files to force git to create subdirectories.
* Update convertzone to also read OctoDNS files

cmd/convertzone/README.md

@@ -1,8 +1,18 @@
 # convertzone -- Converts a standard DNS zonefile into tsv, pretty, or DSL
 
-This is a crude hack we put together to read a BIND-style zonefile
+This is a crude hack we put together to read a couple common zonefile
-and output a draft DNSControl dnsconfig.js file. It does about 90%
+formats and output them in a few different formats.  Current input
-of the work, but it isn't complete.
+formats are BIND zonefiles and OctoDNS "config" YAML files.  Current
+output formats as BIND zonefiles, tab separated records, or a draft
+DNSControl dnsconfig.js file. For dnsconfig.js, it does about 90%
+of the work, but should be manually verified.
+
+The primary purpose of this program is to convert BIND-style
+zonefiles to DNSControl dnsconfig.js files.  Nearly all DNS Service
+providers include the ability to export records as a BIND-style zonefile.
+This makes it easy to import DNS data from other systems into DNSControl.
+Later OctoDNS input was added because we had the parser (as part of
+the OctoDNS provider), so why not use it?
 
 ## Building the software
 
@@ -17,37 +27,53 @@ $ cp convertzone ~/bin/.
 
 ## Usage Overview
 
-convertzone converts an old-style DNS zone file into one of three formats:
+convertzone: Read and write DNS zone files.
 
-    convertzone [-mode=MODE] zonename [filename]
+convertzone [-in=INPUT] [-out=OUTPUT] zonename [filename]
 
-    -mode=tsv      Output the zone recoreds as tab-separated values
+Input format:
-    -mode=pretty   Output the zone pretty-printed.
+-in=bind      BIND-style zonefiles (DEFAULT)
-    -mode=dsl      Output the zone records as the DNSControl DSL language.
+-in=octodns   OctoDNS YAML "config" files.
 
-    zonename    The FQDN of the zone name.
+Output format:
-    filename    File to read (optional. Defaults to stdin)
 
+-out=dsl      DNSControl DSL language (dnsconfig.js) (DEFAULT)
+-out=tsv      TAB-separated values
+-out=pretty   pretty-printed (BIND-style zonefiles)
+
+zonename    The FQDN of the zone name.
+filename    File to read (optional. Defaults to stdin)
+
+The DSL output format is useful for creating the first
+draft of your dnsconfig.js when importing zones from
+other services.
+
+The TSV format makes it easy to process a zonefile with
+shell tools.
+
+The PRETTY format is just a nice way to clean up a zonefile.
+
+If no filename is specified, stdin is assumed.
 Output is sent to stdout.
 
 The zonename is required as it can not be guessed automatically from the input.
 
 Example:
 
-    convertzone stackoverflow.com zone.stackoverflow.com >new/stackoverflow.com
+    convertzone stackoverflow.com zone.stackoverflow.com >new/draft.js
 
 
-### -mode=tsv:
+### -out=tsv:
 
 This is useful for `awk` and other systems that expect a very
 uniform set of input.
 
 Example: Print all CNAMEs:
 
-    convertzone -mode=tsv foo.com <zone.foo.com | awk '$4 == "CNAME" { print $1 " -> " $5 }'
+    convertzone -out=tsv foo.com <zone.foo.com | awk '$4 == "CNAME" { print $1 " -> " $5 }'
 
 
-### -mode=pretty:
+### -out=pretty:
 
 This is useful for cleaning up a zonefile. It sorts the records,
 moving SOA and NS records to the top of the zone; all other records
@@ -58,18 +84,18 @@ etc.  Use `-ttl` to set a default TTL.
 
 Example: Clean up a zone file:
 
-    convertzone -mode=pretty foo.com <old/zone.foo.com >new/zone.foo.com
+    convertzone -out=pretty foo.com <old/zone.foo.com >new/zone.foo.com
 
 
-### -mode=dsl:
+### -out=dsl:
 
 This is useful for generating your draft `dnsconfig.js` configuration.
 The output can be appended to the `dnsconfig.js` file as a good first draft.
 
 Example: Generate statements for a dnsconfig.js file:
 
-    convertzone -mode=dsl foo.com <old/zone.foo.com >first-draft.js
+    convertzone -out=dsl foo.com <old/zone.foo.com >first-draft.js
 
 Note: The conversion is not perfect. You'll need to manually clean
 it up and insert it into `dnsconfig.js`.  More instructions in the
-DNSControl [migration doc]({site.github.url}}/migration).
+DNSControl [migration doc]({site.github.url}}/migration).

cmd/convertzone/main.go

@@ -1,16 +1,36 @@
 package main
 
 /*
-convertzone: Read BIND-style zonefile and output.
+convertzone: Read and write DNS zone files.
 
-     convertzone [-mode=MODE] zonename [filename]
+     convertzone [-in=INPUT] [-out=OUTPUT] zonename [filename]
 
-     -mode=tsv   TAB-separated values (default)
+	Input format:
-     -mode=dsl   DNSControl DSL
+	-in=bind      BIND-style zonefiles (DEFAULT)
-     -mode=pretty   Sort and pretty-print records.
+    -in=octodns   OctoDNS YAML "config" files.
 
-     zonename    The FQDN of the zone name.
+    Output format:
-     filename    File to read (default: stdin)
+
+    -out=dsl      DNSControl DSL language (dnsconfig.js) (DEFAULT)
+    -out=tsv      TAB-separated values
+    -out=pretty   pretty-printed (BIND-style zonefiles)
+
+    zonename    The FQDN of the zone name.
+    filename    File to read (optional. Defaults to stdin)
+
+	The DSL output format is useful for creating the first
+	draft of your dnsconfig.js when importing zones from
+	other services.
+
+	The TSV format makes it easy to process a zonefile with
+	shell tools.  `awk -F"\t" $2 = "A" { print $3 }`
+
+	The PRETTY format is just a nice way to clean up a zonefile.
+
+	If no filename is specified, stdin is assumed.
+	Output is sent to stdout.
+
+	The zonename is required as it can not be guessed automatically from the input.
 */
 
 import (
@@ -24,16 +44,59 @@ import (
 	"strings"
 
 	"github.com/StackExchange/dnscontrol/providers/bind"
+	"github.com/StackExchange/dnscontrol/providers/octodns/octoyaml"
 	"github.com/miekg/dns"
 	"github.com/miekg/dns/dnsutil"
 	"github.com/pkg/errors"
 )
 
-var flagMode = flag.String("mode", "tsv", "tsv|dsl|pretty")
+var flagInfmt = flag.String("in", "zone", "zone|octodns")
+var flagOutfmt = flag.String("out", "dsl", "dsl|tsv|pretty")
 var flagDefaultTTL = flag.Uint("ttl", 300, "Default TTL")
 var flagRegText = flag.String("registrar", "REG_FILL_IN", "registrar text")
 var flagProviderText = flag.String("provider", "DNS_FILL_IN", "provider text")
 
+func main() {
+	flag.Parse()
+	zonename, filename, reader, err := parseargs(flag.Args())
+	if err != nil {
+		fmt.Printf("ERROR: %v\n\n", err)
+		fmt.Println("convertzone [-flags] ZONENAME FILENAME")
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	defTTL := uint32(*flagDefaultTTL)
+
+	var recs []dns.RR
+
+	// Read it in:
+
+	switch *flagInfmt {
+	case "zone":
+		recs = readZone(zonename, reader, filename)
+	case "oct", "octo", "octodns":
+		recs = readOctodns(zonename, reader, filename)
+	}
+
+	// Write it out:
+
+	switch *flagOutfmt {
+	case "pretty":
+		bind.WriteZoneFile(os.Stdout, recs, zonename)
+	case "dsl":
+		fmt.Printf(`D("%s", %s, DnsProvider(%s)`, zonename, *flagRegText, *flagProviderText)
+		rrFormat(zonename, filename, recs, defTTL, true)
+		fmt.Println("\n)")
+	case "tsv":
+		rrFormat(zonename, filename, recs, defTTL, false)
+	default:
+		fmt.Println("convertzone [-flags] ZONENAME FILENAME")
+		flag.Usage()
+	}
+
+}
+
 // parseargs parses the non-flag arguments.
 func parseargs(args []string) (zonename string, filename string, r io.Reader, err error) {
 	// 1 args: first arg is the zonename. Read stdin.
@@ -62,26 +125,42 @@ func parseargs(args []string) (zonename string, filename string, r io.Reader, er
 	return zonename, filename, r, nil
 }
 
-// pretty outputs the zonefile using the prettyprinter.
+func readZone(zonename string, r io.Reader, filename string) []dns.RR {
-func pretty(zonename string, filename string, r io.Reader, defaultTTL uint32) {
 	var l []dns.RR
-	for x := range dns.ParseZone(r, zonename, filename) {
-		if x.Error == nil {
-			l = append(l, x.RR)
-		}
-	}
-	bind.WriteZoneFile(os.Stdout, l, zonename)
-}
-
-// rrFormat outputs the zonefile in either DSL or TSV format.
-func rrFormat(zonename string, filename string, r io.Reader, defaultTTL uint32, dsl bool) {
-	zonenamedot := zonename + "."
-
 	for x := range dns.ParseZone(r, zonename, filename) {
 		if x.Error != nil {
 			log.Println(x.Error)
-			continue
+		} else {
+			l = append(l, x.RR)
 		}
+	}
+	return l
+}
+
+func readOctodns(zonename string, r io.Reader, filename string) []dns.RR {
+	var l []dns.RR
+
+	foundRecords, err := octoyaml.ReadYaml(r, zonename)
+	if err != nil {
+		log.Println(errors.Wrapf(err, "can not get corrections"))
+	}
+
+	for _, x := range foundRecords {
+		l = append(l, x.ToRR())
+	}
+	return l
+}
+
+// pretty outputs the zonefile using the prettyprinter.
+func writePretty(zonename string, recs []dns.RR, defaultTTL uint32) {
+	bind.WriteZoneFile(os.Stdout, recs, zonename)
+}
+
+// rrFormat outputs the zonefile in either DSL or TSV format.
+func rrFormat(zonename string, filename string, recs []dns.RR, defaultTTL uint32, dsl bool) {
+	zonenamedot := zonename + "."
+
+	for _, x := range recs {
 
 		// Skip comments. Parse the formatted version.
 		line := x.String()
@@ -122,10 +201,10 @@ func rrFormat(zonename string, filename string, r io.Reader, defaultTTL uint32,
 			case dns.TypeSOA:
 				continue
 			case dns.TypeTXT:
-				if len(x.RR.(*dns.TXT).Txt) == 1 {
+				if len(x.(*dns.TXT).Txt) == 1 {
-					target = `'` + x.RR.(*dns.TXT).Txt[0] + `'`
+					target = `'` + x.(*dns.TXT).Txt[0] + `'`
 				} else {
-					target = `['` + strings.Join(x.RR.(*dns.TXT).Txt, `', '`) + `']`
+					target = `['` + strings.Join(x.(*dns.TXT).Txt, `', '`) + `']`
 				}
 			default:
 				target = "'" + target + "'"
@@ -140,31 +219,3 @@ func rrFormat(zonename string, filename string, r io.Reader, defaultTTL uint32,
 	}
 
 }
-
-func main() {
-	flag.Parse()
-	zonename, filename, reader, err := parseargs(flag.Args())
-	if err != nil {
-		fmt.Printf("ERROR: %v\n\n", err)
-		fmt.Println("convertzone [-flags] ZONENAME FILENAME")
-		flag.Usage()
-		os.Exit(1)
-	}
-
-	defTTL := uint32(*flagDefaultTTL)
-
-	switch *flagMode {
-	case "pretty":
-		pretty(zonename, filename, reader, defTTL)
-	case "dsl":
-		fmt.Printf(`D("%s", %s, DnsProvider(%s)`, zonename, *flagRegText, *flagProviderText)
-		rrFormat(zonename, filename, reader, defTTL, true)
-		fmt.Println("\n)")
-	case "tsv":
-		rrFormat(zonename, filename, reader, defTTL, false)
-	default:
-		fmt.Println("convertzone [-flags] ZONENAME FILENAME")
-		flag.Usage()
-	}
-
-}

docs/_includes/matrix.html

@@ -18,6 +18,7 @@
 	<th class="rotate"><div><span>NAMECHEAP</span></div></th>
 	<th class="rotate"><div><span>NAMEDOTCOM</span></div></th>
 	<th class="rotate"><div><span>NS1</span></div></th>
+	<th class="rotate"><div><span>OCTODNS</span></div></th>
 	<th class="rotate"><div><span>OVH</span></div></th>
 	<th class="rotate"><div><span>ROUTE53</span></div></th>
 	<th class="rotate"><div><span>SOFTLAYER</span></div></th>
@@ -66,6 +67,9 @@
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
+		<td class="danger">
+			<i class="fa fa-times text-danger" aria-hidden="true"></i>
+		</td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -126,6 +130,9 @@
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
+		<td class="success">
+			<i class="fa fa-check text-success" aria-hidden="true"></i>
+		</td>
 		</tr>
 	<tr>
 		<th class="row-header" style="text-decoration: underline;" data-toggle="tooltip" data-container="body" data-placement="top" title="The provider has registrar capabilities to set nameservers for zones">Registrar</th>
@@ -165,6 +172,9 @@
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
+		<td class="danger">
+			<i class="fa fa-times text-danger" aria-hidden="true"></i>
+		</td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -202,6 +212,7 @@
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td><i class="fa fa-minus dim"></i></td>
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
@@ -243,6 +254,7 @@
 		</td>
 		<td><i class="fa fa-minus dim"></i></td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td><i class="fa fa-minus dim"></i></td>
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
@@ -284,6 +296,9 @@
 			<a href="https://www.name.com/support/articles/205188508-Reverse-DNS-records"><i class="fa has-tooltip fa-times text-danger" aria-hidden="true"></i></a>
 		</td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td class="success">
+			<i class="fa fa-check text-success" aria-hidden="true"></i>
+		</td>
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
@@ -343,6 +358,9 @@
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
+		<td class="success">
+			<i class="fa fa-check text-success" aria-hidden="true"></i>
+		</td>
 		</tr>
 	<tr>
 		<th class="row-header" style="text-decoration: underline;" data-toggle="tooltip" data-container="body" data-placement="top" title="Provider can manage TLSA records">TLSA</th>
@@ -364,6 +382,7 @@
 		</td>
 		<td><i class="fa fa-minus dim"></i></td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td><i class="fa fa-minus dim"></i></td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -392,6 +411,7 @@
 		</td>
 		<td><i class="fa fa-minus dim"></i></td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td><i class="fa fa-minus dim"></i></td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -413,6 +433,7 @@
 		<td><i class="fa fa-minus dim"></i></td>
 		<td><i class="fa fa-minus dim"></i></td>
 		<td><i class="fa fa-minus dim"></i></td>
+		<td><i class="fa fa-minus dim"></i></td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -451,6 +472,9 @@
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
+		<td class="danger" data-toggle="tooltip" data-container="body" data-placement="top" title="Research is needed.">
+			<i class="fa has-tooltip fa-times text-danger" aria-hidden="true"></i>
+		</td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
@@ -498,6 +522,9 @@
 		<td class="danger">
 			<i class="fa fa-times text-danger" aria-hidden="true"></i>
 		</td>
+		<td class="danger" data-toggle="tooltip" data-container="body" data-placement="top" title="Driver just maintains list of OctoDNS config files. You must manually create the master config files that refer these.">
+			<i class="fa has-tooltip fa-times text-danger" aria-hidden="true"></i>
+		</td>
 		<td class="danger" data-toggle="tooltip" data-container="body" data-placement="top" title="New domains require registration">
 			<i class="fa has-tooltip fa-times text-danger" aria-hidden="true"></i>
 		</td>
@@ -561,6 +588,9 @@
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
+		<td class="success">
+			<i class="fa fa-check text-success" aria-hidden="true"></i>
+		</td>
 		</tr>
 	</tbody>
 </table>

docs/getting-started.md

@@ -31,7 +31,8 @@ like [git-crypt](https://www.agwa.name/projects/git-crypt) or
 
 Create a subdirectory called `zones` in the same directory as the
 configuration files.  (`mkdir zones`).  `zones` is where the BIND
-provider writes the zonefiles it creates.
+provider writes the zonefiles it creates. Even if you don't
+use BIND, it is useful for testing.
 
 
 ## 3. Create the initial `dnsconfig.js`
@@ -246,7 +247,7 @@ You can manually create the `D()` statements, or you can
 generate them automatically using the
 [convertzone](https://github.com/StackExchange/dnscontrol/blob/master/cmd/convertzone/README.md)
 utility that is included in the DNSControl repo (it converts
-BIND-style zone files to DNSControl's language).
+BIND-style zone files and OctoDNS-style YAML files to DNSControl's language).
 
 Now you can make change to the domain(s)  and run `dnscontrol preview`
 
@@ -258,4 +259,4 @@ If you are going to use this in production, we highly recommend the following:
 * Store the configuration files in Git.
 * Encrypt the `creds.json` file before storing it in Git.
 * Use a CI/CD tool like Jenkins to automatically push DNS changes.
-* Join the DNSControl community. File [issues and PRs](https://github.com/StackExchange/dnscontrol).
+* Join the DNSControl community. File [issues and PRs](https://github.com/StackExchange/dnscontrol).

docs/migrating.md

@@ -29,9 +29,9 @@ with no changes.  It is tempting to clean up the data as you do the migration...
 removing that old CNAME that nobody uses any more, or adding an
 A record you discovered was missing. Resist that temptation.  If you make any
 changes it will be difficult to tell which changes were intentional
-and which are typos. During the migration you will know you are done
+and which are mistakes. During the migration you will know you are done
-when `dnscontrol preview` says there are no changes needed. If there
+when `dnscontrol preview` says there are no changes needed. At that
-are items that should be cleaned up, do those cleanups now.
+point it is safe to do any cleanups.
 
 ## Create the first draft
 
@@ -43,7 +43,7 @@ hand, possibly with your text editor's search and replace functions.
 However, where's the fun in that?
 
 The `convertzone` tool can automate 90% of the conversion for you. It
-reads a BIND-style zone file and outputs a `D()` statement
+reads a BIND-style zone file or an OctoDNS-style YAML file and outputs a `D()` statement
 that is usually fairly complete. You may need to touch it up a bit.
 
 The convertzone command is in the `cmd/convertzone` subdirectory.
@@ -56,16 +56,21 @@ existing zone data to a file called the BIND zone file format.
 For example, suppose you owned the `foo.com` domain and the zone file
 was in a file called `old/zone.foo.com`. This command will convert the file:
 
-    convertzone -mode=dsl foo.com <old/zone.foo.com >first-draft.js
+    convertzone -out=dsl foo.com <old/zone.foo.com >first-draft.js
+
+If you are converting an OctoDNS file, add the flag `-in=octodns`:
+
+    convertzone -in=octodns -out=dsl foo.com <config/foo.com.yaml >first-draft.js
 
 Add the contents of `first-draft.js` to `dnsconfig.js`
 
+Run `dnscontrol preview` and see if it finds any differences.
 Edit dnsconfig.js until `dnscontrol preview` shows no errors and
 no changes to be made. This means the conversion of your old DNS
 data is correct.
 
-convertzone makes a guess at what to do with NS records. If
+convertzone makes a guess at what to do with NS records.
-they An NS record at the AP is turned into a NAMESERVER() call, the
+An NS record at the apex is turned into a NAMESERVER() call, the
 rest are left as NS().  You probably want to check each of them for
 correctness.
 
@@ -86,7 +91,7 @@ to convert a zone. Lines that start with `#` are comments.
 
     # Note this command uses ">>" to append to dnsconfig.js.  Do
     # not use ">" as that will erase the existing file.
-    convertzone -mode=dsl foo.com <old/zone.foo.com >>dnsconfig.js
+    convertzone -out=dsl foo.com <old/zone.foo.com >>dnsconfig.js
     #
     dnscontrol preview
     vim dnsconfig.js
@@ -100,4 +105,4 @@ to convert a zone. Lines that start with `#` are comments.
     vim dnsconfig.js
     dnscontrol preview
     # (repeat until all warnings/errors are resolved)
-    dnscontrol push
+    dnscontrol push

integrationTest/integration_test.go

@@ -465,6 +465,9 @@ func makeTests(t *testing.T) []*TestCase {
 		)
 	}
 
+	// NB(tlim): To temporarily skip most of the tests, insert a line like this:
+	//tests = nil
+
 	// TXT (single)
 	tests = append(tests, tc("Empty"),
 		tc("Empty"),
@@ -508,7 +511,7 @@ func makeTests(t *testing.T) []*TestCase {
 		)
 	}
 
-	// ignored recrods
+	// ignored records
 	tests = append(tests,
 		tc("Empty"),
 		tc("Create some records", txt("foo", "simple"), a("foo", "1.2.3.4")),

integrationTest/providers.json

@@ -63,6 +63,10 @@
     "apiuser": "$NAMECHEAP_USER",
     "domain": "$NAMECHEAP_DOMAIN"
   },
+  "OCTODNS": {
+    "domain": "example.com",
+    "directory": "config"
+  },
   "ROUTE53": {
     "KeyId": "$R53_KEY_ID",
     "SecretKey": "$R53_KEY",

models/record.go

@@ -253,10 +253,22 @@ func (r Records) Grouped() map[RecordKey]Records {
 	return groups
 }
 
+// GroupedByLabel returns a map of keys to records, and their original key order.
+func (r Records) GroupedByLabel() ([]string, map[string]Records) {
+	order := []string{}
+	groups := map[string]Records{}
+	for _, rec := range r {
+		if _, found := groups[rec.Name]; !found {
+			order = append(order, rec.Name)
+		}
+		groups[rec.Name] = append(groups[rec.Name], rec)
+	}
+	return order, groups
+}
+
 // PostProcessRecords does any post-processing of the downloaded DNS records.
 func PostProcessRecords(recs []*RecordConfig) {
 	Downcase(recs)
-	//fixTxt(recs)
 }
 
 // Downcase converts all labels and targets to lowercase in a list of RecordConfig.

models/t_mx.go

@@ -17,7 +17,6 @@ func (rc *RecordConfig) SetTargetMX(pref uint16, target string) error {
 	if rc.Type != "MX" {
 		panic("assertion failed: SetTargetMX called when .Type is not MX")
 	}
-
 	return nil
 }
 

models/target.go

@@ -1,6 +1,7 @@
 package models
 
 import (
+	"fmt"
 	"net"
 	"strings"
 
@@ -65,38 +66,43 @@ func (rc *RecordConfig) GetTargetCombined() string {
 	return full[len(header):]
 }
 
-// // GetTargetDebug returns a string with the various fields spelled out.
+// GetTargetSortable returns a string that is sortable.
-// func (rc *RecordConfig) GetTargetDebug() string {
+func (rc *RecordConfig) GetTargetSortable() string {
-// 	content := fmt.Sprintf("%s %s %s %d", rc.Type, rc.NameFQDN, rc.Target, rc.TTL)
+	return rc.GetTargetDebug()
-// 	switch rc.Type { // #rtype_variations
+}
-// 	case "A", "AAAA", "CNAME", "NS", "PTR", "TXT":
-// 		// Nothing special.
-// 	case "MX":
-// 		content += fmt.Sprintf(" pref=%d", rc.MxPreference)
-// 	case "SOA":
-// 		content = fmt.Sprintf("%s %s %s %d", rc.Type, rc.Name, rc.Target, rc.TTL)
-// 	case "SRV":
-// 		content += fmt.Sprintf(" srvpriority=%d srvweight=%d srvport=%d", rc.SrvPriority, rc.SrvWeight, rc.SrvPort)
-// 	case "TLSA":
-// 		content += fmt.Sprintf(" tlsausage=%d tlsaselector=%d tlsamatchingtype=%d", rc.TlsaUsage, rc.TlsaSelector, rc.TlsaMatchingType)
-// 	case "CAA":
-// 		content += fmt.Sprintf(" caatag=%s caaflag=%d", rc.CaaTag, rc.CaaFlag)
-// 	case "R53_ALIAS":
-// 		content += fmt.Sprintf(" type=%s zone_id=%s", rc.R53Alias["type"], rc.R53Alias["zone_id"])
-// 	default:
-// 		panic(errors.Errorf("rc.String rtype %v unimplemented", rc.Type))
-// 		// We panic so that we quickly find any switch statements
-// 		// that have not been updated for a new RR type.
-// 	}
-// 	for k, v := range rc.Metadata {
-// 		content += fmt.Sprintf(" %s=%s", k, v)
-// 	}
-// 	return content
-// }
 
-// SetTarget sets the target (assumes that the rtype is appropriate).
+// GetTargetDebug returns a string with the various fields spelled out.
-func (rc *RecordConfig) SetTarget(fqdn string) error {
+func (rc *RecordConfig) GetTargetDebug() string {
-	rc.Target = fqdn
+	content := fmt.Sprintf("%s %s %s %d", rc.Type, rc.NameFQDN, rc.Target, rc.TTL)
+	switch rc.Type { // #rtype_variations
+	case "A", "AAAA", "CNAME", "NS", "PTR", "TXT":
+		// Nothing special.
+	case "MX":
+		content += fmt.Sprintf(" pref=%d", rc.MxPreference)
+	case "SOA":
+		content = fmt.Sprintf("%s %s %s %d", rc.Type, rc.Name, rc.Target, rc.TTL)
+	case "SRV":
+		content += fmt.Sprintf(" srvpriority=%d srvweight=%d srvport=%d", rc.SrvPriority, rc.SrvWeight, rc.SrvPort)
+	case "TLSA":
+		content += fmt.Sprintf(" tlsausage=%d tlsaselector=%d tlsamatchingtype=%d", rc.TlsaUsage, rc.TlsaSelector, rc.TlsaMatchingType)
+	case "CAA":
+		content += fmt.Sprintf(" caatag=%s caaflag=%d", rc.CaaTag, rc.CaaFlag)
+	case "R53_ALIAS":
+		content += fmt.Sprintf(" type=%s zone_id=%s", rc.R53Alias["type"], rc.R53Alias["zone_id"])
+	default:
+		panic(errors.Errorf("rc.String rtype %v unimplemented", rc.Type))
+		// We panic so that we quickly find any switch statements
+		// that have not been updated for a new RR type.
+	}
+	for k, v := range rc.Metadata {
+		content += fmt.Sprintf(" %s=%s", k, v)
+	}
+	return content
+}
+
+// SetTarget sets the target, assuming that the rtype is appropriate.
+func (rc *RecordConfig) SetTarget(target string) error {
+	rc.Target = target
 	return nil
 }
 

pkg/natsort/README.txt

@@ -0,0 +1,4 @@
+This is from https://godoc.org/bitbucket.org/zombiezen/cardcpx/natsort
+
+I modified it to be compatible with the Python natsort package.
+I'll move this to vendor/ once he accepts our PR.

pkg/natsort/sort.go

@@ -0,0 +1,201 @@
+/*
+	Copyright 2014 Google Inc. All rights reserved.
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+// Package natsort provides an implementation of the natural sorting algorithm.
+// See http://blog.codinghorror.com/sorting-for-humans-natural-sort-order/.
+package natsort
+
+import (
+	"errors"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Strings sorts a slice of strings with Less.
+func Strings(s []string) {
+	sort.Sort(stringSlice(s))
+}
+
+// Less reports whether s is less than t.
+func Less(s, t string) bool {
+	return LessRunes([]rune(s), []rune(t))
+}
+
+// LessRunes reports whether s is less than t.
+func LessRunes(s, t []rune) bool {
+
+	nprefix := commonPrefix(s, t)
+	// equal?
+	if len(s) == nprefix && len(t) == nprefix {
+		return false
+	}
+	// empty strings are less than anything.
+	if len(s) == 0 || len(t) == 0 {
+		return len(s) == 0
+	}
+
+	// both start numeric? Sort by the prefixed digits.
+	lds := leadDigits(s)
+	ldt := leadDigits(t)
+	if lds != 0 && ldt != 0 { // both start with a digit
+		if lds == len(s) && ldt == len(t) { // s and t are all digits.
+			if lds == ldt {
+				// equal length? compare as strings.
+				return string(s) < string(t)
+			}
+			//  otherwise, the shorter one is smaller.
+			return lds < ldt
+		}
+		ss := string(s[:lds])
+		st := string(t[:ldt])
+		ns, _ := strconv.Atoi(ss)
+		nt, _ := strconv.Atoi(st)
+		if ns == nt && lds != ldt {
+			return lds < ldt
+		}
+		return ns < nt
+	}
+
+	// * < digit
+	if strings.HasPrefix(string(s), "*") || strings.HasPrefix(string(t), "*") {
+		if isDigit(t[0]) {
+			return false
+		}
+		if isDigit(s[0]) {
+			return true
+		}
+		return string(s) < string(t)
+	}
+	sps := string(s[nprefix:])
+	tps := string(t[nprefix:])
+	if strings.HasPrefix(sps, "-") || strings.HasPrefix(tps, "-") {
+		// digits < -
+		if leadDigits(s[nprefix:]) > 0 && strings.HasPrefix(tps, "-") {
+			return true
+		}
+		if leadDigits(t[nprefix:]) > 0 && strings.HasPrefix(sps, "-") {
+			return false
+		}
+		// . < -
+		if strings.HasPrefix(sps, ".") && strings.HasPrefix(tps, "-") {
+			return false
+		}
+		if strings.HasPrefix(sps, "-") && strings.HasPrefix(tps, ".") {
+			return true
+		}
+	}
+	// digits < .
+	if leadDigits(s[nprefix:]) > 0 && strings.HasPrefix(tps, ".") {
+		return true
+	}
+	if leadDigits(t[nprefix:]) > 0 && strings.HasPrefix(sps, ".") {
+		return false
+	}
+	sEnd := leadDigits(s[nprefix:]) + nprefix
+	tEnd := leadDigits(t[nprefix:]) + nprefix
+	if sEnd > nprefix || tEnd > nprefix {
+		start := trailDigits(s[:nprefix])
+		if sEnd-start > 0 && tEnd-start > 0 {
+			// TODO(light): log errors?
+			sn := atoi(s[start:sEnd])
+			tn := atoi(t[start:tEnd])
+			if sn != tn {
+				return sn < tn
+			}
+		}
+	}
+	switch {
+	case len(s) == nprefix:
+		return true
+	case len(t) == nprefix:
+		return false
+	default:
+		return s[nprefix] < t[nprefix]
+	}
+}
+
+func isDigit(r rune) bool {
+	return '0' <= r && r <= '9'
+}
+
+func atoi(r []rune) uint64 {
+	if len(r) < 1 {
+		panic(errors.New("atoi got an empty slice"))
+	}
+	const cutoff = uint64((1<<64-1)/10 + 1)
+	const maxVal = 1<<64 - 1
+
+	var n uint64
+	for _, d := range r {
+		v := uint64(d - '0')
+		if n >= cutoff {
+			return 1<<64 - 1
+		}
+		n *= 10
+		n1 := n + v
+		if n1 < n || n1 > maxVal {
+			// n+v overflows
+			return 1<<64 - 1
+		}
+		n = n1
+	}
+	return n
+}
+
+func commonPrefix(s, t []rune) int {
+	for i := range s {
+		if i >= len(t) {
+			return len(t)
+		}
+		if s[i] != t[i] {
+			return i
+		}
+	}
+	return len(s)
+}
+
+func trailDigits(r []rune) int {
+	for i := len(r) - 1; i >= 0; i-- {
+		if !isDigit(r[i]) {
+			return i + 1
+		}
+	}
+	return 0
+}
+
+func leadDigits(r []rune) int {
+	for i := range r {
+		if !isDigit(r[i]) {
+			return i
+		}
+	}
+	return len(r)
+}
+
+type stringSlice []string
+
+func (ss stringSlice) Len() int {
+	return len(ss)
+}
+
+func (ss stringSlice) Less(i, j int) bool {
+	return Less(ss[i], ss[j])
+}
+
+func (ss stringSlice) Swap(i, j int) {
+	ss[i], ss[j] = ss[j], ss[i]
+}

pkg/natsort/sort_test.go

@@ -0,0 +1,68 @@
+package natsort
+
+import "testing"
+
+func TestLess(t *testing.T) {
+
+	tests := []struct {
+		d1, d2 string
+	}{
+
+		{``, `x`},
+		{`foo3`, `foo10`},
+		{`foo2`, `foo40`},
+		{`ny-dc01.ds`, `ny-dc-vpn`},
+		{`20161108174726pm._domainkey`, `*`},
+		{`co-dc01.ds.stackexchange.com`, `co-dc-vpn.stackexchange.com`},
+
+		// Bug#4: [a1 a#1 a_1 aa]
+		//{`a1`, `a#1`},
+		{`a#1`, `a_1`},
+		{`a_1`, `aa`},
+
+		// Bug#4: [1 #1 _1 a]
+		//{`1`, `#1`},  // Not implemented
+		{`#1`, `_1`},
+		{`_1`, `a`},
+
+		// Bug#4: [1 01 2 02 3]
+		{`1`, `01`},
+		{`2`, `02`},
+		//{`02`, `3`}, // Not implemented
+
+		// Bug#4: [111111111111111111112 111111111111111111113 1111111111111111111120]
+		{`111111111111111111112`, `111111111111111111113`},
+		{`111111111111111111113`, `1111111111111111111120`},
+	}
+	for i, test := range tests {
+		r1 := Less(test.d1, test.d2)
+		if r1 != true {
+			t.Errorf("%va: expected (%v) got (%v): (%v) < (%v)", i, true, r1, test.d1, test.d2)
+		} else {
+			r2 := Less(test.d2, test.d1)
+			if r2 == true {
+				t.Errorf("%vb: expected (%v) got (%v): (%v) < (%v)", i, false, r2, test.d1, test.d2)
+			}
+		}
+	}
+}
+
+func TestEqual(t *testing.T) {
+
+	tests := []struct {
+		d1, d2 string
+	}{
+		{``, ``},
+	}
+	for i, test := range tests {
+		r1 := Less(test.d1, test.d2)
+		if r1 != false {
+			t.Errorf("%va: expected (%v) got (%v): (%v) < (%v)", i, false, r1, test.d1, test.d2)
+		} else {
+			r2 := Less(test.d2, test.d1)
+			if r2 != false {
+				t.Errorf("%vb: expected (%v) got (%v): (%v) < (%v)", i, false, r2, test.d1, test.d2)
+			}
+		}
+	}
+}

providers/_all/all.go

@@ -14,6 +14,7 @@ import (
 	_ "github.com/StackExchange/dnscontrol/providers/namecheap"
 	_ "github.com/StackExchange/dnscontrol/providers/namedotcom"
 	_ "github.com/StackExchange/dnscontrol/providers/ns1"
+	_ "github.com/StackExchange/dnscontrol/providers/octodns"
 	_ "github.com/StackExchange/dnscontrol/providers/ovh"
 	_ "github.com/StackExchange/dnscontrol/providers/route53"
 	_ "github.com/StackExchange/dnscontrol/providers/softlayer"

providers/octodns/TESTING.md

@@ -0,0 +1,104 @@
+# Testing:
+
+## Create the environment.
+
+These variables are used in all other sections of this doc.
+
+```
+export DNSCONFIGDIR=~/gitwork/fakeroot/ExternalDNS
+export OCTCONFIGDIR=~/gitwork/octodns/dns
+export SRCDIR=~/src/github.com/StackExchange/dnscontrol
+```
+
+## Code tests
+
+Unit tests:
+
+```
+cd $SRCDIR/providers/octodns/octoyaml
+go test -v
+```
+
+Integration tests:
+
+```
+cd $SRCDIR/integrationTest
+go test -v -verbose -provider OCTODNS
+```
+
+## Test against OctoDNS-Validate
+
+### Download OctoDNS:
+
+```
+cd $DNSCONFIGDIR
+mkdir dns
+cd dns
+virtualenv env
+source env/bin/activate
+pip install octodns
+ln -s ~/gitwork/fakeroot/ExternalDNS/config config
+```
+
+### Modify dnsconfig.js
+
+Make a copy of dnsconfig.js and modify it to use OCTODNS as a provider. We did it this way:
+
+```
+cd $DNSCONFIGDIR/dns
+cp ../dnsconfig.js .
+cp ../creds.json .
+```
+
+Add:
+
+```
+var OCT = NewDnsProvider("octodns", "OCTODNS");
+```
+
+Add:
+
+```
+ DEFAULTS(
+   DnsProvider(SERVERFAULT, 0),
++  DnsProvider(OCT, 0),
+   { ns_ttl: "172800" },
+ END);
+```
+
+Add:
+
+```
+ var NO_BIND = function(d) {
+   delete d.dnsProviders[SERVERFAULT];
++  delete d.dnsProviders[OCT];
+ };
+```
+
+## Run the tests:
+
+### Step 1: Generate the files
+
+This builds the software then generates the yaml files in the config directory:
+
+```
+(cd $SRCDIR && go install ) && cd $DNSCONFIGDIR/dns && rm -f config/*.yaml && dnscontrol push -providers=octodns
+```
+
+### Step 2: Run the validator:
+
+This runs octodns-validate against the YAMl files we generated.  production.yaml should
+list each domain.
+
+We create production.yaml like this:
+
+```
+cd $DNSCONFIGDIR/dns && $SRCDIR/providers/octodns/mkprodyaml.sh
+```
+
+Now we can run the validation:
+
+```
+cd $DNSCONFIGDIR/dns
+cp $SRCDIR/providers/octodns/testdata/production.yaml config/. && env/bin/octodns-validate --log-stream-stdout
+```

providers/octodns/mkprodyaml.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Read the YAML files in the config directory and generate a production.yaml file.
+
+cat <<HERE >production.yaml
+---
+providers:
+  config:
+    class: octodns.provider.yaml.YamlProvider
+    directory: ./config
+zones:
+HERE
+
+( cd config && ls *.yaml ) |
+grep -v '^provider.yaml$' |
+sed 's/.\{4\}$//' |
+awk '{ print "    " $1 ":" ; print "    sources:" ; print "      - config" }' >>production.yaml

providers/octodns/octodnsProvider.go

@@ -0,0 +1,170 @@
+package octodns
+
+/*
+
+octodns -
+  Generate zonefiles suitiable for OctoDNS.
+
+	The zonefiles are read and written to the directory octoconfig
+
+	If the old octoconfig files are readable, we read them to determine
+	if an update is actually needed.
+
+	The YAML input and output code is extremely complicated because
+	the format does not fit well with a statically typed language.
+	The YAML format changes drastically if the label has single
+	or multiple rtypes associated with it, and if there is a single
+	or multiple rtype data.
+
+*/
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/StackExchange/dnscontrol/models"
+	"github.com/StackExchange/dnscontrol/providers"
+	"github.com/StackExchange/dnscontrol/providers/diff"
+	"github.com/StackExchange/dnscontrol/providers/octodns/octoyaml"
+	"github.com/pkg/errors"
+)
+
+var features = providers.DocumentationNotes{
+	//providers.CanUseCAA: providers.Can(),
+	providers.CanUsePTR: providers.Can(),
+	providers.CanUseSRV: providers.Can(),
+	//providers.CanUseTXTMulti:   providers.Can(),
+	providers.DocCreateDomains: providers.Cannot("Driver just maintains list of OctoDNS config files. You must manually create the master config files that refer these."),
+	providers.DocDualHost:      providers.Cannot("Research is needed."),
+}
+
+func initProvider(config map[string]string, providermeta json.RawMessage) (providers.DNSServiceProvider, error) {
+	// config -- the key/values from creds.json
+	// meta -- the json blob from NewReq('name', 'TYPE', meta)
+	api := &Provider{
+		directory: config["directory"],
+	}
+	if api.directory == "" {
+		api.directory = "config"
+	}
+	if len(providermeta) != 0 {
+		err := json.Unmarshal(providermeta, api)
+		if err != nil {
+			return nil, err
+		}
+	}
+	//api.nameservers = models.StringsToNameservers(api.DefaultNS)
+	return api, nil
+}
+
+func init() {
+	providers.RegisterDomainServiceProviderType("OCTODNS", initProvider, features)
+}
+
+// Provider is the provider handle for the OctoDNS driver.
+type Provider struct {
+	//DefaultNS   []string `json:"default_ns"`
+	//DefaultSoa  SoaInfo  `json:"default_soa"`
+	//nameservers []*models.Nameserver
+	directory string
+}
+
+// GetNameservers returns the nameservers for a domain.
+func (c *Provider) GetNameservers(string) ([]*models.Nameserver, error) {
+	return nil, nil
+}
+
+// GetDomainCorrections returns a list of corrections to update a domain.
+func (c *Provider) GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
+	dc.Punycode()
+	// Phase 1: Copy everything to []*models.RecordConfig:
+	//    expectedRecords < dc.Records[i]
+	//    foundRecords < zonefile
+	//
+	// Phase 2: Do any manipulations:
+	// add NS
+	// manipulate SOA
+	//
+	// Phase 3: Convert to []diff.Records and compare:
+	// expectedDiffRecords < expectedRecords
+	// foundDiffRecords < foundRecords
+	// diff.Inc...(foundDiffRecords, expectedDiffRecords )
+
+	// Read foundRecords:
+	var foundRecords models.Records
+	zoneFileFound := true
+	zoneFileName := filepath.Join(c.directory, strings.Replace(strings.ToLower(dc.Name), "/", "_", -1)+".yaml")
+	foundFH, err := os.Open(zoneFileName)
+	if err != nil {
+		if os.IsNotExist(err) {
+			zoneFileFound = false
+		} else {
+			return nil, errors.Wrapf(err, "can't open %s:", zoneFileName)
+		}
+	} else {
+		foundRecords, err = octoyaml.ReadYaml(foundFH, dc.Name)
+		if err != nil {
+			return nil, errors.Wrapf(err, "can not get corrections")
+		}
+	}
+
+	// Normalize
+	models.PostProcessRecords(foundRecords)
+
+	differ := diff.New(dc)
+	_, create, del, mod := differ.IncrementalDiff(foundRecords)
+
+	buf := &bytes.Buffer{}
+	// Print a list of changes. Generate an actual change that is the zone
+	changes := false
+	for _, i := range create {
+		changes = true
+		fmt.Fprintln(buf, i)
+	}
+	for _, i := range del {
+		changes = true
+		fmt.Fprintln(buf, i)
+	}
+	for _, i := range mod {
+		changes = true
+		fmt.Fprintln(buf, i)
+	}
+	msg := fmt.Sprintf("GENERATE_CONFIGFILE: %s", dc.Name)
+	if zoneFileFound {
+		msg += "\n"
+		msg += buf.String()
+	} else {
+		msg += fmt.Sprintf(" (%d records)\n", len(create))
+	}
+	corrections := []*models.Correction{}
+	if changes {
+		corrections = append(corrections,
+			&models.Correction{
+				Msg: msg,
+				F: func() error {
+					fmt.Printf("CREATING CONFIGFILE: %v\n", zoneFileName)
+					zf, err := os.Create(zoneFileName)
+					if err != nil {
+						log.Fatalf("Could not create zonefile: %v", err)
+					}
+					//err = WriteZoneFile(zf, dc.Records, dc.Name)
+					err = octoyaml.WriteYaml(zf, dc.Records, dc.Name)
+					if err != nil {
+						log.Fatalf("WriteZoneFile error: %v\n", err)
+					}
+					err = zf.Close()
+					if err != nil {
+						log.Fatalf("Closing: %v", err)
+					}
+					return nil
+				},
+			})
+	}
+
+	return corrections, nil
+}

providers/octodns/octoyaml/js.go

@@ -0,0 +1,92 @@
+package octoyaml
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/StackExchange/dnscontrol/models"
+	"github.com/StackExchange/dnscontrol/pkg/transform"
+
+	"github.com/robertkrimen/otto"
+	// load underscore js into vm by default
+
+	_ "github.com/robertkrimen/otto/underscore" // required by otto
+)
+
+// ExecuteJavascript accepts a javascript string and runs it, returning the resulting dnsConfig.
+func ExecuteJavascript(script string, devMode bool) (*models.DNSConfig, error) {
+	vm := otto.New()
+
+	vm.Set("require", require)
+	vm.Set("REV", reverse)
+
+	helperJs := GetHelpers(true)
+	// run helper script to prime vm and initialize variables
+	if _, err := vm.Run(helperJs); err != nil {
+		return nil, err
+	}
+
+	// run user script
+	if _, err := vm.Run(script); err != nil {
+		return nil, err
+	}
+
+	// export conf as string and unmarshal
+	value, err := vm.Run(`JSON.stringify(conf)`)
+	if err != nil {
+		return nil, err
+	}
+	str, err := value.ToString()
+	if err != nil {
+		return nil, err
+	}
+	conf := &models.DNSConfig{}
+	if err = json.Unmarshal([]byte(str), conf); err != nil {
+		return nil, err
+	}
+	return conf, nil
+}
+
+// GetHelpers returns the filename of helpers.js, or the esc'ed version.
+func GetHelpers(devMode bool) string {
+	d, err := ioutil.ReadFile("../pkg/js/helpers.js")
+	if err != nil {
+		panic(err)
+	}
+	return string(d)
+}
+
+func require(call otto.FunctionCall) otto.Value {
+	if len(call.ArgumentList) != 1 {
+		throw(call.Otto, "require takes exactly one argument")
+	}
+	file := call.Argument(0).String()
+	fmt.Printf("requiring: %s\n", file)
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		throw(call.Otto, err.Error())
+	}
+	_, err = call.Otto.Run(string(data))
+	if err != nil {
+		throw(call.Otto, err.Error())
+	}
+	return otto.TrueValue()
+}
+
+func throw(vm *otto.Otto, str string) {
+	panic(vm.MakeCustomError("Error", str))
+}
+
+func reverse(call otto.FunctionCall) otto.Value {
+	if len(call.ArgumentList) != 1 {
+		throw(call.Otto, "REV takes exactly one argument")
+	}
+	dom := call.Argument(0).String()
+	rev, err := transform.ReverseDomainName(dom)
+	if err != nil {
+		throw(call.Otto, err.Error())
+	}
+	v, _ := otto.ToValue(rev)
+	return v
+}

providers/octodns/octoyaml/parse_tests/001-single-a.js

@@ -0,0 +1,6 @@
+var REG = NewRegistrar("Third-Party","NONE");
+var CF = NewDnsProvider("bind", "BIND")
+D("example.tld",REG,DnsProvider(CF),
+    DefaultTTL(301),
+    A("foo","1.2.3.4", TTL(301))
+);

providers/octodns/octoyaml/parse_tests/001-single-a.json

@@ -0,0 +1,8 @@
+[
+  {
+    "type":"A",
+    "name":"foo",
+    "target":"1.2.3.4",
+    "ttl":301
+  }
+]

providers/octodns/octoyaml/parse_tests/001-single-a.yaml

@@ -0,0 +1,5 @@
+---
+foo:
+  ttl: 301
+  type: A
+  value: 1.2.3.4

providers/octodns/octoyaml/parse_tests/002-multiple-a.js

@@ -0,0 +1,7 @@
+var REG = NewRegistrar("Third-Party","NONE");
+var CF = NewDnsProvider("bind", "BIND")
+D("example.tld",REG,DnsProvider(CF),
+    DefaultTTL(302),
+    A("foo","1.2.3.4"),
+    A("foo","1.2.3.5")
+);

providers/octodns/octoyaml/parse_tests/002-multiple-a.json

@@ -0,0 +1,4 @@
+[
+  {"type":"A","name":"foo","target":"1.2.3.4","ttl":302},
+  {"type":"A","name":"foo","target":"1.2.3.5","ttl":302}
+]

providers/octodns/octoyaml/parse_tests/002-multiple-a.yaml

@@ -0,0 +1,7 @@
+---
+foo:
+  ttl: 302
+  type: A
+  values:
+  - 1.2.3.4
+  - 1.2.3.5

providers/octodns/octoyaml/parse_tests/003-complex.js

@@ -0,0 +1,10 @@
+var REG = NewRegistrar("Third-Party","NONE");
+var CF = NewDnsProvider("bind", "BIND")
+D("example.tld",REG,DnsProvider(CF),
+    DefaultTTL(303),
+    A("one","1.2.3.3"),
+    A("foo","1.2.3.4"),
+    A("foo","1.2.3.5"),
+    MX("foo", 10, "mx1.example.com."),
+    MX("foo", 10, "mx2.example.com.")
+);

providers/octodns/octoyaml/parse_tests/003-complex.json

@@ -0,0 +1,7 @@
+[
+  {"type":"A","name":"foo","target":"1.2.3.4","ttl":303},
+  {"type":"A","name":"foo","target":"1.2.3.5","ttl":303},
+  {"type":"MX","name":"foo","target":"mx1.example.com.","ttl":303,"mxpreference":10},
+  {"type":"MX","name":"foo","target":"mx2.example.com.","ttl":303,"mxpreference":10},
+  {"type":"A","name":"one","target":"1.2.3.3","ttl":303}
+]

providers/octodns/octoyaml/parse_tests/003-complex.yaml

@@ -0,0 +1,18 @@
+---
+foo:
+- ttl: 303
+  type: A
+  values:
+  - 1.2.3.4
+  - 1.2.3.5
+- ttl: 303
+  type: MX
+  values:
+  - priority: 10
+    value: mx1.example.com.
+  - priority: 10
+    value: mx2.example.com.
+one:
+  ttl: 303
+  type: A
+  value: 1.2.3.3

providers/octodns/octoyaml/parse_tests/004-doc-example1.json

@@ -0,0 +1,9 @@
+[
+  {"type":"CNAME","name":"*","target":"www.example.com."},
+  {"type":"A","name":"@","target":"1.2.3.4","ttl":304},
+  {"type":"A","name":"@","target":"1.2.3.5","ttl":304},
+  {"type":"A","name":"www","target":"1.2.3.4","ttl":304},
+  {"type":"A","name":"www","target":"1.2.3.5","ttl":304},
+  {"type":"A","name":"www.sub","target":"1.2.3.6","ttl":304},
+  {"type":"A","name":"www.sub","target":"1.2.3.7","ttl":304}
+]

providers/octodns/octoyaml/parse_tests/004-doc-example1.yaml

@@ -0,0 +1,22 @@
+---
+'':
+  type: A
+  ttl: 304
+  values:
+    - 1.2.3.4
+    - 1.2.3.5
+'*':
+  type: CNAME
+  value: www.example.com.
+www:
+  type: A
+  ttl: 304
+  values:
+    - 1.2.3.4
+    - 1.2.3.5
+www.sub:
+  type: A
+  ttl: 304
+  values:
+    - 1.2.3.6
+    - 1.2.3.7

providers/octodns/octoyaml/parse_tests/005-doc-example2.json

@@ -0,0 +1,6 @@
+[
+  {"type":"A","name":"@","target":"1.2.3.4","ttl":305},
+  {"type":"A","name":"@","target":"1.2.3.5","ttl":305},
+  {"type":"MX","name":"@","target":"mx1.example.com.","ttl":305,"mxpreference":10},
+  {"type":"MX","name":"@","target":"mx2.example.com.","ttl":305,"mxpreference":10}
+]

providers/octodns/octoyaml/parse_tests/005-doc-example2.yaml

@@ -0,0 +1,14 @@
+---
+'':
+  - type: A
+    ttl: 305
+    values:
+      - 1.2.3.4
+      - 1.2.3.5
+  - type: MX
+    ttl: 305
+    values:
+      - priority: 10
+        value: mx1.example.com.
+      - priority: 10
+        value: mx2.example.com.

providers/octodns/octoyaml/parse_tests/006-apex.json

@@ -0,0 +1,9 @@
+[
+  {
+    "type":"A",
+    "name":"@",
+    "target":"1.2.3.4",
+    "ttl":306
+  }
+]
+

providers/octodns/octoyaml/parse_tests/006-apex.yaml

@@ -0,0 +1,5 @@
+---
+'':
+  type: A
+  ttl: 306
+  value: 1.2.3.4

providers/octodns/octoyaml/parse_tests/007-apex-quote.js

@@ -0,0 +1,12 @@
+// FYI: go-yaml writes an empty string as ""; python's yaml writes an empty string as "".
+// For that reason:
+// 006-apex:       tests YAML -> JSON.
+// 007-apex-quote: tests JS -> YAML -> JSON
+// It would be nice if go-yaml has an option to write '' instead of "".
+
+var REG = NewRegistrar("Third-Party","NONE");
+var CF = NewDnsProvider("bind", "BIND")
+D("example.tld",REG,DnsProvider(CF),
+    DefaultTTL(307),
+    A("@","1.2.3.4")
+);

providers/octodns/octoyaml/parse_tests/007-apex-quote.json

@@ -0,0 +1,8 @@
+[
+  {
+    "type":"A",
+    "name":"@",
+    "target":"1.2.3.4",
+    "ttl":307
+  }
+]

providers/octodns/octoyaml/parse_tests/007-apex-quote.yaml

@@ -0,0 +1,5 @@
+---
+"":
+  ttl: 307
+  type: A
+  value: 1.2.3.4

providers/octodns/octoyaml/read.go

@@ -0,0 +1,271 @@
+package octoyaml
+
+/*
+This module handles reading OctoDNS yaml files.  Sadly the YAML files
+are so entirely flexible that parsing them is a nighmare.  We UnMarshalYAML
+them into a slice of interfaces mapped to interfaces, then use reflection
+to walk the tree, interpreting what we find along the way.  As we collect
+data we output models.RecordConfig objects.
+*/
+
+import (
+	"io"
+	"io/ioutil"
+	"math"
+	"reflect"
+	"strconv"
+
+	"github.com/StackExchange/dnscontrol/models"
+	"github.com/pkg/errors"
+	yaml "gopkg.in/yaml.v2"
+)
+
+// ReadYaml parses a yaml input and returns a list of RecordConfigs
+func ReadYaml(r io.Reader, origin string) (models.Records, error) {
+	results := models.Records{}
+
+	// Slurp the YAML into a string.
+	ydata, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, errors.Wrapf(err, "can not read yaml filehandle")
+	}
+
+	// Unmarshal the mystery data into a structure we can relect into.
+	var mysterydata map[string]interface{}
+	err = yaml.Unmarshal(ydata, &mysterydata)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not unmarshal yaml")
+	}
+	//fmt.Printf("ReadYaml: mysterydata == %v\n", mysterydata)
+
+	// Traverse every key/value pair.
+	for k, v := range mysterydata { // Each label
+		// k, v: k is the label, v is everything we know about the label.
+		// In other code, k1, v2 refers to one level deeper, k3, k3 refers to
+		// one more level deeper, and so on.
+		//fmt.Printf("ReadYaml: NEXT KEY\n")
+		//fmt.Printf("ReadYaml:  KEY=%s v.(type)=%s\n", k, reflect.TypeOf(v).String())
+		switch v.(type) {
+		case map[interface{}]interface{}:
+			// The value is itself a map. This means we have a label with
+			// with one or more records, each of them are all the same rtype.
+			// parseLeaf will handle both of these forms:
+			// For example, this:
+			// 'www':
+			//    type: A
+			//    values:
+			//      - 1.2.3.4
+			//      - 1.2.3.5
+			// or
+			// 'www':
+			//    type: CNAME
+			//    value: foo.example.com.
+			results, err = parseLeaf(results, k, v, origin)
+			if err != nil {
+				return results, errors.Wrapf(err, "leaf (%v) error", v)
+			}
+		case []interface{}:
+			// The value is a list. This means we have a label with
+			// multiple records, each of them may be different rtypes.
+			// We need to call parseLeaf() once for each rtype.
+			// For example, this:
+			// 'www':
+			// - type: A
+			//   values:
+			// 	- 1.2.3.4
+			// 	- 1.2.3.5
+			// - type: MX
+			//   values:
+			// 	- priority: 10
+			// 	  value: mx1.example.com.
+			// 	- priority: 10
+			// 	  value: mx2.example.com.
+			for i, v3 := range v.([]interface{}) { // All the label's list
+				_ = i
+				//fmt.Printf("ReadYaml:   list key=%s i=%d v3.(type)=%s\n", k, i, typeof(v3))
+				switch v3.(type) {
+				case map[interface{}]interface{}:
+					//fmt.Printf("ReadYaml:   v3=%v\n", v3)
+					results, err = parseLeaf(results, k, v3, origin)
+					if err != nil {
+						return results, errors.Wrapf(err, "leaf v3=%v", v3)
+					}
+				default:
+					return nil, errors.Errorf("unknown type in list3: k=%s v.(type)=%T v=%v", k, v, v)
+				}
+			}
+
+		default:
+			return nil, errors.Errorf("unknown type in list1: k=%s v.(type)=%T v=%v", k, v, v)
+		}
+	}
+
+	sortRecs(results, origin)
+	//fmt.Printf("ReadYaml: RESULTS=%v\n", results)
+	return results, nil
+}
+
+func parseLeaf(results models.Records, k string, v interface{}, origin string) (models.Records, error) {
+	var rType, rTarget string
+	var rTTL uint32
+	rTargets := []string{}
+	var someresults models.Records
+	for k2, v2 := range v.(map[interface{}]interface{}) { // All  the label's items
+		// fmt.Printf("ReadYaml: ifs tk2=%s tv2=%s len(rTargets)=%d\n", typeof(k2), typeof(v2), len(rTargets))
+		if typeof(k2) == "string" && (typeof(v2) == "string" || typeof(v2) == "int") {
+			// The 2nd level key is a string, and the 2nd level value is a string or int.
+			// Here are 3 examples:
+			// type: CNAME
+			// value: foo.example.com.
+			// ttl: 3
+			//fmt.Printf("parseLeaf:   k2=%s v2=%v\n", k2, v2)
+			switch k2.(string) {
+			case "type":
+				rType = v2.(string)
+			case "ttl":
+				var err error
+				rTTL, err = decodeTTL(v2)
+				if err != nil {
+					return nil, errors.Errorf("parseLeaf: can not parse ttl (%v)", v2)
+				}
+			case "value":
+				rTarget = v2.(string)
+			case "values":
+				switch v2.(type) {
+				case string:
+					rTarget = v2.(string)
+				default:
+					return nil, errors.Errorf("parseLeaf: unknown type in values: rtpe=%s k=%s k2=%s v2.(type)=%T v2=%v", rType, k, k2, v2, v2)
+				}
+			default:
+				panic("Should not happen")
+			}
+		} else if typeof(k2) == "string" && typeof(v2) == "[]interface {}" {
+			// The 2nd level key is a string, and the 2nd level value is a list.
+			someresults = nil
+			for _, v3 := range v2.([]interface{}) {
+				switch v3.(type) {
+				case string:
+					// Example:
+					// values:
+					//   - 1.2.3.1
+					//   - 1.2.3.2
+					//   - 1.2.3.3
+					// We collect all the values for later, when we'll need to generate
+					// one RecordConfig for each value.
+					//fmt.Printf("parseLeaf: s-append %s\n", v3.(string))
+					rTargets = append(rTargets, v3.(string))
+				case map[interface{}]interface{}:
+					// Example:
+					// values:
+					// - priority: 10
+					//   value: mx1.example.com.
+					// - priority: 10
+					//   value: mx2.example.com.
+					// We collect the individual values. When we are done with this level,
+					// we should have enough to generate a single RecordConfig.
+					newRc := newRecordConfig(k, rType, "", rTTL, origin)
+					for k4, v4 := range v3.(map[interface{}]interface{}) {
+						//fmt.Printf("parseLeaf: k4=%s v4=%s\n", k4, v4)
+						switch k4.(string) {
+						case "priority": // MX,SRV
+							priority := uint16(v4.(int))
+							newRc.MxPreference = priority
+							newRc.SrvPriority = priority
+							// Assign it to both places. We'll zap the wrong one later.
+						case "weight": // SRV
+							newRc.SrvWeight = uint16(v4.(int))
+						case "port": // SRV
+							newRc.SrvPort = uint16(v4.(int))
+						case "value": // MX
+							newRc.Target = v4.(string)
+						}
+					}
+					//fmt.Printf("parseLeaf: append %v\n", newRc)
+					someresults = append(someresults, newRc)
+				default:
+					return nil, errors.Errorf("parseLeaf: unknown type in map: rtype=%s k=%s v3.(type)=%T v3=%v", rType, k, v3, v3)
+				}
+			}
+		} else {
+			return nil, errors.Errorf("parseLeaf: unknown type in level 2: k=%s k2=%s v.2(type)=%T v2=%v", k, k2, v2, v2)
+		}
+	}
+	// fmt.Printf("parseLeaf: Target=(%v)\n", rTarget)
+	// fmt.Printf("parseLeaf: len(rTargets)=%d\n", len(rTargets))
+	// fmt.Printf("parseLeaf: len(someresults)=%d\n", len(someresults))
+
+	// We've now looped through everything about one label. Make the RecordConfig(s).
+
+	if len(someresults) > 0 {
+		// We have many results. Generate a RecordConfig for each one.
+		for _, r := range someresults {
+			r.Type = rType
+			r.TTL = rTTL
+			results = append(results, r)
+			// Earlier we didn't know what the priority was for. Now that  we know the rType,
+			// we zap the wrong one.
+			switch r.Type {
+			case "MX":
+				r.SrvPriority = 0
+			case "SRV":
+				r.MxPreference = 0
+			default:
+				panic("ugh")
+			}
+		}
+	} else if rTarget != "" && len(rTargets) == 0 {
+		// The file used "value".  Generate a single RecordConfig
+		//fmt.Printf("parseLeaf: 1-newRecordConfig(%v, %v, %v, %v, %v)\n", k, rType, rTarget, rTTL, origin)
+		results = append(results, newRecordConfig(k, rType, rTarget, rTTL, origin))
+	} else {
+		// The file used "values" so now we must generate a RecordConfig for each value.
+		for _, target := range rTargets {
+			//fmt.Printf("parseLeaf: 3-newRecordConfig(%v, %v, %v, %v, %v)\n", k, rType, target, rTTL, origin)
+			results = append(results, newRecordConfig(k, rType, target, rTTL, origin))
+		}
+	}
+	return results, nil
+}
+
+// newRecordConfig is a RecordConfig factory.
+func newRecordConfig(rname, rtype, target string, ttl uint32, origin string) *models.RecordConfig {
+	rc := &models.RecordConfig{
+		Type: rtype,
+		TTL:  ttl,
+	}
+	rc.SetLabel(rname, origin)
+	switch rtype {
+	case "TXT":
+		rc.SetTargetTXT(target)
+	default:
+		rc.SetTarget(target)
+	}
+	return rc
+}
+
+// typeof returns a string that indicates v's type:
+func typeof(v interface{}) string {
+	// Cite: https://stackoverflow.com/a/20170555/71978
+	return reflect.TypeOf(v).String()
+}
+
+// decodeTTL decodes an interface into a TTL value.
+// This is useful when you don't know if a TTL arrived as a string or int.
+func decodeTTL(ttl interface{}) (uint32, error) {
+	switch ttl.(type) {
+	case uint32:
+		return ttl.(uint32), nil
+	case string:
+		s := ttl.(string)
+		t, err := strconv.ParseUint(s, 10, 32)
+		return uint32(t), errors.Wrapf(err, "decodeTTL failed to parse (%s)", s)
+	case int:
+		i := ttl.(int)
+		if i < 0 || i > math.MaxUint32 {
+			return 0, errors.Errorf("ttl won't fit in 32-bits (%d)", i)
+		}
+		return uint32(i), nil
+	}
+	panic("I don't know what type this TTL is")
+}

providers/octodns/octoyaml/rw_test.go

@@ -0,0 +1,186 @@
+package octoyaml
+
+/*
+
+Test
+	DSL -> yaml
+	YAML -> JSON
+
+	001-test.js
+	001-test.yaml
+	001-test.json
+*/
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"unicode"
+
+	"github.com/tdewolff/minify"
+	minjson "github.com/tdewolff/minify/json"
+)
+
+const (
+	testDir  = "octodns/octoyaml/parse_tests"
+	errorDir = "octodns/octoyaml/error_tests"
+)
+
+func init() {
+	os.Chdir("../..") // go up a directory so we helpers.js is in a consistent place.
+}
+
+func TestYamlWrite(t *testing.T) {
+
+	// Read a .JS and make sure we can generate the expected YAML.
+
+	files, err := ioutil.ReadDir(testDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, f := range files {
+
+		// Run JS -> conf
+
+		// run all js files that start with a number. Skip others.
+		if filepath.Ext(f.Name()) != ".js" || !unicode.IsNumber(rune(f.Name()[0])) {
+			continue
+		}
+
+		m := minify.New()
+		m.AddFunc("json", minjson.Minify)
+
+		t.Run(f.Name(), func(t *testing.T) {
+			content, err := ioutil.ReadFile(filepath.Join(testDir, f.Name()))
+			if err != nil {
+				t.Fatal(err)
+			}
+			conf, err := ExecuteJavascript(string(content), true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			basename := f.Name()[:len(f.Name())-3] // Remove ".js"
+
+			// Run conf -> YAML
+
+			actualYAML := bytes.NewBuffer([]byte{})
+			dom := conf.FindDomain("example.tld")
+			if dom == nil {
+				panic(fmt.Sprintf("FILE %s does not mention domain '%s'", f.Name(), "example.tld"))
+			}
+
+			err = WriteYaml(
+				actualYAML, conf.FindDomain("example.tld").Records, "example.tld")
+
+			// Read expected YAML
+
+			expectedFile := filepath.Join(testDir, basename+".yaml")
+			expectedData, err := ioutil.ReadFile(expectedFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			expectedYAML := expectedData
+
+			// Compare YAML and expectedData
+
+			if string(expectedYAML) != actualYAML.String() {
+				t.Error("Expected and actual YAML don't match")
+				t.Log("Expected:", string(expectedYAML))
+				t.Log("Actual  :", actualYAML.String())
+			}
+
+		})
+	}
+}
+
+func TestYamlRead(t *testing.T) {
+
+	// Read a .YAML and make sure it matches the RecordConfig (.JSON).
+
+	minifyFlag := true
+
+	files, err := ioutil.ReadDir(testDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, f := range files {
+		// run all yaml files that start with a number. Skip others.
+		if filepath.Ext(f.Name()) != ".yaml" || !unicode.IsNumber(rune(f.Name()[0])) {
+			continue
+		}
+		basename := f.Name()[:len(f.Name())-5] // remove ".yaml"
+
+		m := minify.New()
+		m.AddFunc("json", minjson.Minify)
+
+		t.Run(f.Name(), func(t *testing.T) {
+
+			// Parse YAML
+
+			content, err := ioutil.ReadFile(filepath.Join(testDir, f.Name()))
+			if err != nil {
+				if os.IsNotExist(err) {
+					content = nil
+				} else {
+					t.Fatal(err)
+				}
+			}
+			recs, err := ReadYaml(bytes.NewBufferString(string(content)), "example.tld")
+			if err != nil {
+				t.Fatal(err)
+			}
+			//fmt.Printf("DEBUG: CONTENT=%s\n", string(content))
+			//fmt.Printf("DEBUG: RECS=%v\n", recs)
+
+			// YAML -> JSON
+
+			actualJSON, err := json.MarshalIndent(recs, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if minifyFlag {
+				// fmt.Printf("DEBUG: actualJSON-full: %s\n", actualJSON)
+				actualJSON, err = m.Bytes("json", actualJSON)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			// fmt.Printf("DEBUG: actualJSON-mini: %s\n", actualJSON)
+
+			// Read expected JSON
+			expectedFile := filepath.Join(testDir, basename+".json")
+			expectedData, err := ioutil.ReadFile(expectedFile)
+			if err != nil {
+				if os.IsNotExist(err) {
+					fmt.Println("SKIPPING")
+					t.Log("Skipping (no .json)")
+					return
+				}
+				t.Fatal(err)
+			}
+			var expectedJSON string
+			if minifyFlag {
+				expectedJSON, err = m.String("json", string(expectedData))
+			} else {
+				expectedJSON = string(expectedData)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			//fmt.Printf("DEBUG: EXPECTED=%s\n", string(expectedJSON))
+			//fmt.Printf("DEBUG: ACTUAL  =%s\n", string(actualJSON))
+
+			if strings.TrimSpace(string(expectedJSON)) != strings.TrimSpace(string(actualJSON)) {
+				t.Error("Expected and actual json don't match")
+				t.Log("Expected:", string(expectedJSON))
+				t.Log("Actual  :", string(actualJSON))
+			}
+		})
+	}
+}

providers/octodns/octoyaml/sort.go

@@ -0,0 +1,136 @@
+package octoyaml
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"net"
+	"sort"
+
+	"github.com/StackExchange/dnscontrol/models"
+	"github.com/StackExchange/dnscontrol/pkg/natsort"
+	"github.com/miekg/dns/dnsutil"
+)
+
+type genYamlData struct {
+	Origin     string
+	DefaultTTL uint32
+	Records    models.Records
+}
+
+func sortRecs(recs models.Records, origin string) {
+	z := &genYamlData{
+		Origin:  dnsutil.AddOrigin(origin, "."),
+		Records: recs,
+	}
+	sort.Sort(z)
+}
+
+func (z *genYamlData) Len() int      { return len(z.Records) }
+func (z *genYamlData) Swap(i, j int) { z.Records[i], z.Records[j] = z.Records[j], z.Records[i] }
+func (z *genYamlData) Less(i, j int) bool {
+	a, b := z.Records[i], z.Records[j]
+	compA, compB := a.GetLabel(), b.GetLabel()
+	if compA != compB {
+		if compA == z.Origin+"." {
+			compA = "@"
+		}
+		if compB == z.Origin+"." {
+			compB = "@"
+		}
+		return zoneLabelLess(compA, compB)
+	}
+	rrtypeA, rrtypeB := a.Type, b.Type
+	if rrtypeA != rrtypeB {
+		return zoneRrtypeLess(rrtypeA, rrtypeB)
+	}
+	switch rrtypeA { // #rtype_variations
+	case "NS", "TXT", "TLSA":
+		// pass through.
+	case "A":
+		ta2, tb2 := net.ParseIP(a.Target), net.ParseIP(b.Target)
+		ipa, ipb := ta2.To4(), tb2.To4()
+		if ipa == nil || ipb == nil {
+			log.Fatalf("should not happen: IPs are not 4 bytes: %#v %#v", ta2, tb2)
+		}
+		return bytes.Compare(ipa, ipb) == -1
+	case "AAAA":
+		ta2, tb2 := net.ParseIP(a.Target), net.ParseIP(b.Target)
+		ipa, ipb := ta2.To16(), tb2.To16()
+		return bytes.Compare(ipa, ipb) == -1
+	case "MX":
+		pa, pb := a.MxPreference, b.MxPreference
+		return pa < pb
+	case "SRV":
+		pa, pb := a.SrvPort, b.SrvPort
+		if pa != pb {
+			return pa < pb
+		}
+		pa, pb = a.SrvPriority, b.SrvPriority
+		if pa != pb {
+			return pa < pb
+		}
+		pa, pb = a.SrvWeight, a.SrvWeight
+		if pa != pb {
+			return pa < pb
+		}
+	case "PTR":
+		pa, pb := a.Target, b.Target
+		if pa != pb {
+			return pa < pb
+		}
+	case "CAA":
+		// sort by tag
+		pa, pb := a.CaaTag, b.CaaTag
+		if pa != pb {
+			return pa < pb
+		}
+		// then flag
+		fa, fb := a.CaaFlag, b.CaaFlag
+		if fa != fb {
+			// flag set goes before ones without flag set
+			return fa > fb
+		}
+	default:
+		panic(fmt.Sprintf("genYamlData Less: unimplemented rtype %v", a.Type))
+		// We panic so that we quickly find any switch statements
+		// that have not been updated for a new RR type.
+	}
+	return a.GetTargetSortable() < b.GetTargetSortable()
+}
+
+func zoneLabelLess(a, b string) bool {
+	return natsort.Less(a, b)
+	// octodns-validate wants a "natural sort" (i.e. foo10 comes after foo3).
+	// We emulate this with the natsort package.
+	// If you need to disable that validatation:
+	//    Edit env/lib/python2.7/site-packages/octodns/yaml.py
+	//    Change line 27: OLD: if key != expected
+	//                    NEW: if False and key != expected
+}
+
+func zoneRrtypeLess(a, b string) bool {
+	// Compare two RR types for the purpose of sorting the RRs in a Zone.
+
+	// If they are equal, we are done. All other code is simplified
+	// because we can assume a!=b.
+	if a == b {
+		return false
+	}
+
+	// List SOAs, then NSs, then all others.
+	// i.e. SOA is always less. NS is less than everything but SOA.
+	if a == "SOA" {
+		return true
+	}
+	if b == "SOA" {
+		return false
+	}
+	if a == "NS" {
+		return true
+	}
+	if b == "NS" {
+		return false
+	}
+	return a < b
+}

providers/octodns/octoyaml/write.go

@@ -0,0 +1,320 @@
+package octoyaml
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+
+	"github.com/StackExchange/dnscontrol/models"
+	"github.com/miekg/dns/dnsutil"
+	"github.com/pkg/errors"
+	yaml "gopkg.in/yaml.v2"
+)
+
+// WriteYaml outputs a yaml version of a list of RecordConfig.
+func WriteYaml(w io.Writer, records models.Records, origin string) error {
+	if len(records) == 0 {
+		return nil
+	}
+
+	// Pick the most common TTL as the default so we can
+	// write the fewest "ttl:" lines.
+	defaultTTL := mostCommonTTL(records)
+
+	// Make a copy of the records, since we want to sort and muck with them.
+	recsCopy := models.Records{}
+	for _, r := range records {
+		recsCopy = append(recsCopy, r)
+	}
+	for _, r := range recsCopy {
+		if r.Name == "@" {
+			r.Name = ""
+		}
+	}
+
+	z := &genYamlData{
+		Origin:     dnsutil.AddOrigin(origin, "."),
+		DefaultTTL: defaultTTL,
+		Records:    recsCopy,
+	}
+
+	// Sort in the weird order that OctoDNS expects:
+	sort.Sort(z)
+
+	// Generate the YAML:
+	fmt.Fprintln(w, "---")
+	yb, err := yaml.Marshal(z.genInterfaceList(w))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(yb)
+
+	return err
+}
+
+// genInterfaceList outputs YAML ordered slices for the entire zone.
+// Each item in the list is an interface that will MarshallYAML to
+// the desired output.
+func (z *genYamlData) genInterfaceList(w io.Writer) yaml.MapSlice {
+	var yam yaml.MapSlice
+	// Group the records by label.
+	order, groups := z.Records.GroupedByLabel()
+	// For each group, generate the YAML.
+	for _, label := range order {
+		group := groups[label]
+		// Within the group, sort the similar Types together:
+		sort.SliceStable(group, func(i, j int) bool { return zoneRrtypeLess(group[i].Type, group[j].Type) })
+		// Generate the YAML records:
+		yam = append(yam, oneLabel(group))
+	}
+	return yam
+}
+
+// "simple" records are when a label has a single rtype.
+// It may have a single (simple) or multiple (many) values.
+
+// Used to generate:
+//  label:
+//    type: A
+//    value: 1.2.3.4
+type simple struct {
+	TTL   uint32 `yaml:"ttl,omitempty"`
+	Type  string `yaml:"type"`
+	Value string `yaml:"value"`
+}
+
+// Used to generate:
+//  label:
+//    type: A
+//    values:
+//    - 1.2.3.4
+//    - 2.3.4.5
+type many struct {
+	TTL    uint32   `yaml:"ttl,omitempty"`
+	Type   string   `yaml:"type"`
+	Values []string `yaml:"values"`
+}
+
+// complexItems are when a single label has multiple rtypes
+// associated with it. For example, a label with both an A and MX record.
+type complexItems []interface{}
+
+// Used to generate a complex item with either a single value or multiple values:
+// 'thing':                             >> complexVals
+//   - type: CNAME
+//     value: newplace.example.com.     << value
+// 'www':
+//   - type: A
+//     values:
+//       - 1.2.3.4                      << values
+//       - 1.2.3.5                      << values
+//   - type: MX
+//     values:
+//       - priority: 10                 << fields
+//         value: mx1.example.com.      << fields
+//       - priority: 10                 << fields
+//         value: mx2.example.com.      << fields
+type complexVals struct {
+	TTL    uint32   `yaml:"ttl,omitempty"`
+	Type   string   `yaml:"type"`
+	Value  string   `yaml:"value,omitempty"`
+	Values []string `yaml:"values,omitempty"`
+}
+
+// Used to generate rtypes like MX rand SRV ecords, which have multiple
+// fields within the rtype.
+type complexFields struct {
+	TTL    uint32   `yaml:"ttl,omitempty"`
+	Type   string   `yaml:"type"`
+	Fields []fields `yaml:"values,omitempty"`
+}
+
+// Used to generate the fields themselves:
+type fields struct {
+	Priority  uint16 `yaml:"priority,omitempty"`
+	SrvWeight uint16 `yaml:"weight,omitempty"`
+	SrvPort   uint16 `yaml:"port,omitempty"`
+	Value     string `yaml:"value,omitempty"`
+}
+
+// FIXME(tlim): An MX record with .Priority=0 will not output the priority.
+
+// sameType returns true if all records have the same type.
+func sameType(records models.Records) bool {
+	t := records[0].Type
+	for _, r := range records {
+		if r.Type != t {
+			return false
+		}
+	}
+	return true
+}
+
+// oneLabel handles all the DNS records associated with a single label.
+// It dispatches the right code whether the label is simple, many, or complex.
+func oneLabel(records models.Records) yaml.MapItem {
+	item := yaml.MapItem{
+		// a yaml.MapItem is a YAML map that retains the key order.
+		Key: records[0].Name,
+	}
+	//  Special case labels with a single record:
+	if len(records) == 1 {
+		switch rtype := records[0].Type; rtype {
+		case "A", "CNAME", "NS", "PTR", "TXT":
+			v := simple{
+				Type:  rtype,
+				Value: records[0].GetTargetField(),
+				TTL:   records[0].TTL,
+			}
+			if v.Type == "TXT" {
+				v.Value = strings.Replace(models.StripQuotes(v.Value), `;`, `\;`, -1)
+			}
+			//fmt.Printf("yamlwrite:oneLabel: simple ttl=%d\n", v.TTL)
+			item.Value = v
+			//fmt.Printf("yamlwrite:oneLabel: SIMPLE=%v\n", item)
+			return item
+		case "MX", "SRV":
+			// Always processed as a complex{}
+		default:
+			panic(errors.Errorf("yamlwrite:oneLabel:len1 rtype not implemented: %s", rtype))
+		}
+	}
+
+	//  Special case labels with many records, all the same rType:
+	if sameType(records) {
+		switch rtype := records[0].Type; rtype {
+		case "A", "CNAME", "NS":
+			v := many{
+				Type: rtype,
+				TTL:  records[0].TTL,
+			}
+			for _, rec := range records {
+				v.Values = append(v.Values, rec.GetTargetField())
+			}
+			item.Value = v
+			//fmt.Printf("SIMPLE=%v\n", item)
+			return item
+		case "MX", "SRV":
+			// Always processed as a complex{}
+		default:
+			panic(errors.Errorf("oneLabel:many rtype not implemented: %s", rtype))
+		}
+	}
+
+	// All other labels are complexItems
+
+	var low int // First index of a run.
+	var lst complexItems
+	var last = records[0].Type
+	for i := range records {
+		if records[i].Type != last {
+			//fmt.Printf("yamlwrite:oneLabel: Calling oneType( [%d:%d] ) last=%s type=%s\n", low, i, last, records[0].Type)
+			lst = append(lst, oneType(records[low:i]))
+			low = i // Current is the first of a run.
+			last = records[i].Type
+		}
+		if i == (len(records) - 1) {
+			// we are on the last element.
+			//fmt.Printf("yamlwrite:oneLabel: Calling oneType( [%d:%d] ) last=%s type=%s\n", low, i+1, last, records[0].Type)
+			lst = append(lst, oneType(records[low:i+1]))
+		}
+	}
+	item.Value = lst
+
+	return item
+}
+
+// oneType returns interfaces that will MarshalYAML properly for a label with
+// one or more records, all the same rtype.
+func oneType(records models.Records) interface{} {
+	//fmt.Printf("yamlwrite:oneType len=%d type=%s\n", len(records), records[0].Type)
+	rtype := records[0].Type
+	switch rtype {
+	case "A", "AAAA", "NS":
+		vv := complexVals{
+			Type: rtype,
+			TTL:  records[0].TTL,
+		}
+		if len(records) == 1 {
+			vv.Value = records[0].GetTargetField()
+		} else {
+			for _, rc := range records {
+				vv.Values = append(vv.Values, rc.GetTargetCombined())
+			}
+		}
+		return vv
+	case "MX":
+		vv := complexFields{
+			Type: rtype,
+			TTL:  records[0].TTL,
+		}
+		for _, rc := range records {
+			vv.Fields = append(vv.Fields, fields{
+				Value:    rc.GetTargetField(),
+				Priority: rc.MxPreference,
+			})
+		}
+		return vv
+	case "SRV":
+		vv := complexFields{
+			Type: rtype,
+			TTL:  records[0].TTL,
+		}
+		for _, rc := range records {
+			vv.Fields = append(vv.Fields, fields{
+				Value:     rc.GetTargetField(),
+				Priority:  rc.SrvPriority,
+				SrvWeight: rc.SrvWeight,
+				SrvPort:   rc.SrvPort,
+			})
+		}
+		return vv
+	case "TXT":
+		vv := complexVals{
+			Type: rtype,
+			TTL:  records[0].TTL,
+		}
+		if len(records) == 1 {
+			vv.Value = strings.Replace(models.StripQuotes(records[0].GetTargetField()), `;`, `\;`, -1)
+		} else {
+			for _, rc := range records {
+				vv.Values = append(vv.Values, models.StripQuotes(rc.GetTargetCombined()))
+			}
+		}
+		return vv
+
+	default:
+		panic(errors.Errorf("yamlwrite:oneType rtype=%s not implemented", rtype))
+	}
+}
+
+// mostCommonTTL returns the most common TTL in a set of records. If there is
+// a tie, the highest TTL is selected. This makes the results consistent.
+// NS records are not included in the analysis because Tom said so.
+func mostCommonTTL(records models.Records) uint32 {
+	// Index the TTLs in use:
+	d := make(map[uint32]int)
+	for _, r := range records {
+		if r.Type != "NS" {
+			d[r.TTL]++
+		}
+	}
+	// Find the largest count:
+	var mc int
+	for _, value := range d {
+		if value > mc {
+			mc = value
+		}
+	}
+	// Find the largest key with that count:
+	var mk uint32
+	for key, value := range d {
+		if value == mc {
+			if key > mk {
+				mk = key
+			}
+		}
+	}
+	return mk
+}

providers/octodns/testdata/production.yaml

@@ -0,0 +1,84 @@
+---
+providers:
+  config:
+    class: octodns.provider.yaml.YamlProvider
+    directory: ./config
+zones:
+  apptivate.ms.:
+    sources:
+      - config
+  askubuntu.com.:
+    sources:
+      - config
+  blogoverflow.com.:
+    sources:
+      - config
+  bosun.org.:
+    sources:
+      - config
+  hashcode.ru.:
+    sources:
+      - config
+  isstackoverflowdownforeveryoneorjustme.com.:
+    sources:
+      - config
+  mathoverflow.net.:
+    sources:
+      - config
+  miniprofiler.com.:
+    sources:
+      - config
+  s.tk.:
+    sources:
+      - config
+  serverfault.com.:
+    sources:
+      - config
+  sezn.ru.:
+    sources:
+      - config
+  sstatic.net.:
+    sources:
+      - config
+  stackapps.com.:
+    sources:
+      - config
+  stackauth.com.:
+    sources:
+      - config
+  stackenterprise.co.:
+    sources:
+      - config
+  stackex.com.:
+    sources:
+      - config
+  stackexchange.com.:
+    sources:
+      - config
+  stackoverflow.blog.:
+    sources:
+      - config
+  stackoverflow.com.:
+    sources:
+      - config
+  stackoverflow.design.:
+    sources:
+      - config
+  stackoverflow.email.:
+    sources:
+      - config
+  stackoverflow.ru.:
+    sources:
+      - config
+  stackoverflowbusiness.com.:
+    sources:
+      - config
+  stacksnippets.net.:
+    sources:
+      - config
+  superuser.com.:
+    sources:
+      - config
+  teststackoverflow.com.:
+    sources:
+      - config

vendor/gopkg.in/yaml.v2/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/gopkg.in/yaml.v2/LICENSE.libyaml

@@ -0,0 +1,31 @@
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original copyright and license:
+
+    apic.go
+    emitterc.go
+    parserc.go
+    readerc.go
+    scannerc.go
+    writerc.go
+    yamlh.go
+    yamlprivateh.go
+
+Copyright (c) 2006 Kirill Simonov
+
+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.

vendor/gopkg.in/yaml.v2/README.md

@@ -0,0 +1,135 @@
+# YAML support for the Go language
+
+Introduction
+------------
+
+The yaml package enables Go programs to comfortably encode and decode YAML
+values. It was developed within [Canonical](https://www.canonical.com) as
+part of the [juju](https://juju.ubuntu.com) project, and is based on a
+pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
+C library to parse and generate YAML data quickly and reliably.
+
+Compatibility
+-------------
+
+The yaml package supports most of YAML 1.1 and 1.2, including support for
+anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
+implemented, and base-60 floats from YAML 1.1 are purposefully not
+supported since they're a poor design and are gone in YAML 1.2.
+
+Installation and usage
+----------------------
+
+The import path for the package is *gopkg.in/yaml.v2*.
+
+To install it, run:
+
+    go get gopkg.in/yaml.v2
+
+API documentation
+-----------------
+
+If opened in a browser, the import path itself leads to the API documentation:
+
+  * [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
+
+API stability
+-------------
+
+The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
+
+
+License
+-------
+
+The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
+
+
+Example
+-------
+
+Some more examples can be found in the "examples" folder.
+
+```Go
+package main
+
+import (
+        "fmt"
+        "log"
+
+        "gopkg.in/yaml.v2"
+)
+
+var data = `
+a: Easy!
+b:
+  c: 2
+  d: [3, 4]
+`
+
+// Note: struct fields must be public in order for unmarshal to
+// correctly populate the data.
+type T struct {
+        A string
+        B struct {
+                RenamedC int   `yaml:"c"`
+                D        []int `yaml:",flow"`
+        }
+}
+
+func main() {
+        t := T{}
+    
+        err := yaml.Unmarshal([]byte(data), &t)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- t:\n%v\n\n", t)
+    
+        d, err := yaml.Marshal(&t)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- t dump:\n%s\n\n", string(d))
+    
+        m := make(map[interface{}]interface{})
+    
+        err = yaml.Unmarshal([]byte(data), &m)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- m:\n%v\n\n", m)
+    
+        d, err = yaml.Marshal(&m)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- m dump:\n%s\n\n", string(d))
+}
+```
+
+This example will generate the following output:
+
+```
+--- t:
+{Easy! {2 [3 4]}}
+
+--- t dump:
+a: Easy!
+b:
+  c: 2
+  d: [3, 4]
+
+
+--- m:
+map[a:Easy! b:map[c:2 d:[3 4]]]
+
+--- m dump:
+a: Easy!
+b:
+  c: 2
+  d:
+  - 3
+  - 4
+```
+

vendor/gopkg.in/yaml.v2/apic.go

@@ -0,0 +1,742 @@
+package yaml
+
+import (
+	"io"
+	"os"
+)
+
+func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
+	//fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
+
+	// Check if we can move the queue at the beginning of the buffer.
+	if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
+		if parser.tokens_head != len(parser.tokens) {
+			copy(parser.tokens, parser.tokens[parser.tokens_head:])
+		}
+		parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
+		parser.tokens_head = 0
+	}
+	parser.tokens = append(parser.tokens, *token)
+	if pos < 0 {
+		return
+	}
+	copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
+	parser.tokens[parser.tokens_head+pos] = *token
+}
+
+// Create a new parser object.
+func yaml_parser_initialize(parser *yaml_parser_t) bool {
+	*parser = yaml_parser_t{
+		raw_buffer: make([]byte, 0, input_raw_buffer_size),
+		buffer:     make([]byte, 0, input_buffer_size),
+	}
+	return true
+}
+
+// Destroy a parser object.
+func yaml_parser_delete(parser *yaml_parser_t) {
+	*parser = yaml_parser_t{}
+}
+
+// String read handler.
+func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+	if parser.input_pos == len(parser.input) {
+		return 0, io.EOF
+	}
+	n = copy(buffer, parser.input[parser.input_pos:])
+	parser.input_pos += n
+	return n, nil
+}
+
+// File read handler.
+func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+	return parser.input_file.Read(buffer)
+}
+
+// Set a string input.
+func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
+	if parser.read_handler != nil {
+		panic("must set the input source only once")
+	}
+	parser.read_handler = yaml_string_read_handler
+	parser.input = input
+	parser.input_pos = 0
+}
+
+// Set a file input.
+func yaml_parser_set_input_file(parser *yaml_parser_t, file *os.File) {
+	if parser.read_handler != nil {
+		panic("must set the input source only once")
+	}
+	parser.read_handler = yaml_file_read_handler
+	parser.input_file = file
+}
+
+// Set the source encoding.
+func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
+	if parser.encoding != yaml_ANY_ENCODING {
+		panic("must set the encoding only once")
+	}
+	parser.encoding = encoding
+}
+
+// Create a new emitter object.
+func yaml_emitter_initialize(emitter *yaml_emitter_t) bool {
+	*emitter = yaml_emitter_t{
+		buffer:     make([]byte, output_buffer_size),
+		raw_buffer: make([]byte, 0, output_raw_buffer_size),
+		states:     make([]yaml_emitter_state_t, 0, initial_stack_size),
+		events:     make([]yaml_event_t, 0, initial_queue_size),
+	}
+	return true
+}
+
+// Destroy an emitter object.
+func yaml_emitter_delete(emitter *yaml_emitter_t) {
+	*emitter = yaml_emitter_t{}
+}
+
+// String write handler.
+func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+	*emitter.output_buffer = append(*emitter.output_buffer, buffer...)
+	return nil
+}
+
+// File write handler.
+func yaml_file_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+	_, err := emitter.output_file.Write(buffer)
+	return err
+}
+
+// Set a string output.
+func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
+	if emitter.write_handler != nil {
+		panic("must set the output target only once")
+	}
+	emitter.write_handler = yaml_string_write_handler
+	emitter.output_buffer = output_buffer
+}
+
+// Set a file output.
+func yaml_emitter_set_output_file(emitter *yaml_emitter_t, file io.Writer) {
+	if emitter.write_handler != nil {
+		panic("must set the output target only once")
+	}
+	emitter.write_handler = yaml_file_write_handler
+	emitter.output_file = file
+}
+
+// Set the output encoding.
+func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
+	if emitter.encoding != yaml_ANY_ENCODING {
+		panic("must set the output encoding only once")
+	}
+	emitter.encoding = encoding
+}
+
+// Set the canonical output style.
+func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
+	emitter.canonical = canonical
+}
+
+//// Set the indentation increment.
+func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
+	if indent < 2 || indent > 9 {
+		indent = 2
+	}
+	emitter.best_indent = indent
+}
+
+// Set the preferred line width.
+func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
+	if width < 0 {
+		width = -1
+	}
+	emitter.best_width = width
+}
+
+// Set if unescaped non-ASCII characters are allowed.
+func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
+	emitter.unicode = unicode
+}
+
+// Set the preferred line break character.
+func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
+	emitter.line_break = line_break
+}
+
+///*
+// * Destroy a token object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_token_delete(yaml_token_t *token)
+//{
+//    assert(token);  // Non-NULL token object expected.
+//
+//    switch (token.type)
+//    {
+//        case YAML_TAG_DIRECTIVE_TOKEN:
+//            yaml_free(token.data.tag_directive.handle);
+//            yaml_free(token.data.tag_directive.prefix);
+//            break;
+//
+//        case YAML_ALIAS_TOKEN:
+//            yaml_free(token.data.alias.value);
+//            break;
+//
+//        case YAML_ANCHOR_TOKEN:
+//            yaml_free(token.data.anchor.value);
+//            break;
+//
+//        case YAML_TAG_TOKEN:
+//            yaml_free(token.data.tag.handle);
+//            yaml_free(token.data.tag.suffix);
+//            break;
+//
+//        case YAML_SCALAR_TOKEN:
+//            yaml_free(token.data.scalar.value);
+//            break;
+//
+//        default:
+//            break;
+//    }
+//
+//    memset(token, 0, sizeof(yaml_token_t));
+//}
+//
+///*
+// * Check if a string is a valid UTF-8 sequence.
+// *
+// * Check 'reader.c' for more details on UTF-8 encoding.
+// */
+//
+//static int
+//yaml_check_utf8(yaml_char_t *start, size_t length)
+//{
+//    yaml_char_t *end = start+length;
+//    yaml_char_t *pointer = start;
+//
+//    while (pointer < end) {
+//        unsigned char octet;
+//        unsigned int width;
+//        unsigned int value;
+//        size_t k;
+//
+//        octet = pointer[0];
+//        width = (octet & 0x80) == 0x00 ? 1 :
+//                (octet & 0xE0) == 0xC0 ? 2 :
+//                (octet & 0xF0) == 0xE0 ? 3 :
+//                (octet & 0xF8) == 0xF0 ? 4 : 0;
+//        value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+//                (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+//                (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+//                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+//        if (!width) return 0;
+//        if (pointer+width > end) return 0;
+//        for (k = 1; k < width; k ++) {
+//            octet = pointer[k];
+//            if ((octet & 0xC0) != 0x80) return 0;
+//            value = (value << 6) + (octet & 0x3F);
+//        }
+//        if (!((width == 1) ||
+//            (width == 2 && value >= 0x80) ||
+//            (width == 3 && value >= 0x800) ||
+//            (width == 4 && value >= 0x10000))) return 0;
+//
+//        pointer += width;
+//    }
+//
+//    return 1;
+//}
+//
+
+// Create STREAM-START.
+func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) bool {
+	*event = yaml_event_t{
+		typ:      yaml_STREAM_START_EVENT,
+		encoding: encoding,
+	}
+	return true
+}
+
+// Create STREAM-END.
+func yaml_stream_end_event_initialize(event *yaml_event_t) bool {
+	*event = yaml_event_t{
+		typ: yaml_STREAM_END_EVENT,
+	}
+	return true
+}
+
+// Create DOCUMENT-START.
+func yaml_document_start_event_initialize(event *yaml_event_t, version_directive *yaml_version_directive_t,
+	tag_directives []yaml_tag_directive_t, implicit bool) bool {
+	*event = yaml_event_t{
+		typ:               yaml_DOCUMENT_START_EVENT,
+		version_directive: version_directive,
+		tag_directives:    tag_directives,
+		implicit:          implicit,
+	}
+	return true
+}
+
+// Create DOCUMENT-END.
+func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) bool {
+	*event = yaml_event_t{
+		typ:      yaml_DOCUMENT_END_EVENT,
+		implicit: implicit,
+	}
+	return true
+}
+
+///*
+// * Create ALIAS.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
+//{
+//    mark yaml_mark_t = { 0, 0, 0 }
+//    anchor_copy *yaml_char_t = NULL
+//
+//    assert(event) // Non-NULL event object is expected.
+//    assert(anchor) // Non-NULL anchor is expected.
+//
+//    if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
+//
+//    anchor_copy = yaml_strdup(anchor)
+//    if (!anchor_copy)
+//        return 0
+//
+//    ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
+//
+//    return 1
+//}
+
+// Create SCALAR.
+func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
+	*event = yaml_event_t{
+		typ:             yaml_SCALAR_EVENT,
+		anchor:          anchor,
+		tag:             tag,
+		value:           value,
+		implicit:        plain_implicit,
+		quoted_implicit: quoted_implicit,
+		style:           yaml_style_t(style),
+	}
+	return true
+}
+
+// Create SEQUENCE-START.
+func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
+	*event = yaml_event_t{
+		typ:      yaml_SEQUENCE_START_EVENT,
+		anchor:   anchor,
+		tag:      tag,
+		implicit: implicit,
+		style:    yaml_style_t(style),
+	}
+	return true
+}
+
+// Create SEQUENCE-END.
+func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
+	*event = yaml_event_t{
+		typ: yaml_SEQUENCE_END_EVENT,
+	}
+	return true
+}
+
+// Create MAPPING-START.
+func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) bool {
+	*event = yaml_event_t{
+		typ:      yaml_MAPPING_START_EVENT,
+		anchor:   anchor,
+		tag:      tag,
+		implicit: implicit,
+		style:    yaml_style_t(style),
+	}
+	return true
+}
+
+// Create MAPPING-END.
+func yaml_mapping_end_event_initialize(event *yaml_event_t) bool {
+	*event = yaml_event_t{
+		typ: yaml_MAPPING_END_EVENT,
+	}
+	return true
+}
+
+// Destroy an event object.
+func yaml_event_delete(event *yaml_event_t) {
+	*event = yaml_event_t{}
+}
+
+///*
+// * Create a document object.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_initialize(document *yaml_document_t,
+//        version_directive *yaml_version_directive_t,
+//        tag_directives_start *yaml_tag_directive_t,
+//        tag_directives_end *yaml_tag_directive_t,
+//        start_implicit int, end_implicit int)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//    struct {
+//        start *yaml_node_t
+//        end *yaml_node_t
+//        top *yaml_node_t
+//    } nodes = { NULL, NULL, NULL }
+//    version_directive_copy *yaml_version_directive_t = NULL
+//    struct {
+//        start *yaml_tag_directive_t
+//        end *yaml_tag_directive_t
+//        top *yaml_tag_directive_t
+//    } tag_directives_copy = { NULL, NULL, NULL }
+//    value yaml_tag_directive_t = { NULL, NULL }
+//    mark yaml_mark_t = { 0, 0, 0 }
+//
+//    assert(document) // Non-NULL document object is expected.
+//    assert((tag_directives_start && tag_directives_end) ||
+//            (tag_directives_start == tag_directives_end))
+//                            // Valid tag directives are expected.
+//
+//    if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
+//
+//    if (version_directive) {
+//        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
+//        if (!version_directive_copy) goto error
+//        version_directive_copy.major = version_directive.major
+//        version_directive_copy.minor = version_directive.minor
+//    }
+//
+//    if (tag_directives_start != tag_directives_end) {
+//        tag_directive *yaml_tag_directive_t
+//        if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+//            goto error
+//        for (tag_directive = tag_directives_start
+//                tag_directive != tag_directives_end; tag_directive ++) {
+//            assert(tag_directive.handle)
+//            assert(tag_directive.prefix)
+//            if (!yaml_check_utf8(tag_directive.handle,
+//                        strlen((char *)tag_directive.handle)))
+//                goto error
+//            if (!yaml_check_utf8(tag_directive.prefix,
+//                        strlen((char *)tag_directive.prefix)))
+//                goto error
+//            value.handle = yaml_strdup(tag_directive.handle)
+//            value.prefix = yaml_strdup(tag_directive.prefix)
+//            if (!value.handle || !value.prefix) goto error
+//            if (!PUSH(&context, tag_directives_copy, value))
+//                goto error
+//            value.handle = NULL
+//            value.prefix = NULL
+//        }
+//    }
+//
+//    DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
+//            tag_directives_copy.start, tag_directives_copy.top,
+//            start_implicit, end_implicit, mark, mark)
+//
+//    return 1
+//
+//error:
+//    STACK_DEL(&context, nodes)
+//    yaml_free(version_directive_copy)
+//    while (!STACK_EMPTY(&context, tag_directives_copy)) {
+//        value yaml_tag_directive_t = POP(&context, tag_directives_copy)
+//        yaml_free(value.handle)
+//        yaml_free(value.prefix)
+//    }
+//    STACK_DEL(&context, tag_directives_copy)
+//    yaml_free(value.handle)
+//    yaml_free(value.prefix)
+//
+//    return 0
+//}
+//
+///*
+// * Destroy a document object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_document_delete(document *yaml_document_t)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//    tag_directive *yaml_tag_directive_t
+//
+//    context.error = YAML_NO_ERROR // Eliminate a compliler warning.
+//
+//    assert(document) // Non-NULL document object is expected.
+//
+//    while (!STACK_EMPTY(&context, document.nodes)) {
+//        node yaml_node_t = POP(&context, document.nodes)
+//        yaml_free(node.tag)
+//        switch (node.type) {
+//            case YAML_SCALAR_NODE:
+//                yaml_free(node.data.scalar.value)
+//                break
+//            case YAML_SEQUENCE_NODE:
+//                STACK_DEL(&context, node.data.sequence.items)
+//                break
+//            case YAML_MAPPING_NODE:
+//                STACK_DEL(&context, node.data.mapping.pairs)
+//                break
+//            default:
+//                assert(0) // Should not happen.
+//        }
+//    }
+//    STACK_DEL(&context, document.nodes)
+//
+//    yaml_free(document.version_directive)
+//    for (tag_directive = document.tag_directives.start
+//            tag_directive != document.tag_directives.end
+//            tag_directive++) {
+//        yaml_free(tag_directive.handle)
+//        yaml_free(tag_directive.prefix)
+//    }
+//    yaml_free(document.tag_directives.start)
+//
+//    memset(document, 0, sizeof(yaml_document_t))
+//}
+//
+///**
+// * Get a document node.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_node(document *yaml_document_t, index int)
+//{
+//    assert(document) // Non-NULL document object is expected.
+//
+//    if (index > 0 && document.nodes.start + index <= document.nodes.top) {
+//        return document.nodes.start + index - 1
+//    }
+//    return NULL
+//}
+//
+///**
+// * Get the root object.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_root_node(document *yaml_document_t)
+//{
+//    assert(document) // Non-NULL document object is expected.
+//
+//    if (document.nodes.top != document.nodes.start) {
+//        return document.nodes.start
+//    }
+//    return NULL
+//}
+//
+///*
+// * Add a scalar node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_scalar(document *yaml_document_t,
+//        tag *yaml_char_t, value *yaml_char_t, length int,
+//        style yaml_scalar_style_t)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//    mark yaml_mark_t = { 0, 0, 0 }
+//    tag_copy *yaml_char_t = NULL
+//    value_copy *yaml_char_t = NULL
+//    node yaml_node_t
+//
+//    assert(document) // Non-NULL document object is expected.
+//    assert(value) // Non-NULL value is expected.
+//
+//    if (!tag) {
+//        tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
+//    }
+//
+//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+//    tag_copy = yaml_strdup(tag)
+//    if (!tag_copy) goto error
+//
+//    if (length < 0) {
+//        length = strlen((char *)value)
+//    }
+//
+//    if (!yaml_check_utf8(value, length)) goto error
+//    value_copy = yaml_malloc(length+1)
+//    if (!value_copy) goto error
+//    memcpy(value_copy, value, length)
+//    value_copy[length] = '\0'
+//
+//    SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
+//    if (!PUSH(&context, document.nodes, node)) goto error
+//
+//    return document.nodes.top - document.nodes.start
+//
+//error:
+//    yaml_free(tag_copy)
+//    yaml_free(value_copy)
+//
+//    return 0
+//}
+//
+///*
+// * Add a sequence node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_sequence(document *yaml_document_t,
+//        tag *yaml_char_t, style yaml_sequence_style_t)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//    mark yaml_mark_t = { 0, 0, 0 }
+//    tag_copy *yaml_char_t = NULL
+//    struct {
+//        start *yaml_node_item_t
+//        end *yaml_node_item_t
+//        top *yaml_node_item_t
+//    } items = { NULL, NULL, NULL }
+//    node yaml_node_t
+//
+//    assert(document) // Non-NULL document object is expected.
+//
+//    if (!tag) {
+//        tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
+//    }
+//
+//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+//    tag_copy = yaml_strdup(tag)
+//    if (!tag_copy) goto error
+//
+//    if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
+//
+//    SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
+//            style, mark, mark)
+//    if (!PUSH(&context, document.nodes, node)) goto error
+//
+//    return document.nodes.top - document.nodes.start
+//
+//error:
+//    STACK_DEL(&context, items)
+//    yaml_free(tag_copy)
+//
+//    return 0
+//}
+//
+///*
+// * Add a mapping node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_mapping(document *yaml_document_t,
+//        tag *yaml_char_t, style yaml_mapping_style_t)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//    mark yaml_mark_t = { 0, 0, 0 }
+//    tag_copy *yaml_char_t = NULL
+//    struct {
+//        start *yaml_node_pair_t
+//        end *yaml_node_pair_t
+//        top *yaml_node_pair_t
+//    } pairs = { NULL, NULL, NULL }
+//    node yaml_node_t
+//
+//    assert(document) // Non-NULL document object is expected.
+//
+//    if (!tag) {
+//        tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
+//    }
+//
+//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+//    tag_copy = yaml_strdup(tag)
+//    if (!tag_copy) goto error
+//
+//    if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
+//
+//    MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
+//            style, mark, mark)
+//    if (!PUSH(&context, document.nodes, node)) goto error
+//
+//    return document.nodes.top - document.nodes.start
+//
+//error:
+//    STACK_DEL(&context, pairs)
+//    yaml_free(tag_copy)
+//
+//    return 0
+//}
+//
+///*
+// * Append an item to a sequence node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_sequence_item(document *yaml_document_t,
+//        sequence int, item int)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//
+//    assert(document) // Non-NULL document is required.
+//    assert(sequence > 0
+//            && document.nodes.start + sequence <= document.nodes.top)
+//                            // Valid sequence id is required.
+//    assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
+//                            // A sequence node is required.
+//    assert(item > 0 && document.nodes.start + item <= document.nodes.top)
+//                            // Valid item id is required.
+//
+//    if (!PUSH(&context,
+//                document.nodes.start[sequence-1].data.sequence.items, item))
+//        return 0
+//
+//    return 1
+//}
+//
+///*
+// * Append a pair of a key and a value to a mapping node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_mapping_pair(document *yaml_document_t,
+//        mapping int, key int, value int)
+//{
+//    struct {
+//        error yaml_error_type_t
+//    } context
+//
+//    pair yaml_node_pair_t
+//
+//    assert(document) // Non-NULL document is required.
+//    assert(mapping > 0
+//            && document.nodes.start + mapping <= document.nodes.top)
+//                            // Valid mapping id is required.
+//    assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
+//                            // A mapping node is required.
+//    assert(key > 0 && document.nodes.start + key <= document.nodes.top)
+//                            // Valid key id is required.
+//    assert(value > 0 && document.nodes.start + value <= document.nodes.top)
+//                            // Valid value id is required.
+//
+//    pair.key = key
+//    pair.value = value
+//
+//    if (!PUSH(&context,
+//                document.nodes.start[mapping-1].data.mapping.pairs, pair))
+//        return 0
+//
+//    return 1
+//}
+//
+//

vendor/gopkg.in/yaml.v2/decode.go

@@ -0,0 +1,685 @@
+package yaml
+
+import (
+	"encoding"
+	"encoding/base64"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+const (
+	documentNode = 1 << iota
+	mappingNode
+	sequenceNode
+	scalarNode
+	aliasNode
+)
+
+type node struct {
+	kind         int
+	line, column int
+	tag          string
+	value        string
+	implicit     bool
+	children     []*node
+	anchors      map[string]*node
+}
+
+// ----------------------------------------------------------------------------
+// Parser, produces a node tree out of a libyaml event stream.
+
+type parser struct {
+	parser yaml_parser_t
+	event  yaml_event_t
+	doc    *node
+}
+
+func newParser(b []byte) *parser {
+	p := parser{}
+	if !yaml_parser_initialize(&p.parser) {
+		panic("failed to initialize YAML emitter")
+	}
+
+	if len(b) == 0 {
+		b = []byte{'\n'}
+	}
+
+	yaml_parser_set_input_string(&p.parser, b)
+
+	p.skip()
+	if p.event.typ != yaml_STREAM_START_EVENT {
+		panic("expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
+	}
+	p.skip()
+	return &p
+}
+
+func (p *parser) destroy() {
+	if p.event.typ != yaml_NO_EVENT {
+		yaml_event_delete(&p.event)
+	}
+	yaml_parser_delete(&p.parser)
+}
+
+func (p *parser) skip() {
+	if p.event.typ != yaml_NO_EVENT {
+		if p.event.typ == yaml_STREAM_END_EVENT {
+			failf("attempted to go past the end of stream; corrupted value?")
+		}
+		yaml_event_delete(&p.event)
+	}
+	if !yaml_parser_parse(&p.parser, &p.event) {
+		p.fail()
+	}
+}
+
+func (p *parser) fail() {
+	var where string
+	var line int
+	if p.parser.problem_mark.line != 0 {
+		line = p.parser.problem_mark.line
+	} else if p.parser.context_mark.line != 0 {
+		line = p.parser.context_mark.line
+	}
+	if line != 0 {
+		where = "line " + strconv.Itoa(line) + ": "
+	}
+	var msg string
+	if len(p.parser.problem) > 0 {
+		msg = p.parser.problem
+	} else {
+		msg = "unknown problem parsing YAML content"
+	}
+	failf("%s%s", where, msg)
+}
+
+func (p *parser) anchor(n *node, anchor []byte) {
+	if anchor != nil {
+		p.doc.anchors[string(anchor)] = n
+	}
+}
+
+func (p *parser) parse() *node {
+	switch p.event.typ {
+	case yaml_SCALAR_EVENT:
+		return p.scalar()
+	case yaml_ALIAS_EVENT:
+		return p.alias()
+	case yaml_MAPPING_START_EVENT:
+		return p.mapping()
+	case yaml_SEQUENCE_START_EVENT:
+		return p.sequence()
+	case yaml_DOCUMENT_START_EVENT:
+		return p.document()
+	case yaml_STREAM_END_EVENT:
+		// Happens when attempting to decode an empty buffer.
+		return nil
+	default:
+		panic("attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ)))
+	}
+}
+
+func (p *parser) node(kind int) *node {
+	return &node{
+		kind:   kind,
+		line:   p.event.start_mark.line,
+		column: p.event.start_mark.column,
+	}
+}
+
+func (p *parser) document() *node {
+	n := p.node(documentNode)
+	n.anchors = make(map[string]*node)
+	p.doc = n
+	p.skip()
+	n.children = append(n.children, p.parse())
+	if p.event.typ != yaml_DOCUMENT_END_EVENT {
+		panic("expected end of document event but got " + strconv.Itoa(int(p.event.typ)))
+	}
+	p.skip()
+	return n
+}
+
+func (p *parser) alias() *node {
+	n := p.node(aliasNode)
+	n.value = string(p.event.anchor)
+	p.skip()
+	return n
+}
+
+func (p *parser) scalar() *node {
+	n := p.node(scalarNode)
+	n.value = string(p.event.value)
+	n.tag = string(p.event.tag)
+	n.implicit = p.event.implicit
+	p.anchor(n, p.event.anchor)
+	p.skip()
+	return n
+}
+
+func (p *parser) sequence() *node {
+	n := p.node(sequenceNode)
+	p.anchor(n, p.event.anchor)
+	p.skip()
+	for p.event.typ != yaml_SEQUENCE_END_EVENT {
+		n.children = append(n.children, p.parse())
+	}
+	p.skip()
+	return n
+}
+
+func (p *parser) mapping() *node {
+	n := p.node(mappingNode)
+	p.anchor(n, p.event.anchor)
+	p.skip()
+	for p.event.typ != yaml_MAPPING_END_EVENT {
+		n.children = append(n.children, p.parse(), p.parse())
+	}
+	p.skip()
+	return n
+}
+
+// ----------------------------------------------------------------------------
+// Decoder, unmarshals a node into a provided value.
+
+type decoder struct {
+	doc     *node
+	aliases map[string]bool
+	mapType reflect.Type
+	terrors []string
+	strict  bool
+}
+
+var (
+	mapItemType    = reflect.TypeOf(MapItem{})
+	durationType   = reflect.TypeOf(time.Duration(0))
+	defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
+	ifaceType      = defaultMapType.Elem()
+)
+
+func newDecoder(strict bool) *decoder {
+	d := &decoder{mapType: defaultMapType, strict: strict}
+	d.aliases = make(map[string]bool)
+	return d
+}
+
+func (d *decoder) terror(n *node, tag string, out reflect.Value) {
+	if n.tag != "" {
+		tag = n.tag
+	}
+	value := n.value
+	if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
+		if len(value) > 10 {
+			value = " `" + value[:7] + "...`"
+		} else {
+			value = " `" + value + "`"
+		}
+	}
+	d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
+}
+
+func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
+	terrlen := len(d.terrors)
+	err := u.UnmarshalYAML(func(v interface{}) (err error) {
+		defer handleErr(&err)
+		d.unmarshal(n, reflect.ValueOf(v))
+		if len(d.terrors) > terrlen {
+			issues := d.terrors[terrlen:]
+			d.terrors = d.terrors[:terrlen]
+			return &TypeError{issues}
+		}
+		return nil
+	})
+	if e, ok := err.(*TypeError); ok {
+		d.terrors = append(d.terrors, e.Errors...)
+		return false
+	}
+	if err != nil {
+		fail(err)
+	}
+	return true
+}
+
+// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
+// if a value is found to implement it.
+// It returns the initialized and dereferenced out value, whether
+// unmarshalling was already done by UnmarshalYAML, and if so whether
+// its types unmarshalled appropriately.
+//
+// If n holds a null value, prepare returns before doing anything.
+func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
+	if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) {
+		return out, false, false
+	}
+	again := true
+	for again {
+		again = false
+		if out.Kind() == reflect.Ptr {
+			if out.IsNil() {
+				out.Set(reflect.New(out.Type().Elem()))
+			}
+			out = out.Elem()
+			again = true
+		}
+		if out.CanAddr() {
+			if u, ok := out.Addr().Interface().(Unmarshaler); ok {
+				good = d.callUnmarshaler(n, u)
+				return out, true, good
+			}
+		}
+	}
+	return out, false, false
+}
+
+func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
+	switch n.kind {
+	case documentNode:
+		return d.document(n, out)
+	case aliasNode:
+		return d.alias(n, out)
+	}
+	out, unmarshaled, good := d.prepare(n, out)
+	if unmarshaled {
+		return good
+	}
+	switch n.kind {
+	case scalarNode:
+		good = d.scalar(n, out)
+	case mappingNode:
+		good = d.mapping(n, out)
+	case sequenceNode:
+		good = d.sequence(n, out)
+	default:
+		panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
+	}
+	return good
+}
+
+func (d *decoder) document(n *node, out reflect.Value) (good bool) {
+	if len(n.children) == 1 {
+		d.doc = n
+		d.unmarshal(n.children[0], out)
+		return true
+	}
+	return false
+}
+
+func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
+	an, ok := d.doc.anchors[n.value]
+	if !ok {
+		failf("unknown anchor '%s' referenced", n.value)
+	}
+	if d.aliases[n.value] {
+		failf("anchor '%s' value contains itself", n.value)
+	}
+	d.aliases[n.value] = true
+	good = d.unmarshal(an, out)
+	delete(d.aliases, n.value)
+	return good
+}
+
+var zeroValue reflect.Value
+
+func resetMap(out reflect.Value) {
+	for _, k := range out.MapKeys() {
+		out.SetMapIndex(k, zeroValue)
+	}
+}
+
+func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
+	var tag string
+	var resolved interface{}
+	if n.tag == "" && !n.implicit {
+		tag = yaml_STR_TAG
+		resolved = n.value
+	} else {
+		tag, resolved = resolve(n.tag, n.value)
+		if tag == yaml_BINARY_TAG {
+			data, err := base64.StdEncoding.DecodeString(resolved.(string))
+			if err != nil {
+				failf("!!binary value contains invalid base64 data")
+			}
+			resolved = string(data)
+		}
+	}
+	if resolved == nil {
+		if out.Kind() == reflect.Map && !out.CanAddr() {
+			resetMap(out)
+		} else {
+			out.Set(reflect.Zero(out.Type()))
+		}
+		return true
+	}
+	if s, ok := resolved.(string); ok && out.CanAddr() {
+		if u, ok := out.Addr().Interface().(encoding.TextUnmarshaler); ok {
+			err := u.UnmarshalText([]byte(s))
+			if err != nil {
+				fail(err)
+			}
+			return true
+		}
+	}
+	switch out.Kind() {
+	case reflect.String:
+		if tag == yaml_BINARY_TAG {
+			out.SetString(resolved.(string))
+			good = true
+		} else if resolved != nil {
+			out.SetString(n.value)
+			good = true
+		}
+	case reflect.Interface:
+		if resolved == nil {
+			out.Set(reflect.Zero(out.Type()))
+		} else {
+			out.Set(reflect.ValueOf(resolved))
+		}
+		good = true
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch resolved := resolved.(type) {
+		case int:
+			if !out.OverflowInt(int64(resolved)) {
+				out.SetInt(int64(resolved))
+				good = true
+			}
+		case int64:
+			if !out.OverflowInt(resolved) {
+				out.SetInt(resolved)
+				good = true
+			}
+		case uint64:
+			if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+				out.SetInt(int64(resolved))
+				good = true
+			}
+		case float64:
+			if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+				out.SetInt(int64(resolved))
+				good = true
+			}
+		case string:
+			if out.Type() == durationType {
+				d, err := time.ParseDuration(resolved)
+				if err == nil {
+					out.SetInt(int64(d))
+					good = true
+				}
+			}
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		switch resolved := resolved.(type) {
+		case int:
+			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+				out.SetUint(uint64(resolved))
+				good = true
+			}
+		case int64:
+			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+				out.SetUint(uint64(resolved))
+				good = true
+			}
+		case uint64:
+			if !out.OverflowUint(uint64(resolved)) {
+				out.SetUint(uint64(resolved))
+				good = true
+			}
+		case float64:
+			if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
+				out.SetUint(uint64(resolved))
+				good = true
+			}
+		}
+	case reflect.Bool:
+		switch resolved := resolved.(type) {
+		case bool:
+			out.SetBool(resolved)
+			good = true
+		}
+	case reflect.Float32, reflect.Float64:
+		switch resolved := resolved.(type) {
+		case int:
+			out.SetFloat(float64(resolved))
+			good = true
+		case int64:
+			out.SetFloat(float64(resolved))
+			good = true
+		case uint64:
+			out.SetFloat(float64(resolved))
+			good = true
+		case float64:
+			out.SetFloat(resolved)
+			good = true
+		}
+	case reflect.Ptr:
+		if out.Type().Elem() == reflect.TypeOf(resolved) {
+			// TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
+			elem := reflect.New(out.Type().Elem())
+			elem.Elem().Set(reflect.ValueOf(resolved))
+			out.Set(elem)
+			good = true
+		}
+	}
+	if !good {
+		d.terror(n, tag, out)
+	}
+	return good
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+	v := reflect.ValueOf(i)
+	sv := reflect.New(v.Type()).Elem()
+	sv.Set(v)
+	return sv
+}
+
+func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
+	l := len(n.children)
+
+	var iface reflect.Value
+	switch out.Kind() {
+	case reflect.Slice:
+		out.Set(reflect.MakeSlice(out.Type(), l, l))
+	case reflect.Interface:
+		// No type hints. Will have to use a generic sequence.
+		iface = out
+		out = settableValueOf(make([]interface{}, l))
+	default:
+		d.terror(n, yaml_SEQ_TAG, out)
+		return false
+	}
+	et := out.Type().Elem()
+
+	j := 0
+	for i := 0; i < l; i++ {
+		e := reflect.New(et).Elem()
+		if ok := d.unmarshal(n.children[i], e); ok {
+			out.Index(j).Set(e)
+			j++
+		}
+	}
+	out.Set(out.Slice(0, j))
+	if iface.IsValid() {
+		iface.Set(out)
+	}
+	return true
+}
+
+func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
+	switch out.Kind() {
+	case reflect.Struct:
+		return d.mappingStruct(n, out)
+	case reflect.Slice:
+		return d.mappingSlice(n, out)
+	case reflect.Map:
+		// okay
+	case reflect.Interface:
+		if d.mapType.Kind() == reflect.Map {
+			iface := out
+			out = reflect.MakeMap(d.mapType)
+			iface.Set(out)
+		} else {
+			slicev := reflect.New(d.mapType).Elem()
+			if !d.mappingSlice(n, slicev) {
+				return false
+			}
+			out.Set(slicev)
+			return true
+		}
+	default:
+		d.terror(n, yaml_MAP_TAG, out)
+		return false
+	}
+	outt := out.Type()
+	kt := outt.Key()
+	et := outt.Elem()
+
+	mapType := d.mapType
+	if outt.Key() == ifaceType && outt.Elem() == ifaceType {
+		d.mapType = outt
+	}
+
+	if out.IsNil() {
+		out.Set(reflect.MakeMap(outt))
+	}
+	l := len(n.children)
+	for i := 0; i < l; i += 2 {
+		if isMerge(n.children[i]) {
+			d.merge(n.children[i+1], out)
+			continue
+		}
+		k := reflect.New(kt).Elem()
+		if d.unmarshal(n.children[i], k) {
+			kkind := k.Kind()
+			if kkind == reflect.Interface {
+				kkind = k.Elem().Kind()
+			}
+			if kkind == reflect.Map || kkind == reflect.Slice {
+				failf("invalid map key: %#v", k.Interface())
+			}
+			e := reflect.New(et).Elem()
+			if d.unmarshal(n.children[i+1], e) {
+				out.SetMapIndex(k, e)
+			}
+		}
+	}
+	d.mapType = mapType
+	return true
+}
+
+func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
+	outt := out.Type()
+	if outt.Elem() != mapItemType {
+		d.terror(n, yaml_MAP_TAG, out)
+		return false
+	}
+
+	mapType := d.mapType
+	d.mapType = outt
+
+	var slice []MapItem
+	var l = len(n.children)
+	for i := 0; i < l; i += 2 {
+		if isMerge(n.children[i]) {
+			d.merge(n.children[i+1], out)
+			continue
+		}
+		item := MapItem{}
+		k := reflect.ValueOf(&item.Key).Elem()
+		if d.unmarshal(n.children[i], k) {
+			v := reflect.ValueOf(&item.Value).Elem()
+			if d.unmarshal(n.children[i+1], v) {
+				slice = append(slice, item)
+			}
+		}
+	}
+	out.Set(reflect.ValueOf(slice))
+	d.mapType = mapType
+	return true
+}
+
+func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
+	sinfo, err := getStructInfo(out.Type())
+	if err != nil {
+		panic(err)
+	}
+	name := settableValueOf("")
+	l := len(n.children)
+
+	var inlineMap reflect.Value
+	var elemType reflect.Type
+	if sinfo.InlineMap != -1 {
+		inlineMap = out.Field(sinfo.InlineMap)
+		inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
+		elemType = inlineMap.Type().Elem()
+	}
+
+	for i := 0; i < l; i += 2 {
+		ni := n.children[i]
+		if isMerge(ni) {
+			d.merge(n.children[i+1], out)
+			continue
+		}
+		if !d.unmarshal(ni, name) {
+			continue
+		}
+		if info, ok := sinfo.FieldsMap[name.String()]; ok {
+			var field reflect.Value
+			if info.Inline == nil {
+				field = out.Field(info.Num)
+			} else {
+				field = out.FieldByIndex(info.Inline)
+			}
+			d.unmarshal(n.children[i+1], field)
+		} else if sinfo.InlineMap != -1 {
+			if inlineMap.IsNil() {
+				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+			}
+			value := reflect.New(elemType).Elem()
+			d.unmarshal(n.children[i+1], value)
+			inlineMap.SetMapIndex(name, value)
+		} else if d.strict {
+			d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in struct %s", ni.line+1, name.String(), out.Type()))
+		}
+	}
+	return true
+}
+
+func failWantMap() {
+	failf("map merge requires map or sequence of maps as the value")
+}
+
+func (d *decoder) merge(n *node, out reflect.Value) {
+	switch n.kind {
+	case mappingNode:
+		d.unmarshal(n, out)
+	case aliasNode:
+		an, ok := d.doc.anchors[n.value]
+		if ok && an.kind != mappingNode {
+			failWantMap()
+		}
+		d.unmarshal(n, out)
+	case sequenceNode:
+		// Step backwards as earlier nodes take precedence.
+		for i := len(n.children) - 1; i >= 0; i-- {
+			ni := n.children[i]
+			if ni.kind == aliasNode {
+				an, ok := d.doc.anchors[ni.value]
+				if ok && an.kind != mappingNode {
+					failWantMap()
+				}
+			} else if ni.kind != mappingNode {
+				failWantMap()
+			}
+			d.unmarshal(ni, out)
+		}
+	default:
+		failWantMap()
+	}
+}
+
+func isMerge(n *node) bool {
+	return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
+}

vendor/gopkg.in/yaml.v2/encode.go

@@ -0,0 +1,306 @@
+package yaml
+
+import (
+	"encoding"
+	"fmt"
+	"reflect"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type encoder struct {
+	emitter yaml_emitter_t
+	event   yaml_event_t
+	out     []byte
+	flow    bool
+}
+
+func newEncoder() (e *encoder) {
+	e = &encoder{}
+	e.must(yaml_emitter_initialize(&e.emitter))
+	yaml_emitter_set_output_string(&e.emitter, &e.out)
+	yaml_emitter_set_unicode(&e.emitter, true)
+	e.must(yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING))
+	e.emit()
+	e.must(yaml_document_start_event_initialize(&e.event, nil, nil, true))
+	e.emit()
+	return e
+}
+
+func (e *encoder) finish() {
+	e.must(yaml_document_end_event_initialize(&e.event, true))
+	e.emit()
+	e.emitter.open_ended = false
+	e.must(yaml_stream_end_event_initialize(&e.event))
+	e.emit()
+}
+
+func (e *encoder) destroy() {
+	yaml_emitter_delete(&e.emitter)
+}
+
+func (e *encoder) emit() {
+	// This will internally delete the e.event value.
+	if !yaml_emitter_emit(&e.emitter, &e.event) && e.event.typ != yaml_DOCUMENT_END_EVENT && e.event.typ != yaml_STREAM_END_EVENT {
+		e.must(false)
+	}
+}
+
+func (e *encoder) must(ok bool) {
+	if !ok {
+		msg := e.emitter.problem
+		if msg == "" {
+			msg = "unknown problem generating YAML content"
+		}
+		failf("%s", msg)
+	}
+}
+
+func (e *encoder) marshal(tag string, in reflect.Value) {
+	if !in.IsValid() {
+		e.nilv()
+		return
+	}
+	iface := in.Interface()
+	if m, ok := iface.(Marshaler); ok {
+		v, err := m.MarshalYAML()
+		if err != nil {
+			fail(err)
+		}
+		if v == nil {
+			e.nilv()
+			return
+		}
+		in = reflect.ValueOf(v)
+	} else if m, ok := iface.(encoding.TextMarshaler); ok {
+		text, err := m.MarshalText()
+		if err != nil {
+			fail(err)
+		}
+		in = reflect.ValueOf(string(text))
+	}
+	switch in.Kind() {
+	case reflect.Interface:
+		if in.IsNil() {
+			e.nilv()
+		} else {
+			e.marshal(tag, in.Elem())
+		}
+	case reflect.Map:
+		e.mapv(tag, in)
+	case reflect.Ptr:
+		if in.IsNil() {
+			e.nilv()
+		} else {
+			e.marshal(tag, in.Elem())
+		}
+	case reflect.Struct:
+		e.structv(tag, in)
+	case reflect.Slice:
+		if in.Type().Elem() == mapItemType {
+			e.itemsv(tag, in)
+		} else {
+			e.slicev(tag, in)
+		}
+	case reflect.String:
+		e.stringv(tag, in)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if in.Type() == durationType {
+			e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
+		} else {
+			e.intv(tag, in)
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		e.uintv(tag, in)
+	case reflect.Float32, reflect.Float64:
+		e.floatv(tag, in)
+	case reflect.Bool:
+		e.boolv(tag, in)
+	default:
+		panic("cannot marshal type: " + in.Type().String())
+	}
+}
+
+func (e *encoder) mapv(tag string, in reflect.Value) {
+	e.mappingv(tag, func() {
+		keys := keyList(in.MapKeys())
+		sort.Sort(keys)
+		for _, k := range keys {
+			e.marshal("", k)
+			e.marshal("", in.MapIndex(k))
+		}
+	})
+}
+
+func (e *encoder) itemsv(tag string, in reflect.Value) {
+	e.mappingv(tag, func() {
+		slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
+		for _, item := range slice {
+			e.marshal("", reflect.ValueOf(item.Key))
+			e.marshal("", reflect.ValueOf(item.Value))
+		}
+	})
+}
+
+func (e *encoder) structv(tag string, in reflect.Value) {
+	sinfo, err := getStructInfo(in.Type())
+	if err != nil {
+		panic(err)
+	}
+	e.mappingv(tag, func() {
+		for _, info := range sinfo.FieldsList {
+			var value reflect.Value
+			if info.Inline == nil {
+				value = in.Field(info.Num)
+			} else {
+				value = in.FieldByIndex(info.Inline)
+			}
+			if info.OmitEmpty && isZero(value) {
+				continue
+			}
+			e.marshal("", reflect.ValueOf(info.Key))
+			e.flow = info.Flow
+			e.marshal("", value)
+		}
+		if sinfo.InlineMap >= 0 {
+			m := in.Field(sinfo.InlineMap)
+			if m.Len() > 0 {
+				e.flow = false
+				keys := keyList(m.MapKeys())
+				sort.Sort(keys)
+				for _, k := range keys {
+					if _, found := sinfo.FieldsMap[k.String()]; found {
+						panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
+					}
+					e.marshal("", k)
+					e.flow = false
+					e.marshal("", m.MapIndex(k))
+				}
+			}
+		}
+	})
+}
+
+func (e *encoder) mappingv(tag string, f func()) {
+	implicit := tag == ""
+	style := yaml_BLOCK_MAPPING_STYLE
+	if e.flow {
+		e.flow = false
+		style = yaml_FLOW_MAPPING_STYLE
+	}
+	e.must(yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
+	e.emit()
+	f()
+	e.must(yaml_mapping_end_event_initialize(&e.event))
+	e.emit()
+}
+
+func (e *encoder) slicev(tag string, in reflect.Value) {
+	implicit := tag == ""
+	style := yaml_BLOCK_SEQUENCE_STYLE
+	if e.flow {
+		e.flow = false
+		style = yaml_FLOW_SEQUENCE_STYLE
+	}
+	e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
+	e.emit()
+	n := in.Len()
+	for i := 0; i < n; i++ {
+		e.marshal("", in.Index(i))
+	}
+	e.must(yaml_sequence_end_event_initialize(&e.event))
+	e.emit()
+}
+
+// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
+//
+// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
+// in YAML 1.2 and by this package, but these should be marshalled quoted for
+// the time being for compatibility with other parsers.
+func isBase60Float(s string) (result bool) {
+	// Fast path.
+	if s == "" {
+		return false
+	}
+	c := s[0]
+	if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
+		return false
+	}
+	// Do the full match.
+	return base60float.MatchString(s)
+}
+
+// From http://yaml.org/type/float.html, except the regular expression there
+// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
+var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
+
+func (e *encoder) stringv(tag string, in reflect.Value) {
+	var style yaml_scalar_style_t
+	s := in.String()
+	rtag, rs := resolve("", s)
+	if rtag == yaml_BINARY_TAG {
+		if tag == "" || tag == yaml_STR_TAG {
+			tag = rtag
+			s = rs.(string)
+		} else if tag == yaml_BINARY_TAG {
+			failf("explicitly tagged !!binary data must be base64-encoded")
+		} else {
+			failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
+		}
+	}
+	if tag == "" && (rtag != yaml_STR_TAG || isBase60Float(s)) {
+		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+	} else if strings.Contains(s, "\n") {
+		style = yaml_LITERAL_SCALAR_STYLE
+	} else {
+		style = yaml_PLAIN_SCALAR_STYLE
+	}
+	e.emitScalar(s, "", tag, style)
+}
+
+func (e *encoder) boolv(tag string, in reflect.Value) {
+	var s string
+	if in.Bool() {
+		s = "true"
+	} else {
+		s = "false"
+	}
+	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) intv(tag string, in reflect.Value) {
+	s := strconv.FormatInt(in.Int(), 10)
+	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) uintv(tag string, in reflect.Value) {
+	s := strconv.FormatUint(in.Uint(), 10)
+	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) floatv(tag string, in reflect.Value) {
+	// FIXME: Handle 64 bits here.
+	s := strconv.FormatFloat(float64(in.Float()), 'g', -1, 32)
+	switch s {
+	case "+Inf":
+		s = ".inf"
+	case "-Inf":
+		s = "-.inf"
+	case "NaN":
+		s = ".nan"
+	}
+	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) nilv() {
+	e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
+	implicit := tag == ""
+	e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
+	e.emit()
+}

vendor/gopkg.in/yaml.v2/readerc.go

@@ -0,0 +1,394 @@
+package yaml
+
+import (
+	"io"
+)
+
+// Set the reader error and return 0.
+func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
+	parser.error = yaml_READER_ERROR
+	parser.problem = problem
+	parser.problem_offset = offset
+	parser.problem_value = value
+	return false
+}
+
+// Byte order marks.
+const (
+	bom_UTF8    = "\xef\xbb\xbf"
+	bom_UTF16LE = "\xff\xfe"
+	bom_UTF16BE = "\xfe\xff"
+)
+
+// Determine the input stream encoding by checking the BOM symbol. If no BOM is
+// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
+func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
+	// Ensure that we had enough bytes in the raw buffer.
+	for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
+		if !yaml_parser_update_raw_buffer(parser) {
+			return false
+		}
+	}
+
+	// Determine the encoding.
+	buf := parser.raw_buffer
+	pos := parser.raw_buffer_pos
+	avail := len(buf) - pos
+	if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
+		parser.encoding = yaml_UTF16LE_ENCODING
+		parser.raw_buffer_pos += 2
+		parser.offset += 2
+	} else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
+		parser.encoding = yaml_UTF16BE_ENCODING
+		parser.raw_buffer_pos += 2
+		parser.offset += 2
+	} else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
+		parser.encoding = yaml_UTF8_ENCODING
+		parser.raw_buffer_pos += 3
+		parser.offset += 3
+	} else {
+		parser.encoding = yaml_UTF8_ENCODING
+	}
+	return true
+}
+
+// Update the raw buffer.
+func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
+	size_read := 0
+
+	// Return if the raw buffer is full.
+	if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
+		return true
+	}
+
+	// Return on EOF.
+	if parser.eof {
+		return true
+	}
+
+	// Move the remaining bytes in the raw buffer to the beginning.
+	if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
+		copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
+	}
+	parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
+	parser.raw_buffer_pos = 0
+
+	// Call the read handler to fill the buffer.
+	size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
+	parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
+	if err == io.EOF {
+		parser.eof = true
+	} else if err != nil {
+		return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
+	}
+	return true
+}
+
+// Ensure that the buffer contains at least `length` characters.
+// Return true on success, false on failure.
+//
+// The length is supposed to be significantly less that the buffer size.
+func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
+	if parser.read_handler == nil {
+		panic("read handler must be set")
+	}
+
+	// If the EOF flag is set and the raw buffer is empty, do nothing.
+	if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
+		return true
+	}
+
+	// Return if the buffer contains enough characters.
+	if parser.unread >= length {
+		return true
+	}
+
+	// Determine the input encoding if it is not known yet.
+	if parser.encoding == yaml_ANY_ENCODING {
+		if !yaml_parser_determine_encoding(parser) {
+			return false
+		}
+	}
+
+	// Move the unread characters to the beginning of the buffer.
+	buffer_len := len(parser.buffer)
+	if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
+		copy(parser.buffer, parser.buffer[parser.buffer_pos:])
+		buffer_len -= parser.buffer_pos
+		parser.buffer_pos = 0
+	} else if parser.buffer_pos == buffer_len {
+		buffer_len = 0
+		parser.buffer_pos = 0
+	}
+
+	// Open the whole buffer for writing, and cut it before returning.
+	parser.buffer = parser.buffer[:cap(parser.buffer)]
+
+	// Fill the buffer until it has enough characters.
+	first := true
+	for parser.unread < length {
+
+		// Fill the raw buffer if necessary.
+		if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
+			if !yaml_parser_update_raw_buffer(parser) {
+				parser.buffer = parser.buffer[:buffer_len]
+				return false
+			}
+		}
+		first = false
+
+		// Decode the raw buffer.
+	inner:
+		for parser.raw_buffer_pos != len(parser.raw_buffer) {
+			var value rune
+			var width int
+
+			raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
+
+			// Decode the next character.
+			switch parser.encoding {
+			case yaml_UTF8_ENCODING:
+				// Decode a UTF-8 character.  Check RFC 3629
+				// (http://www.ietf.org/rfc/rfc3629.txt) for more details.
+				//
+				// The following table (taken from the RFC) is used for
+				// decoding.
+				//
+				//    Char. number range |        UTF-8 octet sequence
+				//      (hexadecimal)    |              (binary)
+				//   --------------------+------------------------------------
+				//   0000 0000-0000 007F | 0xxxxxxx
+				//   0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+				//   0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+				//   0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+				//
+				// Additionally, the characters in the range 0xD800-0xDFFF
+				// are prohibited as they are reserved for use with UTF-16
+				// surrogate pairs.
+
+				// Determine the length of the UTF-8 sequence.
+				octet := parser.raw_buffer[parser.raw_buffer_pos]
+				switch {
+				case octet&0x80 == 0x00:
+					width = 1
+				case octet&0xE0 == 0xC0:
+					width = 2
+				case octet&0xF0 == 0xE0:
+					width = 3
+				case octet&0xF8 == 0xF0:
+					width = 4
+				default:
+					// The leading octet is invalid.
+					return yaml_parser_set_reader_error(parser,
+						"invalid leading UTF-8 octet",
+						parser.offset, int(octet))
+				}
+
+				// Check if the raw buffer contains an incomplete character.
+				if width > raw_unread {
+					if parser.eof {
+						return yaml_parser_set_reader_error(parser,
+							"incomplete UTF-8 octet sequence",
+							parser.offset, -1)
+					}
+					break inner
+				}
+
+				// Decode the leading octet.
+				switch {
+				case octet&0x80 == 0x00:
+					value = rune(octet & 0x7F)
+				case octet&0xE0 == 0xC0:
+					value = rune(octet & 0x1F)
+				case octet&0xF0 == 0xE0:
+					value = rune(octet & 0x0F)
+				case octet&0xF8 == 0xF0:
+					value = rune(octet & 0x07)
+				default:
+					value = 0
+				}
+
+				// Check and decode the trailing octets.
+				for k := 1; k < width; k++ {
+					octet = parser.raw_buffer[parser.raw_buffer_pos+k]
+
+					// Check if the octet is valid.
+					if (octet & 0xC0) != 0x80 {
+						return yaml_parser_set_reader_error(parser,
+							"invalid trailing UTF-8 octet",
+							parser.offset+k, int(octet))
+					}
+
+					// Decode the octet.
+					value = (value << 6) + rune(octet&0x3F)
+				}
+
+				// Check the length of the sequence against the value.
+				switch {
+				case width == 1:
+				case width == 2 && value >= 0x80:
+				case width == 3 && value >= 0x800:
+				case width == 4 && value >= 0x10000:
+				default:
+					return yaml_parser_set_reader_error(parser,
+						"invalid length of a UTF-8 sequence",
+						parser.offset, -1)
+				}
+
+				// Check the range of the value.
+				if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
+					return yaml_parser_set_reader_error(parser,
+						"invalid Unicode character",
+						parser.offset, int(value))
+				}
+
+			case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
+				var low, high int
+				if parser.encoding == yaml_UTF16LE_ENCODING {
+					low, high = 0, 1
+				} else {
+					low, high = 1, 0
+				}
+
+				// The UTF-16 encoding is not as simple as one might
+				// naively think.  Check RFC 2781
+				// (http://www.ietf.org/rfc/rfc2781.txt).
+				//
+				// Normally, two subsequent bytes describe a Unicode
+				// character.  However a special technique (called a
+				// surrogate pair) is used for specifying character
+				// values larger than 0xFFFF.
+				//
+				// A surrogate pair consists of two pseudo-characters:
+				//      high surrogate area (0xD800-0xDBFF)
+				//      low surrogate area (0xDC00-0xDFFF)
+				//
+				// The following formulas are used for decoding
+				// and encoding characters using surrogate pairs:
+				//
+				//  U  = U' + 0x10000   (0x01 00 00 <= U <= 0x10 FF FF)
+				//  U' = yyyyyyyyyyxxxxxxxxxx   (0 <= U' <= 0x0F FF FF)
+				//  W1 = 110110yyyyyyyyyy
+				//  W2 = 110111xxxxxxxxxx
+				//
+				// where U is the character value, W1 is the high surrogate
+				// area, W2 is the low surrogate area.
+
+				// Check for incomplete UTF-16 character.
+				if raw_unread < 2 {
+					if parser.eof {
+						return yaml_parser_set_reader_error(parser,
+							"incomplete UTF-16 character",
+							parser.offset, -1)
+					}
+					break inner
+				}
+
+				// Get the character.
+				value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
+					(rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
+
+				// Check for unexpected low surrogate area.
+				if value&0xFC00 == 0xDC00 {
+					return yaml_parser_set_reader_error(parser,
+						"unexpected low surrogate area",
+						parser.offset, int(value))
+				}
+
+				// Check for a high surrogate area.
+				if value&0xFC00 == 0xD800 {
+					width = 4
+
+					// Check for incomplete surrogate pair.
+					if raw_unread < 4 {
+						if parser.eof {
+							return yaml_parser_set_reader_error(parser,
+								"incomplete UTF-16 surrogate pair",
+								parser.offset, -1)
+						}
+						break inner
+					}
+
+					// Get the next character.
+					value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
+						(rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
+
+					// Check for a low surrogate area.
+					if value2&0xFC00 != 0xDC00 {
+						return yaml_parser_set_reader_error(parser,
+							"expected low surrogate area",
+							parser.offset+2, int(value2))
+					}
+
+					// Generate the value of the surrogate pair.
+					value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
+				} else {
+					width = 2
+				}
+
+			default:
+				panic("impossible")
+			}
+
+			// Check if the character is in the allowed range:
+			//      #x9 | #xA | #xD | [#x20-#x7E]               (8 bit)
+			//      | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD]    (16 bit)
+			//      | [#x10000-#x10FFFF]                        (32 bit)
+			switch {
+			case value == 0x09:
+			case value == 0x0A:
+			case value == 0x0D:
+			case value >= 0x20 && value <= 0x7E:
+			case value == 0x85:
+			case value >= 0xA0 && value <= 0xD7FF:
+			case value >= 0xE000 && value <= 0xFFFD:
+			case value >= 0x10000 && value <= 0x10FFFF:
+			default:
+				return yaml_parser_set_reader_error(parser,
+					"control characters are not allowed",
+					parser.offset, int(value))
+			}
+
+			// Move the raw pointers.
+			parser.raw_buffer_pos += width
+			parser.offset += width
+
+			// Finally put the character into the buffer.
+			if value <= 0x7F {
+				// 0000 0000-0000 007F . 0xxxxxxx
+				parser.buffer[buffer_len+0] = byte(value)
+				buffer_len += 1
+			} else if value <= 0x7FF {
+				// 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
+				parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
+				parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
+				buffer_len += 2
+			} else if value <= 0xFFFF {
+				// 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
+				parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
+				parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
+				parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
+				buffer_len += 3
+			} else {
+				// 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+				parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
+				parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
+				parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
+				parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
+				buffer_len += 4
+			}
+
+			parser.unread++
+		}
+
+		// On EOF, put NUL into the buffer and return.
+		if parser.eof {
+			parser.buffer[buffer_len] = 0
+			buffer_len++
+			parser.unread++
+			break
+		}
+	}
+	parser.buffer = parser.buffer[:buffer_len]
+	return true
+}

vendor/gopkg.in/yaml.v2/resolve.go

@@ -0,0 +1,208 @@
+package yaml
+
+import (
+	"encoding/base64"
+	"math"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+type resolveMapItem struct {
+	value interface{}
+	tag   string
+}
+
+var resolveTable = make([]byte, 256)
+var resolveMap = make(map[string]resolveMapItem)
+
+func init() {
+	t := resolveTable
+	t[int('+')] = 'S' // Sign
+	t[int('-')] = 'S'
+	for _, c := range "0123456789" {
+		t[int(c)] = 'D' // Digit
+	}
+	for _, c := range "yYnNtTfFoO~" {
+		t[int(c)] = 'M' // In map
+	}
+	t[int('.')] = '.' // Float (potentially in map)
+
+	var resolveMapList = []struct {
+		v   interface{}
+		tag string
+		l   []string
+	}{
+		{true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
+		{true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
+		{true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
+		{false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
+		{false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
+		{false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
+		{nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
+		{math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
+		{math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
+		{math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
+		{math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
+		{"<<", yaml_MERGE_TAG, []string{"<<"}},
+	}
+
+	m := resolveMap
+	for _, item := range resolveMapList {
+		for _, s := range item.l {
+			m[s] = resolveMapItem{item.v, item.tag}
+		}
+	}
+}
+
+const longTagPrefix = "tag:yaml.org,2002:"
+
+func shortTag(tag string) string {
+	// TODO This can easily be made faster and produce less garbage.
+	if strings.HasPrefix(tag, longTagPrefix) {
+		return "!!" + tag[len(longTagPrefix):]
+	}
+	return tag
+}
+
+func longTag(tag string) string {
+	if strings.HasPrefix(tag, "!!") {
+		return longTagPrefix + tag[2:]
+	}
+	return tag
+}
+
+func resolvableTag(tag string) bool {
+	switch tag {
+	case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG:
+		return true
+	}
+	return false
+}
+
+var yamlStyleFloat = regexp.MustCompile(`^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)?$`)
+
+func resolve(tag string, in string) (rtag string, out interface{}) {
+	if !resolvableTag(tag) {
+		return tag, in
+	}
+
+	defer func() {
+		switch tag {
+		case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
+			return
+		}
+		failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
+	}()
+
+	// Any data is accepted as a !!str or !!binary.
+	// Otherwise, the prefix is enough of a hint about what it might be.
+	hint := byte('N')
+	if in != "" {
+		hint = resolveTable[in[0]]
+	}
+	if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
+		// Handle things we can lookup in a map.
+		if item, ok := resolveMap[in]; ok {
+			return item.tag, item.value
+		}
+
+		// Base 60 floats are a bad idea, were dropped in YAML 1.2, and
+		// are purposefully unsupported here. They're still quoted on
+		// the way out for compatibility with other parser, though.
+
+		switch hint {
+		case 'M':
+			// We've already checked the map above.
+
+		case '.':
+			// Not in the map, so maybe a normal float.
+			floatv, err := strconv.ParseFloat(in, 64)
+			if err == nil {
+				return yaml_FLOAT_TAG, floatv
+			}
+
+		case 'D', 'S':
+			// Int, float, or timestamp.
+			plain := strings.Replace(in, "_", "", -1)
+			intv, err := strconv.ParseInt(plain, 0, 64)
+			if err == nil {
+				if intv == int64(int(intv)) {
+					return yaml_INT_TAG, int(intv)
+				} else {
+					return yaml_INT_TAG, intv
+				}
+			}
+			uintv, err := strconv.ParseUint(plain, 0, 64)
+			if err == nil {
+				return yaml_INT_TAG, uintv
+			}
+			if yamlStyleFloat.MatchString(plain) {
+				floatv, err := strconv.ParseFloat(plain, 64)
+				if err == nil {
+					return yaml_FLOAT_TAG, floatv
+				}
+			}
+			if strings.HasPrefix(plain, "0b") {
+				intv, err := strconv.ParseInt(plain[2:], 2, 64)
+				if err == nil {
+					if intv == int64(int(intv)) {
+						return yaml_INT_TAG, int(intv)
+					} else {
+						return yaml_INT_TAG, intv
+					}
+				}
+				uintv, err := strconv.ParseUint(plain[2:], 2, 64)
+				if err == nil {
+					return yaml_INT_TAG, uintv
+				}
+			} else if strings.HasPrefix(plain, "-0b") {
+				intv, err := strconv.ParseInt(plain[3:], 2, 64)
+				if err == nil {
+					if intv == int64(int(intv)) {
+						return yaml_INT_TAG, -int(intv)
+					} else {
+						return yaml_INT_TAG, -intv
+					}
+				}
+			}
+			// XXX Handle timestamps here.
+
+		default:
+			panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
+		}
+	}
+	if tag == yaml_BINARY_TAG {
+		return yaml_BINARY_TAG, in
+	}
+	if utf8.ValidString(in) {
+		return yaml_STR_TAG, in
+	}
+	return yaml_BINARY_TAG, encodeBase64(in)
+}
+
+// encodeBase64 encodes s as base64 that is broken up into multiple lines
+// as appropriate for the resulting length.
+func encodeBase64(s string) string {
+	const lineLen = 70
+	encLen := base64.StdEncoding.EncodedLen(len(s))
+	lines := encLen/lineLen + 1
+	buf := make([]byte, encLen*2+lines)
+	in := buf[0:encLen]
+	out := buf[encLen:]
+	base64.StdEncoding.Encode(in, []byte(s))
+	k := 0
+	for i := 0; i < len(in); i += lineLen {
+		j := i + lineLen
+		if j > len(in) {
+			j = len(in)
+		}
+		k += copy(out[k:], in[i:j])
+		if lines > 1 {
+			out[k] = '\n'
+			k++
+		}
+	}
+	return string(out[:k])
+}

vendor/gopkg.in/yaml.v2/sorter.go

@@ -0,0 +1,104 @@
+package yaml
+
+import (
+	"reflect"
+	"unicode"
+)
+
+type keyList []reflect.Value
+
+func (l keyList) Len() int      { return len(l) }
+func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l keyList) Less(i, j int) bool {
+	a := l[i]
+	b := l[j]
+	ak := a.Kind()
+	bk := b.Kind()
+	for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
+		a = a.Elem()
+		ak = a.Kind()
+	}
+	for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
+		b = b.Elem()
+		bk = b.Kind()
+	}
+	af, aok := keyFloat(a)
+	bf, bok := keyFloat(b)
+	if aok && bok {
+		if af != bf {
+			return af < bf
+		}
+		if ak != bk {
+			return ak < bk
+		}
+		return numLess(a, b)
+	}
+	if ak != reflect.String || bk != reflect.String {
+		return ak < bk
+	}
+	ar, br := []rune(a.String()), []rune(b.String())
+	for i := 0; i < len(ar) && i < len(br); i++ {
+		if ar[i] == br[i] {
+			continue
+		}
+		al := unicode.IsLetter(ar[i])
+		bl := unicode.IsLetter(br[i])
+		if al && bl {
+			return ar[i] < br[i]
+		}
+		if al || bl {
+			return bl
+		}
+		var ai, bi int
+		var an, bn int64
+		for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
+			an = an*10 + int64(ar[ai]-'0')
+		}
+		for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
+			bn = bn*10 + int64(br[bi]-'0')
+		}
+		if an != bn {
+			return an < bn
+		}
+		if ai != bi {
+			return ai < bi
+		}
+		return ar[i] < br[i]
+	}
+	return len(ar) < len(br)
+}
+
+// keyFloat returns a float value for v if it is a number/bool
+// and whether it is a number/bool or not.
+func keyFloat(v reflect.Value) (f float64, ok bool) {
+	switch v.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return float64(v.Int()), true
+	case reflect.Float32, reflect.Float64:
+		return v.Float(), true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return float64(v.Uint()), true
+	case reflect.Bool:
+		if v.Bool() {
+			return 1, true
+		}
+		return 0, true
+	}
+	return 0, false
+}
+
+// numLess returns whether a < b.
+// a and b must necessarily have the same kind.
+func numLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return a.Int() < b.Int()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	}
+	panic("not a number")
+}

vendor/gopkg.in/yaml.v2/writerc.go

@@ -0,0 +1,89 @@
+package yaml
+
+// Set the writer error and return false.
+func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
+	emitter.error = yaml_WRITER_ERROR
+	emitter.problem = problem
+	return false
+}
+
+// Flush the output buffer.
+func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
+	if emitter.write_handler == nil {
+		panic("write handler not set")
+	}
+
+	// Check if the buffer is empty.
+	if emitter.buffer_pos == 0 {
+		return true
+	}
+
+	// If the output encoding is UTF-8, we don't need to recode the buffer.
+	if emitter.encoding == yaml_UTF8_ENCODING {
+		if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
+			return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+		}
+		emitter.buffer_pos = 0
+		return true
+	}
+
+	// Recode the buffer into the raw buffer.
+	var low, high int
+	if emitter.encoding == yaml_UTF16LE_ENCODING {
+		low, high = 0, 1
+	} else {
+		high, low = 1, 0
+	}
+
+	pos := 0
+	for pos < emitter.buffer_pos {
+		// See the "reader.c" code for more details on UTF-8 encoding.  Note
+		// that we assume that the buffer contains a valid UTF-8 sequence.
+
+		// Read the next UTF-8 character.
+		octet := emitter.buffer[pos]
+
+		var w int
+		var value rune
+		switch {
+		case octet&0x80 == 0x00:
+			w, value = 1, rune(octet&0x7F)
+		case octet&0xE0 == 0xC0:
+			w, value = 2, rune(octet&0x1F)
+		case octet&0xF0 == 0xE0:
+			w, value = 3, rune(octet&0x0F)
+		case octet&0xF8 == 0xF0:
+			w, value = 4, rune(octet&0x07)
+		}
+		for k := 1; k < w; k++ {
+			octet = emitter.buffer[pos+k]
+			value = (value << 6) + (rune(octet) & 0x3F)
+		}
+		pos += w
+
+		// Write the character.
+		if value < 0x10000 {
+			var b [2]byte
+			b[high] = byte(value >> 8)
+			b[low] = byte(value & 0xFF)
+			emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1])
+		} else {
+			// Write the character using a surrogate pair (check "reader.c").
+			var b [4]byte
+			value -= 0x10000
+			b[high] = byte(0xD8 + (value >> 18))
+			b[low] = byte((value >> 10) & 0xFF)
+			b[high+2] = byte(0xDC + ((value >> 8) & 0xFF))
+			b[low+2] = byte(value & 0xFF)
+			emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3])
+		}
+	}
+
+	// Write the raw buffer.
+	if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil {
+		return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+	}
+	emitter.buffer_pos = 0
+	emitter.raw_buffer = emitter.raw_buffer[:0]
+	return true
+}

vendor/gopkg.in/yaml.v2/yaml.go

@@ -0,0 +1,357 @@
+// Package yaml implements YAML support for the Go language.
+//
+// Source code and other details for the project are available at GitHub:
+//
+//   https://github.com/go-yaml/yaml
+//
+package yaml
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+)
+
+// MapSlice encodes and decodes as a YAML map.
+// The order of keys is preserved when encoding and decoding.
+type MapSlice []MapItem
+
+// MapItem is an item in a MapSlice.
+type MapItem struct {
+	Key, Value interface{}
+}
+
+// The Unmarshaler interface may be implemented by types to customize their
+// behavior when being unmarshaled from a YAML document. The UnmarshalYAML
+// method receives a function that may be called to unmarshal the original
+// YAML value into a field or variable. It is safe to call the unmarshal
+// function parameter more than once if necessary.
+type Unmarshaler interface {
+	UnmarshalYAML(unmarshal func(interface{}) error) error
+}
+
+// The Marshaler interface may be implemented by types to customize their
+// behavior when being marshaled into a YAML document. The returned value
+// is marshaled in place of the original value implementing Marshaler.
+//
+// If an error is returned by MarshalYAML, the marshaling procedure stops
+// and returns with the provided error.
+type Marshaler interface {
+	MarshalYAML() (interface{}, error)
+}
+
+// Unmarshal decodes the first document found within the in byte slice
+// and assigns decoded values into the out value.
+//
+// Maps and pointers (to a struct, string, int, etc) are accepted as out
+// values. If an internal pointer within a struct is not initialized,
+// the yaml package will initialize it if necessary for unmarshalling
+// the provided data. The out parameter must not be nil.
+//
+// The type of the decoded values should be compatible with the respective
+// values in out. If one or more values cannot be decoded due to a type
+// mismatches, decoding continues partially until the end of the YAML
+// content, and a *yaml.TypeError is returned with details for all
+// missed values.
+//
+// Struct fields are only unmarshalled if they are exported (have an
+// upper case first letter), and are unmarshalled using the field name
+// lowercased as the default key. Custom keys may be defined via the
+// "yaml" name in the field tag: the content preceding the first comma
+// is used as the key, and the following comma-separated options are
+// used to tweak the marshalling process (see Marshal).
+// Conflicting names result in a runtime error.
+//
+// For example:
+//
+//     type T struct {
+//         F int `yaml:"a,omitempty"`
+//         B int
+//     }
+//     var t T
+//     yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
+//
+// See the documentation of Marshal for the format of tags and a list of
+// supported tag options.
+//
+func Unmarshal(in []byte, out interface{}) (err error) {
+	return unmarshal(in, out, false)
+}
+
+// UnmarshalStrict is like Unmarshal except that any fields that are found
+// in the data that do not have corresponding struct members will result in
+// an error.
+func UnmarshalStrict(in []byte, out interface{}) (err error) {
+	return unmarshal(in, out, true)
+}
+
+func unmarshal(in []byte, out interface{}, strict bool) (err error) {
+	defer handleErr(&err)
+	d := newDecoder(strict)
+	p := newParser(in)
+	defer p.destroy()
+	node := p.parse()
+	if node != nil {
+		v := reflect.ValueOf(out)
+		if v.Kind() == reflect.Ptr && !v.IsNil() {
+			v = v.Elem()
+		}
+		d.unmarshal(node, v)
+	}
+	if len(d.terrors) > 0 {
+		return &TypeError{d.terrors}
+	}
+	return nil
+}
+
+// Marshal serializes the value provided into a YAML document. The structure
+// of the generated document will reflect the structure of the value itself.
+// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
+//
+// Struct fields are only unmarshalled if they are exported (have an upper case
+// first letter), and are unmarshalled using the field name lowercased as the
+// default key. Custom keys may be defined via the "yaml" name in the field
+// tag: the content preceding the first comma is used as the key, and the
+// following comma-separated options are used to tweak the marshalling process.
+// Conflicting names result in a runtime error.
+//
+// The field tag format accepted is:
+//
+//     `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
+//
+// The following flags are currently supported:
+//
+//     omitempty    Only include the field if it's not set to the zero
+//                  value for the type or to empty slices or maps.
+//                  Does not apply to zero valued structs.
+//
+//     flow         Marshal using a flow style (useful for structs,
+//                  sequences and maps).
+//
+//     inline       Inline the field, which must be a struct or a map,
+//                  causing all of its fields or keys to be processed as if
+//                  they were part of the outer struct. For maps, keys must
+//                  not conflict with the yaml keys of other struct fields.
+//
+// In addition, if the key is "-", the field is ignored.
+//
+// For example:
+//
+//     type T struct {
+//         F int `yaml:"a,omitempty"`
+//         B int
+//     }
+//     yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
+//     yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
+//
+func Marshal(in interface{}) (out []byte, err error) {
+	defer handleErr(&err)
+	e := newEncoder()
+	defer e.destroy()
+	e.marshal("", reflect.ValueOf(in))
+	e.finish()
+	out = e.out
+	return
+}
+
+func handleErr(err *error) {
+	if v := recover(); v != nil {
+		if e, ok := v.(yamlError); ok {
+			*err = e.err
+		} else {
+			panic(v)
+		}
+	}
+}
+
+type yamlError struct {
+	err error
+}
+
+func fail(err error) {
+	panic(yamlError{err})
+}
+
+func failf(format string, args ...interface{}) {
+	panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
+}
+
+// A TypeError is returned by Unmarshal when one or more fields in
+// the YAML document cannot be properly decoded into the requested
+// types. When this error is returned, the value is still
+// unmarshaled partially.
+type TypeError struct {
+	Errors []string
+}
+
+func (e *TypeError) Error() string {
+	return fmt.Sprintf("yaml: unmarshal errors:\n  %s", strings.Join(e.Errors, "\n  "))
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+// The code in this section was copied from mgo/bson.
+
+// structInfo holds details for the serialization of fields of
+// a given struct.
+type structInfo struct {
+	FieldsMap  map[string]fieldInfo
+	FieldsList []fieldInfo
+
+	// InlineMap is the number of the field in the struct that
+	// contains an ,inline map, or -1 if there's none.
+	InlineMap int
+}
+
+type fieldInfo struct {
+	Key       string
+	Num       int
+	OmitEmpty bool
+	Flow      bool
+
+	// Inline holds the field index if the field is part of an inlined struct.
+	Inline []int
+}
+
+var structMap = make(map[reflect.Type]*structInfo)
+var fieldMapMutex sync.RWMutex
+
+func getStructInfo(st reflect.Type) (*structInfo, error) {
+	fieldMapMutex.RLock()
+	sinfo, found := structMap[st]
+	fieldMapMutex.RUnlock()
+	if found {
+		return sinfo, nil
+	}
+
+	n := st.NumField()
+	fieldsMap := make(map[string]fieldInfo)
+	fieldsList := make([]fieldInfo, 0, n)
+	inlineMap := -1
+	for i := 0; i != n; i++ {
+		field := st.Field(i)
+		if field.PkgPath != "" && !field.Anonymous {
+			continue // Private field
+		}
+
+		info := fieldInfo{Num: i}
+
+		tag := field.Tag.Get("yaml")
+		if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
+			tag = string(field.Tag)
+		}
+		if tag == "-" {
+			continue
+		}
+
+		inline := false
+		fields := strings.Split(tag, ",")
+		if len(fields) > 1 {
+			for _, flag := range fields[1:] {
+				switch flag {
+				case "omitempty":
+					info.OmitEmpty = true
+				case "flow":
+					info.Flow = true
+				case "inline":
+					inline = true
+				default:
+					return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
+				}
+			}
+			tag = fields[0]
+		}
+
+		if inline {
+			switch field.Type.Kind() {
+			case reflect.Map:
+				if inlineMap >= 0 {
+					return nil, errors.New("Multiple ,inline maps in struct " + st.String())
+				}
+				if field.Type.Key() != reflect.TypeOf("") {
+					return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
+				}
+				inlineMap = info.Num
+			case reflect.Struct:
+				sinfo, err := getStructInfo(field.Type)
+				if err != nil {
+					return nil, err
+				}
+				for _, finfo := range sinfo.FieldsList {
+					if _, found := fieldsMap[finfo.Key]; found {
+						msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
+						return nil, errors.New(msg)
+					}
+					if finfo.Inline == nil {
+						finfo.Inline = []int{i, finfo.Num}
+					} else {
+						finfo.Inline = append([]int{i}, finfo.Inline...)
+					}
+					fieldsMap[finfo.Key] = finfo
+					fieldsList = append(fieldsList, finfo)
+				}
+			default:
+				//return nil, errors.New("Option ,inline needs a struct value or map field")
+				return nil, errors.New("Option ,inline needs a struct value field")
+			}
+			continue
+		}
+
+		if tag != "" {
+			info.Key = tag
+		} else {
+			info.Key = strings.ToLower(field.Name)
+		}
+
+		if _, found = fieldsMap[info.Key]; found {
+			msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
+			return nil, errors.New(msg)
+		}
+
+		fieldsList = append(fieldsList, info)
+		fieldsMap[info.Key] = info
+	}
+
+	sinfo = &structInfo{fieldsMap, fieldsList, inlineMap}
+
+	fieldMapMutex.Lock()
+	structMap[st] = sinfo
+	fieldMapMutex.Unlock()
+	return sinfo, nil
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.String:
+		return len(v.String()) == 0
+	case reflect.Interface, reflect.Ptr:
+		return v.IsNil()
+	case reflect.Slice:
+		return v.Len() == 0
+	case reflect.Map:
+		return v.Len() == 0
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Struct:
+		vt := v.Type()
+		for i := v.NumField() - 1; i >= 0; i-- {
+			if vt.Field(i).PkgPath != "" {
+				continue // Private field
+			}
+			if !isZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}

vendor/gopkg.in/yaml.v2/yamlh.go

@@ -0,0 +1,716 @@
+package yaml
+
+import (
+	"io"
+)
+
+// The version directive data.
+type yaml_version_directive_t struct {
+	major int8 // The major version number.
+	minor int8 // The minor version number.
+}
+
+// The tag directive data.
+type yaml_tag_directive_t struct {
+	handle []byte // The tag handle.
+	prefix []byte // The tag prefix.
+}
+
+type yaml_encoding_t int
+
+// The stream encoding.
+const (
+	// Let the parser choose the encoding.
+	yaml_ANY_ENCODING yaml_encoding_t = iota
+
+	yaml_UTF8_ENCODING    // The default UTF-8 encoding.
+	yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM.
+	yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM.
+)
+
+type yaml_break_t int
+
+// Line break types.
+const (
+	// Let the parser choose the break type.
+	yaml_ANY_BREAK yaml_break_t = iota
+
+	yaml_CR_BREAK   // Use CR for line breaks (Mac style).
+	yaml_LN_BREAK   // Use LN for line breaks (Unix style).
+	yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style).
+)
+
+type yaml_error_type_t int
+
+// Many bad things could happen with the parser and emitter.
+const (
+	// No error is produced.
+	yaml_NO_ERROR yaml_error_type_t = iota
+
+	yaml_MEMORY_ERROR   // Cannot allocate or reallocate a block of memory.
+	yaml_READER_ERROR   // Cannot read or decode the input stream.
+	yaml_SCANNER_ERROR  // Cannot scan the input stream.
+	yaml_PARSER_ERROR   // Cannot parse the input stream.
+	yaml_COMPOSER_ERROR // Cannot compose a YAML document.
+	yaml_WRITER_ERROR   // Cannot write to the output stream.
+	yaml_EMITTER_ERROR  // Cannot emit a YAML stream.
+)
+
+// The pointer position.
+type yaml_mark_t struct {
+	index  int // The position index.
+	line   int // The position line.
+	column int // The position column.
+}
+
+// Node Styles
+
+type yaml_style_t int8
+
+type yaml_scalar_style_t yaml_style_t
+
+// Scalar styles.
+const (
+	// Let the emitter choose the style.
+	yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota
+
+	yaml_PLAIN_SCALAR_STYLE         // The plain scalar style.
+	yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
+	yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
+	yaml_LITERAL_SCALAR_STYLE       // The literal scalar style.
+	yaml_FOLDED_SCALAR_STYLE        // The folded scalar style.
+)
+
+type yaml_sequence_style_t yaml_style_t
+
+// Sequence styles.
+const (
+	// Let the emitter choose the style.
+	yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota
+
+	yaml_BLOCK_SEQUENCE_STYLE // The block sequence style.
+	yaml_FLOW_SEQUENCE_STYLE  // The flow sequence style.
+)
+
+type yaml_mapping_style_t yaml_style_t
+
+// Mapping styles.
+const (
+	// Let the emitter choose the style.
+	yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota
+
+	yaml_BLOCK_MAPPING_STYLE // The block mapping style.
+	yaml_FLOW_MAPPING_STYLE  // The flow mapping style.
+)
+
+// Tokens
+
+type yaml_token_type_t int
+
+// Token types.
+const (
+	// An empty token.
+	yaml_NO_TOKEN yaml_token_type_t = iota
+
+	yaml_STREAM_START_TOKEN // A STREAM-START token.
+	yaml_STREAM_END_TOKEN   // A STREAM-END token.
+
+	yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token.
+	yaml_TAG_DIRECTIVE_TOKEN     // A TAG-DIRECTIVE token.
+	yaml_DOCUMENT_START_TOKEN    // A DOCUMENT-START token.
+	yaml_DOCUMENT_END_TOKEN      // A DOCUMENT-END token.
+
+	yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token.
+	yaml_BLOCK_MAPPING_START_TOKEN  // A BLOCK-SEQUENCE-END token.
+	yaml_BLOCK_END_TOKEN            // A BLOCK-END token.
+
+	yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token.
+	yaml_FLOW_SEQUENCE_END_TOKEN   // A FLOW-SEQUENCE-END token.
+	yaml_FLOW_MAPPING_START_TOKEN  // A FLOW-MAPPING-START token.
+	yaml_FLOW_MAPPING_END_TOKEN    // A FLOW-MAPPING-END token.
+
+	yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token.
+	yaml_FLOW_ENTRY_TOKEN  // A FLOW-ENTRY token.
+	yaml_KEY_TOKEN         // A KEY token.
+	yaml_VALUE_TOKEN       // A VALUE token.
+
+	yaml_ALIAS_TOKEN  // An ALIAS token.
+	yaml_ANCHOR_TOKEN // An ANCHOR token.
+	yaml_TAG_TOKEN    // A TAG token.
+	yaml_SCALAR_TOKEN // A SCALAR token.
+)
+
+func (tt yaml_token_type_t) String() string {
+	switch tt {
+	case yaml_NO_TOKEN:
+		return "yaml_NO_TOKEN"
+	case yaml_STREAM_START_TOKEN:
+		return "yaml_STREAM_START_TOKEN"
+	case yaml_STREAM_END_TOKEN:
+		return "yaml_STREAM_END_TOKEN"
+	case yaml_VERSION_DIRECTIVE_TOKEN:
+		return "yaml_VERSION_DIRECTIVE_TOKEN"
+	case yaml_TAG_DIRECTIVE_TOKEN:
+		return "yaml_TAG_DIRECTIVE_TOKEN"
+	case yaml_DOCUMENT_START_TOKEN:
+		return "yaml_DOCUMENT_START_TOKEN"
+	case yaml_DOCUMENT_END_TOKEN:
+		return "yaml_DOCUMENT_END_TOKEN"
+	case yaml_BLOCK_SEQUENCE_START_TOKEN:
+		return "yaml_BLOCK_SEQUENCE_START_TOKEN"
+	case yaml_BLOCK_MAPPING_START_TOKEN:
+		return "yaml_BLOCK_MAPPING_START_TOKEN"
+	case yaml_BLOCK_END_TOKEN:
+		return "yaml_BLOCK_END_TOKEN"
+	case yaml_FLOW_SEQUENCE_START_TOKEN:
+		return "yaml_FLOW_SEQUENCE_START_TOKEN"
+	case yaml_FLOW_SEQUENCE_END_TOKEN:
+		return "yaml_FLOW_SEQUENCE_END_TOKEN"
+	case yaml_FLOW_MAPPING_START_TOKEN:
+		return "yaml_FLOW_MAPPING_START_TOKEN"
+	case yaml_FLOW_MAPPING_END_TOKEN:
+		return "yaml_FLOW_MAPPING_END_TOKEN"
+	case yaml_BLOCK_ENTRY_TOKEN:
+		return "yaml_BLOCK_ENTRY_TOKEN"
+	case yaml_FLOW_ENTRY_TOKEN:
+		return "yaml_FLOW_ENTRY_TOKEN"
+	case yaml_KEY_TOKEN:
+		return "yaml_KEY_TOKEN"
+	case yaml_VALUE_TOKEN:
+		return "yaml_VALUE_TOKEN"
+	case yaml_ALIAS_TOKEN:
+		return "yaml_ALIAS_TOKEN"
+	case yaml_ANCHOR_TOKEN:
+		return "yaml_ANCHOR_TOKEN"
+	case yaml_TAG_TOKEN:
+		return "yaml_TAG_TOKEN"
+	case yaml_SCALAR_TOKEN:
+		return "yaml_SCALAR_TOKEN"
+	}
+	return "<unknown token>"
+}
+
+// The token structure.
+type yaml_token_t struct {
+	// The token type.
+	typ yaml_token_type_t
+
+	// The start/end of the token.
+	start_mark, end_mark yaml_mark_t
+
+	// The stream encoding (for yaml_STREAM_START_TOKEN).
+	encoding yaml_encoding_t
+
+	// The alias/anchor/scalar value or tag/tag directive handle
+	// (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN).
+	value []byte
+
+	// The tag suffix (for yaml_TAG_TOKEN).
+	suffix []byte
+
+	// The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN).
+	prefix []byte
+
+	// The scalar style (for yaml_SCALAR_TOKEN).
+	style yaml_scalar_style_t
+
+	// The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN).
+	major, minor int8
+}
+
+// Events
+
+type yaml_event_type_t int8
+
+// Event types.
+const (
+	// An empty event.
+	yaml_NO_EVENT yaml_event_type_t = iota
+
+	yaml_STREAM_START_EVENT   // A STREAM-START event.
+	yaml_STREAM_END_EVENT     // A STREAM-END event.
+	yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event.
+	yaml_DOCUMENT_END_EVENT   // A DOCUMENT-END event.
+	yaml_ALIAS_EVENT          // An ALIAS event.
+	yaml_SCALAR_EVENT         // A SCALAR event.
+	yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event.
+	yaml_SEQUENCE_END_EVENT   // A SEQUENCE-END event.
+	yaml_MAPPING_START_EVENT  // A MAPPING-START event.
+	yaml_MAPPING_END_EVENT    // A MAPPING-END event.
+)
+
+// The event structure.
+type yaml_event_t struct {
+
+	// The event type.
+	typ yaml_event_type_t
+
+	// The start and end of the event.
+	start_mark, end_mark yaml_mark_t
+
+	// The document encoding (for yaml_STREAM_START_EVENT).
+	encoding yaml_encoding_t
+
+	// The version directive (for yaml_DOCUMENT_START_EVENT).
+	version_directive *yaml_version_directive_t
+
+	// The list of tag directives (for yaml_DOCUMENT_START_EVENT).
+	tag_directives []yaml_tag_directive_t
+
+	// The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
+	anchor []byte
+
+	// The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+	tag []byte
+
+	// The scalar value (for yaml_SCALAR_EVENT).
+	value []byte
+
+	// Is the document start/end indicator implicit, or the tag optional?
+	// (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT).
+	implicit bool
+
+	// Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT).
+	quoted_implicit bool
+
+	// The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+	style yaml_style_t
+}
+
+func (e *yaml_event_t) scalar_style() yaml_scalar_style_t     { return yaml_scalar_style_t(e.style) }
+func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) }
+func (e *yaml_event_t) mapping_style() yaml_mapping_style_t   { return yaml_mapping_style_t(e.style) }
+
+// Nodes
+
+const (
+	yaml_NULL_TAG      = "tag:yaml.org,2002:null"      // The tag !!null with the only possible value: null.
+	yaml_BOOL_TAG      = "tag:yaml.org,2002:bool"      // The tag !!bool with the values: true and false.
+	yaml_STR_TAG       = "tag:yaml.org,2002:str"       // The tag !!str for string values.
+	yaml_INT_TAG       = "tag:yaml.org,2002:int"       // The tag !!int for integer values.
+	yaml_FLOAT_TAG     = "tag:yaml.org,2002:float"     // The tag !!float for float values.
+	yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values.
+
+	yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
+	yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
+
+	// Not in original libyaml.
+	yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
+	yaml_MERGE_TAG  = "tag:yaml.org,2002:merge"
+
+	yaml_DEFAULT_SCALAR_TAG   = yaml_STR_TAG // The default scalar tag is !!str.
+	yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
+	yaml_DEFAULT_MAPPING_TAG  = yaml_MAP_TAG // The default mapping tag is !!map.
+)
+
+type yaml_node_type_t int
+
+// Node types.
+const (
+	// An empty node.
+	yaml_NO_NODE yaml_node_type_t = iota
+
+	yaml_SCALAR_NODE   // A scalar node.
+	yaml_SEQUENCE_NODE // A sequence node.
+	yaml_MAPPING_NODE  // A mapping node.
+)
+
+// An element of a sequence node.
+type yaml_node_item_t int
+
+// An element of a mapping node.
+type yaml_node_pair_t struct {
+	key   int // The key of the element.
+	value int // The value of the element.
+}
+
+// The node structure.
+type yaml_node_t struct {
+	typ yaml_node_type_t // The node type.
+	tag []byte           // The node tag.
+
+	// The node data.
+
+	// The scalar parameters (for yaml_SCALAR_NODE).
+	scalar struct {
+		value  []byte              // The scalar value.
+		length int                 // The length of the scalar value.
+		style  yaml_scalar_style_t // The scalar style.
+	}
+
+	// The sequence parameters (for YAML_SEQUENCE_NODE).
+	sequence struct {
+		items_data []yaml_node_item_t    // The stack of sequence items.
+		style      yaml_sequence_style_t // The sequence style.
+	}
+
+	// The mapping parameters (for yaml_MAPPING_NODE).
+	mapping struct {
+		pairs_data  []yaml_node_pair_t   // The stack of mapping pairs (key, value).
+		pairs_start *yaml_node_pair_t    // The beginning of the stack.
+		pairs_end   *yaml_node_pair_t    // The end of the stack.
+		pairs_top   *yaml_node_pair_t    // The top of the stack.
+		style       yaml_mapping_style_t // The mapping style.
+	}
+
+	start_mark yaml_mark_t // The beginning of the node.
+	end_mark   yaml_mark_t // The end of the node.
+
+}
+
+// The document structure.
+type yaml_document_t struct {
+
+	// The document nodes.
+	nodes []yaml_node_t
+
+	// The version directive.
+	version_directive *yaml_version_directive_t
+
+	// The list of tag directives.
+	tag_directives_data  []yaml_tag_directive_t
+	tag_directives_start int // The beginning of the tag directives list.
+	tag_directives_end   int // The end of the tag directives list.
+
+	start_implicit int // Is the document start indicator implicit?
+	end_implicit   int // Is the document end indicator implicit?
+
+	// The start/end of the document.
+	start_mark, end_mark yaml_mark_t
+}
+
+// The prototype of a read handler.
+//
+// The read handler is called when the parser needs to read more bytes from the
+// source. The handler should write not more than size bytes to the buffer.
+// The number of written bytes should be set to the size_read variable.
+//
+// [in,out]   data        A pointer to an application data specified by
+//                        yaml_parser_set_input().
+// [out]      buffer      The buffer to write the data from the source.
+// [in]       size        The size of the buffer.
+// [out]      size_read   The actual number of bytes read from the source.
+//
+// On success, the handler should return 1.  If the handler failed,
+// the returned value should be 0. On EOF, the handler should set the
+// size_read to 0 and return 1.
+type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
+
+// This structure holds information about a potential simple key.
+type yaml_simple_key_t struct {
+	possible     bool        // Is a simple key possible?
+	required     bool        // Is a simple key required?
+	token_number int         // The number of the token.
+	mark         yaml_mark_t // The position mark.
+}
+
+// The states of the parser.
+type yaml_parser_state_t int
+
+const (
+	yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota
+
+	yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE           // Expect the beginning of an implicit document.
+	yaml_PARSE_DOCUMENT_START_STATE                    // Expect DOCUMENT-START.
+	yaml_PARSE_DOCUMENT_CONTENT_STATE                  // Expect the content of a document.
+	yaml_PARSE_DOCUMENT_END_STATE                      // Expect DOCUMENT-END.
+	yaml_PARSE_BLOCK_NODE_STATE                        // Expect a block node.
+	yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence.
+	yaml_PARSE_FLOW_NODE_STATE                         // Expect a flow node.
+	yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE        // Expect the first entry of a block sequence.
+	yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE              // Expect an entry of a block sequence.
+	yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE         // Expect an entry of an indentless sequence.
+	yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE           // Expect the first key of a block mapping.
+	yaml_PARSE_BLOCK_MAPPING_KEY_STATE                 // Expect a block mapping key.
+	yaml_PARSE_BLOCK_MAPPING_VALUE_STATE               // Expect a block mapping value.
+	yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE         // Expect the first entry of a flow sequence.
+	yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE               // Expect an entry of a flow sequence.
+	yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE   // Expect a key of an ordered mapping.
+	yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping.
+	yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE   // Expect the and of an ordered mapping entry.
+	yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE            // Expect the first key of a flow mapping.
+	yaml_PARSE_FLOW_MAPPING_KEY_STATE                  // Expect a key of a flow mapping.
+	yaml_PARSE_FLOW_MAPPING_VALUE_STATE                // Expect a value of a flow mapping.
+	yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE          // Expect an empty value of a flow mapping.
+	yaml_PARSE_END_STATE                               // Expect nothing.
+)
+
+func (ps yaml_parser_state_t) String() string {
+	switch ps {
+	case yaml_PARSE_STREAM_START_STATE:
+		return "yaml_PARSE_STREAM_START_STATE"
+	case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+		return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE"
+	case yaml_PARSE_DOCUMENT_START_STATE:
+		return "yaml_PARSE_DOCUMENT_START_STATE"
+	case yaml_PARSE_DOCUMENT_CONTENT_STATE:
+		return "yaml_PARSE_DOCUMENT_CONTENT_STATE"
+	case yaml_PARSE_DOCUMENT_END_STATE:
+		return "yaml_PARSE_DOCUMENT_END_STATE"
+	case yaml_PARSE_BLOCK_NODE_STATE:
+		return "yaml_PARSE_BLOCK_NODE_STATE"
+	case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+		return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE"
+	case yaml_PARSE_FLOW_NODE_STATE:
+		return "yaml_PARSE_FLOW_NODE_STATE"
+	case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+		return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE"
+	case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+		return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE"
+	case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+		return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE"
+	case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+		return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE"
+	case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
+		return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE"
+	case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
+		return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE"
+	case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+		return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE"
+	case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+		return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE"
+	case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+		return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE"
+	case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+		return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE"
+	case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+		return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE"
+	case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+		return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE"
+	case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
+		return "yaml_PARSE_FLOW_MAPPING_KEY_STATE"
+	case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
+		return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE"
+	case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+		return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE"
+	case yaml_PARSE_END_STATE:
+		return "yaml_PARSE_END_STATE"
+	}
+	return "<unknown parser state>"
+}
+
+// This structure holds aliases data.
+type yaml_alias_data_t struct {
+	anchor []byte      // The anchor.
+	index  int         // The node id.
+	mark   yaml_mark_t // The anchor mark.
+}
+
+// The parser structure.
+//
+// All members are internal. Manage the structure using the
+// yaml_parser_ family of functions.
+type yaml_parser_t struct {
+
+	// Error handling
+
+	error yaml_error_type_t // Error type.
+
+	problem string // Error description.
+
+	// The byte about which the problem occurred.
+	problem_offset int
+	problem_value  int
+	problem_mark   yaml_mark_t
+
+	// The error context.
+	context      string
+	context_mark yaml_mark_t
+
+	// Reader stuff
+
+	read_handler yaml_read_handler_t // Read handler.
+
+	input_file io.Reader // File input data.
+	input      []byte    // String input data.
+	input_pos  int
+
+	eof bool // EOF flag
+
+	buffer     []byte // The working buffer.
+	buffer_pos int    // The current position of the buffer.
+
+	unread int // The number of unread characters in the buffer.
+
+	raw_buffer     []byte // The raw buffer.
+	raw_buffer_pos int    // The current position of the buffer.
+
+	encoding yaml_encoding_t // The input encoding.
+
+	offset int         // The offset of the current position (in bytes).
+	mark   yaml_mark_t // The mark of the current position.
+
+	// Scanner stuff
+
+	stream_start_produced bool // Have we started to scan the input stream?
+	stream_end_produced   bool // Have we reached the end of the input stream?
+
+	flow_level int // The number of unclosed '[' and '{' indicators.
+
+	tokens          []yaml_token_t // The tokens queue.
+	tokens_head     int            // The head of the tokens queue.
+	tokens_parsed   int            // The number of tokens fetched from the queue.
+	token_available bool           // Does the tokens queue contain a token ready for dequeueing.
+
+	indent  int   // The current indentation level.
+	indents []int // The indentation levels stack.
+
+	simple_key_allowed bool                // May a simple key occur at the current position?
+	simple_keys        []yaml_simple_key_t // The stack of simple keys.
+
+	// Parser stuff
+
+	state          yaml_parser_state_t    // The current parser state.
+	states         []yaml_parser_state_t  // The parser states stack.
+	marks          []yaml_mark_t          // The stack of marks.
+	tag_directives []yaml_tag_directive_t // The list of TAG directives.
+
+	// Dumper stuff
+
+	aliases []yaml_alias_data_t // The alias data.
+
+	document *yaml_document_t // The currently parsed document.
+}
+
+// Emitter Definitions
+
+// The prototype of a write handler.
+//
+// The write handler is called when the emitter needs to flush the accumulated
+// characters to the output.  The handler should write @a size bytes of the
+// @a buffer to the output.
+//
+// @param[in,out]   data        A pointer to an application data specified by
+//                              yaml_emitter_set_output().
+// @param[in]       buffer      The buffer with bytes to be written.
+// @param[in]       size        The size of the buffer.
+//
+// @returns On success, the handler should return @c 1.  If the handler failed,
+// the returned value should be @c 0.
+//
+type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
+
+type yaml_emitter_state_t int
+
+// The emitter states.
+const (
+	// Expect STREAM-START.
+	yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota
+
+	yaml_EMIT_FIRST_DOCUMENT_START_STATE       // Expect the first DOCUMENT-START or STREAM-END.
+	yaml_EMIT_DOCUMENT_START_STATE             // Expect DOCUMENT-START or STREAM-END.
+	yaml_EMIT_DOCUMENT_CONTENT_STATE           // Expect the content of a document.
+	yaml_EMIT_DOCUMENT_END_STATE               // Expect DOCUMENT-END.
+	yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE   // Expect the first item of a flow sequence.
+	yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE         // Expect an item of a flow sequence.
+	yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE     // Expect the first key of a flow mapping.
+	yaml_EMIT_FLOW_MAPPING_KEY_STATE           // Expect a key of a flow mapping.
+	yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE  // Expect a value for a simple key of a flow mapping.
+	yaml_EMIT_FLOW_MAPPING_VALUE_STATE         // Expect a value of a flow mapping.
+	yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE  // Expect the first item of a block sequence.
+	yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE        // Expect an item of a block sequence.
+	yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE    // Expect the first key of a block mapping.
+	yaml_EMIT_BLOCK_MAPPING_KEY_STATE          // Expect the key of a block mapping.
+	yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping.
+	yaml_EMIT_BLOCK_MAPPING_VALUE_STATE        // Expect a value of a block mapping.
+	yaml_EMIT_END_STATE                        // Expect nothing.
+)
+
+// The emitter structure.
+//
+// All members are internal.  Manage the structure using the @c yaml_emitter_
+// family of functions.
+type yaml_emitter_t struct {
+
+	// Error handling
+
+	error   yaml_error_type_t // Error type.
+	problem string            // Error description.
+
+	// Writer stuff
+
+	write_handler yaml_write_handler_t // Write handler.
+
+	output_buffer *[]byte   // String output data.
+	output_file   io.Writer // File output data.
+
+	buffer     []byte // The working buffer.
+	buffer_pos int    // The current position of the buffer.
+
+	raw_buffer     []byte // The raw buffer.
+	raw_buffer_pos int    // The current position of the buffer.
+
+	encoding yaml_encoding_t // The stream encoding.
+
+	// Emitter stuff
+
+	canonical   bool         // If the output is in the canonical style?
+	best_indent int          // The number of indentation spaces.
+	best_width  int          // The preferred width of the output lines.
+	unicode     bool         // Allow unescaped non-ASCII characters?
+	line_break  yaml_break_t // The preferred line break.
+
+	state  yaml_emitter_state_t   // The current emitter state.
+	states []yaml_emitter_state_t // The stack of states.
+
+	events      []yaml_event_t // The event queue.
+	events_head int            // The head of the event queue.
+
+	indents []int // The stack of indentation levels.
+
+	tag_directives []yaml_tag_directive_t // The list of tag directives.
+
+	indent int // The current indentation level.
+
+	flow_level int // The current flow level.
+
+	root_context       bool // Is it the document root context?
+	sequence_context   bool // Is it a sequence context?
+	mapping_context    bool // Is it a mapping context?
+	simple_key_context bool // Is it a simple mapping key context?
+
+	line       int  // The current line.
+	column     int  // The current column.
+	whitespace bool // If the last character was a whitespace?
+	indention  bool // If the last character was an indentation character (' ', '-', '?', ':')?
+	open_ended bool // If an explicit document end is required?
+
+	// Anchor analysis.
+	anchor_data struct {
+		anchor []byte // The anchor value.
+		alias  bool   // Is it an alias?
+	}
+
+	// Tag analysis.
+	tag_data struct {
+		handle []byte // The tag handle.
+		suffix []byte // The tag suffix.
+	}
+
+	// Scalar analysis.
+	scalar_data struct {
+		value                 []byte              // The scalar value.
+		multiline             bool                // Does the scalar contain line breaks?
+		flow_plain_allowed    bool                // Can the scalar be expessed in the flow plain style?
+		block_plain_allowed   bool                // Can the scalar be expressed in the block plain style?
+		single_quoted_allowed bool                // Can the scalar be expressed in the single quoted style?
+		block_allowed         bool                // Can the scalar be expressed in the literal or folded styles?
+		style                 yaml_scalar_style_t // The output style.
+	}
+
+	// Dumper stuff
+
+	opened bool // If the stream was already opened?
+	closed bool // If the stream was already closed?
+
+	// The information associated with the document nodes.
+	anchors *struct {
+		references int  // The number of references.
+		anchor     int  // The anchor id.
+		serialized bool // If the node has been emitted?
+	}
+
+	last_anchor_id int // The last assigned anchor id.
+
+	document *yaml_document_t // The currently emitted document.
+}

vendor/gopkg.in/yaml.v2/yamlprivateh.go

@@ -0,0 +1,173 @@
+package yaml
+
+const (
+	// The size of the input raw buffer.
+	input_raw_buffer_size = 512
+
+	// The size of the input buffer.
+	// It should be possible to decode the whole raw buffer.
+	input_buffer_size = input_raw_buffer_size * 3
+
+	// The size of the output buffer.
+	output_buffer_size = 128
+
+	// The size of the output raw buffer.
+	// It should be possible to encode the whole output buffer.
+	output_raw_buffer_size = (output_buffer_size*2 + 2)
+
+	// The size of other stacks and queues.
+	initial_stack_size  = 16
+	initial_queue_size  = 16
+	initial_string_size = 16
+)
+
+// Check if the character at the specified position is an alphabetical
+// character, a digit, '_', or '-'.
+func is_alpha(b []byte, i int) bool {
+	return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
+}
+
+// Check if the character at the specified position is a digit.
+func is_digit(b []byte, i int) bool {
+	return b[i] >= '0' && b[i] <= '9'
+}
+
+// Get the value of a digit.
+func as_digit(b []byte, i int) int {
+	return int(b[i]) - '0'
+}
+
+// Check if the character at the specified position is a hex-digit.
+func is_hex(b []byte, i int) bool {
+	return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
+}
+
+// Get the value of a hex-digit.
+func as_hex(b []byte, i int) int {
+	bi := b[i]
+	if bi >= 'A' && bi <= 'F' {
+		return int(bi) - 'A' + 10
+	}
+	if bi >= 'a' && bi <= 'f' {
+		return int(bi) - 'a' + 10
+	}
+	return int(bi) - '0'
+}
+
+// Check if the character is ASCII.
+func is_ascii(b []byte, i int) bool {
+	return b[i] <= 0x7F
+}
+
+// Check if the character at the start of the buffer can be printed unescaped.
+func is_printable(b []byte, i int) bool {
+	return ((b[i] == 0x0A) || // . == #x0A
+		(b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
+		(b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
+		(b[i] > 0xC2 && b[i] < 0xED) ||
+		(b[i] == 0xED && b[i+1] < 0xA0) ||
+		(b[i] == 0xEE) ||
+		(b[i] == 0xEF && // #xE000 <= . <= #xFFFD
+			!(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
+			!(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
+}
+
+// Check if the character at the specified position is NUL.
+func is_z(b []byte, i int) bool {
+	return b[i] == 0x00
+}
+
+// Check if the beginning of the buffer is a BOM.
+func is_bom(b []byte, i int) bool {
+	return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
+}
+
+// Check if the character at the specified position is space.
+func is_space(b []byte, i int) bool {
+	return b[i] == ' '
+}
+
+// Check if the character at the specified position is tab.
+func is_tab(b []byte, i int) bool {
+	return b[i] == '\t'
+}
+
+// Check if the character at the specified position is blank (space or tab).
+func is_blank(b []byte, i int) bool {
+	//return is_space(b, i) || is_tab(b, i)
+	return b[i] == ' ' || b[i] == '\t'
+}
+
+// Check if the character at the specified position is a line break.
+func is_break(b []byte, i int) bool {
+	return (b[i] == '\r' || // CR (#xD)
+		b[i] == '\n' || // LF (#xA)
+		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
+}
+
+func is_crlf(b []byte, i int) bool {
+	return b[i] == '\r' && b[i+1] == '\n'
+}
+
+// Check if the character is a line break or NUL.
+func is_breakz(b []byte, i int) bool {
+	//return is_break(b, i) || is_z(b, i)
+	return (        // is_break:
+	b[i] == '\r' || // CR (#xD)
+		b[i] == '\n' || // LF (#xA)
+		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+		// is_z:
+		b[i] == 0)
+}
+
+// Check if the character is a line break, space, or NUL.
+func is_spacez(b []byte, i int) bool {
+	//return is_space(b, i) || is_breakz(b, i)
+	return ( // is_space:
+	b[i] == ' ' ||
+		// is_breakz:
+		b[i] == '\r' || // CR (#xD)
+		b[i] == '\n' || // LF (#xA)
+		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+		b[i] == 0)
+}
+
+// Check if the character is a line break, space, tab, or NUL.
+func is_blankz(b []byte, i int) bool {
+	//return is_blank(b, i) || is_breakz(b, i)
+	return ( // is_blank:
+	b[i] == ' ' || b[i] == '\t' ||
+		// is_breakz:
+		b[i] == '\r' || // CR (#xD)
+		b[i] == '\n' || // LF (#xA)
+		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+		b[i] == 0)
+}
+
+// Determine the width of the character.
+func width(b byte) int {
+	// Don't replace these by a switch without first
+	// confirming that it is being inlined.
+	if b&0x80 == 0x00 {
+		return 1
+	}
+	if b&0xE0 == 0xC0 {
+		return 2
+	}
+	if b&0xF0 == 0xE0 {
+		return 3
+	}
+	if b&0xF8 == 0xF0 {
+		return 4
+	}
+	return 0
+
+}

vendor/vendor.json

@@ -798,6 +798,12 @@
 			"path": "gopkg.in/sourcemap.v1/base64vlq",
 			"revision": "8cd1e2e0ddc78dcb4511bcb184d23171bed15c67",
 			"revisionTime": "2016-05-31T08:25:40Z"
+		},
+		{
+			"checksumSHA1": "qOmvuDm+F+2nQQecUZBVkZrTn6Y=",
+			"path": "gopkg.in/yaml.v2",
+			"revision": "d670f9405373e636a5a2765eea47fac0c9bc91a4",
+			"revisionTime": "2018-01-09T11:43:31Z"
 		}
 	],
 	"rootPath": "github.com/StackExchange/dnscontrol"