diff -uNr docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/app.go docker-1/vendor/src/github.com/codegangsta/cli/app.go

--- docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/app.go	1969-12-31 19:00:00.000000000 -0500

+++ docker-1/vendor/src/github.com/codegangsta/cli/app.go	2015-01-16 03:56:49.105152140 -0500

@@ -0,0 +1,248 @@

+package cli

+

+import (

+	"fmt"

+	"io/ioutil"

+	"os"

+	"time"

+)

+

+// App is the main structure of a cli application. It is recomended that

+// and app be created with the cli.NewApp() function

+type App struct {

+	// The name of the program. Defaults to os.Args[0]

+	Name string

+	// Description of the program.

+	Usage string

+	// Version of the program

+	Version 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

+	// An action to execute when the bash-completion flag is set

+	BashComplete func(context *Context)

+	// 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 func(context *Context) error

+	// The action to execute when no subcommands are specified

+	Action func(context *Context)

+	// Execute this function if the proper command cannot be found

+	CommandNotFound func(context *Context, command string)

+	// Compilation date

+	Compiled time.Time

+	// Author

+	Author string

+	// Author e-mail

+	Email string

+}

+

+// 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()

+}

+

+// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.

+func NewApp() *App {

+	return &App{

+		Name:         os.Args[0],

+		Usage:        "A new cli application",

+		Version:      "0.0.0",

+		BashComplete: DefaultAppComplete,

+		Action:       helpCommand.Action,

+		Compiled:     compileTime(),

+		Author:       "Author",

+		Email:        "unknown@email",

+	}

+}

+

+// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination

+func (a *App) Run(arguments []string) error {

+	// append help to commands

+	if a.Command(helpCommand.Name) == nil && !a.HideHelp {

+		a.Commands = append(a.Commands, helpCommand)

+		a.appendFlag(HelpFlag)

+	}

+

+	//append version/help flags

+	if a.EnableBashCompletion {

+		a.appendFlag(BashCompletionFlag)

+	}

+	a.appendFlag(VersionFlag)

+

+	// parse flags

+	set := flagSet(a.Name, a.Flags)

+	set.SetOutput(ioutil.Discard)

+	err := set.Parse(arguments[1:])

+	nerr := normalizeFlags(a.Flags, set)

+	if nerr != nil {

+		fmt.Println(nerr)

+		context := NewContext(a, set, set)

+		ShowAppHelp(context)

+		fmt.Println("")

+		return nerr

+	}

+	context := NewContext(a, set, set)

+

+	if err != nil {

+		fmt.Printf("Incorrect Usage.\n\n")

+		ShowAppHelp(context)

+		fmt.Println("")

+		return err

+	}

+

+	if checkCompletions(context) {

+		return nil

+	}

+

+	if checkHelp(context) {

+		return nil

+	}

+

+	if checkVersion(context) {

+		return nil

+	}

+

+	if a.Before != nil {

+		err := a.Before(context)

+		if err != nil {

+			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

+	a.Action(context)

+	return nil

+}

+

+// Another entry point to the cli app, takes care of passing arguments and error handling

+func (a *App) RunAndExitOnError() {

+	if err := a.Run(os.Args); err != nil {

+		os.Stderr.WriteString(fmt.Sprintln(err))

+		os.Exit(1)

+	}

+}

+

+// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags

+func (a *App) RunAsSubcommand(ctx *Context) error {

+	// append help to commands

+	if len(a.Commands) > 0 {

+		if a.Command(helpCommand.Name) == nil && !a.HideHelp {

+			a.Commands = append(a.Commands, helpCommand)

+			a.appendFlag(HelpFlag)

+		}

+	}

+

+	// append flags

+	if a.EnableBashCompletion {

+		a.appendFlag(BashCompletionFlag)

+	}

+

+	// parse flags

+	set := flagSet(a.Name, a.Flags)

+	set.SetOutput(ioutil.Discard)

+	err := set.Parse(ctx.Args().Tail())

+	nerr := normalizeFlags(a.Flags, set)

+	context := NewContext(a, set, ctx.globalSet)

+

+	if nerr != nil {

+		fmt.Println(nerr)

+		if len(a.Commands) > 0 {

+			ShowSubcommandHelp(context)

+		} else {

+			ShowCommandHelp(ctx, context.Args().First())

+		}

+		fmt.Println("")

+		return nerr

+	}

+

+	if err != nil {

+		fmt.Printf("Incorrect Usage.\n\n")

+		ShowSubcommandHelp(context)

+		return err

+	}

+

+	if checkCompletions(context) {

+		return nil

+	}

+

+	if len(a.Commands) > 0 {

+		if checkSubcommandHelp(context) {

+			return nil

+		}

+	} else {

+		if checkCommandHelp(ctx, context.Args().First()) {

+			return nil

+		}

+	}

+

+	if a.Before != nil {

+		err := a.Before(context)

+		if err != nil {

+			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

+	if len(a.Commands) > 0 {

+		a.Action(context)

+	} else {

+		a.Action(ctx)

+	}

+

+	return nil

+}

+

+// 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

+}

+

+func (a *App) hasFlag(flag Flag) bool {

+	for _, f := range a.Flags {

+		if flag == f {

+			return true

+		}

+	}

+

+	return false

+}

+

+func (a *App) appendFlag(flag Flag) {

+	if !a.hasFlag(flag) {

+		a.Flags = append(a.Flags, flag)

+	}

+}

diff -uNr docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/app_test.go docker-1/vendor/src/github.com/codegangsta/cli/app_test.go

--- docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/app_test.go	1969-12-31 19:00:00.000000000 -0500

+++ docker-1/vendor/src/github.com/codegangsta/cli/app_test.go	2015-01-16 03:56:49.104152140 -0500

@@ -0,0 +1,399 @@

+package cli_test

+

+import (

+	"fmt"

+	"os"

+	"testing"

+

+	"github.com/codegangsta/cli"

+)

+

+func ExampleApp() {

+	// set args for examples sake

+	os.Args = []string{"greet", "--name", "Jeremy"}

+

+	app := cli.NewApp()

+	app.Name = "greet"

+	app.Flags = []cli.Flag{

+		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},

+	}

+	app.Action = func(c *cli.Context) {

+		fmt.Printf("Hello %v\n", c.String("name"))

+	}

+	app.Run(os.Args)

+	// Output:

+	// Hello Jeremy

+}

+

+func ExampleAppSubcommand() {

+	// set args for examples sake

+	os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}

+	app := cli.NewApp()

+	app.Name = "say"

+	app.Commands = []cli.Command{

+		{

+			Name:        "hello",

+			ShortName:   "hi",

+			Usage:       "use it to see a description",

+			Description: "This is how we describe hello the function",

+			Subcommands: []cli.Command{

+				{

+					Name:        "english",

+					ShortName:   "en",

+					Usage:       "sends a greeting in english",

+					Description: "greets someone in english",

+					Flags: []cli.Flag{

+						cli.StringFlag{Name: "name", Value: "Bob", Usage: "Name of the person to greet"},

+					},

+					Action: func(c *cli.Context) {

+						fmt.Println("Hello,", c.String("name"))

+					},

+				},

+			},

+		},

+	}

+

+	app.Run(os.Args)

+	// Output:

+	// Hello, Jeremy

+}

+

+func ExampleAppHelp() {

+	// set args for examples sake

+	os.Args = []string{"greet", "h", "describeit"}

+

+	app := cli.NewApp()

+	app.Name = "greet"

+	app.Flags = []cli.Flag{

+		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},

+	}

+	app.Commands = []cli.Command{

+		{

+			Name:        "describeit",

+			ShortName:   "d",

+			Usage:       "use it to see a description",

+			Description: "This is how we describe describeit the function",

+			Action: func(c *cli.Context) {

+				fmt.Printf("i like to describe things")

+			},

+		},

+	}

+	app.Run(os.Args)

+	// Output:

+	// NAME:

+	//    describeit - use it to see a description

+	//

+	// USAGE:

+	//    command describeit [arguments...]

+	//

+	// DESCRIPTION:

+	//    This is how we describe describeit the function

+}

+

+func ExampleAppBashComplete() {

+	// set args for examples sake

+	os.Args = []string{"greet", "--generate-bash-completion"}

+

+	app := cli.NewApp()

+	app.Name = "greet"

+	app.EnableBashCompletion = true

+	app.Commands = []cli.Command{

+		{

+			Name:        "describeit",

+			ShortName:   "d",

+			Usage:       "use it to see a description",

+			Description: "This is how we describe describeit the function",

+			Action: func(c *cli.Context) {

+				fmt.Printf("i like to describe things")

+			},

+		}, {

+			Name:        "next",

+			Usage:       "next example",

+			Description: "more stuff to see when generating bash completion",

+			Action: func(c *cli.Context) {

+				fmt.Printf("the next example")

+			},

+		},

+	}

+

+	app.Run(os.Args)

+	// Output:

+	// describeit

+	// d

+	// next

+	// help

+	// h

+}

+

+func TestApp_Run(t *testing.T) {

+	s := ""

+

+	app := cli.NewApp()

+	app.Action = func(c *cli.Context) {

+		s = s + c.Args().First()

+	}

+

+	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 := cli.NewApp()

+	fooCommand := cli.Command{Name: "foobar", ShortName: "f"}

+	batCommand := cli.Command{Name: "batbaz", ShortName: "b"}

+	app.Commands = []cli.Command{

+		fooCommand,

+		batCommand,

+	}

+

+	for _, test := range commandAppTests {

+		expect(t, app.Command(test.name) != nil, test.expected)

+	}

+}

+

+func TestApp_CommandWithArgBeforeFlags(t *testing.T) {

+	var parsedOption, firstArg string

+

+	app := cli.NewApp()

+	command := cli.Command{

+		Name: "cmd",

+		Flags: []cli.Flag{

+			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},

+		},

+		Action: func(c *cli.Context) {

+			parsedOption = c.String("option")

+			firstArg = c.Args().First()

+		},

+	}

+	app.Commands = []cli.Command{command}

+

+	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})

+

+	expect(t, parsedOption, "my-option")

+	expect(t, firstArg, "my-arg")

+}

+

+func TestApp_Float64Flag(t *testing.T) {

+	var meters float64

+

+	app := cli.NewApp()

+	app.Flags = []cli.Flag{

+		cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},

+	}

+	app.Action = func(c *cli.Context) {

+		meters = c.Float64("height")

+	}

+

+	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 := cli.NewApp()

+	command := cli.Command{

+		Name: "cmd",

+		Flags: []cli.Flag{

+			cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},

+			cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},

+		},

+		Action: func(c *cli.Context) {

+			parsedIntSlice = c.IntSlice("p")

+			parsedStringSlice = c.StringSlice("ip")

+			parsedOption = c.String("option")

+			firstArg = c.Args().First()

+		},

+	}

+	app.Commands = []cli.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_BeforeFunc(t *testing.T) {

+	beforeRun, subcommandRun := false, false

+	beforeError := fmt.Errorf("fail")

+	var err error

+

+	app := cli.NewApp()

+

+	app.Before = func(c *cli.Context) error {

+		beforeRun = true

+		s := c.String("opt")

+		if s == "fail" {

+			return beforeError

+		}

+

+		return nil

+	}

+

+	app.Commands = []cli.Command{

+		cli.Command{

+			Name: "sub",

+			Action: func(c *cli.Context) {

+				subcommandRun = true

+			},

+		},

+	}

+

+	app.Flags = []cli.Flag{

+		cli.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 beforeRun == false {

+		t.Errorf("Before() not executed when expected")

+	}

+

+	if subcommandRun == false {

+		t.Errorf("Subcommand not executed when expected")

+	}

+

+	// reset

+	beforeRun, subcommandRun = false, false

+

+	// 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 beforeRun == false {

+		t.Errorf("Before() not executed when expected")

+	}

+

+	if subcommandRun == true {

+		t.Errorf("Subcommand executed when NOT expected")

+	}

+

+}

+

+func TestAppHelpPrinter(t *testing.T) {

+	oldPrinter := cli.HelpPrinter

+	defer func() {

+		cli.HelpPrinter = oldPrinter

+	}()

+

+	var wasCalled = false

+	cli.HelpPrinter = func(template string, data interface{}) {

+		wasCalled = true

+	}

+

+	app := cli.NewApp()

+	app.Run([]string{"-h"})

+

+	if wasCalled == false {

+		t.Errorf("Help printer expected to be called, but was not")

+	}

+}

+

+func TestAppCommandNotFound(t *testing.T) {

+	beforeRun, subcommandRun := false, false

+	app := cli.NewApp()

+

+	app.CommandNotFound = func(c *cli.Context, command string) {

+		beforeRun = true

+	}

+

+	app.Commands = []cli.Command{

+		cli.Command{

+			Name: "bar",

+			Action: func(c *cli.Context) {

+				subcommandRun = true

+			},

+		},

+	}

+

+	app.Run([]string{"command", "foo"})

+

+	expect(t, beforeRun, true)

+	expect(t, subcommandRun, false)

+}

+

+func TestGlobalFlagsInSubcommands(t *testing.T) {

+	subcommandRun := false

+	app := cli.NewApp()

+

+	app.Flags = []cli.Flag{

+		cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},

+	}

+

+	app.Commands = []cli.Command{

+		cli.Command{

+			Name: "foo",

+			Subcommands: []cli.Command{

+				{

+					Name: "bar",

+					Action: func(c *cli.Context) {

+						if c.GlobalBool("debug") {

+							subcommandRun = true

+						}

+					},

+				},

+			},

+		},

+	}

+

+	app.Run([]string{"command", "-d", "foo", "bar"})

+

+	expect(t, subcommandRun, true)

+}

diff -uNr docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete docker-1/vendor/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete

--- docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete	1969-12-31 19:00:00.000000000 -0500

+++ docker-1/vendor/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete	2015-01-16 03:56:49.103152140 -0500

@@ -0,0 +1,13 @@

+#! /bin/bash

+

+_cli_bash_autocomplete() {

+     local cur prev opts base

+     COMPREPLY=()

+     cur="${COMP_WORDS[COMP_CWORD]}"

+     prev="${COMP_WORDS[COMP_CWORD-1]}"

+     opts=$( ${COMP_WORDS[@]:0:COMP_CWORD} --generate-bash-completion )

+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )

+     return 0

+ }

+  

+ complete -F _cli_bash_autocomplete $PROG

\ No newline at end of file

diff -uNr docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/cli.go docker-1/vendor/src/github.com/codegangsta/cli/cli.go

--- docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/cli.go	1969-12-31 19:00:00.000000000 -0500

+++ docker-1/vendor/src/github.com/codegangsta/cli/cli.go	2015-01-16 03:56:49.104152140 -0500

@@ -0,0 +1,19 @@

+// 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) {

+//       println("Greetings")

+//     }

+//

+//     app.Run(os.Args)

+//   }

+package cli

diff -uNr docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/cli_test.go docker-1/vendor/src/github.com/codegangsta/cli/cli_test.go

--- docker-6ee24211b4111e0b1e1bd7a46c5a3c4ced1b2ffa/vendor/src/github.com/codegangsta/cli/cli_test.go	1969-12-31 19:00:00.000000000 -0500

+++ docker-1/vendor/src/github.com/codegangsta/cli/cli_test.go	2015-01-16 03:56:49.105152140 -0500

@@ -0,0 +1,88 @@

+package cli_test

+

+import (

+	"os"

+

+	"github.com/codegangsta/cli"

+)

+

+func Example() {

+	app := cli.NewApp()

+	app.Name = "todo"

+	app.Usage = "task list on the command line"

+	app.Commands = []cli.Command{

+		{

+			Name:      "add",

+			ShortName: "a",

+			Usage:     "add a task to the list",

+			Action: func(c *cli.Context) {

+				println("added task: ", c.Args().First())

+			},