No OneTemporary
Actions

Size

857 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/.gitignore b/.gitignore
	index cdb5036..ca6cfcb 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,6 +1,7 @@
	*.swp
	*~

	build
	.ninja_*
	build.ninja
	+data/writeas
	diff --git a/.gitmodules b/.gitmodules
	new file mode 100644
	index 0000000..62f5059
	--- /dev/null
	+++ b/.gitmodules
	@@ -0,0 +1,7 @@
	+[submodule "src/github.com/writeas/writeas-cli"]
	+ path = src/github.com/writeas/writeas-cli
	+ url = https://github.com/writeas/writeas-cli.git
	+[submodule "fonts/lora"]
	+ path = fonts/lora
	+ url = https://code.as/writeas/fonts-lora.git
	+ branch = include
	diff --git a/build-cli.sh b/build-cli.sh
	new file mode 100755
	index 0000000..62664e8
	--- /dev/null
	+++ b/build-cli.sh
	@@ -0,0 +1,7 @@
	+#!/bin/bash
	+
	+exec_name=writeas
	+
	+echo "Building $exec_name CLI..."
	+gb build github.com/writeas/writeas-cli/cmd/writeas
	+echo "Success."
	diff --git a/data/icons/writeas-bright-dark.png b/data/icons/writeas-bright-dark.png
	deleted file mode 100644
	index 003cadb..0000000
	Binary files a/data/icons/writeas-bright-dark.png and /dev/null differ
	diff --git a/data/icons/writeas-bright-dark@2x.png b/data/icons/writeas-bright-dark@2x.png
	deleted file mode 100644
	index c24dfbf..0000000
	Binary files a/data/icons/writeas-bright-dark@2x.png and /dev/null differ
	diff --git a/data/meson.build b/data/meson.build
	index f1e8188..1c92abd 100644
	--- a/data/meson.build
	+++ b/data/meson.build
	@@ -1,18 +1,14 @@
	icon_sizes = ['16', '24', '32', '48', '64', '128']

	foreach i : icon_sizes
	install_data(
	join_paths('icons', i, meson.project_name() + '.png'),
	install_dir: join_paths(get_option('datadir'), 'icons', 'hicolor', i + 'x' + i, 'apps'
	)
	)
	endforeach

	-install_data('icons/writeas-bright-dark.png',
	- install_dir: join_paths(get_option('datadir'), 'icons', 'hicolor', '16x16', 'actions'))
	-
	install_data('com.github.writeas.writeas-gtk.desktop',
	install_dir: join_paths(get_option('datadir'), 'applications'))
	install_data('com.github.writeas.writeas-gtk.appdata.xml',
	install_dir: join_paths(get_option('datadir'), 'metainfo'))
	-install_data('writeas', install_dir: get_option('bindir'))
	diff --git a/data/writeas b/data/writeas
	deleted file mode 100755
	index 63b1cd5..0000000
	Binary files a/data/writeas and /dev/null differ
	diff --git a/debian/control b/debian/control
	index 6c37d07..a849fba 100644
	--- a/debian/control
	+++ b/debian/control
	@@ -1,16 +1,18 @@
	Source: com.github.writeas.writeas-gtk
	Section: x11
	Priority: extra
	Maintainer: Write.as <hello@write.as>
	Build-Depends: meson,
	debhelper (>= 9),
	libgtk-3-dev,
	libgtksourceview-3.0-dev,
	- valac (>= 0.36)
	+ valac (>= 0.36),
	+ golang-go,
	+ gb
	Standards-Version: 3.9.3

	Package: com.github.writeas.writeas-gtk
	Architecture: any
	-Depends: ${misc:Depends}, ${shlibs:Depends}, writeas-cli
	-Recommends: fonts-lora, fonts-open-sans, fonts-hack
	+Depends: ${misc:Depends}, ${shlibs:Depends}
	+Recommends: fonts-open-sans, fonts-hack-ttf
	Description: A distraction free and private writing tool, with built-in publishing.
	diff --git a/debian/rules b/debian/rules
	index 8847451..022735d 100755
	--- a/debian/rules
	+++ b/debian/rules
	@@ -1,31 +1,33 @@
	#!/usr/bin/make -f
	# -- makefile --
	# Sample debian/rules that uses debhelper.
	# This file was originally written by Joey Hess and Craig Small.
	# As a special exception, when this file is copied by dh-make into a
	# dh-make output file, you may use that output file without restriction.
	# This special exception was added by Craig Small in version 0.37 of dh-make.

	# This file was extended to incorporate a Meson/Ninja build system.

	# Uncomment this to turn on verbose mode.
	#export DH_VERBOSE=1

	%:
	dh $@

	override_dh_auto_clean:
	rm -rf debian/build

	override_dh_auto_configure:
	mkdir -p debian/build
	cd debian/build && meson --prefix=/usr ../..

	override_dh_auto_build:
	- cd debian/build && ninja -v
	+ cd debian/build && ninja -v && ninja build

	override_dh_auto_test:
	cd debian/build && ninja test

	override_dh_auto_install:
	cd debian/build && DESTDIR=${CURDIR}/debian/com.github.writeas.writeas-gtk ninja install
	+ mkdir -p debian/com.github.writeas.writeas-gtk/usr/bin
	+ cp bin/writeas debian/com.github.writeas.writeas-gtk/usr/bin/
	diff --git a/fonts/lora b/fonts/lora
	new file mode 160000
	index 0000000..4145c5b
	--- /dev/null
	+++ b/fonts/lora
	@@ -0,0 +1 @@
	+Subproject commit 4145c5b1880287fa82b04b63a7ebc4748982be0e
	diff --git a/meson.build b/meson.build
	index ea63182..224792e 100644
	--- a/meson.build
	+++ b/meson.build
	@@ -1,13 +1,19 @@
	project('com.github.writeas.writeas-gtk', ['vala', 'c'],
	version: '1.0.1',
	license: 'GPL',
	meson_version: '>=0.40.1')

	i18n = import('i18n')
	conf = configuration_data()
	conf.set_quoted('GETTEXT_PACKAGE', meson.project_name())
	configure_file(output: 'config.h', configuration: conf)
	config_h_dir = include_directories('.')

	+run_target('build', command: 'build-cli.sh')
	+
	subdir('data')
	subdir('src')
	+subdir('fonts/lora')
	+
	+meson.add_install_script('meson/post_install.py')
	+
	diff --git a/meson/post_install.py b/meson/post_install.py
	new file mode 100644
	index 0000000..7634127
	--- /dev/null
	+++ b/meson/post_install.py
	@@ -0,0 +1,22 @@
	+#!/usr/bin/env python3
	+
	+import os
	+import subprocess
	+
	+prefix = os.environ.get('MESON_INSTALL_PREFIX', '/usr/local')
	+datadir = os.path.join(prefix, 'share')
	+
	+# Packaging tools define DESTDIR and this isn't needed for them
	+if 'DESTDIR' not in os.environ:
	+ print('Updating icon cache...')
	+ icon_cache_dir = os.path.join(datadir, 'icons', 'hicolor')
	+ if not os.path.exists(icon_cache_dir):
	+ os.makedirs(icon_cache_dir)
	+ subprocess.call(['gtk-update-icon-cache', '-qtf', icon_cache_dir])
	+
	+ print('Updating desktop database...')
	+ desktop_database_dir = os.path.join(datadir, 'applications')
	+ if not os.path.exists(desktop_database_dir):
	+ os.makedirs(desktop_database_dir)
	+ subprocess.call(['update-desktop-database', '-q', desktop_database_dir])
	+
	diff --git a/screenshot-monospace.png b/screenshot-monospace.png
	index 122d12b..a33b4de 100644
	Binary files a/screenshot-monospace.png and b/screenshot-monospace.png differ
	diff --git a/screenshot-sans-light.png b/screenshot-sans-light.png
	index 8dc8996..2297119 100644
	Binary files a/screenshot-sans-light.png and b/screenshot-sans-light.png differ
	diff --git a/screenshot-serif-dark.png b/screenshot-serif-dark.png
	index fbfcfa3..d296970 100644
	Binary files a/screenshot-serif-dark.png and b/screenshot-serif-dark.png differ
	diff --git a/screenshot-serif-light.png b/screenshot-serif-light.png
	index 535e37d..2e4364a 100644
	Binary files a/screenshot-serif-light.png and b/screenshot-serif-light.png differ
	diff --git a/src/Widgets/ModeSwitch.vala b/src/Widgets/ModeSwitch.vala
	new file mode 100644
	index 0000000..98d99f2
	--- /dev/null
	+++ b/src/Widgets/ModeSwitch.vala
	@@ -0,0 +1,157 @@
	+/*
	+* Copyright (c) 2018 elementary, Inc. (https://elementary.io)
	+*
	+* This program is free software; you can redistribute it and/or
	+* modify it under the terms of the GNU General Public
	+* License as published by the Free Software Foundation; either
	+* version 2 of the License, or (at your option) any later version.
	+*
	+* This program is distributed in the hope that it will be useful,
	+* but WITHOUT ANY WARRANTY; without even the implied warranty of
	+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	+* General Public License for more details.
	+*
	+* You should have received a copy of the GNU General Public
	+* License along with this program; if not, write to the
	+* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	+* Boston, MA 02110-1301 USA
	+*/
	+
	+// From https://github.com/elementary/granite/blob/2066b377226cf327cb2d5399b6b40a2d36d47b11/lib/Widgets/ModeSwitch.vala
	+
	+/**
	+ * ModeSwitch is a selection control for choosing between two options that can be described with an icon.
	+ *
	+ * ''Example''<<BR>>
	+ * {{{
	+ * var gtk_settings = Gtk.Settings.get_default ();
	+ *
	+ * var mode_switch = new ModeSwitch.from_icon_name ("display-brightness-symbolic", "weather-clear-night-symbolic");
	+ * mode_switch.primary_icon_tooltip_text = _("Light background");
	+ * mode_switch.secondary_icon_tooltip_text = _("Dark background");
	+ * mode_switch.bind_property ("active", gtk_settings, "gtk_application_prefer_dark_theme");
	+ * }}}
	+ */
	+public class Granite.ModeSwitch : Gtk.Grid {
	+ /**
	+ * Whether the {@link Gtk.Switch} widget is pointing to the secondary icon or not.
	+ */
	+ public bool active { get; set; }
	+
	+ /**
	+ * The {@link GLib.Icon} to use for the primary icon for the switch.
	+ */
	+ public GLib.Icon primary_icon_gicon { get; construct set; }
	+
	+ /**
	+ * The icon name to use for the primary icon for the switch.
	+ */
	+ public string primary_icon_name { get; construct set; }
	+
	+ /**
	+ * The contents of the tooltip on the primary icon.
	+ */
	+ public string primary_icon_tooltip_text { get; set; }
	+
	+ /**
	+ * The {@link GLib.Icon} to use for the secondary icon for the switch.
	+ */
	+ public GLib.Icon secondary_icon_gicon { get; construct set; }
	+
	+ /**
	+ * The icon name to use for the secondary icon for the switch.
	+ */
	+ public string secondary_icon_name { get; construct set; }
	+
	+ /**
	+ * The contents of the tooltip on the secondary icon.
	+ */
	+ public string secondary_icon_tooltip_text { get; set; }
	+
	+ /**
	+ * Constructs a new {@link Granite.ModeSwitch} using {@link GLib.Icon}s.
	+ *
	+ * @param primary_icon_gicon The {@link GLib.Icon} to use for the primary icon for the switch.
	+ * @param secondary_icon_gicon The {@link GLib.Icon} to use for the secondary icon for the switch.
	+ */
	+ public ModeSwitch (GLib.Icon primary_icon_gicon, GLib.Icon secondary_icon_gicon) {
	+ Object (
	+ primary_icon_gicon: primary_icon_gicon,
	+ secondary_icon_gicon: secondary_icon_gicon
	+ );
	+ }
	+
	+ /**
	+ * Constructs a new {@link Granite.ModeSwitch} from icon names.
	+ *
	+ * @param primary_icon_name The icon name to use for the primary icon for the switch.
	+ * @param secondary_icon_name The icon name to use for the secondary icon for the switch.
	+ */
	+ public ModeSwitch.from_icon_name (string primary_icon_name, string secondary_icon_name) {
	+ Object (
	+ primary_icon_gicon: new ThemedIcon (primary_icon_name),
	+ secondary_icon_gicon: new ThemedIcon (secondary_icon_name),
	+ primary_icon_name: primary_icon_name,
	+ secondary_icon_name: secondary_icon_name
	+ );
	+ }
	+
	+ construct {
	+ var primary_image = new Gtk.Image ();
	+ primary_image.pixel_size = 16;
	+
	+ var primary_icon_box = new Gtk.EventBox ();
	+ primary_icon_box.add_events (Gdk.EventMask.BUTTON_RELEASE_MASK);
	+ primary_icon_box.add (primary_image);
	+
	+ var mode_switch = new Gtk.Switch ();
	+ mode_switch.valign = Gtk.Align.CENTER;
	+ mode_switch.get_style_context ().add_class ("mode-switch");
	+
	+ var secondary_icon = new Gtk.Image ();
	+ secondary_icon.pixel_size = 16;
	+
	+ var secondary_icon_box = new Gtk.EventBox ();
	+ secondary_icon_box.add_events (Gdk.EventMask.BUTTON_RELEASE_MASK);
	+ secondary_icon_box.add (secondary_icon);
	+
	+ column_spacing = 6;
	+ add (primary_icon_box);
	+ add (mode_switch);
	+ add (secondary_icon_box);
	+
	+ bind_property ("primary-icon-gicon", primary_image, "gicon", GLib.BindingFlags.SYNC_CREATE);
	+ bind_property ("primary-icon-name", primary_image, "icon-name", GLib.BindingFlags.SYNC_CREATE);
	+ bind_property ("primary-icon-tooltip-text", primary_image, "tooltip-text");
	+ bind_property ("secondary-icon-gicon", secondary_icon, "gicon", GLib.BindingFlags.SYNC_CREATE);
	+ bind_property ("secondary-icon-name", secondary_icon, "icon_name", GLib.BindingFlags.SYNC_CREATE);
	+ bind_property ("secondary-icon-tooltip-text", secondary_icon, "tooltip-text");
	+
	+ this.notify["active"].connect (() => {
	+ if (Gtk.StateFlags.DIR_RTL in get_state_flags ()) {
	+ mode_switch.active = !active;
	+ } else {
	+ mode_switch.active = active;
	+ }
	+ });
	+
	+ mode_switch.notify["active"].connect (() => {
	+ if (Gtk.StateFlags.DIR_RTL in get_state_flags ()) {
	+ active = !mode_switch.active;
	+ } else {
	+ active = mode_switch.active;
	+ }
	+ });
	+
	+ primary_icon_box.button_release_event.connect (() => {
	+ active = false;
	+ return Gdk.EVENT_STOP;
	+ });
	+
	+ secondary_icon_box.button_release_event.connect (() => {
	+ active = true;
	+ return Gdk.EVENT_STOP;
	+ });
	+ }
	+}
	+
	diff --git a/src/code.as/core/socks/LICENSE b/src/code.as/core/socks/LICENSE
	new file mode 100644
	index 0000000..47289bb
	--- /dev/null
	+++ b/src/code.as/core/socks/LICENSE
	@@ -0,0 +1,22 @@
	+Copyright (c) 2012, Hailiang Wang. All rights reserved.
	+
	+Redistribution and use in source and binary forms, with or without modification,
	+are permitted provided that the following conditions are met:
	+
	+ * Redistributions of source code must retain the above copyright notice, this
	+list of conditions and the following disclaimer.
	+
	+ * Redistributions in binary form must reproduce the above copyright notice,
	+this list of conditions and the following disclaimer in the documentation
	+and/or other materials provided with the distribution.
	+
	+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	\ No newline at end of file
	diff --git a/src/code.as/core/socks/README.md b/src/code.as/core/socks/README.md
	new file mode 100644
	index 0000000..869c183
	--- /dev/null
	+++ b/src/code.as/core/socks/README.md
	@@ -0,0 +1,58 @@
	+SOCKS
	+=====
	+
	+[![GoDoc](https://godoc.org/code.as/core/socks?status.svg)](https://godoc.org/code.as/core/socks)
	+
	+SOCKS is a SOCKS4, SOCKS4A and SOCKS5 proxy package for Go, forked from [h12w/socks](https://github.com/h12w/socks) and patched so it's `go get`able.
	+
	+## Quick Start
	+### Get the package
	+
	+ go get -u "code.as/core/socks"
	+
	+### Import the package
	+
	+ import "code.as/core/socks"
	+
	+### Create a SOCKS proxy dialing function
	+
	+ dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, "127.0.0.1:1080")
	+ tr := &http.Transport{Dial: dialSocksProxy}
	+ httpClient := &http.Client{Transport: tr}
	+
	+## Example
	+
	+```go
	+package main
	+
	+import (
	+ "fmt"
	+ "io/ioutil"
	+ "log"
	+ "net/http"
	+
	+ "code.as/core/socks"
	+)
	+
	+func main() {
	+ dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, "127.0.0.1:1080")
	+ tr := &http.Transport{Dial: dialSocksProxy}
	+ httpClient := &http.Client{Transport: tr}
	+ resp, err := httpClient.Get("http://www.google.com")
	+ if err != nil {
	+ log.Fatal(err)
	+ }
	+ defer resp.Body.Close()
	+ if resp.StatusCode != http.StatusOK {
	+ log.Fatal(resp.StatusCode)
	+ }
	+ buf, err := ioutil.ReadAll(resp.Body)
	+ if err != nil {
	+ log.Fatal(err)
	+ }
	+ fmt.Println(string(buf))
	+}
	+```
	+
	+## Alternatives
	+http://godoc.org/golang.org/x/net/proxy
	diff --git a/src/code.as/core/socks/socks.go b/src/code.as/core/socks/socks.go
	new file mode 100644
	index 0000000..78602ec
	--- /dev/null
	+++ b/src/code.as/core/socks/socks.go
	@@ -0,0 +1,218 @@
	+// Copyright 2012, Hailiang Wang. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+/*
	+Package socks implements a SOCKS (SOCKS4, SOCKS4A and SOCKS5) proxy client.
	+
	+A complete example using this package:
	+ package main
	+
	+ import (
	+ "code.as/core/socks"
	+ "fmt"
	+ "net/http"
	+ "io/ioutil"
	+ )
	+
	+ func main() {
	+ dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, "127.0.0.1:1080")
	+ tr := &http.Transport{Dial: dialSocksProxy}
	+ httpClient := &http.Client{Transport: tr}
	+
	+ bodyText, err := TestHttpsGet(httpClient, "https://h12.io/about")
	+ if err != nil {
	+ fmt.Println(err.Error())
	+ }
	+ fmt.Print(bodyText)
	+ }
	+
	+ func TestHttpsGet(c *http.Client, url string) (bodyText string, err error) {
	+ resp, err := c.Get(url)
	+ if err != nil { return }
	+ defer resp.Body.Close()
	+
	+ body, err := ioutil.ReadAll(resp.Body)
	+ if err != nil { return }
	+ bodyText = string(body)
	+ return
	+ }
	+*/
	+package socks
	+
	+import (
	+ "errors"
	+ "fmt"
	+ "net"
	+ "strconv"
	+)
	+
	+// Constants to choose which version of SOCKS protocol to use.
	+const (
	+ SOCKS4 = iota
	+ SOCKS4A
	+ SOCKS5
	+)
	+
	+// DialSocksProxy returns the dial function to be used in http.Transport object.
	+// Argument socksType should be one of SOCKS4, SOCKS4A and SOCKS5.
	+// Argument proxy should be in this format "127.0.0.1:1080".
	+func DialSocksProxy(socksType int, proxy string) func(string, string) (net.Conn, error) {
	+ if socksType == SOCKS5 {
	+ return func(_, targetAddr string) (conn net.Conn, err error) {
	+ return dialSocks5(proxy, targetAddr)
	+ }
	+ }
	+
	+ // SOCKS4, SOCKS4A
	+ return func(_, targetAddr string) (conn net.Conn, err error) {
	+ return dialSocks4(socksType, proxy, targetAddr)
	+ }
	+}
	+
	+func dialSocks5(proxy, targetAddr string) (conn net.Conn, err error) {
	+ // dial TCP
	+ conn, err = net.Dial("tcp", proxy)
	+ if err != nil {
	+ return
	+ }
	+
	+ // version identifier/method selection request
	+ req := []byte{
	+ 5, // version number
	+ 1, // number of methods
	+ 0, // method 0: no authentication (only anonymous access supported for now)
	+ }
	+ resp, err := sendReceive(conn, req)
	+ if err != nil {
	+ return
	+ } else if len(resp) != 2 {
	+ err = errors.New("Server does not respond properly.")
	+ return
	+ } else if resp[0] != 5 {
	+ err = errors.New("Server does not support Socks 5.")
	+ return
	+ } else if resp[1] != 0 { // no auth
	+ err = errors.New("socks method negotiation failed.")
	+ return
	+ }
	+
	+ // detail request
	+ host, port, err := splitHostPort(targetAddr)
	+ req = []byte{
	+ 5, // version number
	+ 1, // connect command
	+ 0, // reserved, must be zero
	+ 3, // address type, 3 means domain name
	+ byte(len(host)), // address length
	+ }
	+ req = append(req, []byte(host)...)
	+ req = append(req, []byte{
	+ byte(port >> 8), // higher byte of destination port
	+ byte(port), // lower byte of destination port (big endian)
	+ }...)
	+ resp, err = sendReceive(conn, req)
	+ if err != nil {
	+ return
	+ } else if len(resp) != 10 {
	+ err = errors.New("Server does not respond properly.")
	+ } else if resp[1] != 0 {
	+ err = errors.New("Can't complete SOCKS5 connection.")
	+ }
	+
	+ return
	+}
	+
	+func dialSocks4(socksType int, proxy, targetAddr string) (conn net.Conn, err error) {
	+ // dial TCP
	+ conn, err = net.Dial("tcp", proxy)
	+ if err != nil {
	+ return
	+ }
	+
	+ // connection request
	+ host, port, err := splitHostPort(targetAddr)
	+ if err != nil {
	+ return
	+ }
	+ ip := net.IPv4(0, 0, 0, 1).To4()
	+ if socksType == SOCKS4 {
	+ ip, err = lookupIP(host)
	+ if err != nil {
	+ return
	+ }
	+ }
	+ req := []byte{
	+ 4, // version number
	+ 1, // command CONNECT
	+ byte(port >> 8), // higher byte of destination port
	+ byte(port), // lower byte of destination port (big endian)
	+ ip[0], ip[1], ip[2], ip[3], // special invalid IP address to indicate the host name is provided
	+ 0, // user id is empty, anonymous proxy only
	+ }
	+ if socksType == SOCKS4A {
	+ req = append(req, []byte(host+"\x00")...)
	+ }
	+
	+ resp, err := sendReceive(conn, req)
	+ if err != nil {
	+ return
	+ } else if len(resp) != 8 {
	+ err = errors.New("Server does not respond properly.")
	+ return
	+ }
	+ switch resp[1] {
	+ case 90:
	+ // request granted
	+ case 91:
	+ err = errors.New("Socks connection request rejected or failed.")
	+ case 92:
	+ err = errors.New("Socks connection request rejected becasue SOCKS server cannot connect to identd on the client.")
	+ case 93:
	+ err = errors.New("Socks connection request rejected because the client program and identd report different user-ids.")
	+ default:
	+ err = errors.New("Socks connection request failed, unknown error.")
	+ }
	+ return
	+}
	+
	+func sendReceive(conn net.Conn, req []byte) (resp []byte, err error) {
	+ _, err = conn.Write(req)
	+ if err != nil {
	+ return
	+ }
	+ resp, err = readAll(conn)
	+ return
	+}
	+
	+func readAll(conn net.Conn) (resp []byte, err error) {
	+ resp = make([]byte, 1024)
	+ n, err := conn.Read(resp)
	+ resp = resp[:n]
	+ return
	+}
	+
	+func lookupIP(host string) (ip net.IP, err error) {
	+ ips, err := net.LookupIP(host)
	+ if err != nil {
	+ return
	+ }
	+ if len(ips) == 0 {
	+ err = errors.New(fmt.Sprintf("Cannot resolve host: %s.", host))
	+ return
	+ }
	+ ip = ips[0].To4()
	+ if len(ip) != net.IPv4len {
	+ fmt.Println(len(ip), ip)
	+ err = errors.New("IPv6 is not supported by SOCKS4.")
	+ return
	+ }
	+ return
	+}
	+
	+func splitHostPort(addr string) (host string, port uint16, err error) {
	+ host, portStr, err := net.SplitHostPort(addr)
	+ portInt, err := strconv.ParseUint(portStr, 10, 16)
	+ port = uint16(portInt)
	+ return
	+}
	diff --git a/src/code.as/core/socks/spec/SOCKS4.protocol.txt b/src/code.as/core/socks/spec/SOCKS4.protocol.txt
	new file mode 100644
	index 0000000..16483de
	--- /dev/null
	+++ b/src/code.as/core/socks/spec/SOCKS4.protocol.txt
	@@ -0,0 +1,150 @@
	+ SOCKS: A protocol for TCP proxy across firewalls
	+
	+ Ying-Da Lee
	+ yingda@best.com or yingda@esd.sgi.com
	+
	+SOCKS was originally developed by David Koblas and subsequently modified
	+and extended by me to its current running version -- version 4. It is a
	+protocol that relays TCP sessions at a firewall host to allow application
	+users transparent access across the firewall. Because the protocol is
	+independent of application protocols, it can be (and has been) used for
	+many different services, such as telnet, ftp, finger, whois, gopher, WWW,
	+etc. Access control can be applied at the beginning of each TCP session;
	+thereafter the server simply relays the data between the client and the
	+application server, incurring minimum processing overhead. Since SOCKS
	+never has to know anything about the application protocol, it should also
	+be easy for it to accommodate applications which use encryption to protect
	+their traffic from nosey snoopers.
	+
	+Two operations are defined: CONNECT and BIND.
	+
	+1) CONNECT
	+
	+The client connects to the SOCKS server and sends a CONNECT request when
	+it wants to establish a connection to an application server. The client
	+includes in the request packet the IP address and the port number of the
	+destination host, and userid, in the following format.
	+
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ \| VN \| CD \| DSTPORT \| DSTIP \| USERID \|NULL\|
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ # of bytes: 1 1 2 4 variable 1
	+
	+VN is the SOCKS protocol version number and should be 4. CD is the
	+SOCKS command code and should be 1 for CONNECT request. NULL is a byte
	+of all zero bits.
	+
	+The SOCKS server checks to see whether such a request should be granted
	+based on any combination of source IP address, destination IP address,
	+destination port number, the userid, and information it may obtain by
	+consulting IDENT, cf. RFC 1413. If the request is granted, the SOCKS
	+server makes a connection to the specified port of the destination host.
	+A reply packet is sent to the client when this connection is established,
	+or when the request is rejected or the operation fails.
	+
	+ +----+----+----+----+----+----+----+----+
	+ \| VN \| CD \| DSTPORT \| DSTIP \|
	+ +----+----+----+----+----+----+----+----+
	+ # of bytes: 1 1 2 4
	+
	+VN is the version of the reply code and should be 0. CD is the result
	+code with one of the following values:
	+
	+ 90: request granted
	+ 91: request rejected or failed
	+ 92: request rejected becasue SOCKS server cannot connect to
	+ identd on the client
	+ 93: request rejected because the client program and identd
	+ report different user-ids
	+
	+The remaining fields are ignored.
	+
	+The SOCKS server closes its connection immediately after notifying
	+the client of a failed or rejected request. For a successful request,
	+the SOCKS server gets ready to relay traffic on both directions. This
	+enables the client to do I/O on its connection as if it were directly
	+connected to the application server.
	+
	+
	+2) BIND
	+
	+The client connects to the SOCKS server and sends a BIND request when
	+it wants to prepare for an inbound connection from an application server.
	+This should only happen after a primary connection to the application
	+server has been established with a CONNECT. Typically, this is part of
	+the sequence of actions:
	+
	+-bind(): obtain a socket
	+-getsockname(): get the IP address and port number of the socket
	+-listen(): ready to accept call from the application server
	+-use the primary connection to inform the application server of
	+ the IP address and the port number that it should connect to.
	+-accept(): accept a connection from the application server
	+
	+The purpose of SOCKS BIND operation is to support such a sequence
	+but using a socket on the SOCKS server rather than on the client.
	+
	+The client includes in the request packet the IP address of the
	+application server, the destination port used in the primary connection,
	+and the userid.
	+
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ \| VN \| CD \| DSTPORT \| DSTIP \| USERID \|NULL\|
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ # of bytes: 1 1 2 4 variable 1
	+
	+VN is again 4 for the SOCKS protocol version number. CD must be 2 to
	+indicate BIND request.
	+
	+The SOCKS server uses the client information to decide whether the
	+request is to be granted. The reply it sends back to the client has
	+the same format as the reply for CONNECT request, i.e.,
	+
	+ +----+----+----+----+----+----+----+----+
	+ \| VN \| CD \| DSTPORT \| DSTIP \|
	+ +----+----+----+----+----+----+----+----+
	+ # of bytes: 1 1 2 4
	+
	+VN is the version of the reply code and should be 0. CD is the result
	+code with one of the following values:
	+
	+ 90: request granted
	+ 91: request rejected or failed
	+ 92: request rejected becasue SOCKS server cannot connect to
	+ identd on the client
	+ 93: request rejected because the client program and identd
	+ report different user-ids.
	+
	+However, for a granted request (CD is 90), the DSTPORT and DSTIP fields
	+are meaningful. In that case, the SOCKS server obtains a socket to wait
	+for an incoming connection and sends the port number and the IP address
	+of that socket to the client in DSTPORT and DSTIP, respectively. If the
	+DSTIP in the reply is 0 (the value of constant INADDR_ANY), then the
	+client should replace it with the IP address of the SOCKS server to which
	+the cleint is connected. (This happens if the SOCKS server is not a
	+multi-homed host.) In the typical scenario, these two numbers are
	+made available to the application client prgram via the result of the
	+subsequent getsockname() call. The application protocol must provide a
	+way for these two pieces of information to be sent from the client to
	+the application server so that it can initiate the connection, which
	+connects it to the SOCKS server rather than directly to the application
	+client as it normally would.
	+
	+The SOCKS server sends a second reply packet to the client when the
	+anticipated connection from the application server is established.
	+The SOCKS server checks the IP address of the originating host against
	+the value of DSTIP specified in the client's BIND request. If a mismatch
	+is found, the CD field in the second reply is set to 91 and the SOCKS
	+server closes both connections. If the two match, CD in the second
	+reply is set to 90 and the SOCKS server gets ready to relay the traffic
	+on its two connections. From then on the client does I/O on its connection
	+to the SOCKS server as if it were directly connected to the application
	+server.
	+
	+
	+
	+For both CONNECT and BIND operations, the server sets a time limit
	+(2 minutes in current CSTC implementation) for the establishment of its
	+connection with the application server. If the connection is still not
	+establiched when the time limit expires, the server closes its connection
	+to the client and gives up.
	diff --git a/src/code.as/core/socks/spec/rfc1928.txt b/src/code.as/core/socks/spec/rfc1928.txt
	new file mode 100644
	index 0000000..46bf46e
	--- /dev/null
	+++ b/src/code.as/core/socks/spec/rfc1928.txt
	@@ -0,0 +1,507 @@
	+
	+
	+
	+
	+
	+
	+Network Working Group M. Leech
	+Request for Comments: 1928 Bell-Northern Research Ltd
	+Category: Standards Track M. Ganis
	+ International Business Machines
	+ Y. Lee
	+ NEC Systems Laboratory
	+ R. Kuris
	+ Unify Corporation
	+ D. Koblas
	+ Independent Consultant
	+ L. Jones
	+ Hewlett-Packard Company
	+ March 1996
	+
	+
	+ SOCKS Protocol Version 5
	+
	+Status of this Memo
	+
	+ This document specifies an Internet standards track protocol for the
	+ Internet community, and requests discussion and suggestions for
	+ improvements. Please refer to the current edition of the "Internet
	+ Official Protocol Standards" (STD 1) for the standardization state
	+ and status of this protocol. Distribution of this memo is unlimited.
	+
	+Acknowledgments
	+
	+ This memo describes a protocol that is an evolution of the previous
	+ version of the protocol, version 4 [1]. This new protocol stems from
	+ active discussions and prototype implementations. The key
	+ contributors are: Marcus Leech: Bell-Northern Research, David Koblas:
	+ Independent Consultant, Ying-Da Lee: NEC Systems Laboratory, LaMont
	+ Jones: Hewlett-Packard Company, Ron Kuris: Unify Corporation, Matt
	+ Ganis: International Business Machines.
	+
	+1. Introduction
	+
	+ The use of network firewalls, systems that effectively isolate an
	+ organizations internal network structure from an exterior network,
	+ such as the INTERNET is becoming increasingly popular. These
	+ firewall systems typically act as application-layer gateways between
	+ networks, usually offering controlled TELNET, FTP, and SMTP access.
	+ With the emergence of more sophisticated application layer protocols
	+ designed to facilitate global information discovery, there exists a
	+ need to provide a general framework for these protocols to
	+ transparently and securely traverse a firewall.
	+
	+
	+
	+
	+
	+Leech, et al Standards Track [Page 1]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ There exists, also, a need for strong authentication of such
	+ traversal in as fine-grained a manner as is practical. This
	+ requirement stems from the realization that client-server
	+ relationships emerge between the networks of various organizations,
	+ and that such relationships need to be controlled and often strongly
	+ authenticated.
	+
	+ The protocol described here is designed to provide a framework for
	+ client-server applications in both the TCP and UDP domains to
	+ conveniently and securely use the services of a network firewall.
	+ The protocol is conceptually a "shim-layer" between the application
	+ layer and the transport layer, and as such does not provide network-
	+ layer gateway services, such as forwarding of ICMP messages.
	+
	+2. Existing practice
	+
	+ There currently exists a protocol, SOCKS Version 4, that provides for
	+ unsecured firewall traversal for TCP-based client-server
	+ applications, including TELNET, FTP and the popular information-
	+ discovery protocols such as HTTP, WAIS and GOPHER.
	+
	+ This new protocol extends the SOCKS Version 4 model to include UDP,
	+ and extends the framework to include provisions for generalized
	+ strong authentication schemes, and extends the addressing scheme to
	+ encompass domain-name and V6 IP addresses.
	+
	+ The implementation of the SOCKS protocol typically involves the
	+ recompilation or relinking of TCP-based client applications to use
	+ the appropriate encapsulation routines in the SOCKS library.
	+
	+Note:
	+
	+ Unless otherwise noted, the decimal numbers appearing in packet-
	+ format diagrams represent the length of the corresponding field, in
	+ octets. Where a given octet must take on a specific value, the
	+ syntax X'hh' is used to denote the value of the single octet in that
	+ field. When the word 'Variable' is used, it indicates that the
	+ corresponding field has a variable length defined either by an
	+ associated (one or two octet) length field, or by a data type field.
	+
	+3. Procedure for TCP-based clients
	+
	+ When a TCP-based client wishes to establish a connection to an object
	+ that is reachable only via a firewall (such determination is left up
	+ to the implementation), it must open a TCP connection to the
	+ appropriate SOCKS port on the SOCKS server system. The SOCKS service
	+ is conventionally located on TCP port 1080. If the connection
	+ request succeeds, the client enters a negotiation for the
	+
	+
	+
	+Leech, et al Standards Track [Page 2]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ authentication method to be used, authenticates with the chosen
	+ method, then sends a relay request. The SOCKS server evaluates the
	+ request, and either establishes the appropriate connection or denies
	+ it.
	+
	+ Unless otherwise noted, the decimal numbers appearing in packet-
	+ format diagrams represent the length of the corresponding field, in
	+ octets. Where a given octet must take on a specific value, the
	+ syntax X'hh' is used to denote the value of the single octet in that
	+ field. When the word 'Variable' is used, it indicates that the
	+ corresponding field has a variable length defined either by an
	+ associated (one or two octet) length field, or by a data type field.
	+
	+ The client connects to the server, and sends a version
	+ identifier/method selection message:
	+
	+ +----+----------+----------+
	+ \|VER \| NMETHODS \| METHODS \|
	+ +----+----------+----------+
	+ \| 1 \| 1 \| 1 to 255 \|
	+ +----+----------+----------+
	+
	+ The VER field is set to X'05' for this version of the protocol. The
	+ NMETHODS field contains the number of method identifier octets that
	+ appear in the METHODS field.
	+
	+ The server selects from one of the methods given in METHODS, and
	+ sends a METHOD selection message:
	+
	+ +----+--------+
	+ \|VER \| METHOD \|
	+ +----+--------+
	+ \| 1 \| 1 \|
	+ +----+--------+
	+
	+ If the selected METHOD is X'FF', none of the methods listed by the
	+ client are acceptable, and the client MUST close the connection.
	+
	+ The values currently defined for METHOD are:
	+
	+ o X'00' NO AUTHENTICATION REQUIRED
	+ o X'01' GSSAPI
	+ o X'02' USERNAME/PASSWORD
	+ o X'03' to X'7F' IANA ASSIGNED
	+ o X'80' to X'FE' RESERVED FOR PRIVATE METHODS
	+ o X'FF' NO ACCEPTABLE METHODS
	+
	+ The client and server then enter a method-specific sub-negotiation.
	+
	+
	+
	+Leech, et al Standards Track [Page 3]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ Descriptions of the method-dependent sub-negotiations appear in
	+ separate memos.
	+
	+ Developers of new METHOD support for this protocol should contact
	+ IANA for a METHOD number. The ASSIGNED NUMBERS document should be
	+ referred to for a current list of METHOD numbers and their
	+ corresponding protocols.
	+
	+ Compliant implementations MUST support GSSAPI and SHOULD support
	+ USERNAME/PASSWORD authentication methods.
	+
	+4. Requests
	+
	+ Once the method-dependent subnegotiation has completed, the client
	+ sends the request details. If the negotiated method includes
	+ encapsulation for purposes of integrity checking and/or
	+ confidentiality, these requests MUST be encapsulated in the method-
	+ dependent encapsulation.
	+
	+ The SOCKS request is formed as follows:
	+
	+ +----+-----+-------+------+----------+----------+
	+ \|VER \| CMD \| RSV \| ATYP \| DST.ADDR \| DST.PORT \|
	+ +----+-----+-------+------+----------+----------+
	+ \| 1 \| 1 \| X'00' \| 1 \| Variable \| 2 \|
	+ +----+-----+-------+------+----------+----------+
	+
	+ Where:
	+
	+ o VER protocol version: X'05'
	+ o CMD
	+ o CONNECT X'01'
	+ o BIND X'02'
	+ o UDP ASSOCIATE X'03'
	+ o RSV RESERVED
	+ o ATYP address type of following address
	+ o IP V4 address: X'01'
	+ o DOMAINNAME: X'03'
	+ o IP V6 address: X'04'
	+ o DST.ADDR desired destination address
	+ o DST.PORT desired destination port in network octet
	+ order
	+
	+ The SOCKS server will typically evaluate the request based on source
	+ and destination addresses, and return one or more reply messages, as
	+ appropriate for the request type.
	+
	+
	+
	+
	+
	+Leech, et al Standards Track [Page 4]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+5. Addressing
	+
	+ In an address field (DST.ADDR, BND.ADDR), the ATYP field specifies
	+ the type of address contained within the field:
	+
	+ o X'01'
	+
	+ the address is a version-4 IP address, with a length of 4 octets
	+
	+ o X'03'
	+
	+ the address field contains a fully-qualified domain name. The first
	+ octet of the address field contains the number of octets of name that
	+ follow, there is no terminating NUL octet.
	+
	+ o X'04'
	+
	+ the address is a version-6 IP address, with a length of 16 octets.
	+
	+6. Replies
	+
	+ The SOCKS request information is sent by the client as soon as it has
	+ established a connection to the SOCKS server, and completed the
	+ authentication negotiations. The server evaluates the request, and
	+ returns a reply formed as follows:
	+
	+ +----+-----+-------+------+----------+----------+
	+ \|VER \| REP \| RSV \| ATYP \| BND.ADDR \| BND.PORT \|
	+ +----+-----+-------+------+----------+----------+
	+ \| 1 \| 1 \| X'00' \| 1 \| Variable \| 2 \|
	+ +----+-----+-------+------+----------+----------+
	+
	+ Where:
	+
	+ o VER protocol version: X'05'
	+ o REP Reply field:
	+ o X'00' succeeded
	+ o X'01' general SOCKS server failure
	+ o X'02' connection not allowed by ruleset
	+ o X'03' Network unreachable
	+ o X'04' Host unreachable
	+ o X'05' Connection refused
	+ o X'06' TTL expired
	+ o X'07' Command not supported
	+ o X'08' Address type not supported
	+ o X'09' to X'FF' unassigned
	+ o RSV RESERVED
	+ o ATYP address type of following address
	+
	+
	+
	+Leech, et al Standards Track [Page 5]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ o IP V4 address: X'01'
	+ o DOMAINNAME: X'03'
	+ o IP V6 address: X'04'
	+ o BND.ADDR server bound address
	+ o BND.PORT server bound port in network octet order
	+
	+ Fields marked RESERVED (RSV) must be set to X'00'.
	+
	+ If the chosen method includes encapsulation for purposes of
	+ authentication, integrity and/or confidentiality, the replies are
	+ encapsulated in the method-dependent encapsulation.
	+
	+CONNECT
	+
	+ In the reply to a CONNECT, BND.PORT contains the port number that the
	+ server assigned to connect to the target host, while BND.ADDR
	+ contains the associated IP address. The supplied BND.ADDR is often
	+ different from the IP address that the client uses to reach the SOCKS
	+ server, since such servers are often multi-homed. It is expected
	+ that the SOCKS server will use DST.ADDR and DST.PORT, and the
	+ client-side source address and port in evaluating the CONNECT
	+ request.
	+
	+BIND
	+
	+ The BIND request is used in protocols which require the client to
	+ accept connections from the server. FTP is a well-known example,
	+ which uses the primary client-to-server connection for commands and
	+ status reports, but may use a server-to-client connection for
	+ transferring data on demand (e.g. LS, GET, PUT).
	+
	+ It is expected that the client side of an application protocol will
	+ use the BIND request only to establish secondary connections after a
	+ primary connection is established using CONNECT. In is expected that
	+ a SOCKS server will use DST.ADDR and DST.PORT in evaluating the BIND
	+ request.
	+
	+ Two replies are sent from the SOCKS server to the client during a
	+ BIND operation. The first is sent after the server creates and binds
	+ a new socket. The BND.PORT field contains the port number that the
	+ SOCKS server assigned to listen for an incoming connection. The
	+ BND.ADDR field contains the associated IP address. The client will
	+ typically use these pieces of information to notify (via the primary
	+ or control connection) the application server of the rendezvous
	+ address. The second reply occurs only after the anticipated incoming
	+ connection succeeds or fails.
	+
	+
	+
	+
	+
	+Leech, et al Standards Track [Page 6]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ In the second reply, the BND.PORT and BND.ADDR fields contain the
	+ address and port number of the connecting host.
	+
	+UDP ASSOCIATE
	+
	+ The UDP ASSOCIATE request is used to establish an association within
	+ the UDP relay process to handle UDP datagrams. The DST.ADDR and
	+ DST.PORT fields contain the address and port that the client expects
	+ to use to send UDP datagrams on for the association. The server MAY
	+ use this information to limit access to the association. If the
	+ client is not in possesion of the information at the time of the UDP
	+ ASSOCIATE, the client MUST use a port number and address of all
	+ zeros.
	+
	+ A UDP association terminates when the TCP connection that the UDP
	+ ASSOCIATE request arrived on terminates.
	+
	+ In the reply to a UDP ASSOCIATE request, the BND.PORT and BND.ADDR
	+ fields indicate the port number/address where the client MUST send
	+ UDP request messages to be relayed.
	+
	+Reply Processing
	+
	+ When a reply (REP value other than X'00') indicates a failure, the
	+ SOCKS server MUST terminate the TCP connection shortly after sending
	+ the reply. This must be no more than 10 seconds after detecting the
	+ condition that caused a failure.
	+
	+ If the reply code (REP value of X'00') indicates a success, and the
	+ request was either a BIND or a CONNECT, the client may now start
	+ passing data. If the selected authentication method supports
	+ encapsulation for the purposes of integrity, authentication and/or
	+ confidentiality, the data are encapsulated using the method-dependent
	+ encapsulation. Similarly, when data arrives at the SOCKS server for
	+ the client, the server MUST encapsulate the data as appropriate for
	+ the authentication method in use.
	+
	+7. Procedure for UDP-based clients
	+
	+ A UDP-based client MUST send its datagrams to the UDP relay server at
	+ the UDP port indicated by BND.PORT in the reply to the UDP ASSOCIATE
	+ request. If the selected authentication method provides
	+ encapsulation for the purposes of authenticity, integrity, and/or
	+ confidentiality, the datagram MUST be encapsulated using the
	+ appropriate encapsulation. Each UDP datagram carries a UDP request
	+ header with it:
	+
	+
	+
	+
	+
	+Leech, et al Standards Track [Page 7]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ +----+------+------+----------+----------+----------+
	+ \|RSV \| FRAG \| ATYP \| DST.ADDR \| DST.PORT \| DATA \|
	+ +----+------+------+----------+----------+----------+
	+ \| 2 \| 1 \| 1 \| Variable \| 2 \| Variable \|
	+ +----+------+------+----------+----------+----------+
	+
	+ The fields in the UDP request header are:
	+
	+ o RSV Reserved X'0000'
	+ o FRAG Current fragment number
	+ o ATYP address type of following addresses:
	+ o IP V4 address: X'01'
	+ o DOMAINNAME: X'03'
	+ o IP V6 address: X'04'
	+ o DST.ADDR desired destination address
	+ o DST.PORT desired destination port
	+ o DATA user data
	+
	+ When a UDP relay server decides to relay a UDP datagram, it does so
	+ silently, without any notification to the requesting client.
	+ Similarly, it will drop datagrams it cannot or will not relay. When
	+ a UDP relay server receives a reply datagram from a remote host, it
	+ MUST encapsulate that datagram using the above UDP request header,
	+ and any authentication-method-dependent encapsulation.
	+
	+ The UDP relay server MUST acquire from the SOCKS server the expected
	+ IP address of the client that will send datagrams to the BND.PORT
	+ given in the reply to UDP ASSOCIATE. It MUST drop any datagrams
	+ arriving from any source IP address other than the one recorded for
	+ the particular association.
	+
	+ The FRAG field indicates whether or not this datagram is one of a
	+ number of fragments. If implemented, the high-order bit indicates
	+ end-of-fragment sequence, while a value of X'00' indicates that this
	+ datagram is standalone. Values between 1 and 127 indicate the
	+ fragment position within a fragment sequence. Each receiver will
	+ have a REASSEMBLY QUEUE and a REASSEMBLY TIMER associated with these
	+ fragments. The reassembly queue must be reinitialized and the
	+ associated fragments abandoned whenever the REASSEMBLY TIMER expires,
	+ or a new datagram arrives carrying a FRAG field whose value is less
	+ than the highest FRAG value processed for this fragment sequence.
	+ The reassembly timer MUST be no less than 5 seconds. It is
	+ recommended that fragmentation be avoided by applications wherever
	+ possible.
	+
	+ Implementation of fragmentation is optional; an implementation that
	+ does not support fragmentation MUST drop any datagram whose FRAG
	+ field is other than X'00'.
	+
	+
	+
	+Leech, et al Standards Track [Page 8]
	+
	+RFC 1928 SOCKS Protocol Version 5 March 1996
	+
	+
	+ The programming interface for a SOCKS-aware UDP MUST report an
	+ available buffer space for UDP datagrams that is smaller than the
	+ actual space provided by the operating system:
	+
	+ o if ATYP is X'01' - 10+method_dependent octets smaller
	+ o if ATYP is X'03' - 262+method_dependent octets smaller
	+ o if ATYP is X'04' - 20+method_dependent octets smaller
	+
	+8. Security Considerations
	+
	+ This document describes a protocol for the application-layer
	+ traversal of IP network firewalls. The security of such traversal is
	+ highly dependent on the particular authentication and encapsulation
	+ methods provided in a particular implementation, and selected during
	+ negotiation between SOCKS client and SOCKS server.
	+
	+ Careful consideration should be given by the administrator to the
	+ selection of authentication methods.
	+
	+9. References
	+
	+ [1] Koblas, D., "SOCKS", Proceedings: 1992 Usenix Security Symposium.
	+
	+Author's Address
	+
	+ Marcus Leech
	+ Bell-Northern Research Ltd
	+ P.O. Box 3511, Stn. C,
	+ Ottawa, ON
	+ CANADA K1Y 4H7
	+
	+ Phone: (613) 763-9145
	+ EMail: mleech@bnr.ca
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+Leech, et al Standards Track [Page 9]
	+
	diff --git a/src/code.as/core/socks/spec/socks4A.protocol.txt b/src/code.as/core/socks/spec/socks4A.protocol.txt
	new file mode 100644
	index 0000000..be2ff83
	--- /dev/null
	+++ b/src/code.as/core/socks/spec/socks4A.protocol.txt
	@@ -0,0 +1,40 @@
	+SOCKS 4A: A Simple Extension to SOCKS 4 Protocol
	+
	+ Ying-Da Lee
	+ yingda@best.com or yingda@esd.sgi.com
	+
	+Please read SOCKS4.protocol first for an description of the version 4
	+protocol. This extension is intended to allow the use of SOCKS on hosts
	+which are not capable of resolving all domain names.
	+
	+In version 4, the client sends the following packet to the SOCKS server
	+to request a CONNECT or a BIND operation:
	+
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ \| VN \| CD \| DSTPORT \| DSTIP \| USERID \|NULL\|
	+ +----+----+----+----+----+----+----+----+----+----+....+----+
	+ # of bytes: 1 1 2 4 variable 1
	+
	+VN is the SOCKS protocol version number and should be 4. CD is the
	+SOCKS command code and should be 1 for CONNECT or 2 for BIND. NULL
	+is a byte of all zero bits.
	+
	+For version 4A, if the client cannot resolve the destination host's
	+domain name to find its IP address, it should set the first three bytes
	+of DSTIP to NULL and the last byte to a non-zero value. (This corresponds
	+to IP address 0.0.0.x, with x nonzero. As decreed by IANA -- The
	+Internet Assigned Numbers Authority -- such an address is inadmissible
	+as a destination IP address and thus should never occur if the client
	+can resolve the domain name.) Following the NULL byte terminating
	+USERID, the client must sends the destination domain name and termiantes
	+it with another NULL byte. This is used for both CONNECT and BIND requests.
	+
	+A server using protocol 4A must check the DSTIP in the request packet.
	+If it represent address 0.0.0.x with nonzero x, the server must read
	+in the domain name that the client sends in the packet. The server
	+should resolve the domain name and make connection to the destination
	+host if it can.
	+
	+SOCKSified sockd may pass domain names that it cannot resolve to
	+the next-hop SOCKS server.
	+
	diff --git a/src/github.com/BurntSushi/toml/COMPATIBLE b/src/github.com/BurntSushi/toml/COMPATIBLE
	new file mode 100644
	index 0000000..6efcfd0
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/COMPATIBLE
	@@ -0,0 +1,3 @@
	+Compatible with TOML version
	+[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md)
	+
	diff --git a/src/github.com/BurntSushi/toml/COPYING b/src/github.com/BurntSushi/toml/COPYING
	new file mode 100644
	index 0000000..01b5743
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/COPYING
	@@ -0,0 +1,21 @@
	+The MIT License (MIT)
	+
	+Copyright (c) 2013 TOML authors
	+
	+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.
	diff --git a/src/github.com/BurntSushi/toml/Makefile b/src/github.com/BurntSushi/toml/Makefile
	new file mode 100644
	index 0000000..3600848
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/Makefile
	@@ -0,0 +1,19 @@
	+install:
	+ go install ./...
	+
	+test: install
	+ go test -v
	+ toml-test toml-test-decoder
	+ toml-test -encoder toml-test-encoder
	+
	+fmt:
	+ gofmt -w .go /*.go
	+ colcheck .go /*.go
	+
	+tags:
	+ find ./ -name '*.go' -print0 \| xargs -0 gotags > TAGS
	+
	+push:
	+ git push origin master
	+ git push github master
	+
	diff --git a/src/github.com/BurntSushi/toml/README.md b/src/github.com/BurntSushi/toml/README.md
	new file mode 100644
	index 0000000..7c1b37e
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/README.md
	@@ -0,0 +1,218 @@
	+## TOML parser and encoder for Go with reflection
	+
	+TOML stands for Tom's Obvious, Minimal Language. This Go package provides a
	+reflection interface similar to Go's standard library `json` and `xml`
	+packages. This package also supports the `encoding.TextUnmarshaler` and
	+`encoding.TextMarshaler` interfaces so that you can define custom data
	+representations. (There is an example of this below.)
	+
	+Spec: https://github.com/toml-lang/toml
	+
	+Compatible with TOML version
	+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
	+
	+Documentation: https://godoc.org/github.com/BurntSushi/toml
	+
	+Installation:
	+
	+```bash
	+go get github.com/BurntSushi/toml
	+```
	+
	+Try the toml validator:
	+
	+```bash
	+go get github.com/BurntSushi/toml/cmd/tomlv
	+tomlv some-toml-file.toml
	+```
	+
	+[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)
	+
	+### Testing
	+
	+This package passes all tests in
	+[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder
	+and the encoder.
	+
	+### Examples
	+
	+This package works similarly to how the Go standard library handles `XML`
	+and `JSON`. Namely, data is loaded into Go values via reflection.
	+
	+For the simplest example, consider some TOML file as just a list of keys
	+and values:
	+
	+```toml
	+Age = 25
	+Cats = [ "Cauchy", "Plato" ]
	+Pi = 3.14
	+Perfection = [ 6, 28, 496, 8128 ]
	+DOB = 1987-07-05T05:45:00Z
	+```
	+
	+Which could be defined in Go as:
	+
	+```go
	+type Config struct {
	+ Age int
	+ Cats []string
	+ Pi float64
	+ Perfection []int
	+ DOB time.Time // requires `import time`
	+}
	+```
	+
	+And then decoded with:
	+
	+```go
	+var conf Config
	+if _, err := toml.Decode(tomlData, &conf); err != nil {
	+ // handle error
	+}
	+```
	+
	+You can also use struct tags if your struct field name doesn't map to a TOML
	+key value directly:
	+
	+```toml
	+some_key_NAME = "wat"
	+```
	+
	+```go
	+type TOML struct {
	+ ObscureKey string `toml:"some_key_NAME"`
	+}
	+```
	+
	+### Using the `encoding.TextUnmarshaler` interface
	+
	+Here's an example that automatically parses duration strings into
	+`time.Duration` values:
	+
	+```toml
	+[[song]]
	+name = "Thunder Road"
	+duration = "4m49s"
	+
	+[[song]]
	+name = "Stairway to Heaven"
	+duration = "8m03s"
	+```
	+
	+Which can be decoded with:
	+
	+```go
	+type song struct {
	+ Name string
	+ Duration duration
	+}
	+type songs struct {
	+ Song []song
	+}
	+var favorites songs
	+if _, err := toml.Decode(blob, &favorites); err != nil {
	+ log.Fatal(err)
	+}
	+
	+for _, s := range favorites.Song {
	+ fmt.Printf("%s (%s)\n", s.Name, s.Duration)
	+}
	+```
	+
	+And you'll also need a `duration` type that satisfies the
	+`encoding.TextUnmarshaler` interface:
	+
	+```go
	+type duration struct {
	+ time.Duration
	+}
	+
	+func (d *duration) UnmarshalText(text []byte) error {
	+ var err error
	+ d.Duration, err = time.ParseDuration(string(text))
	+ return err
	+}
	+```
	+
	+### More complex usage
	+
	+Here's an example of how to load the example from the official spec page:
	+
	+```toml
	+# This is a TOML document. Boom.
	+
	+title = "TOML Example"
	+
	+[owner]
	+name = "Tom Preston-Werner"
	+organization = "GitHub"
	+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
	+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
	+
	+[database]
	+server = "192.168.1.1"
	+ports = [ 8001, 8001, 8002 ]
	+connection_max = 5000
	+enabled = true
	+
	+[servers]
	+
	+ # You can indent as you please. Tabs or spaces. TOML don't care.
	+ [servers.alpha]
	+ ip = "10.0.0.1"
	+ dc = "eqdc10"
	+
	+ [servers.beta]
	+ ip = "10.0.0.2"
	+ dc = "eqdc10"
	+
	+[clients]
	+data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
	+
	+# Line breaks are OK when inside arrays
	+hosts = [
	+ "alpha",
	+ "omega"
	+]
	+```
	+
	+And the corresponding Go types are:
	+
	+```go
	+type tomlConfig struct {
	+ Title string
	+ Owner ownerInfo
	+ DB database `toml:"database"`
	+ Servers map[string]server
	+ Clients clients
	+}
	+
	+type ownerInfo struct {
	+ Name string
	+ Org string `toml:"organization"`
	+ Bio string
	+ DOB time.Time
	+}
	+
	+type database struct {
	+ Server string
	+ Ports []int
	+ ConnMax int `toml:"connection_max"`
	+ Enabled bool
	+}
	+
	+type server struct {
	+ IP string
	+ DC string
	+}
	+
	+type clients struct {
	+ Data [][]interface{}
	+ Hosts []string
	+}
	+```
	+
	+Note that a case insensitive match will be tried if an exact match can't be
	+found.
	+
	+A working example of the above can be found in `_examples/example.{go,toml}`.
	diff --git a/src/github.com/BurntSushi/toml/_examples/example.go b/src/github.com/BurntSushi/toml/_examples/example.go
	new file mode 100644
	index 0000000..79f31f2
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/example.go
	@@ -0,0 +1,61 @@
	+package main
	+
	+import (
	+ "fmt"
	+ "time"
	+
	+ "github.com/BurntSushi/toml"
	+)
	+
	+type tomlConfig struct {
	+ Title string
	+ Owner ownerInfo
	+ DB database `toml:"database"`
	+ Servers map[string]server
	+ Clients clients
	+}
	+
	+type ownerInfo struct {
	+ Name string
	+ Org string `toml:"organization"`
	+ Bio string
	+ DOB time.Time
	+}
	+
	+type database struct {
	+ Server string
	+ Ports []int
	+ ConnMax int `toml:"connection_max"`
	+ Enabled bool
	+}
	+
	+type server struct {
	+ IP string
	+ DC string
	+}
	+
	+type clients struct {
	+ Data [][]interface{}
	+ Hosts []string
	+}
	+
	+func main() {
	+ var config tomlConfig
	+ if _, err := toml.DecodeFile("example.toml", &config); err != nil {
	+ fmt.Println(err)
	+ return
	+ }
	+
	+ fmt.Printf("Title: %s\n", config.Title)
	+ fmt.Printf("Owner: %s (%s, %s), Born: %s\n",
	+ config.Owner.Name, config.Owner.Org, config.Owner.Bio,
	+ config.Owner.DOB)
	+ fmt.Printf("Database: %s %v (Max conn. %d), Enabled? %v\n",
	+ config.DB.Server, config.DB.Ports, config.DB.ConnMax,
	+ config.DB.Enabled)
	+ for serverName, server := range config.Servers {
	+ fmt.Printf("Server: %s (%s, %s)\n", serverName, server.IP, server.DC)
	+ }
	+ fmt.Printf("Client data: %v\n", config.Clients.Data)
	+ fmt.Printf("Client hosts: %v\n", config.Clients.Hosts)
	+}
	diff --git a/src/github.com/BurntSushi/toml/_examples/example.toml b/src/github.com/BurntSushi/toml/_examples/example.toml
	new file mode 100644
	index 0000000..32c7a4f
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/example.toml
	@@ -0,0 +1,35 @@
	+# This is a TOML document. Boom.
	+
	+title = "TOML Example"
	+
	+[owner]
	+name = "Tom Preston-Werner"
	+organization = "GitHub"
	+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
	+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
	+
	+[database]
	+server = "192.168.1.1"
	+ports = [ 8001, 8001, 8002 ]
	+connection_max = 5000
	+enabled = true
	+
	+[servers]
	+
	+ # You can indent as you please. Tabs or spaces. TOML don't care.
	+ [servers.alpha]
	+ ip = "10.0.0.1"
	+ dc = "eqdc10"
	+
	+ [servers.beta]
	+ ip = "10.0.0.2"
	+ dc = "eqdc10"
	+
	+[clients]
	+data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
	+
	+# Line breaks are OK when inside arrays
	+hosts = [
	+ "alpha",
	+ "omega"
	+]
	diff --git a/src/github.com/BurntSushi/toml/_examples/hard.toml b/src/github.com/BurntSushi/toml/_examples/hard.toml
	new file mode 100644
	index 0000000..26145d2
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/hard.toml
	@@ -0,0 +1,22 @@
	+# Test file for TOML
	+# Only this one tries to emulate a TOML file written by a user of the kind of parser writers probably hate
	+# This part you'll really hate
	+
	+[the]
	+test_string = "You'll hate me after this - #" # " Annoying, isn't it?
	+
	+ [the.hard]
	+ test_array = [ "] ", " # "] # ] There you go, parse this!
	+ test_array2 = [ "Test #11 ]proved that", "Experiment #9 was a success" ]
	+ # You didn't think it'd as easy as chucking out the last #, did you?
	+ another_test_string = " Same thing, but with a string #"
	+ harder_test_string = " And when \"'s are in the string, along with # \"" # "and comments are there too"
	+ # Things will get harder
	+
	+ [the.hard.bit#]
	+ what? = "You don't think some user won't do that?"
	+ multi_line_array = [
	+ "]",
	+ # ] Oh yes I did
	+ ]
	+
	diff --git a/src/github.com/BurntSushi/toml/_examples/implicit.toml b/src/github.com/BurntSushi/toml/_examples/implicit.toml
	new file mode 100644
	index 0000000..1dea5ce
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/implicit.toml
	@@ -0,0 +1,4 @@
	+# [x] you
	+# [x.y] don't
	+# [x.y.z] need these
	+[x.y.z.w] # for this to work
	diff --git a/src/github.com/BurntSushi/toml/_examples/invalid-apples.toml b/src/github.com/BurntSushi/toml/_examples/invalid-apples.toml
	new file mode 100644
	index 0000000..74e9e33
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/invalid-apples.toml
	@@ -0,0 +1,6 @@
	+# DO NOT WANT
	+[fruit]
	+type = "apple"
	+
	+[fruit.type]
	+apple = "yes"
	diff --git a/src/github.com/BurntSushi/toml/_examples/invalid.toml b/src/github.com/BurntSushi/toml/_examples/invalid.toml
	new file mode 100644
	index 0000000..beb1dba
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/invalid.toml
	@@ -0,0 +1,35 @@
	+# This is an INVALID TOML document. Boom.
	+# Can you spot the error without help?
	+
	+title = "TOML Example"
	+
	+[owner]
	+name = "Tom Preston-Werner"
	+organization = "GitHub"
	+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
	+dob = 1979-05-27T7:32:00Z # First class dates? Why not?
	+
	+[database]
	+server = "192.168.1.1"
	+ports = [ 8001, 8001, 8002 ]
	+connection_max = 5000
	+enabled = true
	+
	+[servers]
	+ # You can indent as you please. Tabs or spaces. TOML don't care.
	+ [servers.alpha]
	+ ip = "10.0.0.1"
	+ dc = "eqdc10"
	+
	+ [servers.beta]
	+ ip = "10.0.0.2"
	+ dc = "eqdc10"
	+
	+[clients]
	+data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
	+
	+# Line breaks are OK when inside arrays
	+hosts = [
	+ "alpha",
	+ "omega"
	+]
	diff --git a/src/github.com/BurntSushi/toml/_examples/readme1.toml b/src/github.com/BurntSushi/toml/_examples/readme1.toml
	new file mode 100644
	index 0000000..3e1261d
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/readme1.toml
	@@ -0,0 +1,5 @@
	+Age = 25
	+Cats = [ "Cauchy", "Plato" ]
	+Pi = 3.14
	+Perfection = [ 6, 28, 496, 8128 ]
	+DOB = 1987-07-05T05:45:00Z
	diff --git a/src/github.com/BurntSushi/toml/_examples/readme2.toml b/src/github.com/BurntSushi/toml/_examples/readme2.toml
	new file mode 100644
	index 0000000..b51cd93
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/_examples/readme2.toml
	@@ -0,0 +1 @@
	+some_key_NAME = "wat"
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING
	new file mode 100644
	index 0000000..01b5743
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING
	@@ -0,0 +1,21 @@
	+The MIT License (MIT)
	+
	+Copyright (c) 2013 TOML authors
	+
	+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.
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/README.md b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/README.md
	new file mode 100644
	index 0000000..93f4e3a
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/README.md
	@@ -0,0 +1,13 @@
	+# Implements the TOML test suite interface
	+
	+This is an implementation of the interface expected by
	+[toml-test](https://github.com/BurntSushi/toml-test) for my
	+[toml parser written in Go](https://github.com/BurntSushi/toml).
	+In particular, it maps TOML data on `stdin` to a JSON format on `stdout`.
	+
	+
	+Compatible with TOML version
	+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
	+
	+Compatible with `toml-test` version
	+[v0.2.0](https://github.com/BurntSushi/toml-test/tree/v0.2.0)
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/main.go b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/main.go
	new file mode 100644
	index 0000000..14e7557
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-decoder/main.go
	@@ -0,0 +1,90 @@
	+// Command toml-test-decoder satisfies the toml-test interface for testing
	+// TOML decoders. Namely, it accepts TOML on stdin and outputs JSON on stdout.
	+package main
	+
	+import (
	+ "encoding/json"
	+ "flag"
	+ "fmt"
	+ "log"
	+ "os"
	+ "path"
	+ "time"
	+
	+ "github.com/BurntSushi/toml"
	+)
	+
	+func init() {
	+ log.SetFlags(0)
	+
	+ flag.Usage = usage
	+ flag.Parse()
	+}
	+
	+func usage() {
	+ log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
	+ flag.PrintDefaults()
	+
	+ os.Exit(1)
	+}
	+
	+func main() {
	+ if flag.NArg() != 0 {
	+ flag.Usage()
	+ }
	+
	+ var tmp interface{}
	+ if _, err := toml.DecodeReader(os.Stdin, &tmp); err != nil {
	+ log.Fatalf("Error decoding TOML: %s", err)
	+ }
	+
	+ typedTmp := translate(tmp)
	+ if err := json.NewEncoder(os.Stdout).Encode(typedTmp); err != nil {
	+ log.Fatalf("Error encoding JSON: %s", err)
	+ }
	+}
	+
	+func translate(tomlData interface{}) interface{} {
	+ switch orig := tomlData.(type) {
	+ case map[string]interface{}:
	+ typed := make(map[string]interface{}, len(orig))
	+ for k, v := range orig {
	+ typed[k] = translate(v)
	+ }
	+ return typed
	+ case []map[string]interface{}:
	+ typed := make([]map[string]interface{}, len(orig))
	+ for i, v := range orig {
	+ typed[i] = translate(v).(map[string]interface{})
	+ }
	+ return typed
	+ case []interface{}:
	+ typed := make([]interface{}, len(orig))
	+ for i, v := range orig {
	+ typed[i] = translate(v)
	+ }
	+
	+ // We don't really need to tag arrays, but let's be future proof.
	+ // (If TOML ever supports tuples, we'll need this.)
	+ return tag("array", typed)
	+ case time.Time:
	+ return tag("datetime", orig.Format("2006-01-02T15:04:05Z"))
	+ case bool:
	+ return tag("bool", fmt.Sprintf("%v", orig))
	+ case int64:
	+ return tag("integer", fmt.Sprintf("%d", orig))
	+ case float64:
	+ return tag("float", fmt.Sprintf("%v", orig))
	+ case string:
	+ return tag("string", orig)
	+ }
	+
	+ panic(fmt.Sprintf("Unknown type: %T", tomlData))
	+}
	+
	+func tag(typeName string, data interface{}) map[string]interface{} {
	+ return map[string]interface{}{
	+ "type": typeName,
	+ "value": data,
	+ }
	+}
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING
	new file mode 100644
	index 0000000..01b5743
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING
	@@ -0,0 +1,21 @@
	+The MIT License (MIT)
	+
	+Copyright (c) 2013 TOML authors
	+
	+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.
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/README.md b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/README.md
	new file mode 100644
	index 0000000..a45bd4d
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/README.md
	@@ -0,0 +1,13 @@
	+# Implements the TOML test suite interface for TOML encoders
	+
	+This is an implementation of the interface expected by
	+[toml-test](https://github.com/BurntSushi/toml-test) for the
	+[TOML encoder](https://github.com/BurntSushi/toml).
	+In particular, it maps JSON data on `stdin` to a TOML format on `stdout`.
	+
	+
	+Compatible with TOML version
	+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
	+
	+Compatible with `toml-test` version
	+[v0.2.0](https://github.com/BurntSushi/toml-test/tree/v0.2.0)
	diff --git a/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/main.go b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/main.go
	new file mode 100644
	index 0000000..092cc68
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/toml-test-encoder/main.go
	@@ -0,0 +1,131 @@
	+// Command toml-test-encoder satisfies the toml-test interface for testing
	+// TOML encoders. Namely, it accepts JSON on stdin and outputs TOML on stdout.
	+package main
	+
	+import (
	+ "encoding/json"
	+ "flag"
	+ "log"
	+ "os"
	+ "path"
	+ "strconv"
	+ "time"
	+
	+ "github.com/BurntSushi/toml"
	+)
	+
	+func init() {
	+ log.SetFlags(0)
	+
	+ flag.Usage = usage
	+ flag.Parse()
	+}
	+
	+func usage() {
	+ log.Printf("Usage: %s < json-file\n", path.Base(os.Args[0]))
	+ flag.PrintDefaults()
	+
	+ os.Exit(1)
	+}
	+
	+func main() {
	+ if flag.NArg() != 0 {
	+ flag.Usage()
	+ }
	+
	+ var tmp interface{}
	+ if err := json.NewDecoder(os.Stdin).Decode(&tmp); err != nil {
	+ log.Fatalf("Error decoding JSON: %s", err)
	+ }
	+
	+ tomlData := translate(tmp)
	+ if err := toml.NewEncoder(os.Stdout).Encode(tomlData); err != nil {
	+ log.Fatalf("Error encoding TOML: %s", err)
	+ }
	+}
	+
	+func translate(typedJson interface{}) interface{} {
	+ switch v := typedJson.(type) {
	+ case map[string]interface{}:
	+ if len(v) == 2 && in("type", v) && in("value", v) {
	+ return untag(v)
	+ }
	+ m := make(map[string]interface{}, len(v))
	+ for k, v2 := range v {
	+ m[k] = translate(v2)
	+ }
	+ return m
	+ case []interface{}:
	+ tabArray := make([]map[string]interface{}, len(v))
	+ for i := range v {
	+ if m, ok := translate(v[i]).(map[string]interface{}); ok {
	+ tabArray[i] = m
	+ } else {
	+ log.Fatalf("JSON arrays may only contain objects. This " +
	+ "corresponds to only tables being allowed in " +
	+ "TOML table arrays.")
	+ }
	+ }
	+ return tabArray
	+ }
	+ log.Fatalf("Unrecognized JSON format '%T'.", typedJson)
	+ panic("unreachable")
	+}
	+
	+func untag(typed map[string]interface{}) interface{} {
	+ t := typed["type"].(string)
	+ v := typed["value"]
	+ switch t {
	+ case "string":
	+ return v.(string)
	+ case "integer":
	+ v := v.(string)
	+ n, err := strconv.Atoi(v)
	+ if err != nil {
	+ log.Fatalf("Could not parse '%s' as integer: %s", v, err)
	+ }
	+ return n
	+ case "float":
	+ v := v.(string)
	+ f, err := strconv.ParseFloat(v, 64)
	+ if err != nil {
	+ log.Fatalf("Could not parse '%s' as float64: %s", v, err)
	+ }
	+ return f
	+ case "datetime":
	+ v := v.(string)
	+ t, err := time.Parse("2006-01-02T15:04:05Z", v)
	+ if err != nil {
	+ log.Fatalf("Could not parse '%s' as a datetime: %s", v, err)
	+ }
	+ return t
	+ case "bool":
	+ v := v.(string)
	+ switch v {
	+ case "true":
	+ return true
	+ case "false":
	+ return false
	+ }
	+ log.Fatalf("Could not parse '%s' as a boolean.", v)
	+ case "array":
	+ v := v.([]interface{})
	+ array := make([]interface{}, len(v))
	+ for i := range v {
	+ if m, ok := v[i].(map[string]interface{}); ok {
	+ array[i] = untag(m)
	+ } else {
	+ log.Fatalf("Arrays may only contain other arrays or "+
	+ "primitive values, but found a '%T'.", m)
	+ }
	+ }
	+ return array
	+ }
	+ log.Fatalf("Unrecognized tag type '%s'.", t)
	+ panic("unreachable")
	+}
	+
	+func in(key string, m map[string]interface{}) bool {
	+ _, ok := m[key]
	+ return ok
	+}
	diff --git a/src/github.com/BurntSushi/toml/cmd/tomlv/COPYING b/src/github.com/BurntSushi/toml/cmd/tomlv/COPYING
	new file mode 100644
	index 0000000..01b5743
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/tomlv/COPYING
	@@ -0,0 +1,21 @@
	+The MIT License (MIT)
	+
	+Copyright (c) 2013 TOML authors
	+
	+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.
	diff --git a/src/github.com/BurntSushi/toml/cmd/tomlv/README.md b/src/github.com/BurntSushi/toml/cmd/tomlv/README.md
	new file mode 100644
	index 0000000..51231e2
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/tomlv/README.md
	@@ -0,0 +1,21 @@
	+# TOML Validator
	+
	+If Go is installed, it's simple to try it out:
	+
	+```bash
	+go get github.com/BurntSushi/toml/cmd/tomlv
	+tomlv some-toml-file.toml
	+```
	+
	+You can see the types of every key in a TOML file with:
	+
	+```bash
	+tomlv -types some-toml-file.toml
	+```
	+
	+At the moment, only one error message is reported at a time. Error messages
	+include line numbers. No output means that the files given are valid TOML, or
	+there is a bug in `tomlv`.
	+
	+Compatible with TOML version
	+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
	diff --git a/src/github.com/BurntSushi/toml/cmd/tomlv/main.go b/src/github.com/BurntSushi/toml/cmd/tomlv/main.go
	new file mode 100644
	index 0000000..c7d689a
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/cmd/tomlv/main.go
	@@ -0,0 +1,61 @@
	+// Command tomlv validates TOML documents and prints each key's type.
	+package main
	+
	+import (
	+ "flag"
	+ "fmt"
	+ "log"
	+ "os"
	+ "path"
	+ "strings"
	+ "text/tabwriter"
	+
	+ "github.com/BurntSushi/toml"
	+)
	+
	+var (
	+ flagTypes = false
	+)
	+
	+func init() {
	+ log.SetFlags(0)
	+
	+ flag.BoolVar(&flagTypes, "types", flagTypes,
	+ "When set, the types of every defined key will be shown.")
	+
	+ flag.Usage = usage
	+ flag.Parse()
	+}
	+
	+func usage() {
	+ log.Printf("Usage: %s toml-file [ toml-file ... ]\n",
	+ path.Base(os.Args[0]))
	+ flag.PrintDefaults()
	+
	+ os.Exit(1)
	+}
	+
	+func main() {
	+ if flag.NArg() < 1 {
	+ flag.Usage()
	+ }
	+ for _, f := range flag.Args() {
	+ var tmp interface{}
	+ md, err := toml.DecodeFile(f, &tmp)
	+ if err != nil {
	+ log.Fatalf("Error in '%s': %s", f, err)
	+ }
	+ if flagTypes {
	+ printTypes(md)
	+ }
	+ }
	+}
	+
	+func printTypes(md toml.MetaData) {
	+ tabw := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
	+ for _, key := range md.Keys() {
	+ fmt.Fprintf(tabw, "%s%s\t%s\n",
	+ strings.Repeat(" ", len(key)-1), key, md.Type(key...))
	+ }
	+ tabw.Flush()
	+}
	diff --git a/src/github.com/BurntSushi/toml/decode.go b/src/github.com/BurntSushi/toml/decode.go
	new file mode 100644
	index 0000000..b0fd51d
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/decode.go
	@@ -0,0 +1,509 @@
	+package toml
	+
	+import (
	+ "fmt"
	+ "io"
	+ "io/ioutil"
	+ "math"
	+ "reflect"
	+ "strings"
	+ "time"
	+)
	+
	+func e(format string, args ...interface{}) error {
	+ return fmt.Errorf("toml: "+format, args...)
	+}
	+
	+// Unmarshaler is the interface implemented by objects that can unmarshal a
	+// TOML description of themselves.
	+type Unmarshaler interface {
	+ UnmarshalTOML(interface{}) error
	+}
	+
	+// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
	+func Unmarshal(p []byte, v interface{}) error {
	+ _, err := Decode(string(p), v)
	+ return err
	+}
	+
	+// Primitive is a TOML value that hasn't been decoded into a Go value.
	+// When using the various `Decode*` functions, the type `Primitive` may
	+// be given to any value, and its decoding will be delayed.
	+//
	+// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
	+//
	+// The underlying representation of a `Primitive` value is subject to change.
	+// Do not rely on it.
	+//
	+// N.B. Primitive values are still parsed, so using them will only avoid
	+// the overhead of reflection. They can be useful when you don't know the
	+// exact type of TOML data until run time.
	+type Primitive struct {
	+ undecoded interface{}
	+ context Key
	+}
	+
	+// DEPRECATED!
	+//
	+// Use MetaData.PrimitiveDecode instead.
	+func PrimitiveDecode(primValue Primitive, v interface{}) error {
	+ md := MetaData{decoded: make(map[string]bool)}
	+ return md.unify(primValue.undecoded, rvalue(v))
	+}
	+
	+// PrimitiveDecode is just like the other `Decode*` functions, except it
	+// decodes a TOML value that has already been parsed. Valid primitive values
	+// can only be obtained from values filled by the decoder functions,
	+// including this method. (i.e., `v` may contain more `Primitive`
	+// values.)
	+//
	+// Meta data for primitive values is included in the meta data returned by
	+// the `Decode*` functions with one exception: keys returned by the Undecoded
	+// method will only reflect keys that were decoded. Namely, any keys hidden
	+// behind a Primitive will be considered undecoded. Executing this method will
	+// update the undecoded keys in the meta data. (See the example.)
	+func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
	+ md.context = primValue.context
	+ defer func() { md.context = nil }()
	+ return md.unify(primValue.undecoded, rvalue(v))
	+}
	+
	+// Decode will decode the contents of `data` in TOML format into a pointer
	+// `v`.
	+//
	+// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
	+// used interchangeably.)
	+//
	+// TOML arrays of tables correspond to either a slice of structs or a slice
	+// of maps.
	+//
	+// TOML datetimes correspond to Go `time.Time` values.
	+//
	+// All other TOML types (float, string, int, bool and array) correspond
	+// to the obvious Go types.
	+//
	+// An exception to the above rules is if a type implements the
	+// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
	+// (floats, strings, integers, booleans and datetimes) will be converted to
	+// a byte string and given to the value's UnmarshalText method. See the
	+// Unmarshaler example for a demonstration with time duration strings.
	+//
	+// Key mapping
	+//
	+// TOML keys can map to either keys in a Go map or field names in a Go
	+// struct. The special `toml` struct tag may be used to map TOML keys to
	+// struct fields that don't match the key name exactly. (See the example.)
	+// A case insensitive match to struct names will be tried if an exact match
	+// can't be found.
	+//
	+// The mapping between TOML values and Go values is loose. That is, there
	+// may exist TOML values that cannot be placed into your representation, and
	+// there may be parts of your representation that do not correspond to
	+// TOML values. This loose mapping can be made stricter by using the IsDefined
	+// and/or Undecoded methods on the MetaData returned.
	+//
	+// This decoder will not handle cyclic types. If a cyclic type is passed,
	+// `Decode` will not terminate.
	+func Decode(data string, v interface{}) (MetaData, error) {
	+ rv := reflect.ValueOf(v)
	+ if rv.Kind() != reflect.Ptr {
	+ return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
	+ }
	+ if rv.IsNil() {
	+ return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
	+ }
	+ p, err := parse(data)
	+ if err != nil {
	+ return MetaData{}, err
	+ }
	+ md := MetaData{
	+ p.mapping, p.types, p.ordered,
	+ make(map[string]bool, len(p.ordered)), nil,
	+ }
	+ return md, md.unify(p.mapping, indirect(rv))
	+}
	+
	+// DecodeFile is just like Decode, except it will automatically read the
	+// contents of the file at `fpath` and decode it for you.
	+func DecodeFile(fpath string, v interface{}) (MetaData, error) {
	+ bs, err := ioutil.ReadFile(fpath)
	+ if err != nil {
	+ return MetaData{}, err
	+ }
	+ return Decode(string(bs), v)
	+}
	+
	+// DecodeReader is just like Decode, except it will consume all bytes
	+// from the reader and decode it for you.
	+func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
	+ bs, err := ioutil.ReadAll(r)
	+ if err != nil {
	+ return MetaData{}, err
	+ }
	+ return Decode(string(bs), v)
	+}
	+
	+// unify performs a sort of type unification based on the structure of `rv`,
	+// which is the client representation.
	+//
	+// Any type mismatch produces an error. Finding a type that we don't know
	+// how to handle produces an unsupported type error.
	+func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
	+
	+ // Special case. Look for a `Primitive` value.
	+ if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
	+ // Save the undecoded data and the key context into the primitive
	+ // value.
	+ context := make(Key, len(md.context))
	+ copy(context, md.context)
	+ rv.Set(reflect.ValueOf(Primitive{
	+ undecoded: data,
	+ context: context,
	+ }))
	+ return nil
	+ }
	+
	+ // Special case. Unmarshaler Interface support.
	+ if rv.CanAddr() {
	+ if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
	+ return v.UnmarshalTOML(data)
	+ }
	+ }
	+
	+ // Special case. Handle time.Time values specifically.
	+ // TODO: Remove this code when we decide to drop support for Go 1.1.
	+ // This isn't necessary in Go 1.2 because time.Time satisfies the encoding
	+ // interfaces.
	+ if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
	+ return md.unifyDatetime(data, rv)
	+ }
	+
	+ // Special case. Look for a value satisfying the TextUnmarshaler interface.
	+ if v, ok := rv.Interface().(TextUnmarshaler); ok {
	+ return md.unifyText(data, v)
	+ }
	+ // BUG(burntsushi)
	+ // The behavior here is incorrect whenever a Go type satisfies the
	+ // encoding.TextUnmarshaler interface but also corresponds to a TOML
	+ // hash or array. In particular, the unmarshaler should only be applied
	+ // to primitive TOML values. But at this point, it will be applied to
	+ // all kinds of values and produce an incorrect error whenever those values
	+ // are hashes or arrays (including arrays of tables).
	+
	+ k := rv.Kind()
	+
	+ // laziness
	+ if k >= reflect.Int && k <= reflect.Uint64 {
	+ return md.unifyInt(data, rv)
	+ }
	+ switch k {
	+ case reflect.Ptr:
	+ elem := reflect.New(rv.Type().Elem())
	+ err := md.unify(data, reflect.Indirect(elem))
	+ if err != nil {
	+ return err
	+ }
	+ rv.Set(elem)
	+ return nil
	+ case reflect.Struct:
	+ return md.unifyStruct(data, rv)
	+ case reflect.Map:
	+ return md.unifyMap(data, rv)
	+ case reflect.Array:
	+ return md.unifyArray(data, rv)
	+ case reflect.Slice:
	+ return md.unifySlice(data, rv)
	+ case reflect.String:
	+ return md.unifyString(data, rv)
	+ case reflect.Bool:
	+ return md.unifyBool(data, rv)
	+ case reflect.Interface:
	+ // we only support empty interfaces.
	+ if rv.NumMethod() > 0 {
	+ return e("unsupported type %s", rv.Type())
	+ }
	+ return md.unifyAnything(data, rv)
	+ case reflect.Float32:
	+ fallthrough
	+ case reflect.Float64:
	+ return md.unifyFloat64(data, rv)
	+ }
	+ return e("unsupported type %s", rv.Kind())
	+}
	+
	+func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
	+ tmap, ok := mapping.(map[string]interface{})
	+ if !ok {
	+ if mapping == nil {
	+ return nil
	+ }
	+ return e("type mismatch for %s: expected table but found %T",
	+ rv.Type().String(), mapping)
	+ }
	+
	+ for key, datum := range tmap {
	+ var f *field
	+ fields := cachedTypeFields(rv.Type())
	+ for i := range fields {
	+ ff := &fields[i]
	+ if ff.name == key {
	+ f = ff
	+ break
	+ }
	+ if f == nil && strings.EqualFold(ff.name, key) {
	+ f = ff
	+ }
	+ }
	+ if f != nil {
	+ subv := rv
	+ for _, i := range f.index {
	+ subv = indirect(subv.Field(i))
	+ }
	+ if isUnifiable(subv) {
	+ md.decoded[md.context.add(key).String()] = true
	+ md.context = append(md.context, key)
	+ if err := md.unify(datum, subv); err != nil {
	+ return err
	+ }
	+ md.context = md.context[0 : len(md.context)-1]
	+ } else if f.name != "" {
	+ // Bad user! No soup for you!
	+ return e("cannot write unexported field %s.%s",
	+ rv.Type().String(), f.name)
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
	+ tmap, ok := mapping.(map[string]interface{})
	+ if !ok {
	+ if tmap == nil {
	+ return nil
	+ }
	+ return badtype("map", mapping)
	+ }
	+ if rv.IsNil() {
	+ rv.Set(reflect.MakeMap(rv.Type()))
	+ }
	+ for k, v := range tmap {
	+ md.decoded[md.context.add(k).String()] = true
	+ md.context = append(md.context, k)
	+
	+ rvkey := indirect(reflect.New(rv.Type().Key()))
	+ rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
	+ if err := md.unify(v, rvval); err != nil {
	+ return err
	+ }
	+ md.context = md.context[0 : len(md.context)-1]
	+
	+ rvkey.SetString(k)
	+ rv.SetMapIndex(rvkey, rvval)
	+ }
	+ return nil
	+}
	+
	+func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
	+ datav := reflect.ValueOf(data)
	+ if datav.Kind() != reflect.Slice {
	+ if !datav.IsValid() {
	+ return nil
	+ }
	+ return badtype("slice", data)
	+ }
	+ sliceLen := datav.Len()
	+ if sliceLen != rv.Len() {
	+ return e("expected array length %d; got TOML array of length %d",
	+ rv.Len(), sliceLen)
	+ }
	+ return md.unifySliceArray(datav, rv)
	+}
	+
	+func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
	+ datav := reflect.ValueOf(data)
	+ if datav.Kind() != reflect.Slice {
	+ if !datav.IsValid() {
	+ return nil
	+ }
	+ return badtype("slice", data)
	+ }
	+ n := datav.Len()
	+ if rv.IsNil() \|\| rv.Cap() < n {
	+ rv.Set(reflect.MakeSlice(rv.Type(), n, n))
	+ }
	+ rv.SetLen(n)
	+ return md.unifySliceArray(datav, rv)
	+}
	+
	+func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
	+ sliceLen := data.Len()
	+ for i := 0; i < sliceLen; i++ {
	+ v := data.Index(i).Interface()
	+ sliceval := indirect(rv.Index(i))
	+ if err := md.unify(v, sliceval); err != nil {
	+ return err
	+ }
	+ }
	+ return nil
	+}
	+
	+func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
	+ if _, ok := data.(time.Time); ok {
	+ rv.Set(reflect.ValueOf(data))
	+ return nil
	+ }
	+ return badtype("time.Time", data)
	+}
	+
	+func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
	+ if s, ok := data.(string); ok {
	+ rv.SetString(s)
	+ return nil
	+ }
	+ return badtype("string", data)
	+}
	+
	+func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
	+ if num, ok := data.(float64); ok {
	+ switch rv.Kind() {
	+ case reflect.Float32:
	+ fallthrough
	+ case reflect.Float64:
	+ rv.SetFloat(num)
	+ default:
	+ panic("bug")
	+ }
	+ return nil
	+ }
	+ return badtype("float", data)
	+}
	+
	+func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
	+ if num, ok := data.(int64); ok {
	+ if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
	+ switch rv.Kind() {
	+ case reflect.Int, reflect.Int64:
	+ // No bounds checking necessary.
	+ case reflect.Int8:
	+ if num < math.MinInt8 \|\| num > math.MaxInt8 {
	+ return e("value %d is out of range for int8", num)
	+ }
	+ case reflect.Int16:
	+ if num < math.MinInt16 \|\| num > math.MaxInt16 {
	+ return e("value %d is out of range for int16", num)
	+ }
	+ case reflect.Int32:
	+ if num < math.MinInt32 \|\| num > math.MaxInt32 {
	+ return e("value %d is out of range for int32", num)
	+ }
	+ }
	+ rv.SetInt(num)
	+ } else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
	+ unum := uint64(num)
	+ switch rv.Kind() {
	+ case reflect.Uint, reflect.Uint64:
	+ // No bounds checking necessary.
	+ case reflect.Uint8:
	+ if num < 0 \|\| unum > math.MaxUint8 {
	+ return e("value %d is out of range for uint8", num)
	+ }
	+ case reflect.Uint16:
	+ if num < 0 \|\| unum > math.MaxUint16 {
	+ return e("value %d is out of range for uint16", num)
	+ }
	+ case reflect.Uint32:
	+ if num < 0 \|\| unum > math.MaxUint32 {
	+ return e("value %d is out of range for uint32", num)
	+ }
	+ }
	+ rv.SetUint(unum)
	+ } else {
	+ panic("unreachable")
	+ }
	+ return nil
	+ }
	+ return badtype("integer", data)
	+}
	+
	+func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
	+ if b, ok := data.(bool); ok {
	+ rv.SetBool(b)
	+ return nil
	+ }
	+ return badtype("boolean", data)
	+}
	+
	+func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
	+ rv.Set(reflect.ValueOf(data))
	+ return nil
	+}
	+
	+func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
	+ var s string
	+ switch sdata := data.(type) {
	+ case TextMarshaler:
	+ text, err := sdata.MarshalText()
	+ if err != nil {
	+ return err
	+ }
	+ s = string(text)
	+ case fmt.Stringer:
	+ s = sdata.String()
	+ case string:
	+ s = sdata
	+ case bool:
	+ s = fmt.Sprintf("%v", sdata)
	+ case int64:
	+ s = fmt.Sprintf("%d", sdata)
	+ case float64:
	+ s = fmt.Sprintf("%f", sdata)
	+ default:
	+ return badtype("primitive (string-like)", data)
	+ }
	+ if err := v.UnmarshalText([]byte(s)); err != nil {
	+ return err
	+ }
	+ return nil
	+}
	+
	+// rvalue returns a reflect.Value of `v`. All pointers are resolved.
	+func rvalue(v interface{}) reflect.Value {
	+ return indirect(reflect.ValueOf(v))
	+}
	+
	+// indirect returns the value pointed to by a pointer.
	+// Pointers are followed until the value is not a pointer.
	+// New values are allocated for each nil pointer.
	+//
	+// An exception to this rule is if the value satisfies an interface of
	+// interest to us (like encoding.TextUnmarshaler).
	+func indirect(v reflect.Value) reflect.Value {
	+ if v.Kind() != reflect.Ptr {
	+ if v.CanSet() {
	+ pv := v.Addr()
	+ if _, ok := pv.Interface().(TextUnmarshaler); ok {
	+ return pv
	+ }
	+ }
	+ return v
	+ }
	+ if v.IsNil() {
	+ v.Set(reflect.New(v.Type().Elem()))
	+ }
	+ return indirect(reflect.Indirect(v))
	+}
	+
	+func isUnifiable(rv reflect.Value) bool {
	+ if rv.CanSet() {
	+ return true
	+ }
	+ if _, ok := rv.Interface().(TextUnmarshaler); ok {
	+ return true
	+ }
	+ return false
	+}
	+
	+func badtype(expected string, data interface{}) error {
	+ return e("cannot load TOML value of type %T into a Go %s", data, expected)
	+}
	diff --git a/src/github.com/BurntSushi/toml/decode_meta.go b/src/github.com/BurntSushi/toml/decode_meta.go
	new file mode 100644
	index 0000000..b9914a6
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/decode_meta.go
	@@ -0,0 +1,121 @@
	+package toml
	+
	+import "strings"
	+
	+// MetaData allows access to meta information about TOML data that may not
	+// be inferrable via reflection. In particular, whether a key has been defined
	+// and the TOML type of a key.
	+type MetaData struct {
	+ mapping map[string]interface{}
	+ types map[string]tomlType
	+ keys []Key
	+ decoded map[string]bool
	+ context Key // Used only during decoding.
	+}
	+
	+// IsDefined returns true if the key given exists in the TOML data. The key
	+// should be specified hierarchially. e.g.,
	+//
	+// // access the TOML key 'a.b.c'
	+// IsDefined("a", "b", "c")
	+//
	+// IsDefined will return false if an empty key given. Keys are case sensitive.
	+func (md *MetaData) IsDefined(key ...string) bool {
	+ if len(key) == 0 {
	+ return false
	+ }
	+
	+ var hash map[string]interface{}
	+ var ok bool
	+ var hashOrVal interface{} = md.mapping
	+ for _, k := range key {
	+ if hash, ok = hashOrVal.(map[string]interface{}); !ok {
	+ return false
	+ }
	+ if hashOrVal, ok = hash[k]; !ok {
	+ return false
	+ }
	+ }
	+ return true
	+}
	+
	+// Type returns a string representation of the type of the key specified.
	+//
	+// Type will return the empty string if given an empty key or a key that
	+// does not exist. Keys are case sensitive.
	+func (md *MetaData) Type(key ...string) string {
	+ fullkey := strings.Join(key, ".")
	+ if typ, ok := md.types[fullkey]; ok {
	+ return typ.typeString()
	+ }
	+ return ""
	+}
	+
	+// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
	+// to get values of this type.
	+type Key []string
	+
	+func (k Key) String() string {
	+ return strings.Join(k, ".")
	+}
	+
	+func (k Key) maybeQuotedAll() string {
	+ var ss []string
	+ for i := range k {
	+ ss = append(ss, k.maybeQuoted(i))
	+ }
	+ return strings.Join(ss, ".")
	+}
	+
	+func (k Key) maybeQuoted(i int) string {
	+ quote := false
	+ for _, c := range k[i] {
	+ if !isBareKeyChar(c) {
	+ quote = true
	+ break
	+ }
	+ }
	+ if quote {
	+ return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
	+ }
	+ return k[i]
	+}
	+
	+func (k Key) add(piece string) Key {
	+ newKey := make(Key, len(k)+1)
	+ copy(newKey, k)
	+ newKey[len(k)] = piece
	+ return newKey
	+}
	+
	+// Keys returns a slice of every key in the TOML data, including key groups.
	+// Each key is itself a slice, where the first element is the top of the
	+// hierarchy and the last is the most specific.
	+//
	+// The list will have the same order as the keys appeared in the TOML data.
	+//
	+// All keys returned are non-empty.
	+func (md *MetaData) Keys() []Key {
	+ return md.keys
	+}
	+
	+// Undecoded returns all keys that have not been decoded in the order in which
	+// they appear in the original TOML document.
	+//
	+// This includes keys that haven't been decoded because of a Primitive value.
	+// Once the Primitive value is decoded, the keys will be considered decoded.
	+//
	+// Also note that decoding into an empty interface will result in no decoding,
	+// and so no keys will be considered decoded.
	+//
	+// In this sense, the Undecoded keys correspond to keys in the TOML document
	+// that do not have a concrete type in your representation.
	+func (md *MetaData) Undecoded() []Key {
	+ undecoded := make([]Key, 0, len(md.keys))
	+ for _, key := range md.keys {
	+ if !md.decoded[key.String()] {
	+ undecoded = append(undecoded, key)
	+ }
	+ }
	+ return undecoded
	+}
	diff --git a/src/github.com/BurntSushi/toml/decode_test.go b/src/github.com/BurntSushi/toml/decode_test.go
	new file mode 100644
	index 0000000..95bc987
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/decode_test.go
	@@ -0,0 +1,1461 @@
	+package toml
	+
	+import (
	+ "fmt"
	+ "log"
	+ "math"
	+ "reflect"
	+ "strings"
	+ "testing"
	+ "time"
	+)
	+
	+func TestDecodeSimple(t *testing.T) {
	+ var testSimple = `
	+age = 250
	+andrew = "gallant"
	+kait = "brady"
	+now = 1987-07-05T05:45:00Z
	+nowEast = 2017-06-22T16:15:21+08:00
	+nowWest = 2017-06-22T02:14:36-06:00
	+yesOrNo = true
	+pi = 3.14
	+colors = [
	+ ["red", "green", "blue"],
	+ ["cyan", "magenta", "yellow", "black"],
	+]
	+
	+[My.Cats]
	+plato = "cat 1"
	+cauchy = "cat 2"
	+`
	+
	+ type cats struct {
	+ Plato string
	+ Cauchy string
	+ }
	+ type simple struct {
	+ Age int
	+ Colors [][]string
	+ Pi float64
	+ YesOrNo bool
	+ Now time.Time
	+ NowEast time.Time
	+ NowWest time.Time
	+ Andrew string
	+ Kait string
	+ My map[string]cats
	+ }
	+
	+ var val simple
	+ _, err := Decode(testSimple, &val)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ now, err := time.Parse("2006-01-02T15:04:05", "1987-07-05T05:45:00")
	+ if err != nil {
	+ panic(err)
	+ }
	+ nowEast, err := time.Parse("2006-01-02T15:04:05-07:00", "2017-06-22T16:15:21+08:00")
	+ if err != nil {
	+ panic(err)
	+ }
	+ nowWest, err := time.Parse("2006-01-02T15:04:05-07:00", "2017-06-22T02:14:36-06:00")
	+ if err != nil {
	+ panic(err)
	+ }
	+ var answer = simple{
	+ Age: 250,
	+ Andrew: "gallant",
	+ Kait: "brady",
	+ Now: now,
	+ NowEast: nowEast,
	+ NowWest: nowWest,
	+ YesOrNo: true,
	+ Pi: 3.14,
	+ Colors: [][]string{
	+ {"red", "green", "blue"},
	+ {"cyan", "magenta", "yellow", "black"},
	+ },
	+ My: map[string]cats{
	+ "Cats": {Plato: "cat 1", Cauchy: "cat 2"},
	+ },
	+ }
	+ if !reflect.DeepEqual(val, answer) {
	+ t.Fatalf("Expected\n-----\n%#v\n-----\nbut got\n-----\n%#v\n",
	+ answer, val)
	+ }
	+}
	+
	+func TestDecodeEmbedded(t *testing.T) {
	+ type Dog struct{ Name string }
	+ type Age int
	+ type cat struct{ Name string }
	+
	+ for _, test := range []struct {
	+ label string
	+ input string
	+ decodeInto interface{}
	+ wantDecoded interface{}
	+ }{
	+ {
	+ label: "embedded struct",
	+ input: `Name = "milton"`,
	+ decodeInto: &struct{ Dog }{},
	+ wantDecoded: &struct{ Dog }{Dog{"milton"}},
	+ },
	+ {
	+ label: "embedded non-nil pointer to struct",
	+ input: `Name = "milton"`,
	+ decodeInto: &struct{ *Dog }{},
	+ wantDecoded: &struct{ *Dog }{&Dog{"milton"}},
	+ },
	+ {
	+ label: "embedded nil pointer to struct",
	+ input: ``,
	+ decodeInto: &struct{ *Dog }{},
	+ wantDecoded: &struct{ *Dog }{nil},
	+ },
	+ {
	+ label: "unexported embedded struct",
	+ input: `Name = "socks"`,
	+ decodeInto: &struct{ cat }{},
	+ wantDecoded: &struct{ cat }{cat{"socks"}},
	+ },
	+ {
	+ label: "embedded int",
	+ input: `Age = -5`,
	+ decodeInto: &struct{ Age }{},
	+ wantDecoded: &struct{ Age }{-5},
	+ },
	+ } {
	+ _, err := Decode(test.input, test.decodeInto)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ if !reflect.DeepEqual(test.wantDecoded, test.decodeInto) {
	+ t.Errorf("%s: want decoded == %+v, got %+v",
	+ test.label, test.wantDecoded, test.decodeInto)
	+ }
	+ }
	+}
	+
	+func TestDecodeIgnoredFields(t *testing.T) {
	+ type simple struct {
	+ Number int `toml:"-"`
	+ }
	+ const input = `
	+Number = 123
	+- = 234
	+`
	+ var s simple
	+ if _, err := Decode(input, &s); err != nil {
	+ t.Fatal(err)
	+ }
	+ if s.Number != 0 {
	+ t.Errorf("got: %d; want 0", s.Number)
	+ }
	+}
	+
	+func TestTableArrays(t *testing.T) {
	+ var tomlTableArrays = `
	+[[albums]]
	+name = "Born to Run"
	+
	+ [[albums.songs]]
	+ name = "Jungleland"
	+
	+ [[albums.songs]]
	+ name = "Meeting Across the River"
	+
	+[[albums]]
	+name = "Born in the USA"
	+
	+ [[albums.songs]]
	+ name = "Glory Days"
	+
	+ [[albums.songs]]
	+ name = "Dancing in the Dark"
	+`
	+
	+ type Song struct {
	+ Name string
	+ }
	+
	+ type Album struct {
	+ Name string
	+ Songs []Song
	+ }
	+
	+ type Music struct {
	+ Albums []Album
	+ }
	+
	+ expected := Music{[]Album{
	+ {"Born to Run", []Song{{"Jungleland"}, {"Meeting Across the River"}}},
	+ {"Born in the USA", []Song{{"Glory Days"}, {"Dancing in the Dark"}}},
	+ }}
	+ var got Music
	+ if _, err := Decode(tomlTableArrays, &got); err != nil {
	+ t.Fatal(err)
	+ }
	+ if !reflect.DeepEqual(expected, got) {
	+ t.Fatalf("\n%#v\n!=\n%#v\n", expected, got)
	+ }
	+}
	+
	+func TestTableNesting(t *testing.T) {
	+ for _, tt := range []struct {
	+ t string
	+ want []string
	+ }{
	+ {"[a.b.c]", []string{"a", "b", "c"}},
	+ {`[a."b.c"]`, []string{"a", "b.c"}},
	+ {`[a.'b.c']`, []string{"a", "b.c"}},
	+ {`[a.' b ']`, []string{"a", " b "}},
	+ {"[ d.e.f ]", []string{"d", "e", "f"}},
	+ {"[ g . h . i ]", []string{"g", "h", "i"}},
	+ {`[ j . "ʞ" . 'l' ]`, []string{"j", "ʞ", "l"}},
	+ } {
	+ var m map[string]interface{}
	+ if _, err := Decode(tt.t, &m); err != nil {
	+ t.Errorf("Decode(%q): got error: %s", tt.t, err)
	+ continue
	+ }
	+ if keys := extractNestedKeys(m); !reflect.DeepEqual(keys, tt.want) {
	+ t.Errorf("Decode(%q): got nested keys %#v; want %#v",
	+ tt.t, keys, tt.want)
	+ }
	+ }
	+}
	+
	+func extractNestedKeys(v map[string]interface{}) []string {
	+ var result []string
	+ for {
	+ if len(v) != 1 {
	+ return result
	+ }
	+ for k, m := range v {
	+ result = append(result, k)
	+ var ok bool
	+ v, ok = m.(map[string]interface{})
	+ if !ok {
	+ return result
	+ }
	+ }
	+
	+ }
	+}
	+
	+// Case insensitive matching tests.
	+// A bit more comprehensive than needed given the current implementation,
	+// but implementations change.
	+// Probably still missing demonstrations of some ugly corner cases regarding
	+// case insensitive matching and multiple fields.
	+func TestCase(t *testing.T) {
	+ var caseToml = `
	+tOpString = "string"
	+tOpInt = 1
	+tOpFloat = 1.1
	+tOpBool = true
	+tOpdate = 2006-01-02T15:04:05Z
	+tOparray = [ "array" ]
	+Match = "i should be in Match only"
	+MatcH = "i should be in MatcH only"
	+once = "just once"
	+[nEst.eD]
	+nEstedString = "another string"
	+`
	+
	+ type InsensitiveEd struct {
	+ NestedString string
	+ }
	+
	+ type InsensitiveNest struct {
	+ Ed InsensitiveEd
	+ }
	+
	+ type Insensitive struct {
	+ TopString string
	+ TopInt int
	+ TopFloat float64
	+ TopBool bool
	+ TopDate time.Time
	+ TopArray []string
	+ Match string
	+ MatcH string
	+ Once string
	+ OncE string
	+ Nest InsensitiveNest
	+ }
	+
	+ tme, err := time.Parse(time.RFC3339, time.RFC3339[:len(time.RFC3339)-5])
	+ if err != nil {
	+ panic(err)
	+ }
	+ expected := Insensitive{
	+ TopString: "string",
	+ TopInt: 1,
	+ TopFloat: 1.1,
	+ TopBool: true,
	+ TopDate: tme,
	+ TopArray: []string{"array"},
	+ MatcH: "i should be in MatcH only",
	+ Match: "i should be in Match only",
	+ Once: "just once",
	+ OncE: "",
	+ Nest: InsensitiveNest{
	+ Ed: InsensitiveEd{NestedString: "another string"},
	+ },
	+ }
	+ var got Insensitive
	+ if _, err := Decode(caseToml, &got); err != nil {
	+ t.Fatal(err)
	+ }
	+ if !reflect.DeepEqual(expected, got) {
	+ t.Fatalf("\n%#v\n!=\n%#v\n", expected, got)
	+ }
	+}
	+
	+func TestPointers(t *testing.T) {
	+ type Object struct {
	+ Type string
	+ Description string
	+ }
	+
	+ type Dict struct {
	+ NamedObject map[string]*Object
	+ BaseObject *Object
	+ Strptr *string
	+ Strptrs []*string
	+ }
	+ s1, s2, s3 := "blah", "abc", "def"
	+ expected := &Dict{
	+ Strptr: &s1,
	+ Strptrs: []*string{&s2, &s3},
	+ NamedObject: map[string]*Object{
	+ "foo": {"FOO", "fooooo!!!"},
	+ "bar": {"BAR", "ba-ba-ba-ba-barrrr!!!"},
	+ },
	+ BaseObject: &Object{"BASE", "da base"},
	+ }
	+
	+ ex1 := `
	+Strptr = "blah"
	+Strptrs = ["abc", "def"]
	+
	+[NamedObject.foo]
	+Type = "FOO"
	+Description = "fooooo!!!"
	+
	+[NamedObject.bar]
	+Type = "BAR"
	+Description = "ba-ba-ba-ba-barrrr!!!"
	+
	+[BaseObject]
	+Type = "BASE"
	+Description = "da base"
	+`
	+ dict := new(Dict)
	+ _, err := Decode(ex1, dict)
	+ if err != nil {
	+ t.Errorf("Decode error: %v", err)
	+ }
	+ if !reflect.DeepEqual(expected, dict) {
	+ t.Fatalf("\n%#v\n!=\n%#v\n", expected, dict)
	+ }
	+}
	+
	+func TestDecodeDatetime(t *testing.T) {
	+ const noTimestamp = "2006-01-02T15:04:05"
	+ for _, tt := range []struct {
	+ s string
	+ t string
	+ format string
	+ }{
	+ {"1979-05-27T07:32:00Z", "1979-05-27T07:32:00Z", time.RFC3339},
	+ {"1979-05-27T00:32:00-07:00", "1979-05-27T00:32:00-07:00", time.RFC3339},
	+ {
	+ "1979-05-27T00:32:00.999999-07:00",
	+ "1979-05-27T00:32:00.999999-07:00",
	+ time.RFC3339,
	+ },
	+ {"1979-05-27T07:32:00", "1979-05-27T07:32:00", noTimestamp},
	+ {
	+ "1979-05-27T00:32:00.999999",
	+ "1979-05-27T00:32:00.999999",
	+ noTimestamp,
	+ },
	+ {"1979-05-27", "1979-05-27T00:00:00", noTimestamp},
	+ } {
	+ var x struct{ D time.Time }
	+ input := "d = " + tt.s
	+ if _, err := Decode(input, &x); err != nil {
	+ t.Errorf("Decode(%q): got error: %s", input, err)
	+ continue
	+ }
	+ want, err := time.ParseInLocation(tt.format, tt.t, time.Local)
	+ if err != nil {
	+ panic(err)
	+ }
	+ if !x.D.Equal(want) {
	+ t.Errorf("Decode(%q): got %s; want %s", input, x.D, want)
	+ }
	+ }
	+}
	+
	+func TestDecodeBadDatetime(t *testing.T) {
	+ var x struct{ T time.Time }
	+ for _, s := range []string{
	+ "123",
	+ "2006-01-50T00:00:00Z",
	+ "2006-01-30T00:00",
	+ "2006-01-30T",
	+ } {
	+ input := "T = " + s
	+ if _, err := Decode(input, &x); err == nil {
	+ t.Errorf("Expected invalid DateTime error for %q", s)
	+ }
	+ }
	+}
	+
	+func TestDecodeMultilineStrings(t *testing.T) {
	+ var x struct {
	+ S string
	+ }
	+ const s0 = `s = """
	+a b \n c
	+d e f
	+"""`
	+ if _, err := Decode(s0, &x); err != nil {
	+ t.Fatal(err)
	+ }
	+ if want := "a b \n c\nd e f\n"; x.S != want {
	+ t.Errorf("got: %q; want: %q", x.S, want)
	+ }
	+ const s1 = `s = """a b c\
	+"""`
	+ if _, err := Decode(s1, &x); err != nil {
	+ t.Fatal(err)
	+ }
	+ if want := "a b c"; x.S != want {
	+ t.Errorf("got: %q; want: %q", x.S, want)
	+ }
	+}
	+
	+type sphere struct {
	+ Center [3]float64
	+ Radius float64
	+}
	+
	+func TestDecodeSimpleArray(t *testing.T) {
	+ var s1 sphere
	+ if _, err := Decode(`center = [0.0, 1.5, 0.0]`, &s1); err != nil {
	+ t.Fatal(err)
	+ }
	+}
	+
	+func TestDecodeArrayWrongSize(t *testing.T) {
	+ var s1 sphere
	+ if _, err := Decode(`center = [0.1, 2.3]`, &s1); err == nil {
	+ t.Fatal("Expected array type mismatch error")
	+ }
	+}
	+
	+func TestDecodeLargeIntoSmallInt(t *testing.T) {
	+ type table struct {
	+ Value int8
	+ }
	+ var tab table
	+ if _, err := Decode(`value = 500`, &tab); err == nil {
	+ t.Fatal("Expected integer out-of-bounds error.")
	+ }
	+}
	+
	+func TestDecodeSizedInts(t *testing.T) {
	+ type table struct {
	+ U8 uint8
	+ U16 uint16
	+ U32 uint32
	+ U64 uint64
	+ U uint
	+ I8 int8
	+ I16 int16
	+ I32 int32
	+ I64 int64
	+ I int
	+ }
	+ answer := table{1, 1, 1, 1, 1, -1, -1, -1, -1, -1}
	+ toml := `
	+ u8 = 1
	+ u16 = 1
	+ u32 = 1
	+ u64 = 1
	+ u = 1
	+ i8 = -1
	+ i16 = -1
	+ i32 = -1
	+ i64 = -1
	+ i = -1
	+ `
	+ var tab table
	+ if _, err := Decode(toml, &tab); err != nil {
	+ t.Fatal(err.Error())
	+ }
	+ if answer != tab {
	+ t.Fatalf("Expected %#v but got %#v", answer, tab)
	+ }
	+}
	+
	+func TestDecodeInts(t *testing.T) {
	+ for _, tt := range []struct {
	+ s string
	+ want int64
	+ }{
	+ {"0", 0},
	+ {"+99", 99},
	+ {"-10", -10},
	+ {"1_234_567", 1234567},
	+ {"1_2_3_4", 1234},
	+ {"-9_223_372_036_854_775_808", math.MinInt64},
	+ {"9_223_372_036_854_775_807", math.MaxInt64},
	+ } {
	+ var x struct{ N int64 }
	+ input := "n = " + tt.s
	+ if _, err := Decode(input, &x); err != nil {
	+ t.Errorf("Decode(%q): got error: %s", input, err)
	+ continue
	+ }
	+ if x.N != tt.want {
	+ t.Errorf("Decode(%q): got %d; want %d", input, x.N, tt.want)
	+ }
	+ }
	+}
	+
	+func TestDecodeFloats(t *testing.T) {
	+ for _, tt := range []struct {
	+ s string
	+ want float64
	+ }{
	+ {"+1.0", 1},
	+ {"3.1415", 3.1415},
	+ {"-0.01", -0.01},
	+ {"5e+22", 5e22},
	+ {"1e6", 1e6},
	+ {"-2E-2", -2e-2},
	+ {"6.626e-34", 6.626e-34},
	+ {"9_224_617.445_991_228_313", 9224617.445991228313},
	+ {"9_876.54_32e1_0", 9876.5432e10},
	+ } {
	+ var x struct{ N float64 }
	+ input := "n = " + tt.s
	+ if _, err := Decode(input, &x); err != nil {
	+ t.Errorf("Decode(%q): got error: %s", input, err)
	+ continue
	+ }
	+ if x.N != tt.want {
	+ t.Errorf("Decode(%q): got %f; want %f", input, x.N, tt.want)
	+ }
	+ }
	+}
	+
	+func TestDecodeMalformedNumbers(t *testing.T) {
	+ for _, tt := range []struct {
	+ s string
	+ want string
	+ }{
	+ {"++99", "expected a digit"},
	+ {"0..1", "must be followed by one or more digits"},
	+ {"0.1.2", "Invalid float value"},
	+ {"1e2.3", "Invalid float value"},
	+ {"1e2e3", "Invalid float value"},
	+ {"_123", "expected value"},
	+ {"123_", "surrounded by digits"},
	+ {"1._23", "surrounded by digits"},
	+ {"1e__23", "surrounded by digits"},
	+ {"123.", "must be followed by one or more digits"},
	+ {"1.e2", "must be followed by one or more digits"},
	+ } {
	+ var x struct{ N interface{} }
	+ input := "n = " + tt.s
	+ _, err := Decode(input, &x)
	+ if err == nil {
	+ t.Errorf("Decode(%q): got nil, want error containing %q",
	+ input, tt.want)
	+ continue
	+ }
	+ if !strings.Contains(err.Error(), tt.want) {
	+ t.Errorf("Decode(%q): got %q, want error containing %q",
	+ input, err, tt.want)
	+ }
	+ }
	+}
	+
	+func TestDecodeBadValues(t *testing.T) {
	+ for _, tt := range []struct {
	+ v interface{}
	+ want string
	+ }{
	+ {3, "non-pointer int"},
	+ {(*int)(nil), "nil"},
	+ } {
	+ _, err := Decode(`x = 3`, tt.v)
	+ if err == nil {
	+ t.Errorf("Decode(%v): got nil; want error containing %q",
	+ tt.v, tt.want)
	+ continue
	+ }
	+ if !strings.Contains(err.Error(), tt.want) {
	+ t.Errorf("Decode(%v): got %q; want error containing %q",
	+ tt.v, err, tt.want)
	+ }
	+ }
	+}
	+
	+func TestUnmarshaler(t *testing.T) {
	+
	+ var tomlBlob = `
	+[dishes.hamboogie]
	+name = "Hamboogie with fries"
	+price = 10.99
	+
	+[[dishes.hamboogie.ingredients]]
	+name = "Bread Bun"
	+
	+[[dishes.hamboogie.ingredients]]
	+name = "Lettuce"
	+
	+[[dishes.hamboogie.ingredients]]
	+name = "Real Beef Patty"
	+
	+[[dishes.hamboogie.ingredients]]
	+name = "Tomato"
	+
	+[dishes.eggsalad]
	+name = "Egg Salad with rice"
	+price = 3.99
	+
	+[[dishes.eggsalad.ingredients]]
	+name = "Egg"
	+
	+[[dishes.eggsalad.ingredients]]
	+name = "Mayo"
	+
	+[[dishes.eggsalad.ingredients]]
	+name = "Rice"
	+`
	+ m := &menu{}
	+ if _, err := Decode(tomlBlob, m); err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ if len(m.Dishes) != 2 {
	+ t.Log("two dishes should be loaded with UnmarshalTOML()")
	+ t.Errorf("expected %d but got %d", 2, len(m.Dishes))
	+ }
	+
	+ eggSalad := m.Dishes["eggsalad"]
	+ if _, ok := interface{}(eggSalad).(dish); !ok {
	+ t.Errorf("expected a dish")
	+ }
	+
	+ if eggSalad.Name != "Egg Salad with rice" {
	+ t.Errorf("expected the dish to be named 'Egg Salad with rice'")
	+ }
	+
	+ if len(eggSalad.Ingredients) != 3 {
	+ t.Log("dish should be loaded with UnmarshalTOML()")
	+ t.Errorf("expected %d but got %d", 3, len(eggSalad.Ingredients))
	+ }
	+
	+ found := false
	+ for _, i := range eggSalad.Ingredients {
	+ if i.Name == "Rice" {
	+ found = true
	+ break
	+ }
	+ }
	+ if !found {
	+ t.Error("Rice was not loaded in UnmarshalTOML()")
	+ }
	+
	+ // test on a value - must be passed as *
	+ o := menu{}
	+ if _, err := Decode(tomlBlob, &o); err != nil {
	+ t.Fatal(err)
	+ }
	+
	+}
	+
	+func TestDecodeInlineTable(t *testing.T) {
	+ input := `
	+[CookieJar]
	+Types = {Chocolate = "yummy", Oatmeal = "best ever"}
	+
	+[Seasons]
	+Locations = {NY = {Temp = "not cold", Rating = 4}, MI = {Temp = "freezing", Rating = 9}}
	+`
	+ type cookieJar struct {
	+ Types map[string]string
	+ }
	+ type properties struct {
	+ Temp string
	+ Rating int
	+ }
	+ type seasons struct {
	+ Locations map[string]properties
	+ }
	+ type wrapper struct {
	+ CookieJar cookieJar
	+ Seasons seasons
	+ }
	+ var got wrapper
	+
	+ meta, err := Decode(input, &got)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ want := wrapper{
	+ CookieJar: cookieJar{
	+ Types: map[string]string{
	+ "Chocolate": "yummy",
	+ "Oatmeal": "best ever",
	+ },
	+ },
	+ Seasons: seasons{
	+ Locations: map[string]properties{
	+ "NY": {
	+ Temp: "not cold",
	+ Rating: 4,
	+ },
	+ "MI": {
	+ Temp: "freezing",
	+ Rating: 9,
	+ },
	+ },
	+ },
	+ }
	+ if !reflect.DeepEqual(got, want) {
	+ t.Fatalf("after decode, got:\n\n%#v\n\nwant:\n\n%#v", got, want)
	+ }
	+ if len(meta.keys) != 12 {
	+ t.Errorf("after decode, got %d meta keys; want 12", len(meta.keys))
	+ }
	+ if len(meta.types) != 12 {
	+ t.Errorf("after decode, got %d meta types; want 12", len(meta.types))
	+ }
	+}
	+
	+func TestDecodeInlineTableArray(t *testing.T) {
	+ type point struct {
	+ X, Y, Z int
	+ }
	+ var got struct {
	+ Points []point
	+ }
	+ // Example inline table array from the spec.
	+ const in = `
	+points = [ { x = 1, y = 2, z = 3 },
	+ { x = 7, y = 8, z = 9 },
	+ { x = 2, y = 4, z = 8 } ]
	+
	+`
	+ if _, err := Decode(in, &got); err != nil {
	+ t.Fatal(err)
	+ }
	+ want := []point{
	+ {X: 1, Y: 2, Z: 3},
	+ {X: 7, Y: 8, Z: 9},
	+ {X: 2, Y: 4, Z: 8},
	+ }
	+ if !reflect.DeepEqual(got.Points, want) {
	+ t.Errorf("got %#v; want %#v", got.Points, want)
	+ }
	+}
	+
	+func TestDecodeMalformedInlineTable(t *testing.T) {
	+ for _, tt := range []struct {
	+ s string
	+ want string
	+ }{
	+ {"{,}", "unexpected comma"},
	+ {"{x = 3 y = 4}", "expected a comma or an inline table terminator"},
	+ {"{x=3,,y=4}", "unexpected comma"},
	+ {"{x=3,\ny=4}", "newlines not allowed"},
	+ {"{x=3\n,y=4}", "newlines not allowed"},
	+ } {
	+ var x struct{ A map[string]int }
	+ input := "a = " + tt.s
	+ _, err := Decode(input, &x)
	+ if err == nil {
	+ t.Errorf("Decode(%q): got nil, want error containing %q",
	+ input, tt.want)
	+ continue
	+ }
	+ if !strings.Contains(err.Error(), tt.want) {
	+ t.Errorf("Decode(%q): got %q, want error containing %q",
	+ input, err, tt.want)
	+ }
	+ }
	+}
	+
	+type menu struct {
	+ Dishes map[string]dish
	+}
	+
	+func (m *menu) UnmarshalTOML(p interface{}) error {
	+ m.Dishes = make(map[string]dish)
	+ data, _ := p.(map[string]interface{})
	+ dishes := data["dishes"].(map[string]interface{})
	+ for n, v := range dishes {
	+ if d, ok := v.(map[string]interface{}); ok {
	+ nd := dish{}
	+ nd.UnmarshalTOML(d)
	+ m.Dishes[n] = nd
	+ } else {
	+ return fmt.Errorf("not a dish")
	+ }
	+ }
	+ return nil
	+}
	+
	+type dish struct {
	+ Name string
	+ Price float32
	+ Ingredients []ingredient
	+}
	+
	+func (d *dish) UnmarshalTOML(p interface{}) error {
	+ data, _ := p.(map[string]interface{})
	+ d.Name, _ = data["name"].(string)
	+ d.Price, _ = data["price"].(float32)
	+ ingredients, _ := data["ingredients"].([]map[string]interface{})
	+ for _, e := range ingredients {
	+ n, _ := interface{}(e).(map[string]interface{})
	+ name, _ := n["name"].(string)
	+ i := ingredient{name}
	+ d.Ingredients = append(d.Ingredients, i)
	+ }
	+ return nil
	+}
	+
	+type ingredient struct {
	+ Name string
	+}
	+
	+func TestDecodeSlices(t *testing.T) {
	+ type T struct {
	+ S []string
	+ }
	+ for i, tt := range []struct {
	+ v T
	+ input string
	+ want T
	+ }{
	+ {T{}, "", T{}},
	+ {T{[]string{}}, "", T{[]string{}}},
	+ {T{[]string{"a", "b"}}, "", T{[]string{"a", "b"}}},
	+ {T{}, "S = []", T{[]string{}}},
	+ {T{[]string{}}, "S = []", T{[]string{}}},
	+ {T{[]string{"a", "b"}}, "S = []", T{[]string{}}},
	+ {T{}, `S = ["x"]`, T{[]string{"x"}}},
	+ {T{[]string{}}, `S = ["x"]`, T{[]string{"x"}}},
	+ {T{[]string{"a", "b"}}, `S = ["x"]`, T{[]string{"x"}}},
	+ } {
	+ if _, err := Decode(tt.input, &tt.v); err != nil {
	+ t.Errorf("[%d] %s", i, err)
	+ continue
	+ }
	+ if !reflect.DeepEqual(tt.v, tt.want) {
	+ t.Errorf("[%d] got %#v; want %#v", i, tt.v, tt.want)
	+ }
	+ }
	+}
	+
	+func TestDecodePrimitive(t *testing.T) {
	+ type S struct {
	+ P Primitive
	+ }
	+ type T struct {
	+ S []int
	+ }
	+ slicep := func(s []int) *[]int { return &s }
	+ arrayp := func(a [2]int) *[2]int { return &a }
	+ mapp := func(m map[string]int) *map[string]int { return &m }
	+ for i, tt := range []struct {
	+ v interface{}
	+ input string
	+ want interface{}
	+ }{
	+ // slices
	+ {slicep(nil), "", slicep(nil)},
	+ {slicep([]int{}), "", slicep([]int{})},
	+ {slicep([]int{1, 2, 3}), "", slicep([]int{1, 2, 3})},
	+ {slicep(nil), "P = [1,2]", slicep([]int{1, 2})},
	+ {slicep([]int{}), "P = [1,2]", slicep([]int{1, 2})},
	+ {slicep([]int{1, 2, 3}), "P = [1,2]", slicep([]int{1, 2})},
	+
	+ // arrays
	+ {arrayp([2]int{2, 3}), "", arrayp([2]int{2, 3})},
	+ {arrayp([2]int{2, 3}), "P = [3,4]", arrayp([2]int{3, 4})},
	+
	+ // maps
	+ {mapp(nil), "", mapp(nil)},
	+ {mapp(map[string]int{}), "", mapp(map[string]int{})},
	+ {mapp(map[string]int{"a": 1}), "", mapp(map[string]int{"a": 1})},
	+ {mapp(nil), "[P]\na = 2", mapp(map[string]int{"a": 2})},
	+ {mapp(map[string]int{}), "[P]\na = 2", mapp(map[string]int{"a": 2})},
	+ {mapp(map[string]int{"a": 1, "b": 3}), "[P]\na = 2", mapp(map[string]int{"a": 2, "b": 3})},
	+
	+ // structs
	+ {&T{nil}, "[P]", &T{nil}},
	+ {&T{[]int{}}, "[P]", &T{[]int{}}},
	+ {&T{[]int{1, 2, 3}}, "[P]", &T{[]int{1, 2, 3}}},
	+ {&T{nil}, "[P]\nS = [1,2]", &T{[]int{1, 2}}},
	+ {&T{[]int{}}, "[P]\nS = [1,2]", &T{[]int{1, 2}}},
	+ {&T{[]int{1, 2, 3}}, "[P]\nS = [1,2]", &T{[]int{1, 2}}},
	+ } {
	+ var s S
	+ md, err := Decode(tt.input, &s)
	+ if err != nil {
	+ t.Errorf("[%d] Decode error: %s", i, err)
	+ continue
	+ }
	+ if err := md.PrimitiveDecode(s.P, tt.v); err != nil {
	+ t.Errorf("[%d] PrimitiveDecode error: %s", i, err)
	+ continue
	+ }
	+ if !reflect.DeepEqual(tt.v, tt.want) {
	+ t.Errorf("[%d] got %#v; want %#v", i, tt.v, tt.want)
	+ }
	+ }
	+}
	+
	+func TestDecodeErrors(t *testing.T) {
	+ for _, s := range []string{
	+ `x="`,
	+ `x='`,
	+ `x='''`,
	+
	+ // Cases found by fuzzing in
	+ // https://github.com/BurntSushi/toml/issues/155.
	+ `""�`, // used to panic with index out of range
	+ `e="""`, // used to hang
	+ } {
	+ var x struct{}
	+ _, err := Decode(s, &x)
	+ if err == nil {
	+ t.Errorf("Decode(%q): got nil error", s)
	+ }
	+ }
	+}
	+
	+// Test for https://github.com/BurntSushi/toml/pull/166.
	+func TestDecodeBoolArray(t *testing.T) {
	+ for _, tt := range []struct {
	+ s string
	+ got interface{}
	+ want interface{}
	+ }{
	+ {
	+ "a = [true, false]",
	+ &struct{ A []bool }{},
	+ &struct{ A []bool }{[]bool{true, false}},
	+ },
	+ {
	+ "a = {a = true, b = false}",
	+ &struct{ A map[string]bool }{},
	+ &struct{ A map[string]bool }{map[string]bool{"a": true, "b": false}},
	+ },
	+ } {
	+ if _, err := Decode(tt.s, tt.got); err != nil {
	+ t.Errorf("Decode(%q): %s", tt.s, err)
	+ continue
	+ }
	+ if !reflect.DeepEqual(tt.got, tt.want) {
	+ t.Errorf("Decode(%q): got %#v; want %#v", tt.s, tt.got, tt.want)
	+ }
	+ }
	+}
	+
	+func ExampleMetaData_PrimitiveDecode() {
	+ var md MetaData
	+ var err error
	+
	+ var tomlBlob = `
	+ranking = ["Springsteen", "J Geils"]
	+
	+[bands.Springsteen]
	+started = 1973
	+albums = ["Greetings", "WIESS", "Born to Run", "Darkness"]
	+
	+[bands."J Geils"]
	+started = 1970
	+albums = ["The J. Geils Band", "Full House", "Blow Your Face Out"]
	+`
	+
	+ type band struct {
	+ Started int
	+ Albums []string
	+ }
	+ type classics struct {
	+ Ranking []string
	+ Bands map[string]Primitive
	+ }
	+
	+ // Do the initial decode. Reflection is delayed on Primitive values.
	+ var music classics
	+ if md, err = Decode(tomlBlob, &music); err != nil {
	+ log.Fatal(err)
	+ }
	+
	+ // MetaData still includes information on Primitive values.
	+ fmt.Printf("Is `bands.Springsteen` defined? %v\n",
	+ md.IsDefined("bands", "Springsteen"))
	+
	+ // Decode primitive data into Go values.
	+ for _, artist := range music.Ranking {
	+ // A band is a primitive value, so we need to decode it to get a
	+ // real `band` value.
	+ primValue := music.Bands[artist]
	+
	+ var aBand band
	+ if err = md.PrimitiveDecode(primValue, &aBand); err != nil {
	+ log.Fatal(err)
	+ }
	+ fmt.Printf("%s started in %d.\n", artist, aBand.Started)
	+ }
	+ // Check to see if there were any fields left undecoded.
	+ // Note that this won't be empty before decoding the Primitive value!
	+ fmt.Printf("Undecoded: %q\n", md.Undecoded())
	+
	+ // Output:
	+ // Is `bands.Springsteen` defined? true
	+ // Springsteen started in 1973.
	+ // J Geils started in 1970.
	+ // Undecoded: []
	+}
	+
	+func ExampleDecode() {
	+ var tomlBlob = `
	+# Some comments.
	+[alpha]
	+ip = "10.0.0.1"
	+
	+ [alpha.config]
	+ Ports = [ 8001, 8002 ]
	+ Location = "Toronto"
	+ Created = 1987-07-05T05:45:00Z
	+
	+[beta]
	+ip = "10.0.0.2"
	+
	+ [beta.config]
	+ Ports = [ 9001, 9002 ]
	+ Location = "New Jersey"
	+ Created = 1887-01-05T05:55:00Z
	+`
	+
	+ type serverConfig struct {
	+ Ports []int
	+ Location string
	+ Created time.Time
	+ }
	+
	+ type server struct {
	+ IP string `toml:"ip,omitempty"`
	+ Config serverConfig `toml:"config"`
	+ }
	+
	+ type servers map[string]server
	+
	+ var config servers
	+ if _, err := Decode(tomlBlob, &config); err != nil {
	+ log.Fatal(err)
	+ }
	+
	+ for _, name := range []string{"alpha", "beta"} {
	+ s := config[name]
	+ fmt.Printf("Server: %s (ip: %s) in %s created on %s\n",
	+ name, s.IP, s.Config.Location,
	+ s.Config.Created.Format("2006-01-02"))
	+ fmt.Printf("Ports: %v\n", s.Config.Ports)
	+ }
	+
	+ // Output:
	+ // Server: alpha (ip: 10.0.0.1) in Toronto created on 1987-07-05
	+ // Ports: [8001 8002]
	+ // Server: beta (ip: 10.0.0.2) in New Jersey created on 1887-01-05
	+ // Ports: [9001 9002]
	+}
	+
	+type duration struct {
	+ time.Duration
	+}
	+
	+func (d *duration) UnmarshalText(text []byte) error {
	+ var err error
	+ d.Duration, err = time.ParseDuration(string(text))
	+ return err
	+}
	+
	+// Example Unmarshaler shows how to decode TOML strings into your own
	+// custom data type.
	+func Example_unmarshaler() {
	+ blob := `
	+[[song]]
	+name = "Thunder Road"
	+duration = "4m49s"
	+
	+[[song]]
	+name = "Stairway to Heaven"
	+duration = "8m03s"
	+`
	+ type song struct {
	+ Name string
	+ Duration duration
	+ }
	+ type songs struct {
	+ Song []song
	+ }
	+ var favorites songs
	+ if _, err := Decode(blob, &favorites); err != nil {
	+ log.Fatal(err)
	+ }
	+
	+ // Code to implement the TextUnmarshaler interface for `duration`:
	+ //
	+ // type duration struct {
	+ // time.Duration
	+ // }
	+ //
	+ // func (d *duration) UnmarshalText(text []byte) error {
	+ // var err error
	+ // d.Duration, err = time.ParseDuration(string(text))
	+ // return err
	+ // }
	+
	+ for _, s := range favorites.Song {
	+ fmt.Printf("%s (%s)\n", s.Name, s.Duration)
	+ }
	+ // Output:
	+ // Thunder Road (4m49s)
	+ // Stairway to Heaven (8m3s)
	+}
	+
	+// Example StrictDecoding shows how to detect whether there are keys in the
	+// TOML document that weren't decoded into the value given. This is useful
	+// for returning an error to the user if they've included extraneous fields
	+// in their configuration.
	+func Example_strictDecoding() {
	+ var blob = `
	+key1 = "value1"
	+key2 = "value2"
	+key3 = "value3"
	+`
	+ type config struct {
	+ Key1 string
	+ Key3 string
	+ }
	+
	+ var conf config
	+ md, err := Decode(blob, &conf)
	+ if err != nil {
	+ log.Fatal(err)
	+ }
	+ fmt.Printf("Undecoded keys: %q\n", md.Undecoded())
	+ // Output:
	+ // Undecoded keys: ["key2"]
	+}
	+
	+// Example UnmarshalTOML shows how to implement a struct type that knows how to
	+// unmarshal itself. The struct must take full responsibility for mapping the
	+// values passed into the struct. The method may be used with interfaces in a
	+// struct in cases where the actual type is not known until the data is
	+// examined.
	+func Example_unmarshalTOML() {
	+
	+ var blob = `
	+[[parts]]
	+type = "valve"
	+id = "valve-1"
	+size = 1.2
	+rating = 4
	+
	+[[parts]]
	+type = "valve"
	+id = "valve-2"
	+size = 2.1
	+rating = 5
	+
	+[[parts]]
	+type = "pipe"
	+id = "pipe-1"
	+length = 2.1
	+diameter = 12
	+
	+[[parts]]
	+type = "cable"
	+id = "cable-1"
	+length = 12
	+rating = 3.1
	+`
	+ o := &order{}
	+ err := Unmarshal([]byte(blob), o)
	+ if err != nil {
	+ log.Fatal(err)
	+ }
	+
	+ fmt.Println(len(o.parts))
	+
	+ for _, part := range o.parts {
	+ fmt.Println(part.Name())
	+ }
	+
	+ // Code to implement UmarshalJSON.
	+
	+ // type order struct {
	+ // // NOTE `order.parts` is a private slice of type `part` which is an
	+ // // interface and may only be loaded from toml using the
	+ // // UnmarshalTOML() method of the Umarshaler interface.
	+ // parts parts
	+ // }
	+
	+ // func (o *order) UnmarshalTOML(data interface{}) error {
	+
	+ // // NOTE the example below contains detailed type casting to show how
	+ // // the 'data' is retrieved. In operational use, a type cast wrapper
	+ // // may be preferred e.g.
	+ // //
	+ // // func AsMap(v interface{}) (map[string]interface{}, error) {
	+ // // return v.(map[string]interface{})
	+ // // }
	+ // //
	+ // // resulting in:
	+ // // d, _ := AsMap(data)
	+ // //
	+
	+ // d, _ := data.(map[string]interface{})
	+ // parts, _ := d["parts"].([]map[string]interface{})
	+
	+ // for _, p := range parts {
	+
	+ // typ, _ := p["type"].(string)
	+ // id, _ := p["id"].(string)
	+
	+ // // detect the type of part and handle each case
	+ // switch p["type"] {
	+ // case "valve":
	+
	+ // size := float32(p["size"].(float64))
	+ // rating := int(p["rating"].(int64))
	+
	+ // valve := &valve{
	+ // Type: typ,
	+ // ID: id,
	+ // Size: size,
	+ // Rating: rating,
	+ // }
	+
	+ // o.parts = append(o.parts, valve)
	+
	+ // case "pipe":
	+
	+ // length := float32(p["length"].(float64))
	+ // diameter := int(p["diameter"].(int64))
	+
	+ // pipe := &pipe{
	+ // Type: typ,
	+ // ID: id,
	+ // Length: length,
	+ // Diameter: diameter,
	+ // }
	+
	+ // o.parts = append(o.parts, pipe)
	+
	+ // case "cable":
	+
	+ // length := int(p["length"].(int64))
	+ // rating := float32(p["rating"].(float64))
	+
	+ // cable := &cable{
	+ // Type: typ,
	+ // ID: id,
	+ // Length: length,
	+ // Rating: rating,
	+ // }
	+
	+ // o.parts = append(o.parts, cable)
	+
	+ // }
	+ // }
	+
	+ // return nil
	+ // }
	+
	+ // type parts []part
	+
	+ // type part interface {
	+ // Name() string
	+ // }
	+
	+ // type valve struct {
	+ // Type string
	+ // ID string
	+ // Size float32
	+ // Rating int
	+ // }
	+
	+ // func (v *valve) Name() string {
	+ // return fmt.Sprintf("VALVE: %s", v.ID)
	+ // }
	+
	+ // type pipe struct {
	+ // Type string
	+ // ID string
	+ // Length float32
	+ // Diameter int
	+ // }
	+
	+ // func (p *pipe) Name() string {
	+ // return fmt.Sprintf("PIPE: %s", p.ID)
	+ // }
	+
	+ // type cable struct {
	+ // Type string
	+ // ID string
	+ // Length int
	+ // Rating float32
	+ // }
	+
	+ // func (c *cable) Name() string {
	+ // return fmt.Sprintf("CABLE: %s", c.ID)
	+ // }
	+
	+ // Output:
	+ // 4
	+ // VALVE: valve-1
	+ // VALVE: valve-2
	+ // PIPE: pipe-1
	+ // CABLE: cable-1
	+
	+}
	+
	+type order struct {
	+ // NOTE `order.parts` is a private slice of type `part` which is an
	+ // interface and may only be loaded from toml using the UnmarshalTOML()
	+ // method of the Umarshaler interface.
	+ parts parts
	+}
	+
	+func (o *order) UnmarshalTOML(data interface{}) error {
	+
	+ // NOTE the example below contains detailed type casting to show how
	+ // the 'data' is retrieved. In operational use, a type cast wrapper
	+ // may be preferred e.g.
	+ //
	+ // func AsMap(v interface{}) (map[string]interface{}, error) {
	+ // return v.(map[string]interface{})
	+ // }
	+ //
	+ // resulting in:
	+ // d, _ := AsMap(data)
	+ //
	+
	+ d, _ := data.(map[string]interface{})
	+ parts, _ := d["parts"].([]map[string]interface{})
	+
	+ for _, p := range parts {
	+
	+ typ, _ := p["type"].(string)
	+ id, _ := p["id"].(string)
	+
	+ // detect the type of part and handle each case
	+ switch p["type"] {
	+ case "valve":
	+
	+ size := float32(p["size"].(float64))
	+ rating := int(p["rating"].(int64))
	+
	+ valve := &valve{
	+ Type: typ,
	+ ID: id,
	+ Size: size,
	+ Rating: rating,
	+ }
	+
	+ o.parts = append(o.parts, valve)
	+
	+ case "pipe":
	+
	+ length := float32(p["length"].(float64))
	+ diameter := int(p["diameter"].(int64))
	+
	+ pipe := &pipe{
	+ Type: typ,
	+ ID: id,
	+ Length: length,
	+ Diameter: diameter,
	+ }
	+
	+ o.parts = append(o.parts, pipe)
	+
	+ case "cable":
	+
	+ length := int(p["length"].(int64))
	+ rating := float32(p["rating"].(float64))
	+
	+ cable := &cable{
	+ Type: typ,
	+ ID: id,
	+ Length: length,
	+ Rating: rating,
	+ }
	+
	+ o.parts = append(o.parts, cable)
	+
	+ }
	+ }
	+
	+ return nil
	+}
	+
	+type parts []part
	+
	+type part interface {
	+ Name() string
	+}
	+
	+type valve struct {
	+ Type string
	+ ID string
	+ Size float32
	+ Rating int
	+}
	+
	+func (v *valve) Name() string {
	+ return fmt.Sprintf("VALVE: %s", v.ID)
	+}
	+
	+type pipe struct {
	+ Type string
	+ ID string
	+ Length float32
	+ Diameter int
	+}
	+
	+func (p *pipe) Name() string {
	+ return fmt.Sprintf("PIPE: %s", p.ID)
	+}
	+
	+type cable struct {
	+ Type string
	+ ID string
	+ Length int
	+ Rating float32
	+}
	+
	+func (c *cable) Name() string {
	+ return fmt.Sprintf("CABLE: %s", c.ID)
	+}
	diff --git a/src/github.com/BurntSushi/toml/doc.go b/src/github.com/BurntSushi/toml/doc.go
	new file mode 100644
	index 0000000..b371f39
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/doc.go
	@@ -0,0 +1,27 @@
	+/*
	+Package toml provides facilities for decoding and encoding TOML configuration
	+files via reflection. There is also support for delaying decoding with
	+the Primitive type, and querying the set of keys in a TOML document with the
	+MetaData type.
	+
	+The specification implemented: https://github.com/toml-lang/toml
	+
	+The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
	+whether a file is a valid TOML document. It can also be used to print the
	+type of each key in a TOML document.
	+
	+Testing
	+
	+There are two important types of tests used for this package. The first is
	+contained inside '*_test.go' files and uses the standard Go unit testing
	+framework. These tests are primarily devoted to holistically testing the
	+decoder and encoder.
	+
	+The second type of testing is used to verify the implementation's adherence
	+to the TOML specification. These tests have been factored into their own
	+project: https://github.com/BurntSushi/toml-test
	+
	+The reason the tests are in a separate project is so that they can be used by
	+any implementation of TOML. Namely, it is language agnostic.
	+*/
	+package toml
	diff --git a/src/github.com/BurntSushi/toml/encode.go b/src/github.com/BurntSushi/toml/encode.go
	new file mode 100644
	index 0000000..d905c21
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/encode.go
	@@ -0,0 +1,568 @@
	+package toml
	+
	+import (
	+ "bufio"
	+ "errors"
	+ "fmt"
	+ "io"
	+ "reflect"
	+ "sort"
	+ "strconv"
	+ "strings"
	+ "time"
	+)
	+
	+type tomlEncodeError struct{ error }
	+
	+var (
	+ errArrayMixedElementTypes = errors.New(
	+ "toml: cannot encode array with mixed element types")
	+ errArrayNilElement = errors.New(
	+ "toml: cannot encode array with nil element")
	+ errNonString = errors.New(
	+ "toml: cannot encode a map with non-string key type")
	+ errAnonNonStruct = errors.New(
	+ "toml: cannot encode an anonymous field that is not a struct")
	+ errArrayNoTable = errors.New(
	+ "toml: TOML array element cannot contain a table")
	+ errNoKey = errors.New(
	+ "toml: top-level values must be Go maps or structs")
	+ errAnything = errors.New("") // used in testing
	+)
	+
	+var quotedReplacer = strings.NewReplacer(
	+ "\t", "\\t",
	+ "\n", "\\n",
	+ "\r", "\\r",
	+ "\"", "\\\"",
	+ "\\", "\\\\",
	+)
	+
	+// Encoder controls the encoding of Go values to a TOML document to some
	+// io.Writer.
	+//
	+// The indentation level can be controlled with the Indent field.
	+type Encoder struct {
	+ // A single indentation level. By default it is two spaces.
	+ Indent string
	+
	+ // hasWritten is whether we have written any output to w yet.
	+ hasWritten bool
	+ w *bufio.Writer
	+}
	+
	+// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
	+// given. By default, a single indentation level is 2 spaces.
	+func NewEncoder(w io.Writer) *Encoder {
	+ return &Encoder{
	+ w: bufio.NewWriter(w),
	+ Indent: " ",
	+ }
	+}
	+
	+// Encode writes a TOML representation of the Go value to the underlying
	+// io.Writer. If the value given cannot be encoded to a valid TOML document,
	+// then an error is returned.
	+//
	+// The mapping between Go values and TOML values should be precisely the same
	+// as for the Decode* functions. Similarly, the TextMarshaler interface is
	+// supported by encoding the resulting bytes as strings. (If you want to write
	+// arbitrary binary data then you will need to use something like base64 since
	+// TOML does not have any binary types.)
	+//
	+// When encoding TOML hashes (i.e., Go maps or structs), keys without any
	+// sub-hashes are encoded first.
	+//
	+// If a Go map is encoded, then its keys are sorted alphabetically for
	+// deterministic output. More control over this behavior may be provided if
	+// there is demand for it.
	+//
	+// Encoding Go values without a corresponding TOML representation---like map
	+// types with non-string keys---will cause an error to be returned. Similarly
	+// for mixed arrays/slices, arrays/slices with nil elements, embedded
	+// non-struct types and nested slices containing maps or structs.
	+// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
	+// and so is []map[string][]string.)
	+func (enc *Encoder) Encode(v interface{}) error {
	+ rv := eindirect(reflect.ValueOf(v))
	+ if err := enc.safeEncode(Key([]string{}), rv); err != nil {
	+ return err
	+ }
	+ return enc.w.Flush()
	+}
	+
	+func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
	+ defer func() {
	+ if r := recover(); r != nil {
	+ if terr, ok := r.(tomlEncodeError); ok {
	+ err = terr.error
	+ return
	+ }
	+ panic(r)
	+ }
	+ }()
	+ enc.encode(key, rv)
	+ return nil
	+}
	+
	+func (enc *Encoder) encode(key Key, rv reflect.Value) {
	+ // Special case. Time needs to be in ISO8601 format.
	+ // Special case. If we can marshal the type to text, then we used that.
	+ // Basically, this prevents the encoder for handling these types as
	+ // generic structs (or whatever the underlying type of a TextMarshaler is).
	+ switch rv.Interface().(type) {
	+ case time.Time, TextMarshaler:
	+ enc.keyEqElement(key, rv)
	+ return
	+ }
	+
	+ k := rv.Kind()
	+ switch k {
	+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
	+ reflect.Int64,
	+ reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
	+ reflect.Uint64,
	+ reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
	+ enc.keyEqElement(key, rv)
	+ case reflect.Array, reflect.Slice:
	+ if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
	+ enc.eArrayOfTables(key, rv)
	+ } else {
	+ enc.keyEqElement(key, rv)
	+ }
	+ case reflect.Interface:
	+ if rv.IsNil() {
	+ return
	+ }
	+ enc.encode(key, rv.Elem())
	+ case reflect.Map:
	+ if rv.IsNil() {
	+ return
	+ }
	+ enc.eTable(key, rv)
	+ case reflect.Ptr:
	+ if rv.IsNil() {
	+ return
	+ }
	+ enc.encode(key, rv.Elem())
	+ case reflect.Struct:
	+ enc.eTable(key, rv)
	+ default:
	+ panic(e("unsupported type for key '%s': %s", key, k))
	+ }
	+}
	+
	+// eElement encodes any value that can be an array element (primitives and
	+// arrays).
	+func (enc *Encoder) eElement(rv reflect.Value) {
	+ switch v := rv.Interface().(type) {
	+ case time.Time:
	+ // Special case time.Time as a primitive. Has to come before
	+ // TextMarshaler below because time.Time implements
	+ // encoding.TextMarshaler, but we need to always use UTC.
	+ enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
	+ return
	+ case TextMarshaler:
	+ // Special case. Use text marshaler if it's available for this value.
	+ if s, err := v.MarshalText(); err != nil {
	+ encPanic(err)
	+ } else {
	+ enc.writeQuoted(string(s))
	+ }
	+ return
	+ }
	+ switch rv.Kind() {
	+ case reflect.Bool:
	+ enc.wf(strconv.FormatBool(rv.Bool()))
	+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
	+ reflect.Int64:
	+ enc.wf(strconv.FormatInt(rv.Int(), 10))
	+ case reflect.Uint, reflect.Uint8, reflect.Uint16,
	+ reflect.Uint32, reflect.Uint64:
	+ enc.wf(strconv.FormatUint(rv.Uint(), 10))
	+ case reflect.Float32:
	+ enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
	+ case reflect.Float64:
	+ enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
	+ case reflect.Array, reflect.Slice:
	+ enc.eArrayOrSliceElement(rv)
	+ case reflect.Interface:
	+ enc.eElement(rv.Elem())
	+ case reflect.String:
	+ enc.writeQuoted(rv.String())
	+ default:
	+ panic(e("unexpected primitive type: %s", rv.Kind()))
	+ }
	+}
	+
	+// By the TOML spec, all floats must have a decimal with at least one
	+// number on either side.
	+func floatAddDecimal(fstr string) string {
	+ if !strings.Contains(fstr, ".") {
	+ return fstr + ".0"
	+ }
	+ return fstr
	+}
	+
	+func (enc *Encoder) writeQuoted(s string) {
	+ enc.wf("\"%s\"", quotedReplacer.Replace(s))
	+}
	+
	+func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
	+ length := rv.Len()
	+ enc.wf("[")
	+ for i := 0; i < length; i++ {
	+ elem := rv.Index(i)
	+ enc.eElement(elem)
	+ if i != length-1 {
	+ enc.wf(", ")
	+ }
	+ }
	+ enc.wf("]")
	+}
	+
	+func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
	+ if len(key) == 0 {
	+ encPanic(errNoKey)
	+ }
	+ for i := 0; i < rv.Len(); i++ {
	+ trv := rv.Index(i)
	+ if isNil(trv) {
	+ continue
	+ }
	+ panicIfInvalidKey(key)
	+ enc.newline()
	+ enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
	+ enc.newline()
	+ enc.eMapOrStruct(key, trv)
	+ }
	+}
	+
	+func (enc *Encoder) eTable(key Key, rv reflect.Value) {
	+ panicIfInvalidKey(key)
	+ if len(key) == 1 {
	+ // Output an extra newline between top-level tables.
	+ // (The newline isn't written if nothing else has been written though.)
	+ enc.newline()
	+ }
	+ if len(key) > 0 {
	+ enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
	+ enc.newline()
	+ }
	+ enc.eMapOrStruct(key, rv)
	+}
	+
	+func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
	+ switch rv := eindirect(rv); rv.Kind() {
	+ case reflect.Map:
	+ enc.eMap(key, rv)
	+ case reflect.Struct:
	+ enc.eStruct(key, rv)
	+ default:
	+ panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
	+ }
	+}
	+
	+func (enc *Encoder) eMap(key Key, rv reflect.Value) {
	+ rt := rv.Type()
	+ if rt.Key().Kind() != reflect.String {
	+ encPanic(errNonString)
	+ }
	+
	+ // Sort keys so that we have deterministic output. And write keys directly
	+ // underneath this key first, before writing sub-structs or sub-maps.
	+ var mapKeysDirect, mapKeysSub []string
	+ for _, mapKey := range rv.MapKeys() {
	+ k := mapKey.String()
	+ if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
	+ mapKeysSub = append(mapKeysSub, k)
	+ } else {
	+ mapKeysDirect = append(mapKeysDirect, k)
	+ }
	+ }
	+
	+ var writeMapKeys = func(mapKeys []string) {
	+ sort.Strings(mapKeys)
	+ for _, mapKey := range mapKeys {
	+ mrv := rv.MapIndex(reflect.ValueOf(mapKey))
	+ if isNil(mrv) {
	+ // Don't write anything for nil fields.
	+ continue
	+ }
	+ enc.encode(key.add(mapKey), mrv)
	+ }
	+ }
	+ writeMapKeys(mapKeysDirect)
	+ writeMapKeys(mapKeysSub)
	+}
	+
	+func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
	+ // Write keys for fields directly under this key first, because if we write
	+ // a field that creates a new table, then all keys under it will be in that
	+ // table (not the one we're writing here).
	+ rt := rv.Type()
	+ var fieldsDirect, fieldsSub [][]int
	+ var addFields func(rt reflect.Type, rv reflect.Value, start []int)
	+ addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
	+ for i := 0; i < rt.NumField(); i++ {
	+ f := rt.Field(i)
	+ // skip unexported fields
	+ if f.PkgPath != "" && !f.Anonymous {
	+ continue
	+ }
	+ frv := rv.Field(i)
	+ if f.Anonymous {
	+ t := f.Type
	+ switch t.Kind() {
	+ case reflect.Struct:
	+ // Treat anonymous struct fields with
	+ // tag names as though they are not
	+ // anonymous, like encoding/json does.
	+ if getOptions(f.Tag).name == "" {
	+ addFields(t, frv, f.Index)
	+ continue
	+ }
	+ case reflect.Ptr:
	+ if t.Elem().Kind() == reflect.Struct &&
	+ getOptions(f.Tag).name == "" {
	+ if !frv.IsNil() {
	+ addFields(t.Elem(), frv.Elem(), f.Index)
	+ }
	+ continue
	+ }
	+ // Fall through to the normal field encoding logic below
	+ // for non-struct anonymous fields.
	+ }
	+ }
	+
	+ if typeIsHash(tomlTypeOfGo(frv)) {
	+ fieldsSub = append(fieldsSub, append(start, f.Index...))
	+ } else {
	+ fieldsDirect = append(fieldsDirect, append(start, f.Index...))
	+ }
	+ }
	+ }
	+ addFields(rt, rv, nil)
	+
	+ var writeFields = func(fields [][]int) {
	+ for _, fieldIndex := range fields {
	+ sft := rt.FieldByIndex(fieldIndex)
	+ sf := rv.FieldByIndex(fieldIndex)
	+ if isNil(sf) {
	+ // Don't write anything for nil fields.
	+ continue
	+ }
	+
	+ opts := getOptions(sft.Tag)
	+ if opts.skip {
	+ continue
	+ }
	+ keyName := sft.Name
	+ if opts.name != "" {
	+ keyName = opts.name
	+ }
	+ if opts.omitempty && isEmpty(sf) {
	+ continue
	+ }
	+ if opts.omitzero && isZero(sf) {
	+ continue
	+ }
	+
	+ enc.encode(key.add(keyName), sf)
	+ }
	+ }
	+ writeFields(fieldsDirect)
	+ writeFields(fieldsSub)
	+}
	+
	+// tomlTypeName returns the TOML type name of the Go value's type. It is
	+// used to determine whether the types of array elements are mixed (which is
	+// forbidden). If the Go value is nil, then it is illegal for it to be an array
	+// element, and valueIsNil is returned as true.
	+
	+// Returns the TOML type of a Go value. The type may be `nil`, which means
	+// no concrete TOML type could be found.
	+func tomlTypeOfGo(rv reflect.Value) tomlType {
	+ if isNil(rv) \|\| !rv.IsValid() {
	+ return nil
	+ }
	+ switch rv.Kind() {
	+ case reflect.Bool:
	+ return tomlBool
	+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
	+ reflect.Int64,
	+ reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
	+ reflect.Uint64:
	+ return tomlInteger
	+ case reflect.Float32, reflect.Float64:
	+ return tomlFloat
	+ case reflect.Array, reflect.Slice:
	+ if typeEqual(tomlHash, tomlArrayType(rv)) {
	+ return tomlArrayHash
	+ }
	+ return tomlArray
	+ case reflect.Ptr, reflect.Interface:
	+ return tomlTypeOfGo(rv.Elem())
	+ case reflect.String:
	+ return tomlString
	+ case reflect.Map:
	+ return tomlHash
	+ case reflect.Struct:
	+ switch rv.Interface().(type) {
	+ case time.Time:
	+ return tomlDatetime
	+ case TextMarshaler:
	+ return tomlString
	+ default:
	+ return tomlHash
	+ }
	+ default:
	+ panic("unexpected reflect.Kind: " + rv.Kind().String())
	+ }
	+}
	+
	+// tomlArrayType returns the element type of a TOML array. The type returned
	+// may be nil if it cannot be determined (e.g., a nil slice or a zero length
	+// slize). This function may also panic if it finds a type that cannot be
	+// expressed in TOML (such as nil elements, heterogeneous arrays or directly
	+// nested arrays of tables).
	+func tomlArrayType(rv reflect.Value) tomlType {
	+ if isNil(rv) \|\| !rv.IsValid() \|\| rv.Len() == 0 {
	+ return nil
	+ }
	+ firstType := tomlTypeOfGo(rv.Index(0))
	+ if firstType == nil {
	+ encPanic(errArrayNilElement)
	+ }
	+
	+ rvlen := rv.Len()
	+ for i := 1; i < rvlen; i++ {
	+ elem := rv.Index(i)
	+ switch elemType := tomlTypeOfGo(elem); {
	+ case elemType == nil:
	+ encPanic(errArrayNilElement)
	+ case !typeEqual(firstType, elemType):
	+ encPanic(errArrayMixedElementTypes)
	+ }
	+ }
	+ // If we have a nested array, then we must make sure that the nested
	+ // array contains ONLY primitives.
	+ // This checks arbitrarily nested arrays.
	+ if typeEqual(firstType, tomlArray) \|\| typeEqual(firstType, tomlArrayHash) {
	+ nest := tomlArrayType(eindirect(rv.Index(0)))
	+ if typeEqual(nest, tomlHash) \|\| typeEqual(nest, tomlArrayHash) {
	+ encPanic(errArrayNoTable)
	+ }
	+ }
	+ return firstType
	+}
	+
	+type tagOptions struct {
	+ skip bool // "-"
	+ name string
	+ omitempty bool
	+ omitzero bool
	+}
	+
	+func getOptions(tag reflect.StructTag) tagOptions {
	+ t := tag.Get("toml")
	+ if t == "-" {
	+ return tagOptions{skip: true}
	+ }
	+ var opts tagOptions
	+ parts := strings.Split(t, ",")
	+ opts.name = parts[0]
	+ for _, s := range parts[1:] {
	+ switch s {
	+ case "omitempty":
	+ opts.omitempty = true
	+ case "omitzero":
	+ opts.omitzero = true
	+ }
	+ }
	+ return opts
	+}
	+
	+func isZero(rv reflect.Value) bool {
	+ switch rv.Kind() {
	+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
	+ return rv.Int() == 0
	+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
	+ return rv.Uint() == 0
	+ case reflect.Float32, reflect.Float64:
	+ return rv.Float() == 0.0
	+ }
	+ return false
	+}
	+
	+func isEmpty(rv reflect.Value) bool {
	+ switch rv.Kind() {
	+ case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
	+ return rv.Len() == 0
	+ case reflect.Bool:
	+ return !rv.Bool()
	+ }
	+ return false
	+}
	+
	+func (enc *Encoder) newline() {
	+ if enc.hasWritten {
	+ enc.wf("\n")
	+ }
	+}
	+
	+func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
	+ if len(key) == 0 {
	+ encPanic(errNoKey)
	+ }
	+ panicIfInvalidKey(key)
	+ enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
	+ enc.eElement(val)
	+ enc.newline()
	+}
	+
	+func (enc *Encoder) wf(format string, v ...interface{}) {
	+ if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
	+ encPanic(err)
	+ }
	+ enc.hasWritten = true
	+}
	+
	+func (enc *Encoder) indentStr(key Key) string {
	+ return strings.Repeat(enc.Indent, len(key)-1)
	+}
	+
	+func encPanic(err error) {
	+ panic(tomlEncodeError{err})
	+}
	+
	+func eindirect(v reflect.Value) reflect.Value {
	+ switch v.Kind() {
	+ case reflect.Ptr, reflect.Interface:
	+ return eindirect(v.Elem())
	+ default:
	+ return v
	+ }
	+}
	+
	+func isNil(rv reflect.Value) bool {
	+ switch rv.Kind() {
	+ case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
	+ return rv.IsNil()
	+ default:
	+ return false
	+ }
	+}
	+
	+func panicIfInvalidKey(key Key) {
	+ for _, k := range key {
	+ if len(k) == 0 {
	+ encPanic(e("Key '%s' is not a valid table name. Key names "+
	+ "cannot be empty.", key.maybeQuotedAll()))
	+ }
	+ }
	+}
	+
	+func isValidKeyName(s string) bool {
	+ return len(s) != 0
	+}
	diff --git a/src/github.com/BurntSushi/toml/encode_test.go b/src/github.com/BurntSushi/toml/encode_test.go
	new file mode 100644
	index 0000000..673b7b0
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/encode_test.go
	@@ -0,0 +1,615 @@
	+package toml
	+
	+import (
	+ "bytes"
	+ "fmt"
	+ "log"
	+ "net"
	+ "testing"
	+ "time"
	+)
	+
	+func TestEncodeRoundTrip(t *testing.T) {
	+ type Config struct {
	+ Age int
	+ Cats []string
	+ Pi float64
	+ Perfection []int
	+ DOB time.Time
	+ Ipaddress net.IP
	+ }
	+
	+ var inputs = Config{
	+ 13,
	+ []string{"one", "two", "three"},
	+ 3.145,
	+ []int{11, 2, 3, 4},
	+ time.Now(),
	+ net.ParseIP("192.168.59.254"),
	+ }
	+
	+ var firstBuffer bytes.Buffer
	+ e := NewEncoder(&firstBuffer)
	+ err := e.Encode(inputs)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ var outputs Config
	+ if _, err := Decode(firstBuffer.String(), &outputs); err != nil {
	+ t.Logf("Could not decode:\n-----\n%s\n-----\n",
	+ firstBuffer.String())
	+ t.Fatal(err)
	+ }
	+
	+ // could test each value individually, but I'm lazy
	+ var secondBuffer bytes.Buffer
	+ e2 := NewEncoder(&secondBuffer)
	+ err = e2.Encode(outputs)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ if firstBuffer.String() != secondBuffer.String() {
	+ t.Error(
	+ firstBuffer.String(),
	+ "\n\n is not identical to\n\n",
	+ secondBuffer.String())
	+ }
	+}
	+
	+// XXX(burntsushi)
	+// I think these tests probably should be removed. They are good, but they
	+// ought to be obsolete by toml-test.
	+func TestEncode(t *testing.T) {
	+ type Embedded struct {
	+ Int int `toml:"_int"`
	+ }
	+ type NonStruct int
	+
	+ date := time.Date(2014, 5, 11, 20, 30, 40, 0, time.FixedZone("IST", 3600))
	+ dateStr := "2014-05-11T19:30:40Z"
	+
	+ tests := map[string]struct {
	+ input interface{}
	+ wantOutput string
	+ wantError error
	+ }{
	+ "bool field": {
	+ input: struct {
	+ BoolTrue bool
	+ BoolFalse bool
	+ }{true, false},
	+ wantOutput: "BoolTrue = true\nBoolFalse = false\n",
	+ },
	+ "int fields": {
	+ input: struct {
	+ Int int
	+ Int8 int8
	+ Int16 int16
	+ Int32 int32
	+ Int64 int64
	+ }{1, 2, 3, 4, 5},
	+ wantOutput: "Int = 1\nInt8 = 2\nInt16 = 3\nInt32 = 4\nInt64 = 5\n",
	+ },
	+ "uint fields": {
	+ input: struct {
	+ Uint uint
	+ Uint8 uint8
	+ Uint16 uint16
	+ Uint32 uint32
	+ Uint64 uint64
	+ }{1, 2, 3, 4, 5},
	+ wantOutput: "Uint = 1\nUint8 = 2\nUint16 = 3\nUint32 = 4" +
	+ "\nUint64 = 5\n",
	+ },
	+ "float fields": {
	+ input: struct {
	+ Float32 float32
	+ Float64 float64
	+ }{1.5, 2.5},
	+ wantOutput: "Float32 = 1.5\nFloat64 = 2.5\n",
	+ },
	+ "string field": {
	+ input: struct{ String string }{"foo"},
	+ wantOutput: "String = \"foo\"\n",
	+ },
	+ "string field and unexported field": {
	+ input: struct {
	+ String string
	+ unexported int
	+ }{"foo", 0},
	+ wantOutput: "String = \"foo\"\n",
	+ },
	+ "datetime field in UTC": {
	+ input: struct{ Date time.Time }{date},
	+ wantOutput: fmt.Sprintf("Date = %s\n", dateStr),
	+ },
	+ "datetime field as primitive": {
	+ // Using a map here to fail if isStructOrMap() returns true for
	+ // time.Time.
	+ input: map[string]interface{}{
	+ "Date": date,
	+ "Int": 1,
	+ },
	+ wantOutput: fmt.Sprintf("Date = %s\nInt = 1\n", dateStr),
	+ },
	+ "array fields": {
	+ input: struct {
	+ IntArray0 [0]int
	+ IntArray3 [3]int
	+ }{[0]int{}, [3]int{1, 2, 3}},
	+ wantOutput: "IntArray0 = []\nIntArray3 = [1, 2, 3]\n",
	+ },
	+ "slice fields": {
	+ input: struct{ IntSliceNil, IntSlice0, IntSlice3 []int }{
	+ nil, []int{}, []int{1, 2, 3},
	+ },
	+ wantOutput: "IntSlice0 = []\nIntSlice3 = [1, 2, 3]\n",
	+ },
	+ "datetime slices": {
	+ input: struct{ DatetimeSlice []time.Time }{
	+ []time.Time{date, date},
	+ },
	+ wantOutput: fmt.Sprintf("DatetimeSlice = [%s, %s]\n",
	+ dateStr, dateStr),
	+ },
	+ "nested arrays and slices": {
	+ input: struct {
	+ SliceOfArrays [][2]int
	+ ArrayOfSlices [2][]int
	+ SliceOfArraysOfSlices [][2][]int
	+ ArrayOfSlicesOfArrays [2][][2]int
	+ SliceOfMixedArrays [][2]interface{}
	+ ArrayOfMixedSlices [2][]interface{}
	+ }{
	+ [][2]int{{1, 2}, {3, 4}},
	+ [2][]int{{1, 2}, {3, 4}},
	+ [][2][]int{
	+ {
	+ {1, 2}, {3, 4},
	+ },
	+ {
	+ {5, 6}, {7, 8},
	+ },
	+ },
	+ [2][][2]int{
	+ {
	+ {1, 2}, {3, 4},
	+ },
	+ {
	+ {5, 6}, {7, 8},
	+ },
	+ },
	+ [][2]interface{}{
	+ {1, 2}, {"a", "b"},
	+ },
	+ [2][]interface{}{
	+ {1, 2}, {"a", "b"},
	+ },
	+ },
	+ wantOutput: `SliceOfArrays = [[1, 2], [3, 4]]
	+ArrayOfSlices = [[1, 2], [3, 4]]
	+SliceOfArraysOfSlices = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
	+ArrayOfSlicesOfArrays = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
	+SliceOfMixedArrays = [[1, 2], ["a", "b"]]
	+ArrayOfMixedSlices = [[1, 2], ["a", "b"]]
	+`,
	+ },
	+ "empty slice": {
	+ input: struct{ Empty []interface{} }{[]interface{}{}},
	+ wantOutput: "Empty = []\n",
	+ },
	+ "(error) slice with element type mismatch (string and integer)": {
	+ input: struct{ Mixed []interface{} }{[]interface{}{1, "a"}},
	+ wantError: errArrayMixedElementTypes,
	+ },
	+ "(error) slice with element type mismatch (integer and float)": {
	+ input: struct{ Mixed []interface{} }{[]interface{}{1, 2.5}},
	+ wantError: errArrayMixedElementTypes,
	+ },
	+ "slice with elems of differing Go types, same TOML types": {
	+ input: struct {
	+ MixedInts []interface{}
	+ MixedFloats []interface{}
	+ }{
	+ []interface{}{
	+ int(1), int8(2), int16(3), int32(4), int64(5),
	+ uint(1), uint8(2), uint16(3), uint32(4), uint64(5),
	+ },
	+ []interface{}{float32(1.5), float64(2.5)},
	+ },
	+ wantOutput: "MixedInts = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n" +
	+ "MixedFloats = [1.5, 2.5]\n",
	+ },
	+ "(error) slice w/ element type mismatch (one is nested array)": {
	+ input: struct{ Mixed []interface{} }{
	+ []interface{}{1, []interface{}{2}},
	+ },
	+ wantError: errArrayMixedElementTypes,
	+ },
	+ "(error) slice with 1 nil element": {
	+ input: struct{ NilElement1 []interface{} }{[]interface{}{nil}},
	+ wantError: errArrayNilElement,
	+ },
	+ "(error) slice with 1 nil element (and other non-nil elements)": {
	+ input: struct{ NilElement []interface{} }{
	+ []interface{}{1, nil},
	+ },
	+ wantError: errArrayNilElement,
	+ },
	+ "simple map": {
	+ input: map[string]int{"a": 1, "b": 2},
	+ wantOutput: "a = 1\nb = 2\n",
	+ },
	+ "map with interface{} value type": {
	+ input: map[string]interface{}{"a": 1, "b": "c"},
	+ wantOutput: "a = 1\nb = \"c\"\n",
	+ },
	+ "map with interface{} value type, some of which are structs": {
	+ input: map[string]interface{}{
	+ "a": struct{ Int int }{2},
	+ "b": 1,
	+ },
	+ wantOutput: "b = 1\n\n[a]\n Int = 2\n",
	+ },
	+ "nested map": {
	+ input: map[string]map[string]int{
	+ "a": {"b": 1},
	+ "c": {"d": 2},
	+ },
	+ wantOutput: "[a]\n b = 1\n\n[c]\n d = 2\n",
	+ },
	+ "nested struct": {
	+ input: struct{ Struct struct{ Int int } }{
	+ struct{ Int int }{1},
	+ },
	+ wantOutput: "[Struct]\n Int = 1\n",
	+ },
	+ "nested struct and non-struct field": {
	+ input: struct {
	+ Struct struct{ Int int }
	+ Bool bool
	+ }{struct{ Int int }{1}, true},
	+ wantOutput: "Bool = true\n\n[Struct]\n Int = 1\n",
	+ },
	+ "2 nested structs": {
	+ input: struct{ Struct1, Struct2 struct{ Int int } }{
	+ struct{ Int int }{1}, struct{ Int int }{2},
	+ },
	+ wantOutput: "[Struct1]\n Int = 1\n\n[Struct2]\n Int = 2\n",
	+ },
	+ "deeply nested structs": {
	+ input: struct {
	+ Struct1, Struct2 struct{ Struct3 *struct{ Int int } }
	+ }{
	+ struct{ Struct3 *struct{ Int int } }{&struct{ Int int }{1}},
	+ struct{ Struct3 *struct{ Int int } }{nil},
	+ },
	+ wantOutput: "[Struct1]\n [Struct1.Struct3]\n Int = 1" +
	+ "\n\n[Struct2]\n",
	+ },
	+ "nested struct with nil struct elem": {
	+ input: struct {
	+ Struct struct{ Inner *struct{ Int int } }
	+ }{
	+ struct{ Inner *struct{ Int int } }{nil},
	+ },
	+ wantOutput: "[Struct]\n",
	+ },
	+ "nested struct with no fields": {
	+ input: struct {
	+ Struct struct{ Inner struct{} }
	+ }{
	+ struct{ Inner struct{} }{struct{}{}},
	+ },
	+ wantOutput: "[Struct]\n [Struct.Inner]\n",
	+ },
	+ "struct with tags": {
	+ input: struct {
	+ Struct struct {
	+ Int int `toml:"_int"`
	+ } `toml:"_struct"`
	+ Bool bool `toml:"_bool"`
	+ }{
	+ struct {
	+ Int int `toml:"_int"`
	+ }{1}, true,
	+ },
	+ wantOutput: "_bool = true\n\n[_struct]\n _int = 1\n",
	+ },
	+ "embedded struct": {
	+ input: struct{ Embedded }{Embedded{1}},
	+ wantOutput: "_int = 1\n",
	+ },
	+ "embedded *struct": {
	+ input: struct{ *Embedded }{&Embedded{1}},
	+ wantOutput: "_int = 1\n",
	+ },
	+ "nested embedded struct": {
	+ input: struct {
	+ Struct struct{ Embedded } `toml:"_struct"`
	+ }{struct{ Embedded }{Embedded{1}}},
	+ wantOutput: "[_struct]\n _int = 1\n",
	+ },
	+ "nested embedded *struct": {
	+ input: struct {
	+ Struct struct{ *Embedded } `toml:"_struct"`
	+ }{struct{ *Embedded }{&Embedded{1}}},
	+ wantOutput: "[_struct]\n _int = 1\n",
	+ },
	+ "embedded non-struct": {
	+ input: struct{ NonStruct }{5},
	+ wantOutput: "NonStruct = 5\n",
	+ },
	+ "array of tables": {
	+ input: struct {
	+ Structs []*struct{ Int int } `toml:"struct"`
	+ }{
	+ []*struct{ Int int }{{1}, {3}},
	+ },
	+ wantOutput: "[[struct]]\n Int = 1\n\n[[struct]]\n Int = 3\n",
	+ },
	+ "array of tables order": {
	+ input: map[string]interface{}{
	+ "map": map[string]interface{}{
	+ "zero": 5,
	+ "arr": []map[string]int{
	+ {
	+ "friend": 5,
	+ },
	+ },
	+ },
	+ },
	+ wantOutput: "[map]\n zero = 5\n\n [[map.arr]]\n friend = 5\n",
	+ },
	+ "(error) top-level slice": {
	+ input: []struct{ Int int }{{1}, {2}, {3}},
	+ wantError: errNoKey,
	+ },
	+ "(error) slice of slice": {
	+ input: struct {
	+ Slices [][]struct{ Int int }
	+ }{
	+ [][]struct{ Int int }{{{1}}, {{2}}, {{3}}},
	+ },
	+ wantError: errArrayNoTable,
	+ },
	+ "(error) map no string key": {
	+ input: map[int]string{1: ""},
	+ wantError: errNonString,
	+ },
	+ "(error) empty key name": {
	+ input: map[string]int{"": 1},
	+ wantError: errAnything,
	+ },
	+ "(error) empty map name": {
	+ input: map[string]interface{}{
	+ "": map[string]int{"v": 1},
	+ },
	+ wantError: errAnything,
	+ },
	+ }
	+ for label, test := range tests {
	+ encodeExpected(t, label, test.input, test.wantOutput, test.wantError)
	+ }
	+}
	+
	+func TestEncodeNestedTableArrays(t *testing.T) {
	+ type song struct {
	+ Name string `toml:"name"`
	+ }
	+ type album struct {
	+ Name string `toml:"name"`
	+ Songs []song `toml:"songs"`
	+ }
	+ type springsteen struct {
	+ Albums []album `toml:"albums"`
	+ }
	+ value := springsteen{
	+ []album{
	+ {"Born to Run",
	+ []song{{"Jungleland"}, {"Meeting Across the River"}}},
	+ {"Born in the USA",
	+ []song{{"Glory Days"}, {"Dancing in the Dark"}}},
	+ },
	+ }
	+ expected := `[[albums]]
	+ name = "Born to Run"
	+
	+ [[albums.songs]]
	+ name = "Jungleland"
	+
	+ [[albums.songs]]
	+ name = "Meeting Across the River"
	+
	+[[albums]]
	+ name = "Born in the USA"
	+
	+ [[albums.songs]]
	+ name = "Glory Days"
	+
	+ [[albums.songs]]
	+ name = "Dancing in the Dark"
	+`
	+ encodeExpected(t, "nested table arrays", value, expected, nil)
	+}
	+
	+func TestEncodeArrayHashWithNormalHashOrder(t *testing.T) {
	+ type Alpha struct {
	+ V int
	+ }
	+ type Beta struct {
	+ V int
	+ }
	+ type Conf struct {
	+ V int
	+ A Alpha
	+ B []Beta
	+ }
	+
	+ val := Conf{
	+ V: 1,
	+ A: Alpha{2},
	+ B: []Beta{{3}},
	+ }
	+ expected := "V = 1\n\n[A]\n V = 2\n\n[[B]]\n V = 3\n"
	+ encodeExpected(t, "array hash with normal hash order", val, expected, nil)
	+}
	+
	+func TestEncodeWithOmitEmpty(t *testing.T) {
	+ type simple struct {
	+ Bool bool `toml:"bool,omitempty"`
	+ String string `toml:"string,omitempty"`
	+ Array [0]byte `toml:"array,omitempty"`
	+ Slice []int `toml:"slice,omitempty"`
	+ Map map[string]string `toml:"map,omitempty"`
	+ }
	+
	+ var v simple
	+ encodeExpected(t, "fields with omitempty are omitted when empty", v, "", nil)
	+ v = simple{
	+ Bool: true,
	+ String: " ",
	+ Slice: []int{2, 3, 4},
	+ Map: map[string]string{"foo": "bar"},
	+ }
	+ expected := `bool = true
	+string = " "
	+slice = [2, 3, 4]
	+
	+[map]
	+ foo = "bar"
	+`
	+ encodeExpected(t, "fields with omitempty are not omitted when non-empty",
	+ v, expected, nil)
	+}
	+
	+func TestEncodeWithOmitZero(t *testing.T) {
	+ type simple struct {
	+ Number int `toml:"number,omitzero"`
	+ Real float64 `toml:"real,omitzero"`
	+ Unsigned uint `toml:"unsigned,omitzero"`
	+ }
	+
	+ value := simple{0, 0.0, uint(0)}
	+ expected := ""
	+
	+ encodeExpected(t, "simple with omitzero, all zero", value, expected, nil)
	+
	+ value.Number = 10
	+ value.Real = 20
	+ value.Unsigned = 5
	+ expected = `number = 10
	+real = 20.0
	+unsigned = 5
	+`
	+ encodeExpected(t, "simple with omitzero, non-zero", value, expected, nil)
	+}
	+
	+func TestEncodeOmitemptyWithEmptyName(t *testing.T) {
	+ type simple struct {
	+ S []int `toml:",omitempty"`
	+ }
	+ v := simple{[]int{1, 2, 3}}
	+ expected := "S = [1, 2, 3]\n"
	+ encodeExpected(t, "simple with omitempty, no name, non-empty field",
	+ v, expected, nil)
	+}
	+
	+func TestEncodeAnonymousStruct(t *testing.T) {
	+ type Inner struct{ N int }
	+ type Outer0 struct{ Inner }
	+ type Outer1 struct {
	+ Inner `toml:"inner"`
	+ }
	+
	+ v0 := Outer0{Inner{3}}
	+ expected := "N = 3\n"
	+ encodeExpected(t, "embedded anonymous untagged struct", v0, expected, nil)
	+
	+ v1 := Outer1{Inner{3}}
	+ expected = "[inner]\n N = 3\n"
	+ encodeExpected(t, "embedded anonymous tagged struct", v1, expected, nil)
	+}
	+
	+func TestEncodeAnonymousStructPointerField(t *testing.T) {
	+ type Inner struct{ N int }
	+ type Outer0 struct{ *Inner }
	+ type Outer1 struct {
	+ *Inner `toml:"inner"`
	+ }
	+
	+ v0 := Outer0{}
	+ expected := ""
	+ encodeExpected(t, "nil anonymous untagged struct pointer field", v0, expected, nil)
	+
	+ v0 = Outer0{&Inner{3}}
	+ expected = "N = 3\n"
	+ encodeExpected(t, "non-nil anonymous untagged struct pointer field", v0, expected, nil)
	+
	+ v1 := Outer1{}
	+ expected = ""
	+ encodeExpected(t, "nil anonymous tagged struct pointer field", v1, expected, nil)
	+
	+ v1 = Outer1{&Inner{3}}
	+ expected = "[inner]\n N = 3\n"
	+ encodeExpected(t, "non-nil anonymous tagged struct pointer field", v1, expected, nil)
	+}
	+
	+func TestEncodeIgnoredFields(t *testing.T) {
	+ type simple struct {
	+ Number int `toml:"-"`
	+ }
	+ value := simple{}
	+ expected := ""
	+ encodeExpected(t, "ignored field", value, expected, nil)
	+}
	+
	+func encodeExpected(
	+ t *testing.T, label string, val interface{}, wantStr string, wantErr error,
	+) {
	+ var buf bytes.Buffer
	+ enc := NewEncoder(&buf)
	+ err := enc.Encode(val)
	+ if err != wantErr {
	+ if wantErr != nil {
	+ if wantErr == errAnything && err != nil {
	+ return
	+ }
	+ t.Errorf("%s: want Encode error %v, got %v", label, wantErr, err)
	+ } else {
	+ t.Errorf("%s: Encode failed: %s", label, err)
	+ }
	+ }
	+ if err != nil {
	+ return
	+ }
	+ if got := buf.String(); wantStr != got {
	+ t.Errorf("%s: want\n-----\n%q\n-----\nbut got\n-----\n%q\n-----\n",
	+ label, wantStr, got)
	+ }
	+}
	+
	+func ExampleEncoder_Encode() {
	+ date, _ := time.Parse(time.RFC822, "14 Mar 10 18:00 UTC")
	+ var config = map[string]interface{}{
	+ "date": date,
	+ "counts": []int{1, 1, 2, 3, 5, 8},
	+ "hash": map[string]string{
	+ "key1": "val1",
	+ "key2": "val2",
	+ },
	+ }
	+ buf := new(bytes.Buffer)
	+ if err := NewEncoder(buf).Encode(config); err != nil {
	+ log.Fatal(err)
	+ }
	+ fmt.Println(buf.String())
	+
	+ // Output:
	+ // counts = [1, 1, 2, 3, 5, 8]
	+ // date = 2010-03-14T18:00:00Z
	+ //
	+ // [hash]
	+ // key1 = "val1"
	+ // key2 = "val2"
	+}
	diff --git a/src/github.com/BurntSushi/toml/encoding_types.go b/src/github.com/BurntSushi/toml/encoding_types.go
	new file mode 100644
	index 0000000..d36e1dd
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/encoding_types.go
	@@ -0,0 +1,19 @@
	+// +build go1.2
	+
	+package toml
	+
	+// In order to support Go 1.1, we define our own TextMarshaler and
	+// TextUnmarshaler types. For Go 1.2+, we just alias them with the
	+// standard library interfaces.
	+
	+import (
	+ "encoding"
	+)
	+
	+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
	+// so that Go 1.1 can be supported.
	+type TextMarshaler encoding.TextMarshaler
	+
	+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
	+// here so that Go 1.1 can be supported.
	+type TextUnmarshaler encoding.TextUnmarshaler
	diff --git a/src/github.com/BurntSushi/toml/encoding_types_1.1.go b/src/github.com/BurntSushi/toml/encoding_types_1.1.go
	new file mode 100644
	index 0000000..e8d503d
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/encoding_types_1.1.go
	@@ -0,0 +1,18 @@
	+// +build !go1.2
	+
	+package toml
	+
	+// These interfaces were introduced in Go 1.2, so we add them manually when
	+// compiling for Go 1.1.
	+
	+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
	+// so that Go 1.1 can be supported.
	+type TextMarshaler interface {
	+ MarshalText() (text []byte, err error)
	+}
	+
	+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
	+// here so that Go 1.1 can be supported.
	+type TextUnmarshaler interface {
	+ UnmarshalText(text []byte) error
	+}
	diff --git a/src/github.com/BurntSushi/toml/lex.go b/src/github.com/BurntSushi/toml/lex.go
	new file mode 100644
	index 0000000..e0a742a
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/lex.go
	@@ -0,0 +1,953 @@
	+package toml
	+
	+import (
	+ "fmt"
	+ "strings"
	+ "unicode"
	+ "unicode/utf8"
	+)
	+
	+type itemType int
	+
	+const (
	+ itemError itemType = iota
	+ itemNIL // used in the parser to indicate no type
	+ itemEOF
	+ itemText
	+ itemString
	+ itemRawString
	+ itemMultilineString
	+ itemRawMultilineString
	+ itemBool
	+ itemInteger
	+ itemFloat
	+ itemDatetime
	+ itemArray // the start of an array
	+ itemArrayEnd
	+ itemTableStart
	+ itemTableEnd
	+ itemArrayTableStart
	+ itemArrayTableEnd
	+ itemKeyStart
	+ itemCommentStart
	+ itemInlineTableStart
	+ itemInlineTableEnd
	+)
	+
	+const (
	+ eof = 0
	+ comma = ','
	+ tableStart = '['
	+ tableEnd = ']'
	+ arrayTableStart = '['
	+ arrayTableEnd = ']'
	+ tableSep = '.'
	+ keySep = '='
	+ arrayStart = '['
	+ arrayEnd = ']'
	+ commentStart = '#'
	+ stringStart = '"'
	+ stringEnd = '"'
	+ rawStringStart = '\''
	+ rawStringEnd = '\''
	+ inlineTableStart = '{'
	+ inlineTableEnd = '}'
	+)
	+
	+type stateFn func(lx *lexer) stateFn
	+
	+type lexer struct {
	+ input string
	+ start int
	+ pos int
	+ line int
	+ state stateFn
	+ items chan item
	+
	+ // Allow for backing up up to three runes.
	+ // This is necessary because TOML contains 3-rune tokens (""" and ''').
	+ prevWidths [3]int
	+ nprev int // how many of prevWidths are in use
	+ // If we emit an eof, we can still back up, but it is not OK to call
	+ // next again.
	+ atEOF bool
	+
	+ // A stack of state functions used to maintain context.
	+ // The idea is to reuse parts of the state machine in various places.
	+ // For example, values can appear at the top level or within arbitrarily
	+ // nested arrays. The last state on the stack is used after a value has
	+ // been lexed. Similarly for comments.
	+ stack []stateFn
	+}
	+
	+type item struct {
	+ typ itemType
	+ val string
	+ line int
	+}
	+
	+func (lx *lexer) nextItem() item {
	+ for {
	+ select {
	+ case item := <-lx.items:
	+ return item
	+ default:
	+ lx.state = lx.state(lx)
	+ }
	+ }
	+}
	+
	+func lex(input string) *lexer {
	+ lx := &lexer{
	+ input: input,
	+ state: lexTop,
	+ line: 1,
	+ items: make(chan item, 10),
	+ stack: make([]stateFn, 0, 10),
	+ }
	+ return lx
	+}
	+
	+func (lx *lexer) push(state stateFn) {
	+ lx.stack = append(lx.stack, state)
	+}
	+
	+func (lx *lexer) pop() stateFn {
	+ if len(lx.stack) == 0 {
	+ return lx.errorf("BUG in lexer: no states to pop")
	+ }
	+ last := lx.stack[len(lx.stack)-1]
	+ lx.stack = lx.stack[0 : len(lx.stack)-1]
	+ return last
	+}
	+
	+func (lx *lexer) current() string {
	+ return lx.input[lx.start:lx.pos]
	+}
	+
	+func (lx *lexer) emit(typ itemType) {
	+ lx.items <- item{typ, lx.current(), lx.line}
	+ lx.start = lx.pos
	+}
	+
	+func (lx *lexer) emitTrim(typ itemType) {
	+ lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line}
	+ lx.start = lx.pos
	+}
	+
	+func (lx *lexer) next() (r rune) {
	+ if lx.atEOF {
	+ panic("next called after EOF")
	+ }
	+ if lx.pos >= len(lx.input) {
	+ lx.atEOF = true
	+ return eof
	+ }
	+
	+ if lx.input[lx.pos] == '\n' {
	+ lx.line++
	+ }
	+ lx.prevWidths[2] = lx.prevWidths[1]
	+ lx.prevWidths[1] = lx.prevWidths[0]
	+ if lx.nprev < 3 {
	+ lx.nprev++
	+ }
	+ r, w := utf8.DecodeRuneInString(lx.input[lx.pos:])
	+ lx.prevWidths[0] = w
	+ lx.pos += w
	+ return r
	+}
	+
	+// ignore skips over the pending input before this point.
	+func (lx *lexer) ignore() {
	+ lx.start = lx.pos
	+}
	+
	+// backup steps back one rune. Can be called only twice between calls to next.
	+func (lx *lexer) backup() {
	+ if lx.atEOF {
	+ lx.atEOF = false
	+ return
	+ }
	+ if lx.nprev < 1 {
	+ panic("backed up too far")
	+ }
	+ w := lx.prevWidths[0]
	+ lx.prevWidths[0] = lx.prevWidths[1]
	+ lx.prevWidths[1] = lx.prevWidths[2]
	+ lx.nprev--
	+ lx.pos -= w
	+ if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {
	+ lx.line--
	+ }
	+}
	+
	+// accept consumes the next rune if it's equal to `valid`.
	+func (lx *lexer) accept(valid rune) bool {
	+ if lx.next() == valid {
	+ return true
	+ }
	+ lx.backup()
	+ return false
	+}
	+
	+// peek returns but does not consume the next rune in the input.
	+func (lx *lexer) peek() rune {
	+ r := lx.next()
	+ lx.backup()
	+ return r
	+}
	+
	+// skip ignores all input that matches the given predicate.
	+func (lx *lexer) skip(pred func(rune) bool) {
	+ for {
	+ r := lx.next()
	+ if pred(r) {
	+ continue
	+ }
	+ lx.backup()
	+ lx.ignore()
	+ return
	+ }
	+}
	+
	+// errorf stops all lexing by emitting an error and returning `nil`.
	+// Note that any value that is a character is escaped if it's a special
	+// character (newlines, tabs, etc.).
	+func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
	+ lx.items <- item{
	+ itemError,
	+ fmt.Sprintf(format, values...),
	+ lx.line,
	+ }
	+ return nil
	+}
	+
	+// lexTop consumes elements at the top level of TOML data.
	+func lexTop(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isWhitespace(r) \|\| isNL(r) {
	+ return lexSkip(lx, lexTop)
	+ }
	+ switch r {
	+ case commentStart:
	+ lx.push(lexTop)
	+ return lexCommentStart
	+ case tableStart:
	+ return lexTableStart
	+ case eof:
	+ if lx.pos > lx.start {
	+ return lx.errorf("unexpected EOF")
	+ }
	+ lx.emit(itemEOF)
	+ return nil
	+ }
	+
	+ // At this point, the only valid item can be a key, so we back up
	+ // and let the key lexer do the rest.
	+ lx.backup()
	+ lx.push(lexTopEnd)
	+ return lexKeyStart
	+}
	+
	+// lexTopEnd is entered whenever a top-level item has been consumed. (A value
	+// or a table.) It must see only whitespace, and will turn back to lexTop
	+// upon a newline. If it sees EOF, it will quit the lexer successfully.
	+func lexTopEnd(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case r == commentStart:
	+ // a comment will read to a newline for us.
	+ lx.push(lexTop)
	+ return lexCommentStart
	+ case isWhitespace(r):
	+ return lexTopEnd
	+ case isNL(r):
	+ lx.ignore()
	+ return lexTop
	+ case r == eof:
	+ lx.emit(itemEOF)
	+ return nil
	+ }
	+ return lx.errorf("expected a top-level item to end with a newline, "+
	+ "comment, or EOF, but got %q instead", r)
	+}
	+
	+// lexTable lexes the beginning of a table. Namely, it makes sure that
	+// it starts with a character other than '.' and ']'.
	+// It assumes that '[' has already been consumed.
	+// It also handles the case that this is an item in an array of tables.
	+// e.g., '[[name]]'.
	+func lexTableStart(lx *lexer) stateFn {
	+ if lx.peek() == arrayTableStart {
	+ lx.next()
	+ lx.emit(itemArrayTableStart)
	+ lx.push(lexArrayTableEnd)
	+ } else {
	+ lx.emit(itemTableStart)
	+ lx.push(lexTableEnd)
	+ }
	+ return lexTableNameStart
	+}
	+
	+func lexTableEnd(lx *lexer) stateFn {
	+ lx.emit(itemTableEnd)
	+ return lexTopEnd
	+}
	+
	+func lexArrayTableEnd(lx *lexer) stateFn {
	+ if r := lx.next(); r != arrayTableEnd {
	+ return lx.errorf("expected end of table array name delimiter %q, "+
	+ "but got %q instead", arrayTableEnd, r)
	+ }
	+ lx.emit(itemArrayTableEnd)
	+ return lexTopEnd
	+}
	+
	+func lexTableNameStart(lx *lexer) stateFn {
	+ lx.skip(isWhitespace)
	+ switch r := lx.peek(); {
	+ case r == tableEnd \|\| r == eof:
	+ return lx.errorf("unexpected end of table name " +
	+ "(table names cannot be empty)")
	+ case r == tableSep:
	+ return lx.errorf("unexpected table separator " +
	+ "(table names cannot be empty)")
	+ case r == stringStart \|\| r == rawStringStart:
	+ lx.ignore()
	+ lx.push(lexTableNameEnd)
	+ return lexValue // reuse string lexing
	+ default:
	+ return lexBareTableName
	+ }
	+}
	+
	+// lexBareTableName lexes the name of a table. It assumes that at least one
	+// valid character for the table has already been read.
	+func lexBareTableName(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isBareKeyChar(r) {
	+ return lexBareTableName
	+ }
	+ lx.backup()
	+ lx.emit(itemText)
	+ return lexTableNameEnd
	+}
	+
	+// lexTableNameEnd reads the end of a piece of a table name, optionally
	+// consuming whitespace.
	+func lexTableNameEnd(lx *lexer) stateFn {
	+ lx.skip(isWhitespace)
	+ switch r := lx.next(); {
	+ case isWhitespace(r):
	+ return lexTableNameEnd
	+ case r == tableSep:
	+ lx.ignore()
	+ return lexTableNameStart
	+ case r == tableEnd:
	+ return lx.pop()
	+ default:
	+ return lx.errorf("expected '.' or ']' to end table name, "+
	+ "but got %q instead", r)
	+ }
	+}
	+
	+// lexKeyStart consumes a key name up until the first non-whitespace character.
	+// lexKeyStart will ignore whitespace.
	+func lexKeyStart(lx *lexer) stateFn {
	+ r := lx.peek()
	+ switch {
	+ case r == keySep:
	+ return lx.errorf("unexpected key separator %q", keySep)
	+ case isWhitespace(r) \|\| isNL(r):
	+ lx.next()
	+ return lexSkip(lx, lexKeyStart)
	+ case r == stringStart \|\| r == rawStringStart:
	+ lx.ignore()
	+ lx.emit(itemKeyStart)
	+ lx.push(lexKeyEnd)
	+ return lexValue // reuse string lexing
	+ default:
	+ lx.ignore()
	+ lx.emit(itemKeyStart)
	+ return lexBareKey
	+ }
	+}
	+
	+// lexBareKey consumes the text of a bare key. Assumes that the first character
	+// (which is not whitespace) has not yet been consumed.
	+func lexBareKey(lx *lexer) stateFn {
	+ switch r := lx.next(); {
	+ case isBareKeyChar(r):
	+ return lexBareKey
	+ case isWhitespace(r):
	+ lx.backup()
	+ lx.emit(itemText)
	+ return lexKeyEnd
	+ case r == keySep:
	+ lx.backup()
	+ lx.emit(itemText)
	+ return lexKeyEnd
	+ default:
	+ return lx.errorf("bare keys cannot contain %q", r)
	+ }
	+}
	+
	+// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
	+// separator).
	+func lexKeyEnd(lx *lexer) stateFn {
	+ switch r := lx.next(); {
	+ case r == keySep:
	+ return lexSkip(lx, lexValue)
	+ case isWhitespace(r):
	+ return lexSkip(lx, lexKeyEnd)
	+ default:
	+ return lx.errorf("expected key separator %q, but got %q instead",
	+ keySep, r)
	+ }
	+}
	+
	+// lexValue starts the consumption of a value anywhere a value is expected.
	+// lexValue will ignore whitespace.
	+// After a value is lexed, the last state on the next is popped and returned.
	+func lexValue(lx *lexer) stateFn {
	+ // We allow whitespace to precede a value, but NOT newlines.
	+ // In array syntax, the array states are responsible for ignoring newlines.
	+ r := lx.next()
	+ switch {
	+ case isWhitespace(r):
	+ return lexSkip(lx, lexValue)
	+ case isDigit(r):
	+ lx.backup() // avoid an extra state and use the same as above
	+ return lexNumberOrDateStart
	+ }
	+ switch r {
	+ case arrayStart:
	+ lx.ignore()
	+ lx.emit(itemArray)
	+ return lexArrayValue
	+ case inlineTableStart:
	+ lx.ignore()
	+ lx.emit(itemInlineTableStart)
	+ return lexInlineTableValue
	+ case stringStart:
	+ if lx.accept(stringStart) {
	+ if lx.accept(stringStart) {
	+ lx.ignore() // Ignore """
	+ return lexMultilineString
	+ }
	+ lx.backup()
	+ }
	+ lx.ignore() // ignore the '"'
	+ return lexString
	+ case rawStringStart:
	+ if lx.accept(rawStringStart) {
	+ if lx.accept(rawStringStart) {
	+ lx.ignore() // Ignore """
	+ return lexMultilineRawString
	+ }
	+ lx.backup()
	+ }
	+ lx.ignore() // ignore the "'"
	+ return lexRawString
	+ case '+', '-':
	+ return lexNumberStart
	+ case '.': // special error case, be kind to users
	+ return lx.errorf("floats must start with a digit, not '.'")
	+ }
	+ if unicode.IsLetter(r) {
	+ // Be permissive here; lexBool will give a nice error if the
	+ // user wrote something like
	+ // x = foo
	+ // (i.e. not 'true' or 'false' but is something else word-like.)
	+ lx.backup()
	+ return lexBool
	+ }
	+ return lx.errorf("expected value but found %q instead", r)
	+}
	+
	+// lexArrayValue consumes one value in an array. It assumes that '[' or ','
	+// have already been consumed. All whitespace and newlines are ignored.
	+func lexArrayValue(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case isWhitespace(r) \|\| isNL(r):
	+ return lexSkip(lx, lexArrayValue)
	+ case r == commentStart:
	+ lx.push(lexArrayValue)
	+ return lexCommentStart
	+ case r == comma:
	+ return lx.errorf("unexpected comma")
	+ case r == arrayEnd:
	+ // NOTE(caleb): The spec isn't clear about whether you can have
	+ // a trailing comma or not, so we'll allow it.
	+ return lexArrayEnd
	+ }
	+
	+ lx.backup()
	+ lx.push(lexArrayValueEnd)
	+ return lexValue
	+}
	+
	+// lexArrayValueEnd consumes everything between the end of an array value and
	+// the next value (or the end of the array): it ignores whitespace and newlines
	+// and expects either a ',' or a ']'.
	+func lexArrayValueEnd(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case isWhitespace(r) \|\| isNL(r):
	+ return lexSkip(lx, lexArrayValueEnd)
	+ case r == commentStart:
	+ lx.push(lexArrayValueEnd)
	+ return lexCommentStart
	+ case r == comma:
	+ lx.ignore()
	+ return lexArrayValue // move on to the next value
	+ case r == arrayEnd:
	+ return lexArrayEnd
	+ }
	+ return lx.errorf(
	+ "expected a comma or array terminator %q, but got %q instead",
	+ arrayEnd, r,
	+ )
	+}
	+
	+// lexArrayEnd finishes the lexing of an array.
	+// It assumes that a ']' has just been consumed.
	+func lexArrayEnd(lx *lexer) stateFn {
	+ lx.ignore()
	+ lx.emit(itemArrayEnd)
	+ return lx.pop()
	+}
	+
	+// lexInlineTableValue consumes one key/value pair in an inline table.
	+// It assumes that '{' or ',' have already been consumed. Whitespace is ignored.
	+func lexInlineTableValue(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case isWhitespace(r):
	+ return lexSkip(lx, lexInlineTableValue)
	+ case isNL(r):
	+ return lx.errorf("newlines not allowed within inline tables")
	+ case r == commentStart:
	+ lx.push(lexInlineTableValue)
	+ return lexCommentStart
	+ case r == comma:
	+ return lx.errorf("unexpected comma")
	+ case r == inlineTableEnd:
	+ return lexInlineTableEnd
	+ }
	+ lx.backup()
	+ lx.push(lexInlineTableValueEnd)
	+ return lexKeyStart
	+}
	+
	+// lexInlineTableValueEnd consumes everything between the end of an inline table
	+// key/value pair and the next pair (or the end of the table):
	+// it ignores whitespace and expects either a ',' or a '}'.
	+func lexInlineTableValueEnd(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case isWhitespace(r):
	+ return lexSkip(lx, lexInlineTableValueEnd)
	+ case isNL(r):
	+ return lx.errorf("newlines not allowed within inline tables")
	+ case r == commentStart:
	+ lx.push(lexInlineTableValueEnd)
	+ return lexCommentStart
	+ case r == comma:
	+ lx.ignore()
	+ return lexInlineTableValue
	+ case r == inlineTableEnd:
	+ return lexInlineTableEnd
	+ }
	+ return lx.errorf("expected a comma or an inline table terminator %q, "+
	+ "but got %q instead", inlineTableEnd, r)
	+}
	+
	+// lexInlineTableEnd finishes the lexing of an inline table.
	+// It assumes that a '}' has just been consumed.
	+func lexInlineTableEnd(lx *lexer) stateFn {
	+ lx.ignore()
	+ lx.emit(itemInlineTableEnd)
	+ return lx.pop()
	+}
	+
	+// lexString consumes the inner contents of a string. It assumes that the
	+// beginning '"' has already been consumed and ignored.
	+func lexString(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case r == eof:
	+ return lx.errorf("unexpected EOF")
	+ case isNL(r):
	+ return lx.errorf("strings cannot contain newlines")
	+ case r == '\\':
	+ lx.push(lexString)
	+ return lexStringEscape
	+ case r == stringEnd:
	+ lx.backup()
	+ lx.emit(itemString)
	+ lx.next()
	+ lx.ignore()
	+ return lx.pop()
	+ }
	+ return lexString
	+}
	+
	+// lexMultilineString consumes the inner contents of a string. It assumes that
	+// the beginning '"""' has already been consumed and ignored.
	+func lexMultilineString(lx *lexer) stateFn {
	+ switch lx.next() {
	+ case eof:
	+ return lx.errorf("unexpected EOF")
	+ case '\\':
	+ return lexMultilineStringEscape
	+ case stringEnd:
	+ if lx.accept(stringEnd) {
	+ if lx.accept(stringEnd) {
	+ lx.backup()
	+ lx.backup()
	+ lx.backup()
	+ lx.emit(itemMultilineString)
	+ lx.next()
	+ lx.next()
	+ lx.next()
	+ lx.ignore()
	+ return lx.pop()
	+ }
	+ lx.backup()
	+ }
	+ }
	+ return lexMultilineString
	+}
	+
	+// lexRawString consumes a raw string. Nothing can be escaped in such a string.
	+// It assumes that the beginning "'" has already been consumed and ignored.
	+func lexRawString(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch {
	+ case r == eof:
	+ return lx.errorf("unexpected EOF")
	+ case isNL(r):
	+ return lx.errorf("strings cannot contain newlines")
	+ case r == rawStringEnd:
	+ lx.backup()
	+ lx.emit(itemRawString)
	+ lx.next()
	+ lx.ignore()
	+ return lx.pop()
	+ }
	+ return lexRawString
	+}
	+
	+// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
	+// a string. It assumes that the beginning "'''" has already been consumed and
	+// ignored.
	+func lexMultilineRawString(lx *lexer) stateFn {
	+ switch lx.next() {
	+ case eof:
	+ return lx.errorf("unexpected EOF")
	+ case rawStringEnd:
	+ if lx.accept(rawStringEnd) {
	+ if lx.accept(rawStringEnd) {
	+ lx.backup()
	+ lx.backup()
	+ lx.backup()
	+ lx.emit(itemRawMultilineString)
	+ lx.next()
	+ lx.next()
	+ lx.next()
	+ lx.ignore()
	+ return lx.pop()
	+ }
	+ lx.backup()
	+ }
	+ }
	+ return lexMultilineRawString
	+}
	+
	+// lexMultilineStringEscape consumes an escaped character. It assumes that the
	+// preceding '\\' has already been consumed.
	+func lexMultilineStringEscape(lx *lexer) stateFn {
	+ // Handle the special case first:
	+ if isNL(lx.next()) {
	+ return lexMultilineString
	+ }
	+ lx.backup()
	+ lx.push(lexMultilineString)
	+ return lexStringEscape(lx)
	+}
	+
	+func lexStringEscape(lx *lexer) stateFn {
	+ r := lx.next()
	+ switch r {
	+ case 'b':
	+ fallthrough
	+ case 't':
	+ fallthrough
	+ case 'n':
	+ fallthrough
	+ case 'f':
	+ fallthrough
	+ case 'r':
	+ fallthrough
	+ case '"':
	+ fallthrough
	+ case '\\':
	+ return lx.pop()
	+ case 'u':
	+ return lexShortUnicodeEscape
	+ case 'U':
	+ return lexLongUnicodeEscape
	+ }
	+ return lx.errorf("invalid escape character %q; only the following "+
	+ "escape characters are allowed: "+
	+ `\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r)
	+}
	+
	+func lexShortUnicodeEscape(lx *lexer) stateFn {
	+ var r rune
	+ for i := 0; i < 4; i++ {
	+ r = lx.next()
	+ if !isHexadecimal(r) {
	+ return lx.errorf(`expected four hexadecimal digits after '\u', `+
	+ "but got %q instead", lx.current())
	+ }
	+ }
	+ return lx.pop()
	+}
	+
	+func lexLongUnicodeEscape(lx *lexer) stateFn {
	+ var r rune
	+ for i := 0; i < 8; i++ {
	+ r = lx.next()
	+ if !isHexadecimal(r) {
	+ return lx.errorf(`expected eight hexadecimal digits after '\U', `+
	+ "but got %q instead", lx.current())
	+ }
	+ }
	+ return lx.pop()
	+}
	+
	+// lexNumberOrDateStart consumes either an integer, a float, or datetime.
	+func lexNumberOrDateStart(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isDigit(r) {
	+ return lexNumberOrDate
	+ }
	+ switch r {
	+ case '_':
	+ return lexNumber
	+ case 'e', 'E':
	+ return lexFloat
	+ case '.':
	+ return lx.errorf("floats must start with a digit, not '.'")
	+ }
	+ return lx.errorf("expected a digit but got %q", r)
	+}
	+
	+// lexNumberOrDate consumes either an integer, float or datetime.
	+func lexNumberOrDate(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isDigit(r) {
	+ return lexNumberOrDate
	+ }
	+ switch r {
	+ case '-':
	+ return lexDatetime
	+ case '_':
	+ return lexNumber
	+ case '.', 'e', 'E':
	+ return lexFloat
	+ }
	+
	+ lx.backup()
	+ lx.emit(itemInteger)
	+ return lx.pop()
	+}
	+
	+// lexDatetime consumes a Datetime, to a first approximation.
	+// The parser validates that it matches one of the accepted formats.
	+func lexDatetime(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isDigit(r) {
	+ return lexDatetime
	+ }
	+ switch r {
	+ case '-', 'T', ':', '.', 'Z', '+':
	+ return lexDatetime
	+ }
	+
	+ lx.backup()
	+ lx.emit(itemDatetime)
	+ return lx.pop()
	+}
	+
	+// lexNumberStart consumes either an integer or a float. It assumes that a sign
	+// has already been read, but that no digits have been consumed.
	+// lexNumberStart will move to the appropriate integer or float states.
	+func lexNumberStart(lx *lexer) stateFn {
	+ // We MUST see a digit. Even floats have to start with a digit.
	+ r := lx.next()
	+ if !isDigit(r) {
	+ if r == '.' {
	+ return lx.errorf("floats must start with a digit, not '.'")
	+ }
	+ return lx.errorf("expected a digit but got %q", r)
	+ }
	+ return lexNumber
	+}
	+
	+// lexNumber consumes an integer or a float after seeing the first digit.
	+func lexNumber(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isDigit(r) {
	+ return lexNumber
	+ }
	+ switch r {
	+ case '_':
	+ return lexNumber
	+ case '.', 'e', 'E':
	+ return lexFloat
	+ }
	+
	+ lx.backup()
	+ lx.emit(itemInteger)
	+ return lx.pop()
	+}
	+
	+// lexFloat consumes the elements of a float. It allows any sequence of
	+// float-like characters, so floats emitted by the lexer are only a first
	+// approximation and must be validated by the parser.
	+func lexFloat(lx *lexer) stateFn {
	+ r := lx.next()
	+ if isDigit(r) {
	+ return lexFloat
	+ }
	+ switch r {
	+ case '_', '.', '-', '+', 'e', 'E':
	+ return lexFloat
	+ }
	+
	+ lx.backup()
	+ lx.emit(itemFloat)
	+ return lx.pop()
	+}
	+
	+// lexBool consumes a bool string: 'true' or 'false.
	+func lexBool(lx *lexer) stateFn {
	+ var rs []rune
	+ for {
	+ r := lx.next()
	+ if !unicode.IsLetter(r) {
	+ lx.backup()
	+ break
	+ }
	+ rs = append(rs, r)
	+ }
	+ s := string(rs)
	+ switch s {
	+ case "true", "false":
	+ lx.emit(itemBool)
	+ return lx.pop()
	+ }
	+ return lx.errorf("expected value but found %q instead", s)
	+}
	+
	+// lexCommentStart begins the lexing of a comment. It will emit
	+// itemCommentStart and consume no characters, passing control to lexComment.
	+func lexCommentStart(lx *lexer) stateFn {
	+ lx.ignore()
	+ lx.emit(itemCommentStart)
	+ return lexComment
	+}
	+
	+// lexComment lexes an entire comment. It assumes that '#' has been consumed.
	+// It will consume up to the first newline character, and pass control
	+// back to the last state on the stack.
	+func lexComment(lx *lexer) stateFn {
	+ r := lx.peek()
	+ if isNL(r) \|\| r == eof {
	+ lx.emit(itemText)
	+ return lx.pop()
	+ }
	+ lx.next()
	+ return lexComment
	+}
	+
	+// lexSkip ignores all slurped input and moves on to the next state.
	+func lexSkip(lx *lexer, nextState stateFn) stateFn {
	+ return func(lx *lexer) stateFn {
	+ lx.ignore()
	+ return nextState
	+ }
	+}
	+
	+// isWhitespace returns true if `r` is a whitespace character according
	+// to the spec.
	+func isWhitespace(r rune) bool {
	+ return r == '\t' \|\| r == ' '
	+}
	+
	+func isNL(r rune) bool {
	+ return r == '\n' \|\| r == '\r'
	+}
	+
	+func isDigit(r rune) bool {
	+ return r >= '0' && r <= '9'
	+}
	+
	+func isHexadecimal(r rune) bool {
	+ return (r >= '0' && r <= '9') \|\|
	+ (r >= 'a' && r <= 'f') \|\|
	+ (r >= 'A' && r <= 'F')
	+}
	+
	+func isBareKeyChar(r rune) bool {
	+ return (r >= 'A' && r <= 'Z') \|\|
	+ (r >= 'a' && r <= 'z') \|\|
	+ (r >= '0' && r <= '9') \|\|
	+ r == '_' \|\|
	+ r == '-'
	+}
	+
	+func (itype itemType) String() string {
	+ switch itype {
	+ case itemError:
	+ return "Error"
	+ case itemNIL:
	+ return "NIL"
	+ case itemEOF:
	+ return "EOF"
	+ case itemText:
	+ return "Text"
	+ case itemString, itemRawString, itemMultilineString, itemRawMultilineString:
	+ return "String"
	+ case itemBool:
	+ return "Bool"
	+ case itemInteger:
	+ return "Integer"
	+ case itemFloat:
	+ return "Float"
	+ case itemDatetime:
	+ return "DateTime"
	+ case itemTableStart:
	+ return "TableStart"
	+ case itemTableEnd:
	+ return "TableEnd"
	+ case itemKeyStart:
	+ return "KeyStart"
	+ case itemArray:
	+ return "Array"
	+ case itemArrayEnd:
	+ return "ArrayEnd"
	+ case itemCommentStart:
	+ return "CommentStart"
	+ }
	+ panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype)))
	+}
	+
	+func (item item) String() string {
	+ return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val)
	+}
	diff --git a/src/github.com/BurntSushi/toml/parse.go b/src/github.com/BurntSushi/toml/parse.go
	new file mode 100644
	index 0000000..50869ef
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/parse.go
	@@ -0,0 +1,592 @@
	+package toml
	+
	+import (
	+ "fmt"
	+ "strconv"
	+ "strings"
	+ "time"
	+ "unicode"
	+ "unicode/utf8"
	+)
	+
	+type parser struct {
	+ mapping map[string]interface{}
	+ types map[string]tomlType
	+ lx *lexer
	+
	+ // A list of keys in the order that they appear in the TOML data.
	+ ordered []Key
	+
	+ // the full key for the current hash in scope
	+ context Key
	+
	+ // the base key name for everything except hashes
	+ currentKey string
	+
	+ // rough approximation of line number
	+ approxLine int
	+
	+ // A map of 'key.group.names' to whether they were created implicitly.
	+ implicits map[string]bool
	+}
	+
	+type parseError string
	+
	+func (pe parseError) Error() string {
	+ return string(pe)
	+}
	+
	+func parse(data string) (p *parser, err error) {
	+ defer func() {
	+ if r := recover(); r != nil {
	+ var ok bool
	+ if err, ok = r.(parseError); ok {
	+ return
	+ }
	+ panic(r)
	+ }
	+ }()
	+
	+ p = &parser{
	+ mapping: make(map[string]interface{}),
	+ types: make(map[string]tomlType),
	+ lx: lex(data),
	+ ordered: make([]Key, 0),
	+ implicits: make(map[string]bool),
	+ }
	+ for {
	+ item := p.next()
	+ if item.typ == itemEOF {
	+ break
	+ }
	+ p.topLevel(item)
	+ }
	+
	+ return p, nil
	+}
	+
	+func (p *parser) panicf(format string, v ...interface{}) {
	+ msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s",
	+ p.approxLine, p.current(), fmt.Sprintf(format, v...))
	+ panic(parseError(msg))
	+}
	+
	+func (p *parser) next() item {
	+ it := p.lx.nextItem()
	+ if it.typ == itemError {
	+ p.panicf("%s", it.val)
	+ }
	+ return it
	+}
	+
	+func (p *parser) bug(format string, v ...interface{}) {
	+ panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
	+}
	+
	+func (p *parser) expect(typ itemType) item {
	+ it := p.next()
	+ p.assertEqual(typ, it.typ)
	+ return it
	+}
	+
	+func (p *parser) assertEqual(expected, got itemType) {
	+ if expected != got {
	+ p.bug("Expected '%s' but got '%s'.", expected, got)
	+ }
	+}
	+
	+func (p *parser) topLevel(item item) {
	+ switch item.typ {
	+ case itemCommentStart:
	+ p.approxLine = item.line
	+ p.expect(itemText)
	+ case itemTableStart:
	+ kg := p.next()
	+ p.approxLine = kg.line
	+
	+ var key Key
	+ for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() {
	+ key = append(key, p.keyString(kg))
	+ }
	+ p.assertEqual(itemTableEnd, kg.typ)
	+
	+ p.establishContext(key, false)
	+ p.setType("", tomlHash)
	+ p.ordered = append(p.ordered, key)
	+ case itemArrayTableStart:
	+ kg := p.next()
	+ p.approxLine = kg.line
	+
	+ var key Key
	+ for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() {
	+ key = append(key, p.keyString(kg))
	+ }
	+ p.assertEqual(itemArrayTableEnd, kg.typ)
	+
	+ p.establishContext(key, true)
	+ p.setType("", tomlArrayHash)
	+ p.ordered = append(p.ordered, key)
	+ case itemKeyStart:
	+ kname := p.next()
	+ p.approxLine = kname.line
	+ p.currentKey = p.keyString(kname)
	+
	+ val, typ := p.value(p.next())
	+ p.setValue(p.currentKey, val)
	+ p.setType(p.currentKey, typ)
	+ p.ordered = append(p.ordered, p.context.add(p.currentKey))
	+ p.currentKey = ""
	+ default:
	+ p.bug("Unexpected type at top level: %s", item.typ)
	+ }
	+}
	+
	+// Gets a string for a key (or part of a key in a table name).
	+func (p *parser) keyString(it item) string {
	+ switch it.typ {
	+ case itemText:
	+ return it.val
	+ case itemString, itemMultilineString,
	+ itemRawString, itemRawMultilineString:
	+ s, _ := p.value(it)
	+ return s.(string)
	+ default:
	+ p.bug("Unexpected key type: %s", it.typ)
	+ panic("unreachable")
	+ }
	+}
	+
	+// value translates an expected value from the lexer into a Go value wrapped
	+// as an empty interface.
	+func (p *parser) value(it item) (interface{}, tomlType) {
	+ switch it.typ {
	+ case itemString:
	+ return p.replaceEscapes(it.val), p.typeOfPrimitive(it)
	+ case itemMultilineString:
	+ trimmed := stripFirstNewline(stripEscapedWhitespace(it.val))
	+ return p.replaceEscapes(trimmed), p.typeOfPrimitive(it)
	+ case itemRawString:
	+ return it.val, p.typeOfPrimitive(it)
	+ case itemRawMultilineString:
	+ return stripFirstNewline(it.val), p.typeOfPrimitive(it)
	+ case itemBool:
	+ switch it.val {
	+ case "true":
	+ return true, p.typeOfPrimitive(it)
	+ case "false":
	+ return false, p.typeOfPrimitive(it)
	+ }
	+ p.bug("Expected boolean value, but got '%s'.", it.val)
	+ case itemInteger:
	+ if !numUnderscoresOK(it.val) {
	+ p.panicf("Invalid integer %q: underscores must be surrounded by digits",
	+ it.val)
	+ }
	+ val := strings.Replace(it.val, "_", "", -1)
	+ num, err := strconv.ParseInt(val, 10, 64)
	+ if err != nil {
	+ // Distinguish integer values. Normally, it'd be a bug if the lexer
	+ // provides an invalid integer, but it's possible that the number is
	+ // out of range of valid values (which the lexer cannot determine).
	+ // So mark the former as a bug but the latter as a legitimate user
	+ // error.
	+ if e, ok := err.(*strconv.NumError); ok &&
	+ e.Err == strconv.ErrRange {
	+
	+ p.panicf("Integer '%s' is out of the range of 64-bit "+
	+ "signed integers.", it.val)
	+ } else {
	+ p.bug("Expected integer value, but got '%s'.", it.val)
	+ }
	+ }
	+ return num, p.typeOfPrimitive(it)
	+ case itemFloat:
	+ parts := strings.FieldsFunc(it.val, func(r rune) bool {
	+ switch r {
	+ case '.', 'e', 'E':
	+ return true
	+ }
	+ return false
	+ })
	+ for _, part := range parts {
	+ if !numUnderscoresOK(part) {
	+ p.panicf("Invalid float %q: underscores must be "+
	+ "surrounded by digits", it.val)
	+ }
	+ }
	+ if !numPeriodsOK(it.val) {
	+ // As a special case, numbers like '123.' or '1.e2',
	+ // which are valid as far as Go/strconv are concerned,
	+ // must be rejected because TOML says that a fractional
	+ // part consists of '.' followed by 1+ digits.
	+ p.panicf("Invalid float %q: '.' must be followed "+
	+ "by one or more digits", it.val)
	+ }
	+ val := strings.Replace(it.val, "_", "", -1)
	+ num, err := strconv.ParseFloat(val, 64)
	+ if err != nil {
	+ if e, ok := err.(*strconv.NumError); ok &&
	+ e.Err == strconv.ErrRange {
	+
	+ p.panicf("Float '%s' is out of the range of 64-bit "+
	+ "IEEE-754 floating-point numbers.", it.val)
	+ } else {
	+ p.panicf("Invalid float value: %q", it.val)
	+ }
	+ }
	+ return num, p.typeOfPrimitive(it)
	+ case itemDatetime:
	+ var t time.Time
	+ var ok bool
	+ var err error
	+ for _, format := range []string{
	+ "2006-01-02T15:04:05Z07:00",
	+ "2006-01-02T15:04:05",
	+ "2006-01-02",
	+ } {
	+ t, err = time.ParseInLocation(format, it.val, time.Local)
	+ if err == nil {
	+ ok = true
	+ break
	+ }
	+ }
	+ if !ok {
	+ p.panicf("Invalid TOML Datetime: %q.", it.val)
	+ }
	+ return t, p.typeOfPrimitive(it)
	+ case itemArray:
	+ array := make([]interface{}, 0)
	+ types := make([]tomlType, 0)
	+
	+ for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
	+ if it.typ == itemCommentStart {
	+ p.expect(itemText)
	+ continue
	+ }
	+
	+ val, typ := p.value(it)
	+ array = append(array, val)
	+ types = append(types, typ)
	+ }
	+ return array, p.typeOfArray(types)
	+ case itemInlineTableStart:
	+ var (
	+ hash = make(map[string]interface{})
	+ outerContext = p.context
	+ outerKey = p.currentKey
	+ )
	+
	+ p.context = append(p.context, p.currentKey)
	+ p.currentKey = ""
	+ for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() {
	+ if it.typ != itemKeyStart {
	+ p.bug("Expected key start but instead found %q, around line %d",
	+ it.val, p.approxLine)
	+ }
	+ if it.typ == itemCommentStart {
	+ p.expect(itemText)
	+ continue
	+ }
	+
	+ // retrieve key
	+ k := p.next()
	+ p.approxLine = k.line
	+ kname := p.keyString(k)
	+
	+ // retrieve value
	+ p.currentKey = kname
	+ val, typ := p.value(p.next())
	+ // make sure we keep metadata up to date
	+ p.setType(kname, typ)
	+ p.ordered = append(p.ordered, p.context.add(p.currentKey))
	+ hash[kname] = val
	+ }
	+ p.context = outerContext
	+ p.currentKey = outerKey
	+ return hash, tomlHash
	+ }
	+ p.bug("Unexpected value type: %s", it.typ)
	+ panic("unreachable")
	+}
	+
	+// numUnderscoresOK checks whether each underscore in s is surrounded by
	+// characters that are not underscores.
	+func numUnderscoresOK(s string) bool {
	+ accept := false
	+ for _, r := range s {
	+ if r == '_' {
	+ if !accept {
	+ return false
	+ }
	+ accept = false
	+ continue
	+ }
	+ accept = true
	+ }
	+ return accept
	+}
	+
	+// numPeriodsOK checks whether every period in s is followed by a digit.
	+func numPeriodsOK(s string) bool {
	+ period := false
	+ for _, r := range s {
	+ if period && !isDigit(r) {
	+ return false
	+ }
	+ period = r == '.'
	+ }
	+ return !period
	+}
	+
	+// establishContext sets the current context of the parser,
	+// where the context is either a hash or an array of hashes. Which one is
	+// set depends on the value of the `array` parameter.
	+//
	+// Establishing the context also makes sure that the key isn't a duplicate, and
	+// will create implicit hashes automatically.
	+func (p *parser) establishContext(key Key, array bool) {
	+ var ok bool
	+
	+ // Always start at the top level and drill down for our context.
	+ hashContext := p.mapping
	+ keyContext := make(Key, 0)
	+
	+ // We only need implicit hashes for key[0:-1]
	+ for _, k := range key[0 : len(key)-1] {
	+ _, ok = hashContext[k]
	+ keyContext = append(keyContext, k)
	+
	+ // No key? Make an implicit hash and move on.
	+ if !ok {
	+ p.addImplicit(keyContext)
	+ hashContext[k] = make(map[string]interface{})
	+ }
	+
	+ // If the hash context is actually an array of tables, then set
	+ // the hash context to the last element in that array.
	+ //
	+ // Otherwise, it better be a table, since this MUST be a key group (by
	+ // virtue of it not being the last element in a key).
	+ switch t := hashContext[k].(type) {
	+ case []map[string]interface{}:
	+ hashContext = t[len(t)-1]
	+ case map[string]interface{}:
	+ hashContext = t
	+ default:
	+ p.panicf("Key '%s' was already created as a hash.", keyContext)
	+ }
	+ }
	+
	+ p.context = keyContext
	+ if array {
	+ // If this is the first element for this array, then allocate a new
	+ // list of tables for it.
	+ k := key[len(key)-1]
	+ if _, ok := hashContext[k]; !ok {
	+ hashContext[k] = make([]map[string]interface{}, 0, 5)
	+ }
	+
	+ // Add a new table. But make sure the key hasn't already been used
	+ // for something else.
	+ if hash, ok := hashContext[k].([]map[string]interface{}); ok {
	+ hashContext[k] = append(hash, make(map[string]interface{}))
	+ } else {
	+ p.panicf("Key '%s' was already created and cannot be used as "+
	+ "an array.", keyContext)
	+ }
	+ } else {
	+ p.setValue(key[len(key)-1], make(map[string]interface{}))
	+ }
	+ p.context = append(p.context, key[len(key)-1])
	+}
	+
	+// setValue sets the given key to the given value in the current context.
	+// It will make sure that the key hasn't already been defined, account for
	+// implicit key groups.
	+func (p *parser) setValue(key string, value interface{}) {
	+ var tmpHash interface{}
	+ var ok bool
	+
	+ hash := p.mapping
	+ keyContext := make(Key, 0)
	+ for _, k := range p.context {
	+ keyContext = append(keyContext, k)
	+ if tmpHash, ok = hash[k]; !ok {
	+ p.bug("Context for key '%s' has not been established.", keyContext)
	+ }
	+ switch t := tmpHash.(type) {
	+ case []map[string]interface{}:
	+ // The context is a table of hashes. Pick the most recent table
	+ // defined as the current hash.
	+ hash = t[len(t)-1]
	+ case map[string]interface{}:
	+ hash = t
	+ default:
	+ p.bug("Expected hash to have type 'map[string]interface{}', but "+
	+ "it has '%T' instead.", tmpHash)
	+ }
	+ }
	+ keyContext = append(keyContext, key)
	+
	+ if _, ok := hash[key]; ok {
	+ // Typically, if the given key has already been set, then we have
	+ // to raise an error since duplicate keys are disallowed. However,
	+ // it's possible that a key was previously defined implicitly. In this
	+ // case, it is allowed to be redefined concretely. (See the
	+ // `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
	+ //
	+ // But we have to make sure to stop marking it as an implicit. (So that
	+ // another redefinition provokes an error.)
	+ //
	+ // Note that since it has already been defined (as a hash), we don't
	+ // want to overwrite it. So our business is done.
	+ if p.isImplicit(keyContext) {
	+ p.removeImplicit(keyContext)
	+ return
	+ }
	+
	+ // Otherwise, we have a concrete key trying to override a previous
	+ // key, which is always wrong.
	+ p.panicf("Key '%s' has already been defined.", keyContext)
	+ }
	+ hash[key] = value
	+}
	+
	+// setType sets the type of a particular value at a given key.
	+// It should be called immediately AFTER setValue.
	+//
	+// Note that if `key` is empty, then the type given will be applied to the
	+// current context (which is either a table or an array of tables).
	+func (p *parser) setType(key string, typ tomlType) {
	+ keyContext := make(Key, 0, len(p.context)+1)
	+ for _, k := range p.context {
	+ keyContext = append(keyContext, k)
	+ }
	+ if len(key) > 0 { // allow type setting for hashes
	+ keyContext = append(keyContext, key)
	+ }
	+ p.types[keyContext.String()] = typ
	+}
	+
	+// addImplicit sets the given Key as having been created implicitly.
	+func (p *parser) addImplicit(key Key) {
	+ p.implicits[key.String()] = true
	+}
	+
	+// removeImplicit stops tagging the given key as having been implicitly
	+// created.
	+func (p *parser) removeImplicit(key Key) {
	+ p.implicits[key.String()] = false
	+}
	+
	+// isImplicit returns true if the key group pointed to by the key was created
	+// implicitly.
	+func (p *parser) isImplicit(key Key) bool {
	+ return p.implicits[key.String()]
	+}
	+
	+// current returns the full key name of the current context.
	+func (p *parser) current() string {
	+ if len(p.currentKey) == 0 {
	+ return p.context.String()
	+ }
	+ if len(p.context) == 0 {
	+ return p.currentKey
	+ }
	+ return fmt.Sprintf("%s.%s", p.context, p.currentKey)
	+}
	+
	+func stripFirstNewline(s string) string {
	+ if len(s) == 0 \|\| s[0] != '\n' {
	+ return s
	+ }
	+ return s[1:]
	+}
	+
	+func stripEscapedWhitespace(s string) string {
	+ esc := strings.Split(s, "\\\n")
	+ if len(esc) > 1 {
	+ for i := 1; i < len(esc); i++ {
	+ esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace)
	+ }
	+ }
	+ return strings.Join(esc, "")
	+}
	+
	+func (p *parser) replaceEscapes(str string) string {
	+ var replaced []rune
	+ s := []byte(str)
	+ r := 0
	+ for r < len(s) {
	+ if s[r] != '\\' {
	+ c, size := utf8.DecodeRune(s[r:])
	+ r += size
	+ replaced = append(replaced, c)
	+ continue
	+ }
	+ r += 1
	+ if r >= len(s) {
	+ p.bug("Escape sequence at end of string.")
	+ return ""
	+ }
	+ switch s[r] {
	+ default:
	+ p.bug("Expected valid escape code after \\, but got %q.", s[r])
	+ return ""
	+ case 'b':
	+ replaced = append(replaced, rune(0x0008))
	+ r += 1
	+ case 't':
	+ replaced = append(replaced, rune(0x0009))
	+ r += 1
	+ case 'n':
	+ replaced = append(replaced, rune(0x000A))
	+ r += 1
	+ case 'f':
	+ replaced = append(replaced, rune(0x000C))
	+ r += 1
	+ case 'r':
	+ replaced = append(replaced, rune(0x000D))
	+ r += 1
	+ case '"':
	+ replaced = append(replaced, rune(0x0022))
	+ r += 1
	+ case '\\':
	+ replaced = append(replaced, rune(0x005C))
	+ r += 1
	+ case 'u':
	+ // At this point, we know we have a Unicode escape of the form
	+ // `uXXXX` at [r, r+5). (Because the lexer guarantees this
	+ // for us.)
	+ escaped := p.asciiEscapeToUnicode(s[r+1 : r+5])
	+ replaced = append(replaced, escaped)
	+ r += 5
	+ case 'U':
	+ // At this point, we know we have a Unicode escape of the form
	+ // `uXXXX` at [r, r+9). (Because the lexer guarantees this
	+ // for us.)
	+ escaped := p.asciiEscapeToUnicode(s[r+1 : r+9])
	+ replaced = append(replaced, escaped)
	+ r += 9
	+ }
	+ }
	+ return string(replaced)
	+}
	+
	+func (p *parser) asciiEscapeToUnicode(bs []byte) rune {
	+ s := string(bs)
	+ hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
	+ if err != nil {
	+ p.bug("Could not parse '%s' as a hexadecimal number, but the "+
	+ "lexer claims it's OK: %s", s, err)
	+ }
	+ if !utf8.ValidRune(rune(hex)) {
	+ p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s)
	+ }
	+ return rune(hex)
	+}
	+
	+func isStringType(ty itemType) bool {
	+ return ty == itemString \|\| ty == itemMultilineString \|\|
	+ ty == itemRawString \|\| ty == itemRawMultilineString
	+}
	diff --git a/src/github.com/BurntSushi/toml/session.vim b/src/github.com/BurntSushi/toml/session.vim
	new file mode 100644
	index 0000000..562164b
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/session.vim
	@@ -0,0 +1 @@
	+au BufWritePost *.go silent!make tags > /dev/null 2>&1
	diff --git a/src/github.com/BurntSushi/toml/type_check.go b/src/github.com/BurntSushi/toml/type_check.go
	new file mode 100644
	index 0000000..c73f8af
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/type_check.go
	@@ -0,0 +1,91 @@
	+package toml
	+
	+// tomlType represents any Go type that corresponds to a TOML type.
	+// While the first draft of the TOML spec has a simplistic type system that
	+// probably doesn't need this level of sophistication, we seem to be militating
	+// toward adding real composite types.
	+type tomlType interface {
	+ typeString() string
	+}
	+
	+// typeEqual accepts any two types and returns true if they are equal.
	+func typeEqual(t1, t2 tomlType) bool {
	+ if t1 == nil \|\| t2 == nil {
	+ return false
	+ }
	+ return t1.typeString() == t2.typeString()
	+}
	+
	+func typeIsHash(t tomlType) bool {
	+ return typeEqual(t, tomlHash) \|\| typeEqual(t, tomlArrayHash)
	+}
	+
	+type tomlBaseType string
	+
	+func (btype tomlBaseType) typeString() string {
	+ return string(btype)
	+}
	+
	+func (btype tomlBaseType) String() string {
	+ return btype.typeString()
	+}
	+
	+var (
	+ tomlInteger tomlBaseType = "Integer"
	+ tomlFloat tomlBaseType = "Float"
	+ tomlDatetime tomlBaseType = "Datetime"
	+ tomlString tomlBaseType = "String"
	+ tomlBool tomlBaseType = "Bool"
	+ tomlArray tomlBaseType = "Array"
	+ tomlHash tomlBaseType = "Hash"
	+ tomlArrayHash tomlBaseType = "ArrayHash"
	+)
	+
	+// typeOfPrimitive returns a tomlType of any primitive value in TOML.
	+// Primitive values are: Integer, Float, Datetime, String and Bool.
	+//
	+// Passing a lexer item other than the following will cause a BUG message
	+// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
	+func (p *parser) typeOfPrimitive(lexItem item) tomlType {
	+ switch lexItem.typ {
	+ case itemInteger:
	+ return tomlInteger
	+ case itemFloat:
	+ return tomlFloat
	+ case itemDatetime:
	+ return tomlDatetime
	+ case itemString:
	+ return tomlString
	+ case itemMultilineString:
	+ return tomlString
	+ case itemRawString:
	+ return tomlString
	+ case itemRawMultilineString:
	+ return tomlString
	+ case itemBool:
	+ return tomlBool
	+ }
	+ p.bug("Cannot infer primitive type of lex item '%s'.", lexItem)
	+ panic("unreachable")
	+}
	+
	+// typeOfArray returns a tomlType for an array given a list of types of its
	+// values.
	+//
	+// In the current spec, if an array is homogeneous, then its type is always
	+// "Array". If the array is not homogeneous, an error is generated.
	+func (p *parser) typeOfArray(types []tomlType) tomlType {
	+ // Empty arrays are cool.
	+ if len(types) == 0 {
	+ return tomlArray
	+ }
	+
	+ theType := types[0]
	+ for _, t := range types[1:] {
	+ if !typeEqual(theType, t) {
	+ p.panicf("Array contains values of type '%s' and '%s', but "+
	+ "arrays must be homogeneous.", theType, t)
	+ }
	+ }
	+ return tomlArray
	+}
	diff --git a/src/github.com/BurntSushi/toml/type_fields.go b/src/github.com/BurntSushi/toml/type_fields.go
	new file mode 100644
	index 0000000..608997c
	--- /dev/null
	+++ b/src/github.com/BurntSushi/toml/type_fields.go
	@@ -0,0 +1,242 @@
	+package toml
	+
	+// Struct field handling is adapted from code in encoding/json:
	+//
	+// Copyright 2010 The Go Authors. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the Go distribution.
	+
	+import (
	+ "reflect"
	+ "sort"
	+ "sync"
	+)
	+
	+// A field represents a single field found in a struct.
	+type field struct {
	+ name string // the name of the field (`toml` tag included)
	+ tag bool // whether field has a `toml` tag
	+ index []int // represents the depth of an anonymous field
	+ typ reflect.Type // the type of the field
	+}
	+
	+// byName sorts field by name, breaking ties with depth,
	+// then breaking ties with "name came from toml tag", then
	+// breaking ties with index sequence.
	+type byName []field
	+
	+func (x byName) Len() int { return len(x) }
	+
	+func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
	+
	+func (x byName) Less(i, j int) bool {
	+ if x[i].name != x[j].name {
	+ return x[i].name < x[j].name
	+ }
	+ if len(x[i].index) != len(x[j].index) {
	+ return len(x[i].index) < len(x[j].index)
	+ }
	+ if x[i].tag != x[j].tag {
	+ return x[i].tag
	+ }
	+ return byIndex(x).Less(i, j)
	+}
	+
	+// byIndex sorts field by index sequence.
	+type byIndex []field
	+
	+func (x byIndex) Len() int { return len(x) }
	+
	+func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
	+
	+func (x byIndex) Less(i, j int) bool {
	+ for k, xik := range x[i].index {
	+ if k >= len(x[j].index) {
	+ return false
	+ }
	+ if xik != x[j].index[k] {
	+ return xik < x[j].index[k]
	+ }
	+ }
	+ return len(x[i].index) < len(x[j].index)
	+}
	+
	+// typeFields returns a list of fields that TOML should recognize for the given
	+// type. The algorithm is breadth-first search over the set of structs to
	+// include - the top struct and then any reachable anonymous structs.
	+func typeFields(t reflect.Type) []field {
	+ // Anonymous fields to explore at the current level and the next.
	+ current := []field{}
	+ next := []field{{typ: t}}
	+
	+ // Count of queued names for current level and the next.
	+ count := map[reflect.Type]int{}
	+ nextCount := map[reflect.Type]int{}
	+
	+ // Types already visited at an earlier level.
	+ visited := map[reflect.Type]bool{}
	+
	+ // Fields found.
	+ var fields []field
	+
	+ for len(next) > 0 {
	+ current, next = next, current[:0]
	+ count, nextCount = nextCount, map[reflect.Type]int{}
	+
	+ for _, f := range current {
	+ if visited[f.typ] {
	+ continue
	+ }
	+ visited[f.typ] = true
	+
	+ // Scan f.typ for fields to include.
	+ for i := 0; i < f.typ.NumField(); i++ {
	+ sf := f.typ.Field(i)
	+ if sf.PkgPath != "" && !sf.Anonymous { // unexported
	+ continue
	+ }
	+ opts := getOptions(sf.Tag)
	+ if opts.skip {
	+ continue
	+ }
	+ index := make([]int, len(f.index)+1)
	+ copy(index, f.index)
	+ index[len(f.index)] = i
	+
	+ ft := sf.Type
	+ if ft.Name() == "" && ft.Kind() == reflect.Ptr {
	+ // Follow pointer.
	+ ft = ft.Elem()
	+ }
	+
	+ // Record found field and index sequence.
	+ if opts.name != "" \|\| !sf.Anonymous \|\| ft.Kind() != reflect.Struct {
	+ tagged := opts.name != ""
	+ name := opts.name
	+ if name == "" {
	+ name = sf.Name
	+ }
	+ fields = append(fields, field{name, tagged, index, ft})
	+ if count[f.typ] > 1 {
	+ // If there were multiple instances, add a second,
	+ // so that the annihilation code will see a duplicate.
	+ // It only cares about the distinction between 1 or 2,
	+ // so don't bother generating any more copies.
	+ fields = append(fields, fields[len(fields)-1])
	+ }
	+ continue
	+ }
	+
	+ // Record new anonymous struct to explore in next round.
	+ nextCount[ft]++
	+ if nextCount[ft] == 1 {
	+ f := field{name: ft.Name(), index: index, typ: ft}
	+ next = append(next, f)
	+ }
	+ }
	+ }
	+ }
	+
	+ sort.Sort(byName(fields))
	+
	+ // Delete all fields that are hidden by the Go rules for embedded fields,
	+ // except that fields with TOML tags are promoted.
	+
	+ // The fields are sorted in primary order of name, secondary order
	+ // of field index length. Loop over names; for each name, delete
	+ // hidden fields by choosing the one dominant field that survives.
	+ out := fields[:0]
	+ for advance, i := 0, 0; i < len(fields); i += advance {
	+ // One iteration per name.
	+ // Find the sequence of fields with the name of this first field.
	+ fi := fields[i]
	+ name := fi.name
	+ for advance = 1; i+advance < len(fields); advance++ {
	+ fj := fields[i+advance]
	+ if fj.name != name {
	+ break
	+ }
	+ }
	+ if advance == 1 { // Only one field with this name
	+ out = append(out, fi)
	+ continue
	+ }
	+ dominant, ok := dominantField(fields[i : i+advance])
	+ if ok {
	+ out = append(out, dominant)
	+ }
	+ }
	+
	+ fields = out
	+ sort.Sort(byIndex(fields))
	+
	+ return fields
	+}
	+
	+// dominantField looks through the fields, all of which are known to
	+// have the same name, to find the single field that dominates the
	+// others using Go's embedding rules, modified by the presence of
	+// TOML tags. If there are multiple top-level fields, the boolean
	+// will be false: This condition is an error in Go and we skip all
	+// the fields.
	+func dominantField(fields []field) (field, bool) {
	+ // The fields are sorted in increasing index-length order. The winner
	+ // must therefore be one with the shortest index length. Drop all
	+ // longer entries, which is easy: just truncate the slice.
	+ length := len(fields[0].index)
	+ tagged := -1 // Index of first tagged field.
	+ for i, f := range fields {
	+ if len(f.index) > length {
	+ fields = fields[:i]
	+ break
	+ }
	+ if f.tag {
	+ if tagged >= 0 {
	+ // Multiple tagged fields at the same level: conflict.
	+ // Return no field.
	+ return field{}, false
	+ }
	+ tagged = i
	+ }
	+ }
	+ if tagged >= 0 {
	+ return fields[tagged], true
	+ }
	+ // All remaining fields have the same length. If there's more than one,
	+ // we have a conflict (two fields named "X" at the same level) and we
	+ // return no field.
	+ if len(fields) > 1 {
	+ return field{}, false
	+ }
	+ return fields[0], true
	+}
	+
	+var fieldCache struct {
	+ sync.RWMutex
	+ m map[reflect.Type][]field
	+}
	+
	+// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
	+func cachedTypeFields(t reflect.Type) []field {
	+ fieldCache.RLock()
	+ f := fieldCache.m[t]
	+ fieldCache.RUnlock()
	+ if f != nil {
	+ return f
	+ }
	+
	+ // Compute fields without lock.
	+ // Might duplicate effort but won't hold other computations back.
	+ f = typeFields(t)
	+ if f == nil {
	+ f = []field{}
	+ }
	+
	+ fieldCache.Lock()
	+ if fieldCache.m == nil {
	+ fieldCache.m = map[reflect.Type][]field{}
	+ }
	+ fieldCache.m[t] = f
	+ fieldCache.Unlock()
	+ return f
	+}
	diff --git a/src/github.com/atotto/clipboard/LICENSE b/src/github.com/atotto/clipboard/LICENSE
	new file mode 100644
	index 0000000..dee3257
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/LICENSE
	@@ -0,0 +1,27 @@
	+Copyright (c) 2013 Ato Araki. All rights reserved.
	+
	+Redistribution and use in source and binary forms, with or without
	+modification, are permitted provided that the following conditions are
	+met:
	+
	+ * Redistributions of source code must retain the above copyright
	+notice, this list of conditions and the following disclaimer.
	+ * Redistributions in binary form must reproduce the above
	+copyright notice, this list of conditions and the following disclaimer
	+in the documentation and/or other materials provided with the
	+distribution.
	+ * Neither the name of @atotto. nor the names of its
	+contributors may be used to endorse or promote products derived from
	+this software without specific prior written permission.
	+
	+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	diff --git a/src/github.com/atotto/clipboard/README.md b/src/github.com/atotto/clipboard/README.md
	new file mode 100644
	index 0000000..6e2d15f
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/README.md
	@@ -0,0 +1,50 @@
	+[![Build Status](https://travis-ci.org/atotto/clipboard.svg?branch=master)](https://travis-ci.org/atotto/clipboard) [![Build Status](https://drone.io/github.com/atotto/clipboard/status.png)](https://drone.io/github.com/atotto/clipboard/latest)
	+
	+[![GoDoc](https://godoc.org/github.com/atotto/clipboard?status.svg)](http://godoc.org/github.com/atotto/clipboard)
	+
	+# Clipboard for Go
	+
	+Provide copying and pasting to the Clipboard for Go.
	+
	+Download shell commands at https://drone.io/github.com/atotto/clipboard/files
	+
	+Build:
	+
	+ $ go get github.com/atotto/clipboard
	+
	+Platforms:
	+
	+* OSX
	+* Windows 7 (probably work on other Windows)
	+* Linux, Unix (requires 'xclip' or 'xsel' command to be installed)
	+
	+
	+Document:
	+
	+* http://godoc.org/github.com/atotto/clipboard
	+
	+Notes:
	+
	+* Text string only
	+* UTF-8 text encoding only (no conversion)
	+
	+TODO:
	+
	+* Clipboard watcher(?)
	+
	+## Commands:
	+
	+paste shell command:
	+
	+ $ go get github.com/atotto/clipboard/cmd/gopaste
	+ $ # example:
	+ $ gopaste > document.txt
	+
	+copy shell command:
	+
	+ $ go get github.com/atotto/clipboard/cmd/gocopy
	+ $ # example:
	+ $ cat document.txt \| gocopy
	+
	+
	+
	diff --git a/src/github.com/atotto/clipboard/clipboard.go b/src/github.com/atotto/clipboard/clipboard.go
	new file mode 100644
	index 0000000..9e8f573
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/clipboard.go
	@@ -0,0 +1,22 @@
	+// Copyright 2013 @atotto. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+// Package clipboard read/write on clipboard
	+package clipboard
	+
	+import ()
	+
	+// ReadAll read string from clipboard
	+func ReadAll() (string, error) {
	+ return readAll()
	+}
	+
	+// WriteAll write string to clipboard
	+func WriteAll(text string) error {
	+ return writeAll(text)
	+}
	+
	+// Unsupported might be set true during clipboard init, to help callers decide
	+// whether or not to offer clipboard options.
	+var Unsupported bool
	diff --git a/src/github.com/atotto/clipboard/clipboard_darwin.go b/src/github.com/atotto/clipboard/clipboard_darwin.go
	new file mode 100644
	index 0000000..6f33078
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/clipboard_darwin.go
	@@ -0,0 +1,52 @@
	+// Copyright 2013 @atotto. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+// +build darwin
	+
	+package clipboard
	+
	+import (
	+ "os/exec"
	+)
	+
	+var (
	+ pasteCmdArgs = "pbpaste"
	+ copyCmdArgs = "pbcopy"
	+)
	+
	+func getPasteCommand() *exec.Cmd {
	+ return exec.Command(pasteCmdArgs)
	+}
	+
	+func getCopyCommand() *exec.Cmd {
	+ return exec.Command(copyCmdArgs)
	+}
	+
	+func readAll() (string, error) {
	+ pasteCmd := getPasteCommand()
	+ out, err := pasteCmd.Output()
	+ if err != nil {
	+ return "", err
	+ }
	+ return string(out), nil
	+}
	+
	+func writeAll(text string) error {
	+ copyCmd := getCopyCommand()
	+ in, err := copyCmd.StdinPipe()
	+ if err != nil {
	+ return err
	+ }
	+
	+ if err := copyCmd.Start(); err != nil {
	+ return err
	+ }
	+ if _, err := in.Write([]byte(text)); err != nil {
	+ return err
	+ }
	+ if err := in.Close(); err != nil {
	+ return err
	+ }
	+ return copyCmd.Wait()
	+}
	diff --git a/src/github.com/atotto/clipboard/clipboard_test.go b/src/github.com/atotto/clipboard/clipboard_test.go
	new file mode 100644
	index 0000000..075e657
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/clipboard_test.go
	@@ -0,0 +1,73 @@
	+// Copyright 2013 @atotto. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+package clipboard_test
	+
	+import (
	+ "testing"
	+
	+ . "github.com/atotto/clipboard"
	+)
	+
	+func TestCopyAndPaste(t *testing.T) {
	+ expected := "日本語"
	+
	+ err := WriteAll(expected)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ actual, err := ReadAll()
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ if actual != expected {
	+ t.Errorf("want %s, got %s", expected, actual)
	+ }
	+}
	+
	+func TestMultiCopyAndPaste(t *testing.T) {
	+ expected1 := "French: éèêëàùœç"
	+ expected2 := "Weird UTF-8: 💩☃"
	+
	+ err := WriteAll(expected1)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ actual1, err := ReadAll()
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ if actual1 != expected1 {
	+ t.Errorf("want %s, got %s", expected1, actual1)
	+ }
	+
	+ err = WriteAll(expected2)
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+
	+ actual2, err := ReadAll()
	+ if err != nil {
	+ t.Fatal(err)
	+ }
	+ if actual2 != expected2 {
	+ t.Errorf("want %s, got %s", expected2, actual2)
	+ }
	+}
	+
	+func BenchmarkReadAll(b *testing.B) {
	+ for i := 0; i < b.N; i++ {
	+ ReadAll()
	+ }
	+}
	+
	+func BenchmarkWriteAll(b *testing.B) {
	+ text := "いろはにほへと"
	+ for i := 0; i < b.N; i++ {
	+ WriteAll(text)
	+ }
	+}
	diff --git a/src/github.com/atotto/clipboard/clipboard_unix.go b/src/github.com/atotto/clipboard/clipboard_unix.go
	new file mode 100644
	index 0000000..aa0ef3a
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/clipboard_unix.go
	@@ -0,0 +1,90 @@
	+// Copyright 2013 @atotto. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+// +build freebsd linux netbsd openbsd solaris
	+
	+package clipboard
	+
	+import (
	+ "errors"
	+ "os/exec"
	+)
	+
	+const (
	+ xsel = "xsel"
	+ xclip = "xclip"
	+)
	+
	+var (
	+ pasteCmdArgs []string
	+ copyCmdArgs []string
	+
	+ xselPasteArgs = []string{xsel, "--output", "--clipboard"}
	+ xselCopyArgs = []string{xsel, "--input", "--clipboard"}
	+
	+ xclipPasteArgs = []string{xclip, "-out", "-selection", "clipboard"}
	+ xclipCopyArgs = []string{xclip, "-in", "-selection", "clipboard"}
	+
	+ missingCommands = errors.New("No clipboard utilities available. Please install xsel or xclip.")
	+)
	+
	+func init() {
	+ pasteCmdArgs = xclipPasteArgs
	+ copyCmdArgs = xclipCopyArgs
	+
	+ if _, err := exec.LookPath(xclip); err == nil {
	+ return
	+ }
	+
	+ pasteCmdArgs = xselPasteArgs
	+ copyCmdArgs = xselCopyArgs
	+
	+ if _, err := exec.LookPath(xsel); err == nil {
	+ return
	+ }
	+
	+ Unsupported = true
	+}
	+
	+func getPasteCommand() *exec.Cmd {
	+ return exec.Command(pasteCmdArgs[0], pasteCmdArgs[1:]...)
	+}
	+
	+func getCopyCommand() *exec.Cmd {
	+ return exec.Command(copyCmdArgs[0], copyCmdArgs[1:]...)
	+}
	+
	+func readAll() (string, error) {
	+ if Unsupported {
	+ return "", missingCommands
	+ }
	+ pasteCmd := getPasteCommand()
	+ out, err := pasteCmd.Output()
	+ if err != nil {
	+ return "", err
	+ }
	+ return string(out), nil
	+}
	+
	+func writeAll(text string) error {
	+ if Unsupported {
	+ return missingCommands
	+ }
	+ copyCmd := getCopyCommand()
	+ in, err := copyCmd.StdinPipe()
	+ if err != nil {
	+ return err
	+ }
	+
	+ if err := copyCmd.Start(); err != nil {
	+ return err
	+ }
	+ if _, err := in.Write([]byte(text)); err != nil {
	+ return err
	+ }
	+ if err := in.Close(); err != nil {
	+ return err
	+ }
	+ return copyCmd.Wait()
	+}
	diff --git a/src/github.com/atotto/clipboard/clipboard_windows.go b/src/github.com/atotto/clipboard/clipboard_windows.go
	new file mode 100644
	index 0000000..5dbb562
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/clipboard_windows.go
	@@ -0,0 +1,101 @@
	+// Copyright 2013 @atotto. All rights reserved.
	+// Use of this source code is governed by a BSD-style
	+// license that can be found in the LICENSE file.
	+
	+// +build windows
	+
	+package clipboard
	+
	+import (
	+ "syscall"
	+ "unsafe"
	+)
	+
	+const (
	+ cfUnicodetext = 13
	+ gmemFixed = 0x0000
	+)
	+
	+var (
	+ user32 = syscall.MustLoadDLL("user32")
	+ openClipboard = user32.MustFindProc("OpenClipboard")
	+ closeClipboard = user32.MustFindProc("CloseClipboard")
	+ emptyClipboard = user32.MustFindProc("EmptyClipboard")
	+ getClipboardData = user32.MustFindProc("GetClipboardData")
	+ setClipboardData = user32.MustFindProc("SetClipboardData")
	+
	+ kernel32 = syscall.NewLazyDLL("kernel32")
	+ globalAlloc = kernel32.NewProc("GlobalAlloc")
	+ globalFree = kernel32.NewProc("GlobalFree")
	+ globalLock = kernel32.NewProc("GlobalLock")
	+ globalUnlock = kernel32.NewProc("GlobalUnlock")
	+ lstrcpy = kernel32.NewProc("lstrcpyW")
	+)
	+
	+func readAll() (string, error) {
	+ r, _, err := openClipboard.Call(0)
	+ if r == 0 {
	+ return "", err
	+ }
	+ defer closeClipboard.Call()
	+
	+ h, _, err := getClipboardData.Call(cfUnicodetext)
	+ if r == 0 {
	+ return "", err
	+ }
	+
	+ l, _, err := globalLock.Call(h)
	+ if l == 0 {
	+ return "", err
	+ }
	+
	+ text := syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(l))[:])
	+
	+ r, _, err = globalUnlock.Call(h)
	+ if r == 0 {
	+ return "", err
	+ }
	+
	+ return text, nil
	+}
	+
	+func writeAll(text string) error {
	+ r, _, err := openClipboard.Call(0)
	+ if r == 0 {
	+ return err
	+ }
	+ defer closeClipboard.Call()
	+
	+ r, _, err = emptyClipboard.Call(0)
	+ if r == 0 {
	+ return err
	+ }
	+
	+ data := syscall.StringToUTF16(text)
	+
	+ h, _, err := globalAlloc.Call(gmemFixed, uintptr(len(data)*int(unsafe.Sizeof(data[0]))))
	+ if h == 0 {
	+ return err
	+ }
	+
	+ l, _, err := globalLock.Call(h)
	+ if l == 0 {
	+ return err
	+ }
	+
	+ r, _, err = lstrcpy.Call(l, uintptr(unsafe.Pointer(&data[0])))
	+ if r == 0 {
	+ return err
	+ }
	+
	+ r, _, err = globalUnlock.Call(h)
	+ if r == 0 {
	+ return err
	+ }
	+
	+ r, _, err = setClipboardData.Call(cfUnicodetext, h)
	+ if r == 0 {
	+ return err
	+ }
	+ return nil
	+}
	diff --git a/src/github.com/atotto/clipboard/cmd/gocopy/gocopy.go b/src/github.com/atotto/clipboard/cmd/gocopy/gocopy.go
	new file mode 100644
	index 0000000..538e5ba
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/cmd/gocopy/gocopy.go
	@@ -0,0 +1,20 @@
	+package main
	+
	+import (
	+ "io/ioutil"
	+ "os"
	+
	+ "github.com/atotto/clipboard"
	+)
	+
	+func main() {
	+
	+ out, err := ioutil.ReadAll(os.Stdin)
	+ if err != nil {
	+ panic(err)
	+ }
	+
	+ if err := clipboard.WriteAll(string(out)); err != nil {
	+ panic(err)
	+ }
	+}
	diff --git a/src/github.com/atotto/clipboard/cmd/gopaste/gopaste.go b/src/github.com/atotto/clipboard/cmd/gopaste/gopaste.go
	new file mode 100644
	index 0000000..49f08ee
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/cmd/gopaste/gopaste.go
	@@ -0,0 +1,16 @@
	+package main
	+
	+import (
	+ "fmt"
	+
	+ "github.com/atotto/clipboard"
	+)
	+
	+func main() {
	+ text, err := clipboard.ReadAll()
	+ if err != nil {
	+ panic(err)
	+ }
	+
	+ fmt.Print(text)
	+}
	diff --git a/src/github.com/atotto/clipboard/example_test.go b/src/github.com/atotto/clipboard/example_test.go
	new file mode 100644
	index 0000000..0f970a0
	--- /dev/null
	+++ b/src/github.com/atotto/clipboard/example_test.go
	@@ -0,0 +1,16 @@
	+package clipboard_test
	+
	+import (
	+ "fmt"
	+
	+ "github.com/atotto/clipboard"
	+)
	+
	+func Example() {
	+ clipboard.WriteAll("日本語")
	+ text, _ := clipboard.ReadAll()
	+ fmt.Println(text)
	+
	+ // Output:
	+ // 日本語
	+}
	diff --git a/src/github.com/mitchellh/go-homedir/LICENSE b/src/github.com/mitchellh/go-homedir/LICENSE
	new file mode 100644
	index 0000000..f9c841a
	--- /dev/null
	+++ b/src/github.com/mitchellh/go-homedir/LICENSE
	@@ -0,0 +1,21 @@
	+The MIT License (MIT)
	+
	+Copyright (c) 2013 Mitchell Hashimoto
	+
	+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.
	diff --git a/src/github.com/mitchellh/go-homedir/README.md b/src/github.com/mitchellh/go-homedir/README.md
	new file mode 100644
	index 0000000..d70706d
	--- /dev/null
	+++ b/src/github.com/mitchellh/go-homedir/README.md
	@@ -0,0 +1,14 @@
	+# go-homedir
	+
	+This is a Go library for detecting the user's home directory without
	+the use of cgo, so the library can be used in cross-compilation environments.
	+
	+Usage is incredibly simple, just call `homedir.Dir()` to get the home directory
	+for a user, and `homedir.Expand()` to expand the `~` in a path to the home
	+directory.
	+
	+Why not just use `os/user`? The built-in `os/user` package requires
	+cgo on Darwin systems. This means that any Go code that uses that package
	+cannot cross compile. But 99% of the time the use for `os/user` is just to
	+retrieve the home directory, which we can do for the current user without
	+cgo. This library does that, enabling cross-compilation.
	diff --git a/src/github.com/mitchellh/go-homedir/homedir.go b/src/github.com/mitchellh/go-homedir/homedir.go
	new file mode 100644
	index 0000000..47e1f9e
	--- /dev/null
	+++ b/src/github.com/mitchellh/go-homedir/homedir.go
	@@ -0,0 +1,137 @@
	+package homedir
	+
	+import (
	+ "bytes"
	+ "errors"
	+ "os"
	+ "os/exec"
	+ "path/filepath"
	+ "runtime"
	+ "strconv"
	+ "strings"
	+ "sync"
	+)
	+
	+// DisableCache will disable caching of the home directory. Caching is enabled
	+// by default.
	+var DisableCache bool
	+
	+var homedirCache string
	+var cacheLock sync.RWMutex
	+
	+// Dir returns the home directory for the executing user.
	+//
	+// This uses an OS-specific method for discovering the home directory.
	+// An error is returned if a home directory cannot be detected.
	+func Dir() (string, error) {
	+ if !DisableCache {
	+ cacheLock.RLock()
	+ cached := homedirCache
	+ cacheLock.RUnlock()
	+ if cached != "" {
	+ return cached, nil
	+ }
	+ }
	+
	+ cacheLock.Lock()
	+ defer cacheLock.Unlock()
	+
	+ var result string
	+ var err error
	+ if runtime.GOOS == "windows" {
	+ result, err = dirWindows()
	+ } else {
	+ // Unix-like system, so just assume Unix
	+ result, err = dirUnix()
	+ }
	+
	+ if err != nil {
	+ return "", err
	+ }
	+ homedirCache = result
	+ return result, nil
	+}
	+
	+// Expand expands the path to include the home directory if the path
	+// is prefixed with `~`. If it isn't prefixed with `~`, the path is
	+// returned as-is.
	+func Expand(path string) (string, error) {
	+ if len(path) == 0 {
	+ return path, nil
	+ }
	+
	+ if path[0] != '~' {
	+ return path, nil
	+ }
	+
	+ if len(path) > 1 && path[1] != '/' && path[1] != '\\' {
	+ return "", errors.New("cannot expand user-specific home dir")
	+ }
	+
	+ dir, err := Dir()
	+ if err != nil {
	+ return "", err
	+ }
	+
	+ return filepath.Join(dir, path[1:]), nil
	+}
	+
	+func dirUnix() (string, error) {
	+ // First prefer the HOME environmental variable
	+ if home := os.Getenv("HOME"); home != "" {
	+ return home, nil
	+ }
	+
	+ // If that fails, try getent
	+ var stdout bytes.Buffer
	+ cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
	+ cmd.Stdout = &stdout
	+ if err := cmd.Run(); err != nil {
	+ // If the error is ErrNotFound, we ignore it. Otherwise, return it.
	+ if err != exec.ErrNotFound {
	+ return "", err
	+ }
	+ } else {
	+ if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
	+ // username:password:uid:gid:gecos:home:shell
	+ passwdParts := strings.SplitN(passwd, ":", 7)
	+ if len(passwdParts) > 5 {
	+ return passwdParts[5], nil
	+ }
	+ }
	+ }
	+
	+ // If all else fails, try the shell
	+ stdout.Reset()
	+ cmd = exec.Command("sh", "-c", "cd && pwd")
	+ cmd.Stdout = &stdout
	+ if err := cmd.Run(); err != nil {
	+ return "", err
	+ }
	+
	+ result := strings.TrimSpace(stdout.String())
	+ if result == "" {
	+ return "", errors.New("blank output when reading home directory")
	+ }
	+
	+ return result, nil
	+}
	+
	+func dirWindows() (string, error) {
	+ // First prefer the HOME environmental variable
	+ if home := os.Getenv("HOME"); home != "" {
	+ return home, nil
	+ }
	+
	+ drive := os.Getenv("HOMEDRIVE")
	+ path := os.Getenv("HOMEPATH")
	+ home := drive + path
	+ if drive == "" \|\| path == "" {
	+ home = os.Getenv("USERPROFILE")
	+ }
	+ if home == "" {
	+ return "", errors.New("HOMEDRIVE, HOMEPATH, and USERPROFILE are blank")
	+ }
	+
	+ return home, nil
	+}
	diff --git a/src/github.com/mitchellh/go-homedir/homedir_test.go b/src/github.com/mitchellh/go-homedir/homedir_test.go
	new file mode 100644
	index 0000000..e4054e7
	--- /dev/null
	+++ b/src/github.com/mitchellh/go-homedir/homedir_test.go
	@@ -0,0 +1,112 @@
	+package homedir
	+
	+import (
	+ "os"
	+ "os/user"
	+ "path/filepath"
	+ "testing"
	+)
	+
	+func patchEnv(key, value string) func() {
	+ bck := os.Getenv(key)
	+ deferFunc := func() {
	+ os.Setenv(key, bck)
	+ }
	+
	+ os.Setenv(key, value)
	+ return deferFunc
	+}
	+
	+func BenchmarkDir(b *testing.B) {
	+ // We do this for any "warmups"
	+ for i := 0; i < 10; i++ {
	+ Dir()
	+ }
	+
	+ b.ResetTimer()
	+ for i := 0; i < b.N; i++ {
	+ Dir()
	+ }
	+}
	+
	+func TestDir(t *testing.T) {
	+ u, err := user.Current()
	+ if err != nil {
	+ t.Fatalf("err: %s", err)
	+ }
	+
	+ dir, err := Dir()
	+ if err != nil {
	+ t.Fatalf("err: %s", err)
	+ }
	+
	+ if u.HomeDir != dir {
	+ t.Fatalf("%#v != %#v", u.HomeDir, dir)
	+ }
	+}
	+
	+func TestExpand(t *testing.T) {
	+ u, err := user.Current()
	+ if err != nil {
	+ t.Fatalf("err: %s", err)
	+ }
	+
	+ cases := []struct {
	+ Input string
	+ Output string
	+ Err bool
	+ }{
	+ {
	+ "/foo",
	+ "/foo",
	+ false,
	+ },
	+
	+ {
	+ "~/foo",
	+ filepath.Join(u.HomeDir, "foo"),
	+ false,
	+ },
	+
	+ {
	+ "",
	+ "",
	+ false,
	+ },
	+
	+ {
	+ "~",
	+ u.HomeDir,
	+ false,
	+ },
	+
	+ {
	+ "~foo/foo",
	+ "",
	+ true,
	+ },
	+ }
	+
	+ for _, tc := range cases {
	+ actual, err := Expand(tc.Input)
	+ if (err != nil) != tc.Err {
	+ t.Fatalf("Input: %#v\n\nErr: %s", tc.Input, err)
	+ }
	+
	+ if actual != tc.Output {
	+ t.Fatalf("Input: %#v\n\nOutput: %#v", tc.Input, actual)
	+ }
	+ }
	+
	+ DisableCache = true
	+ defer func() { DisableCache = false }()
	+ defer patchEnv("HOME", "/custom/path/")()
	+ expected := filepath.Join("/", "custom", "path", "foo/bar")
	+ actual, err := Expand("~/foo/bar")
	+
	+ if err != nil {
	+ t.Errorf("No error is expected, got: %v", err)
	+ } else if actual != expected {
	+ t.Errorf("Expected: %v; actual: %v", expected, actual)
	+ }
	+}
	diff --git a/src/github.com/writeas/writeas-cli b/src/github.com/writeas/writeas-cli
	new file mode 160000
	index 0000000..e05f5bd
	--- /dev/null
	+++ b/src/github.com/writeas/writeas-cli
	@@ -0,0 +1 @@
	+Subproject commit e05f5bd9432323459d91251782a0b1f71455584e
	diff --git a/src/gopkg.in/urfave/cli.v1/CHANGELOG.md b/src/gopkg.in/urfave/cli.v1/CHANGELOG.md
	new file mode 100644
	index 0000000..07f7546
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/CHANGELOG.md
	@@ -0,0 +1,392 @@
	+# Change Log
	+
	+ATTN: This project uses [semantic versioning](http://semver.org/).
	+
	+## [Unreleased]
	+
	+## [1.19.1] - 2016-11-21
	+
	+### Fixed
	+
	+- Fixes regression introduced in 1.19.0 where using an `ActionFunc` as
	+ the `Action` for a command would cause it to error rather than calling the
	+ function. Should not have a affected declarative cases using `func(c
	+ *cli.Context) err)`.
	+- Shell completion now handles the case where the user specifies
	+ `--generate-bash-completion` immediately after a flag that takes an argument.
	+ Previously it call the application with `--generate-bash-completion` as the
	+ flag value.
	+
	+## [1.19.0] - 2016-11-19
	+### Added
	+- `FlagsByName` was added to make it easy to sort flags (e.g. `sort.Sort(cli.FlagsByName(app.Flags))`)
	+- A `Description` field was added to `App` for a more detailed description of
	+ the application (similar to the existing `Description` field on `Command`)
	+- Flag type code generation via `go generate`
	+- Write to stderr and exit 1 if action returns non-nil error
	+- Added support for TOML to the `altsrc` loader
	+- `SkipArgReorder` was added to allow users to skip the argument reordering.
	+ This is useful if you want to consider all "flags" after an argument as
	+ arguments rather than flags (the default behavior of the stdlib `flag`
	+ library). This is backported functionality from the [removal of the flag
	+ reordering](https://github.com/urfave/cli/pull/398) in the unreleased version
	+ 2
	+- For formatted errors (those implementing `ErrorFormatter`), the errors will
	+ be formatted during output. Compatible with `pkg/errors`.
	+
	+### Changed
	+- Raise minimum tested/supported Go version to 1.2+
	+
	+### Fixed
	+- Consider empty environment variables as set (previously environment variables
	+ with the equivalent of `""` would be skipped rather than their value used).
	+- Return an error if the value in a given environment variable cannot be parsed
	+ as the flag type. Previously these errors were silently swallowed.
	+- Print full error when an invalid flag is specified (which includes the invalid flag)
	+- `App.Writer` defaults to `stdout` when `nil`
	+- If no action is specified on a command or app, the help is now printed instead of `panic`ing
	+- `App.Metadata` is initialized automatically now (previously was `nil` unless initialized)
	+- Correctly show help message if `-h` is provided to a subcommand
	+- `context.(Global)IsSet` now respects environment variables. Previously it
	+ would return `false` if a flag was specified in the environment rather than
	+ as an argument
	+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
	+- `altsrc`s import paths were updated to use `gopkg.in/urfave/cli.v1`. This
	+ fixes issues that occurred when `gopkg.in/urfave/cli.v1` was imported as well
	+ as `altsrc` where Go would complain that the types didn't match
	+
	+## [1.18.1] - 2016-08-28
	+### Fixed
	+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user (backported)
	+
	+## [1.18.0] - 2016-06-27
	+### Added
	+- `./runtests` test runner with coverage tracking by default
	+- testing on OS X
	+- testing on Windows
	+- `UintFlag`, `Uint64Flag`, and `Int64Flag` types and supporting code
	+
	+### Changed
	+- Use spaces for alignment in help/usage output instead of tabs, making the
	+ output alignment consistent regardless of tab width
	+
	+### Fixed
	+- Printing of command aliases in help text
	+- Printing of visible flags for both struct and struct pointer flags
	+- Display the `help` subcommand when using `CommandCategories`
	+- No longer swallows `panic`s that occur within the `Action`s themselves when
	+ detecting the signature of the `Action` field
	+
	+## [1.17.1] - 2016-08-28
	+### Fixed
	+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
	+
	+## [1.17.0] - 2016-05-09
	+### Added
	+- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc`
	+- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool`
	+- Support for hiding commands by setting `Hidden: true` -- this will hide the
	+ commands in help output
	+
	+### Changed
	+- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer
	+ quoted in help text output.
	+- All flag types now include `(default: {value})` strings following usage when a
	+ default value can be (reasonably) detected.
	+- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent
	+ with non-slice flag types
	+- Apps now exit with a code of 3 if an unknown subcommand is specified
	+ (previously they printed "No help topic for...", but still exited 0. This
	+ makes it easier to script around apps built using `cli` since they can trust
	+ that a 0 exit code indicated a successful execution.
	+- cleanups based on [Go Report Card
	+ feedback](https://goreportcard.com/report/github.com/urfave/cli)
	+
	+## [1.16.1] - 2016-08-28
	+### Fixed
	+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
	+
	+## [1.16.0] - 2016-05-02
	+### Added
	+- `Hidden` field on all flag struct types to omit from generated help text
	+
	+### Changed
	+- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from
	+generated help text via the `Hidden` field
	+
	+### Fixed
	+- handling of error values in `HandleAction` and `HandleExitCoder`
	+
	+## [1.15.0] - 2016-04-30
	+### Added
	+- This file!
	+- Support for placeholders in flag usage strings
	+- `App.Metadata` map for arbitrary data/state management
	+- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after
	+parsing.
	+- Support for nested lookup of dot-delimited keys in structures loaded from
	+YAML.
	+
	+### Changed
	+- The `App.Action` and `Command.Action` now prefer a return signature of
	+`func(*cli.Context) error`, as defined by `cli.ActionFunc`. If a non-nil
	+`error` is returned, there may be two outcomes:
	+ - If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called
	+ automatically
	+ - Else the error is bubbled up and returned from `App.Run`
	+- Specifying an `Action` with the legacy return signature of
	+`func(*cli.Context)` will produce a deprecation message to stderr
	+- Specifying an `Action` that is not a `func` type will produce a non-zero exit
	+from `App.Run`
	+- Specifying an `Action` func that has an invalid (input) signature will
	+produce a non-zero exit from `App.Run`
	+
	+### Deprecated
	+- <a name="deprecated-cli-app-runandexitonerror"></a>
	+`cli.App.RunAndExitOnError`, which should now be done by returning an error
	+that fulfills `cli.ExitCoder` to `cli.App.Run`.
	+- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for
	+`cli.App.Action` of `func(*cli.Context)`, which should now have a return
	+signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`.
	+
	+### Fixed
	+- Added missing `*cli.Context.GlobalFloat64` method
	+
	+## [1.14.0] - 2016-04-03 (backfilled 2016-04-25)
	+### Added
	+- Codebeat badge
	+- Support for categorization via `CategorizedHelp` and `Categories` on app.
	+
	+### Changed
	+- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`.
	+
	+### Fixed
	+- Ensure version is not shown in help text when `HideVersion` set.
	+
	+## [1.13.0] - 2016-03-06 (backfilled 2016-04-25)
	+### Added
	+- YAML file input support.
	+- `NArg` method on context.
	+
	+## [1.12.0] - 2016-02-17 (backfilled 2016-04-25)
	+### Added
	+- Custom usage error handling.
	+- Custom text support in `USAGE` section of help output.
	+- Improved help messages for empty strings.
	+- AppVeyor CI configuration.
	+
	+### Changed
	+- Removed `panic` from default help printer func.
	+- De-duping and optimizations.
	+
	+### Fixed
	+- Correctly handle `Before`/`After` at command level when no subcommands.
	+- Case of literal `-` argument causing flag reordering.
	+- Environment variable hints on Windows.
	+- Docs updates.
	+
	+## [1.11.1] - 2015-12-21 (backfilled 2016-04-25)
	+### Changed
	+- Use `path.Base` in `Name` and `HelpName`
	+- Export `GetName` on flag types.
	+
	+### Fixed
	+- Flag parsing when skipping is enabled.
	+- Test output cleanup.
	+- Move completion check to account for empty input case.
	+
	+## [1.11.0] - 2015-11-15 (backfilled 2016-04-25)
	+### Added
	+- Destination scan support for flags.
	+- Testing against `tip` in Travis CI config.
	+
	+### Changed
	+- Go version in Travis CI config.
	+
	+### Fixed
	+- Removed redundant tests.
	+- Use correct example naming in tests.
	+
	+## [1.10.2] - 2015-10-29 (backfilled 2016-04-25)
	+### Fixed
	+- Remove unused var in bash completion.
	+
	+## [1.10.1] - 2015-10-21 (backfilled 2016-04-25)
	+### Added
	+- Coverage and reference logos in README.
	+
	+### Fixed
	+- Use specified values in help and version parsing.
	+- Only display app version and help message once.
	+
	+## [1.10.0] - 2015-10-06 (backfilled 2016-04-25)
	+### Added
	+- More tests for existing functionality.
	+- `ArgsUsage` at app and command level for help text flexibility.
	+
	+### Fixed
	+- Honor `HideHelp` and `HideVersion` in `App.Run`.
	+- Remove juvenile word from README.
	+
	+## [1.9.0] - 2015-09-08 (backfilled 2016-04-25)
	+### Added
	+- `FullName` on command with accompanying help output update.
	+- Set default `$PROG` in bash completion.
	+
	+### Changed
	+- Docs formatting.
	+
	+### Fixed
	+- Removed self-referential imports in tests.
	+
	+## [1.8.0] - 2015-06-30 (backfilled 2016-04-25)
	+### Added
	+- Support for `Copyright` at app level.
	+- `Parent` func at context level to walk up context lineage.
	+
	+### Fixed
	+- Global flag processing at top level.
	+
	+## [1.7.1] - 2015-06-11 (backfilled 2016-04-25)
	+### Added
	+- Aggregate errors from `Before`/`After` funcs.
	+- Doc comments on flag structs.
	+- Include non-global flags when checking version and help.
	+- Travis CI config updates.
	+
	+### Fixed
	+- Ensure slice type flags have non-nil values.
	+- Collect global flags from the full command hierarchy.
	+- Docs prose.
	+
	+## [1.7.0] - 2015-05-03 (backfilled 2016-04-25)
	+### Changed
	+- `HelpPrinter` signature includes output writer.
	+
	+### Fixed
	+- Specify go 1.1+ in docs.
	+- Set `Writer` when running command as app.
	+
	+## [1.6.0] - 2015-03-23 (backfilled 2016-04-25)
	+### Added
	+- Multiple author support.
	+- `NumFlags` at context level.
	+- `Aliases` at command level.
	+
	+### Deprecated
	+- `ShortName` at command level.
	+
	+### Fixed
	+- Subcommand help output.
	+- Backward compatible support for deprecated `Author` and `Email` fields.
	+- Docs regarding `Names`/`Aliases`.
	+
	+## [1.5.0] - 2015-02-20 (backfilled 2016-04-25)
	+### Added
	+- `After` hook func support at app and command level.
	+
	+### Fixed
	+- Use parsed context when running command as subcommand.
	+- Docs prose.
	+
	+## [1.4.1] - 2015-01-09 (backfilled 2016-04-25)
	+### Added
	+- Support for hiding `-h / --help` flags, but not `help` subcommand.
	+- Stop flag parsing after `--`.
	+
	+### Fixed
	+- Help text for generic flags to specify single value.
	+- Use double quotes in output for defaults.
	+- Use `ParseInt` instead of `ParseUint` for int environment var values.
	+- Use `0` as base when parsing int environment var values.
	+
	+## [1.4.0] - 2014-12-12 (backfilled 2016-04-25)
	+### Added
	+- Support for environment variable lookup "cascade".
	+- Support for `Stdout` on app for output redirection.
	+
	+### Fixed
	+- Print command help instead of app help in `ShowCommandHelp`.
	+
	+## [1.3.1] - 2014-11-13 (backfilled 2016-04-25)
	+### Added
	+- Docs and example code updates.
	+
	+### Changed
	+- Default `-v / --version` flag made optional.
	+
	+## [1.3.0] - 2014-08-10 (backfilled 2016-04-25)
	+### Added
	+- `FlagNames` at context level.
	+- Exposed `VersionPrinter` var for more control over version output.
	+- Zsh completion hook.
	+- `AUTHOR` section in default app help template.
	+- Contribution guidelines.
	+- `DurationFlag` type.
	+
	+## [1.2.0] - 2014-08-02
	+### Added
	+- Support for environment variable defaults on flags plus tests.
	+
	+## [1.1.0] - 2014-07-15
	+### Added
	+- Bash completion.
	+- Optional hiding of built-in help command.
	+- Optional skipping of flag parsing at command level.
	+- `Author`, `Email`, and `Compiled` metadata on app.
	+- `Before` hook func support at app and command level.
	+- `CommandNotFound` func support at app level.
	+- Command reference available on context.
	+- `GenericFlag` type.
	+- `Float64Flag` type.
	+- `BoolTFlag` type.
	+- `IsSet` flag helper on context.
	+- More flag lookup funcs at context level.
	+- More tests & docs.
	+
	+### Changed
	+- Help template updates to account for presence/absence of flags.
	+- Separated subcommand help template.
	+- Exposed `HelpPrinter` var for more control over help output.
	+
	+## [1.0.0] - 2013-11-01
	+### Added
	+- `help` flag in default app flag set and each command flag set.
	+- Custom handling of argument parsing errors.
	+- Command lookup by name at app level.
	+- `StringSliceFlag` type and supporting `StringSlice` type.
	+- `IntSliceFlag` type and supporting `IntSlice` type.
	+- Slice type flag lookups by name at context level.
	+- Export of app and command help functions.
	+- More tests & docs.
	+
	+## 0.1.0 - 2013-07-22
	+### Added
	+- Initial implementation.
	+
	+[Unreleased]: https://github.com/urfave/cli/compare/v1.18.0...HEAD
	+[1.18.0]: https://github.com/urfave/cli/compare/v1.17.0...v1.18.0
	+[1.17.0]: https://github.com/urfave/cli/compare/v1.16.0...v1.17.0
	+[1.16.0]: https://github.com/urfave/cli/compare/v1.15.0...v1.16.0
	+[1.15.0]: https://github.com/urfave/cli/compare/v1.14.0...v1.15.0
	+[1.14.0]: https://github.com/urfave/cli/compare/v1.13.0...v1.14.0
	+[1.13.0]: https://github.com/urfave/cli/compare/v1.12.0...v1.13.0
	+[1.12.0]: https://github.com/urfave/cli/compare/v1.11.1...v1.12.0
	+[1.11.1]: https://github.com/urfave/cli/compare/v1.11.0...v1.11.1
	+[1.11.0]: https://github.com/urfave/cli/compare/v1.10.2...v1.11.0
	+[1.10.2]: https://github.com/urfave/cli/compare/v1.10.1...v1.10.2
	+[1.10.1]: https://github.com/urfave/cli/compare/v1.10.0...v1.10.1
	+[1.10.0]: https://github.com/urfave/cli/compare/v1.9.0...v1.10.0
	+[1.9.0]: https://github.com/urfave/cli/compare/v1.8.0...v1.9.0
	+[1.8.0]: https://github.com/urfave/cli/compare/v1.7.1...v1.8.0
	+[1.7.1]: https://github.com/urfave/cli/compare/v1.7.0...v1.7.1
	+[1.7.0]: https://github.com/urfave/cli/compare/v1.6.0...v1.7.0
	+[1.6.0]: https://github.com/urfave/cli/compare/v1.5.0...v1.6.0
	+[1.5.0]: https://github.com/urfave/cli/compare/v1.4.1...v1.5.0
	+[1.4.1]: https://github.com/urfave/cli/compare/v1.4.0...v1.4.1
	+[1.4.0]: https://github.com/urfave/cli/compare/v1.3.1...v1.4.0
	+[1.3.1]: https://github.com/urfave/cli/compare/v1.3.0...v1.3.1
	+[1.3.0]: https://github.com/urfave/cli/compare/v1.2.0...v1.3.0
	+[1.2.0]: https://github.com/urfave/cli/compare/v1.1.0...v1.2.0
	+[1.1.0]: https://github.com/urfave/cli/compare/v1.0.0...v1.1.0
	+[1.0.0]: https://github.com/urfave/cli/compare/v0.1.0...v1.0.0
	diff --git a/src/gopkg.in/urfave/cli.v1/LICENSE b/src/gopkg.in/urfave/cli.v1/LICENSE
	new file mode 100644
	index 0000000..42a597e
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/LICENSE
	@@ -0,0 +1,21 @@
	+MIT License
	+
	+Copyright (c) 2016 Jeremy Saenz & Contributors
	+
	+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.
	diff --git a/src/gopkg.in/urfave/cli.v1/README.md b/src/gopkg.in/urfave/cli.v1/README.md
	new file mode 100644
	index 0000000..bb5f61e
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/README.md
	@@ -0,0 +1,1364 @@
	+cli
	+===
	+
	+[![Build Status](https://travis-ci.org/urfave/cli.svg?branch=master)](https://travis-ci.org/urfave/cli)
	+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/rtgk5xufi932pb2v?svg=true)](https://ci.appveyor.com/project/urfave/cli)
	+[![GoDoc](https://godoc.org/github.com/urfave/cli?status.svg)](https://godoc.org/github.com/urfave/cli)
	+[![codebeat](https://codebeat.co/badges/0a8f30aa-f975-404b-b878-5fab3ae1cc5f)](https://codebeat.co/projects/github-com-urfave-cli)
	+[![Go Report Card](https://goreportcard.com/badge/urfave/cli)](https://goreportcard.com/report/urfave/cli)
	+[![top level coverage](https://gocover.io/_badge/github.com/urfave/cli?0 "top level coverage")](http://gocover.io/github.com/urfave/cli) /
	+[![altsrc coverage](https://gocover.io/_badge/github.com/urfave/cli/altsrc?0 "altsrc coverage")](http://gocover.io/github.com/urfave/cli/altsrc)
	+
	+Notice: This is the library formerly known as
	+`github.com/codegangsta/cli` -- Github will automatically redirect requests
	+to this repository, but we recommend updating your references for clarity.
	+
	+cli is a simple, fast, and fun package for building command line apps in Go. The
	+goal is to enable developers to write fast and distributable command line
	+applications in an expressive way.
	+
	+<!-- toc -->
	+
	+- [Overview](#overview)
	+- [Installation](#installation)
	+ * [Supported platforms](#supported-platforms)
	+ * [Using the `v2` branch](#using-the-v2-branch)
	+ * [Pinning to the `v1` releases](#pinning-to-the-v1-releases)
	+- [Getting Started](#getting-started)
	+- [Examples](#examples)
	+ * [Arguments](#arguments)
	+ * [Flags](#flags)
	+ + [Placeholder Values](#placeholder-values)
	+ + [Alternate Names](#alternate-names)
	+ + [Ordering](#ordering)
	+ + [Values from the Environment](#values-from-the-environment)
	+ + [Values from alternate input sources (YAML, TOML, and others)](#values-from-alternate-input-sources-yaml-toml-and-others)
	+ * [Subcommands](#subcommands)
	+ * [Subcommands categories](#subcommands-categories)
	+ * [Exit code](#exit-code)
	+ * [Bash Completion](#bash-completion)
	+ + [Enabling](#enabling)
	+ + [Distribution](#distribution)
	+ + [Customization](#customization)
	+ * [Generated Help Text](#generated-help-text)
	+ + [Customization](#customization-1)
	+ * [Version Flag](#version-flag)
	+ + [Customization](#customization-2)
	+ + [Full API Example](#full-api-example)
	+- [Contribution Guidelines](#contribution-guidelines)
	+
	+<!-- tocstop -->
	+
	+## Overview
	+
	+Command line apps are usually so tiny that there is absolutely no reason why
	+your code should not be self-documenting. Things like generating help text and
	+parsing command flags/options should not hinder productivity when writing a
	+command line app.
	+
	+This is where cli comes into play. cli makes command line programming fun,
	+organized, and expressive!
	+
	+## Installation
	+
	+Make sure you have a working Go environment. Go version 1.2+ is supported. [See
	+the install instructions for Go](http://golang.org/doc/install.html).
	+
	+To install cli, simply run:
	+```
	+$ go get github.com/urfave/cli
	+```
	+
	+Make sure your `PATH` includes the `$GOPATH/bin` directory so your commands can
	+be easily used:
	+```
	+export PATH=$PATH:$GOPATH/bin
	+```
	+
	+### Supported platforms
	+
	+cli is tested against multiple versions of Go on Linux, and against the latest
	+released version of Go on OS X and Windows. For full details, see
	+[`./.travis.yml`](./.travis.yml) and [`./appveyor.yml`](./appveyor.yml).
	+
	+### Using the `v2` branch
	+
	+Warning: The `v2` branch is currently unreleased and considered unstable.
	+
	+There is currently a long-lived branch named `v2` that is intended to land as
	+the new `master` branch once development there has settled down. The current
	+`master` branch (mirrored as `v1`) is being manually merged into `v2` on
	+an irregular human-based schedule, but generally if one wants to "upgrade" to
	+`v2` now and accept the volatility (read: "awesomeness") that comes along with
	+that, please use whatever version pinning of your preference, such as via
	+`gopkg.in`:
	+
	+```
	+$ go get gopkg.in/urfave/cli.v2
	+```
	+
	+``` go
	+...
	+import (
	+ "gopkg.in/urfave/cli.v2" // imports as package "cli"
	+)
	+...
	+```
	+
	+### Pinning to the `v1` releases
	+
	+Similarly to the section above describing use of the `v2` branch, if one wants
	+to avoid any unexpected compatibility pains once `v2` becomes `master`, then
	+pinning to `v1` is an acceptable option, e.g.:
	+
	+```
	+$ go get gopkg.in/urfave/cli.v1
	+```
	+
	+``` go
	+...
	+import (
	+ "gopkg.in/urfave/cli.v1" // imports as package "cli"
	+)
	+...
	+```
	+
	+This will pull the latest tagged `v1` release (e.g. `v1.18.1` at the time of writing).
	+
	+## Getting Started
	+
	+One of the philosophies behind cli is that an API should be playful and full of
	+discovery. So a cli app can be as little as one line of code in `main()`.
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "A new cli application"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ cli.NewApp().Run(os.Args)
	+}
	+```
	+
	+This app will run and show help text, but is not very useful. Let's give an
	+action to execute and some help documentation:
	+
	+<!-- {
	+ "output": "boom! I say!"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+ app.Name = "boom"
	+ app.Usage = "make an explosive entrance"
	+ app.Action = func(c *cli.Context) error {
	+ fmt.Println("boom! I say!")
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+Running this already gives you a ton of functionality, plus support for things
	+like subcommands and flags, which are covered below.
	+
	+## Examples
	+
	+Being a programmer can be a lonely job. Thankfully by the power of automation
	+that is not the case! Let's create a greeter app to fend off our demons of
	+loneliness!
	+
	+Start by creating a directory named `greet`, and within it, add a file,
	+`greet.go` with the following code in it:
	+
	+<!-- {
	+ "output": "Hello friend!"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+ app.Name = "greet"
	+ app.Usage = "fight the loneliness!"
	+ app.Action = func(c *cli.Context) error {
	+ fmt.Println("Hello friend!")
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+Install our command to the `$GOPATH/bin` directory:
	+
	+```
	+$ go install
	+```
	+
	+Finally run our new command:
	+
	+```
	+$ greet
	+Hello friend!
	+```
	+
	+cli also generates neat help text:
	+
	+```
	+$ greet help
	+NAME:
	+ greet - fight the loneliness!
	+
	+USAGE:
	+ greet [global options] command [command options] [arguments...]
	+
	+VERSION:
	+ 0.0.0
	+
	+COMMANDS:
	+ help, h Shows a list of commands or help for one command
	+
	+GLOBAL OPTIONS
	+ --version Shows version information
	+```
	+
	+### Arguments
	+
	+You can lookup arguments by calling the `Args` function on `cli.Context`, e.g.:
	+
	+<!-- {
	+ "output": "Hello \""
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Action = func(c *cli.Context) error {
	+ fmt.Printf("Hello %q", c.Args().Get(0))
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+### Flags
	+
	+Setting and querying flags is simple.
	+
	+<!-- {
	+ "output": "Hello Nefertiti"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ },
	+ }
	+
	+ app.Action = func(c *cli.Context) error {
	+ name := "Nefertiti"
	+ if c.NArg() > 0 {
	+ name = c.Args().Get(0)
	+ }
	+ if c.String("lang") == "spanish" {
	+ fmt.Println("Hola", name)
	+ } else {
	+ fmt.Println("Hello", name)
	+ }
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+You can also set a destination variable for a flag, to which the content will be
	+scanned.
	+
	+<!-- {
	+ "output": "Hello someone"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+ "fmt"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ var language string
	+
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ Destination: &language,
	+ },
	+ }
	+
	+ app.Action = func(c *cli.Context) error {
	+ name := "someone"
	+ if c.NArg() > 0 {
	+ name = c.Args()[0]
	+ }
	+ if language == "spanish" {
	+ fmt.Println("Hola", name)
	+ } else {
	+ fmt.Println("Hello", name)
	+ }
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+See full list of flags at http://godoc.org/github.com/urfave/cli
	+
	+#### Placeholder Values
	+
	+Sometimes it's useful to specify a flag's value within the usage string itself.
	+Such placeholders are indicated with back quotes.
	+
	+For example this:
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "--config FILE, -c FILE"
	+} -->
	+```go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag{
	+ cli.StringFlag{
	+ Name: "config, c",
	+ Usage: "Load configuration from `FILE`",
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+Will result in help output like:
	+
	+```
	+--config FILE, -c FILE Load configuration from FILE
	+```
	+
	+Note that only the first placeholder is used. Subsequent back-quoted words will
	+be left as-is.
	+
	+#### Alternate Names
	+
	+You can set alternate (or short) names for flags by providing a comma-delimited
	+list for the `Name`. e.g.
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "--lang value, -l value.language for the greeting.default: \"english\""
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang, l",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+That flag can then be set with `--lang spanish` or `-l spanish`. Note that
	+giving two different forms of the same flag in the same command invocation is an
	+error.
	+
	+#### Ordering
	+
	+Flags for the application and commands are shown in the order they are defined.
	+However, it's possible to sort them from outside this library by using `FlagsByName`
	+with `sort`.
	+
	+For example this:
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "Load configuration from FILE\n.Language for the greeting."
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+ "sort"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang, l",
	+ Value: "english",
	+ Usage: "Language for the greeting",
	+ },
	+ cli.StringFlag{
	+ Name: "config, c",
	+ Usage: "Load configuration from `FILE`",
	+ },
	+ }
	+
	+ sort.Sort(cli.FlagsByName(app.Flags))
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+Will result in help output like:
	+
	+```
	+--config FILE, -c FILE Load configuration from FILE
	+--lang value, -l value Language for the greeting (default: "english")
	+```
	+
	+#### Values from the Environment
	+
	+You can also have the default value set from the environment via `EnvVar`. e.g.
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "language for the greeting.*APP_LANG"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang, l",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ EnvVar: "APP_LANG",
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+The `EnvVar` may also be given as a comma-delimited "cascade", where the first
	+environment variable that resolves is used as the default.
	+
	+<!-- {
	+ "args": ["--help"],
	+ "output": "language for the greeting.LEGACY_COMPAT_LANG.APP_LANG.*LANG"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Flags = []cli.Flag {
	+ cli.StringFlag{
	+ Name: "lang, l",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+#### Values from alternate input sources (YAML, TOML, and others)
	+
	+There is a separate package altsrc that adds support for getting flag values
	+from other file input sources.
	+
	+Currently supported input source formats:
	+* YAML
	+* TOML
	+
	+In order to get values for a flag from an alternate input source the following
	+code would be added to wrap an existing cli.Flag like below:
	+
	+``` go
	+ altsrc.NewIntFlag(cli.IntFlag{Name: "test"})
	+```
	+
	+Initialization must also occur for these flags. Below is an example initializing
	+getting data from a yaml file below.
	+
	+``` go
	+ command.Before = altsrc.InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+```
	+
	+The code above will use the "load" string as a flag name to get the file name of
	+a yaml file from the cli.Context. It will then use that file name to initialize
	+the yaml input source for any flags that are defined on that command. As a note
	+the "load" flag used would also have to be defined on the command flags in order
	+for this code snipped to work.
	+
	+Currently only the aboved specified formats are supported but developers can
	+add support for other input sources by implementing the
	+altsrc.InputSourceContext for their given sources.
	+
	+Here is a more complete sample of a command using YAML support:
	+
	+<!-- {
	+ "args": ["test-cmd", "--help"],
	+ "output": "&#45-test value.*default: 0"
	+} -->
	+``` go
	+package notmain
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+ "github.com/urfave/cli/altsrc"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ flags := []cli.Flag{
	+ altsrc.NewIntFlag(cli.IntFlag{Name: "test"}),
	+ cli.StringFlag{Name: "load"},
	+ }
	+
	+ app.Action = func(c *cli.Context) error {
	+ fmt.Println("yaml ist rad")
	+ return nil
	+ }
	+
	+ app.Before = altsrc.InitInputSourceWithContext(flags, altsrc.NewYamlSourceFromFlagFunc("load"))
	+ app.Flags = flags
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+### Subcommands
	+
	+Subcommands can be defined for a more git-like command line app.
	+
	+<!-- {
	+ "args": ["template", "add"],
	+ "output": "new task template: .+"
	+} -->
	+```go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Commands = []cli.Command{
	+ {
	+ Name: "add",
	+ Aliases: []string{"a"},
	+ Usage: "add a task to the list",
	+ Action: func(c *cli.Context) error {
	+ fmt.Println("added task: ", c.Args().First())
	+ return nil
	+ },
	+ },
	+ {
	+ Name: "complete",
	+ Aliases: []string{"c"},
	+ Usage: "complete a task on the list",
	+ Action: func(c *cli.Context) error {
	+ fmt.Println("completed task: ", c.Args().First())
	+ return nil
	+ },
	+ },
	+ {
	+ Name: "template",
	+ Aliases: []string{"t"},
	+ Usage: "options for task templates",
	+ Subcommands: []cli.Command{
	+ {
	+ Name: "add",
	+ Usage: "add a new template",
	+ Action: func(c *cli.Context) error {
	+ fmt.Println("new task template: ", c.Args().First())
	+ return nil
	+ },
	+ },
	+ {
	+ Name: "remove",
	+ Usage: "remove an existing template",
	+ Action: func(c *cli.Context) error {
	+ fmt.Println("removed task template: ", c.Args().First())
	+ return nil
	+ },
	+ },
	+ },
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+### Subcommands categories
	+
	+For additional organization in apps that have many subcommands, you can
	+associate a category for each command to group them together in the help
	+output.
	+
	+E.g.
	+
	+```go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+
	+ app.Commands = []cli.Command{
	+ {
	+ Name: "noop",
	+ },
	+ {
	+ Name: "add",
	+ Category: "template",
	+ },
	+ {
	+ Name: "remove",
	+ Category: "template",
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+Will include:
	+
	+```
	+COMMANDS:
	+ noop
	+
	+ Template actions:
	+ add
	+ remove
	+```
	+
	+### Exit code
	+
	+Calling `App.Run` will not automatically call `os.Exit`, which means that by
	+default the exit code will "fall through" to being `0`. An explicit exit code
	+may be set by returning a non-nil error that fulfills `cli.ExitCoder`, or a
	+`cli.MultiError` that includes an error that fulfills `cli.ExitCoder`, e.g.:
	+
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ app := cli.NewApp()
	+ app.Flags = []cli.Flag{
	+ cli.BoolTFlag{
	+ Name: "ginger-crouton",
	+ Usage: "is it in the soup?",
	+ },
	+ }
	+ app.Action = func(ctx *cli.Context) error {
	+ if !ctx.Bool("ginger-crouton") {
	+ return cli.NewExitError("it is not in the soup", 86)
	+ }
	+ return nil
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+### Bash Completion
	+
	+You can enable completion commands by setting the `EnableBashCompletion`
	+flag on the `App` object. By default, this setting will only auto-complete to
	+show an app's subcommands, but you can write your own completion methods for
	+the App or its subcommands.
	+
	+<!-- {
	+ "args": ["complete", "--generate-bash-completion"],
	+ "output": "laundry"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ tasks := []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
	+
	+ app := cli.NewApp()
	+ app.EnableBashCompletion = true
	+ app.Commands = []cli.Command{
	+ {
	+ Name: "complete",
	+ Aliases: []string{"c"},
	+ Usage: "complete a task on the list",
	+ Action: func(c *cli.Context) error {
	+ fmt.Println("completed task: ", c.Args().First())
	+ return nil
	+ },
	+ BashComplete: func(c *cli.Context) {
	+ // This will complete if no args are passed
	+ if c.NArg() > 0 {
	+ return
	+ }
	+ for _, t := range tasks {
	+ fmt.Println(t)
	+ }
	+ },
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+}
	+```
	+
	+#### Enabling
	+
	+Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
	+setting the `PROG` variable to the name of your program:
	+
	+`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
	+
	+#### Distribution
	+
	+Copy `autocomplete/bash_autocomplete` into `/etc/bash_completion.d/` and rename
	+it to the name of the program you wish to add autocomplete support for (or
	+automatically install it there if you are distributing a package). Don't forget
	+to source the file to make it active in the current shell.
	+
	+```
	+sudo cp src/bash_autocomplete /etc/bash_completion.d/<myprogram>
	+source /etc/bash_completion.d/<myprogram>
	+```
	+
	+Alternatively, you can just document that users should source the generic
	+`autocomplete/bash_autocomplete` in their bash configuration with `$PROG` set
	+to the name of their program (as above).
	+
	+#### Customization
	+
	+The default bash completion flag (`--generate-bash-completion`) is defined as
	+`cli.BashCompletionFlag`, and may be redefined if desired, e.g.:
	+
	+<!-- {
	+ "args": ["--compgen"],
	+ "output": "wat\nhelp\nh"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ cli.BashCompletionFlag = cli.BoolFlag{
	+ Name: "compgen",
	+ Hidden: true,
	+ }
	+
	+ app := cli.NewApp()
	+ app.EnableBashCompletion = true
	+ app.Commands = []cli.Command{
	+ {
	+ Name: "wat",
	+ },
	+ }
	+ app.Run(os.Args)
	+}
	+```
	+
	+### Generated Help Text
	+
	+The default help flag (`-h/--help`) is defined as `cli.HelpFlag` and is checked
	+by the cli internals in order to print generated help text for the app, command,
	+or subcommand, and break execution.
	+
	+#### Customization
	+
	+All of the help text generation may be customized, and at multiple levels. The
	+templates are exposed as variables `AppHelpTemplate`, `CommandHelpTemplate`, and
	+`SubcommandHelpTemplate` which may be reassigned or augmented, and full override
	+is possible by assigning a compatible func to the `cli.HelpPrinter` variable,
	+e.g.:
	+
	+<!-- {
	+ "output": "Ha HA. I pwnd the help!!1"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "io"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ // EXAMPLE: Append to an existing template
	+ cli.AppHelpTemplate = fmt.Sprintf(`%s
	+
	+WEBSITE: http://awesometown.example.com
	+
	+SUPPORT: support@awesometown.example.com
	+
	+`, cli.AppHelpTemplate)
	+
	+ // EXAMPLE: Override a template
	+ cli.AppHelpTemplate = `NAME:
	+ {{.Name}} - {{.Usage}}
	+USAGE:
	+ {{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command
	+[command options]{{end}} {{if
	+.ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
	+ {{if len .Authors}}
	+AUTHOR(S):
	+ {{range .Authors}}{{ . }}{{end}}
	+ {{end}}{{if .Commands}}
	+COMMANDS:
	+{{range .Commands}}{{if not .HideHelp}} {{join .Names ", "}}{{ "\t"
	+}}{{.Usage}}{{ "\n" }}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
	+GLOBAL OPTIONS:
	+ {{range .VisibleFlags}}{{.}}
	+ {{end}}{{end}}{{if .Copyright }}
	+COPYRIGHT:
	+ {{.Copyright}}
	+ {{end}}{{if .Version}}
	+VERSION:
	+ {{.Version}}
	+ {{end}}
	+`
	+
	+ // EXAMPLE: Replace the `HelpPrinter` func
	+ cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {
	+ fmt.Println("Ha HA. I pwnd the help!!1")
	+ }
	+
	+ cli.NewApp().Run(os.Args)
	+}
	+```
	+
	+The default flag may be customized to something other than `-h/--help` by
	+setting `cli.HelpFlag`, e.g.:
	+
	+<!-- {
	+ "args": ["-&#45halp"],
	+ "output": "haaaaalp.*HALP"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ cli.HelpFlag = cli.BoolFlag{
	+ Name: "halp, haaaaalp",
	+ Usage: "HALP",
	+ EnvVar: "SHOW_HALP,HALPPLZ",
	+ }
	+
	+ cli.NewApp().Run(os.Args)
	+}
	+```
	+
	+### Version Flag
	+
	+The default version flag (`-v/--version`) is defined as `cli.VersionFlag`, which
	+is checked by the cli internals in order to print the `App.Version` via
	+`cli.VersionPrinter` and break execution.
	+
	+#### Customization
	+
	+The default flag may be customized to something other than `-v/--version` by
	+setting `cli.VersionFlag`, e.g.:
	+
	+<!-- {
	+ "args": ["-&#45print-version"],
	+ "output": "partay version 19\\.99\\.0"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func main() {
	+ cli.VersionFlag = cli.BoolFlag{
	+ Name: "print-version, V",
	+ Usage: "print only the version",
	+ }
	+
	+ app := cli.NewApp()
	+ app.Name = "partay"
	+ app.Version = "19.99.0"
	+ app.Run(os.Args)
	+}
	+```
	+
	+Alternatively, the version printer at `cli.VersionPrinter` may be overridden, e.g.:
	+
	+<!-- {
	+ "args": ["-&#45version"],
	+ "output": "version=19\\.99\\.0 revision=fafafaf"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "fmt"
	+ "os"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+var (
	+ Revision = "fafafaf"
	+)
	+
	+func main() {
	+ cli.VersionPrinter = func(c *cli.Context) {
	+ fmt.Printf("version=%s revision=%s\n", c.App.Version, Revision)
	+ }
	+
	+ app := cli.NewApp()
	+ app.Name = "partay"
	+ app.Version = "19.99.0"
	+ app.Run(os.Args)
	+}
	+```
	+
	+#### Full API Example
	+
	+Notice: This is a contrived (functioning) example meant strictly for API
	+demonstration purposes. Use of one's imagination is encouraged.
	+
	+<!-- {
	+ "output": "made it!\nPhew!"
	+} -->
	+``` go
	+package main
	+
	+import (
	+ "errors"
	+ "flag"
	+ "fmt"
	+ "io"
	+ "io/ioutil"
	+ "os"
	+ "time"
	+
	+ "github.com/urfave/cli"
	+)
	+
	+func init() {
	+ cli.AppHelpTemplate += "\nCUSTOMIZED: you bet ur muffins\n"
	+ cli.CommandHelpTemplate += "\nYMMV\n"
	+ cli.SubcommandHelpTemplate += "\nor something\n"
	+
	+ cli.HelpFlag = cli.BoolFlag{Name: "halp"}
	+ cli.BashCompletionFlag = cli.BoolFlag{Name: "compgen", Hidden: true}
	+ cli.VersionFlag = cli.BoolFlag{Name: "print-version, V"}
	+
	+ cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {
	+ fmt.Fprintf(w, "best of luck to you\n")
	+ }
	+ cli.VersionPrinter = func(c *cli.Context) {
	+ fmt.Fprintf(c.App.Writer, "version=%s\n", c.App.Version)
	+ }
	+ cli.OsExiter = func(c int) {
	+ fmt.Fprintf(cli.ErrWriter, "refusing to exit %d\n", c)
	+ }
	+ cli.ErrWriter = ioutil.Discard
	+ cli.FlagStringer = func(fl cli.Flag) string {
	+ return fmt.Sprintf("\t\t%s", fl.GetName())
	+ }
	+}
	+
	+type hexWriter struct{}
	+
	+func (w *hexWriter) Write(p []byte) (int, error) {
	+ for _, b := range p {
	+ fmt.Printf("%x", b)
	+ }
	+ fmt.Printf("\n")
	+
	+ return len(p), nil
	+}
	+
	+type genericType struct{
	+ s string
	+}
	+
	+func (g *genericType) Set(value string) error {
	+ g.s = value
	+ return nil
	+}
	+
	+func (g *genericType) String() string {
	+ return g.s
	+}
	+
	+func main() {
	+ app := cli.NewApp()
	+ app.Name = "kənˈtrīv"
	+ app.Version = "19.99.0"
	+ app.Compiled = time.Now()
	+ app.Authors = []cli.Author{
	+ cli.Author{
	+ Name: "Example Human",
	+ Email: "human@example.com",
	+ },
	+ }
	+ app.Copyright = "(c) 1999 Serious Enterprise"
	+ app.HelpName = "contrive"
	+ app.Usage = "demonstrate available API"
	+ app.UsageText = "contrive - demonstrating the available API"
	+ app.ArgsUsage = "[args and such]"
	+ app.Commands = []cli.Command{
	+ cli.Command{
	+ Name: "doo",
	+ Aliases: []string{"do"},
	+ Category: "motion",
	+ Usage: "do the doo",
	+ UsageText: "doo - does the dooing",
	+ Description: "no really, there is a lot of dooing to be done",
	+ ArgsUsage: "[arrgh]",
	+ Flags: []cli.Flag{
	+ cli.BoolFlag{Name: "forever, forevvarr"},
	+ },
	+ Subcommands: cli.Commands{
	+ cli.Command{
	+ Name: "wop",
	+ Action: wopAction,
	+ },
	+ },
	+ SkipFlagParsing: false,
	+ HideHelp: false,
	+ Hidden: false,
	+ HelpName: "doo!",
	+ BashComplete: func(c *cli.Context) {
	+ fmt.Fprintf(c.App.Writer, "--better\n")
	+ },
	+ Before: func(c *cli.Context) error {
	+ fmt.Fprintf(c.App.Writer, "brace for impact\n")
	+ return nil
	+ },
	+ After: func(c *cli.Context) error {
	+ fmt.Fprintf(c.App.Writer, "did we lose anyone?\n")
	+ return nil
	+ },
	+ Action: func(c *cli.Context) error {
	+ c.Command.FullName()
	+ c.Command.HasName("wop")
	+ c.Command.Names()
	+ c.Command.VisibleFlags()
	+ fmt.Fprintf(c.App.Writer, "dodododododoodododddooooododododooo\n")
	+ if c.Bool("forever") {
	+ c.Command.Run(c)
	+ }
	+ return nil
	+ },
	+ OnUsageError: func(c *cli.Context, err error, isSubcommand bool) error {
	+ fmt.Fprintf(c.App.Writer, "for shame\n")
	+ return err
	+ },
	+ },
	+ }
	+ app.Flags = []cli.Flag{
	+ cli.BoolFlag{Name: "fancy"},
	+ cli.BoolTFlag{Name: "fancier"},
	+ cli.DurationFlag{Name: "howlong, H", Value: time.Second * 3},
	+ cli.Float64Flag{Name: "howmuch"},
	+ cli.GenericFlag{Name: "wat", Value: &genericType{}},
	+ cli.Int64Flag{Name: "longdistance"},
	+ cli.Int64SliceFlag{Name: "intervals"},
	+ cli.IntFlag{Name: "distance"},
	+ cli.IntSliceFlag{Name: "times"},
	+ cli.StringFlag{Name: "dance-move, d"},
	+ cli.StringSliceFlag{Name: "names, N"},
	+ cli.UintFlag{Name: "age"},
	+ cli.Uint64Flag{Name: "bigage"},
	+ }
	+ app.EnableBashCompletion = true
	+ app.HideHelp = false
	+ app.HideVersion = false
	+ app.BashComplete = func(c *cli.Context) {
	+ fmt.Fprintf(c.App.Writer, "lipstick\nkiss\nme\nlipstick\nringo\n")
	+ }
	+ app.Before = func(c *cli.Context) error {
	+ fmt.Fprintf(c.App.Writer, "HEEEERE GOES\n")
	+ return nil
	+ }
	+ app.After = func(c *cli.Context) error {
	+ fmt.Fprintf(c.App.Writer, "Phew!\n")
	+ return nil
	+ }
	+ app.CommandNotFound = func(c *cli.Context, command string) {
	+ fmt.Fprintf(c.App.Writer, "Thar be no %q here.\n", command)
	+ }
	+ app.OnUsageError = func(c *cli.Context, err error, isSubcommand bool) error {
	+ if isSubcommand {
	+ return err
	+ }
	+
	+ fmt.Fprintf(c.App.Writer, "WRONG: %#v\n", err)
	+ return nil
	+ }
	+ app.Action = func(c *cli.Context) error {
	+ cli.DefaultAppComplete(c)
	+ cli.HandleExitCoder(errors.New("not an exit coder, though"))
	+ cli.ShowAppHelp(c)
	+ cli.ShowCommandCompletions(c, "nope")
	+ cli.ShowCommandHelp(c, "also-nope")
	+ cli.ShowCompletions(c)
	+ cli.ShowSubcommandHelp(c)
	+ cli.ShowVersion(c)
	+
	+ categories := c.App.Categories()
	+ categories.AddCommand("sounds", cli.Command{
	+ Name: "bloop",
	+ })
	+
	+ for _, category := range c.App.Categories() {
	+ fmt.Fprintf(c.App.Writer, "%s\n", category.Name)
	+ fmt.Fprintf(c.App.Writer, "%#v\n", category.Commands)
	+ fmt.Fprintf(c.App.Writer, "%#v\n", category.VisibleCommands())
	+ }
	+
	+ fmt.Printf("%#v\n", c.App.Command("doo"))
	+ if c.Bool("infinite") {
	+ c.App.Run([]string{"app", "doo", "wop"})
	+ }
	+
	+ if c.Bool("forevar") {
	+ c.App.RunAsSubcommand(c)
	+ }
	+ c.App.Setup()
	+ fmt.Printf("%#v\n", c.App.VisibleCategories())
	+ fmt.Printf("%#v\n", c.App.VisibleCommands())
	+ fmt.Printf("%#v\n", c.App.VisibleFlags())
	+
	+ fmt.Printf("%#v\n", c.Args().First())
	+ if len(c.Args()) > 0 {
	+ fmt.Printf("%#v\n", c.Args()[1])
	+ }
	+ fmt.Printf("%#v\n", c.Args().Present())
	+ fmt.Printf("%#v\n", c.Args().Tail())
	+
	+ set := flag.NewFlagSet("contrive", 0)
	+ nc := cli.NewContext(c.App, set, c)
	+
	+ fmt.Printf("%#v\n", nc.Args())
	+ fmt.Printf("%#v\n", nc.Bool("nope"))
	+ fmt.Printf("%#v\n", nc.BoolT("nerp"))
	+ fmt.Printf("%#v\n", nc.Duration("howlong"))
	+ fmt.Printf("%#v\n", nc.Float64("hay"))
	+ fmt.Printf("%#v\n", nc.Generic("bloop"))
	+ fmt.Printf("%#v\n", nc.Int64("bonk"))
	+ fmt.Printf("%#v\n", nc.Int64Slice("burnks"))
	+ fmt.Printf("%#v\n", nc.Int("bips"))
	+ fmt.Printf("%#v\n", nc.IntSlice("blups"))
	+ fmt.Printf("%#v\n", nc.String("snurt"))
	+ fmt.Printf("%#v\n", nc.StringSlice("snurkles"))
	+ fmt.Printf("%#v\n", nc.Uint("flub"))
	+ fmt.Printf("%#v\n", nc.Uint64("florb"))
	+ fmt.Printf("%#v\n", nc.GlobalBool("global-nope"))
	+ fmt.Printf("%#v\n", nc.GlobalBoolT("global-nerp"))
	+ fmt.Printf("%#v\n", nc.GlobalDuration("global-howlong"))
	+ fmt.Printf("%#v\n", nc.GlobalFloat64("global-hay"))
	+ fmt.Printf("%#v\n", nc.GlobalGeneric("global-bloop"))
	+ fmt.Printf("%#v\n", nc.GlobalInt("global-bips"))
	+ fmt.Printf("%#v\n", nc.GlobalIntSlice("global-blups"))
	+ fmt.Printf("%#v\n", nc.GlobalString("global-snurt"))
	+ fmt.Printf("%#v\n", nc.GlobalStringSlice("global-snurkles"))
	+
	+ fmt.Printf("%#v\n", nc.FlagNames())
	+ fmt.Printf("%#v\n", nc.GlobalFlagNames())
	+ fmt.Printf("%#v\n", nc.GlobalIsSet("wat"))
	+ fmt.Printf("%#v\n", nc.GlobalSet("wat", "nope"))
	+ fmt.Printf("%#v\n", nc.NArg())
	+ fmt.Printf("%#v\n", nc.NumFlags())
	+ fmt.Printf("%#v\n", nc.Parent())
	+
	+ nc.Set("wat", "also-nope")
	+
	+ ec := cli.NewExitError("ohwell", 86)
	+ fmt.Fprintf(c.App.Writer, "%d", ec.ExitCode())
	+ fmt.Printf("made it!\n")
	+ return ec
	+ }
	+
	+ if os.Getenv("HEXY") != "" {
	+ app.Writer = &hexWriter{}
	+ app.ErrWriter = &hexWriter{}
	+ }
	+
	+ app.Metadata = map[string]interface{}{
	+ "layers": "many",
	+ "explicable": false,
	+ "whatever-values": 19.99,
	+ }
	+
	+ app.Run(os.Args)
	+}
	+
	+func wopAction(c *cli.Context) error {
	+ fmt.Fprintf(c.App.Writer, ":wave: over here, eh\n")
	+ return nil
	+}
	+```
	+
	+## Contribution Guidelines
	+
	+Feel free to put up a pull request to fix a bug or maybe add a feature. I will
	+give it a code review and make sure that it does not break backwards
	+compatibility. If I or any other collaborators agree that it is in line with
	+the vision of the project, we will work with you to get the code into
	+a mergeable state and merge it into the master branch.
	+
	+If you have contributed something significant to the project, we will most
	+likely add you as a collaborator. As a collaborator you are given the ability
	+to merge others pull requests. It is very important that new code does not
	+break existing code, so be careful about what code you do choose to merge.
	+
	+If you feel like you have contributed to the project but have not yet been
	+added as a collaborator, we probably forgot to add you, please open an issue.
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/altsrc.go b/src/gopkg.in/urfave/cli.v1/altsrc/altsrc.go
	new file mode 100644
	index 0000000..ac34bf6
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/altsrc.go
	@@ -0,0 +1,3 @@
	+package altsrc
	+
	+//go:generate python ../generate-flag-types altsrc -i ../flag-types.json -o flag_generated.go
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/flag.go b/src/gopkg.in/urfave/cli.v1/altsrc/flag.go
	new file mode 100644
	index 0000000..84ef009
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/flag.go
	@@ -0,0 +1,261 @@
	+package altsrc
	+
	+import (
	+ "fmt"
	+ "strconv"
	+ "strings"
	+ "syscall"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+// FlagInputSourceExtension is an extension interface of cli.Flag that
	+// allows a value to be set on the existing parsed flags.
	+type FlagInputSourceExtension interface {
	+ cli.Flag
	+ ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error
	+}
	+
	+// ApplyInputSourceValues iterates over all provided flags and
	+// executes ApplyInputSourceValue on flags implementing the
	+// FlagInputSourceExtension interface to initialize these flags
	+// to an alternate input source.
	+func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error {
	+ for _, f := range flags {
	+ inputSourceExtendedFlag, isType := f.(FlagInputSourceExtension)
	+ if isType {
	+ err := inputSourceExtendedFlag.ApplyInputSourceValue(context, inputSourceContext)
	+ if err != nil {
	+ return err
	+ }
	+ }
	+ }
	+
	+ return nil
	+}
	+
	+// InitInputSource is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
	+// input source based on the func provided. If there is no error it will then apply the new input source to any flags
	+// that are supported by the input source
	+func InitInputSource(flags []cli.Flag, createInputSource func() (InputSourceContext, error)) cli.BeforeFunc {
	+ return func(context *cli.Context) error {
	+ inputSource, err := createInputSource()
	+ if err != nil {
	+ return fmt.Errorf("Unable to create input source: inner error: \n'%v'", err.Error())
	+ }
	+
	+ return ApplyInputSourceValues(context, inputSource, flags)
	+ }
	+}
	+
	+// InitInputSourceWithContext is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
	+// input source based on the func provided with potentially using existing cli.Context values to initialize itself. If there is
	+// no error it will then apply the new input source to any flags that are supported by the input source
	+func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(context *cli.Context) (InputSourceContext, error)) cli.BeforeFunc {
	+ return func(context *cli.Context) error {
	+ inputSource, err := createInputSource(context)
	+ if err != nil {
	+ return fmt.Errorf("Unable to create input source with context: inner error: \n'%v'", err.Error())
	+ }
	+
	+ return ApplyInputSourceValues(context, inputSource, flags)
	+ }
	+}
	+
	+// ApplyInputSourceValue applies a generic value to the flagSet if required
	+func (f GenericFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
	+ value, err := isc.Generic(f.GenericFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value != nil {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, value.String())
	+ })
	+ }
	+ }
	+ }
	+
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a StringSlice value to the flagSet if required
	+func (f StringSliceFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
	+ value, err := isc.StringSlice(f.StringSliceFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value != nil {
	+ var sliceValue cli.StringSlice = value
	+ eachName(f.Name, func(name string) {
	+ underlyingFlag := f.set.Lookup(f.Name)
	+ if underlyingFlag != nil {
	+ underlyingFlag.Value = &sliceValue
	+ }
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a IntSlice value if required
	+func (f IntSliceFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
	+ value, err := isc.IntSlice(f.IntSliceFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value != nil {
	+ var sliceValue cli.IntSlice = value
	+ eachName(f.Name, func(name string) {
	+ underlyingFlag := f.set.Lookup(f.Name)
	+ if underlyingFlag != nil {
	+ underlyingFlag.Value = &sliceValue
	+ }
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a Bool value to the flagSet if required
	+func (f BoolFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
	+ value, err := isc.Bool(f.BoolFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, strconv.FormatBool(value))
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a BoolT value to the flagSet if required
	+func (f BoolTFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
	+ value, err := isc.BoolT(f.BoolTFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if !value {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, strconv.FormatBool(value))
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a String value to the flagSet if required
	+func (f StringFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !(context.IsSet(f.Name) \|\| isEnvVarSet(f.EnvVar)) {
	+ value, err := isc.String(f.StringFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value != "" {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, value)
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a int value to the flagSet if required
	+func (f IntFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !(context.IsSet(f.Name) \|\| isEnvVarSet(f.EnvVar)) {
	+ value, err := isc.Int(f.IntFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value > 0 {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, strconv.FormatInt(int64(value), 10))
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a Duration value to the flagSet if required
	+func (f DurationFlag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !(context.IsSet(f.Name) \|\| isEnvVarSet(f.EnvVar)) {
	+ value, err := isc.Duration(f.DurationFlag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value > 0 {
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, value.String())
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+// ApplyInputSourceValue applies a Float64 value to the flagSet if required
	+func (f Float64Flag) ApplyInputSourceValue(context cli.Context, isc InputSourceContext) error {
	+ if f.set != nil {
	+ if !(context.IsSet(f.Name) \|\| isEnvVarSet(f.EnvVar)) {
	+ value, err := isc.Float64(f.Float64Flag.Name)
	+ if err != nil {
	+ return err
	+ }
	+ if value > 0 {
	+ floatStr := float64ToString(value)
	+ eachName(f.Name, func(name string) {
	+ f.set.Set(f.Name, floatStr)
	+ })
	+ }
	+ }
	+ }
	+ return nil
	+}
	+
	+func isEnvVarSet(envVars string) bool {
	+ for _, envVar := range strings.Split(envVars, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if _, ok := syscall.Getenv(envVar); ok {
	+ // TODO: Can't use this for bools as
	+ // set means that it was true or false based on
	+ // Bool flag type, should work for other types
	+ return true
	+ }
	+ }
	+
	+ return false
	+}
	+
	+func float64ToString(f float64) string {
	+ return fmt.Sprintf("%v", f)
	+}
	+
	+func eachName(longName string, fn func(string)) {
	+ parts := strings.Split(longName, ",")
	+ for _, name := range parts {
	+ name = strings.Trim(name, " ")
	+ fn(name)
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/flag_generated.go b/src/gopkg.in/urfave/cli.v1/altsrc/flag_generated.go
	new file mode 100644
	index 0000000..0aeb0b0
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/flag_generated.go
	@@ -0,0 +1,347 @@
	+package altsrc
	+
	+import (
	+ "flag"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+// WARNING: This file is generated!
	+
	+// BoolFlag is the flag type that wraps cli.BoolFlag to allow
	+// for other values to be specified
	+type BoolFlag struct {
	+ cli.BoolFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewBoolFlag creates a new BoolFlag
	+func NewBoolFlag(fl cli.BoolFlag) *BoolFlag {
	+ return &BoolFlag{BoolFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped BoolFlag.Apply
	+func (f BoolFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.BoolFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped BoolFlag.ApplyWithError
	+func (f BoolFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.BoolFlag.ApplyWithError(set)
	+}
	+
	+// BoolTFlag is the flag type that wraps cli.BoolTFlag to allow
	+// for other values to be specified
	+type BoolTFlag struct {
	+ cli.BoolTFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewBoolTFlag creates a new BoolTFlag
	+func NewBoolTFlag(fl cli.BoolTFlag) *BoolTFlag {
	+ return &BoolTFlag{BoolTFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped BoolTFlag.Apply
	+func (f BoolTFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.BoolTFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped BoolTFlag.ApplyWithError
	+func (f BoolTFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.BoolTFlag.ApplyWithError(set)
	+}
	+
	+// DurationFlag is the flag type that wraps cli.DurationFlag to allow
	+// for other values to be specified
	+type DurationFlag struct {
	+ cli.DurationFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewDurationFlag creates a new DurationFlag
	+func NewDurationFlag(fl cli.DurationFlag) *DurationFlag {
	+ return &DurationFlag{DurationFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped DurationFlag.Apply
	+func (f DurationFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.DurationFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped DurationFlag.ApplyWithError
	+func (f DurationFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.DurationFlag.ApplyWithError(set)
	+}
	+
	+// Float64Flag is the flag type that wraps cli.Float64Flag to allow
	+// for other values to be specified
	+type Float64Flag struct {
	+ cli.Float64Flag
	+ set *flag.FlagSet
	+}
	+
	+// NewFloat64Flag creates a new Float64Flag
	+func NewFloat64Flag(fl cli.Float64Flag) *Float64Flag {
	+ return &Float64Flag{Float64Flag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped Float64Flag.Apply
	+func (f Float64Flag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.Float64Flag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped Float64Flag.ApplyWithError
	+func (f Float64Flag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.Float64Flag.ApplyWithError(set)
	+}
	+
	+// GenericFlag is the flag type that wraps cli.GenericFlag to allow
	+// for other values to be specified
	+type GenericFlag struct {
	+ cli.GenericFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewGenericFlag creates a new GenericFlag
	+func NewGenericFlag(fl cli.GenericFlag) *GenericFlag {
	+ return &GenericFlag{GenericFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped GenericFlag.Apply
	+func (f GenericFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.GenericFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped GenericFlag.ApplyWithError
	+func (f GenericFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.GenericFlag.ApplyWithError(set)
	+}
	+
	+// Int64Flag is the flag type that wraps cli.Int64Flag to allow
	+// for other values to be specified
	+type Int64Flag struct {
	+ cli.Int64Flag
	+ set *flag.FlagSet
	+}
	+
	+// NewInt64Flag creates a new Int64Flag
	+func NewInt64Flag(fl cli.Int64Flag) *Int64Flag {
	+ return &Int64Flag{Int64Flag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped Int64Flag.Apply
	+func (f Int64Flag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.Int64Flag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped Int64Flag.ApplyWithError
	+func (f Int64Flag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.Int64Flag.ApplyWithError(set)
	+}
	+
	+// IntFlag is the flag type that wraps cli.IntFlag to allow
	+// for other values to be specified
	+type IntFlag struct {
	+ cli.IntFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewIntFlag creates a new IntFlag
	+func NewIntFlag(fl cli.IntFlag) *IntFlag {
	+ return &IntFlag{IntFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped IntFlag.Apply
	+func (f IntFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.IntFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped IntFlag.ApplyWithError
	+func (f IntFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.IntFlag.ApplyWithError(set)
	+}
	+
	+// IntSliceFlag is the flag type that wraps cli.IntSliceFlag to allow
	+// for other values to be specified
	+type IntSliceFlag struct {
	+ cli.IntSliceFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewIntSliceFlag creates a new IntSliceFlag
	+func NewIntSliceFlag(fl cli.IntSliceFlag) *IntSliceFlag {
	+ return &IntSliceFlag{IntSliceFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped IntSliceFlag.Apply
	+func (f IntSliceFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.IntSliceFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped IntSliceFlag.ApplyWithError
	+func (f IntSliceFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.IntSliceFlag.ApplyWithError(set)
	+}
	+
	+// Int64SliceFlag is the flag type that wraps cli.Int64SliceFlag to allow
	+// for other values to be specified
	+type Int64SliceFlag struct {
	+ cli.Int64SliceFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewInt64SliceFlag creates a new Int64SliceFlag
	+func NewInt64SliceFlag(fl cli.Int64SliceFlag) *Int64SliceFlag {
	+ return &Int64SliceFlag{Int64SliceFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped Int64SliceFlag.Apply
	+func (f Int64SliceFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.Int64SliceFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped Int64SliceFlag.ApplyWithError
	+func (f Int64SliceFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.Int64SliceFlag.ApplyWithError(set)
	+}
	+
	+// StringFlag is the flag type that wraps cli.StringFlag to allow
	+// for other values to be specified
	+type StringFlag struct {
	+ cli.StringFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewStringFlag creates a new StringFlag
	+func NewStringFlag(fl cli.StringFlag) *StringFlag {
	+ return &StringFlag{StringFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped StringFlag.Apply
	+func (f StringFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.StringFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped StringFlag.ApplyWithError
	+func (f StringFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.StringFlag.ApplyWithError(set)
	+}
	+
	+// StringSliceFlag is the flag type that wraps cli.StringSliceFlag to allow
	+// for other values to be specified
	+type StringSliceFlag struct {
	+ cli.StringSliceFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewStringSliceFlag creates a new StringSliceFlag
	+func NewStringSliceFlag(fl cli.StringSliceFlag) *StringSliceFlag {
	+ return &StringSliceFlag{StringSliceFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped StringSliceFlag.Apply
	+func (f StringSliceFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.StringSliceFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped StringSliceFlag.ApplyWithError
	+func (f StringSliceFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.StringSliceFlag.ApplyWithError(set)
	+}
	+
	+// Uint64Flag is the flag type that wraps cli.Uint64Flag to allow
	+// for other values to be specified
	+type Uint64Flag struct {
	+ cli.Uint64Flag
	+ set *flag.FlagSet
	+}
	+
	+// NewUint64Flag creates a new Uint64Flag
	+func NewUint64Flag(fl cli.Uint64Flag) *Uint64Flag {
	+ return &Uint64Flag{Uint64Flag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped Uint64Flag.Apply
	+func (f Uint64Flag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.Uint64Flag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped Uint64Flag.ApplyWithError
	+func (f Uint64Flag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.Uint64Flag.ApplyWithError(set)
	+}
	+
	+// UintFlag is the flag type that wraps cli.UintFlag to allow
	+// for other values to be specified
	+type UintFlag struct {
	+ cli.UintFlag
	+ set *flag.FlagSet
	+}
	+
	+// NewUintFlag creates a new UintFlag
	+func NewUintFlag(fl cli.UintFlag) *UintFlag {
	+ return &UintFlag{UintFlag: fl, set: nil}
	+}
	+
	+// Apply saves the flagSet for later usage calls, then calls the
	+// wrapped UintFlag.Apply
	+func (f UintFlag) Apply(set flag.FlagSet) {
	+ f.set = set
	+ f.UintFlag.Apply(set)
	+}
	+
	+// ApplyWithError saves the flagSet for later usage calls, then calls the
	+// wrapped UintFlag.ApplyWithError
	+func (f UintFlag) ApplyWithError(set flag.FlagSet) error {
	+ f.set = set
	+ return f.UintFlag.ApplyWithError(set)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/flag_test.go b/src/gopkg.in/urfave/cli.v1/altsrc/flag_test.go
	new file mode 100644
	index 0000000..9e9c96d
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/flag_test.go
	@@ -0,0 +1,336 @@
	+package altsrc
	+
	+import (
	+ "flag"
	+ "fmt"
	+ "os"
	+ "strings"
	+ "testing"
	+ "time"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+type testApplyInputSource struct {
	+ Flag FlagInputSourceExtension
	+ FlagName string
	+ FlagSetName string
	+ Expected string
	+ ContextValueString string
	+ ContextValue flag.Value
	+ EnvVarValue string
	+ EnvVarName string
	+ MapValue interface{}
	+}
	+
	+func TestGenericApplyInputSourceValue(t *testing.T) {
	+ v := &Parser{"abc", "def"}
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}}),
	+ FlagName: "test",
	+ MapValue: v,
	+ })
	+ expect(t, v, c.Generic("test"))
	+}
	+
	+func TestGenericApplyInputSourceMethodContextSet(t *testing.T) {
	+ p := &Parser{"abc", "def"}
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}}),
	+ FlagName: "test",
	+ MapValue: &Parser{"efg", "hig"},
	+ ContextValueString: p.String(),
	+ })
	+ expect(t, p, c.Generic("test"))
	+}
	+
	+func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}, EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: &Parser{"efg", "hij"},
	+ EnvVarName: "TEST",
	+ EnvVarValue: "abc,def",
	+ })
	+ expect(t, &Parser{"abc", "def"}, c.Generic("test"))
	+}
	+
	+func TestStringSliceApplyInputSourceValue(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringSliceFlag(cli.StringSliceFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: []string{"hello", "world"},
	+ })
	+ expect(t, c.StringSlice("test"), []string{"hello", "world"})
	+}
	+
	+func TestStringSliceApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringSliceFlag(cli.StringSliceFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: []string{"hello", "world"},
	+ ContextValueString: "ohno",
	+ })
	+ expect(t, c.StringSlice("test"), []string{"ohno"})
	+}
	+
	+func TestStringSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringSliceFlag(cli.StringSliceFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: []string{"hello", "world"},
	+ EnvVarName: "TEST",
	+ EnvVarValue: "oh,no",
	+ })
	+ expect(t, c.StringSlice("test"), []string{"oh", "no"})
	+}
	+
	+func TestIntSliceApplyInputSourceValue(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntSliceFlag(cli.IntSliceFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: []int{1, 2},
	+ })
	+ expect(t, c.IntSlice("test"), []int{1, 2})
	+}
	+
	+func TestIntSliceApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntSliceFlag(cli.IntSliceFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: []int{1, 2},
	+ ContextValueString: "3",
	+ })
	+ expect(t, c.IntSlice("test"), []int{3})
	+}
	+
	+func TestIntSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntSliceFlag(cli.IntSliceFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: []int{1, 2},
	+ EnvVarName: "TEST",
	+ EnvVarValue: "3,4",
	+ })
	+ expect(t, c.IntSlice("test"), []int{3, 4})
	+}
	+
	+func TestBoolApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolFlag(cli.BoolFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: true,
	+ })
	+ expect(t, true, c.Bool("test"))
	+}
	+
	+func TestBoolApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolFlag(cli.BoolFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: false,
	+ ContextValueString: "true",
	+ })
	+ expect(t, true, c.Bool("test"))
	+}
	+
	+func TestBoolApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolFlag(cli.BoolFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: false,
	+ EnvVarName: "TEST",
	+ EnvVarValue: "true",
	+ })
	+ expect(t, true, c.Bool("test"))
	+}
	+
	+func TestBoolTApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolTFlag(cli.BoolTFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: false,
	+ })
	+ expect(t, false, c.BoolT("test"))
	+}
	+
	+func TestBoolTApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolTFlag(cli.BoolTFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: true,
	+ ContextValueString: "false",
	+ })
	+ expect(t, false, c.BoolT("test"))
	+}
	+
	+func TestBoolTApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewBoolTFlag(cli.BoolTFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: true,
	+ EnvVarName: "TEST",
	+ EnvVarValue: "false",
	+ })
	+ expect(t, false, c.BoolT("test"))
	+}
	+
	+func TestStringApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringFlag(cli.StringFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: "hello",
	+ })
	+ expect(t, "hello", c.String("test"))
	+}
	+
	+func TestStringApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringFlag(cli.StringFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: "hello",
	+ ContextValueString: "goodbye",
	+ })
	+ expect(t, "goodbye", c.String("test"))
	+}
	+
	+func TestStringApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewStringFlag(cli.StringFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: "hello",
	+ EnvVarName: "TEST",
	+ EnvVarValue: "goodbye",
	+ })
	+ expect(t, "goodbye", c.String("test"))
	+}
	+
	+func TestIntApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntFlag(cli.IntFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: 15,
	+ })
	+ expect(t, 15, c.Int("test"))
	+}
	+
	+func TestIntApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntFlag(cli.IntFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: 15,
	+ ContextValueString: "7",
	+ })
	+ expect(t, 7, c.Int("test"))
	+}
	+
	+func TestIntApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: 15,
	+ EnvVarName: "TEST",
	+ EnvVarValue: "12",
	+ })
	+ expect(t, 12, c.Int("test"))
	+}
	+
	+func TestDurationApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewDurationFlag(cli.DurationFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: time.Duration(30 * time.Second),
	+ })
	+ expect(t, time.Duration(30*time.Second), c.Duration("test"))
	+}
	+
	+func TestDurationApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewDurationFlag(cli.DurationFlag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: time.Duration(30 * time.Second),
	+ ContextValueString: time.Duration(15 * time.Second).String(),
	+ })
	+ expect(t, time.Duration(15*time.Second), c.Duration("test"))
	+}
	+
	+func TestDurationApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewDurationFlag(cli.DurationFlag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: time.Duration(30 * time.Second),
	+ EnvVarName: "TEST",
	+ EnvVarValue: time.Duration(15 * time.Second).String(),
	+ })
	+ expect(t, time.Duration(15*time.Second), c.Duration("test"))
	+}
	+
	+func TestFloat64ApplyInputSourceMethodSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewFloat64Flag(cli.Float64Flag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: 1.3,
	+ })
	+ expect(t, 1.3, c.Float64("test"))
	+}
	+
	+func TestFloat64ApplyInputSourceMethodContextSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewFloat64Flag(cli.Float64Flag{Name: "test"}),
	+ FlagName: "test",
	+ MapValue: 1.3,
	+ ContextValueString: fmt.Sprintf("%v", 1.4),
	+ })
	+ expect(t, 1.4, c.Float64("test"))
	+}
	+
	+func TestFloat64ApplyInputSourceMethodEnvVarSet(t *testing.T) {
	+ c := runTest(t, testApplyInputSource{
	+ Flag: NewFloat64Flag(cli.Float64Flag{Name: "test", EnvVar: "TEST"}),
	+ FlagName: "test",
	+ MapValue: 1.3,
	+ EnvVarName: "TEST",
	+ EnvVarValue: fmt.Sprintf("%v", 1.4),
	+ })
	+ expect(t, 1.4, c.Float64("test"))
	+}
	+
	+func runTest(t testing.T, test testApplyInputSource) cli.Context {
	+ inputSource := &MapInputSource{valueMap: map[interface{}]interface{}{test.FlagName: test.MapValue}}
	+ set := flag.NewFlagSet(test.FlagSetName, flag.ContinueOnError)
	+ c := cli.NewContext(nil, set, nil)
	+ if test.EnvVarName != "" && test.EnvVarValue != "" {
	+ os.Setenv(test.EnvVarName, test.EnvVarValue)
	+ defer os.Setenv(test.EnvVarName, "")
	+ }
	+
	+ test.Flag.Apply(set)
	+ if test.ContextValue != nil {
	+ flag := set.Lookup(test.FlagName)
	+ flag.Value = test.ContextValue
	+ }
	+ if test.ContextValueString != "" {
	+ set.Set(test.FlagName, test.ContextValueString)
	+ }
	+ test.Flag.ApplyInputSourceValue(c, inputSource)
	+
	+ return c
	+}
	+
	+type Parser [2]string
	+
	+func (p *Parser) Set(value string) error {
	+ parts := strings.Split(value, ",")
	+ if len(parts) != 2 {
	+ return fmt.Errorf("invalid format")
	+ }
	+
	+ (*p)[0] = parts[0]
	+ (*p)[1] = parts[1]
	+
	+ return nil
	+}
	+
	+func (p *Parser) String() string {
	+ return fmt.Sprintf("%s,%s", p[0], p[1])
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/helpers_test.go b/src/gopkg.in/urfave/cli.v1/altsrc/helpers_test.go
	new file mode 100644
	index 0000000..3b7f7e9
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/helpers_test.go
	@@ -0,0 +1,18 @@
	+package altsrc
	+
	+import (
	+ "reflect"
	+ "testing"
	+)
	+
	+func expect(t *testing.T, a interface{}, b interface{}) {
	+ if !reflect.DeepEqual(b, a) {
	+ t.Errorf("Expected %#v (type %v) - Got %#v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
	+ }
	+}
	+
	+func refute(t *testing.T, a interface{}, b interface{}) {
	+ if a == b {
	+ t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/input_source_context.go b/src/gopkg.in/urfave/cli.v1/altsrc/input_source_context.go
	new file mode 100644
	index 0000000..276dcda
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/input_source_context.go
	@@ -0,0 +1,21 @@
	+package altsrc
	+
	+import (
	+ "time"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+// InputSourceContext is an interface used to allow
	+// other input sources to be implemented as needed.
	+type InputSourceContext interface {
	+ Int(name string) (int, error)
	+ Duration(name string) (time.Duration, error)
	+ Float64(name string) (float64, error)
	+ String(name string) (string, error)
	+ StringSlice(name string) ([]string, error)
	+ IntSlice(name string) ([]int, error)
	+ Generic(name string) (cli.Generic, error)
	+ Bool(name string) (bool, error)
	+ BoolT(name string) (bool, error)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/map_input_source.go b/src/gopkg.in/urfave/cli.v1/altsrc/map_input_source.go
	new file mode 100644
	index 0000000..b720995
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/map_input_source.go
	@@ -0,0 +1,248 @@
	+package altsrc
	+
	+import (
	+ "fmt"
	+ "reflect"
	+ "strings"
	+ "time"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+// MapInputSource implements InputSourceContext to return
	+// data from the map that is loaded.
	+type MapInputSource struct {
	+ valueMap map[interface{}]interface{}
	+}
	+
	+// nestedVal checks if the name has '.' delimiters.
	+// If so, it tries to traverse the tree by the '.' delimited sections to find
	+// a nested value for the key.
	+func nestedVal(name string, tree map[interface{}]interface{}) (interface{}, bool) {
	+ if sections := strings.Split(name, "."); len(sections) > 1 {
	+ node := tree
	+ for _, section := range sections[:len(sections)-1] {
	+ if child, ok := node[section]; !ok {
	+ return nil, false
	+ } else {
	+ if ctype, ok := child.(map[interface{}]interface{}); !ok {
	+ return nil, false
	+ } else {
	+ node = ctype
	+ }
	+ }
	+ }
	+ if val, ok := node[sections[len(sections)-1]]; ok {
	+ return val, true
	+ }
	+ }
	+ return nil, false
	+}
	+
	+// Int returns an int from the map if it exists otherwise returns 0
	+func (fsm *MapInputSource) Int(name string) (int, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(int)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "int", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(int)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "int", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return 0, nil
	+}
	+
	+// Duration returns a duration from the map if it exists otherwise returns 0
	+func (fsm *MapInputSource) Duration(name string) (time.Duration, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(time.Duration)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "duration", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(time.Duration)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "duration", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return 0, nil
	+}
	+
	+// Float64 returns an float64 from the map if it exists otherwise returns 0
	+func (fsm *MapInputSource) Float64(name string) (float64, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(float64)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "float64", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(float64)
	+ if !isType {
	+ return 0, incorrectTypeForFlagError(name, "float64", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return 0, nil
	+}
	+
	+// String returns a string from the map if it exists otherwise returns an empty string
	+func (fsm *MapInputSource) String(name string) (string, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(string)
	+ if !isType {
	+ return "", incorrectTypeForFlagError(name, "string", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(string)
	+ if !isType {
	+ return "", incorrectTypeForFlagError(name, "string", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return "", nil
	+}
	+
	+// StringSlice returns an []string from the map if it exists otherwise returns nil
	+func (fsm *MapInputSource) StringSlice(name string) ([]string, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.([]string)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "[]string", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.([]string)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "[]string", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return nil, nil
	+}
	+
	+// IntSlice returns an []int from the map if it exists otherwise returns nil
	+func (fsm *MapInputSource) IntSlice(name string) ([]int, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.([]int)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "[]int", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.([]int)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "[]int", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return nil, nil
	+}
	+
	+// Generic returns an cli.Generic from the map if it exists otherwise returns nil
	+func (fsm *MapInputSource) Generic(name string) (cli.Generic, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(cli.Generic)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "cli.Generic", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(cli.Generic)
	+ if !isType {
	+ return nil, incorrectTypeForFlagError(name, "cli.Generic", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return nil, nil
	+}
	+
	+// Bool returns an bool from the map otherwise returns false
	+func (fsm *MapInputSource) Bool(name string) (bool, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(bool)
	+ if !isType {
	+ return false, incorrectTypeForFlagError(name, "bool", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(bool)
	+ if !isType {
	+ return false, incorrectTypeForFlagError(name, "bool", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return false, nil
	+}
	+
	+// BoolT returns an bool from the map otherwise returns true
	+func (fsm *MapInputSource) BoolT(name string) (bool, error) {
	+ otherGenericValue, exists := fsm.valueMap[name]
	+ if exists {
	+ otherValue, isType := otherGenericValue.(bool)
	+ if !isType {
	+ return true, incorrectTypeForFlagError(name, "bool", otherGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+ nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
	+ if exists {
	+ otherValue, isType := nestedGenericValue.(bool)
	+ if !isType {
	+ return true, incorrectTypeForFlagError(name, "bool", nestedGenericValue)
	+ }
	+ return otherValue, nil
	+ }
	+
	+ return true, nil
	+}
	+
	+func incorrectTypeForFlagError(name, expectedTypeName string, value interface{}) error {
	+ valueType := reflect.TypeOf(value)
	+ valueTypeName := ""
	+ if valueType != nil {
	+ valueTypeName = valueType.Name()
	+ }
	+
	+ return fmt.Errorf("Mismatched type for flag '%s'. Expected '%s' but actual is '%s'", name, expectedTypeName, valueTypeName)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/toml_command_test.go b/src/gopkg.in/urfave/cli.v1/altsrc/toml_command_test.go
	new file mode 100644
	index 0000000..a5053d4
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/toml_command_test.go
	@@ -0,0 +1,310 @@
	+// Disabling building of toml support in cases where golang is 1.0 or 1.1
	+// as the encoding library is not implemented or supported.
	+
	+// +build go1.2
	+
	+package altsrc
	+
	+import (
	+ "flag"
	+ "io/ioutil"
	+ "os"
	+ "testing"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+func TestCommandTomFileTest(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
	+ defer os.Remove("current.toml")
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestGlobalEnvVarWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ os.Setenv("THE_TEST", "10")
	+ defer os.Setenv("THE_TEST", "")
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 10)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestGlobalEnvVarWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ os.Setenv("THE_TEST", "10")
	+ defer os.Setenv("THE_TEST", "")
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 10)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestSpecifiedFlagWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ test := []string{"test-cmd", "--load", "current.toml", "--test", "7"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 7)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestSpecifiedFlagWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte(`[top]
	+ test = 15`), 0666)
	+ defer os.Remove("current.toml")
	+
	+ test := []string{"test-cmd", "--load", "current.toml", "--top.test", "7"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 7)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestDefaultValueFileWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", Value: 7}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileTestDefaultValueFileWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ os.Setenv("THE_TEST", "11")
	+ defer os.Setenv("THE_TEST", "")
	+
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 11)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", Value: 7, EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
	+ defer os.Remove("current.toml")
	+
	+ os.Setenv("THE_TEST", "11")
	+ defer os.Setenv("THE_TEST", "")
	+
	+ test := []string{"test-cmd", "--load", "current.toml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 11)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7, EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/toml_file_loader.go b/src/gopkg.in/urfave/cli.v1/altsrc/toml_file_loader.go
	new file mode 100644
	index 0000000..39c124f
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/toml_file_loader.go
	@@ -0,0 +1,113 @@
	+// Disabling building of toml support in cases where golang is 1.0 or 1.1
	+// as the encoding library is not implemented or supported.
	+
	+// +build go1.2
	+
	+package altsrc
	+
	+import (
	+ "fmt"
	+ "reflect"
	+
	+ "github.com/BurntSushi/toml"
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+type tomlMap struct {
	+ Map map[interface{}]interface{}
	+}
	+
	+func unmarshalMap(i interface{}) (ret map[interface{}]interface{}, err error) {
	+ ret = make(map[interface{}]interface{})
	+ m := i.(map[string]interface{})
	+ for key, val := range m {
	+ v := reflect.ValueOf(val)
	+ switch v.Kind() {
	+ case reflect.Bool:
	+ ret[key] = val.(bool)
	+ case reflect.String:
	+ ret[key] = val.(string)
	+ case reflect.Int:
	+ ret[key] = int(val.(int))
	+ case reflect.Int8:
	+ ret[key] = int(val.(int8))
	+ case reflect.Int16:
	+ ret[key] = int(val.(int16))
	+ case reflect.Int32:
	+ ret[key] = int(val.(int32))
	+ case reflect.Int64:
	+ ret[key] = int(val.(int64))
	+ case reflect.Uint:
	+ ret[key] = int(val.(uint))
	+ case reflect.Uint8:
	+ ret[key] = int(val.(uint8))
	+ case reflect.Uint16:
	+ ret[key] = int(val.(uint16))
	+ case reflect.Uint32:
	+ ret[key] = int(val.(uint32))
	+ case reflect.Uint64:
	+ ret[key] = int(val.(uint64))
	+ case reflect.Float32:
	+ ret[key] = float64(val.(float32))
	+ case reflect.Float64:
	+ ret[key] = float64(val.(float64))
	+ case reflect.Map:
	+ if tmp, err := unmarshalMap(val); err == nil {
	+ ret[key] = tmp
	+ } else {
	+ return nil, err
	+ }
	+ case reflect.Array:
	+ fallthrough // [todo] - Support array type
	+ default:
	+ return nil, fmt.Errorf("Unsupported: type = %#v", v.Kind())
	+ }
	+ }
	+ return ret, nil
	+}
	+
	+func (self *tomlMap) UnmarshalTOML(i interface{}) error {
	+ if tmp, err := unmarshalMap(i); err == nil {
	+ self.Map = tmp
	+ } else {
	+ return err
	+ }
	+ return nil
	+}
	+
	+type tomlSourceContext struct {
	+ FilePath string
	+}
	+
	+// NewTomlSourceFromFile creates a new TOML InputSourceContext from a filepath.
	+func NewTomlSourceFromFile(file string) (InputSourceContext, error) {
	+ tsc := &tomlSourceContext{FilePath: file}
	+ var results tomlMap = tomlMap{}
	+ if err := readCommandToml(tsc.FilePath, &results); err != nil {
	+ return nil, fmt.Errorf("Unable to load TOML file '%s': inner error: \n'%v'", tsc.FilePath, err.Error())
	+ }
	+ return &MapInputSource{valueMap: results.Map}, nil
	+}
	+
	+// NewTomlSourceFromFlagFunc creates a new TOML InputSourceContext from a provided flag name and source context.
	+func NewTomlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
	+ return func(context *cli.Context) (InputSourceContext, error) {
	+ filePath := context.String(flagFileName)
	+ return NewTomlSourceFromFile(filePath)
	+ }
	+}
	+
	+func readCommandToml(filePath string, container interface{}) (err error) {
	+ b, err := loadDataFrom(filePath)
	+ if err != nil {
	+ return err
	+ }
	+
	+ err = toml.Unmarshal(b, container)
	+ if err != nil {
	+ return err
	+ }
	+
	+ err = nil
	+ return
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/yaml_command_test.go b/src/gopkg.in/urfave/cli.v1/altsrc/yaml_command_test.go
	new file mode 100644
	index 0000000..9d3f431
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/yaml_command_test.go
	@@ -0,0 +1,313 @@
	+// Disabling building of yaml support in cases where golang is 1.0 or 1.1
	+// as the encoding library is not implemented or supported.
	+
	+// +build go1.2
	+
	+package altsrc
	+
	+import (
	+ "flag"
	+ "io/ioutil"
	+ "os"
	+ "testing"
	+
	+ "gopkg.in/urfave/cli.v1"
	+)
	+
	+func TestCommandYamlFileTest(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
	+ defer os.Remove("current.yaml")
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestGlobalEnvVarWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ os.Setenv("THE_TEST", "10")
	+ defer os.Setenv("THE_TEST", "")
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 10)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestGlobalEnvVarWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte(`top:
	+ test: 15`), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ os.Setenv("THE_TEST", "10")
	+ defer os.Setenv("THE_TEST", "")
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 10)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestSpecifiedFlagWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml", "--test", "7"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 7)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestSpecifiedFlagWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte(`top:
	+ test: 15`), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml", "--top.test", "7"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 7)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestDefaultValueFileWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", Value: 7}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileTestDefaultValueFileWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte(`top:
	+ test: 15`), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 15)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWins(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ os.Setenv("THE_TEST", "11")
	+ defer os.Setenv("THE_TEST", "")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("test")
	+ expect(t, val, 11)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "test", Value: 7, EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	+
	+func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWinsNested(t *testing.T) {
	+ app := cli.NewApp()
	+ set := flag.NewFlagSet("test", 0)
	+ ioutil.WriteFile("current.yaml", []byte(`top:
	+ test: 15`), 0666)
	+ defer os.Remove("current.yaml")
	+
	+ os.Setenv("THE_TEST", "11")
	+ defer os.Setenv("THE_TEST", "")
	+
	+ test := []string{"test-cmd", "--load", "current.yaml"}
	+ set.Parse(test)
	+
	+ c := cli.NewContext(app, set, nil)
	+
	+ command := &cli.Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(c *cli.Context) error {
	+ val := c.Int("top.test")
	+ expect(t, val, 11)
	+ return nil
	+ },
	+ Flags: []cli.Flag{
	+ NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7, EnvVar: "THE_TEST"}),
	+ cli.StringFlag{Name: "load"}},
	+ }
	+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
	+ err := command.Run(c)
	+
	+ expect(t, err, nil)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/altsrc/yaml_file_loader.go b/src/gopkg.in/urfave/cli.v1/altsrc/yaml_file_loader.go
	new file mode 100644
	index 0000000..335356f
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/altsrc/yaml_file_loader.go
	@@ -0,0 +1,84 @@
	+// Disabling building of yaml support in cases where golang is 1.0 or 1.1
	+// as the encoding library is not implemented or supported.
	+
	+// +build go1.2
	+
	+package altsrc
	+
	+import (
	+ "fmt"
	+ "io/ioutil"
	+ "net/http"
	+ "net/url"
	+ "os"
	+
	+ "gopkg.in/urfave/cli.v1"
	+
	+ "gopkg.in/yaml.v2"
	+)
	+
	+type yamlSourceContext struct {
	+ FilePath string
	+}
	+
	+// NewYamlSourceFromFile creates a new Yaml InputSourceContext from a filepath.
	+func NewYamlSourceFromFile(file string) (InputSourceContext, error) {
	+ ysc := &yamlSourceContext{FilePath: file}
	+ var results map[interface{}]interface{}
	+ err := readCommandYaml(ysc.FilePath, &results)
	+ if err != nil {
	+ return nil, fmt.Errorf("Unable to load Yaml file '%s': inner error: \n'%v'", ysc.FilePath, err.Error())
	+ }
	+
	+ return &MapInputSource{valueMap: results}, nil
	+}
	+
	+// NewYamlSourceFromFlagFunc creates a new Yaml InputSourceContext from a provided flag name and source context.
	+func NewYamlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
	+ return func(context *cli.Context) (InputSourceContext, error) {
	+ filePath := context.String(flagFileName)
	+ return NewYamlSourceFromFile(filePath)
	+ }
	+}
	+
	+func readCommandYaml(filePath string, container interface{}) (err error) {
	+ b, err := loadDataFrom(filePath)
	+ if err != nil {
	+ return err
	+ }
	+
	+ err = yaml.Unmarshal(b, container)
	+ if err != nil {
	+ return err
	+ }
	+
	+ err = nil
	+ return
	+}
	+
	+func loadDataFrom(filePath string) ([]byte, error) {
	+ u, err := url.Parse(filePath)
	+ if err != nil {
	+ return nil, err
	+ }
	+
	+ if u.Host != "" { // i have a host, now do i support the scheme?
	+ switch u.Scheme {
	+ case "http", "https":
	+ res, err := http.Get(filePath)
	+ if err != nil {
	+ return nil, err
	+ }
	+ return ioutil.ReadAll(res.Body)
	+ default:
	+ return nil, fmt.Errorf("scheme of %s is unsupported", filePath)
	+ }
	+ } else if u.Path != "" { // i dont have a host, but I have a path. I am a local file.
	+ if _, notFoundFileErr := os.Stat(filePath); notFoundFileErr != nil {
	+ return nil, fmt.Errorf("Cannot read from file: '%s' because it does not exist.", filePath)
	+ }
	+ return ioutil.ReadFile(filePath)
	+ } else {
	+ return nil, fmt.Errorf("unable to determine how to load from path %s", filePath)
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/app.go b/src/gopkg.in/urfave/cli.v1/app.go
	new file mode 100644
	index 0000000..95ffc0b
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/app.go
	@@ -0,0 +1,492 @@
	+package cli
	+
	+import (
	+ "fmt"
	+ "io"
	+ "io/ioutil"
	+ "os"
	+ "path/filepath"
	+ "sort"
	+ "time"
	+)
	+
	+var (
	+ changeLogURL = "https://github.com/urfave/cli/blob/master/CHANGELOG.md"
	+ appActionDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
	+ runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL)
	+
	+ contactSysadmin = "This is an error in the application. Please contact the distributor of this application if this is not you."
	+
	+ errInvalidActionType = NewExitError("ERROR invalid Action type. "+
	+ fmt.Sprintf("Must be `func(Context`)` or `func(Context) error). %s", contactSysadmin)+
	+ fmt.Sprintf("See %s", appActionDeprecationURL), 2)
	+)
	+
	+// App is the main structure of a cli application. It is recommended that
	+// an app be created with the cli.NewApp() function
	+type App struct {
	+ // The name of the program. Defaults to path.Base(os.Args[0])
	+ Name string
	+ // Full name of command for help, defaults to Name
	+ HelpName string
	+ // Description of the program.
	+ Usage string
	+ // Text to override the USAGE section of help
	+ UsageText string
	+ // Description of the program argument format.
	+ ArgsUsage string
	+ // Version of the program
	+ Version string
	+ // Description of the program
	+ Description string
	+ // List of commands to execute
	+ Commands []Command
	+ // List of flags to parse
	+ Flags []Flag
	+ // Boolean to enable bash completion commands
	+ EnableBashCompletion bool
	+ // Boolean to hide built-in help command
	+ HideHelp bool
	+ // Boolean to hide built-in version flag and the VERSION section of help
	+ HideVersion bool
	+ // Populate on app startup, only gettable through method Categories()
	+ categories CommandCategories
	+ // An action to execute when the bash-completion flag is set
	+ BashComplete BashCompleteFunc
	+ // An action to execute before any subcommands are run, but after the context is ready
	+ // If a non-nil error is returned, no subcommands are run
	+ Before BeforeFunc
	+ // An action to execute after any subcommands are run, but after the subcommand has finished
	+ // It is run even if Action() panics
	+ After AfterFunc
	+
	+ // The action to execute when no subcommands are specified
	+ // Expects a `cli.ActionFunc` but will accept the deprecated signature of `func(*cli.Context) {}`
	+ // Note: support for the deprecated `Action` signature will be removed in a future version
	+ Action interface{}
	+
	+ // Execute this function if the proper command cannot be found
	+ CommandNotFound CommandNotFoundFunc
	+ // Execute this function if an usage error occurs
	+ OnUsageError OnUsageErrorFunc
	+ // Compilation date
	+ Compiled time.Time
	+ // List of all authors who contributed
	+ Authors []Author
	+ // Copyright of the binary if any
	+ Copyright string
	+ // Name of Author (Note: Use App.Authors, this is deprecated)
	+ Author string
	+ // Email of Author (Note: Use App.Authors, this is deprecated)
	+ Email string
	+ // Writer writer to write output to
	+ Writer io.Writer
	+ // ErrWriter writes error output
	+ ErrWriter io.Writer
	+ // Other custom info
	+ Metadata map[string]interface{}
	+
	+ didSetup bool
	+}
	+
	+// Tries to find out when this binary was compiled.
	+// Returns the current time if it fails to find it.
	+func compileTime() time.Time {
	+ info, err := os.Stat(os.Args[0])
	+ if err != nil {
	+ return time.Now()
	+ }
	+ return info.ModTime()
	+}
	+
	+// NewApp creates a new cli Application with some reasonable defaults for Name,
	+// Usage, Version and Action.
	+func NewApp() *App {
	+ return &App{
	+ Name: filepath.Base(os.Args[0]),
	+ HelpName: filepath.Base(os.Args[0]),
	+ Usage: "A new cli application",
	+ UsageText: "",
	+ Version: "0.0.0",
	+ BashComplete: DefaultAppComplete,
	+ Action: helpCommand.Action,
	+ Compiled: compileTime(),
	+ Writer: os.Stdout,
	+ }
	+}
	+
	+// Setup runs initialization code to ensure all data structures are ready for
	+// `Run` or inspection prior to `Run`. It is internally called by `Run`, but
	+// will return early if setup has already happened.
	+func (a *App) Setup() {
	+ if a.didSetup {
	+ return
	+ }
	+
	+ a.didSetup = true
	+
	+ if a.Author != "" \|\| a.Email != "" {
	+ a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
	+ }
	+
	+ newCmds := []Command{}
	+ for _, c := range a.Commands {
	+ if c.HelpName == "" {
	+ c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
	+ }
	+ newCmds = append(newCmds, c)
	+ }
	+ a.Commands = newCmds
	+
	+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
	+ a.Commands = append(a.Commands, helpCommand)
	+ if (HelpFlag != BoolFlag{}) {
	+ a.appendFlag(HelpFlag)
	+ }
	+ }
	+
	+ if !a.HideVersion {
	+ a.appendFlag(VersionFlag)
	+ }
	+
	+ a.categories = CommandCategories{}
	+ for _, command := range a.Commands {
	+ a.categories = a.categories.AddCommand(command.Category, command)
	+ }
	+ sort.Sort(a.categories)
	+
	+ if a.Metadata == nil {
	+ a.Metadata = make(map[string]interface{})
	+ }
	+
	+ if a.Writer == nil {
	+ a.Writer = os.Stdout
	+ }
	+}
	+
	+// Run is the entry point to the cli app. Parses the arguments slice and routes
	+// to the proper flag/args combination
	+func (a *App) Run(arguments []string) (err error) {
	+ a.Setup()
	+
	+ // handle the completion flag separately from the flagset since
	+ // completion could be attempted after a flag, but before its value was put
	+ // on the command line. this causes the flagset to interpret the completion
	+ // flag name as the value of the flag before it which is undesirable
	+ // note that we can only do this because the shell autocomplete function
	+ // always appends the completion flag at the end of the command
	+ shellComplete, arguments := checkShellCompleteFlag(a, arguments)
	+
	+ // parse flags
	+ set, err := flagSet(a.Name, a.Flags)
	+ if err != nil {
	+ return err
	+ }
	+
	+ set.SetOutput(ioutil.Discard)
	+ err = set.Parse(arguments[1:])
	+ nerr := normalizeFlags(a.Flags, set)
	+ context := NewContext(a, set, nil)
	+ if nerr != nil {
	+ fmt.Fprintln(a.Writer, nerr)
	+ ShowAppHelp(context)
	+ return nerr
	+ }
	+ context.shellComplete = shellComplete
	+
	+ if checkCompletions(context) {
	+ return nil
	+ }
	+
	+ if err != nil {
	+ if a.OnUsageError != nil {
	+ err := a.OnUsageError(context, err, false)
	+ HandleExitCoder(err)
	+ return err
	+ }
	+ fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
	+ ShowAppHelp(context)
	+ return err
	+ }
	+
	+ if !a.HideHelp && checkHelp(context) {
	+ ShowAppHelp(context)
	+ return nil
	+ }
	+
	+ if !a.HideVersion && checkVersion(context) {
	+ ShowVersion(context)
	+ return nil
	+ }
	+
	+ if a.After != nil {
	+ defer func() {
	+ if afterErr := a.After(context); afterErr != nil {
	+ if err != nil {
	+ err = NewMultiError(err, afterErr)
	+ } else {
	+ err = afterErr
	+ }
	+ }
	+ }()
	+ }
	+
	+ if a.Before != nil {
	+ beforeErr := a.Before(context)
	+ if beforeErr != nil {
	+ fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
	+ ShowAppHelp(context)
	+ HandleExitCoder(beforeErr)
	+ err = beforeErr
	+ return err
	+ }
	+ }
	+
	+ args := context.Args()
	+ if args.Present() {
	+ name := args.First()
	+ c := a.Command(name)
	+ if c != nil {
	+ return c.Run(context)
	+ }
	+ }
	+
	+ if a.Action == nil {
	+ a.Action = helpCommand.Action
	+ }
	+
	+ // Run default Action
	+ err = HandleAction(a.Action, context)
	+
	+ HandleExitCoder(err)
	+ return err
	+}
	+
	+// RunAndExitOnError calls .Run() and exits non-zero if an error was returned
	+//
	+// Deprecated: instead you should return an error that fulfills cli.ExitCoder
	+// to cli.App.Run. This will cause the application to exit with the given eror
	+// code in the cli.ExitCoder
	+func (a *App) RunAndExitOnError() {
	+ if err := a.Run(os.Args); err != nil {
	+ fmt.Fprintln(a.errWriter(), err)
	+ OsExiter(1)
	+ }
	+}
	+
	+// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
	+// generate command-specific flags
	+func (a App) RunAsSubcommand(ctx Context) (err error) {
	+ // append help to commands
	+ if len(a.Commands) > 0 {
	+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
	+ a.Commands = append(a.Commands, helpCommand)
	+ if (HelpFlag != BoolFlag{}) {
	+ a.appendFlag(HelpFlag)
	+ }
	+ }
	+ }
	+
	+ newCmds := []Command{}
	+ for _, c := range a.Commands {
	+ if c.HelpName == "" {
	+ c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
	+ }
	+ newCmds = append(newCmds, c)
	+ }
	+ a.Commands = newCmds
	+
	+ // parse flags
	+ set, err := flagSet(a.Name, a.Flags)
	+ if err != nil {
	+ return err
	+ }
	+
	+ set.SetOutput(ioutil.Discard)
	+ err = set.Parse(ctx.Args().Tail())
	+ nerr := normalizeFlags(a.Flags, set)
	+ context := NewContext(a, set, ctx)
	+
	+ if nerr != nil {
	+ fmt.Fprintln(a.Writer, nerr)
	+ fmt.Fprintln(a.Writer)
	+ if len(a.Commands) > 0 {
	+ ShowSubcommandHelp(context)
	+ } else {
	+ ShowCommandHelp(ctx, context.Args().First())
	+ }
	+ return nerr
	+ }
	+
	+ if checkCompletions(context) {
	+ return nil
	+ }
	+
	+ if err != nil {
	+ if a.OnUsageError != nil {
	+ err = a.OnUsageError(context, err, true)
	+ HandleExitCoder(err)
	+ return err
	+ }
	+ fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
	+ ShowSubcommandHelp(context)
	+ return err
	+ }
	+
	+ if len(a.Commands) > 0 {
	+ if checkSubcommandHelp(context) {
	+ return nil
	+ }
	+ } else {
	+ if checkCommandHelp(ctx, context.Args().First()) {
	+ return nil
	+ }
	+ }
	+
	+ if a.After != nil {
	+ defer func() {
	+ afterErr := a.After(context)
	+ if afterErr != nil {
	+ HandleExitCoder(err)
	+ if err != nil {
	+ err = NewMultiError(err, afterErr)
	+ } else {
	+ err = afterErr
	+ }
	+ }
	+ }()
	+ }
	+
	+ if a.Before != nil {
	+ beforeErr := a.Before(context)
	+ if beforeErr != nil {
	+ HandleExitCoder(beforeErr)
	+ err = beforeErr
	+ return err
	+ }
	+ }
	+
	+ args := context.Args()
	+ if args.Present() {
	+ name := args.First()
	+ c := a.Command(name)
	+ if c != nil {
	+ return c.Run(context)
	+ }
	+ }
	+
	+ // Run default Action
	+ err = HandleAction(a.Action, context)
	+
	+ HandleExitCoder(err)
	+ return err
	+}
	+
	+// Command returns the named command on App. Returns nil if the command does not exist
	+func (a App) Command(name string) Command {
	+ for _, c := range a.Commands {
	+ if c.HasName(name) {
	+ return &c
	+ }
	+ }
	+
	+ return nil
	+}
	+
	+// Categories returns a slice containing all the categories with the commands they contain
	+func (a *App) Categories() CommandCategories {
	+ return a.categories
	+}
	+
	+// VisibleCategories returns a slice of categories and commands that are
	+// Hidden=false
	+func (a App) VisibleCategories() []CommandCategory {
	+ ret := []*CommandCategory{}
	+ for _, category := range a.categories {
	+ if visible := func() *CommandCategory {
	+ for _, command := range category.Commands {
	+ if !command.Hidden {
	+ return category
	+ }
	+ }
	+ return nil
	+ }(); visible != nil {
	+ ret = append(ret, visible)
	+ }
	+ }
	+ return ret
	+}
	+
	+// VisibleCommands returns a slice of the Commands with Hidden=false
	+func (a *App) VisibleCommands() []Command {
	+ ret := []Command{}
	+ for _, command := range a.Commands {
	+ if !command.Hidden {
	+ ret = append(ret, command)
	+ }
	+ }
	+ return ret
	+}
	+
	+// VisibleFlags returns a slice of the Flags with Hidden=false
	+func (a *App) VisibleFlags() []Flag {
	+ return visibleFlags(a.Flags)
	+}
	+
	+func (a *App) hasFlag(flag Flag) bool {
	+ for _, f := range a.Flags {
	+ if flag == f {
	+ return true
	+ }
	+ }
	+
	+ return false
	+}
	+
	+func (a *App) errWriter() io.Writer {
	+
	+ // When the app ErrWriter is nil use the package level one.
	+ if a.ErrWriter == nil {
	+ return ErrWriter
	+ }
	+
	+ return a.ErrWriter
	+}
	+
	+func (a *App) appendFlag(flag Flag) {
	+ if !a.hasFlag(flag) {
	+ a.Flags = append(a.Flags, flag)
	+ }
	+}
	+
	+// Author represents someone who has contributed to a cli project.
	+type Author struct {
	+ Name string // The Authors name
	+ Email string // The Authors email
	+}
	+
	+// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
	+func (a Author) String() string {
	+ e := ""
	+ if a.Email != "" {
	+ e = " <" + a.Email + ">"
	+ }
	+
	+ return fmt.Sprintf("%v%v", a.Name, e)
	+}
	+
	+// HandleAction attempts to figure out which Action signature was used. If
	+// it's an ActionFunc or a func with the legacy signature for Action, the func
	+// is run!
	+func HandleAction(action interface{}, context *Context) (err error) {
	+ if a, ok := action.(ActionFunc); ok {
	+ return a(context)
	+ } else if a, ok := action.(func(*Context) error); ok {
	+ return a(context)
	+ } else if a, ok := action.(func(*Context)); ok { // deprecated function signature
	+ a(context)
	+ return nil
	+ } else {
	+ return errInvalidActionType
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/app_test.go b/src/gopkg.in/urfave/cli.v1/app_test.go
	new file mode 100644
	index 0000000..10f1562
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/app_test.go
	@@ -0,0 +1,1685 @@
	+package cli
	+
	+import (
	+ "bytes"
	+ "errors"
	+ "flag"
	+ "fmt"
	+ "io"
	+ "io/ioutil"
	+ "os"
	+ "reflect"
	+ "strings"
	+ "testing"
	+)
	+
	+var (
	+ lastExitCode = 0
	+ fakeOsExiter = func(rc int) {
	+ lastExitCode = rc
	+ }
	+ fakeErrWriter = &bytes.Buffer{}
	+)
	+
	+func init() {
	+ OsExiter = fakeOsExiter
	+ ErrWriter = fakeErrWriter
	+}
	+
	+type opCounts struct {
	+ Total, BashComplete, OnUsageError, Before, CommandNotFound, Action, After, SubCommand int
	+}
	+
	+func ExampleApp_Run() {
	+ // set args for examples sake
	+ os.Args = []string{"greet", "--name", "Jeremy"}
	+
	+ app := NewApp()
	+ app.Name = "greet"
	+ app.Flags = []Flag{
	+ StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
	+ }
	+ app.Action = func(c *Context) error {
	+ fmt.Printf("Hello %v\n", c.String("name"))
	+ return nil
	+ }
	+ app.UsageText = "app [first_arg] [second_arg]"
	+ app.Author = "Harrison"
	+ app.Email = "harrison@lolwut.com"
	+ app.Authors = []Author{{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
	+ app.Run(os.Args)
	+ // Output:
	+ // Hello Jeremy
	+}
	+
	+func ExampleApp_Run_subcommand() {
	+ // set args for examples sake
	+ os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
	+ app := NewApp()
	+ app.Name = "say"
	+ app.Commands = []Command{
	+ {
	+ Name: "hello",
	+ Aliases: []string{"hi"},
	+ Usage: "use it to see a description",
	+ Description: "This is how we describe hello the function",
	+ Subcommands: []Command{
	+ {
	+ Name: "english",
	+ Aliases: []string{"en"},
	+ Usage: "sends a greeting in english",
	+ Description: "greets someone in english",
	+ Flags: []Flag{
	+ StringFlag{
	+ Name: "name",
	+ Value: "Bob",
	+ Usage: "Name of the person to greet",
	+ },
	+ },
	+ Action: func(c *Context) error {
	+ fmt.Println("Hello,", c.String("name"))
	+ return nil
	+ },
	+ },
	+ },
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+ // Output:
	+ // Hello, Jeremy
	+}
	+
	+func ExampleApp_Run_appHelp() {
	+ // set args for examples sake
	+ os.Args = []string{"greet", "help"}
	+
	+ app := NewApp()
	+ app.Name = "greet"
	+ app.Version = "0.1.0"
	+ app.Description = "This is how we describe greet the app"
	+ app.Authors = []Author{
	+ {Name: "Harrison", Email: "harrison@lolwut.com"},
	+ {Name: "Oliver Allen", Email: "oliver@toyshop.com"},
	+ }
	+ app.Flags = []Flag{
	+ StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
	+ }
	+ app.Commands = []Command{
	+ {
	+ Name: "describeit",
	+ Aliases: []string{"d"},
	+ Usage: "use it to see a description",
	+ Description: "This is how we describe describeit the function",
	+ Action: func(c *Context) error {
	+ fmt.Printf("i like to describe things")
	+ return nil
	+ },
	+ },
	+ }
	+ app.Run(os.Args)
	+ // Output:
	+ // NAME:
	+ // greet - A new cli application
	+ //
	+ // USAGE:
	+ // greet [global options] command [command options] [arguments...]
	+ //
	+ // VERSION:
	+ // 0.1.0
	+ //
	+ // DESCRIPTION:
	+ // This is how we describe greet the app
	+ //
	+ // AUTHORS:
	+ // Harrison <harrison@lolwut.com>
	+ // Oliver Allen <oliver@toyshop.com>
	+ //
	+ // COMMANDS:
	+ // describeit, d use it to see a description
	+ // help, h Shows a list of commands or help for one command
	+ //
	+ // GLOBAL OPTIONS:
	+ // --name value a name to say (default: "bob")
	+ // --help, -h show help
	+ // --version, -v print the version
	+}
	+
	+func ExampleApp_Run_commandHelp() {
	+ // set args for examples sake
	+ os.Args = []string{"greet", "h", "describeit"}
	+
	+ app := NewApp()
	+ app.Name = "greet"
	+ app.Flags = []Flag{
	+ StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
	+ }
	+ app.Commands = []Command{
	+ {
	+ Name: "describeit",
	+ Aliases: []string{"d"},
	+ Usage: "use it to see a description",
	+ Description: "This is how we describe describeit the function",
	+ Action: func(c *Context) error {
	+ fmt.Printf("i like to describe things")
	+ return nil
	+ },
	+ },
	+ }
	+ app.Run(os.Args)
	+ // Output:
	+ // NAME:
	+ // greet describeit - use it to see a description
	+ //
	+ // USAGE:
	+ // greet describeit [arguments...]
	+ //
	+ // DESCRIPTION:
	+ // This is how we describe describeit the function
	+}
	+
	+func ExampleApp_Run_noAction() {
	+ app := App{}
	+ app.Name = "greet"
	+ app.Run([]string{"greet"})
	+ // Output:
	+ // NAME:
	+ // greet
	+ //
	+ // USAGE:
	+ // [global options] command [command options] [arguments...]
	+ //
	+ // COMMANDS:
	+ // help, h Shows a list of commands or help for one command
	+ //
	+ // GLOBAL OPTIONS:
	+ // --help, -h show help
	+ // --version, -v print the version
	+}
	+
	+func ExampleApp_Run_subcommandNoAction() {
	+ app := App{}
	+ app.Name = "greet"
	+ app.Commands = []Command{
	+ {
	+ Name: "describeit",
	+ Aliases: []string{"d"},
	+ Usage: "use it to see a description",
	+ Description: "This is how we describe describeit the function",
	+ },
	+ }
	+ app.Run([]string{"greet", "describeit"})
	+ // Output:
	+ // NAME:
	+ // describeit - use it to see a description
	+ //
	+ // USAGE:
	+ // describeit [arguments...]
	+ //
	+ // DESCRIPTION:
	+ // This is how we describe describeit the function
	+
	+}
	+
	+func ExampleApp_Run_bashComplete() {
	+ // set args for examples sake
	+ os.Args = []string{"greet", "--generate-bash-completion"}
	+
	+ app := NewApp()
	+ app.Name = "greet"
	+ app.EnableBashCompletion = true
	+ app.Commands = []Command{
	+ {
	+ Name: "describeit",
	+ Aliases: []string{"d"},
	+ Usage: "use it to see a description",
	+ Description: "This is how we describe describeit the function",
	+ Action: func(c *Context) error {
	+ fmt.Printf("i like to describe things")
	+ return nil
	+ },
	+ }, {
	+ Name: "next",
	+ Usage: "next example",
	+ Description: "more stuff to see when generating bash completion",
	+ Action: func(c *Context) error {
	+ fmt.Printf("the next example")
	+ return nil
	+ },
	+ },
	+ }
	+
	+ app.Run(os.Args)
	+ // Output:
	+ // describeit
	+ // d
	+ // next
	+ // help
	+ // h
	+}
	+
	+func TestApp_Run(t *testing.T) {
	+ s := ""
	+
	+ app := NewApp()
	+ app.Action = func(c *Context) error {
	+ s = s + c.Args().First()
	+ return nil
	+ }
	+
	+ err := app.Run([]string{"command", "foo"})
	+ expect(t, err, nil)
	+ err = app.Run([]string{"command", "bar"})
	+ expect(t, err, nil)
	+ expect(t, s, "foobar")
	+}
	+
	+var commandAppTests = []struct {
	+ name string
	+ expected bool
	+}{
	+ {"foobar", true},
	+ {"batbaz", true},
	+ {"b", true},
	+ {"f", true},
	+ {"bat", false},
	+ {"nothing", false},
	+}
	+
	+func TestApp_Command(t *testing.T) {
	+ app := NewApp()
	+ fooCommand := Command{Name: "foobar", Aliases: []string{"f"}}
	+ batCommand := Command{Name: "batbaz", Aliases: []string{"b"}}
	+ app.Commands = []Command{
	+ fooCommand,
	+ batCommand,
	+ }
	+
	+ for _, test := range commandAppTests {
	+ expect(t, app.Command(test.name) != nil, test.expected)
	+ }
	+}
	+
	+func TestApp_Setup_defaultsWriter(t *testing.T) {
	+ app := &App{}
	+ app.Setup()
	+ expect(t, app.Writer, os.Stdout)
	+}
	+
	+func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
	+ var parsedOption, firstArg string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Flags: []Flag{
	+ StringFlag{Name: "option", Value: "", Usage: "some option"},
	+ },
	+ Action: func(c *Context) error {
	+ parsedOption = c.String("option")
	+ firstArg = c.Args().First()
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
	+
	+ expect(t, parsedOption, "my-option")
	+ expect(t, firstArg, "my-arg")
	+}
	+
	+func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
	+ var context *Context
	+
	+ a := NewApp()
	+ a.Commands = []Command{
	+ {
	+ Name: "foo",
	+ Action: func(c *Context) error {
	+ context = c
	+ return nil
	+ },
	+ Flags: []Flag{
	+ StringFlag{
	+ Name: "lang",
	+ Value: "english",
	+ Usage: "language for the greeting",
	+ },
	+ },
	+ Before: func(_ *Context) error { return nil },
	+ },
	+ }
	+ a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
	+
	+ expect(t, context.Args().Get(0), "abcd")
	+ expect(t, context.String("lang"), "spanish")
	+}
	+
	+func TestApp_RunAsSubCommandIncorrectUsage(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ StringFlag{Name: "--foo"},
	+ },
	+ Writer: bytes.NewBufferString(""),
	+ }
	+
	+ set := flag.NewFlagSet("", flag.ContinueOnError)
	+ set.Parse([]string{"", "---foo"})
	+ c := &Context{flagSet: set}
	+
	+ err := a.RunAsSubcommand(c)
	+
	+ expect(t, err, errors.New("bad flag syntax: ---foo"))
	+}
	+
	+func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
	+ var parsedOption string
	+ var args []string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Flags: []Flag{
	+ StringFlag{Name: "option", Value: "", Usage: "some option"},
	+ },
	+ Action: func(c *Context) error {
	+ parsedOption = c.String("option")
	+ args = c.Args()
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
	+
	+ expect(t, parsedOption, "my-option")
	+ expect(t, args[0], "my-arg")
	+ expect(t, args[1], "--")
	+ expect(t, args[2], "--notARealFlag")
	+}
	+
	+func TestApp_CommandWithDash(t *testing.T) {
	+ var args []string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Action: func(c *Context) error {
	+ args = c.Args()
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "-"})
	+
	+ expect(t, args[0], "my-arg")
	+ expect(t, args[1], "-")
	+}
	+
	+func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
	+ var args []string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Action: func(c *Context) error {
	+ args = c.Args()
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
	+
	+ expect(t, args[0], "my-arg")
	+ expect(t, args[1], "--")
	+ expect(t, args[2], "notAFlagAtAll")
	+}
	+
	+func TestApp_VisibleCommands(t *testing.T) {
	+ app := NewApp()
	+ app.Commands = []Command{
	+ {
	+ Name: "frob",
	+ HelpName: "foo frob",
	+ Action: func(_ *Context) error { return nil },
	+ },
	+ {
	+ Name: "frib",
	+ HelpName: "foo frib",
	+ Hidden: true,
	+ Action: func(_ *Context) error { return nil },
	+ },
	+ }
	+
	+ app.Setup()
	+ expected := []Command{
	+ app.Commands[0],
	+ app.Commands[2], // help
	+ }
	+ actual := app.VisibleCommands()
	+ expect(t, len(expected), len(actual))
	+ for i, actualCommand := range actual {
	+ expectedCommand := expected[i]
	+
	+ if expectedCommand.Action != nil {
	+ // comparing func addresses is OK!
	+ expect(t, fmt.Sprintf("%p", expectedCommand.Action), fmt.Sprintf("%p", actualCommand.Action))
	+ }
	+
	+ // nil out funcs, as they cannot be compared
	+ // (https://github.com/golang/go/issues/8554)
	+ expectedCommand.Action = nil
	+ actualCommand.Action = nil
	+
	+ if !reflect.DeepEqual(expectedCommand, actualCommand) {
	+ t.Errorf("expected\n%#v\n!=\n%#v", expectedCommand, actualCommand)
	+ }
	+ }
	+}
	+
	+func TestApp_Float64Flag(t *testing.T) {
	+ var meters float64
	+
	+ app := NewApp()
	+ app.Flags = []Flag{
	+ Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
	+ }
	+ app.Action = func(c *Context) error {
	+ meters = c.Float64("height")
	+ return nil
	+ }
	+
	+ app.Run([]string{"", "--height", "1.93"})
	+ expect(t, meters, 1.93)
	+}
	+
	+func TestApp_ParseSliceFlags(t *testing.T) {
	+ var parsedOption, firstArg string
	+ var parsedIntSlice []int
	+ var parsedStringSlice []string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Flags: []Flag{
	+ IntSliceFlag{Name: "p", Value: &IntSlice{}, Usage: "set one or more ip addr"},
	+ StringSliceFlag{Name: "ip", Value: &StringSlice{}, Usage: "set one or more ports to open"},
	+ },
	+ Action: func(c *Context) error {
	+ parsedIntSlice = c.IntSlice("p")
	+ parsedStringSlice = c.StringSlice("ip")
	+ parsedOption = c.String("option")
	+ firstArg = c.Args().First()
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
	+
	+ IntsEquals := func(a, b []int) bool {
	+ if len(a) != len(b) {
	+ return false
	+ }
	+ for i, v := range a {
	+ if v != b[i] {
	+ return false
	+ }
	+ }
	+ return true
	+ }
	+
	+ StrsEquals := func(a, b []string) bool {
	+ if len(a) != len(b) {
	+ return false
	+ }
	+ for i, v := range a {
	+ if v != b[i] {
	+ return false
	+ }
	+ }
	+ return true
	+ }
	+ var expectedIntSlice = []int{22, 80}
	+ var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
	+
	+ if !IntsEquals(parsedIntSlice, expectedIntSlice) {
	+ t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
	+ }
	+
	+ if !StrsEquals(parsedStringSlice, expectedStringSlice) {
	+ t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
	+ }
	+}
	+
	+func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
	+ var parsedIntSlice []int
	+ var parsedStringSlice []string
	+
	+ app := NewApp()
	+ command := Command{
	+ Name: "cmd",
	+ Flags: []Flag{
	+ IntSliceFlag{Name: "a", Usage: "set numbers"},
	+ StringSliceFlag{Name: "str", Usage: "set strings"},
	+ },
	+ Action: func(c *Context) error {
	+ parsedIntSlice = c.IntSlice("a")
	+ parsedStringSlice = c.StringSlice("str")
	+ return nil
	+ },
	+ }
	+ app.Commands = []Command{command}
	+
	+ app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
	+
	+ var expectedIntSlice = []int{2}
	+ var expectedStringSlice = []string{"A"}
	+
	+ if parsedIntSlice[0] != expectedIntSlice[0] {
	+ t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
	+ }
	+
	+ if parsedStringSlice[0] != expectedStringSlice[0] {
	+ t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
	+ }
	+}
	+
	+func TestApp_DefaultStdout(t *testing.T) {
	+ app := NewApp()
	+
	+ if app.Writer != os.Stdout {
	+ t.Error("Default output writer not set.")
	+ }
	+}
	+
	+type mockWriter struct {
	+ written []byte
	+}
	+
	+func (fw *mockWriter) Write(p []byte) (n int, err error) {
	+ if fw.written == nil {
	+ fw.written = p
	+ } else {
	+ fw.written = append(fw.written, p...)
	+ }
	+
	+ return len(p), nil
	+}
	+
	+func (fw *mockWriter) GetWritten() (b []byte) {
	+ return fw.written
	+}
	+
	+func TestApp_SetStdout(t *testing.T) {
	+ w := &mockWriter{}
	+
	+ app := NewApp()
	+ app.Name = "test"
	+ app.Writer = w
	+
	+ err := app.Run([]string{"help"})
	+
	+ if err != nil {
	+ t.Fatalf("Run error: %s", err)
	+ }
	+
	+ if len(w.written) == 0 {
	+ t.Error("App did not write output to desired writer.")
	+ }
	+}
	+
	+func TestApp_BeforeFunc(t *testing.T) {
	+ counts := &opCounts{}
	+ beforeError := fmt.Errorf("fail")
	+ var err error
	+
	+ app := NewApp()
	+
	+ app.Before = func(c *Context) error {
	+ counts.Total++
	+ counts.Before = counts.Total
	+ s := c.String("opt")
	+ if s == "fail" {
	+ return beforeError
	+ }
	+
	+ return nil
	+ }
	+
	+ app.Commands = []Command{
	+ {
	+ Name: "sub",
	+ Action: func(c *Context) error {
	+ counts.Total++
	+ counts.SubCommand = counts.Total
	+ return nil
	+ },
	+ },
	+ }
	+
	+ app.Flags = []Flag{
	+ StringFlag{Name: "opt"},
	+ }
	+
	+ // run with the Before() func succeeding
	+ err = app.Run([]string{"command", "--opt", "succeed", "sub"})
	+
	+ if err != nil {
	+ t.Fatalf("Run error: %s", err)
	+ }
	+
	+ if counts.Before != 1 {
	+ t.Errorf("Before() not executed when expected")
	+ }
	+
	+ if counts.SubCommand != 2 {
	+ t.Errorf("Subcommand not executed when expected")
	+ }
	+
	+ // reset
	+ counts = &opCounts{}
	+
	+ // run with the Before() func failing
	+ err = app.Run([]string{"command", "--opt", "fail", "sub"})
	+
	+ // should be the same error produced by the Before func
	+ if err != beforeError {
	+ t.Errorf("Run error expected, but not received")
	+ }
	+
	+ if counts.Before != 1 {
	+ t.Errorf("Before() not executed when expected")
	+ }
	+
	+ if counts.SubCommand != 0 {
	+ t.Errorf("Subcommand executed when NOT expected")
	+ }
	+
	+ // reset
	+ counts = &opCounts{}
	+
	+ afterError := errors.New("fail again")
	+ app.After = func(_ *Context) error {
	+ return afterError
	+ }
	+
	+ // run with the Before() func failing, wrapped by After()
	+ err = app.Run([]string{"command", "--opt", "fail", "sub"})
	+
	+ // should be the same error produced by the Before func
	+ if _, ok := err.(MultiError); !ok {
	+ t.Errorf("MultiError expected, but not received")
	+ }
	+
	+ if counts.Before != 1 {
	+ t.Errorf("Before() not executed when expected")
	+ }
	+
	+ if counts.SubCommand != 0 {
	+ t.Errorf("Subcommand executed when NOT expected")
	+ }
	+}
	+
	+func TestApp_AfterFunc(t *testing.T) {
	+ counts := &opCounts{}
	+ afterError := fmt.Errorf("fail")
	+ var err error
	+
	+ app := NewApp()
	+
	+ app.After = func(c *Context) error {
	+ counts.Total++
	+ counts.After = counts.Total
	+ s := c.String("opt")
	+ if s == "fail" {
	+ return afterError
	+ }
	+
	+ return nil
	+ }
	+
	+ app.Commands = []Command{
	+ {
	+ Name: "sub",
	+ Action: func(c *Context) error {
	+ counts.Total++
	+ counts.SubCommand = counts.Total
	+ return nil
	+ },
	+ },
	+ }
	+
	+ app.Flags = []Flag{
	+ StringFlag{Name: "opt"},
	+ }
	+
	+ // run with the After() func succeeding
	+ err = app.Run([]string{"command", "--opt", "succeed", "sub"})
	+
	+ if err != nil {
	+ t.Fatalf("Run error: %s", err)
	+ }
	+
	+ if counts.After != 2 {
	+ t.Errorf("After() not executed when expected")
	+ }
	+
	+ if counts.SubCommand != 1 {
	+ t.Errorf("Subcommand not executed when expected")
	+ }
	+
	+ // reset
	+ counts = &opCounts{}
	+
	+ // run with the Before() func failing
	+ err = app.Run([]string{"command", "--opt", "fail", "sub"})
	+
	+ // should be the same error produced by the Before func
	+ if err != afterError {
	+ t.Errorf("Run error expected, but not received")
	+ }
	+
	+ if counts.After != 2 {
	+ t.Errorf("After() not executed when expected")
	+ }
	+
	+ if counts.SubCommand != 1 {
	+ t.Errorf("Subcommand not executed when expected")
	+ }
	+}
	+
	+func TestAppNoHelpFlag(t *testing.T) {
	+ oldFlag := HelpFlag
	+ defer func() {
	+ HelpFlag = oldFlag
	+ }()
	+
	+ HelpFlag = BoolFlag{}
	+
	+ app := NewApp()
	+ app.Writer = ioutil.Discard
	+ err := app.Run([]string{"test", "-h"})
	+
	+ if err != flag.ErrHelp {
	+ t.Errorf("expected error about missing help flag, but got: %s (%T)", err, err)
	+ }
	+}
	+
	+func TestAppHelpPrinter(t *testing.T) {
	+ oldPrinter := HelpPrinter
	+ defer func() {
	+ HelpPrinter = oldPrinter
	+ }()
	+
	+ var wasCalled = false
	+ HelpPrinter = func(w io.Writer, template string, data interface{}) {
	+ wasCalled = true
	+ }
	+
	+ app := NewApp()
	+ app.Run([]string{"-h"})
	+
	+ if wasCalled == false {
	+ t.Errorf("Help printer expected to be called, but was not")
	+ }
	+}
	+
	+func TestApp_VersionPrinter(t *testing.T) {
	+ oldPrinter := VersionPrinter
	+ defer func() {
	+ VersionPrinter = oldPrinter
	+ }()
	+
	+ var wasCalled = false
	+ VersionPrinter = func(c *Context) {
	+ wasCalled = true
	+ }
	+
	+ app := NewApp()
	+ ctx := NewContext(app, nil, nil)
	+ ShowVersion(ctx)
	+
	+ if wasCalled == false {
	+ t.Errorf("Version printer expected to be called, but was not")
	+ }
	+}
	+
	+func TestApp_CommandNotFound(t *testing.T) {
	+ counts := &opCounts{}
	+ app := NewApp()
	+
	+ app.CommandNotFound = func(c *Context, command string) {
	+ counts.Total++
	+ counts.CommandNotFound = counts.Total
	+ }
	+
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ Action: func(c *Context) error {
	+ counts.Total++
	+ counts.SubCommand = counts.Total
	+ return nil
	+ },
	+ },
	+ }
	+
	+ app.Run([]string{"command", "foo"})
	+
	+ expect(t, counts.CommandNotFound, 1)
	+ expect(t, counts.SubCommand, 0)
	+ expect(t, counts.Total, 1)
	+}
	+
	+func TestApp_OrderOfOperations(t *testing.T) {
	+ counts := &opCounts{}
	+
	+ resetCounts := func() { counts = &opCounts{} }
	+
	+ app := NewApp()
	+ app.EnableBashCompletion = true
	+ app.BashComplete = func(c *Context) {
	+ counts.Total++
	+ counts.BashComplete = counts.Total
	+ }
	+
	+ app.OnUsageError = func(c *Context, err error, isSubcommand bool) error {
	+ counts.Total++
	+ counts.OnUsageError = counts.Total
	+ return errors.New("hay OnUsageError")
	+ }
	+
	+ beforeNoError := func(c *Context) error {
	+ counts.Total++
	+ counts.Before = counts.Total
	+ return nil
	+ }
	+
	+ beforeError := func(c *Context) error {
	+ counts.Total++
	+ counts.Before = counts.Total
	+ return errors.New("hay Before")
	+ }
	+
	+ app.Before = beforeNoError
	+ app.CommandNotFound = func(c *Context, command string) {
	+ counts.Total++
	+ counts.CommandNotFound = counts.Total
	+ }
	+
	+ afterNoError := func(c *Context) error {
	+ counts.Total++
	+ counts.After = counts.Total
	+ return nil
	+ }
	+
	+ afterError := func(c *Context) error {
	+ counts.Total++
	+ counts.After = counts.Total
	+ return errors.New("hay After")
	+ }
	+
	+ app.After = afterNoError
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ Action: func(c *Context) error {
	+ counts.Total++
	+ counts.SubCommand = counts.Total
	+ return nil
	+ },
	+ },
	+ }
	+
	+ app.Action = func(c *Context) error {
	+ counts.Total++
	+ counts.Action = counts.Total
	+ return nil
	+ }
	+
	+ _ = app.Run([]string{"command", "--nope"})
	+ expect(t, counts.OnUsageError, 1)
	+ expect(t, counts.Total, 1)
	+
	+ resetCounts()
	+
	+ _ = app.Run([]string{"command", "--generate-bash-completion"})
	+ expect(t, counts.BashComplete, 1)
	+ expect(t, counts.Total, 1)
	+
	+ resetCounts()
	+
	+ oldOnUsageError := app.OnUsageError
	+ app.OnUsageError = nil
	+ _ = app.Run([]string{"command", "--nope"})
	+ expect(t, counts.Total, 0)
	+ app.OnUsageError = oldOnUsageError
	+
	+ resetCounts()
	+
	+ _ = app.Run([]string{"command", "foo"})
	+ expect(t, counts.OnUsageError, 0)
	+ expect(t, counts.Before, 1)
	+ expect(t, counts.CommandNotFound, 0)
	+ expect(t, counts.Action, 2)
	+ expect(t, counts.After, 3)
	+ expect(t, counts.Total, 3)
	+
	+ resetCounts()
	+
	+ app.Before = beforeError
	+ _ = app.Run([]string{"command", "bar"})
	+ expect(t, counts.OnUsageError, 0)
	+ expect(t, counts.Before, 1)
	+ expect(t, counts.After, 2)
	+ expect(t, counts.Total, 2)
	+ app.Before = beforeNoError
	+
	+ resetCounts()
	+
	+ app.After = nil
	+ _ = app.Run([]string{"command", "bar"})
	+ expect(t, counts.OnUsageError, 0)
	+ expect(t, counts.Before, 1)
	+ expect(t, counts.SubCommand, 2)
	+ expect(t, counts.Total, 2)
	+ app.After = afterNoError
	+
	+ resetCounts()
	+
	+ app.After = afterError
	+ err := app.Run([]string{"command", "bar"})
	+ if err == nil {
	+ t.Fatalf("expected a non-nil error")
	+ }
	+ expect(t, counts.OnUsageError, 0)
	+ expect(t, counts.Before, 1)
	+ expect(t, counts.SubCommand, 2)
	+ expect(t, counts.After, 3)
	+ expect(t, counts.Total, 3)
	+ app.After = afterNoError
	+
	+ resetCounts()
	+
	+ oldCommands := app.Commands
	+ app.Commands = nil
	+ _ = app.Run([]string{"command"})
	+ expect(t, counts.OnUsageError, 0)
	+ expect(t, counts.Before, 1)
	+ expect(t, counts.Action, 2)
	+ expect(t, counts.After, 3)
	+ expect(t, counts.Total, 3)
	+ app.Commands = oldCommands
	+}
	+
	+func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
	+ var subcommandHelpTopics = [][]string{
	+ {"command", "foo", "--help"},
	+ {"command", "foo", "-h"},
	+ {"command", "foo", "help"},
	+ }
	+
	+ for _, flagSet := range subcommandHelpTopics {
	+ t.Logf("==> checking with flags %v", flagSet)
	+
	+ app := NewApp()
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+
	+ subCmdBar := Command{
	+ Name: "bar",
	+ Usage: "does bar things",
	+ }
	+ subCmdBaz := Command{
	+ Name: "baz",
	+ Usage: "does baz things",
	+ }
	+ cmd := Command{
	+ Name: "foo",
	+ Description: "descriptive wall of text about how it does foo things",
	+ Subcommands: []Command{subCmdBar, subCmdBaz},
	+ Action: func(c *Context) error { return nil },
	+ }
	+
	+ app.Commands = []Command{cmd}
	+ err := app.Run(flagSet)
	+
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ t.Logf("output: %q\n", buf.Bytes())
	+
	+ if strings.Contains(output, "No help topic for") {
	+ t.Errorf("expect a help topic, got none: \n%q", output)
	+ }
	+
	+ for _, shouldContain := range []string{
	+ cmd.Name, cmd.Description,
	+ subCmdBar.Name, subCmdBar.Usage,
	+ subCmdBaz.Name, subCmdBaz.Usage,
	+ } {
	+ if !strings.Contains(output, shouldContain) {
	+ t.Errorf("want help to contain %q, did not: \n%q", shouldContain, output)
	+ }
	+ }
	+ }
	+}
	+
	+func TestApp_Run_SubcommandFullPath(t *testing.T) {
	+ app := NewApp()
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+ app.Name = "command"
	+ subCmd := Command{
	+ Name: "bar",
	+ Usage: "does bar things",
	+ }
	+ cmd := Command{
	+ Name: "foo",
	+ Description: "foo commands",
	+ Subcommands: []Command{subCmd},
	+ }
	+ app.Commands = []Command{cmd}
	+
	+ err := app.Run([]string{"command", "foo", "bar", "--help"})
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ if !strings.Contains(output, "command foo bar - does bar things") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+ if !strings.Contains(output, "command foo bar [arguments...]") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+}
	+
	+func TestApp_Run_SubcommandHelpName(t *testing.T) {
	+ app := NewApp()
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+ app.Name = "command"
	+ subCmd := Command{
	+ Name: "bar",
	+ HelpName: "custom",
	+ Usage: "does bar things",
	+ }
	+ cmd := Command{
	+ Name: "foo",
	+ Description: "foo commands",
	+ Subcommands: []Command{subCmd},
	+ }
	+ app.Commands = []Command{cmd}
	+
	+ err := app.Run([]string{"command", "foo", "bar", "--help"})
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ if !strings.Contains(output, "custom - does bar things") {
	+ t.Errorf("expected HelpName for subcommand: %s", output)
	+ }
	+ if !strings.Contains(output, "custom [arguments...]") {
	+ t.Errorf("expected HelpName to subcommand: %s", output)
	+ }
	+}
	+
	+func TestApp_Run_CommandHelpName(t *testing.T) {
	+ app := NewApp()
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+ app.Name = "command"
	+ subCmd := Command{
	+ Name: "bar",
	+ Usage: "does bar things",
	+ }
	+ cmd := Command{
	+ Name: "foo",
	+ HelpName: "custom",
	+ Description: "foo commands",
	+ Subcommands: []Command{subCmd},
	+ }
	+ app.Commands = []Command{cmd}
	+
	+ err := app.Run([]string{"command", "foo", "bar", "--help"})
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ if !strings.Contains(output, "command foo bar - does bar things") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+ if !strings.Contains(output, "command foo bar [arguments...]") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+}
	+
	+func TestApp_Run_CommandSubcommandHelpName(t *testing.T) {
	+ app := NewApp()
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+ app.Name = "base"
	+ subCmd := Command{
	+ Name: "bar",
	+ HelpName: "custom",
	+ Usage: "does bar things",
	+ }
	+ cmd := Command{
	+ Name: "foo",
	+ Description: "foo commands",
	+ Subcommands: []Command{subCmd},
	+ }
	+ app.Commands = []Command{cmd}
	+
	+ err := app.Run([]string{"command", "foo", "--help"})
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ if !strings.Contains(output, "base foo - foo commands") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+ if !strings.Contains(output, "base foo command [command options] [arguments...]") {
	+ t.Errorf("expected full path to subcommand: %s", output)
	+ }
	+}
	+
	+func TestApp_Run_Help(t *testing.T) {
	+ var helpArguments = [][]string{{"boom", "--help"}, {"boom", "-h"}, {"boom", "help"}}
	+
	+ for _, args := range helpArguments {
	+ buf := new(bytes.Buffer)
	+
	+ t.Logf("==> checking with arguments %v", args)
	+
	+ app := NewApp()
	+ app.Name = "boom"
	+ app.Usage = "make an explosive entrance"
	+ app.Writer = buf
	+ app.Action = func(c *Context) error {
	+ buf.WriteString("boom I say!")
	+ return nil
	+ }
	+
	+ err := app.Run(args)
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ t.Logf("output: %q\n", buf.Bytes())
	+
	+ if !strings.Contains(output, "boom - make an explosive entrance") {
	+ t.Errorf("want help to contain %q, did not: \n%q", "boom - make an explosive entrance", output)
	+ }
	+ }
	+}
	+
	+func TestApp_Run_Version(t *testing.T) {
	+ var versionArguments = [][]string{{"boom", "--version"}, {"boom", "-v"}}
	+
	+ for _, args := range versionArguments {
	+ buf := new(bytes.Buffer)
	+
	+ t.Logf("==> checking with arguments %v", args)
	+
	+ app := NewApp()
	+ app.Name = "boom"
	+ app.Usage = "make an explosive entrance"
	+ app.Version = "0.1.0"
	+ app.Writer = buf
	+ app.Action = func(c *Context) error {
	+ buf.WriteString("boom I say!")
	+ return nil
	+ }
	+
	+ err := app.Run(args)
	+ if err != nil {
	+ t.Error(err)
	+ }
	+
	+ output := buf.String()
	+ t.Logf("output: %q\n", buf.Bytes())
	+
	+ if !strings.Contains(output, "0.1.0") {
	+ t.Errorf("want version to contain %q, did not: \n%q", "0.1.0", output)
	+ }
	+ }
	+}
	+
	+func TestApp_Run_Categories(t *testing.T) {
	+ app := NewApp()
	+ app.Name = "categories"
	+ app.HideHelp = true
	+ app.Commands = []Command{
	+ {
	+ Name: "command1",
	+ Category: "1",
	+ },
	+ {
	+ Name: "command2",
	+ Category: "1",
	+ },
	+ {
	+ Name: "command3",
	+ Category: "2",
	+ },
	+ }
	+ buf := new(bytes.Buffer)
	+ app.Writer = buf
	+
	+ app.Run([]string{"categories"})
	+
	+ expect := CommandCategories{
	+ &CommandCategory{
	+ Name: "1",
	+ Commands: []Command{
	+ app.Commands[0],
	+ app.Commands[1],
	+ },
	+ },
	+ &CommandCategory{
	+ Name: "2",
	+ Commands: []Command{
	+ app.Commands[2],
	+ },
	+ },
	+ }
	+ if !reflect.DeepEqual(app.Categories(), expect) {
	+ t.Fatalf("expected categories %#v, to equal %#v", app.Categories(), expect)
	+ }
	+
	+ output := buf.String()
	+ t.Logf("output: %q\n", buf.Bytes())
	+
	+ if !strings.Contains(output, "1:\n command1") {
	+ t.Errorf("want buffer to include category %q, did not: \n%q", "1:\n command1", output)
	+ }
	+}
	+
	+func TestApp_VisibleCategories(t *testing.T) {
	+ app := NewApp()
	+ app.Name = "visible-categories"
	+ app.HideHelp = true
	+ app.Commands = []Command{
	+ {
	+ Name: "command1",
	+ Category: "1",
	+ HelpName: "foo command1",
	+ Hidden: true,
	+ },
	+ {
	+ Name: "command2",
	+ Category: "2",
	+ HelpName: "foo command2",
	+ },
	+ {
	+ Name: "command3",
	+ Category: "3",
	+ HelpName: "foo command3",
	+ },
	+ }
	+
	+ expected := []*CommandCategory{
	+ {
	+ Name: "2",
	+ Commands: []Command{
	+ app.Commands[1],
	+ },
	+ },
	+ {
	+ Name: "3",
	+ Commands: []Command{
	+ app.Commands[2],
	+ },
	+ },
	+ }
	+
	+ app.Setup()
	+ expect(t, expected, app.VisibleCategories())
	+
	+ app = NewApp()
	+ app.Name = "visible-categories"
	+ app.HideHelp = true
	+ app.Commands = []Command{
	+ {
	+ Name: "command1",
	+ Category: "1",
	+ HelpName: "foo command1",
	+ Hidden: true,
	+ },
	+ {
	+ Name: "command2",
	+ Category: "2",
	+ HelpName: "foo command2",
	+ Hidden: true,
	+ },
	+ {
	+ Name: "command3",
	+ Category: "3",
	+ HelpName: "foo command3",
	+ },
	+ }
	+
	+ expected = []*CommandCategory{
	+ {
	+ Name: "3",
	+ Commands: []Command{
	+ app.Commands[2],
	+ },
	+ },
	+ }
	+
	+ app.Setup()
	+ expect(t, expected, app.VisibleCategories())
	+
	+ app = NewApp()
	+ app.Name = "visible-categories"
	+ app.HideHelp = true
	+ app.Commands = []Command{
	+ {
	+ Name: "command1",
	+ Category: "1",
	+ HelpName: "foo command1",
	+ Hidden: true,
	+ },
	+ {
	+ Name: "command2",
	+ Category: "2",
	+ HelpName: "foo command2",
	+ Hidden: true,
	+ },
	+ {
	+ Name: "command3",
	+ Category: "3",
	+ HelpName: "foo command3",
	+ Hidden: true,
	+ },
	+ }
	+
	+ expected = []*CommandCategory{}
	+
	+ app.Setup()
	+ expect(t, expected, app.VisibleCategories())
	+}
	+
	+func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
	+ app := NewApp()
	+ app.Action = func(c *Context) error { return nil }
	+ app.Before = func(c *Context) error { return fmt.Errorf("before error") }
	+ app.After = func(c *Context) error { return fmt.Errorf("after error") }
	+
	+ err := app.Run([]string{"foo"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.Contains(err.Error(), "before error") {
	+ t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
	+ }
	+ if !strings.Contains(err.Error(), "after error") {
	+ t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
	+ }
	+}
	+
	+func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
	+ app := NewApp()
	+ app.Commands = []Command{
	+ {
	+ Subcommands: []Command{
	+ {
	+ Name: "sub",
	+ },
	+ },
	+ Name: "bar",
	+ Before: func(c *Context) error { return fmt.Errorf("before error") },
	+ After: func(c *Context) error { return fmt.Errorf("after error") },
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "bar"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.Contains(err.Error(), "before error") {
	+ t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
	+ }
	+ if !strings.Contains(err.Error(), "after error") {
	+ t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
	+ }
	+}
	+
	+func TestApp_OnUsageError_WithWrongFlagValue(t *testing.T) {
	+ app := NewApp()
	+ app.Flags = []Flag{
	+ IntFlag{Name: "flag"},
	+ }
	+ app.OnUsageError = func(c *Context, err error, isSubcommand bool) error {
	+ if isSubcommand {
	+ t.Errorf("Expect no subcommand")
	+ }
	+ if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
	+ t.Errorf("Expect an invalid value error, but got \"%v\"", err)
	+ }
	+ return errors.New("intercepted: " + err.Error())
	+ }
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "--flag=wrong"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
	+ t.Errorf("Expect an intercepted error, but got \"%v\"", err)
	+ }
	+}
	+
	+func TestApp_OnUsageError_WithWrongFlagValue_ForSubcommand(t *testing.T) {
	+ app := NewApp()
	+ app.Flags = []Flag{
	+ IntFlag{Name: "flag"},
	+ }
	+ app.OnUsageError = func(c *Context, err error, isSubcommand bool) error {
	+ if isSubcommand {
	+ t.Errorf("Expect subcommand")
	+ }
	+ if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
	+ t.Errorf("Expect an invalid value error, but got \"%v\"", err)
	+ }
	+ return errors.New("intercepted: " + err.Error())
	+ }
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "--flag=wrong", "bar"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
	+ t.Errorf("Expect an intercepted error, but got \"%v\"", err)
	+ }
	+}
	+
	+func TestHandleAction_WithNonFuncAction(t *testing.T) {
	+ app := NewApp()
	+ app.Action = 42
	+ fs, err := flagSet(app.Name, app.Flags)
	+ if err != nil {
	+ t.Errorf("error creating FlagSet: %s", err)
	+ }
	+ err = HandleAction(app.Action, NewContext(app, fs, nil))
	+
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ exitErr, ok := err.(*ExitError)
	+
	+ if !ok {
	+ t.Fatalf("expected to receive a *ExitError")
	+ }
	+
	+ if !strings.HasPrefix(exitErr.Error(), "ERROR invalid Action type.") {
	+ t.Fatalf("expected an unknown Action error, but got: %v", exitErr.Error())
	+ }
	+
	+ if exitErr.ExitCode() != 2 {
	+ t.Fatalf("expected error exit code to be 2, but got: %v", exitErr.ExitCode())
	+ }
	+}
	+
	+func TestHandleAction_WithInvalidFuncSignature(t *testing.T) {
	+ app := NewApp()
	+ app.Action = func() string { return "" }
	+ fs, err := flagSet(app.Name, app.Flags)
	+ if err != nil {
	+ t.Errorf("error creating FlagSet: %s", err)
	+ }
	+ err = HandleAction(app.Action, NewContext(app, fs, nil))
	+
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ exitErr, ok := err.(*ExitError)
	+
	+ if !ok {
	+ t.Fatalf("expected to receive a *ExitError")
	+ }
	+
	+ if !strings.HasPrefix(exitErr.Error(), "ERROR invalid Action type") {
	+ t.Fatalf("expected an unknown Action error, but got: %v", exitErr.Error())
	+ }
	+
	+ if exitErr.ExitCode() != 2 {
	+ t.Fatalf("expected error exit code to be 2, but got: %v", exitErr.ExitCode())
	+ }
	+}
	+
	+func TestHandleAction_WithInvalidFuncReturnSignature(t *testing.T) {
	+ app := NewApp()
	+ app.Action = func(_ *Context) (int, error) { return 0, nil }
	+ fs, err := flagSet(app.Name, app.Flags)
	+ if err != nil {
	+ t.Errorf("error creating FlagSet: %s", err)
	+ }
	+ err = HandleAction(app.Action, NewContext(app, fs, nil))
	+
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ exitErr, ok := err.(*ExitError)
	+
	+ if !ok {
	+ t.Fatalf("expected to receive a *ExitError")
	+ }
	+
	+ if !strings.HasPrefix(exitErr.Error(), "ERROR invalid Action type") {
	+ t.Fatalf("expected an invalid Action signature error, but got: %v", exitErr.Error())
	+ }
	+
	+ if exitErr.ExitCode() != 2 {
	+ t.Fatalf("expected error exit code to be 2, but got: %v", exitErr.ExitCode())
	+ }
	+}
	+
	+func TestHandleAction_WithUnknownPanic(t *testing.T) {
	+ defer func() { refute(t, recover(), nil) }()
	+
	+ var fn ActionFunc
	+
	+ app := NewApp()
	+ app.Action = func(ctx *Context) error {
	+ fn(ctx)
	+ return nil
	+ }
	+ fs, err := flagSet(app.Name, app.Flags)
	+ if err != nil {
	+ t.Errorf("error creating FlagSet: %s", err)
	+ }
	+ HandleAction(app.Action, NewContext(app, fs, nil))
	+}
	+
	+func TestShellCompletionForIncompleteFlags(t *testing.T) {
	+ app := NewApp()
	+ app.Flags = []Flag{
	+ IntFlag{
	+ Name: "test-completion",
	+ },
	+ }
	+ app.EnableBashCompletion = true
	+ app.BashComplete = func(ctx *Context) {
	+ for _, command := range ctx.App.Commands {
	+ if command.Hidden {
	+ continue
	+ }
	+
	+ for _, name := range command.Names() {
	+ fmt.Fprintln(ctx.App.Writer, name)
	+ }
	+ }
	+
	+ for _, flag := range ctx.App.Flags {
	+ for _, name := range strings.Split(flag.GetName(), ",") {
	+ if name == BashCompletionFlag.Name {
	+ continue
	+ }
	+
	+ switch name = strings.TrimSpace(name); len(name) {
	+ case 0:
	+ case 1:
	+ fmt.Fprintln(ctx.App.Writer, "-"+name)
	+ default:
	+ fmt.Fprintln(ctx.App.Writer, "--"+name)
	+ }
	+ }
	+ }
	+ }
	+ app.Action = func(ctx *Context) error {
	+ return fmt.Errorf("should not get here")
	+ }
	+ err := app.Run([]string{"", "--test-completion", "--" + BashCompletionFlag.Name})
	+ if err != nil {
	+ t.Errorf("app should not return an error: %s", err)
	+ }
	+}
	+
	+func TestHandleActionActuallyWorksWithActions(t *testing.T) {
	+ var f ActionFunc
	+ called := false
	+ f = func(c *Context) error {
	+ called = true
	+ return nil
	+ }
	+
	+ err := HandleAction(f, nil)
	+
	+ if err != nil {
	+ t.Errorf("Should not have errored: %v", err)
	+ }
	+
	+ if !called {
	+ t.Errorf("Function was not called")
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/appveyor.yml b/src/gopkg.in/urfave/cli.v1/appveyor.yml
	new file mode 100644
	index 0000000..698b188
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/appveyor.yml
	@@ -0,0 +1,24 @@
	+version: "{build}"
	+
	+os: Windows Server 2012 R2
	+
	+clone_folder: c:\gopath\src\github.com\urfave\cli
	+
	+environment:
	+ GOPATH: C:\gopath
	+ GOVERSION: 1.6
	+ PYTHON: C:\Python27-x64
	+ PYTHON_VERSION: 2.7.x
	+ PYTHON_ARCH: 64
	+
	+install:
	+- set PATH=%GOPATH%\bin;C:\go\bin;%PATH%
	+- go version
	+- go env
	+- go get github.com/urfave/gfmrun/...
	+- go get -v -t ./...
	+
	+build_script:
	+- python runtests vet
	+- python runtests test
	+- python runtests gfmrun
	diff --git a/src/gopkg.in/urfave/cli.v1/autocomplete/bash_autocomplete b/src/gopkg.in/urfave/cli.v1/autocomplete/bash_autocomplete
	new file mode 100644
	index 0000000..21a232f
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/autocomplete/bash_autocomplete
	@@ -0,0 +1,14 @@
	+#! /bin/bash
	+
	+: ${PROG:=$(basename ${BASH_SOURCE})}
	+
	+_cli_bash_autocomplete() {
	+ local cur opts base
	+ COMPREPLY=()
	+ cur="${COMP_WORDS[COMP_CWORD]}"
	+ opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
	+ COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	+ return 0
	+ }
	+
	+ complete -F _cli_bash_autocomplete $PROG
	diff --git a/src/gopkg.in/urfave/cli.v1/autocomplete/zsh_autocomplete b/src/gopkg.in/urfave/cli.v1/autocomplete/zsh_autocomplete
	new file mode 100644
	index 0000000..5430a18
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/autocomplete/zsh_autocomplete
	@@ -0,0 +1,5 @@
	+autoload -U compinit && compinit
	+autoload -U bashcompinit && bashcompinit
	+
	+script_dir=$(dirname $0)
	+source ${script_dir}/bash_autocomplete
	diff --git a/src/gopkg.in/urfave/cli.v1/category.go b/src/gopkg.in/urfave/cli.v1/category.go
	new file mode 100644
	index 0000000..1a60550
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/category.go
	@@ -0,0 +1,44 @@
	+package cli
	+
	+// CommandCategories is a slice of *CommandCategory.
	+type CommandCategories []*CommandCategory
	+
	+// CommandCategory is a category containing commands.
	+type CommandCategory struct {
	+ Name string
	+ Commands Commands
	+}
	+
	+func (c CommandCategories) Less(i, j int) bool {
	+ return c[i].Name < c[j].Name
	+}
	+
	+func (c CommandCategories) Len() int {
	+ return len(c)
	+}
	+
	+func (c CommandCategories) Swap(i, j int) {
	+ c[i], c[j] = c[j], c[i]
	+}
	+
	+// AddCommand adds a command to a category.
	+func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
	+ for _, commandCategory := range c {
	+ if commandCategory.Name == category {
	+ commandCategory.Commands = append(commandCategory.Commands, command)
	+ return c
	+ }
	+ }
	+ return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
	+}
	+
	+// VisibleCommands returns a slice of the Commands with Hidden=false
	+func (c *CommandCategory) VisibleCommands() []Command {
	+ ret := []Command{}
	+ for _, command := range c.Commands {
	+ if !command.Hidden {
	+ ret = append(ret, command)
	+ }
	+ }
	+ return ret
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/cli.go b/src/gopkg.in/urfave/cli.v1/cli.go
	new file mode 100644
	index 0000000..74fd101
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/cli.go
	@@ -0,0 +1,21 @@
	+// Package cli provides a minimal framework for creating and organizing command line
	+// Go applications. cli is designed to be easy to understand and write, the most simple
	+// cli application can be written as follows:
	+// func main() {
	+// cli.NewApp().Run(os.Args)
	+// }
	+//
	+// Of course this application does not do much, so let's make this an actual application:
	+// func main() {
	+// app := cli.NewApp()
	+// app.Name = "greet"
	+// app.Usage = "say a greeting"
	+// app.Action = func(c *cli.Context) error {
	+// println("Greetings")
	+// }
	+//
	+// app.Run(os.Args)
	+// }
	+package cli
	+
	+//go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go
	diff --git a/src/gopkg.in/urfave/cli.v1/command.go b/src/gopkg.in/urfave/cli.v1/command.go
	new file mode 100644
	index 0000000..2628fbf
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/command.go
	@@ -0,0 +1,286 @@
	+package cli
	+
	+import (
	+ "fmt"
	+ "io/ioutil"
	+ "sort"
	+ "strings"
	+)
	+
	+// Command is a subcommand for a cli.App.
	+type Command struct {
	+ // The name of the command
	+ Name string
	+ // short name of the command. Typically one character (deprecated, use `Aliases`)
	+ ShortName string
	+ // A list of aliases for the command
	+ Aliases []string
	+ // A short description of the usage of this command
	+ Usage string
	+ // Custom text to show on USAGE section of help
	+ UsageText string
	+ // A longer explanation of how the command works
	+ Description string
	+ // A short description of the arguments of this command
	+ ArgsUsage string
	+ // The category the command is part of
	+ Category string
	+ // The function to call when checking for bash command completions
	+ BashComplete BashCompleteFunc
	+ // An action to execute before any sub-subcommands are run, but after the context is ready
	+ // If a non-nil error is returned, no sub-subcommands are run
	+ Before BeforeFunc
	+ // An action to execute after any subcommands are run, but after the subcommand has finished
	+ // It is run even if Action() panics
	+ After AfterFunc
	+ // The function to call when this command is invoked
	+ Action interface{}
	+ // TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
	+ // of deprecation period has passed, maybe?
	+
	+ // Execute this function if a usage error occurs.
	+ OnUsageError OnUsageErrorFunc
	+ // List of child commands
	+ Subcommands Commands
	+ // List of flags to parse
	+ Flags []Flag
	+ // Treat all flags as normal arguments if true
	+ SkipFlagParsing bool
	+ // Skip argument reordering which attempts to move flags before arguments,
	+ // but only works if all flags appear after all arguments. This behavior was
	+ // removed n version 2 since it only works under specific conditions so we
	+ // backport here by exposing it as an option for compatibility.
	+ SkipArgReorder bool
	+ // Boolean to hide built-in help command
	+ HideHelp bool
	+ // Boolean to hide this command from help or completion
	+ Hidden bool
	+
	+ // Full name of command for help, defaults to full command name, including parent commands.
	+ HelpName string
	+ commandNamePath []string
	+}
	+
	+// FullName returns the full name of the command.
	+// For subcommands this ensures that parent commands are part of the command path
	+func (c Command) FullName() string {
	+ if c.commandNamePath == nil {
	+ return c.Name
	+ }
	+ return strings.Join(c.commandNamePath, " ")
	+}
	+
	+// Commands is a slice of Command
	+type Commands []Command
	+
	+// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
	+func (c Command) Run(ctx *Context) (err error) {
	+ if len(c.Subcommands) > 0 {
	+ return c.startApp(ctx)
	+ }
	+
	+ if !c.HideHelp && (HelpFlag != BoolFlag{}) {
	+ // append help to flags
	+ c.Flags = append(
	+ c.Flags,
	+ HelpFlag,
	+ )
	+ }
	+
	+ set, err := flagSet(c.Name, c.Flags)
	+ if err != nil {
	+ return err
	+ }
	+ set.SetOutput(ioutil.Discard)
	+
	+ if c.SkipFlagParsing {
	+ err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
	+ } else if !c.SkipArgReorder {
	+ firstFlagIndex := -1
	+ terminatorIndex := -1
	+ for index, arg := range ctx.Args() {
	+ if arg == "--" {
	+ terminatorIndex = index
	+ break
	+ } else if arg == "-" {
	+ // Do nothing. A dash alone is not really a flag.
	+ continue
	+ } else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
	+ firstFlagIndex = index
	+ }
	+ }
	+
	+ if firstFlagIndex > -1 {
	+ args := ctx.Args()
	+ regularArgs := make([]string, len(args[1:firstFlagIndex]))
	+ copy(regularArgs, args[1:firstFlagIndex])
	+
	+ var flagArgs []string
	+ if terminatorIndex > -1 {
	+ flagArgs = args[firstFlagIndex:terminatorIndex]
	+ regularArgs = append(regularArgs, args[terminatorIndex:]...)
	+ } else {
	+ flagArgs = args[firstFlagIndex:]
	+ }
	+
	+ err = set.Parse(append(flagArgs, regularArgs...))
	+ } else {
	+ err = set.Parse(ctx.Args().Tail())
	+ }
	+ } else {
	+ err = set.Parse(ctx.Args().Tail())
	+ }
	+
	+ nerr := normalizeFlags(c.Flags, set)
	+ if nerr != nil {
	+ fmt.Fprintln(ctx.App.Writer, nerr)
	+ fmt.Fprintln(ctx.App.Writer)
	+ ShowCommandHelp(ctx, c.Name)
	+ return nerr
	+ }
	+
	+ context := NewContext(ctx.App, set, ctx)
	+ if checkCommandCompletions(context, c.Name) {
	+ return nil
	+ }
	+
	+ if err != nil {
	+ if c.OnUsageError != nil {
	+ err := c.OnUsageError(ctx, err, false)
	+ HandleExitCoder(err)
	+ return err
	+ }
	+ fmt.Fprintln(ctx.App.Writer, "Incorrect Usage:", err.Error())
	+ fmt.Fprintln(ctx.App.Writer)
	+ ShowCommandHelp(ctx, c.Name)
	+ return err
	+ }
	+
	+ if checkCommandHelp(context, c.Name) {
	+ return nil
	+ }
	+
	+ if c.After != nil {
	+ defer func() {
	+ afterErr := c.After(context)
	+ if afterErr != nil {
	+ HandleExitCoder(err)
	+ if err != nil {
	+ err = NewMultiError(err, afterErr)
	+ } else {
	+ err = afterErr
	+ }
	+ }
	+ }()
	+ }
	+
	+ if c.Before != nil {
	+ err = c.Before(context)
	+ if err != nil {
	+ fmt.Fprintln(ctx.App.Writer, err)
	+ fmt.Fprintln(ctx.App.Writer)
	+ ShowCommandHelp(ctx, c.Name)
	+ HandleExitCoder(err)
	+ return err
	+ }
	+ }
	+
	+ if c.Action == nil {
	+ c.Action = helpSubcommand.Action
	+ }
	+
	+ context.Command = c
	+ err = HandleAction(c.Action, context)
	+
	+ if err != nil {
	+ HandleExitCoder(err)
	+ }
	+ return err
	+}
	+
	+// Names returns the names including short names and aliases.
	+func (c Command) Names() []string {
	+ names := []string{c.Name}
	+
	+ if c.ShortName != "" {
	+ names = append(names, c.ShortName)
	+ }
	+
	+ return append(names, c.Aliases...)
	+}
	+
	+// HasName returns true if Command.Name or Command.ShortName matches given name
	+func (c Command) HasName(name string) bool {
	+ for _, n := range c.Names() {
	+ if n == name {
	+ return true
	+ }
	+ }
	+ return false
	+}
	+
	+func (c Command) startApp(ctx *Context) error {
	+ app := NewApp()
	+ app.Metadata = ctx.App.Metadata
	+ // set the name and usage
	+ app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
	+ if c.HelpName == "" {
	+ app.HelpName = c.HelpName
	+ } else {
	+ app.HelpName = app.Name
	+ }
	+
	+ if c.Description != "" {
	+ app.Usage = c.Description
	+ } else {
	+ app.Usage = c.Usage
	+ }
	+
	+ // set CommandNotFound
	+ app.CommandNotFound = ctx.App.CommandNotFound
	+
	+ // set the flags and commands
	+ app.Commands = c.Subcommands
	+ app.Flags = c.Flags
	+ app.HideHelp = c.HideHelp
	+
	+ app.Version = ctx.App.Version
	+ app.HideVersion = ctx.App.HideVersion
	+ app.Compiled = ctx.App.Compiled
	+ app.Author = ctx.App.Author
	+ app.Email = ctx.App.Email
	+ app.Writer = ctx.App.Writer
	+
	+ app.categories = CommandCategories{}
	+ for _, command := range c.Subcommands {
	+ app.categories = app.categories.AddCommand(command.Category, command)
	+ }
	+
	+ sort.Sort(app.categories)
	+
	+ // bash completion
	+ app.EnableBashCompletion = ctx.App.EnableBashCompletion
	+ if c.BashComplete != nil {
	+ app.BashComplete = c.BashComplete
	+ }
	+
	+ // set the actions
	+ app.Before = c.Before
	+ app.After = c.After
	+ if c.Action != nil {
	+ app.Action = c.Action
	+ } else {
	+ app.Action = helpSubcommand.Action
	+ }
	+
	+ for index, cc := range app.Commands {
	+ app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
	+ }
	+
	+ return app.RunAsSubcommand(ctx)
	+}
	+
	+// VisibleFlags returns a slice of the Flags with Hidden=false
	+func (c Command) VisibleFlags() []Flag {
	+ return visibleFlags(c.Flags)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/command_test.go b/src/gopkg.in/urfave/cli.v1/command_test.go
	new file mode 100644
	index 0000000..5e0e8de
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/command_test.go
	@@ -0,0 +1,155 @@
	+package cli
	+
	+import (
	+ "errors"
	+ "flag"
	+ "fmt"
	+ "io/ioutil"
	+ "strings"
	+ "testing"
	+)
	+
	+func TestCommandFlagParsing(t *testing.T) {
	+ cases := []struct {
	+ testArgs []string
	+ skipFlagParsing bool
	+ skipArgReorder bool
	+ expectedErr error
	+ }{
	+ // Test normal "not ignoring flags" flow
	+ {[]string{"test-cmd", "blah", "blah", "-break"}, false, false, errors.New("flag provided but not defined: -break")},
	+
	+ // Test no arg reorder
	+ {[]string{"test-cmd", "blah", "blah", "-break"}, false, true, nil},
	+
	+ {[]string{"test-cmd", "blah", "blah"}, true, false, nil}, // Test SkipFlagParsing without any args that look like flags
	+ {[]string{"test-cmd", "blah", "-break"}, true, false, nil}, // Test SkipFlagParsing with random flag arg
	+ {[]string{"test-cmd", "blah", "-help"}, true, false, nil}, // Test SkipFlagParsing with "special" help flag arg
	+ }
	+
	+ for _, c := range cases {
	+ app := NewApp()
	+ app.Writer = ioutil.Discard
	+ set := flag.NewFlagSet("test", 0)
	+ set.Parse(c.testArgs)
	+
	+ context := NewContext(app, set, nil)
	+
	+ command := Command{
	+ Name: "test-cmd",
	+ Aliases: []string{"tc"},
	+ Usage: "this is for testing",
	+ Description: "testing",
	+ Action: func(_ *Context) error { return nil },
	+ SkipFlagParsing: c.skipFlagParsing,
	+ SkipArgReorder: c.skipArgReorder,
	+ }
	+
	+ err := command.Run(context)
	+
	+ expect(t, err, c.expectedErr)
	+ expect(t, []string(context.Args()), c.testArgs)
	+ }
	+}
	+
	+func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
	+ app := NewApp()
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ Before: func(c *Context) error {
	+ return fmt.Errorf("before error")
	+ },
	+ After: func(c *Context) error {
	+ return fmt.Errorf("after error")
	+ },
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "bar"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.Contains(err.Error(), "before error") {
	+ t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
	+ }
	+ if !strings.Contains(err.Error(), "after error") {
	+ t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
	+ }
	+}
	+
	+func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
	+ var receivedMsgFromAction string
	+ var receivedMsgFromAfter string
	+
	+ app := NewApp()
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ Before: func(c *Context) error {
	+ c.App.Metadata["msg"] = "hello world"
	+ return nil
	+ },
	+ Action: func(c *Context) error {
	+ msg, ok := c.App.Metadata["msg"]
	+ if !ok {
	+ return errors.New("msg not found")
	+ }
	+ receivedMsgFromAction = msg.(string)
	+ return nil
	+ },
	+ After: func(c *Context) error {
	+ msg, ok := c.App.Metadata["msg"]
	+ if !ok {
	+ return errors.New("msg not found")
	+ }
	+ receivedMsgFromAfter = msg.(string)
	+ return nil
	+ },
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "bar"})
	+ if err != nil {
	+ t.Fatalf("expected no error from Run, got %s", err)
	+ }
	+
	+ expectedMsg := "hello world"
	+
	+ if receivedMsgFromAction != expectedMsg {
	+ t.Fatalf("expected msg from Action to match. Given: %q\nExpected: %q",
	+ receivedMsgFromAction, expectedMsg)
	+ }
	+ if receivedMsgFromAfter != expectedMsg {
	+ t.Fatalf("expected msg from After to match. Given: %q\nExpected: %q",
	+ receivedMsgFromAction, expectedMsg)
	+ }
	+}
	+
	+func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
	+ app := NewApp()
	+ app.Commands = []Command{
	+ {
	+ Name: "bar",
	+ Flags: []Flag{
	+ IntFlag{Name: "flag"},
	+ },
	+ OnUsageError: func(c *Context, err error, _ bool) error {
	+ if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
	+ t.Errorf("Expect an invalid value error, but got \"%v\"", err)
	+ }
	+ return errors.New("intercepted: " + err.Error())
	+ },
	+ },
	+ }
	+
	+ err := app.Run([]string{"foo", "bar", "--flag=wrong"})
	+ if err == nil {
	+ t.Fatalf("expected to receive error from Run, got none")
	+ }
	+
	+ if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
	+ t.Errorf("Expect an intercepted error, but got \"%v\"", err)
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/context.go b/src/gopkg.in/urfave/cli.v1/context.go
	new file mode 100644
	index 0000000..cb89e92
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/context.go
	@@ -0,0 +1,276 @@
	+package cli
	+
	+import (
	+ "errors"
	+ "flag"
	+ "reflect"
	+ "strings"
	+ "syscall"
	+)
	+
	+// Context is a type that is passed through to
	+// each Handler action in a cli application. Context
	+// can be used to retrieve context-specific Args and
	+// parsed command-line options.
	+type Context struct {
	+ App *App
	+ Command Command
	+ shellComplete bool
	+ flagSet *flag.FlagSet
	+ setFlags map[string]bool
	+ parentContext *Context
	+}
	+
	+// NewContext creates a new context. For use in when invoking an App or Command action.
	+func NewContext(app App, set flag.FlagSet, parentCtx Context) Context {
	+ c := &Context{App: app, flagSet: set, parentContext: parentCtx}
	+
	+ if parentCtx != nil {
	+ c.shellComplete = parentCtx.shellComplete
	+ }
	+
	+ return c
	+}
	+
	+// NumFlags returns the number of flags set
	+func (c *Context) NumFlags() int {
	+ return c.flagSet.NFlag()
	+}
	+
	+// Set sets a context flag to a value.
	+func (c *Context) Set(name, value string) error {
	+ return c.flagSet.Set(name, value)
	+}
	+
	+// GlobalSet sets a context flag to a value on the global flagset
	+func (c *Context) GlobalSet(name, value string) error {
	+ return globalContext(c).flagSet.Set(name, value)
	+}
	+
	+// IsSet determines if the flag was actually set
	+func (c *Context) IsSet(name string) bool {
	+ if c.setFlags == nil {
	+ c.setFlags = make(map[string]bool)
	+
	+ c.flagSet.Visit(func(f *flag.Flag) {
	+ c.setFlags[f.Name] = true
	+ })
	+
	+ c.flagSet.VisitAll(func(f *flag.Flag) {
	+ if _, ok := c.setFlags[f.Name]; ok {
	+ return
	+ }
	+ c.setFlags[f.Name] = false
	+ })
	+
	+ // XXX hack to support IsSet for flags with EnvVar
	+ //
	+ // There isn't an easy way to do this with the current implementation since
	+ // whether a flag was set via an environment variable is very difficult to
	+ // determine here. Instead, we intend to introduce a backwards incompatible
	+ // change in version 2 to add `IsSet` to the Flag interface to push the
	+ // responsibility closer to where the information required to determine
	+ // whether a flag is set by non-standard means such as environment
	+ // variables is avaliable.
	+ //
	+ // See https://github.com/urfave/cli/issues/294 for additional discussion
	+ flags := c.Command.Flags
	+ if c.Command.Name == "" { // cannot == Command{} since it contains slice types
	+ if c.App != nil {
	+ flags = c.App.Flags
	+ }
	+ }
	+ for _, f := range flags {
	+ eachName(f.GetName(), func(name string) {
	+ if isSet, ok := c.setFlags[name]; isSet \|\| !ok {
	+ return
	+ }
	+
	+ val := reflect.ValueOf(f)
	+ if val.Kind() == reflect.Ptr {
	+ val = val.Elem()
	+ }
	+
	+ envVarValue := val.FieldByName("EnvVar")
	+ if !envVarValue.IsValid() {
	+ return
	+ }
	+
	+ eachName(envVarValue.String(), func(envVar string) {
	+ envVar = strings.TrimSpace(envVar)
	+ if _, ok := syscall.Getenv(envVar); ok {
	+ c.setFlags[name] = true
	+ return
	+ }
	+ })
	+ })
	+ }
	+ }
	+
	+ return c.setFlags[name]
	+}
	+
	+// GlobalIsSet determines if the global flag was actually set
	+func (c *Context) GlobalIsSet(name string) bool {
	+ ctx := c
	+ if ctx.parentContext != nil {
	+ ctx = ctx.parentContext
	+ }
	+
	+ for ; ctx != nil; ctx = ctx.parentContext {
	+ if ctx.IsSet(name) {
	+ return true
	+ }
	+ }
	+ return false
	+}
	+
	+// FlagNames returns a slice of flag names used in this context.
	+func (c *Context) FlagNames() (names []string) {
	+ for _, flag := range c.Command.Flags {
	+ name := strings.Split(flag.GetName(), ",")[0]
	+ if name == "help" {
	+ continue
	+ }
	+ names = append(names, name)
	+ }
	+ return
	+}
	+
	+// GlobalFlagNames returns a slice of global flag names used by the app.
	+func (c *Context) GlobalFlagNames() (names []string) {
	+ for _, flag := range c.App.Flags {
	+ name := strings.Split(flag.GetName(), ",")[0]
	+ if name == "help" \|\| name == "version" {
	+ continue
	+ }
	+ names = append(names, name)
	+ }
	+ return
	+}
	+
	+// Parent returns the parent context, if any
	+func (c Context) Parent() Context {
	+ return c.parentContext
	+}
	+
	+// value returns the value of the flag coressponding to `name`
	+func (c *Context) value(name string) interface{} {
	+ return c.flagSet.Lookup(name).Value.(flag.Getter).Get()
	+}
	+
	+// Args contains apps console arguments
	+type Args []string
	+
	+// Args returns the command line arguments associated with the context.
	+func (c *Context) Args() Args {
	+ args := Args(c.flagSet.Args())
	+ return args
	+}
	+
	+// NArg returns the number of the command line arguments.
	+func (c *Context) NArg() int {
	+ return len(c.Args())
	+}
	+
	+// Get returns the nth argument, or else a blank string
	+func (a Args) Get(n int) string {
	+ if len(a) > n {
	+ return a[n]
	+ }
	+ return ""
	+}
	+
	+// First returns the first argument, or else a blank string
	+func (a Args) First() string {
	+ return a.Get(0)
	+}
	+
	+// Tail returns the rest of the arguments (not the first one)
	+// or else an empty string slice
	+func (a Args) Tail() []string {
	+ if len(a) >= 2 {
	+ return []string(a)[1:]
	+ }
	+ return []string{}
	+}
	+
	+// Present checks if there are any arguments present
	+func (a Args) Present() bool {
	+ return len(a) != 0
	+}
	+
	+// Swap swaps arguments at the given indexes
	+func (a Args) Swap(from, to int) error {
	+ if from >= len(a) \|\| to >= len(a) {
	+ return errors.New("index out of range")
	+ }
	+ a[from], a[to] = a[to], a[from]
	+ return nil
	+}
	+
	+func globalContext(ctx Context) Context {
	+ if ctx == nil {
	+ return nil
	+ }
	+
	+ for {
	+ if ctx.parentContext == nil {
	+ return ctx
	+ }
	+ ctx = ctx.parentContext
	+ }
	+}
	+
	+func lookupGlobalFlagSet(name string, ctx Context) flag.FlagSet {
	+ if ctx.parentContext != nil {
	+ ctx = ctx.parentContext
	+ }
	+ for ; ctx != nil; ctx = ctx.parentContext {
	+ if f := ctx.flagSet.Lookup(name); f != nil {
	+ return ctx.flagSet
	+ }
	+ }
	+ return nil
	+}
	+
	+func copyFlag(name string, ff flag.Flag, set flag.FlagSet) {
	+ switch ff.Value.(type) {
	+ case *StringSlice:
	+ default:
	+ set.Set(name, ff.Value.String())
	+ }
	+}
	+
	+func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
	+ visited := make(map[string]bool)
	+ set.Visit(func(f *flag.Flag) {
	+ visited[f.Name] = true
	+ })
	+ for _, f := range flags {
	+ parts := strings.Split(f.GetName(), ",")
	+ if len(parts) == 1 {
	+ continue
	+ }
	+ var ff *flag.Flag
	+ for _, name := range parts {
	+ name = strings.Trim(name, " ")
	+ if visited[name] {
	+ if ff != nil {
	+ return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
	+ }
	+ ff = set.Lookup(name)
	+ }
	+ }
	+ if ff == nil {
	+ continue
	+ }
	+ for _, name := range parts {
	+ name = strings.Trim(name, " ")
	+ if !visited[name] {
	+ copyFlag(name, ff, set)
	+ }
	+ }
	+ }
	+ return nil
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/context_test.go b/src/gopkg.in/urfave/cli.v1/context_test.go
	new file mode 100644
	index 0000000..a1ab05b
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/context_test.go
	@@ -0,0 +1,399 @@
	+package cli
	+
	+import (
	+ "flag"
	+ "os"
	+ "testing"
	+ "time"
	+)
	+
	+func TestNewContext(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int("myflag", 12, "doc")
	+ set.Int64("myflagInt64", int64(12), "doc")
	+ set.Uint("myflagUint", uint(93), "doc")
	+ set.Uint64("myflagUint64", uint64(93), "doc")
	+ set.Float64("myflag64", float64(17), "doc")
	+ globalSet := flag.NewFlagSet("test", 0)
	+ globalSet.Int("myflag", 42, "doc")
	+ globalSet.Int64("myflagInt64", int64(42), "doc")
	+ globalSet.Uint("myflagUint", uint(33), "doc")
	+ globalSet.Uint64("myflagUint64", uint64(33), "doc")
	+ globalSet.Float64("myflag64", float64(47), "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+ command := Command{Name: "mycommand"}
	+ c := NewContext(nil, set, globalCtx)
	+ c.Command = command
	+ expect(t, c.Int("myflag"), 12)
	+ expect(t, c.Int64("myflagInt64"), int64(12))
	+ expect(t, c.Uint("myflagUint"), uint(93))
	+ expect(t, c.Uint64("myflagUint64"), uint64(93))
	+ expect(t, c.Float64("myflag64"), float64(17))
	+ expect(t, c.GlobalInt("myflag"), 42)
	+ expect(t, c.GlobalInt64("myflagInt64"), int64(42))
	+ expect(t, c.GlobalUint("myflagUint"), uint(33))
	+ expect(t, c.GlobalUint64("myflagUint64"), uint64(33))
	+ expect(t, c.GlobalFloat64("myflag64"), float64(47))
	+ expect(t, c.Command.Name, "mycommand")
	+}
	+
	+func TestContext_Int(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int("myflag", 12, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Int("myflag"), 12)
	+}
	+
	+func TestContext_Int64(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int64("myflagInt64", 12, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Int64("myflagInt64"), int64(12))
	+}
	+
	+func TestContext_Uint(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Uint("myflagUint", uint(13), "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Uint("myflagUint"), uint(13))
	+}
	+
	+func TestContext_Uint64(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Uint64("myflagUint64", uint64(9), "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Uint64("myflagUint64"), uint64(9))
	+}
	+
	+func TestContext_GlobalInt(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int("myflag", 12, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.GlobalInt("myflag"), 12)
	+ expect(t, c.GlobalInt("nope"), 0)
	+}
	+
	+func TestContext_GlobalInt64(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int64("myflagInt64", 12, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.GlobalInt64("myflagInt64"), int64(12))
	+ expect(t, c.GlobalInt64("nope"), int64(0))
	+}
	+
	+func TestContext_Float64(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Float64("myflag", float64(17), "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Float64("myflag"), float64(17))
	+}
	+
	+func TestContext_GlobalFloat64(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Float64("myflag", float64(17), "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.GlobalFloat64("myflag"), float64(17))
	+ expect(t, c.GlobalFloat64("nope"), float64(0))
	+}
	+
	+func TestContext_Duration(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Duration("myflag", time.Duration(12*time.Second), "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
	+}
	+
	+func TestContext_String(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.String("myflag", "hello world", "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.String("myflag"), "hello world")
	+}
	+
	+func TestContext_Bool(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.Bool("myflag"), false)
	+}
	+
	+func TestContext_BoolT(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", true, "doc")
	+ c := NewContext(nil, set, nil)
	+ expect(t, c.BoolT("myflag"), true)
	+}
	+
	+func TestContext_GlobalBool(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+
	+ globalSet := flag.NewFlagSet("test-global", 0)
	+ globalSet.Bool("myflag", false, "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+
	+ c := NewContext(nil, set, globalCtx)
	+ expect(t, c.GlobalBool("myflag"), false)
	+ expect(t, c.GlobalBool("nope"), false)
	+}
	+
	+func TestContext_GlobalBoolT(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+
	+ globalSet := flag.NewFlagSet("test-global", 0)
	+ globalSet.Bool("myflag", true, "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+
	+ c := NewContext(nil, set, globalCtx)
	+ expect(t, c.GlobalBoolT("myflag"), true)
	+ expect(t, c.GlobalBoolT("nope"), false)
	+}
	+
	+func TestContext_Args(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ c := NewContext(nil, set, nil)
	+ set.Parse([]string{"--myflag", "bat", "baz"})
	+ expect(t, len(c.Args()), 2)
	+ expect(t, c.Bool("myflag"), true)
	+}
	+
	+func TestContext_NArg(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ c := NewContext(nil, set, nil)
	+ set.Parse([]string{"--myflag", "bat", "baz"})
	+ expect(t, c.NArg(), 2)
	+}
	+
	+func TestContext_IsSet(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ set.String("otherflag", "hello world", "doc")
	+ globalSet := flag.NewFlagSet("test", 0)
	+ globalSet.Bool("myflagGlobal", true, "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+ c := NewContext(nil, set, globalCtx)
	+ set.Parse([]string{"--myflag", "bat", "baz"})
	+ globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
	+ expect(t, c.IsSet("myflag"), true)
	+ expect(t, c.IsSet("otherflag"), false)
	+ expect(t, c.IsSet("bogusflag"), false)
	+ expect(t, c.IsSet("myflagGlobal"), false)
	+}
	+
	+// XXX Corresponds to hack in context.IsSet for flags with EnvVar field
	+// Should be moved to `flag_test` in v2
	+func TestContext_IsSet_fromEnv(t *testing.T) {
	+ var (
	+ timeoutIsSet, tIsSet bool
	+ noEnvVarIsSet, nIsSet bool
	+ passwordIsSet, pIsSet bool
	+ unparsableIsSet, uIsSet bool
	+ )
	+
	+ clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
	+ os.Setenv("APP_PASSWORD", "")
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
	+ StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"},
	+ Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"},
	+ Float64Flag{Name: "no-env-var, n"},
	+ },
	+ Action: func(ctx *Context) error {
	+ timeoutIsSet = ctx.IsSet("timeout")
	+ tIsSet = ctx.IsSet("t")
	+ passwordIsSet = ctx.IsSet("password")
	+ pIsSet = ctx.IsSet("p")
	+ unparsableIsSet = ctx.IsSet("unparsable")
	+ uIsSet = ctx.IsSet("u")
	+ noEnvVarIsSet = ctx.IsSet("no-env-var")
	+ nIsSet = ctx.IsSet("n")
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+ expect(t, timeoutIsSet, true)
	+ expect(t, tIsSet, true)
	+ expect(t, passwordIsSet, true)
	+ expect(t, pIsSet, true)
	+ expect(t, noEnvVarIsSet, false)
	+ expect(t, nIsSet, false)
	+
	+ os.Setenv("APP_UNPARSABLE", "foobar")
	+ a.Run([]string{"run"})
	+ expect(t, unparsableIsSet, false)
	+ expect(t, uIsSet, false)
	+}
	+
	+func TestContext_GlobalIsSet(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ set.String("otherflag", "hello world", "doc")
	+ globalSet := flag.NewFlagSet("test", 0)
	+ globalSet.Bool("myflagGlobal", true, "doc")
	+ globalSet.Bool("myflagGlobalUnset", true, "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+ c := NewContext(nil, set, globalCtx)
	+ set.Parse([]string{"--myflag", "bat", "baz"})
	+ globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
	+ expect(t, c.GlobalIsSet("myflag"), false)
	+ expect(t, c.GlobalIsSet("otherflag"), false)
	+ expect(t, c.GlobalIsSet("bogusflag"), false)
	+ expect(t, c.GlobalIsSet("myflagGlobal"), true)
	+ expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
	+ expect(t, c.GlobalIsSet("bogusGlobal"), false)
	+}
	+
	+// XXX Corresponds to hack in context.IsSet for flags with EnvVar field
	+// Should be moved to `flag_test` in v2
	+func TestContext_GlobalIsSet_fromEnv(t *testing.T) {
	+ var (
	+ timeoutIsSet, tIsSet bool
	+ noEnvVarIsSet, nIsSet bool
	+ passwordIsSet, pIsSet bool
	+ unparsableIsSet, uIsSet bool
	+ )
	+
	+ clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
	+ os.Setenv("APP_PASSWORD", "")
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
	+ StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"},
	+ Float64Flag{Name: "no-env-var, n"},
	+ Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"},
	+ },
	+ Commands: []Command{
	+ {
	+ Name: "hello",
	+ Action: func(ctx *Context) error {
	+ timeoutIsSet = ctx.GlobalIsSet("timeout")
	+ tIsSet = ctx.GlobalIsSet("t")
	+ passwordIsSet = ctx.GlobalIsSet("password")
	+ pIsSet = ctx.GlobalIsSet("p")
	+ unparsableIsSet = ctx.GlobalIsSet("unparsable")
	+ uIsSet = ctx.GlobalIsSet("u")
	+ noEnvVarIsSet = ctx.GlobalIsSet("no-env-var")
	+ nIsSet = ctx.GlobalIsSet("n")
	+ return nil
	+ },
	+ },
	+ },
	+ }
	+ if err := a.Run([]string{"run", "hello"}); err != nil {
	+ t.Logf("error running Run(): %+v", err)
	+ }
	+ expect(t, timeoutIsSet, true)
	+ expect(t, tIsSet, true)
	+ expect(t, passwordIsSet, true)
	+ expect(t, pIsSet, true)
	+ expect(t, noEnvVarIsSet, false)
	+ expect(t, nIsSet, false)
	+
	+ os.Setenv("APP_UNPARSABLE", "foobar")
	+ if err := a.Run([]string{"run"}); err != nil {
	+ t.Logf("error running Run(): %+v", err)
	+ }
	+ expect(t, unparsableIsSet, false)
	+ expect(t, uIsSet, false)
	+}
	+
	+func TestContext_NumFlags(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Bool("myflag", false, "doc")
	+ set.String("otherflag", "hello world", "doc")
	+ globalSet := flag.NewFlagSet("test", 0)
	+ globalSet.Bool("myflagGlobal", true, "doc")
	+ globalCtx := NewContext(nil, globalSet, nil)
	+ c := NewContext(nil, set, globalCtx)
	+ set.Parse([]string{"--myflag", "--otherflag=foo"})
	+ globalSet.Parse([]string{"--myflagGlobal"})
	+ expect(t, c.NumFlags(), 2)
	+}
	+
	+func TestContext_GlobalFlag(t *testing.T) {
	+ var globalFlag string
	+ var globalFlagSet bool
	+ app := NewApp()
	+ app.Flags = []Flag{
	+ StringFlag{Name: "global, g", Usage: "global"},
	+ }
	+ app.Action = func(c *Context) error {
	+ globalFlag = c.GlobalString("global")
	+ globalFlagSet = c.GlobalIsSet("global")
	+ return nil
	+ }
	+ app.Run([]string{"command", "-g", "foo"})
	+ expect(t, globalFlag, "foo")
	+ expect(t, globalFlagSet, true)
	+
	+}
	+
	+func TestContext_GlobalFlagsInSubcommands(t *testing.T) {
	+ subcommandRun := false
	+ parentFlag := false
	+ app := NewApp()
	+
	+ app.Flags = []Flag{
	+ BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
	+ }
	+
	+ app.Commands = []Command{
	+ {
	+ Name: "foo",
	+ Flags: []Flag{
	+ BoolFlag{Name: "parent, p", Usage: "Parent flag"},
	+ },
	+ Subcommands: []Command{
	+ {
	+ Name: "bar",
	+ Action: func(c *Context) error {
	+ if c.GlobalBool("debug") {
	+ subcommandRun = true
	+ }
	+ if c.GlobalBool("parent") {
	+ parentFlag = true
	+ }
	+ return nil
	+ },
	+ },
	+ },
	+ },
	+ }
	+
	+ app.Run([]string{"command", "-d", "foo", "-p", "bar"})
	+
	+ expect(t, subcommandRun, true)
	+ expect(t, parentFlag, true)
	+}
	+
	+func TestContext_Set(t *testing.T) {
	+ set := flag.NewFlagSet("test", 0)
	+ set.Int("int", 5, "an int")
	+ c := NewContext(nil, set, nil)
	+
	+ c.Set("int", "1")
	+ expect(t, c.Int("int"), 1)
	+}
	+
	+func TestContext_GlobalSet(t *testing.T) {
	+ gSet := flag.NewFlagSet("test", 0)
	+ gSet.Int("int", 5, "an int")
	+
	+ set := flag.NewFlagSet("sub", 0)
	+ set.Int("int", 3, "an int")
	+
	+ pc := NewContext(nil, gSet, nil)
	+ c := NewContext(nil, set, pc)
	+
	+ c.Set("int", "1")
	+ expect(t, c.Int("int"), 1)
	+ expect(t, c.GlobalInt("int"), 5)
	+
	+ c.GlobalSet("int", "1")
	+ expect(t, c.Int("int"), 1)
	+ expect(t, c.GlobalInt("int"), 1)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/errors.go b/src/gopkg.in/urfave/cli.v1/errors.go
	new file mode 100644
	index 0000000..0206ff4
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/errors.go
	@@ -0,0 +1,110 @@
	+package cli
	+
	+import (
	+ "fmt"
	+ "io"
	+ "os"
	+ "strings"
	+)
	+
	+// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
	+var OsExiter = os.Exit
	+
	+// ErrWriter is used to write errors to the user. This can be anything
	+// implementing the io.Writer interface and defaults to os.Stderr.
	+var ErrWriter io.Writer = os.Stderr
	+
	+// MultiError is an error that wraps multiple errors.
	+type MultiError struct {
	+ Errors []error
	+}
	+
	+// NewMultiError creates a new MultiError. Pass in one or more errors.
	+func NewMultiError(err ...error) MultiError {
	+ return MultiError{Errors: err}
	+}
	+
	+// Error implements the error interface.
	+func (m MultiError) Error() string {
	+ errs := make([]string, len(m.Errors))
	+ for i, err := range m.Errors {
	+ errs[i] = err.Error()
	+ }
	+
	+ return strings.Join(errs, "\n")
	+}
	+
	+type ErrorFormatter interface {
	+ Format(s fmt.State, verb rune)
	+}
	+
	+// ExitCoder is the interface checked by `App` and `Command` for a custom exit
	+// code
	+type ExitCoder interface {
	+ error
	+ ExitCode() int
	+}
	+
	+// ExitError fulfills both the builtin `error` interface and `ExitCoder`
	+type ExitError struct {
	+ exitCode int
	+ message interface{}
	+}
	+
	+// NewExitError makes a new *ExitError
	+func NewExitError(message interface{}, exitCode int) *ExitError {
	+ return &ExitError{
	+ exitCode: exitCode,
	+ message: message,
	+ }
	+}
	+
	+// Error returns the string message, fulfilling the interface required by
	+// `error`
	+func (ee *ExitError) Error() string {
	+ return fmt.Sprintf("%v", ee.message)
	+}
	+
	+// ExitCode returns the exit code, fulfilling the interface required by
	+// `ExitCoder`
	+func (ee *ExitError) ExitCode() int {
	+ return ee.exitCode
	+}
	+
	+// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
	+// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
	+// given exit code. If the given error is a MultiError, then this func is
	+// called on all members of the Errors slice.
	+func HandleExitCoder(err error) {
	+ if err == nil {
	+ return
	+ }
	+
	+ if exitErr, ok := err.(ExitCoder); ok {
	+ if err.Error() != "" {
	+ if _, ok := exitErr.(ErrorFormatter); ok {
	+ fmt.Fprintf(ErrWriter, "%+v\n", err)
	+ } else {
	+ fmt.Fprintln(ErrWriter, err)
	+ }
	+ }
	+ OsExiter(exitErr.ExitCode())
	+ return
	+ }
	+
	+ if multiErr, ok := err.(MultiError); ok {
	+ for _, merr := range multiErr.Errors {
	+ HandleExitCoder(merr)
	+ }
	+ return
	+ }
	+
	+ if err.Error() != "" {
	+ if _, ok := err.(ErrorFormatter); ok {
	+ fmt.Fprintf(ErrWriter, "%+v\n", err)
	+ } else {
	+ fmt.Fprintln(ErrWriter, err)
	+ }
	+ }
	+ OsExiter(1)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/errors_test.go b/src/gopkg.in/urfave/cli.v1/errors_test.go
	new file mode 100644
	index 0000000..131bd38
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/errors_test.go
	@@ -0,0 +1,157 @@
	+package cli
	+
	+import (
	+ "bytes"
	+ "errors"
	+ "fmt"
	+ "testing"
	+)
	+
	+func TestHandleExitCoder_nil(t *testing.T) {
	+ exitCode := 0
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ exitCode = rc
	+ called = true
	+ }
	+
	+ defer func() { OsExiter = fakeOsExiter }()
	+
	+ HandleExitCoder(nil)
	+
	+ expect(t, exitCode, 0)
	+ expect(t, called, false)
	+}
	+
	+func TestHandleExitCoder_ExitCoder(t *testing.T) {
	+ exitCode := 0
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ exitCode = rc
	+ called = true
	+ }
	+
	+ defer func() { OsExiter = fakeOsExiter }()
	+
	+ HandleExitCoder(NewExitError("galactic perimeter breach", 9))
	+
	+ expect(t, exitCode, 9)
	+ expect(t, called, true)
	+}
	+
	+func TestHandleExitCoder_MultiErrorWithExitCoder(t *testing.T) {
	+ exitCode := 0
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ exitCode = rc
	+ called = true
	+ }
	+
	+ defer func() { OsExiter = fakeOsExiter }()
	+
	+ exitErr := NewExitError("galactic perimeter breach", 9)
	+ err := NewMultiError(errors.New("wowsa"), errors.New("egad"), exitErr)
	+ HandleExitCoder(err)
	+
	+ expect(t, exitCode, 9)
	+ expect(t, called, true)
	+}
	+
	+func TestHandleExitCoder_ErrorWithMessage(t *testing.T) {
	+ exitCode := 0
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ exitCode = rc
	+ called = true
	+ }
	+ ErrWriter = &bytes.Buffer{}
	+
	+ defer func() {
	+ OsExiter = fakeOsExiter
	+ ErrWriter = fakeErrWriter
	+ }()
	+
	+ err := errors.New("gourd havens")
	+ HandleExitCoder(err)
	+
	+ expect(t, exitCode, 1)
	+ expect(t, called, true)
	+ expect(t, ErrWriter.(*bytes.Buffer).String(), "gourd havens\n")
	+}
	+
	+func TestHandleExitCoder_ErrorWithoutMessage(t *testing.T) {
	+ exitCode := 0
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ exitCode = rc
	+ called = true
	+ }
	+ ErrWriter = &bytes.Buffer{}
	+
	+ defer func() {
	+ OsExiter = fakeOsExiter
	+ ErrWriter = fakeErrWriter
	+ }()
	+
	+ err := errors.New("")
	+ HandleExitCoder(err)
	+
	+ expect(t, exitCode, 1)
	+ expect(t, called, true)
	+ expect(t, ErrWriter.(*bytes.Buffer).String(), "")
	+}
	+
	+// make a stub to not import pkg/errors
	+type ErrorWithFormat struct {
	+ error
	+}
	+
	+func NewErrorWithFormat(m string) *ErrorWithFormat {
	+ return &ErrorWithFormat{error: errors.New(m)}
	+}
	+
	+func (f *ErrorWithFormat) Format(s fmt.State, verb rune) {
	+ fmt.Fprintf(s, "This the format: %v", f.error)
	+}
	+
	+func TestHandleExitCoder_ErrorWithFormat(t *testing.T) {
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ called = true
	+ }
	+ ErrWriter = &bytes.Buffer{}
	+
	+ defer func() {
	+ OsExiter = fakeOsExiter
	+ ErrWriter = fakeErrWriter
	+ }()
	+
	+ err := NewErrorWithFormat("I am formatted")
	+ HandleExitCoder(err)
	+
	+ expect(t, called, true)
	+ expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: I am formatted\n")
	+}
	+
	+func TestHandleExitCoder_MultiErrorWithFormat(t *testing.T) {
	+ called := false
	+
	+ OsExiter = func(rc int) {
	+ called = true
	+ }
	+ ErrWriter = &bytes.Buffer{}
	+
	+ defer func() { OsExiter = fakeOsExiter }()
	+
	+ err := NewMultiError(NewErrorWithFormat("err1"), NewErrorWithFormat("err2"))
	+ HandleExitCoder(err)
	+
	+ expect(t, called, true)
	+ expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: err1\nThis the format: err2\n")
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/flag-types.json b/src/gopkg.in/urfave/cli.v1/flag-types.json
	new file mode 100644
	index 0000000..1223107
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/flag-types.json
	@@ -0,0 +1,93 @@
	+[
	+ {
	+ "name": "Bool",
	+ "type": "bool",
	+ "value": false,
	+ "context_default": "false",
	+ "parser": "strconv.ParseBool(f.Value.String())"
	+ },
	+ {
	+ "name": "BoolT",
	+ "type": "bool",
	+ "value": false,
	+ "doctail": " that is true by default",
	+ "context_default": "false",
	+ "parser": "strconv.ParseBool(f.Value.String())"
	+ },
	+ {
	+ "name": "Duration",
	+ "type": "time.Duration",
	+ "doctail": " (see https://golang.org/pkg/time/#ParseDuration)",
	+ "context_default": "0",
	+ "parser": "time.ParseDuration(f.Value.String())"
	+ },
	+ {
	+ "name": "Float64",
	+ "type": "float64",
	+ "context_default": "0",
	+ "parser": "strconv.ParseFloat(f.Value.String(), 64)"
	+ },
	+ {
	+ "name": "Generic",
	+ "type": "Generic",
	+ "dest": false,
	+ "context_default": "nil",
	+ "context_type": "interface{}"
	+ },
	+ {
	+ "name": "Int64",
	+ "type": "int64",
	+ "context_default": "0",
	+ "parser": "strconv.ParseInt(f.Value.String(), 0, 64)"
	+ },
	+ {
	+ "name": "Int",
	+ "type": "int",
	+ "context_default": "0",
	+ "parser": "strconv.ParseInt(f.Value.String(), 0, 64)",
	+ "parser_cast": "int(parsed)"
	+ },
	+ {
	+ "name": "IntSlice",
	+ "type": "*IntSlice",
	+ "dest": false,
	+ "context_default": "nil",
	+ "context_type": "[]int",
	+ "parser": "(f.Value.(*IntSlice)).Value(), error(nil)"
	+ },
	+ {
	+ "name": "Int64Slice",
	+ "type": "*Int64Slice",
	+ "dest": false,
	+ "context_default": "nil",
	+ "context_type": "[]int64",
	+ "parser": "(f.Value.(*Int64Slice)).Value(), error(nil)"
	+ },
	+ {
	+ "name": "String",
	+ "type": "string",
	+ "context_default": "\"\"",
	+ "parser": "f.Value.String(), error(nil)"
	+ },
	+ {
	+ "name": "StringSlice",
	+ "type": "*StringSlice",
	+ "dest": false,
	+ "context_default": "nil",
	+ "context_type": "[]string",
	+ "parser": "(f.Value.(*StringSlice)).Value(), error(nil)"
	+ },
	+ {
	+ "name": "Uint64",
	+ "type": "uint64",
	+ "context_default": "0",
	+ "parser": "strconv.ParseUint(f.Value.String(), 0, 64)"
	+ },
	+ {
	+ "name": "Uint",
	+ "type": "uint",
	+ "context_default": "0",
	+ "parser": "strconv.ParseUint(f.Value.String(), 0, 64)",
	+ "parser_cast": "uint(parsed)"
	+ }
	+]
	diff --git a/src/gopkg.in/urfave/cli.v1/flag.go b/src/gopkg.in/urfave/cli.v1/flag.go
	new file mode 100644
	index 0000000..7dd8a2c
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/flag.go
	@@ -0,0 +1,799 @@
	+package cli
	+
	+import (
	+ "flag"
	+ "fmt"
	+ "reflect"
	+ "runtime"
	+ "strconv"
	+ "strings"
	+ "syscall"
	+ "time"
	+)
	+
	+const defaultPlaceholder = "value"
	+
	+// BashCompletionFlag enables bash-completion for all commands and subcommands
	+var BashCompletionFlag = BoolFlag{
	+ Name: "generate-bash-completion",
	+ Hidden: true,
	+}
	+
	+// VersionFlag prints the version for the application
	+var VersionFlag = BoolFlag{
	+ Name: "version, v",
	+ Usage: "print the version",
	+}
	+
	+// HelpFlag prints the help for all commands and subcommands
	+// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
	+// unless HideHelp is set to true)
	+var HelpFlag = BoolFlag{
	+ Name: "help, h",
	+ Usage: "show help",
	+}
	+
	+// FlagStringer converts a flag definition to a string. This is used by help
	+// to display a flag.
	+var FlagStringer FlagStringFunc = stringifyFlag
	+
	+// FlagsByName is a slice of Flag.
	+type FlagsByName []Flag
	+
	+func (f FlagsByName) Len() int {
	+ return len(f)
	+}
	+
	+func (f FlagsByName) Less(i, j int) bool {
	+ return f[i].GetName() < f[j].GetName()
	+}
	+
	+func (f FlagsByName) Swap(i, j int) {
	+ f[i], f[j] = f[j], f[i]
	+}
	+
	+// Flag is a common interface related to parsing flags in cli.
	+// For more advanced flag parsing techniques, it is recommended that
	+// this interface be implemented.
	+type Flag interface {
	+ fmt.Stringer
	+ // Apply Flag settings to the given flag set
	+ Apply(*flag.FlagSet)
	+ GetName() string
	+}
	+
	+// errorableFlag is an interface that allows us to return errors during apply
	+// it allows flags defined in this library to return errors in a fashion backwards compatible
	+// TODO remove in v2 and modify the existing Flag interface to return errors
	+type errorableFlag interface {
	+ Flag
	+
	+ ApplyWithError(*flag.FlagSet) error
	+}
	+
	+func flagSet(name string, flags []Flag) (*flag.FlagSet, error) {
	+ set := flag.NewFlagSet(name, flag.ContinueOnError)
	+
	+ for _, f := range flags {
	+ //TODO remove in v2 when errorableFlag is removed
	+ if ef, ok := f.(errorableFlag); ok {
	+ if err := ef.ApplyWithError(set); err != nil {
	+ return nil, err
	+ }
	+ } else {
	+ f.Apply(set)
	+ }
	+ }
	+ return set, nil
	+}
	+
	+func eachName(longName string, fn func(string)) {
	+ parts := strings.Split(longName, ",")
	+ for _, name := range parts {
	+ name = strings.Trim(name, " ")
	+ fn(name)
	+ }
	+}
	+
	+// Generic is a generic parseable type identified by a specific flag
	+type Generic interface {
	+ Set(value string) error
	+ String() string
	+}
	+
	+// Apply takes the flagset and calls Set on the generic flag with the value
	+// provided by the user for parsing by the flag
	+// Ignores parsing errors
	+func (f GenericFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError takes the flagset and calls Set on the generic flag with the value
	+// provided by the user for parsing by the flag
	+func (f GenericFlag) ApplyWithError(set *flag.FlagSet) error {
	+ val := f.Value
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ if err := val.Set(envVal); err != nil {
	+ return fmt.Errorf("could not parse %s as value for flag %s: %s", envVal, f.Name, err)
	+ }
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ set.Var(f.Value, name, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// StringSlice is an opaque type for []string to satisfy flag.Value and flag.Getter
	+type StringSlice []string
	+
	+// Set appends the string value to the list of values
	+func (f *StringSlice) Set(value string) error {
	+ f = append(f, value)
	+ return nil
	+}
	+
	+// String returns a readable representation of this value (for usage defaults)
	+func (f *StringSlice) String() string {
	+ return fmt.Sprintf("%s", *f)
	+}
	+
	+// Value returns the slice of strings set by this flag
	+func (f *StringSlice) Value() []string {
	+ return *f
	+}
	+
	+// Get returns the slice of strings set by this flag
	+func (f *StringSlice) Get() interface{} {
	+ return *f
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f StringSliceFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f StringSliceFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ newVal := &StringSlice{}
	+ for _, s := range strings.Split(envVal, ",") {
	+ s = strings.TrimSpace(s)
	+ if err := newVal.Set(s); err != nil {
	+ return fmt.Errorf("could not parse %s as string value for flag %s: %s", envVal, f.Name, err)
	+ }
	+ }
	+ f.Value = newVal
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Value == nil {
	+ f.Value = &StringSlice{}
	+ }
	+ set.Var(f.Value, name, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// IntSlice is an opaque type for []int to satisfy flag.Value and flag.Getter
	+type IntSlice []int
	+
	+// Set parses the value into an integer and appends it to the list of values
	+func (f *IntSlice) Set(value string) error {
	+ tmp, err := strconv.Atoi(value)
	+ if err != nil {
	+ return err
	+ }
	+ f = append(f, tmp)
	+ return nil
	+}
	+
	+// String returns a readable representation of this value (for usage defaults)
	+func (f *IntSlice) String() string {
	+ return fmt.Sprintf("%#v", *f)
	+}
	+
	+// Value returns the slice of ints set by this flag
	+func (f *IntSlice) Value() []int {
	+ return *f
	+}
	+
	+// Get returns the slice of ints set by this flag
	+func (f *IntSlice) Get() interface{} {
	+ return *f
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f IntSliceFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f IntSliceFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ newVal := &IntSlice{}
	+ for _, s := range strings.Split(envVal, ",") {
	+ s = strings.TrimSpace(s)
	+ if err := newVal.Set(s); err != nil {
	+ return fmt.Errorf("could not parse %s as int slice value for flag %s: %s", envVal, f.Name, err)
	+ }
	+ }
	+ f.Value = newVal
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Value == nil {
	+ f.Value = &IntSlice{}
	+ }
	+ set.Var(f.Value, name, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Int64Slice is an opaque type for []int to satisfy flag.Value and flag.Getter
	+type Int64Slice []int64
	+
	+// Set parses the value into an integer and appends it to the list of values
	+func (f *Int64Slice) Set(value string) error {
	+ tmp, err := strconv.ParseInt(value, 10, 64)
	+ if err != nil {
	+ return err
	+ }
	+ f = append(f, tmp)
	+ return nil
	+}
	+
	+// String returns a readable representation of this value (for usage defaults)
	+func (f *Int64Slice) String() string {
	+ return fmt.Sprintf("%#v", *f)
	+}
	+
	+// Value returns the slice of ints set by this flag
	+func (f *Int64Slice) Value() []int64 {
	+ return *f
	+}
	+
	+// Get returns the slice of ints set by this flag
	+func (f *Int64Slice) Get() interface{} {
	+ return *f
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f Int64SliceFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ newVal := &Int64Slice{}
	+ for _, s := range strings.Split(envVal, ",") {
	+ s = strings.TrimSpace(s)
	+ if err := newVal.Set(s); err != nil {
	+ return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err)
	+ }
	+ }
	+ f.Value = newVal
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Value == nil {
	+ f.Value = &Int64Slice{}
	+ }
	+ set.Var(f.Value, name, f.Usage)
	+ })
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f BoolFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f BoolFlag) ApplyWithError(set *flag.FlagSet) error {
	+ val := false
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ if envVal == "" {
	+ val = false
	+ break
	+ }
	+
	+ envValBool, err := strconv.ParseBool(envVal)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ val = envValBool
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.BoolVar(f.Destination, name, val, f.Usage)
	+ return
	+ }
	+ set.Bool(name, val, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f BoolTFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f BoolTFlag) ApplyWithError(set *flag.FlagSet) error {
	+ val := true
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ if envVal == "" {
	+ val = false
	+ break
	+ }
	+
	+ envValBool, err := strconv.ParseBool(envVal)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ val = envValBool
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.BoolVar(f.Destination, name, val, f.Usage)
	+ return
	+ }
	+ set.Bool(name, val, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f StringFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f StringFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ f.Value = envVal
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.StringVar(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.String(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f IntFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f IntFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValInt, err := strconv.ParseInt(envVal, 0, 64)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
	+ }
	+ f.Value = int(envValInt)
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.IntVar(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Int(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f Int64Flag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f Int64Flag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValInt, err := strconv.ParseInt(envVal, 0, 64)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ f.Value = envValInt
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.Int64Var(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Int64(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f UintFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f UintFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValInt, err := strconv.ParseUint(envVal, 0, 64)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as uint value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ f.Value = uint(envValInt)
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.UintVar(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Uint(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f Uint64Flag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f Uint64Flag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValInt, err := strconv.ParseUint(envVal, 0, 64)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ f.Value = uint64(envValInt)
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.Uint64Var(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Uint64(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f DurationFlag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f DurationFlag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValDuration, err := time.ParseDuration(envVal)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as duration for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ f.Value = envValDuration
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.DurationVar(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Duration(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+// Apply populates the flag given the flag set and environment
	+// Ignores errors
	+func (f Float64Flag) Apply(set *flag.FlagSet) {
	+ f.ApplyWithError(set)
	+}
	+
	+// ApplyWithError populates the flag given the flag set and environment
	+func (f Float64Flag) ApplyWithError(set *flag.FlagSet) error {
	+ if f.EnvVar != "" {
	+ for _, envVar := range strings.Split(f.EnvVar, ",") {
	+ envVar = strings.TrimSpace(envVar)
	+ if envVal, ok := syscall.Getenv(envVar); ok {
	+ envValFloat, err := strconv.ParseFloat(envVal, 10)
	+ if err != nil {
	+ return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", envVal, f.Name, err)
	+ }
	+
	+ f.Value = float64(envValFloat)
	+ break
	+ }
	+ }
	+ }
	+
	+ eachName(f.Name, func(name string) {
	+ if f.Destination != nil {
	+ set.Float64Var(f.Destination, name, f.Value, f.Usage)
	+ return
	+ }
	+ set.Float64(name, f.Value, f.Usage)
	+ })
	+
	+ return nil
	+}
	+
	+func visibleFlags(fl []Flag) []Flag {
	+ visible := []Flag{}
	+ for _, flag := range fl {
	+ if !flagValue(flag).FieldByName("Hidden").Bool() {
	+ visible = append(visible, flag)
	+ }
	+ }
	+ return visible
	+}
	+
	+func prefixFor(name string) (prefix string) {
	+ if len(name) == 1 {
	+ prefix = "-"
	+ } else {
	+ prefix = "--"
	+ }
	+
	+ return
	+}
	+
	+// Returns the placeholder, if any, and the unquoted usage string.
	+func unquoteUsage(usage string) (string, string) {
	+ for i := 0; i < len(usage); i++ {
	+ if usage[i] == '`' {
	+ for j := i + 1; j < len(usage); j++ {
	+ if usage[j] == '`' {
	+ name := usage[i+1 : j]
	+ usage = usage[:i] + name + usage[j+1:]
	+ return name, usage
	+ }
	+ }
	+ break
	+ }
	+ }
	+ return "", usage
	+}
	+
	+func prefixedNames(fullName, placeholder string) string {
	+ var prefixed string
	+ parts := strings.Split(fullName, ",")
	+ for i, name := range parts {
	+ name = strings.Trim(name, " ")
	+ prefixed += prefixFor(name) + name
	+ if placeholder != "" {
	+ prefixed += " " + placeholder
	+ }
	+ if i < len(parts)-1 {
	+ prefixed += ", "
	+ }
	+ }
	+ return prefixed
	+}
	+
	+func withEnvHint(envVar, str string) string {
	+ envText := ""
	+ if envVar != "" {
	+ prefix := "$"
	+ suffix := ""
	+ sep := ", $"
	+ if runtime.GOOS == "windows" {
	+ prefix = "%"
	+ suffix = "%"
	+ sep = "%, %"
	+ }
	+ envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(strings.Split(envVar, ","), sep), suffix)
	+ }
	+ return str + envText
	+}
	+
	+func flagValue(f Flag) reflect.Value {
	+ fv := reflect.ValueOf(f)
	+ for fv.Kind() == reflect.Ptr {
	+ fv = reflect.Indirect(fv)
	+ }
	+ return fv
	+}
	+
	+func stringifyFlag(f Flag) string {
	+ fv := flagValue(f)
	+
	+ switch f.(type) {
	+ case IntSliceFlag:
	+ return withEnvHint(fv.FieldByName("EnvVar").String(),
	+ stringifyIntSliceFlag(f.(IntSliceFlag)))
	+ case Int64SliceFlag:
	+ return withEnvHint(fv.FieldByName("EnvVar").String(),
	+ stringifyInt64SliceFlag(f.(Int64SliceFlag)))
	+ case StringSliceFlag:
	+ return withEnvHint(fv.FieldByName("EnvVar").String(),
	+ stringifyStringSliceFlag(f.(StringSliceFlag)))
	+ }
	+
	+ placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
	+
	+ needsPlaceholder := false
	+ defaultValueString := ""
	+ val := fv.FieldByName("Value")
	+
	+ if val.IsValid() {
	+ needsPlaceholder = true
	+ defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
	+
	+ if val.Kind() == reflect.String && val.String() != "" {
	+ defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
	+ }
	+ }
	+
	+ if defaultValueString == " (default: )" {
	+ defaultValueString = ""
	+ }
	+
	+ if needsPlaceholder && placeholder == "" {
	+ placeholder = defaultPlaceholder
	+ }
	+
	+ usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
	+
	+ return withEnvHint(fv.FieldByName("EnvVar").String(),
	+ fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
	+}
	+
	+func stringifyIntSliceFlag(f IntSliceFlag) string {
	+ defaultVals := []string{}
	+ if f.Value != nil && len(f.Value.Value()) > 0 {
	+ for _, i := range f.Value.Value() {
	+ defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
	+ }
	+ }
	+
	+ return stringifySliceFlag(f.Usage, f.Name, defaultVals)
	+}
	+
	+func stringifyInt64SliceFlag(f Int64SliceFlag) string {
	+ defaultVals := []string{}
	+ if f.Value != nil && len(f.Value.Value()) > 0 {
	+ for _, i := range f.Value.Value() {
	+ defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
	+ }
	+ }
	+
	+ return stringifySliceFlag(f.Usage, f.Name, defaultVals)
	+}
	+
	+func stringifyStringSliceFlag(f StringSliceFlag) string {
	+ defaultVals := []string{}
	+ if f.Value != nil && len(f.Value.Value()) > 0 {
	+ for _, s := range f.Value.Value() {
	+ if len(s) > 0 {
	+ defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
	+ }
	+ }
	+ }
	+
	+ return stringifySliceFlag(f.Usage, f.Name, defaultVals)
	+}
	+
	+func stringifySliceFlag(usage, name string, defaultVals []string) string {
	+ placeholder, usage := unquoteUsage(usage)
	+ if placeholder == "" {
	+ placeholder = defaultPlaceholder
	+ }
	+
	+ defaultVal := ""
	+ if len(defaultVals) > 0 {
	+ defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
	+ }
	+
	+ usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
	+ return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/flag_generated.go b/src/gopkg.in/urfave/cli.v1/flag_generated.go
	new file mode 100644
	index 0000000..491b619
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/flag_generated.go
	@@ -0,0 +1,627 @@
	+package cli
	+
	+import (
	+ "flag"
	+ "strconv"
	+ "time"
	+)
	+
	+// WARNING: This file is generated!
	+
	+// BoolFlag is a flag with type bool
	+type BoolFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Destination *bool
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f BoolFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f BoolFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Bool looks up the value of a local BoolFlag, returns
	+// false if not found
	+func (c *Context) Bool(name string) bool {
	+ return lookupBool(name, c.flagSet)
	+}
	+
	+// GlobalBool looks up the value of a global BoolFlag, returns
	+// false if not found
	+func (c *Context) GlobalBool(name string) bool {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupBool(name, fs)
	+ }
	+ return false
	+}
	+
	+func lookupBool(name string, set *flag.FlagSet) bool {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseBool(f.Value.String())
	+ if err != nil {
	+ return false
	+ }
	+ return parsed
	+ }
	+ return false
	+}
	+
	+// BoolTFlag is a flag with type bool that is true by default
	+type BoolTFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Destination *bool
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f BoolTFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f BoolTFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// BoolT looks up the value of a local BoolTFlag, returns
	+// false if not found
	+func (c *Context) BoolT(name string) bool {
	+ return lookupBoolT(name, c.flagSet)
	+}
	+
	+// GlobalBoolT looks up the value of a global BoolTFlag, returns
	+// false if not found
	+func (c *Context) GlobalBoolT(name string) bool {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupBoolT(name, fs)
	+ }
	+ return false
	+}
	+
	+func lookupBoolT(name string, set *flag.FlagSet) bool {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseBool(f.Value.String())
	+ if err != nil {
	+ return false
	+ }
	+ return parsed
	+ }
	+ return false
	+}
	+
	+// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
	+type DurationFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value time.Duration
	+ Destination *time.Duration
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f DurationFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f DurationFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Duration looks up the value of a local DurationFlag, returns
	+// 0 if not found
	+func (c *Context) Duration(name string) time.Duration {
	+ return lookupDuration(name, c.flagSet)
	+}
	+
	+// GlobalDuration looks up the value of a global DurationFlag, returns
	+// 0 if not found
	+func (c *Context) GlobalDuration(name string) time.Duration {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupDuration(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := time.ParseDuration(f.Value.String())
	+ if err != nil {
	+ return 0
	+ }
	+ return parsed
	+ }
	+ return 0
	+}
	+
	+// Float64Flag is a flag with type float64
	+type Float64Flag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value float64
	+ Destination *float64
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f Float64Flag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f Float64Flag) GetName() string {
	+ return f.Name
	+}
	+
	+// Float64 looks up the value of a local Float64Flag, returns
	+// 0 if not found
	+func (c *Context) Float64(name string) float64 {
	+ return lookupFloat64(name, c.flagSet)
	+}
	+
	+// GlobalFloat64 looks up the value of a global Float64Flag, returns
	+// 0 if not found
	+func (c *Context) GlobalFloat64(name string) float64 {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupFloat64(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupFloat64(name string, set *flag.FlagSet) float64 {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseFloat(f.Value.String(), 64)
	+ if err != nil {
	+ return 0
	+ }
	+ return parsed
	+ }
	+ return 0
	+}
	+
	+// GenericFlag is a flag with type Generic
	+type GenericFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value Generic
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f GenericFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f GenericFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Generic looks up the value of a local GenericFlag, returns
	+// nil if not found
	+func (c *Context) Generic(name string) interface{} {
	+ return lookupGeneric(name, c.flagSet)
	+}
	+
	+// GlobalGeneric looks up the value of a global GenericFlag, returns
	+// nil if not found
	+func (c *Context) GlobalGeneric(name string) interface{} {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupGeneric(name, fs)
	+ }
	+ return nil
	+}
	+
	+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := f.Value, error(nil)
	+ if err != nil {
	+ return nil
	+ }
	+ return parsed
	+ }
	+ return nil
	+}
	+
	+// Int64Flag is a flag with type int64
	+type Int64Flag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value int64
	+ Destination *int64
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f Int64Flag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f Int64Flag) GetName() string {
	+ return f.Name
	+}
	+
	+// Int64 looks up the value of a local Int64Flag, returns
	+// 0 if not found
	+func (c *Context) Int64(name string) int64 {
	+ return lookupInt64(name, c.flagSet)
	+}
	+
	+// GlobalInt64 looks up the value of a global Int64Flag, returns
	+// 0 if not found
	+func (c *Context) GlobalInt64(name string) int64 {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupInt64(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupInt64(name string, set *flag.FlagSet) int64 {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
	+ if err != nil {
	+ return 0
	+ }
	+ return parsed
	+ }
	+ return 0
	+}
	+
	+// IntFlag is a flag with type int
	+type IntFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value int
	+ Destination *int
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f IntFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f IntFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Int looks up the value of a local IntFlag, returns
	+// 0 if not found
	+func (c *Context) Int(name string) int {
	+ return lookupInt(name, c.flagSet)
	+}
	+
	+// GlobalInt looks up the value of a global IntFlag, returns
	+// 0 if not found
	+func (c *Context) GlobalInt(name string) int {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupInt(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupInt(name string, set *flag.FlagSet) int {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
	+ if err != nil {
	+ return 0
	+ }
	+ return int(parsed)
	+ }
	+ return 0
	+}
	+
	+// IntSliceFlag is a flag with type *IntSlice
	+type IntSliceFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value *IntSlice
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f IntSliceFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f IntSliceFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// IntSlice looks up the value of a local IntSliceFlag, returns
	+// nil if not found
	+func (c *Context) IntSlice(name string) []int {
	+ return lookupIntSlice(name, c.flagSet)
	+}
	+
	+// GlobalIntSlice looks up the value of a global IntSliceFlag, returns
	+// nil if not found
	+func (c *Context) GlobalIntSlice(name string) []int {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupIntSlice(name, fs)
	+ }
	+ return nil
	+}
	+
	+func lookupIntSlice(name string, set *flag.FlagSet) []int {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := (f.Value.(*IntSlice)).Value(), error(nil)
	+ if err != nil {
	+ return nil
	+ }
	+ return parsed
	+ }
	+ return nil
	+}
	+
	+// Int64SliceFlag is a flag with type *Int64Slice
	+type Int64SliceFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value *Int64Slice
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f Int64SliceFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f Int64SliceFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Int64Slice looks up the value of a local Int64SliceFlag, returns
	+// nil if not found
	+func (c *Context) Int64Slice(name string) []int64 {
	+ return lookupInt64Slice(name, c.flagSet)
	+}
	+
	+// GlobalInt64Slice looks up the value of a global Int64SliceFlag, returns
	+// nil if not found
	+func (c *Context) GlobalInt64Slice(name string) []int64 {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupInt64Slice(name, fs)
	+ }
	+ return nil
	+}
	+
	+func lookupInt64Slice(name string, set *flag.FlagSet) []int64 {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil)
	+ if err != nil {
	+ return nil
	+ }
	+ return parsed
	+ }
	+ return nil
	+}
	+
	+// StringFlag is a flag with type string
	+type StringFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value string
	+ Destination *string
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f StringFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f StringFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// String looks up the value of a local StringFlag, returns
	+// "" if not found
	+func (c *Context) String(name string) string {
	+ return lookupString(name, c.flagSet)
	+}
	+
	+// GlobalString looks up the value of a global StringFlag, returns
	+// "" if not found
	+func (c *Context) GlobalString(name string) string {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupString(name, fs)
	+ }
	+ return ""
	+}
	+
	+func lookupString(name string, set *flag.FlagSet) string {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := f.Value.String(), error(nil)
	+ if err != nil {
	+ return ""
	+ }
	+ return parsed
	+ }
	+ return ""
	+}
	+
	+// StringSliceFlag is a flag with type *StringSlice
	+type StringSliceFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value *StringSlice
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f StringSliceFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f StringSliceFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// StringSlice looks up the value of a local StringSliceFlag, returns
	+// nil if not found
	+func (c *Context) StringSlice(name string) []string {
	+ return lookupStringSlice(name, c.flagSet)
	+}
	+
	+// GlobalStringSlice looks up the value of a global StringSliceFlag, returns
	+// nil if not found
	+func (c *Context) GlobalStringSlice(name string) []string {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupStringSlice(name, fs)
	+ }
	+ return nil
	+}
	+
	+func lookupStringSlice(name string, set *flag.FlagSet) []string {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
	+ if err != nil {
	+ return nil
	+ }
	+ return parsed
	+ }
	+ return nil
	+}
	+
	+// Uint64Flag is a flag with type uint64
	+type Uint64Flag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value uint64
	+ Destination *uint64
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f Uint64Flag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f Uint64Flag) GetName() string {
	+ return f.Name
	+}
	+
	+// Uint64 looks up the value of a local Uint64Flag, returns
	+// 0 if not found
	+func (c *Context) Uint64(name string) uint64 {
	+ return lookupUint64(name, c.flagSet)
	+}
	+
	+// GlobalUint64 looks up the value of a global Uint64Flag, returns
	+// 0 if not found
	+func (c *Context) GlobalUint64(name string) uint64 {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupUint64(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupUint64(name string, set *flag.FlagSet) uint64 {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
	+ if err != nil {
	+ return 0
	+ }
	+ return parsed
	+ }
	+ return 0
	+}
	+
	+// UintFlag is a flag with type uint
	+type UintFlag struct {
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ Value uint
	+ Destination *uint
	+}
	+
	+// String returns a readable representation of this value
	+// (for usage defaults)
	+func (f UintFlag) String() string {
	+ return FlagStringer(f)
	+}
	+
	+// GetName returns the name of the flag
	+func (f UintFlag) GetName() string {
	+ return f.Name
	+}
	+
	+// Uint looks up the value of a local UintFlag, returns
	+// 0 if not found
	+func (c *Context) Uint(name string) uint {
	+ return lookupUint(name, c.flagSet)
	+}
	+
	+// GlobalUint looks up the value of a global UintFlag, returns
	+// 0 if not found
	+func (c *Context) GlobalUint(name string) uint {
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
	+ return lookupUint(name, fs)
	+ }
	+ return 0
	+}
	+
	+func lookupUint(name string, set *flag.FlagSet) uint {
	+ f := set.Lookup(name)
	+ if f != nil {
	+ parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
	+ if err != nil {
	+ return 0
	+ }
	+ return uint(parsed)
	+ }
	+ return 0
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/flag_test.go b/src/gopkg.in/urfave/cli.v1/flag_test.go
	new file mode 100644
	index 0000000..0dd8654
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/flag_test.go
	@@ -0,0 +1,1203 @@
	+package cli
	+
	+import (
	+ "fmt"
	+ "os"
	+ "reflect"
	+ "runtime"
	+ "strings"
	+ "testing"
	+ "time"
	+)
	+
	+var boolFlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"help", "--help\t"},
	+ {"h", "-h\t"},
	+}
	+
	+func TestBoolFlagHelpOutput(t *testing.T) {
	+ for _, test := range boolFlagTests {
	+ flag := BoolFlag{Name: test.name}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestFlagsFromEnv(t *testing.T) {
	+ var flagTests = []struct {
	+ input string
	+ output interface{}
	+ flag Flag
	+ err error
	+ }{
	+ {"", false, BoolFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"1", true, BoolFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"false", false, BoolFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"foobar", true, BoolFlag{Name: "debug", EnvVar: "DEBUG"}, fmt.Errorf(`could not parse foobar as bool value for flag debug: strconv.ParseBool: parsing "foobar": invalid syntax`)},
	+
	+ {"", false, BoolTFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"1", true, BoolTFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"false", false, BoolTFlag{Name: "debug", EnvVar: "DEBUG"}, nil},
	+ {"foobar", true, BoolTFlag{Name: "debug", EnvVar: "DEBUG"}, fmt.Errorf(`could not parse foobar as bool value for flag debug: strconv.ParseBool: parsing "foobar": invalid syntax`)},
	+
	+ {"1s", 1 * time.Second, DurationFlag{Name: "time", EnvVar: "TIME"}, nil},
	+ {"foobar", false, DurationFlag{Name: "time", EnvVar: "TIME"}, fmt.Errorf(`could not parse foobar as duration for flag time: time: invalid duration foobar`)},
	+
	+ {"1.2", 1.2, Float64Flag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1", 1.0, Float64Flag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"foobar", 0, Float64Flag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as float64 value for flag seconds: strconv.ParseFloat: parsing "foobar": invalid syntax`)},
	+
	+ {"1", int64(1), Int64Flag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2", 0, Int64Flag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2 as int value for flag seconds: strconv.ParseInt: parsing "1.2": invalid syntax`)},
	+ {"foobar", 0, Int64Flag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as int value for flag seconds: strconv.ParseInt: parsing "foobar": invalid syntax`)},
	+
	+ {"1", 1, IntFlag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2", 0, IntFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2 as int value for flag seconds: strconv.ParseInt: parsing "1.2": invalid syntax`)},
	+ {"foobar", 0, IntFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as int value for flag seconds: strconv.ParseInt: parsing "foobar": invalid syntax`)},
	+
	+ {"1,2", IntSlice{1, 2}, IntSliceFlag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2,2", IntSlice{}, IntSliceFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2,2 as int slice value for flag seconds: strconv.ParseInt: parsing "1.2": invalid syntax`)},
	+ {"foobar", IntSlice{}, IntSliceFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as int slice value for flag seconds: strconv.ParseInt: parsing "foobar": invalid syntax`)},
	+
	+ {"1,2", Int64Slice{1, 2}, Int64SliceFlag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2,2", Int64Slice{}, Int64SliceFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2,2 as int64 slice value for flag seconds: strconv.ParseInt: parsing "1.2": invalid syntax`)},
	+ {"foobar", Int64Slice{}, Int64SliceFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as int64 slice value for flag seconds: strconv.ParseInt: parsing "foobar": invalid syntax`)},
	+
	+ {"foo", "foo", StringFlag{Name: "name", EnvVar: "NAME"}, nil},
	+
	+ {"foo,bar", StringSlice{"foo", "bar"}, StringSliceFlag{Name: "names", EnvVar: "NAMES"}, nil},
	+
	+ {"1", uint(1), UintFlag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2", 0, UintFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2 as uint value for flag seconds: strconv.ParseUint: parsing "1.2": invalid syntax`)},
	+ {"foobar", 0, UintFlag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as uint value for flag seconds: strconv.ParseUint: parsing "foobar": invalid syntax`)},
	+
	+ {"1", uint64(1), Uint64Flag{Name: "seconds", EnvVar: "SECONDS"}, nil},
	+ {"1.2", 0, Uint64Flag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse 1.2 as uint64 value for flag seconds: strconv.ParseUint: parsing "1.2": invalid syntax`)},
	+ {"foobar", 0, Uint64Flag{Name: "seconds", EnvVar: "SECONDS"}, fmt.Errorf(`could not parse foobar as uint64 value for flag seconds: strconv.ParseUint: parsing "foobar": invalid syntax`)},
	+
	+ {"foo,bar", &Parser{"foo", "bar"}, GenericFlag{Name: "names", Value: &Parser{}, EnvVar: "NAMES"}, nil},
	+ }
	+
	+ for _, test := range flagTests {
	+ os.Clearenv()
	+ os.Setenv(reflect.ValueOf(test.flag).FieldByName("EnvVar").String(), test.input)
	+ a := App{
	+ Flags: []Flag{test.flag},
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.value(test.flag.GetName()), test.output) {
	+ t.Errorf("expected %+v to be parsed as %+v, instead was %+v", test.input, test.output, ctx.value(test.flag.GetName()))
	+ }
	+ return nil
	+ },
	+ }
	+
	+ err := a.Run([]string{"run"})
	+ if !reflect.DeepEqual(test.err, err) {
	+ t.Errorf("expected error %s, got error %s", test.err, err)
	+ }
	+ }
	+}
	+
	+var stringFlagTests = []struct {
	+ name string
	+ usage string
	+ value string
	+ expected string
	+}{
	+ {"foo", "", "", "--foo value\t"},
	+ {"f", "", "", "-f value\t"},
	+ {"f", "The total `foo` desired", "all", "-f foo\tThe total foo desired (default: \"all\")"},
	+ {"test", "", "Something", "--test value\t(default: \"Something\")"},
	+ {"config,c", "Load configuration from `FILE`", "", "--config FILE, -c FILE\tLoad configuration from FILE"},
	+ {"config,c", "Load configuration from `CONFIG`", "config.json", "--config CONFIG, -c CONFIG\tLoad configuration from CONFIG (default: \"config.json\")"},
	+}
	+
	+func TestStringFlagHelpOutput(t *testing.T) {
	+ for _, test := range stringFlagTests {
	+ flag := StringFlag{Name: test.name, Usage: test.usage, Value: test.value}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_FOO", "derp")
	+ for _, test := range stringFlagTests {
	+ flag := StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_FOO]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_FOO%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var stringSliceFlagTests = []struct {
	+ name string
	+ value *StringSlice
	+ expected string
	+}{
	+ {"foo", func() *StringSlice {
	+ s := &StringSlice{}
	+ s.Set("")
	+ return s
	+ }(), "--foo value\t"},
	+ {"f", func() *StringSlice {
	+ s := &StringSlice{}
	+ s.Set("")
	+ return s
	+ }(), "-f value\t"},
	+ {"f", func() *StringSlice {
	+ s := &StringSlice{}
	+ s.Set("Lipstick")
	+ return s
	+ }(), "-f value\t(default: \"Lipstick\")"},
	+ {"test", func() *StringSlice {
	+ s := &StringSlice{}
	+ s.Set("Something")
	+ return s
	+ }(), "--test value\t(default: \"Something\")"},
	+}
	+
	+func TestStringSliceFlagHelpOutput(t *testing.T) {
	+ for _, test := range stringSliceFlagTests {
	+ flag := StringSliceFlag{Name: test.name, Value: test.value}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_QWWX", "11,4")
	+ for _, test := range stringSliceFlagTests {
	+ flag := StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_QWWX]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_QWWX%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%q does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var intFlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"hats", "--hats value\t(default: 9)"},
	+ {"H", "-H value\t(default: 9)"},
	+}
	+
	+func TestIntFlagHelpOutput(t *testing.T) {
	+ for _, test := range intFlagTests {
	+ flag := IntFlag{Name: test.name, Value: 9}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%s does not match %s", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAR", "2")
	+ for _, test := range intFlagTests {
	+ flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAR]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAR%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var int64FlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"hats", "--hats value\t(default: 8589934592)"},
	+ {"H", "-H value\t(default: 8589934592)"},
	+}
	+
	+func TestInt64FlagHelpOutput(t *testing.T) {
	+ for _, test := range int64FlagTests {
	+ flag := Int64Flag{Name: test.name, Value: 8589934592}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%s does not match %s", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestInt64FlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAR", "2")
	+ for _, test := range int64FlagTests {
	+ flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAR]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAR%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var uintFlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"nerfs", "--nerfs value\t(default: 41)"},
	+ {"N", "-N value\t(default: 41)"},
	+}
	+
	+func TestUintFlagHelpOutput(t *testing.T) {
	+ for _, test := range uintFlagTests {
	+ flag := UintFlag{Name: test.name, Value: 41}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%s does not match %s", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestUintFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAR", "2")
	+ for _, test := range uintFlagTests {
	+ flag := UintFlag{Name: test.name, EnvVar: "APP_BAR"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAR]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAR%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var uint64FlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"gerfs", "--gerfs value\t(default: 8589934582)"},
	+ {"G", "-G value\t(default: 8589934582)"},
	+}
	+
	+func TestUint64FlagHelpOutput(t *testing.T) {
	+ for _, test := range uint64FlagTests {
	+ flag := Uint64Flag{Name: test.name, Value: 8589934582}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%s does not match %s", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestUint64FlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAR", "2")
	+ for _, test := range uint64FlagTests {
	+ flag := UintFlag{Name: test.name, EnvVar: "APP_BAR"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAR]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAR%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var durationFlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"hooting", "--hooting value\t(default: 1s)"},
	+ {"H", "-H value\t(default: 1s)"},
	+}
	+
	+func TestDurationFlagHelpOutput(t *testing.T) {
	+ for _, test := range durationFlagTests {
	+ flag := DurationFlag{Name: test.name, Value: 1 * time.Second}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAR", "2h3m6s")
	+ for _, test := range durationFlagTests {
	+ flag := DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAR]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAR%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var intSliceFlagTests = []struct {
	+ name string
	+ value *IntSlice
	+ expected string
	+}{
	+ {"heads", &IntSlice{}, "--heads value\t"},
	+ {"H", &IntSlice{}, "-H value\t"},
	+ {"H, heads", func() *IntSlice {
	+ i := &IntSlice{}
	+ i.Set("9")
	+ i.Set("3")
	+ return i
	+ }(), "-H value, --heads value\t(default: 9, 3)"},
	+}
	+
	+func TestIntSliceFlagHelpOutput(t *testing.T) {
	+ for _, test := range intSliceFlagTests {
	+ flag := IntSliceFlag{Name: test.name, Value: test.value}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_SMURF", "42,3")
	+ for _, test := range intSliceFlagTests {
	+ flag := IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_SMURF]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_SMURF%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%q does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var int64SliceFlagTests = []struct {
	+ name string
	+ value *Int64Slice
	+ expected string
	+}{
	+ {"heads", &Int64Slice{}, "--heads value\t"},
	+ {"H", &Int64Slice{}, "-H value\t"},
	+ {"H, heads", func() *Int64Slice {
	+ i := &Int64Slice{}
	+ i.Set("2")
	+ i.Set("17179869184")
	+ return i
	+ }(), "-H value, --heads value\t(default: 2, 17179869184)"},
	+}
	+
	+func TestInt64SliceFlagHelpOutput(t *testing.T) {
	+ for _, test := range int64SliceFlagTests {
	+ flag := Int64SliceFlag{Name: test.name, Value: test.value}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestInt64SliceFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_SMURF", "42,17179869184")
	+ for _, test := range int64SliceFlagTests {
	+ flag := Int64SliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_SMURF]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_SMURF%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%q does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var float64FlagTests = []struct {
	+ name string
	+ expected string
	+}{
	+ {"hooting", "--hooting value\t(default: 0.1)"},
	+ {"H", "-H value\t(default: 0.1)"},
	+}
	+
	+func TestFloat64FlagHelpOutput(t *testing.T) {
	+ for _, test := range float64FlagTests {
	+ flag := Float64Flag{Name: test.name, Value: float64(0.1)}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_BAZ", "99.4")
	+ for _, test := range float64FlagTests {
	+ flag := Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_BAZ]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_BAZ%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+var genericFlagTests = []struct {
	+ name string
	+ value Generic
	+ expected string
	+}{
	+ {"toads", &Parser{"abc", "def"}, "--toads value\ttest flag (default: abc,def)"},
	+ {"t", &Parser{"abc", "def"}, "-t value\ttest flag (default: abc,def)"},
	+}
	+
	+func TestGenericFlagHelpOutput(t *testing.T) {
	+ for _, test := range genericFlagTests {
	+ flag := GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
	+ output := flag.String()
	+
	+ if output != test.expected {
	+ t.Errorf("%q does not match %q", output, test.expected)
	+ }
	+ }
	+}
	+
	+func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_ZAP", "3")
	+ for _, test := range genericFlagTests {
	+ flag := GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
	+ output := flag.String()
	+
	+ expectedSuffix := " [$APP_ZAP]"
	+ if runtime.GOOS == "windows" {
	+ expectedSuffix = " [%APP_ZAP%]"
	+ }
	+ if !strings.HasSuffix(output, expectedSuffix) {
	+ t.Errorf("%s does not end with"+expectedSuffix, output)
	+ }
	+ }
	+}
	+
	+func TestParseMultiString(t *testing.T) {
	+ (&App{
	+ Flags: []Flag{
	+ StringFlag{Name: "serve, s"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.String("serve") != "10" {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.String("s") != "10" {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run", "-s", "10"})
	+}
	+
	+func TestParseDestinationString(t *testing.T) {
	+ var dest string
	+ a := App{
	+ Flags: []Flag{
	+ StringFlag{
	+ Name: "dest",
	+ Destination: &dest,
	+ },
	+ },
	+ Action: func(ctx *Context) error {
	+ if dest != "10" {
	+ t.Errorf("expected destination String 10")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--dest", "10"})
	+}
	+
	+func TestParseMultiStringFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_COUNT", "20")
	+ (&App{
	+ Flags: []Flag{
	+ StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.String("count") != "20" {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.String("c") != "20" {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiStringFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_COUNT", "20")
	+ (&App{
	+ Flags: []Flag{
	+ StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.String("count") != "20" {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.String("c") != "20" {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiStringSlice(t *testing.T) {
	+ (&App{
	+ Flags: []Flag{
	+ StringSliceFlag{Name: "serve, s", Value: &StringSlice{}},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
	+ t.Errorf("main name not set")
	+ }
	+ if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run", "-s", "10", "-s", "20"})
	+}
	+
	+func TestParseMultiStringSliceFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,40")
	+
	+ (&App{
	+ Flags: []Flag{
	+ StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,40")
	+
	+ (&App{
	+ Flags: []Flag{
	+ StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiInt(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ IntFlag{Name: "serve, s"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Int("serve") != 10 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Int("s") != 10 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "-s", "10"})
	+}
	+
	+func TestParseDestinationInt(t *testing.T) {
	+ var dest int
	+ a := App{
	+ Flags: []Flag{
	+ IntFlag{
	+ Name: "dest",
	+ Destination: &dest,
	+ },
	+ },
	+ Action: func(ctx *Context) error {
	+ if dest != 10 {
	+ t.Errorf("expected destination Int 10")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--dest", "10"})
	+}
	+
	+func TestParseMultiIntFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "10")
	+ a := App{
	+ Flags: []Flag{
	+ IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Int("timeout") != 10 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Int("t") != 10 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiIntFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "10")
	+ a := App{
	+ Flags: []Flag{
	+ IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Int("timeout") != 10 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Int("t") != 10 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiIntSlice(t *testing.T) {
	+ (&App{
	+ Flags: []Flag{
	+ IntSliceFlag{Name: "serve, s", Value: &IntSlice{}},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
	+ t.Errorf("main name not set")
	+ }
	+ if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run", "-s", "10", "-s", "20"})
	+}
	+
	+func TestParseMultiIntSliceFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,40")
	+
	+ (&App{
	+ Flags: []Flag{
	+ IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,40")
	+
	+ (&App{
	+ Flags: []Flag{
	+ IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiInt64Slice(t *testing.T) {
	+ (&App{
	+ Flags: []Flag{
	+ Int64SliceFlag{Name: "serve, s", Value: &Int64Slice{}},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Int64Slice("serve"), []int64{10, 17179869184}) {
	+ t.Errorf("main name not set")
	+ }
	+ if !reflect.DeepEqual(ctx.Int64Slice("s"), []int64{10, 17179869184}) {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run", "-s", "10", "-s", "17179869184"})
	+}
	+
	+func TestParseMultiInt64SliceFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,17179869184")
	+
	+ (&App{
	+ Flags: []Flag{
	+ Int64SliceFlag{Name: "intervals, i", Value: &Int64Slice{}, EnvVar: "APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Int64Slice("intervals"), []int64{20, 30, 17179869184}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.Int64Slice("i"), []int64{20, 30, 17179869184}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiInt64SliceFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_INTERVALS", "20,30,17179869184")
	+
	+ (&App{
	+ Flags: []Flag{
	+ Int64SliceFlag{Name: "intervals, i", Value: &Int64Slice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Int64Slice("intervals"), []int64{20, 30, 17179869184}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.Int64Slice("i"), []int64{20, 30, 17179869184}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }).Run([]string{"run"})
	+}
	+
	+func TestParseMultiFloat64(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{Name: "serve, s"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Float64("serve") != 10.2 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Float64("s") != 10.2 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "-s", "10.2"})
	+}
	+
	+func TestParseDestinationFloat64(t *testing.T) {
	+ var dest float64
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{
	+ Name: "dest",
	+ Destination: &dest,
	+ },
	+ },
	+ Action: func(ctx *Context) error {
	+ if dest != 10.2 {
	+ t.Errorf("expected destination Float64 10.2")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--dest", "10.2"})
	+}
	+
	+func TestParseMultiFloat64FromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Float64("timeout") != 15.5 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Float64("t") != 15.5 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
	+ a := App{
	+ Flags: []Flag{
	+ Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Float64("timeout") != 15.5 {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Float64("t") != 15.5 {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiBool(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ BoolFlag{Name: "serve, s"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("serve") != true {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.Bool("s") != true {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--serve"})
	+}
	+
	+func TestParseDestinationBool(t *testing.T) {
	+ var dest bool
	+ a := App{
	+ Flags: []Flag{
	+ BoolFlag{
	+ Name: "dest",
	+ Destination: &dest,
	+ },
	+ },
	+ Action: func(ctx *Context) error {
	+ if dest != true {
	+ t.Errorf("expected destination Bool true")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--dest"})
	+}
	+
	+func TestParseMultiBoolFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_DEBUG", "1")
	+ a := App{
	+ Flags: []Flag{
	+ BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("debug") != true {
	+ t.Errorf("main name not set from env")
	+ }
	+ if ctx.Bool("d") != true {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiBoolFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_DEBUG", "1")
	+ a := App{
	+ Flags: []Flag{
	+ BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("debug") != true {
	+ t.Errorf("main name not set from env")
	+ }
	+ if ctx.Bool("d") != true {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseBoolTFromEnv(t *testing.T) {
	+ var boolTFlagTests = []struct {
	+ input string
	+ output bool
	+ }{
	+ {"", false},
	+ {"1", true},
	+ {"false", false},
	+ {"true", true},
	+ }
	+
	+ for _, test := range boolTFlagTests {
	+ os.Clearenv()
	+ os.Setenv("DEBUG", test.input)
	+ a := App{
	+ Flags: []Flag{
	+ BoolTFlag{Name: "debug, d", EnvVar: "DEBUG"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("debug") != test.output {
	+ t.Errorf("expected %+v to be parsed as %+v, instead was %+v", test.input, test.output, ctx.Bool("debug"))
	+ }
	+ if ctx.Bool("d") != test.output {
	+ t.Errorf("expected %+v to be parsed as %+v, instead was %+v", test.input, test.output, ctx.Bool("d"))
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+ }
	+}
	+
	+func TestParseMultiBoolT(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ BoolTFlag{Name: "serve, s"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.BoolT("serve") != true {
	+ t.Errorf("main name not set")
	+ }
	+ if ctx.BoolT("s") != true {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--serve"})
	+}
	+
	+func TestParseDestinationBoolT(t *testing.T) {
	+ var dest bool
	+ a := App{
	+ Flags: []Flag{
	+ BoolTFlag{
	+ Name: "dest",
	+ Destination: &dest,
	+ },
	+ },
	+ Action: func(ctx *Context) error {
	+ if dest != true {
	+ t.Errorf("expected destination BoolT true")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "--dest"})
	+}
	+
	+func TestParseMultiBoolTFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_DEBUG", "0")
	+ a := App{
	+ Flags: []Flag{
	+ BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.BoolT("debug") != false {
	+ t.Errorf("main name not set from env")
	+ }
	+ if ctx.BoolT("d") != false {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_DEBUG", "0")
	+ a := App{
	+ Flags: []Flag{
	+ BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.BoolT("debug") != false {
	+ t.Errorf("main name not set from env")
	+ }
	+ if ctx.BoolT("d") != false {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+type Parser [2]string
	+
	+func (p *Parser) Set(value string) error {
	+ parts := strings.Split(value, ",")
	+ if len(parts) != 2 {
	+ return fmt.Errorf("invalid format")
	+ }
	+
	+ (*p)[0] = parts[0]
	+ (*p)[1] = parts[1]
	+
	+ return nil
	+}
	+
	+func (p *Parser) String() string {
	+ return fmt.Sprintf("%s,%s", p[0], p[1])
	+}
	+
	+func (p *Parser) Get() interface{} {
	+ return p
	+}
	+
	+func TestParseGeneric(t *testing.T) {
	+ a := App{
	+ Flags: []Flag{
	+ GenericFlag{Name: "serve, s", Value: &Parser{}},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
	+ t.Errorf("main name not set")
	+ }
	+ if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) {
	+ t.Errorf("short name not set")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run", "-s", "10,20"})
	+}
	+
	+func TestParseGenericFromEnv(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_SERVE", "20,30")
	+ a := App{
	+ Flags: []Flag{
	+ GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
	+ t.Errorf("main name not set from env")
	+ }
	+ if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) {
	+ t.Errorf("short name not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	+
	+func TestParseGenericFromEnvCascade(t *testing.T) {
	+ os.Clearenv()
	+ os.Setenv("APP_FOO", "99,2000")
	+ a := App{
	+ Flags: []Flag{
	+ GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
	+ t.Errorf("value not set from env")
	+ }
	+ return nil
	+ },
	+ }
	+ a.Run([]string{"run"})
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/funcs.go b/src/gopkg.in/urfave/cli.v1/funcs.go
	new file mode 100644
	index 0000000..cba5e6c
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/funcs.go
	@@ -0,0 +1,28 @@
	+package cli
	+
	+// BashCompleteFunc is an action to execute when the bash-completion flag is set
	+type BashCompleteFunc func(*Context)
	+
	+// BeforeFunc is an action to execute before any subcommands are run, but after
	+// the context is ready if a non-nil error is returned, no subcommands are run
	+type BeforeFunc func(*Context) error
	+
	+// AfterFunc is an action to execute after any subcommands are run, but after the
	+// subcommand has finished it is run even if Action() panics
	+type AfterFunc func(*Context) error
	+
	+// ActionFunc is the action to execute when no subcommands are specified
	+type ActionFunc func(*Context) error
	+
	+// CommandNotFoundFunc is executed if the proper command cannot be found
	+type CommandNotFoundFunc func(*Context, string)
	+
	+// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
	+// customized usage error messages. This function is able to replace the
	+// original error messages. If this function is not set, the "Incorrect usage"
	+// is displayed and the execution is interrupted.
	+type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
	+
	+// FlagStringFunc is used by the help generation to display a flag, which is
	+// expected to be a single line.
	+type FlagStringFunc func(Flag) string
	diff --git a/src/gopkg.in/urfave/cli.v1/generate-flag-types b/src/gopkg.in/urfave/cli.v1/generate-flag-types
	new file mode 100755
	index 0000000..7147381
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/generate-flag-types
	@@ -0,0 +1,255 @@
	+#!/usr/bin/env python
	+"""
	+The flag types that ship with the cli library have many things in common, and
	+so we can take advantage of the `go generate` command to create much of the
	+source code from a list of definitions. These definitions attempt to cover
	+the parts that vary between flag types, and should evolve as needed.
	+
	+An example of the minimum definition needed is:
	+
	+ {
	+ "name": "SomeType",
	+ "type": "sometype",
	+ "context_default": "nil"
	+ }
	+
	+In this example, the code generated for the `cli` package will include a type
	+named `SomeTypeFlag` that is expected to wrap a value of type `sometype`.
	+Fetching values by name via `*cli.Context` will default to a value of `nil`.
	+
	+A more complete, albeit somewhat redundant, example showing all available
	+definition keys is:
	+
	+ {
	+ "name": "VeryMuchType",
	+ "type": "*VeryMuchType",
	+ "value": true,
	+ "dest": false,
	+ "doctail": " which really only wraps a []float64, oh well!",
	+ "context_type": "[]float64",
	+ "context_default": "nil",
	+ "parser": "parseVeryMuchType(f.Value.String())",
	+ "parser_cast": "[]float64(parsed)"
	+ }
	+
	+The meaning of each field is as follows:
	+
	+ name (string) - The type "name", which will be suffixed with
	+ `Flag` when generating the type definition
	+ for `cli` and the wrapper type for `altsrc`
	+ type (string) - The type that the generated `Flag` type for `cli`
	+ is expected to "contain" as its `.Value` member
	+ value (bool) - Should the generated `cli` type have a `Value`
	+ member?
	+ dest (bool) - Should the generated `cli` type support a
	+ destination pointer?
	+ doctail (string) - Additional docs for the `cli` flag type comment
	+ context_type (string) - The literal type used in the `*cli.Context`
	+ reader func signature
	+ context_default (string) - The literal value used as the default by the
	+ `*cli.Context` reader funcs when no value is
	+ present
	+ parser (string) - Literal code used to parse the flag `f`,
	+ expected to have a return signature of
	+ (value, error)
	+ parser_cast (string) - Literal code used to cast the `parsed` value
	+ returned from the `parser` code
	+"""
	+
	+from __future__ import print_function, unicode_literals
	+
	+import argparse
	+import json
	+import os
	+import subprocess
	+import sys
	+import tempfile
	+import textwrap
	+
	+
	+class _FancyFormatter(argparse.ArgumentDefaultsHelpFormatter,
	+ argparse.RawDescriptionHelpFormatter):
	+ pass
	+
	+
	+def main(sysargs=sys.argv[:]):
	+ parser = argparse.ArgumentParser(
	+ description='Generate flag type code!',
	+ formatter_class=_FancyFormatter)
	+ parser.add_argument(
	+ 'package',
	+ type=str, default='cli', choices=_WRITEFUNCS.keys(),
	+ help='Package for which flag types will be generated'
	+ )
	+ parser.add_argument(
	+ '-i', '--in-json',
	+ type=argparse.FileType('r'),
	+ default=sys.stdin,
	+ help='Input JSON file which defines each type to be generated'
	+ )
	+ parser.add_argument(
	+ '-o', '--out-go',
	+ type=argparse.FileType('w'),
	+ default=sys.stdout,
	+ help='Output file/stream to which generated source will be written'
	+ )
	+ parser.epilog = __doc__
	+
	+ args = parser.parse_args(sysargs[1:])
	+ _generate_flag_types(_WRITEFUNCS[args.package], args.out_go, args.in_json)
	+ return 0
	+
	+
	+def _generate_flag_types(writefunc, output_go, input_json):
	+ types = json.load(input_json)
	+
	+ tmp = tempfile.NamedTemporaryFile(suffix='.go', delete=False)
	+ writefunc(tmp, types)
	+ tmp.close()
	+
	+ new_content = subprocess.check_output(
	+ ['goimports', tmp.name]
	+ ).decode('utf-8')
	+
	+ print(new_content, file=output_go, end='')
	+ output_go.flush()
	+ os.remove(tmp.name)
	+
	+
	+def _set_typedef_defaults(typedef):
	+ typedef.setdefault('doctail', '')
	+ typedef.setdefault('context_type', typedef['type'])
	+ typedef.setdefault('dest', True)
	+ typedef.setdefault('value', True)
	+ typedef.setdefault('parser', 'f.Value, error(nil)')
	+ typedef.setdefault('parser_cast', 'parsed')
	+
	+
	+def _write_cli_flag_types(outfile, types):
	+ _fwrite(outfile, """\
	+ package cli
	+
	+ // WARNING: This file is generated!
	+
	+ """)
	+
	+ for typedef in types:
	+ _set_typedef_defaults(typedef)
	+
	+ _fwrite(outfile, """\
	+ // {name}Flag is a flag with type {type}{doctail}
	+ type {name}Flag struct {{
	+ Name string
	+ Usage string
	+ EnvVar string
	+ Hidden bool
	+ """.format(**typedef))
	+
	+ if typedef['value']:
	+ _fwrite(outfile, """\
	+ Value {type}
	+ """.format(**typedef))
	+
	+ if typedef['dest']:
	+ _fwrite(outfile, """\
	+ Destination *{type}
	+ """.format(**typedef))
	+
	+ _fwrite(outfile, "\n}\n\n")
	+
	+ _fwrite(outfile, """\
	+ // String returns a readable representation of this value
	+ // (for usage defaults)
	+ func (f {name}Flag) String() string {{
	+ return FlagStringer(f)
	+ }}
	+
	+ // GetName returns the name of the flag
	+ func (f {name}Flag) GetName() string {{
	+ return f.Name
	+ }}
	+
	+ // {name} looks up the value of a local {name}Flag, returns
	+ // {context_default} if not found
	+ func (c *Context) {name}(name string) {context_type} {{
	+ return lookup{name}(name, c.flagSet)
	+ }}
	+
	+ // Global{name} looks up the value of a global {name}Flag, returns
	+ // {context_default} if not found
	+ func (c *Context) Global{name}(name string) {context_type} {{
	+ if fs := lookupGlobalFlagSet(name, c); fs != nil {{
	+ return lookup{name}(name, fs)
	+ }}
	+ return {context_default}
	+ }}
	+
	+ func lookup{name}(name string, set *flag.FlagSet) {context_type} {{
	+ f := set.Lookup(name)
	+ if f != nil {{
	+ parsed, err := {parser}
	+ if err != nil {{
	+ return {context_default}
	+ }}
	+ return {parser_cast}
	+ }}
	+ return {context_default}
	+ }}
	+ """.format(**typedef))
	+
	+
	+def _write_altsrc_flag_types(outfile, types):
	+ _fwrite(outfile, """\
	+ package altsrc
	+
	+ import (
	+ "gopkg.in/urfave/cli.v1"
	+ )
	+
	+ // WARNING: This file is generated!
	+
	+ """)
	+
	+ for typedef in types:
	+ _set_typedef_defaults(typedef)
	+
	+ _fwrite(outfile, """\
	+ // {name}Flag is the flag type that wraps cli.{name}Flag to allow
	+ // for other values to be specified
	+ type {name}Flag struct {{
	+ cli.{name}Flag
	+ set *flag.FlagSet
	+ }}
	+
	+ // New{name}Flag creates a new {name}Flag
	+ func New{name}Flag(fl cli.{name}Flag) *{name}Flag {{
	+ return &{name}Flag{{{name}Flag: fl, set: nil}}
	+ }}
	+
	+ // Apply saves the flagSet for later usage calls, then calls the
	+ // wrapped {name}Flag.Apply
	+ func (f {name}Flag) Apply(set flag.FlagSet) {{
	+ f.set = set
	+ f.{name}Flag.Apply(set)
	+ }}
	+
	+ // ApplyWithError saves the flagSet for later usage calls, then calls the
	+ // wrapped {name}Flag.ApplyWithError
	+ func (f {name}Flag) ApplyWithError(set flag.FlagSet) error {{
	+ f.set = set
	+ return f.{name}Flag.ApplyWithError(set)
	+ }}
	+ """.format(**typedef))
	+
	+
	+def _fwrite(outfile, text):
	+ print(textwrap.dedent(text), end='', file=outfile)
	+
	+
	+_WRITEFUNCS = {
	+ 'cli': _write_cli_flag_types,
	+ 'altsrc': _write_altsrc_flag_types
	+}
	+
	+if __name__ == '__main__':
	+ sys.exit(main())
	diff --git a/src/gopkg.in/urfave/cli.v1/help.go b/src/gopkg.in/urfave/cli.v1/help.go
	new file mode 100644
	index 0000000..c8c1aee
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/help.go
	@@ -0,0 +1,294 @@
	+package cli
	+
	+import (
	+ "fmt"
	+ "io"
	+ "os"
	+ "strings"
	+ "text/tabwriter"
	+ "text/template"
	+)
	+
	+// AppHelpTemplate is the text template for the Default help topic.
	+// cli.go uses text/template to render templates. You can
	+// render custom help text by setting this variable.
	+var AppHelpTemplate = `NAME:
	+ {{.Name}}{{if .Usage}} - {{.Usage}}{{end}}
	+
	+USAGE:
	+ {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
	+
	+VERSION:
	+ {{.Version}}{{end}}{{end}}{{if .Description}}
	+
	+DESCRIPTION:
	+ {{.Description}}{{end}}{{if len .Authors}}
	+
	+AUTHOR{{with $length := len .Authors}}{{if ne 1 $length}}S{{end}}{{end}}:
	+ {{range $index, $author := .Authors}}{{if $index}}
	+ {{end}}{{$author}}{{end}}{{end}}{{if .VisibleCommands}}
	+
	+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
	+ {{.Name}}:{{end}}{{range .VisibleCommands}}
	+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
	+
	+GLOBAL OPTIONS:
	+ {{range $index, $option := .VisibleFlags}}{{if $index}}
	+ {{end}}{{$option}}{{end}}{{end}}{{if .Copyright}}
	+
	+COPYRIGHT:
	+ {{.Copyright}}{{end}}
	+`
	+
	+// CommandHelpTemplate is the text template for the command help topic.
	+// cli.go uses text/template to render templates. You can
	+// render custom help text by setting this variable.
	+var CommandHelpTemplate = `NAME:
	+ {{.HelpName}} - {{.Usage}}
	+
	+USAGE:
	+ {{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}
	+
	+CATEGORY:
	+ {{.Category}}{{end}}{{if .Description}}
	+
	+DESCRIPTION:
	+ {{.Description}}{{end}}{{if .VisibleFlags}}
	+
	+OPTIONS:
	+ {{range .VisibleFlags}}{{.}}
	+ {{end}}{{end}}
	+`
	+
	+// SubcommandHelpTemplate is the text template for the subcommand help topic.
	+// cli.go uses text/template to render templates. You can
	+// render custom help text by setting this variable.
	+var SubcommandHelpTemplate = `NAME:
	+ {{.HelpName}} - {{.Usage}}
	+
	+USAGE:
	+ {{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
	+
	+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
	+ {{.Name}}:{{end}}{{range .VisibleCommands}}
	+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}
	+{{end}}{{if .VisibleFlags}}
	+OPTIONS:
	+ {{range .VisibleFlags}}{{.}}
	+ {{end}}{{end}}
	+`
	+
	+var helpCommand = Command{
	+ Name: "help",
	+ Aliases: []string{"h"},
	+ Usage: "Shows a list of commands or help for one command",
	+ ArgsUsage: "[command]",
	+ Action: func(c *Context) error {
	+ args := c.Args()
	+ if args.Present() {
	+ return ShowCommandHelp(c, args.First())
	+ }
	+
	+ ShowAppHelp(c)
	+ return nil
	+ },
	+}
	+
	+var helpSubcommand = Command{
	+ Name: "help",
	+ Aliases: []string{"h"},
	+ Usage: "Shows a list of commands or help for one command",
	+ ArgsUsage: "[command]",
	+ Action: func(c *Context) error {
	+ args := c.Args()
	+ if args.Present() {
	+ return ShowCommandHelp(c, args.First())
	+ }
	+
	+ return ShowSubcommandHelp(c)
	+ },
	+}
	+
	+// Prints help for the App or Command
	+type helpPrinter func(w io.Writer, templ string, data interface{})
	+
	+// HelpPrinter is a function that writes the help output. If not set a default
	+// is used. The function signature is:
	+// func(w io.Writer, templ string, data interface{})
	+var HelpPrinter helpPrinter = printHelp
	+
	+// VersionPrinter prints the version for the App
	+var VersionPrinter = printVersion
	+
	+// ShowAppHelp is an action that displays the help.
	+func ShowAppHelp(c *Context) error {
	+ HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
	+ return nil
	+}
	+
	+// DefaultAppComplete prints the list of subcommands as the default app completion method
	+func DefaultAppComplete(c *Context) {
	+ for _, command := range c.App.Commands {
	+ if command.Hidden {
	+ continue
	+ }
	+ for _, name := range command.Names() {
	+ fmt.Fprintln(c.App.Writer, name)
	+ }
	+ }
	+}
	+
	+// ShowCommandHelp prints help for the given command
	+func ShowCommandHelp(ctx *Context, command string) error {
	+ // show the subcommand help for a command with subcommands
	+ if command == "" {
	+ HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
	+ return nil
	+ }
	+
	+ for _, c := range ctx.App.Commands {
	+ if c.HasName(command) {
	+ HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
	+ return nil
	+ }
	+ }
	+
	+ if ctx.App.CommandNotFound == nil {
	+ return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3)
	+ }
	+
	+ ctx.App.CommandNotFound(ctx, command)
	+ return nil
	+}
	+
	+// ShowSubcommandHelp prints help for the given subcommand
	+func ShowSubcommandHelp(c *Context) error {
	+ return ShowCommandHelp(c, c.Command.Name)
	+}
	+
	+// ShowVersion prints the version number of the App
	+func ShowVersion(c *Context) {
	+ VersionPrinter(c)
	+}
	+
	+func printVersion(c *Context) {
	+ fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
	+}
	+
	+// ShowCompletions prints the lists of commands within a given context
	+func ShowCompletions(c *Context) {
	+ a := c.App
	+ if a != nil && a.BashComplete != nil {
	+ a.BashComplete(c)
	+ }
	+}
	+
	+// ShowCommandCompletions prints the custom completions for a given command
	+func ShowCommandCompletions(ctx *Context, command string) {
	+ c := ctx.App.Command(command)
	+ if c != nil && c.BashComplete != nil {
	+ c.BashComplete(ctx)
	+ }
	+}
	+
	+func printHelp(out io.Writer, templ string, data interface{}) {
	+ funcMap := template.FuncMap{
	+ "join": strings.Join,
	+ }
	+
	+ w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
	+ t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
	+ err := t.Execute(w, data)
	+ if err != nil {
	+ // If the writer is closed, t.Execute will fail, and there's nothing
	+ // we can do to recover.
	+ if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
	+ fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
	+ }
	+ return
	+ }
	+ w.Flush()
	+}
	+
	+func checkVersion(c *Context) bool {
	+ found := false
	+ if VersionFlag.Name != "" {
	+ eachName(VersionFlag.Name, func(name string) {
	+ if c.GlobalBool(name) \|\| c.Bool(name) {
	+ found = true
	+ }
	+ })
	+ }
	+ return found
	+}
	+
	+func checkHelp(c *Context) bool {
	+ found := false
	+ if HelpFlag.Name != "" {
	+ eachName(HelpFlag.Name, func(name string) {
	+ if c.GlobalBool(name) \|\| c.Bool(name) {
	+ found = true
	+ }
	+ })
	+ }
	+ return found
	+}
	+
	+func checkCommandHelp(c *Context, name string) bool {
	+ if c.Bool("h") \|\| c.Bool("help") {
	+ ShowCommandHelp(c, name)
	+ return true
	+ }
	+
	+ return false
	+}
	+
	+func checkSubcommandHelp(c *Context) bool {
	+ if c.Bool("h") \|\| c.Bool("help") {
	+ ShowSubcommandHelp(c)
	+ return true
	+ }
	+
	+ return false
	+}
	+
	+func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
	+ if !a.EnableBashCompletion {
	+ return false, arguments
	+ }
	+
	+ pos := len(arguments) - 1
	+ lastArg := arguments[pos]
	+
	+ if lastArg != "--"+BashCompletionFlag.Name {
	+ return false, arguments
	+ }
	+
	+ return true, arguments[:pos]
	+}
	+
	+func checkCompletions(c *Context) bool {
	+ if !c.shellComplete {
	+ return false
	+ }
	+
	+ if args := c.Args(); args.Present() {
	+ name := args.First()
	+ if cmd := c.App.Command(name); cmd != nil {
	+ // let the command handle the completion
	+ return false
	+ }
	+ }
	+
	+ ShowCompletions(c)
	+ return true
	+}
	+
	+func checkCommandCompletions(c *Context, name string) bool {
	+ if !c.shellComplete {
	+ return false
	+ }
	+
	+ ShowCommandCompletions(c, name)
	+ return true
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/help_test.go b/src/gopkg.in/urfave/cli.v1/help_test.go
	new file mode 100644
	index 0000000..7c15400
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/help_test.go
	@@ -0,0 +1,289 @@
	+package cli
	+
	+import (
	+ "bytes"
	+ "flag"
	+ "strings"
	+ "testing"
	+)
	+
	+func Test_ShowAppHelp_NoAuthor(t *testing.T) {
	+ output := new(bytes.Buffer)
	+ app := NewApp()
	+ app.Writer = output
	+
	+ c := NewContext(app, nil, nil)
	+
	+ ShowAppHelp(c)
	+
	+ if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
	+ t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
	+ }
	+}
	+
	+func Test_ShowAppHelp_NoVersion(t *testing.T) {
	+ output := new(bytes.Buffer)
	+ app := NewApp()
	+ app.Writer = output
	+
	+ app.Version = ""
	+
	+ c := NewContext(app, nil, nil)
	+
	+ ShowAppHelp(c)
	+
	+ if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
	+ t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
	+ }
	+}
	+
	+func Test_ShowAppHelp_HideVersion(t *testing.T) {
	+ output := new(bytes.Buffer)
	+ app := NewApp()
	+ app.Writer = output
	+
	+ app.HideVersion = true
	+
	+ c := NewContext(app, nil, nil)
	+
	+ ShowAppHelp(c)
	+
	+ if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
	+ t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
	+ }
	+}
	+
	+func Test_Help_Custom_Flags(t *testing.T) {
	+ oldFlag := HelpFlag
	+ defer func() {
	+ HelpFlag = oldFlag
	+ }()
	+
	+ HelpFlag = BoolFlag{
	+ Name: "help, x",
	+ Usage: "show help",
	+ }
	+
	+ app := App{
	+ Flags: []Flag{
	+ BoolFlag{Name: "foo, h"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("h") != true {
	+ t.Errorf("custom help flag not set")
	+ }
	+ return nil
	+ },
	+ }
	+ output := new(bytes.Buffer)
	+ app.Writer = output
	+ app.Run([]string{"test", "-h"})
	+ if output.Len() > 0 {
	+ t.Errorf("unexpected output: %s", output.String())
	+ }
	+}
	+
	+func Test_Version_Custom_Flags(t *testing.T) {
	+ oldFlag := VersionFlag
	+ defer func() {
	+ VersionFlag = oldFlag
	+ }()
	+
	+ VersionFlag = BoolFlag{
	+ Name: "version, V",
	+ Usage: "show version",
	+ }
	+
	+ app := App{
	+ Flags: []Flag{
	+ BoolFlag{Name: "foo, v"},
	+ },
	+ Action: func(ctx *Context) error {
	+ if ctx.Bool("v") != true {
	+ t.Errorf("custom version flag not set")
	+ }
	+ return nil
	+ },
	+ }
	+ output := new(bytes.Buffer)
	+ app.Writer = output
	+ app.Run([]string{"test", "-v"})
	+ if output.Len() > 0 {
	+ t.Errorf("unexpected output: %s", output.String())
	+ }
	+}
	+
	+func Test_helpCommand_Action_ErrorIfNoTopic(t *testing.T) {
	+ app := NewApp()
	+
	+ set := flag.NewFlagSet("test", 0)
	+ set.Parse([]string{"foo"})
	+
	+ c := NewContext(app, set, nil)
	+
	+ err := helpCommand.Action.(func(*Context) error)(c)
	+
	+ if err == nil {
	+ t.Fatalf("expected error from helpCommand.Action(), but got nil")
	+ }
	+
	+ exitErr, ok := err.(*ExitError)
	+ if !ok {
	+ t.Fatalf("expected ExitError from helpCommand.Action(), but instead got: %v", err.Error())
	+ }
	+
	+ if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
	+ t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
	+ }
	+
	+ if exitErr.exitCode != 3 {
	+ t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
	+ }
	+}
	+
	+func Test_helpCommand_InHelpOutput(t *testing.T) {
	+ app := NewApp()
	+ output := &bytes.Buffer{}
	+ app.Writer = output
	+ app.Run([]string{"test", "--help"})
	+
	+ s := output.String()
	+
	+ if strings.Contains(s, "\nCOMMANDS:\nGLOBAL OPTIONS:\n") {
	+ t.Fatalf("empty COMMANDS section detected: %q", s)
	+ }
	+
	+ if !strings.Contains(s, "help, h") {
	+ t.Fatalf("missing \"help, h\": %q", s)
	+ }
	+}
	+
	+func Test_helpSubcommand_Action_ErrorIfNoTopic(t *testing.T) {
	+ app := NewApp()
	+
	+ set := flag.NewFlagSet("test", 0)
	+ set.Parse([]string{"foo"})
	+
	+ c := NewContext(app, set, nil)
	+
	+ err := helpSubcommand.Action.(func(*Context) error)(c)
	+
	+ if err == nil {
	+ t.Fatalf("expected error from helpCommand.Action(), but got nil")
	+ }
	+
	+ exitErr, ok := err.(*ExitError)
	+ if !ok {
	+ t.Fatalf("expected ExitError from helpCommand.Action(), but instead got: %v", err.Error())
	+ }
	+
	+ if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
	+ t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
	+ }
	+
	+ if exitErr.exitCode != 3 {
	+ t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
	+ }
	+}
	+
	+func TestShowAppHelp_CommandAliases(t *testing.T) {
	+ app := &App{
	+ Commands: []Command{
	+ {
	+ Name: "frobbly",
	+ Aliases: []string{"fr", "frob"},
	+ Action: func(ctx *Context) error {
	+ return nil
	+ },
	+ },
	+ },
	+ }
	+
	+ output := &bytes.Buffer{}
	+ app.Writer = output
	+ app.Run([]string{"foo", "--help"})
	+
	+ if !strings.Contains(output.String(), "frobbly, fr, frob") {
	+ t.Errorf("expected output to include all command aliases; got: %q", output.String())
	+ }
	+}
	+
	+func TestShowCommandHelp_CommandAliases(t *testing.T) {
	+ app := &App{
	+ Commands: []Command{
	+ {
	+ Name: "frobbly",
	+ Aliases: []string{"fr", "frob", "bork"},
	+ Action: func(ctx *Context) error {
	+ return nil
	+ },
	+ },
	+ },
	+ }
	+
	+ output := &bytes.Buffer{}
	+ app.Writer = output
	+ app.Run([]string{"foo", "help", "fr"})
	+
	+ if !strings.Contains(output.String(), "frobbly") {
	+ t.Errorf("expected output to include command name; got: %q", output.String())
	+ }
	+
	+ if strings.Contains(output.String(), "bork") {
	+ t.Errorf("expected output to exclude command aliases; got: %q", output.String())
	+ }
	+}
	+
	+func TestShowSubcommandHelp_CommandAliases(t *testing.T) {
	+ app := &App{
	+ Commands: []Command{
	+ {
	+ Name: "frobbly",
	+ Aliases: []string{"fr", "frob", "bork"},
	+ Action: func(ctx *Context) error {
	+ return nil
	+ },
	+ },
	+ },
	+ }
	+
	+ output := &bytes.Buffer{}
	+ app.Writer = output
	+ app.Run([]string{"foo", "help"})
	+
	+ if !strings.Contains(output.String(), "frobbly, fr, frob, bork") {
	+ t.Errorf("expected output to include all command aliases; got: %q", output.String())
	+ }
	+}
	+
	+func TestShowAppHelp_HiddenCommand(t *testing.T) {
	+ app := &App{
	+ Commands: []Command{
	+ {
	+ Name: "frobbly",
	+ Action: func(ctx *Context) error {
	+ return nil
	+ },
	+ },
	+ {
	+ Name: "secretfrob",
	+ Hidden: true,
	+ Action: func(ctx *Context) error {
	+ return nil
	+ },
	+ },
	+ },
	+ }
	+
	+ output := &bytes.Buffer{}
	+ app.Writer = output
	+ app.Run([]string{"app", "--help"})
	+
	+ if strings.Contains(output.String(), "secretfrob") {
	+ t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String())
	+ }
	+
	+ if !strings.Contains(output.String(), "frobbly") {
	+ t.Errorf("expected output to include \"frobbly\"; got: %q", output.String())
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/helpers_test.go b/src/gopkg.in/urfave/cli.v1/helpers_test.go
	new file mode 100644
	index 0000000..109ea7a
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/helpers_test.go
	@@ -0,0 +1,28 @@
	+package cli
	+
	+import (
	+ "os"
	+ "reflect"
	+ "runtime"
	+ "strings"
	+ "testing"
	+)
	+
	+var (
	+ wd, _ = os.Getwd()
	+)
	+
	+func expect(t *testing.T, a interface{}, b interface{}) {
	+ _, fn, line, _ := runtime.Caller(1)
	+ fn = strings.Replace(fn, wd+"/", "", -1)
	+
	+ if !reflect.DeepEqual(a, b) {
	+ t.Errorf("(%s:%d) Expected %v (type %v) - Got %v (type %v)", fn, line, b, reflect.TypeOf(b), a, reflect.TypeOf(a))
	+ }
	+}
	+
	+func refute(t *testing.T, a interface{}, b interface{}) {
	+ if reflect.DeepEqual(a, b) {
	+ t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/helpers_unix_test.go b/src/gopkg.in/urfave/cli.v1/helpers_unix_test.go
	new file mode 100644
	index 0000000..ae27fc5
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/helpers_unix_test.go
	@@ -0,0 +1,9 @@
	+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
	+
	+package cli
	+
	+import "os"
	+
	+func clearenv() {
	+ os.Clearenv()
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/helpers_windows_test.go b/src/gopkg.in/urfave/cli.v1/helpers_windows_test.go
	new file mode 100644
	index 0000000..4eb84f9
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/helpers_windows_test.go
	@@ -0,0 +1,20 @@
	+package cli
	+
	+import (
	+ "os"
	+ "syscall"
	+)
	+
	+// os.Clearenv() doesn't actually unset variables on Windows
	+// See: https://github.com/golang/go/issues/17902
	+func clearenv() {
	+ for _, s := range os.Environ() {
	+ for j := 1; j < len(s); j++ {
	+ if s[j] == '=' {
	+ keyp, _ := syscall.UTF16PtrFromString(s[0:j])
	+ syscall.SetEnvironmentVariable(keyp, nil)
	+ break
	+ }
	+ }
	+ }
	+}
	diff --git a/src/gopkg.in/urfave/cli.v1/runtests b/src/gopkg.in/urfave/cli.v1/runtests
	new file mode 100755
	index 0000000..ee22bde
	--- /dev/null
	+++ b/src/gopkg.in/urfave/cli.v1/runtests
	@@ -0,0 +1,122 @@
	+#!/usr/bin/env python
	+from __future__ import print_function
	+
	+import argparse
	+import os
	+import sys
	+import tempfile
	+
	+from subprocess import check_call, check_output
	+
	+
	+PACKAGE_NAME = os.environ.get(
	+ 'CLI_PACKAGE_NAME', 'github.com/urfave/cli'
	+)
	+
	+
	+def main(sysargs=sys.argv[:]):
	+ targets = {
	+ 'vet': _vet,
	+ 'test': _test,
	+ 'gfmrun': _gfmrun,
	+ 'toc': _toc,
	+ 'gen': _gen,
	+ }
	+
	+ parser = argparse.ArgumentParser()
	+ parser.add_argument(
	+ 'target', nargs='?', choices=tuple(targets.keys()), default='test'
	+ )
	+ args = parser.parse_args(sysargs[1:])
	+
	+ targets[args.target]()
	+ return 0
	+
	+
	+def _test():
	+ if check_output('go version'.split()).split()[2] < 'go1.2':
	+ _run('go test -v .')
	+ return
	+
	+ coverprofiles = []
	+ for subpackage in ['', 'altsrc']:
	+ coverprofile = 'cli.coverprofile'
	+ if subpackage != '':
	+ coverprofile = '{}.coverprofile'.format(subpackage)
	+
	+ coverprofiles.append(coverprofile)
	+
	+ _run('go test -v'.split() + [
	+ '-coverprofile={}'.format(coverprofile),
	+ ('{}/{}'.format(PACKAGE_NAME, subpackage)).rstrip('/')
	+ ])
	+
	+ combined_name = _combine_coverprofiles(coverprofiles)
	+ _run('go tool cover -func={}'.format(combined_name))
	+ os.remove(combined_name)
	+
	+
	+def _gfmrun():
	+ go_version = check_output('go version'.split()).split()[2]
	+ if go_version < 'go1.3':
	+ print('runtests: skip on {}'.format(go_version), file=sys.stderr)
	+ return
	+ _run(['gfmrun', '-c', str(_gfmrun_count()), '-s', 'README.md'])
	+
	+
	+def _vet():
	+ _run('go vet ./...')
	+
	+
	+def _toc():
	+ _run('node_modules/.bin/markdown-toc -i README.md')
	+ _run('git diff --exit-code')
	+
	+
	+def _gen():
	+ go_version = check_output('go version'.split()).split()[2]
	+ if go_version < 'go1.5':
	+ print('runtests: skip on {}'.format(go_version), file=sys.stderr)
	+ return
	+
	+ _run('go generate ./...')
	+ _run('git diff --exit-code')
	+
	+
	+def _run(command):
	+ if hasattr(command, 'split'):
	+ command = command.split()
	+ print('runtests: {}'.format(' '.join(command)), file=sys.stderr)
	+ check_call(command)
	+
	+
	+def _gfmrun_count():
	+ with open('README.md') as infile:
	+ lines = infile.read().splitlines()
	+ return len(filter(_is_go_runnable, lines))
	+
	+
	+def _is_go_runnable(line):
	+ return line.startswith('package main')
	+
	+
	+def _combine_coverprofiles(coverprofiles):
	+ combined = tempfile.NamedTemporaryFile(
	+ suffix='.coverprofile', delete=False
	+ )
	+ combined.write('mode: set\n')
	+
	+ for coverprofile in coverprofiles:
	+ with open(coverprofile, 'r') as infile:
	+ for line in infile.readlines():
	+ if not line.startswith('mode: '):
	+ combined.write(line)
	+
	+ combined.flush()
	+ name = combined.name
	+ combined.close()
	+ return name
	+
	+
	+if __name__ == '__main__':
	+ sys.exit(main())
	diff --git a/src/gopkg.in/yaml.v2/LICENSE b/src/gopkg.in/yaml.v2/LICENSE
	new file mode 100644
	index 0000000..a68e67f
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/LICENSE
	@@ -0,0 +1,188 @@
	+
	+Copyright (c) 2011-2014 - Canonical Inc.
	+
	+This software is licensed under the LGPLv3, included below.
	+
	+As a special exception to the GNU Lesser General Public License version 3
	+("LGPL3"), the copyright holders of this Library give you permission to
	+convey to a third party a Combined Work that links statically or dynamically
	+to this Library without providing any Minimal Corresponding Source or
	+Minimal Application Code as set out in 4d or providing the installation
	+information set out in section 4e, provided that you comply with the other
	+provisions of LGPL3 and provided that you meet, for the Application the
	+terms and conditions of the license(s) which apply to the Application.
	+
	+Except as stated in this special exception, the provisions of LGPL3 will
	+continue to comply in full to this Library. If you modify this Library, you
	+may apply this exception to your version of this Library, but you are not
	+obliged to do so. If you do not wish to do so, delete this exception
	+statement from your version. This exception does not (and cannot) modify any
	+license terms which apply to the Application, with which you must still
	+comply.
	+
	+
	+ GNU LESSER GENERAL PUBLIC LICENSE
	+ Version 3, 29 June 2007
	+
	+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
	+ Everyone is permitted to copy and distribute verbatim copies
	+ of this license document, but changing it is not allowed.
	+
	+
	+ This version of the GNU Lesser General Public License incorporates
	+the terms and conditions of version 3 of the GNU General Public
	+License, supplemented by the additional permissions listed below.
	+
	+ 0. Additional Definitions.
	+
	+ As used herein, "this License" refers to version 3 of the GNU Lesser
	+General Public License, and the "GNU GPL" refers to version 3 of the GNU
	+General Public License.
	+
	+ "The Library" refers to a covered work governed by this License,
	+other than an Application or a Combined Work as defined below.
	+
	+ An "Application" is any work that makes use of an interface provided
	+by the Library, but which is not otherwise based on the Library.
	+Defining a subclass of a class defined by the Library is deemed a mode
	+of using an interface provided by the Library.
	+
	+ A "Combined Work" is a work produced by combining or linking an
	+Application with the Library. The particular version of the Library
	+with which the Combined Work was made is also called the "Linked
	+Version".
	+
	+ The "Minimal Corresponding Source" for a Combined Work means the
	+Corresponding Source for the Combined Work, excluding any source code
	+for portions of the Combined Work that, considered in isolation, are
	+based on the Application, and not on the Linked Version.
	+
	+ The "Corresponding Application Code" for a Combined Work means the
	+object code and/or source code for the Application, including any data
	+and utility programs needed for reproducing the Combined Work from the
	+Application, but excluding the System Libraries of the Combined Work.
	+
	+ 1. Exception to Section 3 of the GNU GPL.
	+
	+ You may convey a covered work under sections 3 and 4 of this License
	+without being bound by section 3 of the GNU GPL.
	+
	+ 2. Conveying Modified Versions.
	+
	+ If you modify a copy of the Library, and, in your modifications, a
	+facility refers to a function or data to be supplied by an Application
	+that uses the facility (other than as an argument passed when the
	+facility is invoked), then you may convey a copy of the modified
	+version:
	+
	+ a) under this License, provided that you make a good faith effort to
	+ ensure that, in the event an Application does not supply the
	+ function or data, the facility still operates, and performs
	+ whatever part of its purpose remains meaningful, or
	+
	+ b) under the GNU GPL, with none of the additional permissions of
	+ this License applicable to that copy.
	+
	+ 3. Object Code Incorporating Material from Library Header Files.
	+
	+ The object code form of an Application may incorporate material from
	+a header file that is part of the Library. You may convey such object
	+code under terms of your choice, provided that, if the incorporated
	+material is not limited to numerical parameters, data structure
	+layouts and accessors, or small macros, inline functions and templates
	+(ten or fewer lines in length), you do both of the following:
	+
	+ a) Give prominent notice with each copy of the object code that the
	+ Library is used in it and that the Library and its use are
	+ covered by this License.
	+
	+ b) Accompany the object code with a copy of the GNU GPL and this license
	+ document.
	+
	+ 4. Combined Works.
	+
	+ You may convey a Combined Work under terms of your choice that,
	+taken together, effectively do not restrict modification of the
	+portions of the Library contained in the Combined Work and reverse
	+engineering for debugging such modifications, if you also do each of
	+the following:
	+
	+ a) Give prominent notice with each copy of the Combined Work that
	+ the Library is used in it and that the Library and its use are
	+ covered by this License.
	+
	+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
	+ document.
	+
	+ c) For a Combined Work that displays copyright notices during
	+ execution, include the copyright notice for the Library among
	+ these notices, as well as a reference directing the user to the
	+ copies of the GNU GPL and this license document.
	+
	+ d) Do one of the following:
	+
	+ 0) Convey the Minimal Corresponding Source under the terms of this
	+ License, and the Corresponding Application Code in a form
	+ suitable for, and under terms that permit, the user to
	+ recombine or relink the Application with a modified version of
	+ the Linked Version to produce a modified Combined Work, in the
	+ manner specified by section 6 of the GNU GPL for conveying
	+ Corresponding Source.
	+
	+ 1) Use a suitable shared library mechanism for linking with the
	+ Library. A suitable mechanism is one that (a) uses at run time
	+ a copy of the Library already present on the user's computer
	+ system, and (b) will operate properly with a modified version
	+ of the Library that is interface-compatible with the Linked
	+ Version.
	+
	+ e) Provide Installation Information, but only if you would otherwise
	+ be required to provide such information under section 6 of the
	+ GNU GPL, and only to the extent that such information is
	+ necessary to install and execute a modified version of the
	+ Combined Work produced by recombining or relinking the
	+ Application with a modified version of the Linked Version. (If
	+ you use option 4d0, the Installation Information must accompany
	+ the Minimal Corresponding Source and Corresponding Application
	+ Code. If you use option 4d1, you must provide the Installation
	+ Information in the manner specified by section 6 of the GNU GPL
	+ for conveying Corresponding Source.)
	+
	+ 5. Combined Libraries.
	+
	+ You may place library facilities that are a work based on the
	+Library side by side in a single library together with other library
	+facilities that are not Applications and are not covered by this
	+License, and convey such a combined library under terms of your
	+choice, if you do both of the following:
	+
	+ a) Accompany the combined library with a copy of the same work based
	+ on the Library, uncombined with any other library facilities,
	+ conveyed under the terms of this License.
	+
	+ b) Give prominent notice with the combined library that part of it
	+ is a work based on the Library, and explaining where to find the
	+ accompanying uncombined form of the same work.
	+
	+ 6. Revised Versions of the GNU Lesser General Public License.
	+
	+ The Free Software Foundation may publish revised and/or new versions
	+of the GNU Lesser General Public License from time to time. Such new
	+versions will be similar in spirit to the present version, but may
	+differ in detail to address new problems or concerns.
	+
	+ Each version is given a distinguishing version number. If the
	+Library as you received it specifies that a certain numbered version
	+of the GNU Lesser General Public License "or any later version"
	+applies to it, you have the option of following the terms and
	+conditions either of that published version or of any later version
	+published by the Free Software Foundation. If the Library as you
	+received it does not specify a version number of the GNU Lesser
	+General Public License, you may choose any version of the GNU Lesser
	+General Public License ever published by the Free Software Foundation.
	+
	+ If the Library as you received it specifies that a proxy can decide
	+whether future versions of the GNU Lesser General Public License shall
	+apply, that proxy's public statement of acceptance of any version is
	+permanent authorization for you to choose that version for the
	+Library.
	diff --git a/src/gopkg.in/yaml.v2/LICENSE.libyaml b/src/gopkg.in/yaml.v2/LICENSE.libyaml
	new file mode 100644
	index 0000000..8da58fb
	--- /dev/null
	+++ b/src/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.
	diff --git a/src/gopkg.in/yaml.v2/README.md b/src/gopkg.in/yaml.v2/README.md
	new file mode 100644
	index 0000000..7b8bd86
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/README.md
	@@ -0,0 +1,131 @@
	+# 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 LGPL with an exception that allows it to be linked statically. Please see the LICENSE file for details.
	+
	+
	+Example
	+-------
	+
	+```Go
	+package main
	+
	+import (
	+ "fmt"
	+ "log"
	+
	+ "gopkg.in/yaml.v2"
	+)
	+
	+var data = `
	+a: Easy!
	+b:
	+ c: 2
	+ d: [3, 4]
	+`
	+
	+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
	+```
	+
	diff --git a/src/gopkg.in/yaml.v2/apic.go b/src/gopkg.in/yaml.v2/apic.go
	new file mode 100644
	index 0000000..95ec014
	--- /dev/null
	+++ b/src/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
	+//}
	+//
	+//
	diff --git a/src/gopkg.in/yaml.v2/decode.go b/src/gopkg.in/yaml.v2/decode.go
	new file mode 100644
	index 0000000..085cddc
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/decode.go
	@@ -0,0 +1,683 @@
	+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)))
	+ }
	+ panic("unreachable")
	+}
	+
	+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
	+}
	+
	+var (
	+ mapItemType = reflect.TypeOf(MapItem{})
	+ durationType = reflect.TypeOf(time.Duration(0))
	+ defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
	+ ifaceType = defaultMapType.Elem()
	+)
	+
	+func newDecoder() *decoder {
	+ d := &decoder{mapType: defaultMapType}
	+ 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 == "") {
	+ 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)
	+ }
	+ }
	+ 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)
	+}
	diff --git a/src/gopkg.in/yaml.v2/decode_test.go b/src/gopkg.in/yaml.v2/decode_test.go
	new file mode 100644
	index 0000000..c159760
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/decode_test.go
	@@ -0,0 +1,988 @@
	+package yaml_test
	+
	+import (
	+ "errors"
	+ . "gopkg.in/check.v1"
	+ "gopkg.in/yaml.v2"
	+ "math"
	+ "net"
	+ "reflect"
	+ "strings"
	+ "time"
	+)
	+
	+var unmarshalIntTest = 123
	+
	+var unmarshalTests = []struct {
	+ data string
	+ value interface{}
	+}{
	+ {
	+ "",
	+ &struct{}{},
	+ }, {
	+ "{}", &struct{}{},
	+ }, {
	+ "v: hi",
	+ map[string]string{"v": "hi"},
	+ }, {
	+ "v: hi", map[string]interface{}{"v": "hi"},
	+ }, {
	+ "v: true",
	+ map[string]string{"v": "true"},
	+ }, {
	+ "v: true",
	+ map[string]interface{}{"v": true},
	+ }, {
	+ "v: 10",
	+ map[string]interface{}{"v": 10},
	+ }, {
	+ "v: 0b10",
	+ map[string]interface{}{"v": 2},
	+ }, {
	+ "v: 0xA",
	+ map[string]interface{}{"v": 10},
	+ }, {
	+ "v: 4294967296",
	+ map[string]int64{"v": 4294967296},
	+ }, {
	+ "v: 0.1",
	+ map[string]interface{}{"v": 0.1},
	+ }, {
	+ "v: .1",
	+ map[string]interface{}{"v": 0.1},
	+ }, {
	+ "v: .Inf",
	+ map[string]interface{}{"v": math.Inf(+1)},
	+ }, {
	+ "v: -.Inf",
	+ map[string]interface{}{"v": math.Inf(-1)},
	+ }, {
	+ "v: -10",
	+ map[string]interface{}{"v": -10},
	+ }, {
	+ "v: -.1",
	+ map[string]interface{}{"v": -0.1},
	+ },
	+
	+ // Simple values.
	+ {
	+ "123",
	+ &unmarshalIntTest,
	+ },
	+
	+ // Floats from spec
	+ {
	+ "canonical: 6.8523e+5",
	+ map[string]interface{}{"canonical": 6.8523e+5},
	+ }, {
	+ "expo: 685.230_15e+03",
	+ map[string]interface{}{"expo": 685.23015e+03},
	+ }, {
	+ "fixed: 685_230.15",
	+ map[string]interface{}{"fixed": 685230.15},
	+ }, {
	+ "neginf: -.inf",
	+ map[string]interface{}{"neginf": math.Inf(-1)},
	+ }, {
	+ "fixed: 685_230.15",
	+ map[string]float64{"fixed": 685230.15},
	+ },
	+ //{"sexa: 190:20:30.15", map[string]interface{}{"sexa": 0}}, // Unsupported
	+ //{"notanum: .NaN", map[string]interface{}{"notanum": math.NaN()}}, // Equality of NaN fails.
	+
	+ // Bools from spec
	+ {
	+ "canonical: y",
	+ map[string]interface{}{"canonical": true},
	+ }, {
	+ "answer: NO",
	+ map[string]interface{}{"answer": false},
	+ }, {
	+ "logical: True",
	+ map[string]interface{}{"logical": true},
	+ }, {
	+ "option: on",
	+ map[string]interface{}{"option": true},
	+ }, {
	+ "option: on",
	+ map[string]bool{"option": true},
	+ },
	+ // Ints from spec
	+ {
	+ "canonical: 685230",
	+ map[string]interface{}{"canonical": 685230},
	+ }, {
	+ "decimal: +685_230",
	+ map[string]interface{}{"decimal": 685230},
	+ }, {
	+ "octal: 02472256",
	+ map[string]interface{}{"octal": 685230},
	+ }, {
	+ "hexa: 0x_0A_74_AE",
	+ map[string]interface{}{"hexa": 685230},
	+ }, {
	+ "bin: 0b1010_0111_0100_1010_1110",
	+ map[string]interface{}{"bin": 685230},
	+ }, {
	+ "bin: -0b101010",
	+ map[string]interface{}{"bin": -42},
	+ }, {
	+ "decimal: +685_230",
	+ map[string]int{"decimal": 685230},
	+ },
	+
	+ //{"sexa: 190:20:30", map[string]interface{}{"sexa": 0}}, // Unsupported
	+
	+ // Nulls from spec
	+ {
	+ "empty:",
	+ map[string]interface{}{"empty": nil},
	+ }, {
	+ "canonical: ~",
	+ map[string]interface{}{"canonical": nil},
	+ }, {
	+ "english: null",
	+ map[string]interface{}{"english": nil},
	+ }, {
	+ "~: null key",
	+ map[interface{}]string{nil: "null key"},
	+ }, {
	+ "empty:",
	+ map[string]*bool{"empty": nil},
	+ },
	+
	+ // Flow sequence
	+ {
	+ "seq: [A,B]",
	+ map[string]interface{}{"seq": []interface{}{"A", "B"}},
	+ }, {
	+ "seq: [A,B,C,]",
	+ map[string][]string{"seq": []string{"A", "B", "C"}},
	+ }, {
	+ "seq: [A,1,C]",
	+ map[string][]string{"seq": []string{"A", "1", "C"}},
	+ }, {
	+ "seq: [A,1,C]",
	+ map[string][]int{"seq": []int{1}},
	+ }, {
	+ "seq: [A,1,C]",
	+ map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
	+ },
	+ // Block sequence
	+ {
	+ "seq:\n - A\n - B",
	+ map[string]interface{}{"seq": []interface{}{"A", "B"}},
	+ }, {
	+ "seq:\n - A\n - B\n - C",
	+ map[string][]string{"seq": []string{"A", "B", "C"}},
	+ }, {
	+ "seq:\n - A\n - 1\n - C",
	+ map[string][]string{"seq": []string{"A", "1", "C"}},
	+ }, {
	+ "seq:\n - A\n - 1\n - C",
	+ map[string][]int{"seq": []int{1}},
	+ }, {
	+ "seq:\n - A\n - 1\n - C",
	+ map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
	+ },
	+
	+ // Literal block scalar
	+ {
	+ "scalar: \| # Comment\n\n literal\n\n \ttext\n\n",
	+ map[string]string{"scalar": "\nliteral\n\n\ttext\n"},
	+ },
	+
	+ // Folded block scalar
	+ {
	+ "scalar: > # Comment\n\n folded\n line\n \n next\n line\n * one\n * two\n\n last\n line\n\n",
	+ map[string]string{"scalar": "\nfolded line\nnext line\n * one\n * two\n\nlast line\n"},
	+ },
	+
	+ // Map inside interface with no type hints.
	+ {
	+ "a: {b: c}",
	+ map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
	+ },
	+
	+ // Structs and type conversions.
	+ {
	+ "hello: world",
	+ &struct{ Hello string }{"world"},
	+ }, {
	+ "a: {b: c}",
	+ &struct{ A struct{ B string } }{struct{ B string }{"c"}},
	+ }, {
	+ "a: {b: c}",
	+ &struct{ A *struct{ B string } }{&struct{ B string }{"c"}},
	+ }, {
	+ "a: {b: c}",
	+ &struct{ A map[string]string }{map[string]string{"b": "c"}},
	+ }, {
	+ "a: {b: c}",
	+ &struct{ A *map[string]string }{&map[string]string{"b": "c"}},
	+ }, {
	+ "a:",
	+ &struct{ A map[string]string }{},
	+ }, {
	+ "a: 1",
	+ &struct{ A int }{1},
	+ }, {
	+ "a: 1",
	+ &struct{ A float64 }{1},
	+ }, {
	+ "a: 1.0",
	+ &struct{ A int }{1},
	+ }, {
	+ "a: 1.0",
	+ &struct{ A uint }{1},
	+ }, {
	+ "a: [1, 2]",
	+ &struct{ A []int }{[]int{1, 2}},
	+ }, {
	+ "a: 1",
	+ &struct{ B int }{0},
	+ }, {
	+ "a: 1",
	+ &struct {
	+ B int "a"
	+ }{1},
	+ }, {
	+ "a: y",
	+ &struct{ A bool }{true},
	+ },
	+
	+ // Some cross type conversions
	+ {
	+ "v: 42",
	+ map[string]uint{"v": 42},
	+ }, {
	+ "v: -42",
	+ map[string]uint{},
	+ }, {
	+ "v: 4294967296",
	+ map[string]uint64{"v": 4294967296},
	+ }, {
	+ "v: -4294967296",
	+ map[string]uint64{},
	+ },
	+
	+ // int
	+ {
	+ "int_max: 2147483647",
	+ map[string]int{"int_max": math.MaxInt32},
	+ },
	+ {
	+ "int_min: -2147483648",
	+ map[string]int{"int_min": math.MinInt32},
	+ },
	+ {
	+ "int_overflow: 9223372036854775808", // math.MaxInt64 + 1
	+ map[string]int{},
	+ },
	+
	+ // int64
	+ {
	+ "int64_max: 9223372036854775807",
	+ map[string]int64{"int64_max": math.MaxInt64},
	+ },
	+ {
	+ "int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
	+ map[string]int64{"int64_max_base2": math.MaxInt64},
	+ },
	+ {
	+ "int64_min: -9223372036854775808",
	+ map[string]int64{"int64_min": math.MinInt64},
	+ },
	+ {
	+ "int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
	+ map[string]int64{"int64_neg_base2": -math.MaxInt64},
	+ },
	+ {
	+ "int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
	+ map[string]int64{},
	+ },
	+
	+ // uint
	+ {
	+ "uint_min: 0",
	+ map[string]uint{"uint_min": 0},
	+ },
	+ {
	+ "uint_max: 4294967295",
	+ map[string]uint{"uint_max": math.MaxUint32},
	+ },
	+ {
	+ "uint_underflow: -1",
	+ map[string]uint{},
	+ },
	+
	+ // uint64
	+ {
	+ "uint64_min: 0",
	+ map[string]uint{"uint64_min": 0},
	+ },
	+ {
	+ "uint64_max: 18446744073709551615",
	+ map[string]uint64{"uint64_max": math.MaxUint64},
	+ },
	+ {
	+ "uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
	+ map[string]uint64{"uint64_max_base2": math.MaxUint64},
	+ },
	+ {
	+ "uint64_maxint64: 9223372036854775807",
	+ map[string]uint64{"uint64_maxint64": math.MaxInt64},
	+ },
	+ {
	+ "uint64_underflow: -1",
	+ map[string]uint64{},
	+ },
	+
	+ // float32
	+ {
	+ "float32_max: 3.40282346638528859811704183484516925440e+38",
	+ map[string]float32{"float32_max": math.MaxFloat32},
	+ },
	+ {
	+ "float32_nonzero: 1.401298464324817070923729583289916131280e-45",
	+ map[string]float32{"float32_nonzero": math.SmallestNonzeroFloat32},
	+ },
	+ {
	+ "float32_maxuint64: 18446744073709551615",
	+ map[string]float32{"float32_maxuint64": float32(math.MaxUint64)},
	+ },
	+ {
	+ "float32_maxuint64+1: 18446744073709551616",
	+ map[string]float32{"float32_maxuint64+1": float32(math.MaxUint64 + 1)},
	+ },
	+
	+ // float64
	+ {
	+ "float64_max: 1.797693134862315708145274237317043567981e+308",
	+ map[string]float64{"float64_max": math.MaxFloat64},
	+ },
	+ {
	+ "float64_nonzero: 4.940656458412465441765687928682213723651e-324",
	+ map[string]float64{"float64_nonzero": math.SmallestNonzeroFloat64},
	+ },
	+ {
	+ "float64_maxuint64: 18446744073709551615",
	+ map[string]float64{"float64_maxuint64": float64(math.MaxUint64)},
	+ },
	+ {
	+ "float64_maxuint64+1: 18446744073709551616",
	+ map[string]float64{"float64_maxuint64+1": float64(math.MaxUint64 + 1)},
	+ },
	+
	+ // Overflow cases.
	+ {
	+ "v: 4294967297",
	+ map[string]int32{},
	+ }, {
	+ "v: 128",
	+ map[string]int8{},
	+ },
	+
	+ // Quoted values.
	+ {
	+ "'1': '\"2\"'",
	+ map[interface{}]interface{}{"1": "\"2\""},
	+ }, {
	+ "v:\n- A\n- 'B\n\n C'\n",
	+ map[string][]string{"v": []string{"A", "B\nC"}},
	+ },
	+
	+ // Explicit tags.
	+ {
	+ "v: !!float '1.1'",
	+ map[string]interface{}{"v": 1.1},
	+ }, {
	+ "v: !!null ''",
	+ map[string]interface{}{"v": nil},
	+ }, {
	+ "%TAG !y! tag:yaml.org,2002:\n---\nv: !y!int '1'",
	+ map[string]interface{}{"v": 1},
	+ },
	+
	+ // Anchors and aliases.
	+ {
	+ "a: &x 1\nb: &y 2\nc: x\nd: y\n",
	+ &struct{ A, B, C, D int }{1, 2, 1, 2},
	+ }, {
	+ "a: &a {c: 1}\nb: *a",
	+ &struct {
	+ A, B struct {
	+ C int
	+ }
	+ }{struct{ C int }{1}, struct{ C int }{1}},
	+ }, {
	+ "a: &a [1, 2]\nb: *a",
	+ &struct{ B []int }{[]int{1, 2}},
	+ }, {
	+ "b: *a\na: &a {c: 1}",
	+ &struct {
	+ A, B struct {
	+ C int
	+ }
	+ }{struct{ C int }{1}, struct{ C int }{1}},
	+ },
	+
	+ // Bug #1133337
	+ {
	+ "foo: ''",
	+ map[string]*string{"foo": new(string)},
	+ }, {
	+ "foo: null",
	+ map[string]string{"foo": ""},
	+ }, {
	+ "foo: null",
	+ map[string]interface{}{"foo": nil},
	+ },
	+
	+ // Ignored field
	+ {
	+ "a: 1\nb: 2\n",
	+ &struct {
	+ A int
	+ B int "-"
	+ }{1, 0},
	+ },
	+
	+ // Bug #1191981
	+ {
	+ "" +
	+ "%YAML 1.1\n" +
	+ "--- !!str\n" +
	+ `"Generic line break (no glyph)\n\` + "\n" +
	+ ` Generic line break (glyphed)\n\` + "\n" +
	+ ` Line separator\u2028\` + "\n" +
	+ ` Paragraph separator\u2029"` + "\n",
	+ "" +
	+ "Generic line break (no glyph)\n" +
	+ "Generic line break (glyphed)\n" +
	+ "Line separator\u2028Paragraph separator\u2029",
	+ },
	+
	+ // Struct inlining
	+ {
	+ "a: 1\nb: 2\nc: 3\n",
	+ &struct {
	+ A int
	+ C inlineB `yaml:",inline"`
	+ }{1, inlineB{2, inlineC{3}}},
	+ },
	+
	+ // Map inlining
	+ {
	+ "a: 1\nb: 2\nc: 3\n",
	+ &struct {
	+ A int
	+ C map[string]int `yaml:",inline"`
	+ }{1, map[string]int{"b": 2, "c": 3}},
	+ },
	+
	+ // bug 1243827
	+ {
	+ "a: -b_c",
	+ map[string]interface{}{"a": "-b_c"},
	+ },
	+ {
	+ "a: +b_c",
	+ map[string]interface{}{"a": "+b_c"},
	+ },
	+ {
	+ "a: 50cent_of_dollar",
	+ map[string]interface{}{"a": "50cent_of_dollar"},
	+ },
	+
	+ // Duration
	+ {
	+ "a: 3s",
	+ map[string]time.Duration{"a": 3 * time.Second},
	+ },
	+
	+ // Issue #24.
	+ {
	+ "a: <foo>",
	+ map[string]string{"a": "<foo>"},
	+ },
	+
	+ // Base 60 floats are obsolete and unsupported.
	+ {
	+ "a: 1:1\n",
	+ map[string]string{"a": "1:1"},
	+ },
	+
	+ // Binary data.
	+ {
	+ "a: !!binary gIGC\n",
	+ map[string]string{"a": "\x80\x81\x82"},
	+ }, {
	+ "a: !!binary \|\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
	+ map[string]string{"a": strings.Repeat("\x90", 54)},
	+ }, {
	+ "a: !!binary \|\n " + strings.Repeat("A", 70) + "\n ==\n",
	+ map[string]string{"a": strings.Repeat("\x00", 52)},
	+ },
	+
	+ // Ordered maps.
	+ {
	+ "{b: 2, a: 1, d: 4, c: 3, sub: {e: 5}}",
	+ &yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
	+ },
	+
	+ // Issue #39.
	+ {
	+ "a:\n b:\n c: d\n",
	+ map[string]struct{ B interface{} }{"a": {map[interface{}]interface{}{"c": "d"}}},
	+ },
	+
	+ // Custom map type.
	+ {
	+ "a: {b: c}",
	+ M{"a": M{"b": "c"}},
	+ },
	+
	+ // Support encoding.TextUnmarshaler.
	+ {
	+ "a: 1.2.3.4\n",
	+ map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
	+ },
	+ {
	+ "a: 2015-02-24T18:19:39Z\n",
	+ map[string]time.Time{"a": time.Unix(1424801979, 0)},
	+ },
	+
	+ // Encode empty lists as zero-length slices.
	+ {
	+ "a: []",
	+ &struct{ A []int }{[]int{}},
	+ },
	+
	+ // UTF-16-LE
	+ {
	+ "\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n\x00",
	+ M{"ñoño": "very yes"},
	+ },
	+ // UTF-16-LE with surrogate.
	+ {
	+ "\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \x00=\xd8\xd4\xdf\n\x00",
	+ M{"ñoño": "very yes 🟔"},
	+ },
	+
	+ // UTF-16-BE
	+ {
	+ "\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n",
	+ M{"ñoño": "very yes"},
	+ },
	+ // UTF-16-BE with surrogate.
	+ {
	+ "\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \xd8=\xdf\xd4\x00\n",
	+ M{"ñoño": "very yes 🟔"},
	+ },
	+}
	+
	+type M map[interface{}]interface{}
	+
	+type inlineB struct {
	+ B int
	+ inlineC `yaml:",inline"`
	+}
	+
	+type inlineC struct {
	+ C int
	+}
	+
	+func (s S) TestUnmarshal(c C) {
	+ for _, item := range unmarshalTests {
	+ t := reflect.ValueOf(item.value).Type()
	+ var value interface{}
	+ switch t.Kind() {
	+ case reflect.Map:
	+ value = reflect.MakeMap(t).Interface()
	+ case reflect.String:
	+ value = reflect.New(t).Interface()
	+ case reflect.Ptr:
	+ value = reflect.New(t.Elem()).Interface()
	+ default:
	+ c.Fatalf("missing case for %s", t)
	+ }
	+ err := yaml.Unmarshal([]byte(item.data), value)
	+ if _, ok := err.(*yaml.TypeError); !ok {
	+ c.Assert(err, IsNil)
	+ }
	+ if t.Kind() == reflect.String {
	+ c.Assert(value.(string), Equals, item.value)
	+ } else {
	+ c.Assert(value, DeepEquals, item.value)
	+ }
	+ }
	+}
	+
	+func (s S) TestUnmarshalNaN(c C) {
	+ value := map[string]interface{}{}
	+ err := yaml.Unmarshal([]byte("notanum: .NaN"), &value)
	+ c.Assert(err, IsNil)
	+ c.Assert(math.IsNaN(value["notanum"].(float64)), Equals, true)
	+}
	+
	+var unmarshalErrorTests = []struct {
	+ data, error string
	+}{
	+ {"v: !!float 'error'", "yaml: cannot decode !!str `error` as a !!float"},
	+ {"v: [A,", "yaml: line 1: did not find expected node content"},
	+ {"v:\n- [A,", "yaml: line 2: did not find expected node content"},
	+ {"a: *b\n", "yaml: unknown anchor 'b' referenced"},
	+ {"a: &a\n b: *a\n", "yaml: anchor 'a' value contains itself"},
	+ {"value: -", "yaml: block sequence entries are not allowed in this context"},
	+ {"a: !!binary ==", "yaml: !!binary value contains invalid base64 data"},
	+ {"{[.]}", `yaml: invalid map key: \[\]interface \{\}\{"\."\}`},
	+ {"{{.}}", `yaml: invalid map key: map\[interface\ \{\}\]interface \{\}\{".":interface \{\}$nil$\}`},
	+}
	+
	+func (s S) TestUnmarshalErrors(c C) {
	+ for _, item := range unmarshalErrorTests {
	+ var value interface{}
	+ err := yaml.Unmarshal([]byte(item.data), &value)
	+ c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value))
	+ }
	+}
	+
	+var unmarshalerTests = []struct {
	+ data, tag string
	+ value interface{}
	+}{
	+ {"_: {hi: there}", "!!map", map[interface{}]interface{}{"hi": "there"}},
	+ {"_: [1,A]", "!!seq", []interface{}{1, "A"}},
	+ {"_: 10", "!!int", 10},
	+ {"_: null", "!!null", nil},
	+ {`_: BAR!`, "!!str", "BAR!"},
	+ {`_: "BAR!"`, "!!str", "BAR!"},
	+ {"_: !!foo 'BAR!'", "!!foo", "BAR!"},
	+}
	+
	+var unmarshalerResult = map[int]error{}
	+
	+type unmarshalerType struct {
	+ value interface{}
	+}
	+
	+func (o *unmarshalerType) UnmarshalYAML(unmarshal func(v interface{}) error) error {
	+ if err := unmarshal(&o.value); err != nil {
	+ return err
	+ }
	+ if i, ok := o.value.(int); ok {
	+ if result, ok := unmarshalerResult[i]; ok {
	+ return result
	+ }
	+ }
	+ return nil
	+}
	+
	+type unmarshalerPointer struct {
	+ Field *unmarshalerType "_"
	+}
	+
	+type unmarshalerValue struct {
	+ Field unmarshalerType "_"
	+}
	+
	+func (s S) TestUnmarshalerPointerField(c C) {
	+ for _, item := range unmarshalerTests {
	+ obj := &unmarshalerPointer{}
	+ err := yaml.Unmarshal([]byte(item.data), obj)
	+ c.Assert(err, IsNil)
	+ if item.value == nil {
	+ c.Assert(obj.Field, IsNil)
	+ } else {
	+ c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
	+ c.Assert(obj.Field.value, DeepEquals, item.value)
	+ }
	+ }
	+}
	+
	+func (s S) TestUnmarshalerValueField(c C) {
	+ for _, item := range unmarshalerTests {
	+ obj := &unmarshalerValue{}
	+ err := yaml.Unmarshal([]byte(item.data), obj)
	+ c.Assert(err, IsNil)
	+ c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
	+ c.Assert(obj.Field.value, DeepEquals, item.value)
	+ }
	+}
	+
	+func (s S) TestUnmarshalerWholeDocument(c C) {
	+ obj := &unmarshalerType{}
	+ err := yaml.Unmarshal([]byte(unmarshalerTests[0].data), obj)
	+ c.Assert(err, IsNil)
	+ value, ok := obj.value.(map[interface{}]interface{})
	+ c.Assert(ok, Equals, true, Commentf("value: %#v", obj.value))
	+ c.Assert(value["_"], DeepEquals, unmarshalerTests[0].value)
	+}
	+
	+func (s S) TestUnmarshalerTypeError(c C) {
	+ unmarshalerResult[2] = &yaml.TypeError{[]string{"foo"}}
	+ unmarshalerResult[4] = &yaml.TypeError{[]string{"bar"}}
	+ defer func() {
	+ delete(unmarshalerResult, 2)
	+ delete(unmarshalerResult, 4)
	+ }()
	+
	+ type T struct {
	+ Before int
	+ After int
	+ M map[string]*unmarshalerType
	+ }
	+ var v T
	+ data := `{before: A, m: {abc: 1, def: 2, ghi: 3, jkl: 4}, after: B}`
	+ err := yaml.Unmarshal([]byte(data), &v)
	+ c.Assert(err, ErrorMatches, ""+
	+ "yaml: unmarshal errors:\n"+
	+ " line 1: cannot unmarshal !!str `A` into int\n"+
	+ " foo\n"+
	+ " bar\n"+
	+ " line 1: cannot unmarshal !!str `B` into int")
	+ c.Assert(v.M["abc"], NotNil)
	+ c.Assert(v.M["def"], IsNil)
	+ c.Assert(v.M["ghi"], NotNil)
	+ c.Assert(v.M["jkl"], IsNil)
	+
	+ c.Assert(v.M["abc"].value, Equals, 1)
	+ c.Assert(v.M["ghi"].value, Equals, 3)
	+}
	+
	+type proxyTypeError struct{}
	+
	+func (v *proxyTypeError) UnmarshalYAML(unmarshal func(interface{}) error) error {
	+ var s string
	+ var a int32
	+ var b int64
	+ if err := unmarshal(&s); err != nil {
	+ panic(err)
	+ }
	+ if s == "a" {
	+ if err := unmarshal(&b); err == nil {
	+ panic("should have failed")
	+ }
	+ return unmarshal(&a)
	+ }
	+ if err := unmarshal(&a); err == nil {
	+ panic("should have failed")
	+ }
	+ return unmarshal(&b)
	+}
	+
	+func (s S) TestUnmarshalerTypeErrorProxying(c C) {
	+ type T struct {
	+ Before int
	+ After int
	+ M map[string]*proxyTypeError
	+ }
	+ var v T
	+ data := `{before: A, m: {abc: a, def: b}, after: B}`
	+ err := yaml.Unmarshal([]byte(data), &v)
	+ c.Assert(err, ErrorMatches, ""+
	+ "yaml: unmarshal errors:\n"+
	+ " line 1: cannot unmarshal !!str `A` into int\n"+
	+ " line 1: cannot unmarshal !!str `a` into int32\n"+
	+ " line 1: cannot unmarshal !!str `b` into int64\n"+
	+ " line 1: cannot unmarshal !!str `B` into int")
	+}
	+
	+type failingUnmarshaler struct{}
	+
	+var failingErr = errors.New("failingErr")
	+
	+func (ft *failingUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
	+ return failingErr
	+}
	+
	+func (s S) TestUnmarshalerError(c C) {
	+ err := yaml.Unmarshal([]byte("a: b"), &failingUnmarshaler{})
	+ c.Assert(err, Equals, failingErr)
	+}
	+
	+type sliceUnmarshaler []int
	+
	+func (su *sliceUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
	+ var slice []int
	+ err := unmarshal(&slice)
	+ if err == nil {
	+ *su = slice
	+ return nil
	+ }
	+
	+ var intVal int
	+ err = unmarshal(&intVal)
	+ if err == nil {
	+ *su = []int{intVal}
	+ return nil
	+ }
	+
	+ return err
	+}
	+
	+func (s S) TestUnmarshalerRetry(c C) {
	+ var su sliceUnmarshaler
	+ err := yaml.Unmarshal([]byte("[1, 2, 3]"), &su)
	+ c.Assert(err, IsNil)
	+ c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1, 2, 3}))
	+
	+ err = yaml.Unmarshal([]byte("1"), &su)
	+ c.Assert(err, IsNil)
	+ c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1}))
	+}
	+
	+// From http://yaml.org/type/merge.html
	+var mergeTests = `
	+anchors:
	+ list:
	+ - &CENTER { "x": 1, "y": 2 }
	+ - &LEFT { "x": 0, "y": 2 }
	+ - &BIG { "r": 10 }
	+ - &SMALL { "r": 1 }
	+
	+# All the following maps are equal:
	+
	+plain:
	+ # Explicit keys
	+ "x": 1
	+ "y": 2
	+ "r": 10
	+ label: center/big
	+
	+mergeOne:
	+ # Merge one map
	+ << : *CENTER
	+ "r": 10
	+ label: center/big
	+
	+mergeMultiple:
	+ # Merge multiple maps
	+ << : [ CENTER, BIG ]
	+ label: center/big
	+
	+override:
	+ # Override
	+ << : [ BIG, LEFT, *SMALL ]
	+ "x": 1
	+ label: center/big
	+
	+shortTag:
	+ # Explicit short merge tag
	+ !!merge "<<" : [ CENTER, BIG ]
	+ label: center/big
	+
	+longTag:
	+ # Explicit merge long tag
	+ !<tag:yaml.org,2002:merge> "<<" : [ CENTER, BIG ]
	+ label: center/big
	+
	+inlineMap:
	+ # Inlined map
	+ << : {"x": 1, "y": 2, "r": 10}
	+ label: center/big
	+
	+inlineSequenceMap:
	+ # Inlined map in sequence
	+ << : [ *CENTER, {"r": 10} ]
	+ label: center/big
	+`
	+
	+func (s S) TestMerge(c C) {
	+ var want = map[interface{}]interface{}{
	+ "x": 1,
	+ "y": 2,
	+ "r": 10,
	+ "label": "center/big",
	+ }
	+
	+ var m map[interface{}]interface{}
	+ err := yaml.Unmarshal([]byte(mergeTests), &m)
	+ c.Assert(err, IsNil)
	+ for name, test := range m {
	+ if name == "anchors" {
	+ continue
	+ }
	+ c.Assert(test, DeepEquals, want, Commentf("test %q failed", name))
	+ }
	+}
	+
	+func (s S) TestMergeStruct(c C) {
	+ type Data struct {
	+ X, Y, R int
	+ Label string
	+ }
	+ want := Data{1, 2, 10, "center/big"}
	+
	+ var m map[string]Data
	+ err := yaml.Unmarshal([]byte(mergeTests), &m)
	+ c.Assert(err, IsNil)
	+ for name, test := range m {
	+ if name == "anchors" {
	+ continue
	+ }
	+ c.Assert(test, Equals, want, Commentf("test %q failed", name))
	+ }
	+}
	+
	+var unmarshalNullTests = []func() interface{}{
	+ func() interface{} { var v interface{}; v = "v"; return &v },
	+ func() interface{} { var s = "s"; return &s },
	+ func() interface{} { var s = "s"; sptr := &s; return &sptr },
	+ func() interface{} { var i = 1; return &i },
	+ func() interface{} { var i = 1; iptr := &i; return &iptr },
	+ func() interface{} { m := map[string]int{"s": 1}; return &m },
	+ func() interface{} { m := map[string]int{"s": 1}; return m },
	+}
	+
	+func (s S) TestUnmarshalNull(c C) {
	+ for _, test := range unmarshalNullTests {
	+ item := test()
	+ zero := reflect.Zero(reflect.TypeOf(item).Elem()).Interface()
	+ err := yaml.Unmarshal([]byte("null"), item)
	+ c.Assert(err, IsNil)
	+ if reflect.TypeOf(item).Kind() == reflect.Map {
	+ c.Assert(reflect.ValueOf(item).Interface(), DeepEquals, reflect.MakeMap(reflect.TypeOf(item)).Interface())
	+ } else {
	+ c.Assert(reflect.ValueOf(item).Elem().Interface(), DeepEquals, zero)
	+ }
	+ }
	+}
	+
	+func (s S) TestUnmarshalSliceOnPreset(c C) {
	+ // Issue #48.
	+ v := struct{ A []int }{[]int{1}}
	+ yaml.Unmarshal([]byte("a: [2]"), &v)
	+ c.Assert(v.A, DeepEquals, []int{2})
	+}
	+
	+//var data []byte
	+//func init() {
	+// var err error
	+// data, err = ioutil.ReadFile("/tmp/file.yaml")
	+// if err != nil {
	+// panic(err)
	+// }
	+//}
	+//
	+//func (s S) BenchmarkUnmarshal(c C) {
	+// var err error
	+// for i := 0; i < c.N; i++ {
	+// var v map[string]interface{}
	+// err = yaml.Unmarshal(data, &v)
	+// }
	+// if err != nil {
	+// panic(err)
	+// }
	+//}
	+//
	+//func (s S) BenchmarkMarshal(c C) {
	+// var v map[string]interface{}
	+// yaml.Unmarshal(data, &v)
	+// c.ResetTimer()
	+// for i := 0; i < c.N; i++ {
	+// yaml.Marshal(&v)
	+// }
	+//}
	diff --git a/src/gopkg.in/yaml.v2/emitterc.go b/src/gopkg.in/yaml.v2/emitterc.go
	new file mode 100644
	index 0000000..2befd55
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/emitterc.go
	@@ -0,0 +1,1685 @@
	+package yaml
	+
	+import (
	+ "bytes"
	+)
	+
	+// Flush the buffer if needed.
	+func flush(emitter *yaml_emitter_t) bool {
	+ if emitter.buffer_pos+5 >= len(emitter.buffer) {
	+ return yaml_emitter_flush(emitter)
	+ }
	+ return true
	+}
	+
	+// Put a character to the output buffer.
	+func put(emitter *yaml_emitter_t, value byte) bool {
	+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
	+ return false
	+ }
	+ emitter.buffer[emitter.buffer_pos] = value
	+ emitter.buffer_pos++
	+ emitter.column++
	+ return true
	+}
	+
	+// Put a line break to the output buffer.
	+func put_break(emitter *yaml_emitter_t) bool {
	+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
	+ return false
	+ }
	+ switch emitter.line_break {
	+ case yaml_CR_BREAK:
	+ emitter.buffer[emitter.buffer_pos] = '\r'
	+ emitter.buffer_pos += 1
	+ case yaml_LN_BREAK:
	+ emitter.buffer[emitter.buffer_pos] = '\n'
	+ emitter.buffer_pos += 1
	+ case yaml_CRLN_BREAK:
	+ emitter.buffer[emitter.buffer_pos+0] = '\r'
	+ emitter.buffer[emitter.buffer_pos+1] = '\n'
	+ emitter.buffer_pos += 2
	+ default:
	+ panic("unknown line break setting")
	+ }
	+ emitter.column = 0
	+ emitter.line++
	+ return true
	+}
	+
	+// Copy a character from a string into buffer.
	+func write(emitter yaml_emitter_t, s []byte, i int) bool {
	+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
	+ return false
	+ }
	+ p := emitter.buffer_pos
	+ w := width(s[*i])
	+ switch w {
	+ case 4:
	+ emitter.buffer[p+3] = s[*i+3]
	+ fallthrough
	+ case 3:
	+ emitter.buffer[p+2] = s[*i+2]
	+ fallthrough
	+ case 2:
	+ emitter.buffer[p+1] = s[*i+1]
	+ fallthrough
	+ case 1:
	+ emitter.buffer[p+0] = s[*i+0]
	+ default:
	+ panic("unknown character width")
	+ }
	+ emitter.column++
	+ emitter.buffer_pos += w
	+ *i += w
	+ return true
	+}
	+
	+// Write a whole string into buffer.
	+func write_all(emitter *yaml_emitter_t, s []byte) bool {
	+ for i := 0; i < len(s); {
	+ if !write(emitter, s, &i) {
	+ return false
	+ }
	+ }
	+ return true
	+}
	+
	+// Copy a line break character from a string into buffer.
	+func write_break(emitter yaml_emitter_t, s []byte, i int) bool {
	+ if s[*i] == '\n' {
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ *i++
	+ } else {
	+ if !write(emitter, s, i) {
	+ return false
	+ }
	+ emitter.column = 0
	+ emitter.line++
	+ }
	+ return true
	+}
	+
	+// Set an emitter error and return false.
	+func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
	+ emitter.error = yaml_EMITTER_ERROR
	+ emitter.problem = problem
	+ return false
	+}
	+
	+// Emit an event.
	+func yaml_emitter_emit(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ emitter.events = append(emitter.events, *event)
	+ for !yaml_emitter_need_more_events(emitter) {
	+ event := &emitter.events[emitter.events_head]
	+ if !yaml_emitter_analyze_event(emitter, event) {
	+ return false
	+ }
	+ if !yaml_emitter_state_machine(emitter, event) {
	+ return false
	+ }
	+ yaml_event_delete(event)
	+ emitter.events_head++
	+ }
	+ return true
	+}
	+
	+// Check if we need to accumulate more events before emitting.
	+//
	+// We accumulate extra
	+// - 1 event for DOCUMENT-START
	+// - 2 events for SEQUENCE-START
	+// - 3 events for MAPPING-START
	+//
	+func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
	+ if emitter.events_head == len(emitter.events) {
	+ return true
	+ }
	+ var accumulate int
	+ switch emitter.events[emitter.events_head].typ {
	+ case yaml_DOCUMENT_START_EVENT:
	+ accumulate = 1
	+ break
	+ case yaml_SEQUENCE_START_EVENT:
	+ accumulate = 2
	+ break
	+ case yaml_MAPPING_START_EVENT:
	+ accumulate = 3
	+ break
	+ default:
	+ return false
	+ }
	+ if len(emitter.events)-emitter.events_head > accumulate {
	+ return false
	+ }
	+ var level int
	+ for i := emitter.events_head; i < len(emitter.events); i++ {
	+ switch emitter.events[i].typ {
	+ case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
	+ level++
	+ case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
	+ level--
	+ }
	+ if level == 0 {
	+ return false
	+ }
	+ }
	+ return true
	+}
	+
	+// Append a directive to the directives stack.
	+func yaml_emitter_append_tag_directive(emitter yaml_emitter_t, value yaml_tag_directive_t, allow_duplicates bool) bool {
	+ for i := 0; i < len(emitter.tag_directives); i++ {
	+ if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
	+ if allow_duplicates {
	+ return true
	+ }
	+ return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
	+ }
	+ }
	+
	+ // [Go] Do we actually need to copy this given garbage collection
	+ // and the lack of deallocating destructors?
	+ tag_copy := yaml_tag_directive_t{
	+ handle: make([]byte, len(value.handle)),
	+ prefix: make([]byte, len(value.prefix)),
	+ }
	+ copy(tag_copy.handle, value.handle)
	+ copy(tag_copy.prefix, value.prefix)
	+ emitter.tag_directives = append(emitter.tag_directives, tag_copy)
	+ return true
	+}
	+
	+// Increase the indentation level.
	+func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
	+ emitter.indents = append(emitter.indents, emitter.indent)
	+ if emitter.indent < 0 {
	+ if flow {
	+ emitter.indent = emitter.best_indent
	+ } else {
	+ emitter.indent = 0
	+ }
	+ } else if !indentless {
	+ emitter.indent += emitter.best_indent
	+ }
	+ return true
	+}
	+
	+// State dispatcher.
	+func yaml_emitter_state_machine(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ switch emitter.state {
	+ default:
	+ case yaml_EMIT_STREAM_START_STATE:
	+ return yaml_emitter_emit_stream_start(emitter, event)
	+
	+ case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
	+ return yaml_emitter_emit_document_start(emitter, event, true)
	+
	+ case yaml_EMIT_DOCUMENT_START_STATE:
	+ return yaml_emitter_emit_document_start(emitter, event, false)
	+
	+ case yaml_EMIT_DOCUMENT_CONTENT_STATE:
	+ return yaml_emitter_emit_document_content(emitter, event)
	+
	+ case yaml_EMIT_DOCUMENT_END_STATE:
	+ return yaml_emitter_emit_document_end(emitter, event)
	+
	+ case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
	+ return yaml_emitter_emit_flow_sequence_item(emitter, event, true)
	+
	+ case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
	+ return yaml_emitter_emit_flow_sequence_item(emitter, event, false)
	+
	+ case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
	+ return yaml_emitter_emit_flow_mapping_key(emitter, event, true)
	+
	+ case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
	+ return yaml_emitter_emit_flow_mapping_key(emitter, event, false)
	+
	+ case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
	+ return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
	+
	+ case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
	+ return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
	+
	+ case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
	+ return yaml_emitter_emit_block_sequence_item(emitter, event, true)
	+
	+ case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
	+ return yaml_emitter_emit_block_sequence_item(emitter, event, false)
	+
	+ case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
	+ return yaml_emitter_emit_block_mapping_key(emitter, event, true)
	+
	+ case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
	+ return yaml_emitter_emit_block_mapping_key(emitter, event, false)
	+
	+ case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
	+ return yaml_emitter_emit_block_mapping_value(emitter, event, true)
	+
	+ case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
	+ return yaml_emitter_emit_block_mapping_value(emitter, event, false)
	+
	+ case yaml_EMIT_END_STATE:
	+ return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
	+ }
	+ panic("invalid emitter state")
	+}
	+
	+// Expect STREAM-START.
	+func yaml_emitter_emit_stream_start(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if event.typ != yaml_STREAM_START_EVENT {
	+ return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
	+ }
	+ if emitter.encoding == yaml_ANY_ENCODING {
	+ emitter.encoding = event.encoding
	+ if emitter.encoding == yaml_ANY_ENCODING {
	+ emitter.encoding = yaml_UTF8_ENCODING
	+ }
	+ }
	+ if emitter.best_indent < 2 \|\| emitter.best_indent > 9 {
	+ emitter.best_indent = 2
	+ }
	+ if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
	+ emitter.best_width = 80
	+ }
	+ if emitter.best_width < 0 {
	+ emitter.best_width = 1<<31 - 1
	+ }
	+ if emitter.line_break == yaml_ANY_BREAK {
	+ emitter.line_break = yaml_LN_BREAK
	+ }
	+
	+ emitter.indent = -1
	+ emitter.line = 0
	+ emitter.column = 0
	+ emitter.whitespace = true
	+ emitter.indention = true
	+
	+ if emitter.encoding != yaml_UTF8_ENCODING {
	+ if !yaml_emitter_write_bom(emitter) {
	+ return false
	+ }
	+ }
	+ emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
	+ return true
	+}
	+
	+// Expect DOCUMENT-START or STREAM-END.
	+func yaml_emitter_emit_document_start(emitter yaml_emitter_t, event yaml_event_t, first bool) bool {
	+
	+ if event.typ == yaml_DOCUMENT_START_EVENT {
	+
	+ if event.version_directive != nil {
	+ if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
	+ return false
	+ }
	+ }
	+
	+ for i := 0; i < len(event.tag_directives); i++ {
	+ tag_directive := &event.tag_directives[i]
	+ if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
	+ return false
	+ }
	+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
	+ return false
	+ }
	+ }
	+
	+ for i := 0; i < len(default_tag_directives); i++ {
	+ tag_directive := &default_tag_directives[i]
	+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
	+ return false
	+ }
	+ }
	+
	+ implicit := event.implicit
	+ if !first \|\| emitter.canonical {
	+ implicit = false
	+ }
	+
	+ if emitter.open_ended && (event.version_directive != nil \|\| len(event.tag_directives) > 0) {
	+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+
	+ if event.version_directive != nil {
	+ implicit = false
	+ if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+
	+ if len(event.tag_directives) > 0 {
	+ implicit = false
	+ for i := 0; i < len(event.tag_directives); i++ {
	+ tag_directive := &event.tag_directives[i]
	+ if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
	+ return false
	+ }
	+ if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ }
	+
	+ if yaml_emitter_check_empty_document(emitter) {
	+ implicit = false
	+ }
	+ if !implicit {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
	+ return false
	+ }
	+ if emitter.canonical {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ }
	+
	+ emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
	+ return true
	+ }
	+
	+ if event.typ == yaml_STREAM_END_EVENT {
	+ if emitter.open_ended {
	+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_flush(emitter) {
	+ return false
	+ }
	+ emitter.state = yaml_EMIT_END_STATE
	+ return true
	+ }
	+
	+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
	+}
	+
	+// Expect the root node.
	+func yaml_emitter_emit_document_content(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
	+ return yaml_emitter_emit_node(emitter, event, true, false, false, false)
	+}
	+
	+// Expect DOCUMENT-END.
	+func yaml_emitter_emit_document_end(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if event.typ != yaml_DOCUMENT_END_EVENT {
	+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if !event.implicit {
	+ // [Go] Allocate the slice elsewhere.
	+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_flush(emitter) {
	+ return false
	+ }
	+ emitter.state = yaml_EMIT_DOCUMENT_START_STATE
	+ emitter.tag_directives = emitter.tag_directives[:0]
	+ return true
	+}
	+
	+// Expect a flow item node.
	+func yaml_emitter_emit_flow_sequence_item(emitter yaml_emitter_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
	+ return false
	+ }
	+ if !yaml_emitter_increase_indent(emitter, true, false) {
	+ return false
	+ }
	+ emitter.flow_level++
	+ }
	+
	+ if event.typ == yaml_SEQUENCE_END_EVENT {
	+ emitter.flow_level--
	+ emitter.indent = emitter.indents[len(emitter.indents)-1]
	+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
	+ if emitter.canonical && !first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
	+ return false
	+ }
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+
	+ return true
	+ }
	+
	+ if !first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
	+ return false
	+ }
	+ }
	+
	+ if emitter.canonical \|\| emitter.column > emitter.best_width {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, true, false, false)
	+}
	+
	+// Expect a flow key node.
	+func yaml_emitter_emit_flow_mapping_key(emitter yaml_emitter_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
	+ return false
	+ }
	+ if !yaml_emitter_increase_indent(emitter, true, false) {
	+ return false
	+ }
	+ emitter.flow_level++
	+ }
	+
	+ if event.typ == yaml_MAPPING_END_EVENT {
	+ emitter.flow_level--
	+ emitter.indent = emitter.indents[len(emitter.indents)-1]
	+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
	+ if emitter.canonical && !first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
	+ return false
	+ }
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+ return true
	+ }
	+
	+ if !first {
	+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
	+ return false
	+ }
	+ }
	+ if emitter.canonical \|\| emitter.column > emitter.best_width {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+
	+ if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
	+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
	+ return false
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
	+}
	+
	+// Expect a flow value node.
	+func yaml_emitter_emit_flow_mapping_value(emitter yaml_emitter_t, event yaml_event_t, simple bool) bool {
	+ if simple {
	+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
	+ return false
	+ }
	+ } else {
	+ if emitter.canonical \|\| emitter.column > emitter.best_width {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
	+ return false
	+ }
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
	+}
	+
	+// Expect a block item node.
	+func yaml_emitter_emit_block_sequence_item(emitter yaml_emitter_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {
	+ return false
	+ }
	+ }
	+ if event.typ == yaml_SEQUENCE_END_EVENT {
	+ emitter.indent = emitter.indents[len(emitter.indents)-1]
	+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+ return true
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
	+ return false
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, true, false, false)
	+}
	+
	+// Expect a block key node.
	+func yaml_emitter_emit_block_mapping_key(emitter yaml_emitter_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ if !yaml_emitter_increase_indent(emitter, false, false) {
	+ return false
	+ }
	+ }
	+ if event.typ == yaml_MAPPING_END_EVENT {
	+ emitter.indent = emitter.indents[len(emitter.indents)-1]
	+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+ return true
	+ }
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if yaml_emitter_check_simple_key(emitter) {
	+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
	+ return false
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
	+}
	+
	+// Expect a block value node.
	+func yaml_emitter_emit_block_mapping_value(emitter yaml_emitter_t, event yaml_event_t, simple bool) bool {
	+ if simple {
	+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
	+ return false
	+ }
	+ } else {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
	+ return false
	+ }
	+ }
	+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
	+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
	+}
	+
	+// Expect a node.
	+func yaml_emitter_emit_node(emitter yaml_emitter_t, event yaml_event_t,
	+ root bool, sequence bool, mapping bool, simple_key bool) bool {
	+
	+ emitter.root_context = root
	+ emitter.sequence_context = sequence
	+ emitter.mapping_context = mapping
	+ emitter.simple_key_context = simple_key
	+
	+ switch event.typ {
	+ case yaml_ALIAS_EVENT:
	+ return yaml_emitter_emit_alias(emitter, event)
	+ case yaml_SCALAR_EVENT:
	+ return yaml_emitter_emit_scalar(emitter, event)
	+ case yaml_SEQUENCE_START_EVENT:
	+ return yaml_emitter_emit_sequence_start(emitter, event)
	+ case yaml_MAPPING_START_EVENT:
	+ return yaml_emitter_emit_mapping_start(emitter, event)
	+ default:
	+ return yaml_emitter_set_emitter_error(emitter,
	+ "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS")
	+ }
	+ return false
	+}
	+
	+// Expect ALIAS.
	+func yaml_emitter_emit_alias(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if !yaml_emitter_process_anchor(emitter) {
	+ return false
	+ }
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+ return true
	+}
	+
	+// Expect SCALAR.
	+func yaml_emitter_emit_scalar(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if !yaml_emitter_select_scalar_style(emitter, event) {
	+ return false
	+ }
	+ if !yaml_emitter_process_anchor(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_process_tag(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_increase_indent(emitter, true, false) {
	+ return false
	+ }
	+ if !yaml_emitter_process_scalar(emitter) {
	+ return false
	+ }
	+ emitter.indent = emitter.indents[len(emitter.indents)-1]
	+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
	+ emitter.state = emitter.states[len(emitter.states)-1]
	+ emitter.states = emitter.states[:len(emitter.states)-1]
	+ return true
	+}
	+
	+// Expect SEQUENCE-START.
	+func yaml_emitter_emit_sequence_start(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if !yaml_emitter_process_anchor(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_process_tag(emitter) {
	+ return false
	+ }
	+ if emitter.flow_level > 0 \|\| emitter.canonical \|\| event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE \|\|
	+ yaml_emitter_check_empty_sequence(emitter) {
	+ emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
	+ } else {
	+ emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
	+ }
	+ return true
	+}
	+
	+// Expect MAPPING-START.
	+func yaml_emitter_emit_mapping_start(emitter yaml_emitter_t, event yaml_event_t) bool {
	+ if !yaml_emitter_process_anchor(emitter) {
	+ return false
	+ }
	+ if !yaml_emitter_process_tag(emitter) {
	+ return false
	+ }
	+ if emitter.flow_level > 0 \|\| emitter.canonical \|\| event.mapping_style() == yaml_FLOW_MAPPING_STYLE \|\|
	+ yaml_emitter_check_empty_mapping(emitter) {
	+ emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
	+ } else {
	+ emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
	+ }
	+ return true
	+}
	+
	+// Check if the document content is an empty scalar.
	+func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
	+ return false // [Go] Huh?
	+}
	+
	+// Check if the next events represent an empty sequence.
	+func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
	+ if len(emitter.events)-emitter.events_head < 2 {
	+ return false
	+ }
	+ return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
	+ emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
	+}
	+
	+// Check if the next events represent an empty mapping.
	+func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
	+ if len(emitter.events)-emitter.events_head < 2 {
	+ return false
	+ }
	+ return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
	+ emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
	+}
	+
	+// Check if the next node can be expressed as a simple key.
	+func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
	+ length := 0
	+ switch emitter.events[emitter.events_head].typ {
	+ case yaml_ALIAS_EVENT:
	+ length += len(emitter.anchor_data.anchor)
	+ case yaml_SCALAR_EVENT:
	+ if emitter.scalar_data.multiline {
	+ return false
	+ }
	+ length += len(emitter.anchor_data.anchor) +
	+ len(emitter.tag_data.handle) +
	+ len(emitter.tag_data.suffix) +
	+ len(emitter.scalar_data.value)
	+ case yaml_SEQUENCE_START_EVENT:
	+ if !yaml_emitter_check_empty_sequence(emitter) {
	+ return false
	+ }
	+ length += len(emitter.anchor_data.anchor) +
	+ len(emitter.tag_data.handle) +
	+ len(emitter.tag_data.suffix)
	+ case yaml_MAPPING_START_EVENT:
	+ if !yaml_emitter_check_empty_mapping(emitter) {
	+ return false
	+ }
	+ length += len(emitter.anchor_data.anchor) +
	+ len(emitter.tag_data.handle) +
	+ len(emitter.tag_data.suffix)
	+ default:
	+ return false
	+ }
	+ return length <= 128
	+}
	+
	+// Determine an acceptable scalar style.
	+func yaml_emitter_select_scalar_style(emitter yaml_emitter_t, event yaml_event_t) bool {
	+
	+ no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
	+ if no_tag && !event.implicit && !event.quoted_implicit {
	+ return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
	+ }
	+
	+ style := event.scalar_style()
	+ if style == yaml_ANY_SCALAR_STYLE {
	+ style = yaml_PLAIN_SCALAR_STYLE
	+ }
	+ if emitter.canonical {
	+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
	+ }
	+ if emitter.simple_key_context && emitter.scalar_data.multiline {
	+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
	+ }
	+
	+ if style == yaml_PLAIN_SCALAR_STYLE {
	+ if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed \|\|
	+ emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
	+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
	+ }
	+ if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 \|\| emitter.simple_key_context) {
	+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
	+ }
	+ if no_tag && !event.implicit {
	+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
	+ }
	+ }
	+ if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
	+ if !emitter.scalar_data.single_quoted_allowed {
	+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
	+ }
	+ }
	+ if style == yaml_LITERAL_SCALAR_STYLE \|\| style == yaml_FOLDED_SCALAR_STYLE {
	+ if !emitter.scalar_data.block_allowed \|\| emitter.flow_level > 0 \|\| emitter.simple_key_context {
	+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
	+ }
	+ }
	+
	+ if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
	+ emitter.tag_data.handle = []byte{'!'}
	+ }
	+ emitter.scalar_data.style = style
	+ return true
	+}
	+
	+// Write an achor.
	+func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
	+ if emitter.anchor_data.anchor == nil {
	+ return true
	+ }
	+ c := []byte{'&'}
	+ if emitter.anchor_data.alias {
	+ c[0] = '*'
	+ }
	+ if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
	+ return false
	+ }
	+ return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
	+}
	+
	+// Write a tag.
	+func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
	+ if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
	+ return true
	+ }
	+ if len(emitter.tag_data.handle) > 0 {
	+ if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
	+ return false
	+ }
	+ if len(emitter.tag_data.suffix) > 0 {
	+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
	+ return false
	+ }
	+ }
	+ } else {
	+ // [Go] Allocate these slices elsewhere.
	+ if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
	+ return false
	+ }
	+ }
	+ return true
	+}
	+
	+// Write a scalar.
	+func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
	+ switch emitter.scalar_data.style {
	+ case yaml_PLAIN_SCALAR_STYLE:
	+ return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
	+
	+ case yaml_SINGLE_QUOTED_SCALAR_STYLE:
	+ return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
	+
	+ case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
	+ return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
	+
	+ case yaml_LITERAL_SCALAR_STYLE:
	+ return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
	+
	+ case yaml_FOLDED_SCALAR_STYLE:
	+ return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
	+ }
	+ panic("unknown scalar style")
	+}
	+
	+// Check if a %YAML directive is valid.
	+func yaml_emitter_analyze_version_directive(emitter yaml_emitter_t, version_directive yaml_version_directive_t) bool {
	+ if version_directive.major != 1 \|\| version_directive.minor != 1 {
	+ return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
	+ }
	+ return true
	+}
	+
	+// Check if a %TAG directive is valid.
	+func yaml_emitter_analyze_tag_directive(emitter yaml_emitter_t, tag_directive yaml_tag_directive_t) bool {
	+ handle := tag_directive.handle
	+ prefix := tag_directive.prefix
	+ if len(handle) == 0 {
	+ return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
	+ }
	+ if handle[0] != '!' {
	+ return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
	+ }
	+ if handle[len(handle)-1] != '!' {
	+ return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
	+ }
	+ for i := 1; i < len(handle)-1; i += width(handle[i]) {
	+ if !is_alpha(handle, i) {
	+ return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
	+ }
	+ }
	+ if len(prefix) == 0 {
	+ return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
	+ }
	+ return true
	+}
	+
	+// Check if an anchor is valid.
	+func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
	+ if len(anchor) == 0 {
	+ problem := "anchor value must not be empty"
	+ if alias {
	+ problem = "alias value must not be empty"
	+ }
	+ return yaml_emitter_set_emitter_error(emitter, problem)
	+ }
	+ for i := 0; i < len(anchor); i += width(anchor[i]) {
	+ if !is_alpha(anchor, i) {
	+ problem := "anchor value must contain alphanumerical characters only"
	+ if alias {
	+ problem = "alias value must contain alphanumerical characters only"
	+ }
	+ return yaml_emitter_set_emitter_error(emitter, problem)
	+ }
	+ }
	+ emitter.anchor_data.anchor = anchor
	+ emitter.anchor_data.alias = alias
	+ return true
	+}
	+
	+// Check if a tag is valid.
	+func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
	+ if len(tag) == 0 {
	+ return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
	+ }
	+ for i := 0; i < len(emitter.tag_directives); i++ {
	+ tag_directive := &emitter.tag_directives[i]
	+ if bytes.HasPrefix(tag, tag_directive.prefix) {
	+ emitter.tag_data.handle = tag_directive.handle
	+ emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
	+ return true
	+ }
	+ }
	+ emitter.tag_data.suffix = tag
	+ return true
	+}
	+
	+// Check if a scalar is valid.
	+func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
	+ var (
	+ block_indicators = false
	+ flow_indicators = false
	+ line_breaks = false
	+ special_characters = false
	+
	+ leading_space = false
	+ leading_break = false
	+ trailing_space = false
	+ trailing_break = false
	+ break_space = false
	+ space_break = false
	+
	+ preceeded_by_whitespace = false
	+ followed_by_whitespace = false
	+ previous_space = false
	+ previous_break = false
	+ )
	+
	+ emitter.scalar_data.value = value
	+
	+ if len(value) == 0 {
	+ emitter.scalar_data.multiline = false
	+ emitter.scalar_data.flow_plain_allowed = false
	+ emitter.scalar_data.block_plain_allowed = true
	+ emitter.scalar_data.single_quoted_allowed = true
	+ emitter.scalar_data.block_allowed = false
	+ return true
	+ }
	+
	+ if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') \|\| (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
	+ block_indicators = true
	+ flow_indicators = true
	+ }
	+
	+ preceeded_by_whitespace = true
	+ for i, w := 0, 0; i < len(value); i += w {
	+ w = width(value[i])
	+ followed_by_whitespace = i+w >= len(value) \|\| is_blank(value, i+w)
	+
	+ if i == 0 {
	+ switch value[i] {
	+ case '#', ',', '[', ']', '{', '}', '&', '*', '!', '\|', '>', '\'', '"', '%', '@', '`':
	+ flow_indicators = true
	+ block_indicators = true
	+ case '?', ':':
	+ flow_indicators = true
	+ if followed_by_whitespace {
	+ block_indicators = true
	+ }
	+ case '-':
	+ if followed_by_whitespace {
	+ flow_indicators = true
	+ block_indicators = true
	+ }
	+ }
	+ } else {
	+ switch value[i] {
	+ case ',', '?', '[', ']', '{', '}':
	+ flow_indicators = true
	+ case ':':
	+ flow_indicators = true
	+ if followed_by_whitespace {
	+ block_indicators = true
	+ }
	+ case '#':
	+ if preceeded_by_whitespace {
	+ flow_indicators = true
	+ block_indicators = true
	+ }
	+ }
	+ }
	+
	+ if !is_printable(value, i) \|\| !is_ascii(value, i) && !emitter.unicode {
	+ special_characters = true
	+ }
	+ if is_space(value, i) {
	+ if i == 0 {
	+ leading_space = true
	+ }
	+ if i+width(value[i]) == len(value) {
	+ trailing_space = true
	+ }
	+ if previous_break {
	+ break_space = true
	+ }
	+ previous_space = true
	+ previous_break = false
	+ } else if is_break(value, i) {
	+ line_breaks = true
	+ if i == 0 {
	+ leading_break = true
	+ }
	+ if i+width(value[i]) == len(value) {
	+ trailing_break = true
	+ }
	+ if previous_space {
	+ space_break = true
	+ }
	+ previous_space = false
	+ previous_break = true
	+ } else {
	+ previous_space = false
	+ previous_break = false
	+ }
	+
	+ // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
	+ preceeded_by_whitespace = is_blankz(value, i)
	+ }
	+
	+ emitter.scalar_data.multiline = line_breaks
	+ emitter.scalar_data.flow_plain_allowed = true
	+ emitter.scalar_data.block_plain_allowed = true
	+ emitter.scalar_data.single_quoted_allowed = true
	+ emitter.scalar_data.block_allowed = true
	+
	+ if leading_space \|\| leading_break \|\| trailing_space \|\| trailing_break {
	+ emitter.scalar_data.flow_plain_allowed = false
	+ emitter.scalar_data.block_plain_allowed = false
	+ }
	+ if trailing_space {
	+ emitter.scalar_data.block_allowed = false
	+ }
	+ if break_space {
	+ emitter.scalar_data.flow_plain_allowed = false
	+ emitter.scalar_data.block_plain_allowed = false
	+ emitter.scalar_data.single_quoted_allowed = false
	+ }
	+ if space_break \|\| special_characters {
	+ emitter.scalar_data.flow_plain_allowed = false
	+ emitter.scalar_data.block_plain_allowed = false
	+ emitter.scalar_data.single_quoted_allowed = false
	+ emitter.scalar_data.block_allowed = false
	+ }
	+ if line_breaks {
	+ emitter.scalar_data.flow_plain_allowed = false
	+ emitter.scalar_data.block_plain_allowed = false
	+ }
	+ if flow_indicators {
	+ emitter.scalar_data.flow_plain_allowed = false
	+ }
	+ if block_indicators {
	+ emitter.scalar_data.block_plain_allowed = false
	+ }
	+ return true
	+}
	+
	+// Check if the event data is valid.
	+func yaml_emitter_analyze_event(emitter yaml_emitter_t, event yaml_event_t) bool {
	+
	+ emitter.anchor_data.anchor = nil
	+ emitter.tag_data.handle = nil
	+ emitter.tag_data.suffix = nil
	+ emitter.scalar_data.value = nil
	+
	+ switch event.typ {
	+ case yaml_ALIAS_EVENT:
	+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
	+ return false
	+ }
	+
	+ case yaml_SCALAR_EVENT:
	+ if len(event.anchor) > 0 {
	+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
	+ return false
	+ }
	+ }
	+ if len(event.tag) > 0 && (emitter.canonical \|\| (!event.implicit && !event.quoted_implicit)) {
	+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
	+ return false
	+ }
	+ }
	+ if !yaml_emitter_analyze_scalar(emitter, event.value) {
	+ return false
	+ }
	+
	+ case yaml_SEQUENCE_START_EVENT:
	+ if len(event.anchor) > 0 {
	+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
	+ return false
	+ }
	+ }
	+ if len(event.tag) > 0 && (emitter.canonical \|\| !event.implicit) {
	+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
	+ return false
	+ }
	+ }
	+
	+ case yaml_MAPPING_START_EVENT:
	+ if len(event.anchor) > 0 {
	+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
	+ return false
	+ }
	+ }
	+ if len(event.tag) > 0 && (emitter.canonical \|\| !event.implicit) {
	+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
	+ return false
	+ }
	+ }
	+ }
	+ return true
	+}
	+
	+// Write the BOM character.
	+func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
	+ if !flush(emitter) {
	+ return false
	+ }
	+ pos := emitter.buffer_pos
	+ emitter.buffer[pos+0] = '\xEF'
	+ emitter.buffer[pos+1] = '\xBB'
	+ emitter.buffer[pos+2] = '\xBF'
	+ emitter.buffer_pos += 3
	+ return true
	+}
	+
	+func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
	+ indent := emitter.indent
	+ if indent < 0 {
	+ indent = 0
	+ }
	+ if !emitter.indention \|\| emitter.column > indent \|\| (emitter.column == indent && !emitter.whitespace) {
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ }
	+ for emitter.column < indent {
	+ if !put(emitter, ' ') {
	+ return false
	+ }
	+ }
	+ emitter.whitespace = true
	+ emitter.indention = true
	+ return true
	+}
	+
	+func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
	+ if need_whitespace && !emitter.whitespace {
	+ if !put(emitter, ' ') {
	+ return false
	+ }
	+ }
	+ if !write_all(emitter, indicator) {
	+ return false
	+ }
	+ emitter.whitespace = is_whitespace
	+ emitter.indention = (emitter.indention && is_indention)
	+ emitter.open_ended = false
	+ return true
	+}
	+
	+func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
	+ if !write_all(emitter, value) {
	+ return false
	+ }
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ return true
	+}
	+
	+func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
	+ if !emitter.whitespace {
	+ if !put(emitter, ' ') {
	+ return false
	+ }
	+ }
	+ if !write_all(emitter, value) {
	+ return false
	+ }
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ return true
	+}
	+
	+func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
	+ if need_whitespace && !emitter.whitespace {
	+ if !put(emitter, ' ') {
	+ return false
	+ }
	+ }
	+ for i := 0; i < len(value); {
	+ var must_write bool
	+ switch value[i] {
	+ case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
	+ must_write = true
	+ default:
	+ must_write = is_alpha(value, i)
	+ }
	+ if must_write {
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ } else {
	+ w := width(value[i])
	+ for k := 0; k < w; k++ {
	+ octet := value[i]
	+ i++
	+ if !put(emitter, '%') {
	+ return false
	+ }
	+
	+ c := octet >> 4
	+ if c < 10 {
	+ c += '0'
	+ } else {
	+ c += 'A' - 10
	+ }
	+ if !put(emitter, c) {
	+ return false
	+ }
	+
	+ c = octet & 0x0f
	+ if c < 10 {
	+ c += '0'
	+ } else {
	+ c += 'A' - 10
	+ }
	+ if !put(emitter, c) {
	+ return false
	+ }
	+ }
	+ }
	+ }
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ return true
	+}
	+
	+func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
	+ if !emitter.whitespace {
	+ if !put(emitter, ' ') {
	+ return false
	+ }
	+ }
	+
	+ spaces := false
	+ breaks := false
	+ for i := 0; i < len(value); {
	+ if is_space(value, i) {
	+ if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ i += width(value[i])
	+ } else {
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ }
	+ spaces = true
	+ } else if is_break(value, i) {
	+ if !breaks && value[i] == '\n' {
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ }
	+ if !write_break(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = true
	+ breaks = true
	+ } else {
	+ if breaks {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = false
	+ spaces = false
	+ breaks = false
	+ }
	+ }
	+
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ if emitter.root_context {
	+ emitter.open_ended = true
	+ }
	+
	+ return true
	+}
	+
	+func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
	+
	+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
	+ return false
	+ }
	+
	+ spaces := false
	+ breaks := false
	+ for i := 0; i < len(value); {
	+ if is_space(value, i) {
	+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ i += width(value[i])
	+ } else {
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ }
	+ spaces = true
	+ } else if is_break(value, i) {
	+ if !breaks && value[i] == '\n' {
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ }
	+ if !write_break(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = true
	+ breaks = true
	+ } else {
	+ if breaks {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if value[i] == '\'' {
	+ if !put(emitter, '\'') {
	+ return false
	+ }
	+ }
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = false
	+ spaces = false
	+ breaks = false
	+ }
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
	+ return false
	+ }
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ return true
	+}
	+
	+func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
	+ spaces := false
	+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
	+ return false
	+ }
	+
	+ for i := 0; i < len(value); {
	+ if !is_printable(value, i) \|\| (!emitter.unicode && !is_ascii(value, i)) \|\|
	+ is_bom(value, i) \|\| is_break(value, i) \|\|
	+ value[i] == '"' \|\| value[i] == '\\' {
	+
	+ octet := value[i]
	+
	+ var w int
	+ var v rune
	+ switch {
	+ case octet&0x80 == 0x00:
	+ w, v = 1, rune(octet&0x7F)
	+ case octet&0xE0 == 0xC0:
	+ w, v = 2, rune(octet&0x1F)
	+ case octet&0xF0 == 0xE0:
	+ w, v = 3, rune(octet&0x0F)
	+ case octet&0xF8 == 0xF0:
	+ w, v = 4, rune(octet&0x07)
	+ }
	+ for k := 1; k < w; k++ {
	+ octet = value[i+k]
	+ v = (v << 6) + (rune(octet) & 0x3F)
	+ }
	+ i += w
	+
	+ if !put(emitter, '\\') {
	+ return false
	+ }
	+
	+ var ok bool
	+ switch v {
	+ case 0x00:
	+ ok = put(emitter, '0')
	+ case 0x07:
	+ ok = put(emitter, 'a')
	+ case 0x08:
	+ ok = put(emitter, 'b')
	+ case 0x09:
	+ ok = put(emitter, 't')
	+ case 0x0A:
	+ ok = put(emitter, 'n')
	+ case 0x0b:
	+ ok = put(emitter, 'v')
	+ case 0x0c:
	+ ok = put(emitter, 'f')
	+ case 0x0d:
	+ ok = put(emitter, 'r')
	+ case 0x1b:
	+ ok = put(emitter, 'e')
	+ case 0x22:
	+ ok = put(emitter, '"')
	+ case 0x5c:
	+ ok = put(emitter, '\\')
	+ case 0x85:
	+ ok = put(emitter, 'N')
	+ case 0xA0:
	+ ok = put(emitter, '_')
	+ case 0x2028:
	+ ok = put(emitter, 'L')
	+ case 0x2029:
	+ ok = put(emitter, 'P')
	+ default:
	+ if v <= 0xFF {
	+ ok = put(emitter, 'x')
	+ w = 2
	+ } else if v <= 0xFFFF {
	+ ok = put(emitter, 'u')
	+ w = 4
	+ } else {
	+ ok = put(emitter, 'U')
	+ w = 8
	+ }
	+ for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
	+ digit := byte((v >> uint(k)) & 0x0F)
	+ if digit < 10 {
	+ ok = put(emitter, digit+'0')
	+ } else {
	+ ok = put(emitter, digit+'A'-10)
	+ }
	+ }
	+ }
	+ if !ok {
	+ return false
	+ }
	+ spaces = false
	+ } else if is_space(value, i) {
	+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ if is_space(value, i+1) {
	+ if !put(emitter, '\\') {
	+ return false
	+ }
	+ }
	+ i += width(value[i])
	+ } else if !write(emitter, value, &i) {
	+ return false
	+ }
	+ spaces = true
	+ } else {
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ spaces = false
	+ }
	+ }
	+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
	+ return false
	+ }
	+ emitter.whitespace = false
	+ emitter.indention = false
	+ return true
	+}
	+
	+func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
	+ if is_space(value, 0) \|\| is_break(value, 0) {
	+ indent_hint := []byte{'0' + byte(emitter.best_indent)}
	+ if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
	+ return false
	+ }
	+ }
	+
	+ emitter.open_ended = false
	+
	+ var chomp_hint [1]byte
	+ if len(value) == 0 {
	+ chomp_hint[0] = '-'
	+ } else {
	+ i := len(value) - 1
	+ for value[i]&0xC0 == 0x80 {
	+ i--
	+ }
	+ if !is_break(value, i) {
	+ chomp_hint[0] = '-'
	+ } else if i == 0 {
	+ chomp_hint[0] = '+'
	+ emitter.open_ended = true
	+ } else {
	+ i--
	+ for value[i]&0xC0 == 0x80 {
	+ i--
	+ }
	+ if is_break(value, i) {
	+ chomp_hint[0] = '+'
	+ emitter.open_ended = true
	+ }
	+ }
	+ }
	+ if chomp_hint[0] != 0 {
	+ if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
	+ return false
	+ }
	+ }
	+ return true
	+}
	+
	+func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
	+ if !yaml_emitter_write_indicator(emitter, []byte{'\|'}, true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
	+ return false
	+ }
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ emitter.indention = true
	+ emitter.whitespace = true
	+ breaks := true
	+ for i := 0; i < len(value); {
	+ if is_break(value, i) {
	+ if !write_break(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = true
	+ breaks = true
	+ } else {
	+ if breaks {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ }
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = false
	+ breaks = false
	+ }
	+ }
	+
	+ return true
	+}
	+
	+func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
	+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
	+ return false
	+ }
	+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
	+ return false
	+ }
	+
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ emitter.indention = true
	+ emitter.whitespace = true
	+
	+ breaks := true
	+ leading_spaces := true
	+ for i := 0; i < len(value); {
	+ if is_break(value, i) {
	+ if !breaks && !leading_spaces && value[i] == '\n' {
	+ k := 0
	+ for is_break(value, k) {
	+ k += width(value[k])
	+ }
	+ if !is_blankz(value, k) {
	+ if !put_break(emitter) {
	+ return false
	+ }
	+ }
	+ }
	+ if !write_break(emitter, value, &i) {
	+ return false
	+ }
	+ emitter.indention = true
	+ breaks = true
	+ } else {
	+ if breaks {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ leading_spaces = is_blank(value, i)
	+ }
	+ if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
	+ if !yaml_emitter_write_indent(emitter) {
	+ return false
	+ }
	+ i += width(value[i])
	+ } else {
	+ if !write(emitter, value, &i) {
	+ return false
	+ }
	+ }
	+ emitter.indention = false
	+ breaks = false
	+ }
	+ }
	+ return true
	+}
	diff --git a/src/gopkg.in/yaml.v2/encode.go b/src/gopkg.in/yaml.v2/encode.go
	new file mode 100644
	index 0000000..84f8499
	--- /dev/null
	+++ b/src/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()
	+}
	diff --git a/src/gopkg.in/yaml.v2/encode_test.go b/src/gopkg.in/yaml.v2/encode_test.go
	new file mode 100644
	index 0000000..84099bd
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/encode_test.go
	@@ -0,0 +1,501 @@
	+package yaml_test
	+
	+import (
	+ "fmt"
	+ "math"
	+ "strconv"
	+ "strings"
	+ "time"
	+
	+ . "gopkg.in/check.v1"
	+ "gopkg.in/yaml.v2"
	+ "net"
	+ "os"
	+)
	+
	+var marshalIntTest = 123
	+
	+var marshalTests = []struct {
	+ value interface{}
	+ data string
	+}{
	+ {
	+ nil,
	+ "null\n",
	+ }, {
	+ &struct{}{},
	+ "{}\n",
	+ }, {
	+ map[string]string{"v": "hi"},
	+ "v: hi\n",
	+ }, {
	+ map[string]interface{}{"v": "hi"},
	+ "v: hi\n",
	+ }, {
	+ map[string]string{"v": "true"},
	+ "v: \"true\"\n",
	+ }, {
	+ map[string]string{"v": "false"},
	+ "v: \"false\"\n",
	+ }, {
	+ map[string]interface{}{"v": true},
	+ "v: true\n",
	+ }, {
	+ map[string]interface{}{"v": false},
	+ "v: false\n",
	+ }, {
	+ map[string]interface{}{"v": 10},
	+ "v: 10\n",
	+ }, {
	+ map[string]interface{}{"v": -10},
	+ "v: -10\n",
	+ }, {
	+ map[string]uint{"v": 42},
	+ "v: 42\n",
	+ }, {
	+ map[string]interface{}{"v": int64(4294967296)},
	+ "v: 4294967296\n",
	+ }, {
	+ map[string]int64{"v": int64(4294967296)},
	+ "v: 4294967296\n",
	+ }, {
	+ map[string]uint64{"v": 4294967296},
	+ "v: 4294967296\n",
	+ }, {
	+ map[string]interface{}{"v": "10"},
	+ "v: \"10\"\n",
	+ }, {
	+ map[string]interface{}{"v": 0.1},
	+ "v: 0.1\n",
	+ }, {
	+ map[string]interface{}{"v": float64(0.1)},
	+ "v: 0.1\n",
	+ }, {
	+ map[string]interface{}{"v": -0.1},
	+ "v: -0.1\n",
	+ }, {
	+ map[string]interface{}{"v": math.Inf(+1)},
	+ "v: .inf\n",
	+ }, {
	+ map[string]interface{}{"v": math.Inf(-1)},
	+ "v: -.inf\n",
	+ }, {
	+ map[string]interface{}{"v": math.NaN()},
	+ "v: .nan\n",
	+ }, {
	+ map[string]interface{}{"v": nil},
	+ "v: null\n",
	+ }, {
	+ map[string]interface{}{"v": ""},
	+ "v: \"\"\n",
	+ }, {
	+ map[string][]string{"v": []string{"A", "B"}},
	+ "v:\n- A\n- B\n",
	+ }, {
	+ map[string][]string{"v": []string{"A", "B\nC"}},
	+ "v:\n- A\n- \|-\n B\n C\n",
	+ }, {
	+ map[string][]interface{}{"v": []interface{}{"A", 1, map[string][]int{"B": []int{2, 3}}}},
	+ "v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
	+ }, {
	+ map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
	+ "a:\n b: c\n",
	+ }, {
	+ map[string]interface{}{"a": "-"},
	+ "a: '-'\n",
	+ },
	+
	+ // Simple values.
	+ {
	+ &marshalIntTest,
	+ "123\n",
	+ },
	+
	+ // Structures
	+ {
	+ &struct{ Hello string }{"world"},
	+ "hello: world\n",
	+ }, {
	+ &struct {
	+ A struct {
	+ B string
	+ }
	+ }{struct{ B string }{"c"}},
	+ "a:\n b: c\n",
	+ }, {
	+ &struct {
	+ A *struct {
	+ B string
	+ }
	+ }{&struct{ B string }{"c"}},
	+ "a:\n b: c\n",
	+ }, {
	+ &struct {
	+ A *struct {
	+ B string
	+ }
	+ }{},
	+ "a: null\n",
	+ }, {
	+ &struct{ A int }{1},
	+ "a: 1\n",
	+ }, {
	+ &struct{ A []int }{[]int{1, 2}},
	+ "a:\n- 1\n- 2\n",
	+ }, {
	+ &struct {
	+ B int "a"
	+ }{1},
	+ "a: 1\n",
	+ }, {
	+ &struct{ A bool }{true},
	+ "a: true\n",
	+ },
	+
	+ // Conditional flag
	+ {
	+ &struct {
	+ A int "a,omitempty"
	+ B int "b,omitempty"
	+ }{1, 0},
	+ "a: 1\n",
	+ }, {
	+ &struct {
	+ A int "a,omitempty"
	+ B int "b,omitempty"
	+ }{0, 0},
	+ "{}\n",
	+ }, {
	+ &struct {
	+ A *struct{ X, y int } "a,omitempty,flow"
	+ }{&struct{ X, y int }{1, 2}},
	+ "a: {x: 1}\n",
	+ }, {
	+ &struct {
	+ A *struct{ X, y int } "a,omitempty,flow"
	+ }{nil},
	+ "{}\n",
	+ }, {
	+ &struct {
	+ A *struct{ X, y int } "a,omitempty,flow"
	+ }{&struct{ X, y int }{}},
	+ "a: {x: 0}\n",
	+ }, {
	+ &struct {
	+ A struct{ X, y int } "a,omitempty,flow"
	+ }{struct{ X, y int }{1, 2}},
	+ "a: {x: 1}\n",
	+ }, {
	+ &struct {
	+ A struct{ X, y int } "a,omitempty,flow"
	+ }{struct{ X, y int }{0, 1}},
	+ "{}\n",
	+ }, {
	+ &struct {
	+ A float64 "a,omitempty"
	+ B float64 "b,omitempty"
	+ }{1, 0},
	+ "a: 1\n",
	+ },
	+
	+ // Flow flag
	+ {
	+ &struct {
	+ A []int "a,flow"
	+ }{[]int{1, 2}},
	+ "a: [1, 2]\n",
	+ }, {
	+ &struct {
	+ A map[string]string "a,flow"
	+ }{map[string]string{"b": "c", "d": "e"}},
	+ "a: {b: c, d: e}\n",
	+ }, {
	+ &struct {
	+ A struct {
	+ B, D string
	+ } "a,flow"
	+ }{struct{ B, D string }{"c", "e"}},
	+ "a: {b: c, d: e}\n",
	+ },
	+
	+ // Unexported field
	+ {
	+ &struct {
	+ u int
	+ A int
	+ }{0, 1},
	+ "a: 1\n",
	+ },
	+
	+ // Ignored field
	+ {
	+ &struct {
	+ A int
	+ B int "-"
	+ }{1, 2},
	+ "a: 1\n",
	+ },
	+
	+ // Struct inlining
	+ {
	+ &struct {
	+ A int
	+ C inlineB `yaml:",inline"`
	+ }{1, inlineB{2, inlineC{3}}},
	+ "a: 1\nb: 2\nc: 3\n",
	+ },
	+
	+ // Map inlining
	+ {
	+ &struct {
	+ A int
	+ C map[string]int `yaml:",inline"`
	+ }{1, map[string]int{"b": 2, "c": 3}},
	+ "a: 1\nb: 2\nc: 3\n",
	+ },
	+
	+ // Duration
	+ {
	+ map[string]time.Duration{"a": 3 * time.Second},
	+ "a: 3s\n",
	+ },
	+
	+ // Issue #24: bug in map merging logic.
	+ {
	+ map[string]string{"a": "<foo>"},
	+ "a: <foo>\n",
	+ },
	+
	+ // Issue #34: marshal unsupported base 60 floats quoted for compatibility
	+ // with old YAML 1.1 parsers.
	+ {
	+ map[string]string{"a": "1:1"},
	+ "a: \"1:1\"\n",
	+ },
	+
	+ // Binary data.
	+ {
	+ map[string]string{"a": "\x00"},
	+ "a: \"\\0\"\n",
	+ }, {
	+ map[string]string{"a": "\x80\x81\x82"},
	+ "a: !!binary gIGC\n",
	+ }, {
	+ map[string]string{"a": strings.Repeat("\x90", 54)},
	+ "a: !!binary \|\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
	+ },
	+
	+ // Ordered maps.
	+ {
	+ &yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
	+ "b: 2\na: 1\nd: 4\nc: 3\nsub:\n e: 5\n",
	+ },
	+
	+ // Encode unicode as utf-8 rather than in escaped form.
	+ {
	+ map[string]string{"a": "你好"},
	+ "a: 你好\n",
	+ },
	+
	+ // Support encoding.TextMarshaler.
	+ {
	+ map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
	+ "a: 1.2.3.4\n",
	+ },
	+ {
	+ map[string]time.Time{"a": time.Unix(1424801979, 0)},
	+ "a: 2015-02-24T18:19:39Z\n",
	+ },
	+
	+ // Ensure strings containing ": " are quoted (reported as PR #43, but not reproducible).
	+ {
	+ map[string]string{"a": "b: c"},
	+ "a: 'b: c'\n",
	+ },
	+
	+ // Containing hash mark ('#') in string should be quoted
	+ {
	+ map[string]string{"a": "Hello #comment"},
	+ "a: 'Hello #comment'\n",
	+ },
	+ {
	+ map[string]string{"a": "你好 #comment"},
	+ "a: '你好 #comment'\n",
	+ },
	+}
	+
	+func (s S) TestMarshal(c C) {
	+ defer os.Setenv("TZ", os.Getenv("TZ"))
	+ os.Setenv("TZ", "UTC")
	+ for _, item := range marshalTests {
	+ data, err := yaml.Marshal(item.value)
	+ c.Assert(err, IsNil)
	+ c.Assert(string(data), Equals, item.data)
	+ }
	+}
	+
	+var marshalErrorTests = []struct {
	+ value interface{}
	+ error string
	+ panic string
	+}{{
	+ value: &struct {
	+ B int
	+ inlineB ",inline"
	+ }{1, inlineB{2, inlineC{3}}},
	+ panic: `Duplicated key 'b' in struct struct \{ B int; .*`,
	+}, {
	+ value: &struct {
	+ A int
	+ B map[string]int ",inline"
	+ }{1, map[string]int{"a": 2}},
	+ panic: `Can't have key "a" in inlined map; conflicts with struct field`,
	+}}
	+
	+func (s S) TestMarshalErrors(c C) {
	+ for _, item := range marshalErrorTests {
	+ if item.panic != "" {
	+ c.Assert(func() { yaml.Marshal(item.value) }, PanicMatches, item.panic)
	+ } else {
	+ _, err := yaml.Marshal(item.value)
	+ c.Assert(err, ErrorMatches, item.error)
	+ }
	+ }
	+}
	+
	+func (s S) TestMarshalTypeCache(c C) {
	+ var data []byte
	+ var err error
	+ func() {
	+ type T struct{ A int }
	+ data, err = yaml.Marshal(&T{})
	+ c.Assert(err, IsNil)
	+ }()
	+ func() {
	+ type T struct{ B int }
	+ data, err = yaml.Marshal(&T{})
	+ c.Assert(err, IsNil)
	+ }()
	+ c.Assert(string(data), Equals, "b: 0\n")
	+}
	+
	+var marshalerTests = []struct {
	+ data string
	+ value interface{}
	+}{
	+ {"_:\n hi: there\n", map[interface{}]interface{}{"hi": "there"}},
	+ {"_:\n- 1\n- A\n", []interface{}{1, "A"}},
	+ {"_: 10\n", 10},
	+ {"_: null\n", nil},
	+ {"_: BAR!\n", "BAR!"},
	+}
	+
	+type marshalerType struct {
	+ value interface{}
	+}
	+
	+func (o marshalerType) MarshalText() ([]byte, error) {
	+ panic("MarshalText called on type with MarshalYAML")
	+}
	+
	+func (o marshalerType) MarshalYAML() (interface{}, error) {
	+ return o.value, nil
	+}
	+
	+type marshalerValue struct {
	+ Field marshalerType "_"
	+}
	+
	+func (s S) TestMarshaler(c C) {
	+ for _, item := range marshalerTests {
	+ obj := &marshalerValue{}
	+ obj.Field.value = item.value
	+ data, err := yaml.Marshal(obj)
	+ c.Assert(err, IsNil)
	+ c.Assert(string(data), Equals, string(item.data))
	+ }
	+}
	+
	+func (s S) TestMarshalerWholeDocument(c C) {
	+ obj := &marshalerType{}
	+ obj.value = map[string]string{"hello": "world!"}
	+ data, err := yaml.Marshal(obj)
	+ c.Assert(err, IsNil)
	+ c.Assert(string(data), Equals, "hello: world!\n")
	+}
	+
	+type failingMarshaler struct{}
	+
	+func (ft *failingMarshaler) MarshalYAML() (interface{}, error) {
	+ return nil, failingErr
	+}
	+
	+func (s S) TestMarshalerError(c C) {
	+ _, err := yaml.Marshal(&failingMarshaler{})
	+ c.Assert(err, Equals, failingErr)
	+}
	+
	+func (s S) TestSortedOutput(c C) {
	+ order := []interface{}{
	+ false,
	+ true,
	+ 1,
	+ uint(1),
	+ 1.0,
	+ 1.1,
	+ 1.2,
	+ 2,
	+ uint(2),
	+ 2.0,
	+ 2.1,
	+ "",
	+ ".1",
	+ ".2",
	+ ".a",
	+ "1",
	+ "2",
	+ "a!10",
	+ "a/2",
	+ "a/10",
	+ "a~10",
	+ "ab/1",
	+ "b/1",
	+ "b/01",
	+ "b/2",
	+ "b/02",
	+ "b/3",
	+ "b/03",
	+ "b1",
	+ "b01",
	+ "b3",
	+ "c2.10",
	+ "c10.2",
	+ "d1",
	+ "d12",
	+ "d12a",
	+ }
	+ m := make(map[interface{}]int)
	+ for _, k := range order {
	+ m[k] = 1
	+ }
	+ data, err := yaml.Marshal(m)
	+ c.Assert(err, IsNil)
	+ out := "\n" + string(data)
	+ last := 0
	+ for i, k := range order {
	+ repr := fmt.Sprint(k)
	+ if s, ok := k.(string); ok {
	+ if _, err = strconv.ParseFloat(repr, 32); s == "" \|\| err == nil {
	+ repr = `"` + repr + `"`
	+ }
	+ }
	+ index := strings.Index(out, "\n"+repr+":")
	+ if index == -1 {
	+ c.Fatalf("%#v is not in the output: %#v", k, out)
	+ }
	+ if index < last {
	+ c.Fatalf("%#v was generated before %#v: %q", k, order[i-1], out)
	+ }
	+ last = index
	+ }
	+}
	diff --git a/src/gopkg.in/yaml.v2/parserc.go b/src/gopkg.in/yaml.v2/parserc.go
	new file mode 100644
	index 0000000..0a7037a
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/parserc.go
	@@ -0,0 +1,1096 @@
	+package yaml
	+
	+import (
	+ "bytes"
	+)
	+
	+// The parser implements the following grammar:
	+//
	+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
	+// implicit_document ::= block_node DOCUMENT-END*
	+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
	+// block_node_or_indentless_sequence ::=
	+// ALIAS
	+// \| properties (block_content \| indentless_block_sequence)?
	+// \| block_content
	+// \| indentless_block_sequence
	+// block_node ::= ALIAS
	+// \| properties block_content?
	+// \| block_content
	+// flow_node ::= ALIAS
	+// \| properties flow_content?
	+// \| flow_content
	+// properties ::= TAG ANCHOR? \| ANCHOR TAG?
	+// block_content ::= block_collection \| flow_collection \| SCALAR
	+// flow_content ::= flow_collection \| SCALAR
	+// block_collection ::= block_sequence \| block_mapping
	+// flow_collection ::= flow_sequence \| flow_mapping
	+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
	+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
	+// block_mapping ::= BLOCK-MAPPING_START
	+// ((KEY block_node_or_indentless_sequence?)?
	+// (VALUE block_node_or_indentless_sequence?)?)*
	+// BLOCK-END
	+// flow_sequence ::= FLOW-SEQUENCE-START
	+// (flow_sequence_entry FLOW-ENTRY)*
	+// flow_sequence_entry?
	+// FLOW-SEQUENCE-END
	+// flow_sequence_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// flow_mapping ::= FLOW-MAPPING-START
	+// (flow_mapping_entry FLOW-ENTRY)*
	+// flow_mapping_entry?
	+// FLOW-MAPPING-END
	+// flow_mapping_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+
	+// Peek the next token in the token queue.
	+func peek_token(parser yaml_parser_t) yaml_token_t {
	+ if parser.token_available \|\| yaml_parser_fetch_more_tokens(parser) {
	+ return &parser.tokens[parser.tokens_head]
	+ }
	+ return nil
	+}
	+
	+// Remove the next token from the queue (must be called after peek_token).
	+func skip_token(parser *yaml_parser_t) {
	+ parser.token_available = false
	+ parser.tokens_parsed++
	+ parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
	+ parser.tokens_head++
	+}
	+
	+// Get the next event.
	+func yaml_parser_parse(parser yaml_parser_t, event yaml_event_t) bool {
	+ // Erase the event object.
	+ *event = yaml_event_t{}
	+
	+ // No events after the end of the stream or error.
	+ if parser.stream_end_produced \|\| parser.error != yaml_NO_ERROR \|\| parser.state == yaml_PARSE_END_STATE {
	+ return true
	+ }
	+
	+ // Generate the next event.
	+ return yaml_parser_state_machine(parser, event)
	+}
	+
	+// Set parser error.
	+func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
	+ parser.error = yaml_PARSER_ERROR
	+ parser.problem = problem
	+ parser.problem_mark = problem_mark
	+ return false
	+}
	+
	+func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool {
	+ parser.error = yaml_PARSER_ERROR
	+ parser.context = context
	+ parser.context_mark = context_mark
	+ parser.problem = problem
	+ parser.problem_mark = problem_mark
	+ return false
	+}
	+
	+// State dispatcher.
	+func yaml_parser_state_machine(parser yaml_parser_t, event yaml_event_t) bool {
	+ //trace("yaml_parser_state_machine", "state:", parser.state.String())
	+
	+ switch parser.state {
	+ case yaml_PARSE_STREAM_START_STATE:
	+ return yaml_parser_parse_stream_start(parser, event)
	+
	+ case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
	+ return yaml_parser_parse_document_start(parser, event, true)
	+
	+ case yaml_PARSE_DOCUMENT_START_STATE:
	+ return yaml_parser_parse_document_start(parser, event, false)
	+
	+ case yaml_PARSE_DOCUMENT_CONTENT_STATE:
	+ return yaml_parser_parse_document_content(parser, event)
	+
	+ case yaml_PARSE_DOCUMENT_END_STATE:
	+ return yaml_parser_parse_document_end(parser, event)
	+
	+ case yaml_PARSE_BLOCK_NODE_STATE:
	+ return yaml_parser_parse_node(parser, event, true, false)
	+
	+ case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
	+ return yaml_parser_parse_node(parser, event, true, true)
	+
	+ case yaml_PARSE_FLOW_NODE_STATE:
	+ return yaml_parser_parse_node(parser, event, false, false)
	+
	+ case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
	+ return yaml_parser_parse_block_sequence_entry(parser, event, true)
	+
	+ case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
	+ return yaml_parser_parse_block_sequence_entry(parser, event, false)
	+
	+ case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
	+ return yaml_parser_parse_indentless_sequence_entry(parser, event)
	+
	+ case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
	+ return yaml_parser_parse_block_mapping_key(parser, event, true)
	+
	+ case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
	+ return yaml_parser_parse_block_mapping_key(parser, event, false)
	+
	+ case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
	+ return yaml_parser_parse_block_mapping_value(parser, event)
	+
	+ case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
	+ return yaml_parser_parse_flow_sequence_entry(parser, event, true)
	+
	+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
	+ return yaml_parser_parse_flow_sequence_entry(parser, event, false)
	+
	+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
	+ return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
	+
	+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
	+ return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
	+
	+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
	+ return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
	+
	+ case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
	+ return yaml_parser_parse_flow_mapping_key(parser, event, true)
	+
	+ case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
	+ return yaml_parser_parse_flow_mapping_key(parser, event, false)
	+
	+ case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
	+ return yaml_parser_parse_flow_mapping_value(parser, event, false)
	+
	+ case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
	+ return yaml_parser_parse_flow_mapping_value(parser, event, true)
	+
	+ default:
	+ panic("invalid parser state")
	+ }
	+ return false
	+}
	+
	+// Parse the production:
	+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
	+// ************
	+func yaml_parser_parse_stream_start(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_STREAM_START_TOKEN {
	+ return yaml_parser_set_parser_error(parser, "did not find expected <stream-start>", token.start_mark)
	+ }
	+ parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_STREAM_START_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ encoding: token.encoding,
	+ }
	+ skip_token(parser)
	+ return true
	+}
	+
	+// Parse the productions:
	+// implicit_document ::= block_node DOCUMENT-END*
	+// *
	+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
	+// *************************
	+func yaml_parser_parse_document_start(parser yaml_parser_t, event yaml_event_t, implicit bool) bool {
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ // Parse extra document end indicators.
	+ if !implicit {
	+ for token.typ == yaml_DOCUMENT_END_TOKEN {
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ }
	+ }
	+
	+ if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
	+ token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
	+ token.typ != yaml_DOCUMENT_START_TOKEN &&
	+ token.typ != yaml_STREAM_END_TOKEN {
	+ // Parse an implicit document.
	+ if !yaml_parser_process_directives(parser, nil, nil) {
	+ return false
	+ }
	+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
	+ parser.state = yaml_PARSE_BLOCK_NODE_STATE
	+
	+ *event = yaml_event_t{
	+ typ: yaml_DOCUMENT_START_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+
	+ } else if token.typ != yaml_STREAM_END_TOKEN {
	+ // Parse an explicit document.
	+ var version_directive *yaml_version_directive_t
	+ var tag_directives []yaml_tag_directive_t
	+ start_mark := token.start_mark
	+ if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
	+ return false
	+ }
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_DOCUMENT_START_TOKEN {
	+ yaml_parser_set_parser_error(parser,
	+ "did not find expected <document start>", token.start_mark)
	+ return false
	+ }
	+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
	+ parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
	+ end_mark := token.end_mark
	+
	+ *event = yaml_event_t{
	+ typ: yaml_DOCUMENT_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ version_directive: version_directive,
	+ tag_directives: tag_directives,
	+ implicit: false,
	+ }
	+ skip_token(parser)
	+
	+ } else {
	+ // Parse the stream end.
	+ parser.state = yaml_PARSE_END_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_STREAM_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+ skip_token(parser)
	+ }
	+
	+ return true
	+}
	+
	+// Parse the productions:
	+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
	+// ***********
	+//
	+func yaml_parser_parse_document_content(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN \|\|
	+ token.typ == yaml_TAG_DIRECTIVE_TOKEN \|\|
	+ token.typ == yaml_DOCUMENT_START_TOKEN \|\|
	+ token.typ == yaml_DOCUMENT_END_TOKEN \|\|
	+ token.typ == yaml_STREAM_END_TOKEN {
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ return yaml_parser_process_empty_scalar(parser, event,
	+ token.start_mark)
	+ }
	+ return yaml_parser_parse_node(parser, event, true, false)
	+}
	+
	+// Parse the productions:
	+// implicit_document ::= block_node DOCUMENT-END*
	+// *************
	+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
	+//
	+func yaml_parser_parse_document_end(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ start_mark := token.start_mark
	+ end_mark := token.start_mark
	+
	+ implicit := true
	+ if token.typ == yaml_DOCUMENT_END_TOKEN {
	+ end_mark = token.end_mark
	+ skip_token(parser)
	+ implicit = false
	+ }
	+
	+ parser.tag_directives = parser.tag_directives[:0]
	+
	+ parser.state = yaml_PARSE_DOCUMENT_START_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_DOCUMENT_END_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ implicit: implicit,
	+ }
	+ return true
	+}
	+
	+// Parse the productions:
	+// block_node_or_indentless_sequence ::=
	+// ALIAS
	+// *****
	+// \| properties (block_content \| indentless_block_sequence)?
	+// ********** *
	+// \| block_content \| indentless_block_sequence
	+// *
	+// block_node ::= ALIAS
	+// *****
	+// \| properties block_content?
	+// ********** *
	+// \| block_content
	+// *
	+// flow_node ::= ALIAS
	+// *****
	+// \| properties flow_content?
	+// ********** *
	+// \| flow_content
	+// *
	+// properties ::= TAG ANCHOR? \| ANCHOR TAG?
	+// *************************
	+// block_content ::= block_collection \| flow_collection \| SCALAR
	+// ******
	+// flow_content ::= flow_collection \| SCALAR
	+// ******
	+func yaml_parser_parse_node(parser yaml_parser_t, event yaml_event_t, block, indentless_sequence bool) bool {
	+ //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ if token.typ == yaml_ALIAS_TOKEN {
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ *event = yaml_event_t{
	+ typ: yaml_ALIAS_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ anchor: token.value,
	+ }
	+ skip_token(parser)
	+ return true
	+ }
	+
	+ start_mark := token.start_mark
	+ end_mark := token.start_mark
	+
	+ var tag_token bool
	+ var tag_handle, tag_suffix, anchor []byte
	+ var tag_mark yaml_mark_t
	+ if token.typ == yaml_ANCHOR_TOKEN {
	+ anchor = token.value
	+ start_mark = token.start_mark
	+ end_mark = token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ == yaml_TAG_TOKEN {
	+ tag_token = true
	+ tag_handle = token.value
	+ tag_suffix = token.suffix
	+ tag_mark = token.start_mark
	+ end_mark = token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ }
	+ } else if token.typ == yaml_TAG_TOKEN {
	+ tag_token = true
	+ tag_handle = token.value
	+ tag_suffix = token.suffix
	+ start_mark = token.start_mark
	+ tag_mark = token.start_mark
	+ end_mark = token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ == yaml_ANCHOR_TOKEN {
	+ anchor = token.value
	+ end_mark = token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ }
	+ }
	+
	+ var tag []byte
	+ if tag_token {
	+ if len(tag_handle) == 0 {
	+ tag = tag_suffix
	+ tag_suffix = nil
	+ } else {
	+ for i := range parser.tag_directives {
	+ if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
	+ tag = append([]byte(nil), parser.tag_directives[i].prefix...)
	+ tag = append(tag, tag_suffix...)
	+ break
	+ }
	+ }
	+ if len(tag) == 0 {
	+ yaml_parser_set_parser_error_context(parser,
	+ "while parsing a node", start_mark,
	+ "found undefined tag handle", tag_mark)
	+ return false
	+ }
	+ }
	+ }
	+
	+ implicit := len(tag) == 0
	+ if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
	+ end_mark = token.end_mark
	+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
	+ }
	+ return true
	+ }
	+ if token.typ == yaml_SCALAR_TOKEN {
	+ var plain_implicit, quoted_implicit bool
	+ end_mark = token.end_mark
	+ if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) \|\| (len(tag) == 1 && tag[0] == '!') {
	+ plain_implicit = true
	+ } else if len(tag) == 0 {
	+ quoted_implicit = true
	+ }
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+
	+ *event = yaml_event_t{
	+ typ: yaml_SCALAR_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ value: token.value,
	+ implicit: plain_implicit,
	+ quoted_implicit: quoted_implicit,
	+ style: yaml_style_t(token.style),
	+ }
	+ skip_token(parser)
	+ return true
	+ }
	+ if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
	+ // [Go] Some of the events below can be merged as they differ only on style.
	+ end_mark = token.end_mark
	+ parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
	+ }
	+ return true
	+ }
	+ if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
	+ end_mark = token.end_mark
	+ parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
	+ }
	+ return true
	+ }
	+ if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
	+ end_mark = token.end_mark
	+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
	+ }
	+ return true
	+ }
	+ if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
	+ end_mark = token.end_mark
	+ parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_START_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
	+ }
	+ return true
	+ }
	+ if len(anchor) > 0 \|\| len(tag) > 0 {
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+
	+ *event = yaml_event_t{
	+ typ: yaml_SCALAR_EVENT,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ anchor: anchor,
	+ tag: tag,
	+ implicit: implicit,
	+ quoted_implicit: false,
	+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
	+ }
	+ return true
	+ }
	+
	+ context := "while parsing a flow node"
	+ if block {
	+ context = "while parsing a block node"
	+ }
	+ yaml_parser_set_parser_error_context(parser, context, start_mark,
	+ "did not find expected node content", token.start_mark)
	+ return false
	+}
	+
	+// Parse the productions:
	+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
	+// ****************** ********* * *********
	+//
	+func yaml_parser_parse_block_sequence_entry(parser yaml_parser_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ token := peek_token(parser)
	+ parser.marks = append(parser.marks, token.start_mark)
	+ skip_token(parser)
	+ }
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
	+ mark := token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
	+ return yaml_parser_parse_node(parser, event, true, false)
	+ } else {
	+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, mark)
	+ }
	+ }
	+ if token.typ == yaml_BLOCK_END_TOKEN {
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+
	+ skip_token(parser)
	+ return true
	+ }
	+
	+ context_mark := parser.marks[len(parser.marks)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ return yaml_parser_set_parser_error_context(parser,
	+ "while parsing a block collection", context_mark,
	+ "did not find expected '-' indicator", token.start_mark)
	+}
	+
	+// Parse the productions:
	+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
	+// *********** *
	+func yaml_parser_parse_indentless_sequence_entry(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
	+ mark := token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
	+ token.typ != yaml_KEY_TOKEN &&
	+ token.typ != yaml_VALUE_TOKEN &&
	+ token.typ != yaml_BLOCK_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
	+ return yaml_parser_parse_node(parser, event, true, false)
	+ }
	+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, mark)
	+ }
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark?
	+ }
	+ return true
	+}
	+
	+// Parse the productions:
	+// block_mapping ::= BLOCK-MAPPING_START
	+// *******************
	+// ((KEY block_node_or_indentless_sequence?)?
	+// *** *
	+// (VALUE block_node_or_indentless_sequence?)?)*
	+//
	+// BLOCK-END
	+// *********
	+//
	+func yaml_parser_parse_block_mapping_key(parser yaml_parser_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ token := peek_token(parser)
	+ parser.marks = append(parser.marks, token.start_mark)
	+ skip_token(parser)
	+ }
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ if token.typ == yaml_KEY_TOKEN {
	+ mark := token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_KEY_TOKEN &&
	+ token.typ != yaml_VALUE_TOKEN &&
	+ token.typ != yaml_BLOCK_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
	+ return yaml_parser_parse_node(parser, event, true, true)
	+ } else {
	+ parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, mark)
	+ }
	+ } else if token.typ == yaml_BLOCK_END_TOKEN {
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+ skip_token(parser)
	+ return true
	+ }
	+
	+ context_mark := parser.marks[len(parser.marks)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ return yaml_parser_set_parser_error_context(parser,
	+ "while parsing a block mapping", context_mark,
	+ "did not find expected key", token.start_mark)
	+}
	+
	+// Parse the productions:
	+// block_mapping ::= BLOCK-MAPPING_START
	+//
	+// ((KEY block_node_or_indentless_sequence?)?
	+//
	+// (VALUE block_node_or_indentless_sequence?)?)*
	+// ***** *
	+// BLOCK-END
	+//
	+//
	+func yaml_parser_parse_block_mapping_value(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ == yaml_VALUE_TOKEN {
	+ mark := token.end_mark
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_KEY_TOKEN &&
	+ token.typ != yaml_VALUE_TOKEN &&
	+ token.typ != yaml_BLOCK_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
	+ return yaml_parser_parse_node(parser, event, true, true)
	+ }
	+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, mark)
	+ }
	+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
	+}
	+
	+// Parse the productions:
	+// flow_sequence ::= FLOW-SEQUENCE-START
	+// *******************
	+// (flow_sequence_entry FLOW-ENTRY)*
	+// * **********
	+// flow_sequence_entry?
	+// *
	+// FLOW-SEQUENCE-END
	+// *****************
	+// flow_sequence_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// *
	+//
	+func yaml_parser_parse_flow_sequence_entry(parser yaml_parser_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ token := peek_token(parser)
	+ parser.marks = append(parser.marks, token.start_mark)
	+ skip_token(parser)
	+ }
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
	+ if !first {
	+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ } else {
	+ context_mark := parser.marks[len(parser.marks)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ return yaml_parser_set_parser_error_context(parser,
	+ "while parsing a flow sequence", context_mark,
	+ "did not find expected ',' or ']'", token.start_mark)
	+ }
	+ }
	+
	+ if token.typ == yaml_KEY_TOKEN {
	+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_START_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ implicit: true,
	+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
	+ }
	+ skip_token(parser)
	+ return true
	+ } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ }
	+ }
	+
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+
	+ *event = yaml_event_t{
	+ typ: yaml_SEQUENCE_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+
	+ skip_token(parser)
	+ return true
	+}
	+
	+//
	+// Parse the productions:
	+// flow_sequence_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// *** *
	+//
	+func yaml_parser_parse_flow_sequence_entry_mapping_key(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_VALUE_TOKEN &&
	+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
	+ token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ }
	+ mark := token.end_mark
	+ skip_token(parser)
	+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, mark)
	+}
	+
	+// Parse the productions:
	+// flow_sequence_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// ***** *
	+//
	+func yaml_parser_parse_flow_sequence_entry_mapping_value(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ == yaml_VALUE_TOKEN {
	+ skip_token(parser)
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ }
	+ }
	+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
	+}
	+
	+// Parse the productions:
	+// flow_sequence_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// *
	+//
	+func yaml_parser_parse_flow_sequence_entry_mapping_end(parser yaml_parser_t, event yaml_event_t) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.start_mark, // [Go] Shouldn't this be end_mark?
	+ }
	+ return true
	+}
	+
	+// Parse the productions:
	+// flow_mapping ::= FLOW-MAPPING-START
	+// ******************
	+// (flow_mapping_entry FLOW-ENTRY)*
	+// * **********
	+// flow_mapping_entry?
	+// ******************
	+// FLOW-MAPPING-END
	+// ****************
	+// flow_mapping_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// * *** *
	+//
	+func yaml_parser_parse_flow_mapping_key(parser yaml_parser_t, event yaml_event_t, first bool) bool {
	+ if first {
	+ token := peek_token(parser)
	+ parser.marks = append(parser.marks, token.start_mark)
	+ skip_token(parser)
	+ }
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
	+ if !first {
	+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ } else {
	+ context_mark := parser.marks[len(parser.marks)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ return yaml_parser_set_parser_error_context(parser,
	+ "while parsing a flow mapping", context_mark,
	+ "did not find expected ',' or '}'", token.start_mark)
	+ }
	+ }
	+
	+ if token.typ == yaml_KEY_TOKEN {
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_VALUE_TOKEN &&
	+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
	+ token.typ != yaml_FLOW_MAPPING_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ } else {
	+ parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
	+ }
	+ } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ }
	+ }
	+
	+ parser.state = parser.states[len(parser.states)-1]
	+ parser.states = parser.states[:len(parser.states)-1]
	+ parser.marks = parser.marks[:len(parser.marks)-1]
	+ *event = yaml_event_t{
	+ typ: yaml_MAPPING_END_EVENT,
	+ start_mark: token.start_mark,
	+ end_mark: token.end_mark,
	+ }
	+ skip_token(parser)
	+ return true
	+}
	+
	+// Parse the productions:
	+// flow_mapping_entry ::= flow_node \| KEY flow_node? (VALUE flow_node?)?
	+// * ***** *
	+//
	+func yaml_parser_parse_flow_mapping_value(parser yaml_parser_t, event yaml_event_t, empty bool) bool {
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if empty {
	+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
	+ }
	+ if token.typ == yaml_VALUE_TOKEN {
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
	+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
	+ return yaml_parser_parse_node(parser, event, false, false)
	+ }
	+ }
	+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
	+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
	+}
	+
	+// Generate an empty scalar event.
	+func yaml_parser_process_empty_scalar(parser yaml_parser_t, event yaml_event_t, mark yaml_mark_t) bool {
	+ *event = yaml_event_t{
	+ typ: yaml_SCALAR_EVENT,
	+ start_mark: mark,
	+ end_mark: mark,
	+ value: nil, // Empty
	+ implicit: true,
	+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
	+ }
	+ return true
	+}
	+
	+var default_tag_directives = []yaml_tag_directive_t{
	+ {[]byte("!"), []byte("!")},
	+ {[]byte("!!"), []byte("tag:yaml.org,2002:")},
	+}
	+
	+// Parse directives.
	+func yaml_parser_process_directives(parser *yaml_parser_t,
	+ version_directive_ref **yaml_version_directive_t,
	+ tag_directives_ref *[]yaml_tag_directive_t) bool {
	+
	+ var version_directive *yaml_version_directive_t
	+ var tag_directives []yaml_tag_directive_t
	+
	+ token := peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+
	+ for token.typ == yaml_VERSION_DIRECTIVE_TOKEN \|\| token.typ == yaml_TAG_DIRECTIVE_TOKEN {
	+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
	+ if version_directive != nil {
	+ yaml_parser_set_parser_error(parser,
	+ "found duplicate %YAML directive", token.start_mark)
	+ return false
	+ }
	+ if token.major != 1 \|\| token.minor != 1 {
	+ yaml_parser_set_parser_error(parser,
	+ "found incompatible YAML document", token.start_mark)
	+ return false
	+ }
	+ version_directive = &yaml_version_directive_t{
	+ major: token.major,
	+ minor: token.minor,
	+ }
	+ } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
	+ value := yaml_tag_directive_t{
	+ handle: token.value,
	+ prefix: token.prefix,
	+ }
	+ if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
	+ return false
	+ }
	+ tag_directives = append(tag_directives, value)
	+ }
	+
	+ skip_token(parser)
	+ token = peek_token(parser)
	+ if token == nil {
	+ return false
	+ }
	+ }
	+
	+ for i := range default_tag_directives {
	+ if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
	+ return false
	+ }
	+ }
	+
	+ if version_directive_ref != nil {
	+ *version_directive_ref = version_directive
	+ }
	+ if tag_directives_ref != nil {
	+ *tag_directives_ref = tag_directives
	+ }
	+ return true
	+}
	+
	+// Append a tag directive to the directives stack.
	+func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
	+ for i := range parser.tag_directives {
	+ if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
	+ if allow_duplicates {
	+ return true
	+ }
	+ return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
	+ }
	+ }
	+
	+ // [Go] I suspect the copy is unnecessary. This was likely done
	+ // because there was no way to track ownership of the data.
	+ value_copy := yaml_tag_directive_t{
	+ handle: make([]byte, len(value.handle)),
	+ prefix: make([]byte, len(value.prefix)),
	+ }
	+ copy(value_copy.handle, value.handle)
	+ copy(value_copy.prefix, value.prefix)
	+ parser.tag_directives = append(parser.tag_directives, value_copy)
	+ return true
	+}
	diff --git a/src/gopkg.in/yaml.v2/readerc.go b/src/gopkg.in/yaml.v2/readerc.go
	new file mode 100644
	index 0000000..f450791
	--- /dev/null
	+++ b/src/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
	+}
	diff --git a/src/gopkg.in/yaml.v2/resolve.go b/src/gopkg.in/yaml.v2/resolve.go
	new file mode 100644
	index 0000000..93a8632
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/resolve.go
	@@ -0,0 +1,203 @@
	+package yaml
	+
	+import (
	+ "encoding/base64"
	+ "math"
	+ "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
	+}
	+
	+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
	+ }
	+ 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])
	+}
	diff --git a/src/gopkg.in/yaml.v2/scannerc.go b/src/gopkg.in/yaml.v2/scannerc.go
	new file mode 100644
	index 0000000..d97d76f
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/scannerc.go
	@@ -0,0 +1,2710 @@
	+package yaml
	+
	+import (
	+ "bytes"
	+ "fmt"
	+)
	+
	+// Introduction
	+// ************
	+//
	+// The following notes assume that you are familiar with the YAML specification
	+// (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in
	+// some cases we are less restrictive that it requires.
	+//
	+// The process of transforming a YAML stream into a sequence of events is
	+// divided on two steps: Scanning and Parsing.
	+//
	+// The Scanner transforms the input stream into a sequence of tokens, while the
	+// parser transform the sequence of tokens produced by the Scanner into a
	+// sequence of parsing events.
	+//
	+// The Scanner is rather clever and complicated. The Parser, on the contrary,
	+// is a straightforward implementation of a recursive-descendant parser (or,
	+// LL(1) parser, as it is usually called).
	+//
	+// Actually there are two issues of Scanning that might be called "clever", the
	+// rest is quite straightforward. The issues are "block collection start" and
	+// "simple keys". Both issues are explained below in details.
	+//
	+// Here the Scanning step is explained and implemented. We start with the list
	+// of all the tokens produced by the Scanner together with short descriptions.
	+//
	+// Now, tokens:
	+//
	+// STREAM-START(encoding) # The stream start.
	+// STREAM-END # The stream end.
	+// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
	+// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
	+// DOCUMENT-START # '---'
	+// DOCUMENT-END # '...'
	+// BLOCK-SEQUENCE-START # Indentation increase denoting a block
	+// BLOCK-MAPPING-START # sequence or a block mapping.
	+// BLOCK-END # Indentation decrease.
	+// FLOW-SEQUENCE-START # '['
	+// FLOW-SEQUENCE-END # ']'
	+// BLOCK-SEQUENCE-START # '{'
	+// BLOCK-SEQUENCE-END # '}'
	+// BLOCK-ENTRY # '-'
	+// FLOW-ENTRY # ','
	+// KEY # '?' or nothing (simple keys).
	+// VALUE # ':'
	+// ALIAS(anchor) # '*anchor'
	+// ANCHOR(anchor) # '&anchor'
	+// TAG(handle,suffix) # '!handle!suffix'
	+// SCALAR(value,style) # A scalar.
	+//
	+// The following two tokens are "virtual" tokens denoting the beginning and the
	+// end of the stream:
	+//
	+// STREAM-START(encoding)
	+// STREAM-END
	+//
	+// We pass the information about the input stream encoding with the
	+// STREAM-START token.
	+//
	+// The next two tokens are responsible for tags:
	+//
	+// VERSION-DIRECTIVE(major,minor)
	+// TAG-DIRECTIVE(handle,prefix)
	+//
	+// Example:
	+//
	+// %YAML 1.1
	+// %TAG ! !foo
	+// %TAG !yaml! tag:yaml.org,2002:
	+// ---
	+//
	+// The correspoding sequence of tokens:
	+//
	+// STREAM-START(utf-8)
	+// VERSION-DIRECTIVE(1,1)
	+// TAG-DIRECTIVE("!","!foo")
	+// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
	+// DOCUMENT-START
	+// STREAM-END
	+//
	+// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
	+// line.
	+//
	+// The document start and end indicators are represented by:
	+//
	+// DOCUMENT-START
	+// DOCUMENT-END
	+//
	+// Note that if a YAML stream contains an implicit document (without '---'
	+// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
	+// produced.
	+//
	+// In the following examples, we present whole documents together with the
	+// produced tokens.
	+//
	+// 1. An implicit document:
	+//
	+// 'a scalar'
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// SCALAR("a scalar",single-quoted)
	+// STREAM-END
	+//
	+// 2. An explicit document:
	+//
	+// ---
	+// 'a scalar'
	+// ...
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// DOCUMENT-START
	+// SCALAR("a scalar",single-quoted)
	+// DOCUMENT-END
	+// STREAM-END
	+//
	+// 3. Several documents in a stream:
	+//
	+// 'a scalar'
	+// ---
	+// 'another scalar'
	+// ---
	+// 'yet another scalar'
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// SCALAR("a scalar",single-quoted)
	+// DOCUMENT-START
	+// SCALAR("another scalar",single-quoted)
	+// DOCUMENT-START
	+// SCALAR("yet another scalar",single-quoted)
	+// STREAM-END
	+//
	+// We have already introduced the SCALAR token above. The following tokens are
	+// used to describe aliases, anchors, tag, and scalars:
	+//
	+// ALIAS(anchor)
	+// ANCHOR(anchor)
	+// TAG(handle,suffix)
	+// SCALAR(value,style)
	+//
	+// The following series of examples illustrate the usage of these tokens:
	+//
	+// 1. A recursive sequence:
	+//
	+// &A [ *A ]
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// ANCHOR("A")
	+// FLOW-SEQUENCE-START
	+// ALIAS("A")
	+// FLOW-SEQUENCE-END
	+// STREAM-END
	+//
	+// 2. A tagged scalar:
	+//
	+// !!float "3.14" # A good approximation.
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// TAG("!!","float")
	+// SCALAR("3.14",double-quoted)
	+// STREAM-END
	+//
	+// 3. Various scalar styles:
	+//
	+// --- # Implicit empty plain scalars do not produce tokens.
	+// --- a plain scalar
	+// --- 'a single-quoted scalar'
	+// --- "a double-quoted scalar"
	+// --- \|-
	+// a literal scalar
	+// --- >-
	+// a folded
	+// scalar
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// DOCUMENT-START
	+// DOCUMENT-START
	+// SCALAR("a plain scalar",plain)
	+// DOCUMENT-START
	+// SCALAR("a single-quoted scalar",single-quoted)
	+// DOCUMENT-START
	+// SCALAR("a double-quoted scalar",double-quoted)
	+// DOCUMENT-START
	+// SCALAR("a literal scalar",literal)
	+// DOCUMENT-START
	+// SCALAR("a folded scalar",folded)
	+// STREAM-END
	+//
	+// Now it's time to review collection-related tokens. We will start with
	+// flow collections:
	+//
	+// FLOW-SEQUENCE-START
	+// FLOW-SEQUENCE-END
	+// FLOW-MAPPING-START
	+// FLOW-MAPPING-END
	+// FLOW-ENTRY
	+// KEY
	+// VALUE
	+//
	+// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
	+// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
	+// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
	+// indicators '?' and ':', which are used for denoting mapping keys and values,
	+// are represented by the KEY and VALUE tokens.
	+//
	+// The following examples show flow collections:
	+//
	+// 1. A flow sequence:
	+//
	+// [item 1, item 2, item 3]
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// FLOW-SEQUENCE-START
	+// SCALAR("item 1",plain)
	+// FLOW-ENTRY
	+// SCALAR("item 2",plain)
	+// FLOW-ENTRY
	+// SCALAR("item 3",plain)
	+// FLOW-SEQUENCE-END
	+// STREAM-END
	+//
	+// 2. A flow mapping:
	+//
	+// {
	+// a simple key: a value, # Note that the KEY token is produced.
	+// ? a complex key: another value,
	+// }
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// FLOW-MAPPING-START
	+// KEY
	+// SCALAR("a simple key",plain)
	+// VALUE
	+// SCALAR("a value",plain)
	+// FLOW-ENTRY
	+// KEY
	+// SCALAR("a complex key",plain)
	+// VALUE
	+// SCALAR("another value",plain)
	+// FLOW-ENTRY
	+// FLOW-MAPPING-END
	+// STREAM-END
	+//
	+// A simple key is a key which is not denoted by the '?' indicator. Note that
	+// the Scanner still produce the KEY token whenever it encounters a simple key.
	+//
	+// For scanning block collections, the following tokens are used (note that we
	+// repeat KEY and VALUE here):
	+//
	+// BLOCK-SEQUENCE-START
	+// BLOCK-MAPPING-START
	+// BLOCK-END
	+// BLOCK-ENTRY
	+// KEY
	+// VALUE
	+//
	+// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
	+// increase that precedes a block collection (cf. the INDENT token in Python).
	+// The token BLOCK-END denote indentation decrease that ends a block collection
	+// (cf. the DEDENT token in Python). However YAML has some syntax pecularities
	+// that makes detections of these tokens more complex.
	+//
	+// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
	+// '-', '?', and ':' correspondingly.
	+//
	+// The following examples show how the tokens BLOCK-SEQUENCE-START,
	+// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
	+//
	+// 1. Block sequences:
	+//
	+// - item 1
	+// - item 2
	+// -
	+// - item 3.1
	+// - item 3.2
	+// -
	+// key 1: value 1
	+// key 2: value 2
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// SCALAR("item 1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 2",plain)
	+// BLOCK-ENTRY
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// SCALAR("item 3.1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 3.2",plain)
	+// BLOCK-END
	+// BLOCK-ENTRY
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("key 1",plain)
	+// VALUE
	+// SCALAR("value 1",plain)
	+// KEY
	+// SCALAR("key 2",plain)
	+// VALUE
	+// SCALAR("value 2",plain)
	+// BLOCK-END
	+// BLOCK-END
	+// STREAM-END
	+//
	+// 2. Block mappings:
	+//
	+// a simple key: a value # The KEY token is produced here.
	+// ? a complex key
	+// : another value
	+// a mapping:
	+// key 1: value 1
	+// key 2: value 2
	+// a sequence:
	+// - item 1
	+// - item 2
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("a simple key",plain)
	+// VALUE
	+// SCALAR("a value",plain)
	+// KEY
	+// SCALAR("a complex key",plain)
	+// VALUE
	+// SCALAR("another value",plain)
	+// KEY
	+// SCALAR("a mapping",plain)
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("key 1",plain)
	+// VALUE
	+// SCALAR("value 1",plain)
	+// KEY
	+// SCALAR("key 2",plain)
	+// VALUE
	+// SCALAR("value 2",plain)
	+// BLOCK-END
	+// KEY
	+// SCALAR("a sequence",plain)
	+// VALUE
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// SCALAR("item 1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 2",plain)
	+// BLOCK-END
	+// BLOCK-END
	+// STREAM-END
	+//
	+// YAML does not always require to start a new block collection from a new
	+// line. If the current line contains only '-', '?', and ':' indicators, a new
	+// block collection may start at the current line. The following examples
	+// illustrate this case:
	+//
	+// 1. Collections in a sequence:
	+//
	+// - - item 1
	+// - item 2
	+// - key 1: value 1
	+// key 2: value 2
	+// - ? complex key
	+// : complex value
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// SCALAR("item 1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 2",plain)
	+// BLOCK-END
	+// BLOCK-ENTRY
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("key 1",plain)
	+// VALUE
	+// SCALAR("value 1",plain)
	+// KEY
	+// SCALAR("key 2",plain)
	+// VALUE
	+// SCALAR("value 2",plain)
	+// BLOCK-END
	+// BLOCK-ENTRY
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("complex key")
	+// VALUE
	+// SCALAR("complex value")
	+// BLOCK-END
	+// BLOCK-END
	+// STREAM-END
	+//
	+// 2. Collections in a mapping:
	+//
	+// ? a sequence
	+// : - item 1
	+// - item 2
	+// ? a mapping
	+// : key 1: value 1
	+// key 2: value 2
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("a sequence",plain)
	+// VALUE
	+// BLOCK-SEQUENCE-START
	+// BLOCK-ENTRY
	+// SCALAR("item 1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 2",plain)
	+// BLOCK-END
	+// KEY
	+// SCALAR("a mapping",plain)
	+// VALUE
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("key 1",plain)
	+// VALUE
	+// SCALAR("value 1",plain)
	+// KEY
	+// SCALAR("key 2",plain)
	+// VALUE
	+// SCALAR("value 2",plain)
	+// BLOCK-END
	+// BLOCK-END
	+// STREAM-END
	+//
	+// YAML also permits non-indented sequences if they are included into a block
	+// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
	+//
	+// key:
	+// - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
	+// - item 2
	+//
	+// Tokens:
	+//
	+// STREAM-START(utf-8)
	+// BLOCK-MAPPING-START
	+// KEY
	+// SCALAR("key",plain)
	+// VALUE
	+// BLOCK-ENTRY
	+// SCALAR("item 1",plain)
	+// BLOCK-ENTRY
	+// SCALAR("item 2",plain)
	+// BLOCK-END
	+//
	+
	+// Ensure that the buffer contains the required number of characters.
	+// Return true on success, false on failure (reader error or memory error).
	+func cache(parser *yaml_parser_t, length int) bool {
	+ // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B)
	+ return parser.unread >= length \|\| yaml_parser_update_buffer(parser, length)
	+}
	+
	+// Advance the buffer pointer.
	+func skip(parser *yaml_parser_t) {
	+ parser.mark.index++
	+ parser.mark.column++
	+ parser.unread--
	+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
	+}
	+
	+func skip_line(parser *yaml_parser_t) {
	+ if is_crlf(parser.buffer, parser.buffer_pos) {
	+ parser.mark.index += 2
	+ parser.mark.column = 0
	+ parser.mark.line++
	+ parser.unread -= 2
	+ parser.buffer_pos += 2
	+ } else if is_break(parser.buffer, parser.buffer_pos) {
	+ parser.mark.index++
	+ parser.mark.column = 0
	+ parser.mark.line++
	+ parser.unread--
	+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
	+ }
	+}
	+
	+// Copy a character to a string buffer and advance pointers.
	+func read(parser *yaml_parser_t, s []byte) []byte {
	+ w := width(parser.buffer[parser.buffer_pos])
	+ if w == 0 {
	+ panic("invalid character sequence")
	+ }
	+ if len(s) == 0 {
	+ s = make([]byte, 0, 32)
	+ }
	+ if w == 1 && len(s)+w <= cap(s) {
	+ s = s[:len(s)+1]
	+ s[len(s)-1] = parser.buffer[parser.buffer_pos]
	+ parser.buffer_pos++
	+ } else {
	+ s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...)
	+ parser.buffer_pos += w
	+ }
	+ parser.mark.index++
	+ parser.mark.column++
	+ parser.unread--
	+ return s
	+}
	+
	+// Copy a line break character to a string buffer and advance pointers.
	+func read_line(parser *yaml_parser_t, s []byte) []byte {
	+ buf := parser.buffer
	+ pos := parser.buffer_pos
	+ switch {
	+ case buf[pos] == '\r' && buf[pos+1] == '\n':
	+ // CR LF . LF
	+ s = append(s, '\n')
	+ parser.buffer_pos += 2
	+ parser.mark.index++
	+ parser.unread--
	+ case buf[pos] == '\r' \|\| buf[pos] == '\n':
	+ // CR\|LF . LF
	+ s = append(s, '\n')
	+ parser.buffer_pos += 1
	+ case buf[pos] == '\xC2' && buf[pos+1] == '\x85':
	+ // NEL . LF
	+ s = append(s, '\n')
	+ parser.buffer_pos += 2
	+ case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' \|\| buf[pos+2] == '\xA9'):
	+ // LS\|PS . LS\|PS
	+ s = append(s, buf[parser.buffer_pos:pos+3]...)
	+ parser.buffer_pos += 3
	+ default:
	+ return s
	+ }
	+ parser.mark.index++
	+ parser.mark.column = 0
	+ parser.mark.line++
	+ parser.unread--
	+ return s
	+}
	+
	+// Get the next token.
	+func yaml_parser_scan(parser yaml_parser_t, token yaml_token_t) bool {
	+ // Erase the token object.
	+ *token = yaml_token_t{} // [Go] Is this necessary?
	+
	+ // No tokens after STREAM-END or error.
	+ if parser.stream_end_produced \|\| parser.error != yaml_NO_ERROR {
	+ return true
	+ }
	+
	+ // Ensure that the tokens queue contains enough tokens.
	+ if !parser.token_available {
	+ if !yaml_parser_fetch_more_tokens(parser) {
	+ return false
	+ }
	+ }
	+
	+ // Fetch the next token from the queue.
	+ *token = parser.tokens[parser.tokens_head]
	+ parser.tokens_head++
	+ parser.tokens_parsed++
	+ parser.token_available = false
	+
	+ if token.typ == yaml_STREAM_END_TOKEN {
	+ parser.stream_end_produced = true
	+ }
	+ return true
	+}
	+
	+// Set the scanner error and return false.
	+func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool {
	+ parser.error = yaml_SCANNER_ERROR
	+ parser.context = context
	+ parser.context_mark = context_mark
	+ parser.problem = problem
	+ parser.problem_mark = parser.mark
	+ return false
	+}
	+
	+func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool {
	+ context := "while parsing a tag"
	+ if directive {
	+ context = "while parsing a %TAG directive"
	+ }
	+ return yaml_parser_set_scanner_error(parser, context, context_mark, "did not find URI escaped octet")
	+}
	+
	+func trace(args ...interface{}) func() {
	+ pargs := append([]interface{}{"+++"}, args...)
	+ fmt.Println(pargs...)
	+ pargs = append([]interface{}{"---"}, args...)
	+ return func() { fmt.Println(pargs...) }
	+}
	+
	+// Ensure that the tokens queue contains at least one token which can be
	+// returned to the Parser.
	+func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
	+ // While we need more tokens to fetch, do it.
	+ for {
	+ // Check if we really need to fetch more tokens.
	+ need_more_tokens := false
	+
	+ if parser.tokens_head == len(parser.tokens) {
	+ // Queue is empty.
	+ need_more_tokens = true
	+ } else {
	+ // Check if any potential simple key may occupy the head position.
	+ if !yaml_parser_stale_simple_keys(parser) {
	+ return false
	+ }
	+
	+ for i := range parser.simple_keys {
	+ simple_key := &parser.simple_keys[i]
	+ if simple_key.possible && simple_key.token_number == parser.tokens_parsed {
	+ need_more_tokens = true
	+ break
	+ }
	+ }
	+ }
	+
	+ // We are finished.
	+ if !need_more_tokens {
	+ break
	+ }
	+ // Fetch the next token.
	+ if !yaml_parser_fetch_next_token(parser) {
	+ return false
	+ }
	+ }
	+
	+ parser.token_available = true
	+ return true
	+}
	+
	+// The dispatcher for token fetchers.
	+func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
	+ // Ensure that the buffer is initialized.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ // Check if we just started scanning. Fetch STREAM-START then.
	+ if !parser.stream_start_produced {
	+ return yaml_parser_fetch_stream_start(parser)
	+ }
	+
	+ // Eat whitespaces and comments until we reach the next token.
	+ if !yaml_parser_scan_to_next_token(parser) {
	+ return false
	+ }
	+
	+ // Remove obsolete potential simple keys.
	+ if !yaml_parser_stale_simple_keys(parser) {
	+ return false
	+ }
	+
	+ // Check the indentation level against the current column.
	+ if !yaml_parser_unroll_indent(parser, parser.mark.column) {
	+ return false
	+ }
	+
	+ // Ensure that the buffer contains at least 4 characters. 4 is the length
	+ // of the longest indicators ('--- ' and '... ').
	+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
	+ return false
	+ }
	+
	+ // Is it the end of the stream?
	+ if is_z(parser.buffer, parser.buffer_pos) {
	+ return yaml_parser_fetch_stream_end(parser)
	+ }
	+
	+ // Is it a directive?
	+ if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' {
	+ return yaml_parser_fetch_directive(parser)
	+ }
	+
	+ buf := parser.buffer
	+ pos := parser.buffer_pos
	+
	+ // Is it the document start indicator?
	+ if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) {
	+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN)
	+ }
	+
	+ // Is it the document end indicator?
	+ if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) {
	+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
	+ }
	+
	+ // Is it the flow sequence start indicator?
	+ if buf[pos] == '[' {
	+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
	+ }
	+
	+ // Is it the flow mapping start indicator?
	+ if parser.buffer[parser.buffer_pos] == '{' {
	+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN)
	+ }
	+
	+ // Is it the flow sequence end indicator?
	+ if parser.buffer[parser.buffer_pos] == ']' {
	+ return yaml_parser_fetch_flow_collection_end(parser,
	+ yaml_FLOW_SEQUENCE_END_TOKEN)
	+ }
	+
	+ // Is it the flow mapping end indicator?
	+ if parser.buffer[parser.buffer_pos] == '}' {
	+ return yaml_parser_fetch_flow_collection_end(parser,
	+ yaml_FLOW_MAPPING_END_TOKEN)
	+ }
	+
	+ // Is it the flow entry indicator?
	+ if parser.buffer[parser.buffer_pos] == ',' {
	+ return yaml_parser_fetch_flow_entry(parser)
	+ }
	+
	+ // Is it the block entry indicator?
	+ if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) {
	+ return yaml_parser_fetch_block_entry(parser)
	+ }
	+
	+ // Is it the key indicator?
	+ if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 \|\| is_blankz(parser.buffer, parser.buffer_pos+1)) {
	+ return yaml_parser_fetch_key(parser)
	+ }
	+
	+ // Is it the value indicator?
	+ if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 \|\| is_blankz(parser.buffer, parser.buffer_pos+1)) {
	+ return yaml_parser_fetch_value(parser)
	+ }
	+
	+ // Is it an alias?
	+ if parser.buffer[parser.buffer_pos] == '*' {
	+ return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN)
	+ }
	+
	+ // Is it an anchor?
	+ if parser.buffer[parser.buffer_pos] == '&' {
	+ return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN)
	+ }
	+
	+ // Is it a tag?
	+ if parser.buffer[parser.buffer_pos] == '!' {
	+ return yaml_parser_fetch_tag(parser)
	+ }
	+
	+ // Is it a literal scalar?
	+ if parser.buffer[parser.buffer_pos] == '\|' && parser.flow_level == 0 {
	+ return yaml_parser_fetch_block_scalar(parser, true)
	+ }
	+
	+ // Is it a folded scalar?
	+ if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 {
	+ return yaml_parser_fetch_block_scalar(parser, false)
	+ }
	+
	+ // Is it a single-quoted scalar?
	+ if parser.buffer[parser.buffer_pos] == '\'' {
	+ return yaml_parser_fetch_flow_scalar(parser, true)
	+ }
	+
	+ // Is it a double-quoted scalar?
	+ if parser.buffer[parser.buffer_pos] == '"' {
	+ return yaml_parser_fetch_flow_scalar(parser, false)
	+ }
	+
	+ // Is it a plain scalar?
	+ //
	+ // A plain scalar may start with any non-blank characters except
	+ //
	+ // '-', '?', ':', ',', '[', ']', '{', '}',
	+ // '#', '&', '*', '!', '\|', '>', '\'', '\"',
	+ // '%', '@', '`'.
	+ //
	+ // In the block context (and, for the '-' indicator, in the flow context
	+ // too), it may also start with the characters
	+ //
	+ // '-', '?', ':'
	+ //
	+ // if it is followed by a non-space character.
	+ //
	+ // The last rule is more restrictive than the specification requires.
	+ // [Go] Make this logic more reasonable.
	+ //switch parser.buffer[parser.buffer_pos] {
	+ //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '\|', '"', '\'', '@', '%', '-', '`':
	+ //}
	+ if !(is_blankz(parser.buffer, parser.buffer_pos) \|\| parser.buffer[parser.buffer_pos] == '-' \|\|
	+ parser.buffer[parser.buffer_pos] == '?' \|\| parser.buffer[parser.buffer_pos] == ':' \|\|
	+ parser.buffer[parser.buffer_pos] == ',' \|\| parser.buffer[parser.buffer_pos] == '[' \|\|
	+ parser.buffer[parser.buffer_pos] == ']' \|\| parser.buffer[parser.buffer_pos] == '{' \|\|
	+ parser.buffer[parser.buffer_pos] == '}' \|\| parser.buffer[parser.buffer_pos] == '#' \|\|
	+ parser.buffer[parser.buffer_pos] == '&' \|\| parser.buffer[parser.buffer_pos] == '*' \|\|
	+ parser.buffer[parser.buffer_pos] == '!' \|\| parser.buffer[parser.buffer_pos] == '\|' \|\|
	+ parser.buffer[parser.buffer_pos] == '>' \|\| parser.buffer[parser.buffer_pos] == '\'' \|\|
	+ parser.buffer[parser.buffer_pos] == '"' \|\| parser.buffer[parser.buffer_pos] == '%' \|\|
	+ parser.buffer[parser.buffer_pos] == '@' \|\| parser.buffer[parser.buffer_pos] == '`') \|\|
	+ (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) \|\|
	+ (parser.flow_level == 0 &&
	+ (parser.buffer[parser.buffer_pos] == '?' \|\| parser.buffer[parser.buffer_pos] == ':') &&
	+ !is_blankz(parser.buffer, parser.buffer_pos+1)) {
	+ return yaml_parser_fetch_plain_scalar(parser)
	+ }
	+
	+ // If we don't determine the token type so far, it is an error.
	+ return yaml_parser_set_scanner_error(parser,
	+ "while scanning for the next token", parser.mark,
	+ "found character that cannot start any token")
	+}
	+
	+// Check the list of potential simple keys and remove the positions that
	+// cannot contain simple keys anymore.
	+func yaml_parser_stale_simple_keys(parser *yaml_parser_t) bool {
	+ // Check for a potential simple key for each flow level.
	+ for i := range parser.simple_keys {
	+ simple_key := &parser.simple_keys[i]
	+
	+ // The specification requires that a simple key
	+ //
	+ // - is limited to a single line,
	+ // - is shorter than 1024 characters.
	+ if simple_key.possible && (simple_key.mark.line < parser.mark.line \|\| simple_key.mark.index+1024 < parser.mark.index) {
	+
	+ // Check if the potential simple key to be removed is required.
	+ if simple_key.required {
	+ return yaml_parser_set_scanner_error(parser,
	+ "while scanning a simple key", simple_key.mark,
	+ "could not find expected ':'")
	+ }
	+ simple_key.possible = false
	+ }
	+ }
	+ return true
	+}
	+
	+// Check if a simple key may start at the current position and add it if
	+// needed.
	+func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {
	+ // A simple key is required at the current position if the scanner is in
	+ // the block context and the current column coincides with the indentation
	+ // level.
	+
	+ required := parser.flow_level == 0 && parser.indent == parser.mark.column
	+
	+ // A simple key is required only when it is the first token in the current
	+ // line. Therefore it is always allowed. But we add a check anyway.
	+ if required && !parser.simple_key_allowed {
	+ panic("should not happen")
	+ }
	+
	+ //
	+ // If the current position may start a simple key, save it.
	+ //
	+ if parser.simple_key_allowed {
	+ simple_key := yaml_simple_key_t{
	+ possible: true,
	+ required: required,
	+ token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
	+ }
	+ simple_key.mark = parser.mark
	+
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+ parser.simple_keys[len(parser.simple_keys)-1] = simple_key
	+ }
	+ return true
	+}
	+
	+// Remove a potential simple key at the current flow level.
	+func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool {
	+ i := len(parser.simple_keys) - 1
	+ if parser.simple_keys[i].possible {
	+ // If the key is required, it is an error.
	+ if parser.simple_keys[i].required {
	+ return yaml_parser_set_scanner_error(parser,
	+ "while scanning a simple key", parser.simple_keys[i].mark,
	+ "could not find expected ':'")
	+ }
	+ }
	+ // Remove the key from the stack.
	+ parser.simple_keys[i].possible = false
	+ return true
	+}
	+
	+// Increase the flow level and resize the simple key list if needed.
	+func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {
	+ // Reset the simple key on the next level.
	+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
	+
	+ // Increase the flow level.
	+ parser.flow_level++
	+ return true
	+}
	+
	+// Decrease the flow level.
	+func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool {
	+ if parser.flow_level > 0 {
	+ parser.flow_level--
	+ parser.simple_keys = parser.simple_keys[:len(parser.simple_keys)-1]
	+ }
	+ return true
	+}
	+
	+// Push the current indentation level to the stack and set the new level
	+// the current column is greater than the indentation level. In this case,
	+// append or insert the specified token into the token queue.
	+func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool {
	+ // In the flow context, do nothing.
	+ if parser.flow_level > 0 {
	+ return true
	+ }
	+
	+ if parser.indent < column {
	+ // Push the current indentation level to the stack and set the new
	+ // indentation level.
	+ parser.indents = append(parser.indents, parser.indent)
	+ parser.indent = column
	+
	+ // Create a token and insert it into the queue.
	+ token := yaml_token_t{
	+ typ: typ,
	+ start_mark: mark,
	+ end_mark: mark,
	+ }
	+ if number > -1 {
	+ number -= parser.tokens_parsed
	+ }
	+ yaml_insert_token(parser, number, &token)
	+ }
	+ return true
	+}
	+
	+// Pop indentation levels from the indents stack until the current level
	+// becomes less or equal to the column. For each indentation level, append
	+// the BLOCK-END token.
	+func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool {
	+ // In the flow context, do nothing.
	+ if parser.flow_level > 0 {
	+ return true
	+ }
	+
	+ // Loop through the indentation levels in the stack.
	+ for parser.indent > column {
	+ // Create a token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_BLOCK_END_TOKEN,
	+ start_mark: parser.mark,
	+ end_mark: parser.mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+
	+ // Pop the indentation level.
	+ parser.indent = parser.indents[len(parser.indents)-1]
	+ parser.indents = parser.indents[:len(parser.indents)-1]
	+ }
	+ return true
	+}
	+
	+// Initialize the scanner and produce the STREAM-START token.
	+func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool {
	+
	+ // Set the initial indentation.
	+ parser.indent = -1
	+
	+ // Initialize the simple key stack.
	+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
	+
	+ // A simple key is allowed at the beginning of the stream.
	+ parser.simple_key_allowed = true
	+
	+ // We have started.
	+ parser.stream_start_produced = true
	+
	+ // Create the STREAM-START token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_STREAM_START_TOKEN,
	+ start_mark: parser.mark,
	+ end_mark: parser.mark,
	+ encoding: parser.encoding,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the STREAM-END token and shut down the scanner.
	+func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
	+
	+ // Force new line.
	+ if parser.mark.column != 0 {
	+ parser.mark.column = 0
	+ parser.mark.line++
	+ }
	+
	+ // Reset the indentation level.
	+ if !yaml_parser_unroll_indent(parser, -1) {
	+ return false
	+ }
	+
	+ // Reset simple keys.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ parser.simple_key_allowed = false
	+
	+ // Create the STREAM-END token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_STREAM_END_TOKEN,
	+ start_mark: parser.mark,
	+ end_mark: parser.mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
	+func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
	+ // Reset the indentation level.
	+ if !yaml_parser_unroll_indent(parser, -1) {
	+ return false
	+ }
	+
	+ // Reset simple keys.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ parser.simple_key_allowed = false
	+
	+ // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token.
	+ token := yaml_token_t{}
	+ if !yaml_parser_scan_directive(parser, &token) {
	+ return false
	+ }
	+ // Append the token to the queue.
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the DOCUMENT-START or DOCUMENT-END token.
	+func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
	+ // Reset the indentation level.
	+ if !yaml_parser_unroll_indent(parser, -1) {
	+ return false
	+ }
	+
	+ // Reset simple keys.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ parser.simple_key_allowed = false
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+
	+ skip(parser)
	+ skip(parser)
	+ skip(parser)
	+
	+ end_mark := parser.mark
	+
	+ // Create the DOCUMENT-START or DOCUMENT-END token.
	+ token := yaml_token_t{
	+ typ: typ,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ // Append the token to the queue.
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
	+func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
	+ // The indicators '[' and '{' may start a simple key.
	+ if !yaml_parser_save_simple_key(parser) {
	+ return false
	+ }
	+
	+ // Increase the flow level.
	+ if !yaml_parser_increase_flow_level(parser) {
	+ return false
	+ }
	+
	+ // A simple key may follow the indicators '[' and '{'.
	+ parser.simple_key_allowed = true
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token.
	+ token := yaml_token_t{
	+ typ: typ,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ // Append the token to the queue.
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
	+func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool {
	+ // Reset any potential simple key on the current flow level.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ // Decrease the flow level.
	+ if !yaml_parser_decrease_flow_level(parser) {
	+ return false
	+ }
	+
	+ // No simple keys after the indicators ']' and '}'.
	+ parser.simple_key_allowed = false
	+
	+ // Consume the token.
	+
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token.
	+ token := yaml_token_t{
	+ typ: typ,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ // Append the token to the queue.
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the FLOW-ENTRY token.
	+func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool {
	+ // Reset any potential simple keys on the current flow level.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ // Simple keys are allowed after ','.
	+ parser.simple_key_allowed = true
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the FLOW-ENTRY token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_FLOW_ENTRY_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the BLOCK-ENTRY token.
	+func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool {
	+ // Check if the scanner is in the block context.
	+ if parser.flow_level == 0 {
	+ // Check if we are allowed to start a new entry.
	+ if !parser.simple_key_allowed {
	+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
	+ "block sequence entries are not allowed in this context")
	+ }
	+ // Add the BLOCK-SEQUENCE-START token if needed.
	+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) {
	+ return false
	+ }
	+ } else {
	+ // It is an error for the '-' indicator to occur in the flow context,
	+ // but we let the Parser detect and report about it because the Parser
	+ // is able to point to the context.
	+ }
	+
	+ // Reset any potential simple keys on the current flow level.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ // Simple keys are allowed after '-'.
	+ parser.simple_key_allowed = true
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the BLOCK-ENTRY token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_BLOCK_ENTRY_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the KEY token.
	+func yaml_parser_fetch_key(parser *yaml_parser_t) bool {
	+
	+ // In the block context, additional checks are required.
	+ if parser.flow_level == 0 {
	+ // Check if we are allowed to start a new key (not nessesary simple).
	+ if !parser.simple_key_allowed {
	+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
	+ "mapping keys are not allowed in this context")
	+ }
	+ // Add the BLOCK-MAPPING-START token if needed.
	+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
	+ return false
	+ }
	+ }
	+
	+ // Reset any potential simple keys on the current flow level.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ // Simple keys are allowed after '?' in the block context.
	+ parser.simple_key_allowed = parser.flow_level == 0
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the KEY token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_KEY_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the VALUE token.
	+func yaml_parser_fetch_value(parser *yaml_parser_t) bool {
	+
	+ simple_key := &parser.simple_keys[len(parser.simple_keys)-1]
	+
	+ // Have we found a simple key?
	+ if simple_key.possible {
	+ // Create the KEY token and insert it into the queue.
	+ token := yaml_token_t{
	+ typ: yaml_KEY_TOKEN,
	+ start_mark: simple_key.mark,
	+ end_mark: simple_key.mark,
	+ }
	+ yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token)
	+
	+ // In the block context, we may need to add the BLOCK-MAPPING-START token.
	+ if !yaml_parser_roll_indent(parser, simple_key.mark.column,
	+ simple_key.token_number,
	+ yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) {
	+ return false
	+ }
	+
	+ // Remove the simple key.
	+ simple_key.possible = false
	+
	+ // A simple key cannot follow another simple key.
	+ parser.simple_key_allowed = false
	+
	+ } else {
	+ // The ':' indicator follows a complex key.
	+
	+ // In the block context, extra checks are required.
	+ if parser.flow_level == 0 {
	+
	+ // Check if we are allowed to start a complex value.
	+ if !parser.simple_key_allowed {
	+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
	+ "mapping values are not allowed in this context")
	+ }
	+
	+ // Add the BLOCK-MAPPING-START token if needed.
	+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
	+ return false
	+ }
	+ }
	+
	+ // Simple keys after ':' are allowed in the block context.
	+ parser.simple_key_allowed = parser.flow_level == 0
	+ }
	+
	+ // Consume the token.
	+ start_mark := parser.mark
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create the VALUE token and append it to the queue.
	+ token := yaml_token_t{
	+ typ: yaml_VALUE_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the ALIAS or ANCHOR token.
	+func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
	+ // An anchor or an alias could be a simple key.
	+ if !yaml_parser_save_simple_key(parser) {
	+ return false
	+ }
	+
	+ // A simple key cannot follow an anchor or an alias.
	+ parser.simple_key_allowed = false
	+
	+ // Create the ALIAS or ANCHOR token and append it to the queue.
	+ var token yaml_token_t
	+ if !yaml_parser_scan_anchor(parser, &token, typ) {
	+ return false
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the TAG token.
	+func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
	+ // A tag could be a simple key.
	+ if !yaml_parser_save_simple_key(parser) {
	+ return false
	+ }
	+
	+ // A simple key cannot follow a tag.
	+ parser.simple_key_allowed = false
	+
	+ // Create the TAG token and append it to the queue.
	+ var token yaml_token_t
	+ if !yaml_parser_scan_tag(parser, &token) {
	+ return false
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
	+func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool {
	+ // Remove any potential simple keys.
	+ if !yaml_parser_remove_simple_key(parser) {
	+ return false
	+ }
	+
	+ // A simple key may follow a block scalar.
	+ parser.simple_key_allowed = true
	+
	+ // Create the SCALAR token and append it to the queue.
	+ var token yaml_token_t
	+ if !yaml_parser_scan_block_scalar(parser, &token, literal) {
	+ return false
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
	+func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool {
	+ // A plain scalar could be a simple key.
	+ if !yaml_parser_save_simple_key(parser) {
	+ return false
	+ }
	+
	+ // A simple key cannot follow a flow scalar.
	+ parser.simple_key_allowed = false
	+
	+ // Create the SCALAR token and append it to the queue.
	+ var token yaml_token_t
	+ if !yaml_parser_scan_flow_scalar(parser, &token, single) {
	+ return false
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Produce the SCALAR(...,plain) token.
	+func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {
	+ // A plain scalar could be a simple key.
	+ if !yaml_parser_save_simple_key(parser) {
	+ return false
	+ }
	+
	+ // A simple key cannot follow a flow scalar.
	+ parser.simple_key_allowed = false
	+
	+ // Create the SCALAR token and append it to the queue.
	+ var token yaml_token_t
	+ if !yaml_parser_scan_plain_scalar(parser, &token) {
	+ return false
	+ }
	+ yaml_insert_token(parser, -1, &token)
	+ return true
	+}
	+
	+// Eat whitespaces and comments until the next token is found.
	+func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
	+
	+ // Until the next token is not found.
	+ for {
	+ // Allow the BOM mark to start a line.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ }
	+
	+ // Eat whitespaces.
	+ // Tabs are allowed:
	+ // - in the flow context
	+ // - in the block context, but not at the beginning of the line or
	+ // after '-', '?', or ':' (complex value).
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for parser.buffer[parser.buffer_pos] == ' ' \|\| ((parser.flow_level > 0 \|\| !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Eat a comment until a line break.
	+ if parser.buffer[parser.buffer_pos] == '#' {
	+ for !is_breakz(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+ }
	+
	+ // If it is a line break, eat it.
	+ if is_break(parser.buffer, parser.buffer_pos) {
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ skip_line(parser)
	+
	+ // In the block context, a new line may start a simple key.
	+ if parser.flow_level == 0 {
	+ parser.simple_key_allowed = true
	+ }
	+ } else {
	+ break // We have found a token.
	+ }
	+ }
	+
	+ return true
	+}
	+
	+// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
	+//
	+// Scope:
	+// %YAML 1.1 # a comment \n
	+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	+// %TAG !yaml! tag:yaml.org,2002: \n
	+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	+//
	+func yaml_parser_scan_directive(parser yaml_parser_t, token yaml_token_t) bool {
	+ // Eat '%'.
	+ start_mark := parser.mark
	+ skip(parser)
	+
	+ // Scan the directive name.
	+ var name []byte
	+ if !yaml_parser_scan_directive_name(parser, start_mark, &name) {
	+ return false
	+ }
	+
	+ // Is it a YAML directive?
	+ if bytes.Equal(name, []byte("YAML")) {
	+ // Scan the VERSION directive value.
	+ var major, minor int8
	+ if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) {
	+ return false
	+ }
	+ end_mark := parser.mark
	+
	+ // Create a VERSION-DIRECTIVE token.
	+ *token = yaml_token_t{
	+ typ: yaml_VERSION_DIRECTIVE_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ major: major,
	+ minor: minor,
	+ }
	+
	+ // Is it a TAG directive?
	+ } else if bytes.Equal(name, []byte("TAG")) {
	+ // Scan the TAG directive value.
	+ var handle, prefix []byte
	+ if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) {
	+ return false
	+ }
	+ end_mark := parser.mark
	+
	+ // Create a TAG-DIRECTIVE token.
	+ *token = yaml_token_t{
	+ typ: yaml_TAG_DIRECTIVE_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: handle,
	+ prefix: prefix,
	+ }
	+
	+ // Unknown directive.
	+ } else {
	+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
	+ start_mark, "found uknown directive name")
	+ return false
	+ }
	+
	+ // Eat the rest of the line including any comments.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for is_blank(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ if parser.buffer[parser.buffer_pos] == '#' {
	+ for !is_breakz(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+ }
	+
	+ // Check if we are at the end of the line.
	+ if !is_breakz(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
	+ start_mark, "did not find expected comment or line break")
	+ return false
	+ }
	+
	+ // Eat a line break.
	+ if is_break(parser.buffer, parser.buffer_pos) {
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ skip_line(parser)
	+ }
	+
	+ return true
	+}
	+
	+// Scan the directive name.
	+//
	+// Scope:
	+// %YAML 1.1 # a comment \n
	+// ^^^^
	+// %TAG !yaml! tag:yaml.org,2002: \n
	+// ^^^
	+//
	+func yaml_parser_scan_directive_name(parser yaml_parser_t, start_mark yaml_mark_t, name []byte) bool {
	+ // Consume the directive name.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ var s []byte
	+ for is_alpha(parser.buffer, parser.buffer_pos) {
	+ s = read(parser, s)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Check if the name is empty.
	+ if len(s) == 0 {
	+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
	+ start_mark, "could not find expected directive name")
	+ return false
	+ }
	+
	+ // Check for an blank character after the name.
	+ if !is_blankz(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
	+ start_mark, "found unexpected non-alphabetical character")
	+ return false
	+ }
	+ *name = s
	+ return true
	+}
	+
	+// Scan the value of VERSION-DIRECTIVE.
	+//
	+// Scope:
	+// %YAML 1.1 # a comment \n
	+// ^^^^^^
	+func yaml_parser_scan_version_directive_value(parser yaml_parser_t, start_mark yaml_mark_t, major, minor int8) bool {
	+ // Eat whitespaces.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ for is_blank(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Consume the major version number.
	+ if !yaml_parser_scan_version_directive_number(parser, start_mark, major) {
	+ return false
	+ }
	+
	+ // Eat '.'.
	+ if parser.buffer[parser.buffer_pos] != '.' {
	+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
	+ start_mark, "did not find expected digit or '.' character")
	+ }
	+
	+ skip(parser)
	+
	+ // Consume the minor version number.
	+ if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) {
	+ return false
	+ }
	+ return true
	+}
	+
	+const max_number_length = 2
	+
	+// Scan the version number of VERSION-DIRECTIVE.
	+//
	+// Scope:
	+// %YAML 1.1 # a comment \n
	+// ^
	+// %YAML 1.1 # a comment \n
	+// ^
	+func yaml_parser_scan_version_directive_number(parser yaml_parser_t, start_mark yaml_mark_t, number int8) bool {
	+
	+ // Repeat while the next character is digit.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ var value, length int8
	+ for is_digit(parser.buffer, parser.buffer_pos) {
	+ // Check if the number is too long.
	+ length++
	+ if length > max_number_length {
	+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
	+ start_mark, "found extremely long version number")
	+ }
	+ value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos))
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Check if the number was present.
	+ if length == 0 {
	+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
	+ start_mark, "did not find expected version number")
	+ }
	+ *number = value
	+ return true
	+}
	+
	+// Scan the value of a TAG-DIRECTIVE token.
	+//
	+// Scope:
	+// %TAG !yaml! tag:yaml.org,2002: \n
	+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	+//
	+func yaml_parser_scan_tag_directive_value(parser yaml_parser_t, start_mark yaml_mark_t, handle, prefix []byte) bool {
	+ var handle_value, prefix_value []byte
	+
	+ // Eat whitespaces.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for is_blank(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Scan a handle.
	+ if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) {
	+ return false
	+ }
	+
	+ // Expect a whitespace.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if !is_blank(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
	+ start_mark, "did not find expected whitespace")
	+ return false
	+ }
	+
	+ // Eat whitespaces.
	+ for is_blank(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Scan a prefix.
	+ if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) {
	+ return false
	+ }
	+
	+ // Expect a whitespace or line break.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if !is_blankz(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
	+ start_mark, "did not find expected whitespace or line break")
	+ return false
	+ }
	+
	+ *handle = handle_value
	+ *prefix = prefix_value
	+ return true
	+}
	+
	+func yaml_parser_scan_anchor(parser yaml_parser_t, token yaml_token_t, typ yaml_token_type_t) bool {
	+ var s []byte
	+
	+ // Eat the indicator character.
	+ start_mark := parser.mark
	+ skip(parser)
	+
	+ // Consume the value.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for is_alpha(parser.buffer, parser.buffer_pos) {
	+ s = read(parser, s)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ end_mark := parser.mark
	+
	+ /*
	+ * Check if length of the anchor is greater than 0 and it is followed by
	+ * a whitespace character or one of the indicators:
	+ *
	+ * '?', ':', ',', ']', '}', '%', '@', '`'.
	+ */
	+
	+ if len(s) == 0 \|\|
	+ !(is_blankz(parser.buffer, parser.buffer_pos) \|\| parser.buffer[parser.buffer_pos] == '?' \|\|
	+ parser.buffer[parser.buffer_pos] == ':' \|\| parser.buffer[parser.buffer_pos] == ',' \|\|
	+ parser.buffer[parser.buffer_pos] == ']' \|\| parser.buffer[parser.buffer_pos] == '}' \|\|
	+ parser.buffer[parser.buffer_pos] == '%' \|\| parser.buffer[parser.buffer_pos] == '@' \|\|
	+ parser.buffer[parser.buffer_pos] == '`') {
	+ context := "while scanning an alias"
	+ if typ == yaml_ANCHOR_TOKEN {
	+ context = "while scanning an anchor"
	+ }
	+ yaml_parser_set_scanner_error(parser, context, start_mark,
	+ "did not find expected alphabetic or numeric character")
	+ return false
	+ }
	+
	+ // Create a token.
	+ *token = yaml_token_t{
	+ typ: typ,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: s,
	+ }
	+
	+ return true
	+}
	+
	+/*
	+ * Scan a TAG token.
	+ */
	+
	+func yaml_parser_scan_tag(parser yaml_parser_t, token yaml_token_t) bool {
	+ var handle, suffix []byte
	+
	+ start_mark := parser.mark
	+
	+ // Check if the tag is in the canonical form.
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+
	+ if parser.buffer[parser.buffer_pos+1] == '<' {
	+ // Keep the handle as ''
	+
	+ // Eat '!<'
	+ skip(parser)
	+ skip(parser)
	+
	+ // Consume the tag value.
	+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
	+ return false
	+ }
	+
	+ // Check for '>' and eat it.
	+ if parser.buffer[parser.buffer_pos] != '>' {
	+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
	+ start_mark, "did not find the expected '>'")
	+ return false
	+ }
	+
	+ skip(parser)
	+ } else {
	+ // The tag has either the '!suffix' or the '!handle!suffix' form.
	+
	+ // First, try to scan a handle.
	+ if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) {
	+ return false
	+ }
	+
	+ // Check if it is, indeed, handle.
	+ if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' {
	+ // Scan the suffix now.
	+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
	+ return false
	+ }
	+ } else {
	+ // It wasn't a handle after all. Scan the rest of the tag.
	+ if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) {
	+ return false
	+ }
	+
	+ // Set the handle to '!'.
	+ handle = []byte{'!'}
	+
	+ // A special case: the '!' tag. Set the handle to '' and the
	+ // suffix to '!'.
	+ if len(suffix) == 0 {
	+ handle, suffix = suffix, handle
	+ }
	+ }
	+ }
	+
	+ // Check the character which ends the tag.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if !is_blankz(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
	+ start_mark, "did not find expected whitespace or line break")
	+ return false
	+ }
	+
	+ end_mark := parser.mark
	+
	+ // Create a token.
	+ *token = yaml_token_t{
	+ typ: yaml_TAG_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: handle,
	+ suffix: suffix,
	+ }
	+ return true
	+}
	+
	+// Scan a tag handle.
	+func yaml_parser_scan_tag_handle(parser yaml_parser_t, directive bool, start_mark yaml_mark_t, handle []byte) bool {
	+ // Check the initial '!' character.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if parser.buffer[parser.buffer_pos] != '!' {
	+ yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "did not find expected '!'")
	+ return false
	+ }
	+
	+ var s []byte
	+
	+ // Copy the '!' character.
	+ s = read(parser, s)
	+
	+ // Copy all subsequent alphabetical and numerical characters.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ for is_alpha(parser.buffer, parser.buffer_pos) {
	+ s = read(parser, s)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Check if the trailing character is '!' and copy it.
	+ if parser.buffer[parser.buffer_pos] == '!' {
	+ s = read(parser, s)
	+ } else {
	+ // It's either the '!' tag or not really a tag handle. If it's a %TAG
	+ // directive, it's an error. If it's a tag token, it must be a part of URI.
	+ if directive && !(s[0] == '!' && s[1] == 0) {
	+ yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "did not find expected '!'")
	+ return false
	+ }
	+ }
	+
	+ *handle = s
	+ return true
	+}
	+
	+// Scan a tag.
	+func yaml_parser_scan_tag_uri(parser yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri []byte) bool {
	+ //size_t length = head ? strlen((char *)head) : 0
	+ var s []byte
	+
	+ // Copy the head if needed.
	+ //
	+ // Note that we don't copy the leading '!' character.
	+ if len(head) > 1 {
	+ s = append(s, head[1:]...)
	+ }
	+
	+ // Scan the tag.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ // The set of characters that may appear in URI is as follows:
	+ //
	+ // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
	+ // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
	+ // '%'.
	+ // [Go] Convert this into more reasonable logic.
	+ for is_alpha(parser.buffer, parser.buffer_pos) \|\| parser.buffer[parser.buffer_pos] == ';' \|\|
	+ parser.buffer[parser.buffer_pos] == '/' \|\| parser.buffer[parser.buffer_pos] == '?' \|\|
	+ parser.buffer[parser.buffer_pos] == ':' \|\| parser.buffer[parser.buffer_pos] == '@' \|\|
	+ parser.buffer[parser.buffer_pos] == '&' \|\| parser.buffer[parser.buffer_pos] == '=' \|\|
	+ parser.buffer[parser.buffer_pos] == '+' \|\| parser.buffer[parser.buffer_pos] == '$' \|\|
	+ parser.buffer[parser.buffer_pos] == ',' \|\| parser.buffer[parser.buffer_pos] == '.' \|\|
	+ parser.buffer[parser.buffer_pos] == '!' \|\| parser.buffer[parser.buffer_pos] == '~' \|\|
	+ parser.buffer[parser.buffer_pos] == '*' \|\| parser.buffer[parser.buffer_pos] == '\'' \|\|
	+ parser.buffer[parser.buffer_pos] == '(' \|\| parser.buffer[parser.buffer_pos] == ')' \|\|
	+ parser.buffer[parser.buffer_pos] == '[' \|\| parser.buffer[parser.buffer_pos] == ']' \|\|
	+ parser.buffer[parser.buffer_pos] == '%' {
	+ // Check if it is a URI-escape sequence.
	+ if parser.buffer[parser.buffer_pos] == '%' {
	+ if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
	+ return false
	+ }
	+ } else {
	+ s = read(parser, s)
	+ }
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Check if the tag is non-empty.
	+ if len(s) == 0 {
	+ yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "did not find expected tag URI")
	+ return false
	+ }
	+ *uri = s
	+ return true
	+}
	+
	+// Decode an URI-escape sequence corresponding to a single UTF-8 character.
	+func yaml_parser_scan_uri_escapes(parser yaml_parser_t, directive bool, start_mark yaml_mark_t, s []byte) bool {
	+
	+ // Decode the required number of characters.
	+ w := 1024
	+ for w > 0 {
	+ // Check for a URI-escaped octet.
	+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
	+ return false
	+ }
	+
	+ if !(parser.buffer[parser.buffer_pos] == '%' &&
	+ is_hex(parser.buffer, parser.buffer_pos+1) &&
	+ is_hex(parser.buffer, parser.buffer_pos+2)) {
	+ return yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "did not find URI escaped octet")
	+ }
	+
	+ // Get the octet.
	+ octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
	+
	+ // If it is the leading octet, determine the length of the UTF-8 sequence.
	+ if w == 1024 {
	+ w = width(octet)
	+ if w == 0 {
	+ return yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "found an incorrect leading UTF-8 octet")
	+ }
	+ } else {
	+ // Check if the trailing octet is correct.
	+ if octet&0xC0 != 0x80 {
	+ return yaml_parser_set_scanner_tag_error(parser, directive,
	+ start_mark, "found an incorrect trailing UTF-8 octet")
	+ }
	+ }
	+
	+ // Copy the octet and move the pointers.
	+ s = append(s, octet)
	+ skip(parser)
	+ skip(parser)
	+ skip(parser)
	+ w--
	+ }
	+ return true
	+}
	+
	+// Scan a block scalar.
	+func yaml_parser_scan_block_scalar(parser yaml_parser_t, token yaml_token_t, literal bool) bool {
	+ // Eat the indicator '\|' or '>'.
	+ start_mark := parser.mark
	+ skip(parser)
	+
	+ // Scan the additional block scalar indicators.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ // Check for a chomping indicator.
	+ var chomping, increment int
	+ if parser.buffer[parser.buffer_pos] == '+' \|\| parser.buffer[parser.buffer_pos] == '-' {
	+ // Set the chomping method and eat the indicator.
	+ if parser.buffer[parser.buffer_pos] == '+' {
	+ chomping = +1
	+ } else {
	+ chomping = -1
	+ }
	+ skip(parser)
	+
	+ // Check for an indentation indicator.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if is_digit(parser.buffer, parser.buffer_pos) {
	+ // Check that the indentation is greater than 0.
	+ if parser.buffer[parser.buffer_pos] == '0' {
	+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
	+ start_mark, "found an indentation indicator equal to 0")
	+ return false
	+ }
	+
	+ // Get the indentation level and eat the indicator.
	+ increment = as_digit(parser.buffer, parser.buffer_pos)
	+ skip(parser)
	+ }
	+
	+ } else if is_digit(parser.buffer, parser.buffer_pos) {
	+ // Do the same as above, but in the opposite order.
	+
	+ if parser.buffer[parser.buffer_pos] == '0' {
	+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
	+ start_mark, "found an indentation indicator equal to 0")
	+ return false
	+ }
	+ increment = as_digit(parser.buffer, parser.buffer_pos)
	+ skip(parser)
	+
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ if parser.buffer[parser.buffer_pos] == '+' \|\| parser.buffer[parser.buffer_pos] == '-' {
	+ if parser.buffer[parser.buffer_pos] == '+' {
	+ chomping = +1
	+ } else {
	+ chomping = -1
	+ }
	+ skip(parser)
	+ }
	+ }
	+
	+ // Eat whitespaces and comments to the end of the line.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ for is_blank(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+ if parser.buffer[parser.buffer_pos] == '#' {
	+ for !is_breakz(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+ }
	+
	+ // Check if we are at the end of the line.
	+ if !is_breakz(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
	+ start_mark, "did not find expected comment or line break")
	+ return false
	+ }
	+
	+ // Eat a line break.
	+ if is_break(parser.buffer, parser.buffer_pos) {
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ skip_line(parser)
	+ }
	+
	+ end_mark := parser.mark
	+
	+ // Set the indentation level if it was specified.
	+ var indent int
	+ if increment > 0 {
	+ if parser.indent >= 0 {
	+ indent = parser.indent + increment
	+ } else {
	+ indent = increment
	+ }
	+ }
	+
	+ // Scan the leading line breaks and determine the indentation level if needed.
	+ var s, leading_break, trailing_breaks []byte
	+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
	+ return false
	+ }
	+
	+ // Scan the block scalar content.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ var leading_blank, trailing_blank bool
	+ for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) {
	+ // We are at the beginning of a non-empty line.
	+
	+ // Is it a trailing whitespace?
	+ trailing_blank = is_blank(parser.buffer, parser.buffer_pos)
	+
	+ // Check if we need to fold the leading line break.
	+ if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' {
	+ // Do we need to join the lines by space?
	+ if len(trailing_breaks) == 0 {
	+ s = append(s, ' ')
	+ }
	+ } else {
	+ s = append(s, leading_break...)
	+ }
	+ leading_break = leading_break[:0]
	+
	+ // Append the remaining line breaks.
	+ s = append(s, trailing_breaks...)
	+ trailing_breaks = trailing_breaks[:0]
	+
	+ // Is it a leading whitespace?
	+ leading_blank = is_blank(parser.buffer, parser.buffer_pos)
	+
	+ // Consume the current line.
	+ for !is_breakz(parser.buffer, parser.buffer_pos) {
	+ s = read(parser, s)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Consume the line break.
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+
	+ leading_break = read_line(parser, leading_break)
	+
	+ // Eat the following indentation spaces and line breaks.
	+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
	+ return false
	+ }
	+ }
	+
	+ // Chomp the tail.
	+ if chomping != -1 {
	+ s = append(s, leading_break...)
	+ }
	+ if chomping == 1 {
	+ s = append(s, trailing_breaks...)
	+ }
	+
	+ // Create a token.
	+ *token = yaml_token_t{
	+ typ: yaml_SCALAR_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: s,
	+ style: yaml_LITERAL_SCALAR_STYLE,
	+ }
	+ if !literal {
	+ token.style = yaml_FOLDED_SCALAR_STYLE
	+ }
	+ return true
	+}
	+
	+// Scan indentation spaces and line breaks for a block scalar. Determine the
	+// indentation level if needed.
	+func yaml_parser_scan_block_scalar_breaks(parser yaml_parser_t, indent int, breaks []byte, start_mark yaml_mark_t, end_mark yaml_mark_t) bool {
	+ *end_mark = parser.mark
	+
	+ // Eat the indentation spaces and line breaks.
	+ max_indent := 0
	+ for {
	+ // Eat the indentation spaces.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ for (indent == 0 \|\| parser.mark.column < indent) && is_space(parser.buffer, parser.buffer_pos) {
	+ skip(parser)
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+ if parser.mark.column > max_indent {
	+ max_indent = parser.mark.column
	+ }
	+
	+ // Check for a tab character messing the indentation.
	+ if (indent == 0 \|\| parser.mark.column < indent) && is_tab(parser.buffer, parser.buffer_pos) {
	+ return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
	+ start_mark, "found a tab character where an indentation space is expected")
	+ }
	+
	+ // Have we found a non-empty line?
	+ if !is_break(parser.buffer, parser.buffer_pos) {
	+ break
	+ }
	+
	+ // Consume the line break.
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ // [Go] Should really be returning breaks instead.
	+ breaks = read_line(parser, breaks)
	+ *end_mark = parser.mark
	+ }
	+
	+ // Determine the indentation level if needed.
	+ if *indent == 0 {
	+ *indent = max_indent
	+ if *indent < parser.indent+1 {
	+ *indent = parser.indent + 1
	+ }
	+ if *indent < 1 {
	+ *indent = 1
	+ }
	+ }
	+ return true
	+}
	+
	+// Scan a quoted scalar.
	+func yaml_parser_scan_flow_scalar(parser yaml_parser_t, token yaml_token_t, single bool) bool {
	+ // Eat the left quote.
	+ start_mark := parser.mark
	+ skip(parser)
	+
	+ // Consume the content of the quoted scalar.
	+ var s, leading_break, trailing_breaks, whitespaces []byte
	+ for {
	+ // Check that there are no document indicators at the beginning of the line.
	+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
	+ return false
	+ }
	+
	+ if parser.mark.column == 0 &&
	+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
	+ parser.buffer[parser.buffer_pos+1] == '-' &&
	+ parser.buffer[parser.buffer_pos+2] == '-') \|\|
	+ (parser.buffer[parser.buffer_pos+0] == '.' &&
	+ parser.buffer[parser.buffer_pos+1] == '.' &&
	+ parser.buffer[parser.buffer_pos+2] == '.')) &&
	+ is_blankz(parser.buffer, parser.buffer_pos+3) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
	+ start_mark, "found unexpected document indicator")
	+ return false
	+ }
	+
	+ // Check for EOF.
	+ if is_z(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
	+ start_mark, "found unexpected end of stream")
	+ return false
	+ }
	+
	+ // Consume non-blank characters.
	+ leading_blanks := false
	+ for !is_blankz(parser.buffer, parser.buffer_pos) {
	+ if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' {
	+ // Is is an escaped single quote.
	+ s = append(s, '\'')
	+ skip(parser)
	+ skip(parser)
	+
	+ } else if single && parser.buffer[parser.buffer_pos] == '\'' {
	+ // It is a right single quote.
	+ break
	+ } else if !single && parser.buffer[parser.buffer_pos] == '"' {
	+ // It is a right double quote.
	+ break
	+
	+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) {
	+ // It is an escaped line break.
	+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
	+ return false
	+ }
	+ skip(parser)
	+ skip_line(parser)
	+ leading_blanks = true
	+ break
	+
	+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' {
	+ // It is an escape sequence.
	+ code_length := 0
	+
	+ // Check the escape character.
	+ switch parser.buffer[parser.buffer_pos+1] {
	+ case '0':
	+ s = append(s, 0)
	+ case 'a':
	+ s = append(s, '\x07')
	+ case 'b':
	+ s = append(s, '\x08')
	+ case 't', '\t':
	+ s = append(s, '\x09')
	+ case 'n':
	+ s = append(s, '\x0A')
	+ case 'v':
	+ s = append(s, '\x0B')
	+ case 'f':
	+ s = append(s, '\x0C')
	+ case 'r':
	+ s = append(s, '\x0D')
	+ case 'e':
	+ s = append(s, '\x1B')
	+ case ' ':
	+ s = append(s, '\x20')
	+ case '"':
	+ s = append(s, '"')
	+ case '\'':
	+ s = append(s, '\'')
	+ case '\\':
	+ s = append(s, '\\')
	+ case 'N': // NEL (#x85)
	+ s = append(s, '\xC2')
	+ s = append(s, '\x85')
	+ case '_': // #xA0
	+ s = append(s, '\xC2')
	+ s = append(s, '\xA0')
	+ case 'L': // LS (#x2028)
	+ s = append(s, '\xE2')
	+ s = append(s, '\x80')
	+ s = append(s, '\xA8')
	+ case 'P': // PS (#x2029)
	+ s = append(s, '\xE2')
	+ s = append(s, '\x80')
	+ s = append(s, '\xA9')
	+ case 'x':
	+ code_length = 2
	+ case 'u':
	+ code_length = 4
	+ case 'U':
	+ code_length = 8
	+ default:
	+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
	+ start_mark, "found unknown escape character")
	+ return false
	+ }
	+
	+ skip(parser)
	+ skip(parser)
	+
	+ // Consume an arbitrary escape code.
	+ if code_length > 0 {
	+ var value int
	+
	+ // Scan the character value.
	+ if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) {
	+ return false
	+ }
	+ for k := 0; k < code_length; k++ {
	+ if !is_hex(parser.buffer, parser.buffer_pos+k) {
	+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
	+ start_mark, "did not find expected hexdecimal number")
	+ return false
	+ }
	+ value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k)
	+ }
	+
	+ // Check the value and write the character.
	+ if (value >= 0xD800 && value <= 0xDFFF) \|\| value > 0x10FFFF {
	+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
	+ start_mark, "found invalid Unicode character escape code")
	+ return false
	+ }
	+ if value <= 0x7F {
	+ s = append(s, byte(value))
	+ } else if value <= 0x7FF {
	+ s = append(s, byte(0xC0+(value>>6)))
	+ s = append(s, byte(0x80+(value&0x3F)))
	+ } else if value <= 0xFFFF {
	+ s = append(s, byte(0xE0+(value>>12)))
	+ s = append(s, byte(0x80+((value>>6)&0x3F)))
	+ s = append(s, byte(0x80+(value&0x3F)))
	+ } else {
	+ s = append(s, byte(0xF0+(value>>18)))
	+ s = append(s, byte(0x80+((value>>12)&0x3F)))
	+ s = append(s, byte(0x80+((value>>6)&0x3F)))
	+ s = append(s, byte(0x80+(value&0x3F)))
	+ }
	+
	+ // Advance the pointer.
	+ for k := 0; k < code_length; k++ {
	+ skip(parser)
	+ }
	+ }
	+ } else {
	+ // It is a non-escaped non-blank character.
	+ s = read(parser, s)
	+ }
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ }
	+
	+ // Check if we are at the end of the scalar.
	+ if single {
	+ if parser.buffer[parser.buffer_pos] == '\'' {
	+ break
	+ }
	+ } else {
	+ if parser.buffer[parser.buffer_pos] == '"' {
	+ break
	+ }
	+ }
	+
	+ // Consume blank characters.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for is_blank(parser.buffer, parser.buffer_pos) \|\| is_break(parser.buffer, parser.buffer_pos) {
	+ if is_blank(parser.buffer, parser.buffer_pos) {
	+ // Consume a space or a tab character.
	+ if !leading_blanks {
	+ whitespaces = read(parser, whitespaces)
	+ } else {
	+ skip(parser)
	+ }
	+ } else {
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+
	+ // Check if it is a first line break.
	+ if !leading_blanks {
	+ whitespaces = whitespaces[:0]
	+ leading_break = read_line(parser, leading_break)
	+ leading_blanks = true
	+ } else {
	+ trailing_breaks = read_line(parser, trailing_breaks)
	+ }
	+ }
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Join the whitespaces or fold line breaks.
	+ if leading_blanks {
	+ // Do we need to fold line breaks?
	+ if len(leading_break) > 0 && leading_break[0] == '\n' {
	+ if len(trailing_breaks) == 0 {
	+ s = append(s, ' ')
	+ } else {
	+ s = append(s, trailing_breaks...)
	+ }
	+ } else {
	+ s = append(s, leading_break...)
	+ s = append(s, trailing_breaks...)
	+ }
	+ trailing_breaks = trailing_breaks[:0]
	+ leading_break = leading_break[:0]
	+ } else {
	+ s = append(s, whitespaces...)
	+ whitespaces = whitespaces[:0]
	+ }
	+ }
	+
	+ // Eat the right quote.
	+ skip(parser)
	+ end_mark := parser.mark
	+
	+ // Create a token.
	+ *token = yaml_token_t{
	+ typ: yaml_SCALAR_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: s,
	+ style: yaml_SINGLE_QUOTED_SCALAR_STYLE,
	+ }
	+ if !single {
	+ token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
	+ }
	+ return true
	+}
	+
	+// Scan a plain scalar.
	+func yaml_parser_scan_plain_scalar(parser yaml_parser_t, token yaml_token_t) bool {
	+
	+ var s, leading_break, trailing_breaks, whitespaces []byte
	+ var leading_blanks bool
	+ var indent = parser.indent + 1
	+
	+ start_mark := parser.mark
	+ end_mark := parser.mark
	+
	+ // Consume the content of the plain scalar.
	+ for {
	+ // Check for a document indicator.
	+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
	+ return false
	+ }
	+ if parser.mark.column == 0 &&
	+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
	+ parser.buffer[parser.buffer_pos+1] == '-' &&
	+ parser.buffer[parser.buffer_pos+2] == '-') \|\|
	+ (parser.buffer[parser.buffer_pos+0] == '.' &&
	+ parser.buffer[parser.buffer_pos+1] == '.' &&
	+ parser.buffer[parser.buffer_pos+2] == '.')) &&
	+ is_blankz(parser.buffer, parser.buffer_pos+3) {
	+ break
	+ }
	+
	+ // Check for a comment.
	+ if parser.buffer[parser.buffer_pos] == '#' {
	+ break
	+ }
	+
	+ // Consume non-blank characters.
	+ for !is_blankz(parser.buffer, parser.buffer_pos) {
	+
	+ // Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13".
	+ if parser.flow_level > 0 &&
	+ parser.buffer[parser.buffer_pos] == ':' &&
	+ !is_blankz(parser.buffer, parser.buffer_pos+1) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
	+ start_mark, "found unexpected ':'")
	+ return false
	+ }
	+
	+ // Check for indicators that may end a plain scalar.
	+ if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) \|\|
	+ (parser.flow_level > 0 &&
	+ (parser.buffer[parser.buffer_pos] == ',' \|\| parser.buffer[parser.buffer_pos] == ':' \|\|
	+ parser.buffer[parser.buffer_pos] == '?' \|\| parser.buffer[parser.buffer_pos] == '[' \|\|
	+ parser.buffer[parser.buffer_pos] == ']' \|\| parser.buffer[parser.buffer_pos] == '{' \|\|
	+ parser.buffer[parser.buffer_pos] == '}')) {
	+ break
	+ }
	+
	+ // Check if we need to join whitespaces and breaks.
	+ if leading_blanks \|\| len(whitespaces) > 0 {
	+ if leading_blanks {
	+ // Do we need to fold line breaks?
	+ if leading_break[0] == '\n' {
	+ if len(trailing_breaks) == 0 {
	+ s = append(s, ' ')
	+ } else {
	+ s = append(s, trailing_breaks...)
	+ }
	+ } else {
	+ s = append(s, leading_break...)
	+ s = append(s, trailing_breaks...)
	+ }
	+ trailing_breaks = trailing_breaks[:0]
	+ leading_break = leading_break[:0]
	+ leading_blanks = false
	+ } else {
	+ s = append(s, whitespaces...)
	+ whitespaces = whitespaces[:0]
	+ }
	+ }
	+
	+ // Copy the character.
	+ s = read(parser, s)
	+
	+ end_mark = parser.mark
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+ }
	+
	+ // Is it the end?
	+ if !(is_blank(parser.buffer, parser.buffer_pos) \|\| is_break(parser.buffer, parser.buffer_pos)) {
	+ break
	+ }
	+
	+ // Consume blank characters.
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+
	+ for is_blank(parser.buffer, parser.buffer_pos) \|\| is_break(parser.buffer, parser.buffer_pos) {
	+ if is_blank(parser.buffer, parser.buffer_pos) {
	+
	+ // Check for tab character that abuse indentation.
	+ if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {
	+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
	+ start_mark, "found a tab character that violate indentation")
	+ return false
	+ }
	+
	+ // Consume a space or a tab character.
	+ if !leading_blanks {
	+ whitespaces = read(parser, whitespaces)
	+ } else {
	+ skip(parser)
	+ }
	+ } else {
	+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
	+ return false
	+ }
	+
	+ // Check if it is a first line break.
	+ if !leading_blanks {
	+ whitespaces = whitespaces[:0]
	+ leading_break = read_line(parser, leading_break)
	+ leading_blanks = true
	+ } else {
	+ trailing_breaks = read_line(parser, trailing_breaks)
	+ }
	+ }
	+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
	+ return false
	+ }
	+ }
	+
	+ // Check indentation level.
	+ if parser.flow_level == 0 && parser.mark.column < indent {
	+ break
	+ }
	+ }
	+
	+ // Create a token.
	+ *token = yaml_token_t{
	+ typ: yaml_SCALAR_TOKEN,
	+ start_mark: start_mark,
	+ end_mark: end_mark,
	+ value: s,
	+ style: yaml_PLAIN_SCALAR_STYLE,
	+ }
	+
	+ // Note that we change the 'simple_key_allowed' flag.
	+ if leading_blanks {
	+ parser.simple_key_allowed = true
	+ }
	+ return true
	+}
	diff --git a/src/gopkg.in/yaml.v2/sorter.go b/src/gopkg.in/yaml.v2/sorter.go
	new file mode 100644
	index 0000000..5958822
	--- /dev/null
	+++ b/src/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")
	+}
	diff --git a/src/gopkg.in/yaml.v2/suite_test.go b/src/gopkg.in/yaml.v2/suite_test.go
	new file mode 100644
	index 0000000..c5cf1ed
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/suite_test.go
	@@ -0,0 +1,12 @@
	+package yaml_test
	+
	+import (
	+ . "gopkg.in/check.v1"
	+ "testing"
	+)
	+
	+func Test(t *testing.T) { TestingT(t) }
	+
	+type S struct{}
	+
	+var _ = Suite(&S{})
	diff --git a/src/gopkg.in/yaml.v2/writerc.go b/src/gopkg.in/yaml.v2/writerc.go
	new file mode 100644
	index 0000000..190362f
	--- /dev/null
	+++ b/src/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
	+}
	diff --git a/src/gopkg.in/yaml.v2/yaml.go b/src/gopkg.in/yaml.v2/yaml.go
	new file mode 100644
	index 0000000..d133edf
	--- /dev/null
	+++ b/src/gopkg.in/yaml.v2/yaml.go
	@@ -0,0 +1,346 @@
	+// 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) {
	+ defer handleErr(&err)
	+ d := newDecoder()
	+ 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 "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 != "" {
	+ 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
	+}
	diff --git a/src/gopkg.in/yaml.v2/yamlh.go b/src/gopkg.in/yaml.v2/yamlh.go
	new file mode 100644
	index 0000000..d60a6b6
	--- /dev/null
	+++ b/src/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 occured.
	+ 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.
	+}
	diff --git a/src/gopkg.in/yaml.v2/yamlprivateh.go b/src/gopkg.in/yaml.v2/yamlprivateh.go
	new file mode 100644
	index 0000000..8110ce3
	--- /dev/null
	+++ b/src/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
	+
	+}
	diff --git a/src/meson.build b/src/meson.build
	index c035d76..991bce1 100644
	--- a/src/meson.build
	+++ b/src/meson.build
	@@ -1,9 +1,10 @@
	executable('com.github.writeas.writeas-gtk',
	'application.vala',
	'window.vala',
	+ 'Widgets/ModeSwitch.vala',

	c_args: ['-include', 'config.h'],
	link_args: '-lm',
	dependencies: [dependency('gtk+-3.0'), dependency('gtksourceview-3.0')],
	install: true
	)
	diff --git a/src/window.vala b/src/window.vala
	index 451279d..61542f5 100644
	--- a/src/window.vala
	+++ b/src/window.vala
	@@ -1,398 +1,393 @@
	/*
	Copyright © 2018 Write.as

	This file is part of the Write.as GTK desktop app.

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program. If not, see <https://www.gnu.org/licenses/>.
	*/
	public class WriteAs.MainWindow : Gtk.ApplicationWindow {
	private Gtk.TextView canvas;
	private Gtk.HeaderBar header;
	- private Gtk.ToggleButton darkmode_button;
	+ private Granite.ModeSwitch darkmode_switch;

	private static string data_dir = ".writeas";
	private static string version = "1.0.1";

	private int font_size = 16;
	private bool dark_mode = false;
	private string font = "Lora, 'Palatino Linotype',"
	+ "'Book Antiqua', 'New York', 'DejaVu serif', serif";
	private string fontstyle = "serif";
	private bool text_changed = false;

	private bool is_initializing = true;

	construct {
	header = new Gtk.HeaderBar();
	header.title = "Write.as";
	construct_toolbar();
	build_keyboard_shortcuts();

	var scrolled = new Gtk.ScrolledWindow(null, null);
	canvas = new Gtk.SourceView();
	canvas.wrap_mode = Gtk.WrapMode.WORD_CHAR;
	scrolled.add(canvas);
	add(scrolled);

	size_allocate.connect((_) => {adjust_text_style();});
	canvas.event_after.connect((evt) => {
	// TODO This word count algorithm may be quite naive
	// and could do improvement.
	var word_count = canvas.buffer.text.split(" ").length;
	header.subtitle = ngettext("%i word","%i words",word_count).printf(word_count);

	text_changed = true;
	});
	Timeout.add_full(Priority.DEFAULT_IDLE, 100/ms/, () => {
	if (!text_changed) return Source.CONTINUE;

	var text = canvas.buffer.text;
	// This happens sometimes for some reason, but it's difficult to debug.
	if (text == "") return Source.CONTINUE;

	try {
	draft_file().replace_contents(text.data, null, false,
	FileCreateFlags.PRIVATE \| FileCreateFlags.REPLACE_DESTINATION,
	null);
	text_changed = false;
	} catch (Error err) {/* We'll try again anyways. */}

	return Source.CONTINUE;
	});

	adjust_text_style(false);

	}

	public MainWindow(Gtk.Application app) {
	stdout.printf("writeas-gtk v%s\n", version);

	set_application(app);
	icon_name = "com.github.writeas.writeas-gtk";
	init_folder();
	try {
	open_file(draft_file());
	} catch (Error err) {}
	restore_styles();

	set_default_size(800, 600);
	is_initializing = false;
	}

	private static void init_folder() {
	var home = File.new_for_path(get_data_dir());
	try {
	home.make_directory();
	} catch (Error e) {
	stderr.printf("Create data dir: %s\n", e.message);
	}
	}

	private static string get_data_dir() {
	return Environment.get_home_dir() + "/" + data_dir;
	}

	private static File draft_file() {
	var home = File.new_for_path(get_data_dir());
	return home.get_child("draft.txt");
	}

	private static bool supports_dark_theme() {
	var theme = Gtk.Settings.get_default().gtk_theme_name;

	foreach (var datapath in Environment.get_system_data_dirs()) {
	var path = File.new_for_path(Path.build_filename(datapath, "themes", theme));
	if (path.get_child("gtk-dark.css").query_exists()) return true;

	try {
	var enumerator = path.enumerate_children("standard::*", 0);
	FileInfo info = null;
	while ((info = enumerator.next_file()) != null) {
	var fullpath = path.get_child(info.get_name()).get_child("gtk-dark.css");
	if (fullpath.query_exists()) return true;
	}
	} catch (Error err) {/* Might be missing something, but no biggy. */}
	}

	return false;
	}

	private void construct_toolbar() {
	header.show_close_button = true;
	set_titlebar(header);

	var publish_button = new Gtk.Button.from_icon_name("document-send",
	Gtk.IconSize.LARGE_TOOLBAR);
	publish_button.tooltip_text = _("Publish to Write.as on the web");
	publish_button.clicked.connect(() => {
	canvas.buffer.text += "\n\n" + publish();

	canvas.grab_focus();
	});
	header.pack_end(publish_button);

	- darkmode_button = new Gtk.ToggleButton();
	- darkmode_button.tooltip_text = _("Toggle dark theme");
	- // NOTE the fallback icon is a bit of a meaning stretch, but it works.
	- var icon_theme = Gtk.IconTheme.get_default();
	- darkmode_button.image = new Gtk.Image.from_icon_name(
	- icon_theme.has_icon("writeas-bright-dark") ?
	- "writeas-bright-dark" : "weather-clear-night",
	- Gtk.IconSize.LARGE_TOOLBAR);
	- darkmode_button.draw_indicator = false;
	+ darkmode_switch = new Granite.ModeSwitch.from_icon_name ("display-brightness-symbolic", "weather-clear-night-symbolic");
	+ darkmode_switch.primary_icon_tooltip_text = ("Light theme");
	+ darkmode_switch.secondary_icon_tooltip_text = ("Dark theme");
	+ darkmode_switch.valign = Gtk.Align.CENTER;
	var settings = Gtk.Settings.get_default();
	- darkmode_button.toggled.connect(() => {
	- settings.gtk_application_prefer_dark_theme = darkmode_button.active;
	- dark_mode = darkmode_button.active;
	+ darkmode_switch.notify["active"].connect(() => {
	+ settings.gtk_application_prefer_dark_theme = darkmode_switch.active;
	+ dark_mode = darkmode_switch.active;
	if (!is_initializing) theme_save();

	canvas.grab_focus();
	});
	- if (supports_dark_theme()) header.pack_end(darkmode_button);
	+ if (supports_dark_theme()) header.pack_end(darkmode_switch);

	var fonts = new Gtk.MenuButton();
	fonts.tooltip_text = _("Change document font");
	fonts.image = new Gtk.Image.from_icon_name("font-x-generic", Gtk.IconSize.LARGE_TOOLBAR);
	fonts.popup = new Gtk.Menu();
	header.pack_start(fonts);

	build_fontoption(fonts.popup, _("Serif"), "serif", font);
	build_fontoption(fonts.popup, _("Sans-serif"), "sans",
	"'Open Sans', 'Segoe UI', Tahoma, Arial, sans-serif");
	build_fontoption(fonts.popup, _("Monospace"), "wrap", "Hack, consolas," +
	"Menlo-Regular, Menlo, Monaco, 'ubuntu mono', monospace");
	fonts.popup.show_all();
	}

	private unowned SList<Gtk.RadioMenuItem>? font_options = null;
	private void build_fontoption(Gtk.Menu menu,
	string label, string fontstyle, string families) {
	var option = new Gtk.RadioMenuItem.with_label(font_options, label);
	font_options = option.get_group();
	option.activate.connect(() => {
	this.font = families;
	this.fontstyle = fontstyle;
	adjust_text_style(!is_initializing);

	canvas.grab_focus();
	});

	var styles = option.get_style_context();
	var provider = new Gtk.CssProvider();
	try {
	provider.load_from_data("* {font-family: %s;}".printf(families));
	styles.add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);
	} catch (Error e) {
	warning(e.message);
	}

	menu.add(option);
	}

	public override void grab_focus() {
	canvas.grab_focus();
	}

	private KeyFile theme = new KeyFile();
	private void restore_styles() {
	try {
	loaded_theme = true;

	theme.load_from_file(get_data_dir() + "/prefs.ini", KeyFileFlags.NONE);

	dark_mode = theme.get_boolean("Theme", "darkmode");
	- darkmode_button.set_active(dark_mode);
	+ darkmode_switch.active = dark_mode;
	Gtk.Settings.get_default().gtk_application_prefer_dark_theme = dark_mode;
	font_size = theme.get_integer("Theme", "fontsize");
	font = theme.get_string("Post", "font");
	fontstyle = theme.get_string("Post", "fontstyle");

	adjust_text_style(false);
	} catch (Error err) {/* No biggy... */}
	}

	private Gtk.CssProvider cur_styles = null;
	// So the theme isn't read before it's saved.
	private bool loaded_theme = false;
	private void adjust_text_style(bool save_theme = true) {
	try {
	if (cur_styles != null)
	Gtk.StyleContext.remove_provider_for_screen(Gdk.Screen.get_default(), cur_styles);

	var padding = canvas.get_allocated_width()*0.10;
	var css = ("textview {font-family: %s; font-size: %dpx; padding: 20px;" +
	" padding-left: %ipx; padding-right: %ipx;" +
	" caret-color: #5ac4ee;}").printf(font, font_size,
	(int) padding, (int) padding);
	cur_styles = new Gtk.CssProvider();
	cur_styles.load_from_data(css);

	Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
	cur_styles, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);

	if (save_theme) theme_save();
	} catch (Error e) {
	warning(e.message);
	}
	}

	private void theme_save() {
	if (!loaded_theme) return;
	theme.set_boolean("Theme", "darkmode", dark_mode);
	theme.set_integer("Theme", "fontsize", font_size);
	theme.set_string("Post", "font", font);
	theme.set_string("Post", "fontstyle", fontstyle);

	try {
	theme.save_to_file(get_data_dir() + "/prefs.ini");
	} catch (FileError err) {/* Oh well. */}
	}

	private string publish() {
	try {
	if (text_changed) {;
	draft_file().replace_contents(canvas.buffer.text.data, null, false,
	FileCreateFlags.PRIVATE \| FileCreateFlags.REPLACE_DESTINATION,
	null);
	text_changed = false;
	}

	var cmd = "sh -c 'cat ~/" + data_dir + "/draft.txt \| writeas --md --font %s --user-agent \"writeas-gtk v" + version + "\"'";
	cmd = cmd.printf(fontstyle);
	string stdout, stderr;
	int status;
	Process.spawn_command_line_sync(cmd,
	out stdout, out stderr, out status);

	// Open it in the browser
	if (status == 0) {
	var browser = AppInfo.get_default_for_uri_scheme("https");
	var urls = new List<string>();
	urls.append(stdout.strip());
	browser.launch_uris(urls, null);
	}

	return stderr.strip();
	} catch (Error err) {
	return err.message;
	}
	}
	/* --- */

	private void build_keyboard_shortcuts() {
	/* These operations are not exposed to the UI as buttons,
	as most people are very familiar with them and they are not the
	focus of this app. */
	var accels = new Gtk.AccelGroup();

	// App operations
	accels.connect(Gdk.Key.W, Gdk.ModifierType.CONTROL_MASK,
	Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED,
	(g,a,k,m) => quit());
	accels.connect(Gdk.Key.Q, Gdk.ModifierType.CONTROL_MASK,
	Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED,
	(g,a,k,m) => quit());

	// File operations
	accels.connect(Gdk.Key.S, Gdk.ModifierType.CONTROL_MASK,
	Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED,
	(g,a,k,m) => save_as());
	accels.connect(Gdk.Key.S,
	Gdk.ModifierType.CONTROL_MASK \| Gdk.ModifierType.SHIFT_MASK,
	Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED,
	(g,a,k,m) => save_as());

	// Adjust text size
	accels.connect(Gdk.Key.minus, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED, (g,a,k,m) => {
	if (font_size < 3) {
	return false;
	}
	if (font_size <= 10) {
	font_size -= 1;
	} else {
	font_size -= 2;
	}
	adjust_text_style(true);
	return true;
	});
	accels.connect(Gdk.Key.equal, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED, (g,a,k,m) => {
	if (font_size < 10) {
	font_size += 1;
	} else {
	font_size += 2;
	}
	adjust_text_style(true);
	return true;
	});

	// Toggle theme with Ctrl+T
	accels.connect(Gdk.Key.T, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED, (g,a,k,m) => {
	- darkmode_button.set_active(!darkmode_button.get_active());
	+ darkmode_switch.active = !darkmode_switch.active;
	return true;
	});

	// Publish with Ctrl+Enter
	accels.connect(Gdk.Key.Return, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE \| Gtk.AccelFlags.LOCKED, (g,a,k,m) => {
	canvas.buffer.text += "\n\n" + publish();
	return true;
	});

	add_accel_group(accels);
	}

	private bool save_as() {
	try {
	var file = prompt_file(Gtk.FileChooserAction.SAVE, _("Save as"));
	file.replace_contents(canvas.buffer.text.data, null, false,
	FileCreateFlags.PRIVATE \| FileCreateFlags.REPLACE_DESTINATION,
	null);
	} catch (Error e) {
	// It's fine...
	}
	return true;
	}

	private File prompt_file(Gtk.FileChooserAction mode, string action)
	throws UserCancellable {
	var file_chooser = new Gtk.FileChooserDialog(action, this, mode,
	_("Cancel"), Gtk.ResponseType.CANCEL,
	action, Gtk.ResponseType.ACCEPT);

	file_chooser.select_multiple = false;
	var filter = new Gtk.FileFilter();
	filter.add_mime_type("text/plain");
	file_chooser.set_filter(filter);

	var resp = file_chooser.run();
	file_chooser.close();
	if (resp == Gtk.ResponseType.ACCEPT) {
	return file_chooser.get_file();
	} else {
	throw new UserCancellable.USER_CANCELLED("FileChooserDialog");
	}
	}

	public void open_file(File file) throws Error {
	uint8[] text;
	file.load_contents(null, out text, null);
	canvas.buffer.text = (string) text;
	}

	private bool quit() {
	this.close();
	return true;
	}
	}

	errordomain WriteAs.UserCancellable {USER_CANCELLED}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 22, 6:00 AM (14 h, 51 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3155523

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions