From 8ea1232ede49c2634f6068cd52c0a03aeeaac82a Mon Sep 17 00:00:00 2001
From: Edward Sheffler III <edward.sheffler.iii@gmail.com>
Date: Mon, 20 Jul 2015 12:18:25 -0700
Subject: [PATCH] Improve vendoring options by removing self-referential
 imports in tests.

---
 app_test.go     | 282 ++++++++++++++++++++++++------------------------
 cli_test.go     |  38 ++++---
 command_test.go |  20 ++--
 context_test.go |  34 +++---
 flag_test.go    | 258 ++++++++++++++++++++++----------------------
 help_test.go    |  16 ++-
 helpers_test.go |   2 +-
 7 files changed, 319 insertions(+), 331 deletions(-)

diff --git a/app_test.go b/app_test.go
index 2d52e88..4c6787a 100644
--- a/app_test.go
+++ b/app_test.go
@@ -1,4 +1,4 @@
-package cli_test
+package cli
 
 import (
 	"bytes"
@@ -8,25 +8,23 @@ import (
 	"os"
 	"strings"
 	"testing"
-
-	"github.com/codegangsta/cli"
 )
 
 func ExampleApp() {
 	// set args for examples sake
 	os.Args = []string{"greet", "--name", "Jeremy"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	app.Flags = []Flag{
+		StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
 	}
-	app.Action = func(c *cli.Context) {
+	app.Action = func(c *Context) {
 		fmt.Printf("Hello %v\n", c.String("name"))
 	}
 	app.Author = "Harrison"
 	app.Email = "harrison@lolwut.com"
-	app.Authors = []cli.Author{cli.Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
+	app.Authors = []Author{Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
 	app.Run(os.Args)
 	// Output:
 	// Hello Jeremy
@@ -35,28 +33,28 @@ func ExampleApp() {
 func ExampleAppSubcommand() {
 	// set args for examples sake
 	os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "say"
-	app.Commands = []cli.Command{
+	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: []cli.Command{
+			Subcommands: []Command{
 				{
 					Name:        "english",
 					Aliases:     []string{"en"},
 					Usage:       "sends a greeting in english",
 					Description: "greets someone in english",
-					Flags: []cli.Flag{
-						cli.StringFlag{
+					Flags: []Flag{
+						StringFlag{
 							Name:  "name",
 							Value: "Bob",
 							Usage: "Name of the person to greet",
 						},
 					},
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						fmt.Println("Hello,", c.String("name"))
 					},
 				},
@@ -73,18 +71,18 @@ func ExampleAppHelp() {
 	// set args for examples sake
 	os.Args = []string{"greet", "h", "describeit"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	app.Flags = []Flag{
+		StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
 	}
-	app.Commands = []cli.Command{
+	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 *cli.Context) {
+			Action: func(c *Context) {
 				fmt.Printf("i like to describe things")
 			},
 		},
@@ -105,23 +103,23 @@ func ExampleAppBashComplete() {
 	// set args for examples sake
 	os.Args = []string{"greet", "--generate-bash-completion"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
 	app.EnableBashCompletion = true
-	app.Commands = []cli.Command{
+	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 *cli.Context) {
+			Action: func(c *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) {
+			Action: func(c *Context) {
 				fmt.Printf("the next example")
 			},
 		},
@@ -139,8 +137,8 @@ func ExampleAppBashComplete() {
 func TestApp_Run(t *testing.T) {
 	s := ""
 
-	app := cli.NewApp()
-	app.Action = func(c *cli.Context) {
+	app := NewApp()
+	app.Action = func(c *Context) {
 		s = s + c.Args().First()
 	}
 
@@ -164,10 +162,10 @@ var commandAppTests = []struct {
 }
 
 func TestApp_Command(t *testing.T) {
-	app := cli.NewApp()
-	fooCommand := cli.Command{Name: "foobar", Aliases: []string{"f"}}
-	batCommand := cli.Command{Name: "batbaz", Aliases: []string{"b"}}
-	app.Commands = []cli.Command{
+	app := NewApp()
+	fooCommand := Command{Name: "foobar", Aliases: []string{"f"}}
+	batCommand := Command{Name: "batbaz", Aliases: []string{"b"}}
+	app.Commands = []Command{
 		fooCommand,
 		batCommand,
 	}
@@ -180,18 +178,18 @@ func TestApp_Command(t *testing.T) {
 func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
 	var parsedOption, firstArg string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
+		Flags: []Flag{
+			StringFlag{Name: "option", Value: "", Usage: "some option"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedOption = c.String("option")
 			firstArg = c.Args().First()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
 
@@ -200,23 +198,23 @@ func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
 }
 
 func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
-	var context *cli.Context
+	var context *Context
 
-	a := cli.NewApp()
-	a.Commands = []cli.Command{
+	a := NewApp()
+	a.Commands = []Command{
 		{
 			Name: "foo",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				context = c
 			},
-			Flags: []cli.Flag{
-				cli.StringFlag{
+			Flags: []Flag{
+				StringFlag{
 					Name:  "lang",
 					Value: "english",
 					Usage: "language for the greeting",
 				},
 			},
-			Before: func(_ *cli.Context) error { return nil },
+			Before: func(_ *Context) error { return nil },
 		},
 	}
 	a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
@@ -229,18 +227,18 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
 	var parsedOption string
 	var args []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
+		Flags: []Flag{
+			StringFlag{Name: "option", Value: "", Usage: "some option"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedOption = c.String("option")
 			args = c.Args()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
 
@@ -253,14 +251,14 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
 func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
 	var args []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			args = c.Args()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
 
@@ -272,11 +270,11 @@ func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
 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 := NewApp()
+	app.Flags = []Flag{
+		Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
 	}
-	app.Action = func(c *cli.Context) {
+	app.Action = func(c *Context) {
 		meters = c.Float64("height")
 	}
 
@@ -289,21 +287,21 @@ func TestApp_ParseSliceFlags(t *testing.T) {
 	var parsedIntSlice []int
 	var parsedStringSlice []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := 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"},
+		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 *cli.Context) {
+		Action: func(c *Context) {
 			parsedIntSlice = c.IntSlice("p")
 			parsedStringSlice = c.StringSlice("ip")
 			parsedOption = c.String("option")
 			firstArg = c.Args().First()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
 
@@ -346,19 +344,19 @@ func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
 	var parsedIntSlice []int
 	var parsedStringSlice []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "a", Usage: "set numbers"},
-			cli.StringSliceFlag{Name: "str", Usage: "set strings"},
+		Flags: []Flag{
+			IntSliceFlag{Name: "a", Usage: "set numbers"},
+			StringSliceFlag{Name: "str", Usage: "set strings"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedIntSlice = c.IntSlice("a")
 			parsedStringSlice = c.StringSlice("str")
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
 
@@ -375,7 +373,7 @@ func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
 }
 
 func TestApp_DefaultStdout(t *testing.T) {
-	app := cli.NewApp()
+	app := NewApp()
 
 	if app.Writer != os.Stdout {
 		t.Error("Default output writer not set.")
@@ -403,7 +401,7 @@ func (fw *mockWriter) GetWritten() (b []byte) {
 func TestApp_SetStdout(t *testing.T) {
 	w := &mockWriter{}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "test"
 	app.Writer = w
 
@@ -423,9 +421,9 @@ func TestApp_BeforeFunc(t *testing.T) {
 	beforeError := fmt.Errorf("fail")
 	var err error
 
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.Before = func(c *cli.Context) error {
+	app.Before = func(c *Context) error {
 		beforeRun = true
 		s := c.String("opt")
 		if s == "fail" {
@@ -435,17 +433,17 @@ func TestApp_BeforeFunc(t *testing.T) {
 		return nil
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "sub",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
 	}
 
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
+	app.Flags = []Flag{
+		StringFlag{Name: "opt"},
 	}
 
 	// run with the Before() func succeeding
@@ -489,9 +487,9 @@ func TestApp_AfterFunc(t *testing.T) {
 	afterError := fmt.Errorf("fail")
 	var err error
 
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.After = func(c *cli.Context) error {
+	app.After = func(c *Context) error {
 		afterRun = true
 		s := c.String("opt")
 		if s == "fail" {
@@ -501,17 +499,17 @@ func TestApp_AfterFunc(t *testing.T) {
 		return nil
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "sub",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
 	}
 
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
+	app.Flags = []Flag{
+		StringFlag{Name: "opt"},
 	}
 
 	// run with the After() func succeeding
@@ -550,14 +548,14 @@ func TestApp_AfterFunc(t *testing.T) {
 }
 
 func TestAppNoHelpFlag(t *testing.T) {
-	oldFlag := cli.HelpFlag
+	oldFlag := HelpFlag
 	defer func() {
-		cli.HelpFlag = oldFlag
+		HelpFlag = oldFlag
 	}()
 
-	cli.HelpFlag = cli.BoolFlag{}
+	HelpFlag = BoolFlag{}
 
-	app := cli.NewApp()
+	app := NewApp()
 	err := app.Run([]string{"test", "-h"})
 
 	if err != flag.ErrHelp {
@@ -566,17 +564,17 @@ func TestAppNoHelpFlag(t *testing.T) {
 }
 
 func TestAppHelpPrinter(t *testing.T) {
-	oldPrinter := cli.HelpPrinter
+	oldPrinter := HelpPrinter
 	defer func() {
-		cli.HelpPrinter = oldPrinter
+		HelpPrinter = oldPrinter
 	}()
 
 	var wasCalled = false
-	cli.HelpPrinter = func(w io.Writer, template string, data interface{}) {
+	HelpPrinter = func(w io.Writer, template string, data interface{}) {
 		wasCalled = true
 	}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Run([]string{"-h"})
 
 	if wasCalled == false {
@@ -585,19 +583,19 @@ func TestAppHelpPrinter(t *testing.T) {
 }
 
 func TestAppVersionPrinter(t *testing.T) {
-	oldPrinter := cli.VersionPrinter
+	oldPrinter := VersionPrinter
 	defer func() {
-		cli.VersionPrinter = oldPrinter
+		VersionPrinter = oldPrinter
 	}()
 
 	var wasCalled = false
-	cli.VersionPrinter = func(c *cli.Context) {
+	VersionPrinter = func(c *Context) {
 		wasCalled = true
 	}
 
-	app := cli.NewApp()
-	ctx := cli.NewContext(app, nil, nil)
-	cli.ShowVersion(ctx)
+	app := NewApp()
+	ctx := NewContext(app, nil, nil)
+	ShowVersion(ctx)
 
 	if wasCalled == false {
 		t.Errorf("Version printer expected to be called, but was not")
@@ -606,16 +604,16 @@ func TestAppVersionPrinter(t *testing.T) {
 
 func TestAppCommandNotFound(t *testing.T) {
 	beforeRun, subcommandRun := false, false
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.CommandNotFound = func(c *cli.Context, command string) {
+	app.CommandNotFound = func(c *Context, command string) {
 		beforeRun = true
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "bar",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
@@ -630,11 +628,11 @@ func TestAppCommandNotFound(t *testing.T) {
 func TestGlobalFlag(t *testing.T) {
 	var globalFlag string
 	var globalFlagSet bool
-	app := cli.NewApp()
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "global, g", Usage: "global"},
+	app := NewApp()
+	app.Flags = []Flag{
+		StringFlag{Name: "global, g", Usage: "global"},
 	}
-	app.Action = func(c *cli.Context) {
+	app.Action = func(c *Context) {
 		globalFlag = c.GlobalString("global")
 		globalFlagSet = c.GlobalIsSet("global")
 	}
@@ -647,22 +645,22 @@ func TestGlobalFlag(t *testing.T) {
 func TestGlobalFlagsInSubcommands(t *testing.T) {
 	subcommandRun := false
 	parentFlag := false
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.Flags = []cli.Flag{
-		cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
+	app.Flags = []Flag{
+		BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "foo",
-			Flags: []cli.Flag{
-				cli.BoolFlag{Name: "parent, p", Usage: "Parent flag"},
+			Flags: []Flag{
+				BoolFlag{Name: "parent, p", Usage: "Parent flag"},
 			},
-			Subcommands: []cli.Command{
+			Subcommands: []Command{
 				{
 					Name: "bar",
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						if c.GlobalBool("debug") {
 							subcommandRun = true
 						}
@@ -691,25 +689,25 @@ func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
 	for _, flagSet := range subcommandHelpTopics {
 		t.Logf("==> checking with flags %v", flagSet)
 
-		app := cli.NewApp()
+		app := NewApp()
 		buf := new(bytes.Buffer)
 		app.Writer = buf
 
-		subCmdBar := cli.Command{
+		subCmdBar := Command{
 			Name:  "bar",
 			Usage: "does bar things",
 		}
-		subCmdBaz := cli.Command{
+		subCmdBaz := Command{
 			Name:  "baz",
 			Usage: "does baz things",
 		}
-		cmd := cli.Command{
+		cmd := Command{
 			Name:        "foo",
 			Description: "descriptive wall of text about how it does foo things",
-			Subcommands: []cli.Command{subCmdBar, subCmdBaz},
+			Subcommands: []Command{subCmdBar, subCmdBaz},
 		}
 
-		app.Commands = []cli.Command{cmd}
+		app.Commands = []Command{cmd}
 		err := app.Run(flagSet)
 
 		if err != nil {
@@ -736,20 +734,20 @@ func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
 }
 
 func TestApp_Run_SubcommandFullPath(t *testing.T) {
-	app := cli.NewApp()
+	app := NewApp()
 	buf := new(bytes.Buffer)
 	app.Writer = buf
 
-	subCmd := cli.Command{
+	subCmd := Command{
 		Name:  "bar",
 		Usage: "does bar things",
 	}
-	cmd := cli.Command{
+	cmd := Command{
 		Name:        "foo",
 		Description: "foo commands",
-		Subcommands: []cli.Command{subCmd},
+		Subcommands: []Command{subCmd},
 	}
-	app.Commands = []cli.Command{cmd}
+	app.Commands = []Command{cmd}
 
 	err := app.Run([]string{"command", "foo", "bar", "--help"})
 	if err != nil {
@@ -773,11 +771,11 @@ func TestApp_Run_Help(t *testing.T) {
 
 		t.Logf("==> checking with arguments %v", args)
 
-		app := cli.NewApp()
+		app := NewApp()
 		app.Name = "boom"
 		app.Usage = "make an explosive entrance"
 		app.Writer = buf
-		app.Action = func(c *cli.Context) {
+		app.Action = func(c *Context) {
 			buf.WriteString("boom I say!")
 		}
 
@@ -803,12 +801,12 @@ func TestApp_Run_Version(t *testing.T) {
 
 		t.Logf("==> checking with arguments %v", args)
 
-		app := cli.NewApp()
+		app := NewApp()
 		app.Name = "boom"
 		app.Usage = "make an explosive entrance"
 		app.Version = "0.1.0"
 		app.Writer = buf
-		app.Action = func(c *cli.Context) {
+		app.Action = func(c *Context) {
 			buf.WriteString("boom I say!")
 		}
 
@@ -827,10 +825,10 @@ func TestApp_Run_Version(t *testing.T) {
 }
 
 func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
-	app := cli.NewApp()
-	app.Action = func(c *cli.Context) {}
-	app.Before = func(c *cli.Context) error { return fmt.Errorf("before error") }
-	app.After = func(c *cli.Context) error { return fmt.Errorf("after error") }
+	app := NewApp()
+	app.Action = func(c *Context) {}
+	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 {
@@ -846,12 +844,12 @@ func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
 }
 
 func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
-	app := cli.NewApp()
-	app.Commands = []cli.Command{
-		cli.Command{
+	app := NewApp()
+	app.Commands = []Command{
+		Command{
 			Name:   "bar",
-			Before: func(c *cli.Context) error { return fmt.Errorf("before error") },
-			After:  func(c *cli.Context) error { return fmt.Errorf("after error") },
+			Before: func(c *Context) error { return fmt.Errorf("before error") },
+			After:  func(c *Context) error { return fmt.Errorf("after error") },
 		},
 	}
 
diff --git a/cli_test.go b/cli_test.go
index 8a8df97..e54f8e2 100644
--- a/cli_test.go
+++ b/cli_test.go
@@ -1,21 +1,19 @@
-package cli_test
+package cli
 
 import (
 	"os"
-
-	"github.com/codegangsta/cli"
 )
 
 func Example() {
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "todo"
 	app.Usage = "task list on the command line"
-	app.Commands = []cli.Command{
+	app.Commands = []Command{
 		{
 			Name:    "add",
 			Aliases: []string{"a"},
 			Usage:   "add a task to the list",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				println("added task: ", c.Args().First())
 			},
 		},
@@ -23,7 +21,7 @@ func Example() {
 			Name:    "complete",
 			Aliases: []string{"c"},
 			Usage:   "complete a task on the list",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				println("completed task: ", c.Args().First())
 			},
 		},
@@ -33,56 +31,56 @@ func Example() {
 }
 
 func ExampleSubcommand() {
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "say"
-	app.Commands = []cli.Command{
+	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: []cli.Command{
+			Subcommands: []Command{
 				{
 					Name:        "english",
 					Aliases:     []string{"en"},
 					Usage:       "sends a greeting in english",
 					Description: "greets someone in english",
-					Flags: []cli.Flag{
-						cli.StringFlag{
+					Flags: []Flag{
+						StringFlag{
 							Name:  "name",
 							Value: "Bob",
 							Usage: "Name of the person to greet",
 						},
 					},
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						println("Hello, ", c.String("name"))
 					},
 				}, {
 					Name:    "spanish",
 					Aliases: []string{"sp"},
 					Usage:   "sends a greeting in spanish",
-					Flags: []cli.Flag{
-						cli.StringFlag{
+					Flags: []Flag{
+						StringFlag{
 							Name:  "surname",
 							Value: "Jones",
 							Usage: "Surname of the person to greet",
 						},
 					},
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						println("Hola, ", c.String("surname"))
 					},
 				}, {
 					Name:    "french",
 					Aliases: []string{"fr"},
 					Usage:   "sends a greeting in french",
-					Flags: []cli.Flag{
-						cli.StringFlag{
+					Flags: []Flag{
+						StringFlag{
 							Name:  "nickname",
 							Value: "Stevie",
 							Usage: "Nickname of the person to greet",
 						},
 					},
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						println("Bonjour, ", c.String("nickname"))
 					},
 				},
@@ -90,7 +88,7 @@ func ExampleSubcommand() {
 		}, {
 			Name:  "bye",
 			Usage: "says goodbye",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				println("bye")
 			},
 		},
diff --git a/command_test.go b/command_test.go
index db81db2..688d12c 100644
--- a/command_test.go
+++ b/command_test.go
@@ -1,26 +1,24 @@
-package cli_test
+package cli
 
 import (
 	"flag"
 	"testing"
-
-	"github.com/codegangsta/cli"
 )
 
 func TestCommandDoNotIgnoreFlags(t *testing.T) {
-	app := cli.NewApp()
+	app := NewApp()
 	set := flag.NewFlagSet("test", 0)
 	test := []string{"blah", "blah", "-break"}
 	set.Parse(test)
 
-	c := cli.NewContext(app, set, nil)
+	c := NewContext(app, set, nil)
 
-	command := cli.Command{
+	command := Command{
 		Name:        "test-cmd",
 		Aliases:     []string{"tc"},
 		Usage:       "this is for testing",
 		Description: "testing",
-		Action:      func(_ *cli.Context) {},
+		Action:      func(_ *Context) {},
 	}
 	err := command.Run(c)
 
@@ -28,19 +26,19 @@ func TestCommandDoNotIgnoreFlags(t *testing.T) {
 }
 
 func TestCommandIgnoreFlags(t *testing.T) {
-	app := cli.NewApp()
+	app := NewApp()
 	set := flag.NewFlagSet("test", 0)
 	test := []string{"blah", "blah"}
 	set.Parse(test)
 
-	c := cli.NewContext(app, set, nil)
+	c := NewContext(app, set, nil)
 
-	command := cli.Command{
+	command := Command{
 		Name:            "test-cmd",
 		Aliases:         []string{"tc"},
 		Usage:           "this is for testing",
 		Description:     "testing",
-		Action:          func(_ *cli.Context) {},
+		Action:          func(_ *Context) {},
 		SkipFlagParsing: true,
 	}
 	err := command.Run(c)
diff --git a/context_test.go b/context_test.go
index 6c27d06..7f8e928 100644
--- a/context_test.go
+++ b/context_test.go
@@ -1,11 +1,9 @@
-package cli_test
+package cli
 
 import (
 	"flag"
 	"testing"
 	"time"
-
-	"github.com/codegangsta/cli"
 )
 
 func TestNewContext(t *testing.T) {
@@ -13,9 +11,9 @@ func TestNewContext(t *testing.T) {
 	set.Int("myflag", 12, "doc")
 	globalSet := flag.NewFlagSet("test", 0)
 	globalSet.Int("myflag", 42, "doc")
-	globalCtx := cli.NewContext(nil, globalSet, nil)
-	command := cli.Command{Name: "mycommand"}
-	c := cli.NewContext(nil, set, globalCtx)
+	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.GlobalInt("myflag"), 42)
@@ -25,42 +23,42 @@ func TestNewContext(t *testing.T) {
 func TestContext_Int(t *testing.T) {
 	set := flag.NewFlagSet("test", 0)
 	set.Int("myflag", 12, "doc")
-	c := cli.NewContext(nil, set, nil)
+	c := NewContext(nil, set, nil)
 	expect(t, c.Int("myflag"), 12)
 }
 
 func TestContext_Duration(t *testing.T) {
 	set := flag.NewFlagSet("test", 0)
 	set.Duration("myflag", time.Duration(12*time.Second), "doc")
-	c := cli.NewContext(nil, set, nil)
+	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 := cli.NewContext(nil, set, nil)
+	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 := cli.NewContext(nil, set, nil)
+	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 := cli.NewContext(nil, set, nil)
+	c := NewContext(nil, set, nil)
 	expect(t, c.BoolT("myflag"), true)
 }
 
 func TestContext_Args(t *testing.T) {
 	set := flag.NewFlagSet("test", 0)
 	set.Bool("myflag", false, "doc")
-	c := cli.NewContext(nil, set, nil)
+	c := NewContext(nil, set, nil)
 	set.Parse([]string{"--myflag", "bat", "baz"})
 	expect(t, len(c.Args()), 2)
 	expect(t, c.Bool("myflag"), true)
@@ -72,8 +70,8 @@ func TestContext_IsSet(t *testing.T) {
 	set.String("otherflag", "hello world", "doc")
 	globalSet := flag.NewFlagSet("test", 0)
 	globalSet.Bool("myflagGlobal", true, "doc")
-	globalCtx := cli.NewContext(nil, globalSet, nil)
-	c := cli.NewContext(nil, set, globalCtx)
+	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)
@@ -89,8 +87,8 @@ func TestContext_GlobalIsSet(t *testing.T) {
 	globalSet := flag.NewFlagSet("test", 0)
 	globalSet.Bool("myflagGlobal", true, "doc")
 	globalSet.Bool("myflagGlobalUnset", true, "doc")
-	globalCtx := cli.NewContext(nil, globalSet, nil)
-	c := cli.NewContext(nil, set, globalCtx)
+	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)
@@ -107,8 +105,8 @@ func TestContext_NumFlags(t *testing.T) {
 	set.String("otherflag", "hello world", "doc")
 	globalSet := flag.NewFlagSet("test", 0)
 	globalSet.Bool("myflagGlobal", true, "doc")
-	globalCtx := cli.NewContext(nil, globalSet, nil)
-	c := cli.NewContext(nil, set, globalCtx)
+	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)
diff --git a/flag_test.go b/flag_test.go
index f0f096a..3606102 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -1,4 +1,4 @@
-package cli_test
+package cli
 
 import (
 	"fmt"
@@ -6,8 +6,6 @@ import (
 	"reflect"
 	"strings"
 	"testing"
-
-	"github.com/codegangsta/cli"
 )
 
 var boolFlagTests = []struct {
@@ -21,7 +19,7 @@ var boolFlagTests = []struct {
 func TestBoolFlagHelpOutput(t *testing.T) {
 
 	for _, test := range boolFlagTests {
-		flag := cli.BoolFlag{Name: test.name}
+		flag := BoolFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -44,7 +42,7 @@ var stringFlagTests = []struct {
 func TestStringFlagHelpOutput(t *testing.T) {
 
 	for _, test := range stringFlagTests {
-		flag := cli.StringFlag{Name: test.name, Value: test.value}
+		flag := StringFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -57,7 +55,7 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_FOO", "derp")
 	for _, test := range stringFlagTests {
-		flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
+		flag := StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_FOO]") {
@@ -68,26 +66,26 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
 
 var stringSliceFlagTests = []struct {
 	name     string
-	value    *cli.StringSlice
+	value    *StringSlice
 	expected string
 }{
-	{"help", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
+	{"help", func() *StringSlice {
+		s := &StringSlice{}
 		s.Set("")
 		return s
 	}(), "--help [--help option --help option]\t"},
-	{"h", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
+	{"h", func() *StringSlice {
+		s := &StringSlice{}
 		s.Set("")
 		return s
 	}(), "-h [-h option -h option]\t"},
-	{"h", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
+	{"h", func() *StringSlice {
+		s := &StringSlice{}
 		s.Set("")
 		return s
 	}(), "-h [-h option -h option]\t"},
-	{"test", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
+	{"test", func() *StringSlice {
+		s := &StringSlice{}
 		s.Set("Something")
 		return s
 	}(), "--test [--test option --test option]\t"},
@@ -96,7 +94,7 @@ var stringSliceFlagTests = []struct {
 func TestStringSliceFlagHelpOutput(t *testing.T) {
 
 	for _, test := range stringSliceFlagTests {
-		flag := cli.StringSliceFlag{Name: test.name, Value: test.value}
+		flag := StringSliceFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -109,7 +107,7 @@ func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_QWWX", "11,4")
 	for _, test := range stringSliceFlagTests {
-		flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
+		flag := StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_QWWX]") {
@@ -129,7 +127,7 @@ var intFlagTests = []struct {
 func TestIntFlagHelpOutput(t *testing.T) {
 
 	for _, test := range intFlagTests {
-		flag := cli.IntFlag{Name: test.name}
+		flag := IntFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -142,7 +140,7 @@ func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_BAR", "2")
 	for _, test := range intFlagTests {
-		flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"}
+		flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_BAR]") {
@@ -162,7 +160,7 @@ var durationFlagTests = []struct {
 func TestDurationFlagHelpOutput(t *testing.T) {
 
 	for _, test := range durationFlagTests {
-		flag := cli.DurationFlag{Name: test.name}
+		flag := DurationFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -175,7 +173,7 @@ func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_BAR", "2h3m6s")
 	for _, test := range durationFlagTests {
-		flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
+		flag := DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_BAR]") {
@@ -186,14 +184,14 @@ func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
 
 var intSliceFlagTests = []struct {
 	name     string
-	value    *cli.IntSlice
+	value    *IntSlice
 	expected string
 }{
-	{"help", &cli.IntSlice{}, "--help [--help option --help option]\t"},
-	{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
-	{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
-	{"test", func() *cli.IntSlice {
-		i := &cli.IntSlice{}
+	{"help", &IntSlice{}, "--help [--help option --help option]\t"},
+	{"h", &IntSlice{}, "-h [-h option -h option]\t"},
+	{"h", &IntSlice{}, "-h [-h option -h option]\t"},
+	{"test", func() *IntSlice {
+		i := &IntSlice{}
 		i.Set("9")
 		return i
 	}(), "--test [--test option --test option]\t"},
@@ -202,7 +200,7 @@ var intSliceFlagTests = []struct {
 func TestIntSliceFlagHelpOutput(t *testing.T) {
 
 	for _, test := range intSliceFlagTests {
-		flag := cli.IntSliceFlag{Name: test.name, Value: test.value}
+		flag := IntSliceFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -215,7 +213,7 @@ func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_SMURF", "42,3")
 	for _, test := range intSliceFlagTests {
-		flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
+		flag := IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_SMURF]") {
@@ -235,7 +233,7 @@ var float64FlagTests = []struct {
 func TestFloat64FlagHelpOutput(t *testing.T) {
 
 	for _, test := range float64FlagTests {
-		flag := cli.Float64Flag{Name: test.name}
+		flag := Float64Flag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -248,7 +246,7 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_BAZ", "99.4")
 	for _, test := range float64FlagTests {
-		flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
+		flag := Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_BAZ]") {
@@ -259,7 +257,7 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
 
 var genericFlagTests = []struct {
 	name     string
-	value    cli.Generic
+	value    Generic
 	expected string
 }{
 	{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
@@ -269,7 +267,7 @@ var genericFlagTests = []struct {
 func TestGenericFlagHelpOutput(t *testing.T) {
 
 	for _, test := range genericFlagTests {
-		flag := cli.GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
+		flag := GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
 		output := flag.String()
 
 		if output != test.expected {
@@ -282,7 +280,7 @@ func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_ZAP", "3")
 	for _, test := range genericFlagTests {
-		flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
+		flag := GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_ZAP]") {
@@ -292,11 +290,11 @@ func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
 }
 
 func TestParseMultiString(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "serve, s"},
+	(&App{
+		Flags: []Flag{
+			StringFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.String("serve") != "10" {
 				t.Errorf("main name not set")
 			}
@@ -310,11 +308,11 @@ func TestParseMultiString(t *testing.T) {
 func TestParseMultiStringFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_COUNT", "20")
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
+	(&App{
+		Flags: []Flag{
+			StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.String("count") != "20" {
 				t.Errorf("main name not set")
 			}
@@ -328,11 +326,11 @@ func TestParseMultiStringFromEnv(t *testing.T) {
 func TestParseMultiStringFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_COUNT", "20")
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
+	(&App{
+		Flags: []Flag{
+			StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.String("count") != "20" {
 				t.Errorf("main name not set")
 			}
@@ -344,11 +342,11 @@ func TestParseMultiStringFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiStringSlice(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}},
+	(&App{
+		Flags: []Flag{
+			StringSliceFlag{Name: "serve, s", Value: &StringSlice{}},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
 				t.Errorf("main name not set")
 			}
@@ -363,11 +361,11 @@ func TestParseMultiStringSliceFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"},
+	(&App{
+		Flags: []Flag{
+			StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "APP_INTERVALS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
 				t.Errorf("main name not set from env")
 			}
@@ -382,11 +380,11 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
+	(&App{
+		Flags: []Flag{
+			StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
 				t.Errorf("main name not set from env")
 			}
@@ -398,11 +396,11 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiInt(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "serve, s"},
+	a := App{
+		Flags: []Flag{
+			IntFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Int("serve") != 10 {
 				t.Errorf("main name not set")
 			}
@@ -417,11 +415,11 @@ func TestParseMultiInt(t *testing.T) {
 func TestParseMultiIntFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+	a := App{
+		Flags: []Flag{
+			IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Int("timeout") != 10 {
 				t.Errorf("main name not set")
 			}
@@ -436,11 +434,11 @@ func TestParseMultiIntFromEnv(t *testing.T) {
 func TestParseMultiIntFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
+	a := App{
+		Flags: []Flag{
+			IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Int("timeout") != 10 {
 				t.Errorf("main name not set")
 			}
@@ -453,11 +451,11 @@ func TestParseMultiIntFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiIntSlice(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}},
+	(&App{
+		Flags: []Flag{
+			IntSliceFlag{Name: "serve, s", Value: &IntSlice{}},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
 				t.Errorf("main name not set")
 			}
@@ -472,11 +470,11 @@ func TestParseMultiIntSliceFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"},
+	(&App{
+		Flags: []Flag{
+			IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "APP_INTERVALS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
 				t.Errorf("main name not set from env")
 			}
@@ -491,11 +489,11 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
+	(&App{
+		Flags: []Flag{
+			IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
 				t.Errorf("main name not set from env")
 			}
@@ -507,11 +505,11 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiFloat64(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "serve, s"},
+	a := App{
+		Flags: []Flag{
+			Float64Flag{Name: "serve, s"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Float64("serve") != 10.2 {
 				t.Errorf("main name not set")
 			}
@@ -526,11 +524,11 @@ func TestParseMultiFloat64(t *testing.T) {
 func TestParseMultiFloat64FromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+	a := App{
+		Flags: []Flag{
+			Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Float64("timeout") != 15.5 {
 				t.Errorf("main name not set")
 			}
@@ -545,11 +543,11 @@ func TestParseMultiFloat64FromEnv(t *testing.T) {
 func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
+	a := App{
+		Flags: []Flag{
+			Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Float64("timeout") != 15.5 {
 				t.Errorf("main name not set")
 			}
@@ -562,11 +560,11 @@ func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiBool(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "serve, s"},
+	a := App{
+		Flags: []Flag{
+			BoolFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Bool("serve") != true {
 				t.Errorf("main name not set")
 			}
@@ -581,11 +579,11 @@ func TestParseMultiBool(t *testing.T) {
 func TestParseMultiBoolFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_DEBUG", "1")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+	a := App{
+		Flags: []Flag{
+			BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Bool("debug") != true {
 				t.Errorf("main name not set from env")
 			}
@@ -600,11 +598,11 @@ func TestParseMultiBoolFromEnv(t *testing.T) {
 func TestParseMultiBoolFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_DEBUG", "1")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
+	a := App{
+		Flags: []Flag{
+			BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.Bool("debug") != true {
 				t.Errorf("main name not set from env")
 			}
@@ -617,11 +615,11 @@ func TestParseMultiBoolFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiBoolT(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "serve, s"},
+	a := App{
+		Flags: []Flag{
+			BoolTFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.BoolT("serve") != true {
 				t.Errorf("main name not set")
 			}
@@ -636,11 +634,11 @@ func TestParseMultiBoolT(t *testing.T) {
 func TestParseMultiBoolTFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_DEBUG", "0")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+	a := App{
+		Flags: []Flag{
+			BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.BoolT("debug") != false {
 				t.Errorf("main name not set from env")
 			}
@@ -655,11 +653,11 @@ func TestParseMultiBoolTFromEnv(t *testing.T) {
 func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_DEBUG", "0")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
+	a := App{
+		Flags: []Flag{
+			BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if ctx.BoolT("debug") != false {
 				t.Errorf("main name not set from env")
 			}
@@ -690,11 +688,11 @@ func (p *Parser) String() string {
 }
 
 func TestParseGeneric(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "serve, s", Value: &Parser{}},
+	a := App{
+		Flags: []Flag{
+			GenericFlag{Name: "serve, s", Value: &Parser{}},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
 				t.Errorf("main name not set")
 			}
@@ -709,11 +707,11 @@ func TestParseGeneric(t *testing.T) {
 func TestParseGenericFromEnv(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_SERVE", "20,30")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
+	a := App{
+		Flags: []Flag{
+			GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
 				t.Errorf("main name not set from env")
 			}
@@ -728,11 +726,11 @@ func TestParseGenericFromEnv(t *testing.T) {
 func TestParseGenericFromEnvCascade(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("APP_FOO", "99,2000")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
+	a := App{
+		Flags: []Flag{
+			GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
 		},
-		Action: func(ctx *cli.Context) {
+		Action: func(ctx *Context) {
 			if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
 				t.Errorf("value not set from env")
 			}
diff --git a/help_test.go b/help_test.go
index c85f957..42d0284 100644
--- a/help_test.go
+++ b/help_test.go
@@ -1,20 +1,18 @@
-package cli_test
+package cli
 
 import (
 	"bytes"
 	"testing"
-
-	"github.com/codegangsta/cli"
 )
 
 func Test_ShowAppHelp_NoAuthor(t *testing.T) {
 	output := new(bytes.Buffer)
-	app := cli.NewApp()
+	app := NewApp()
 	app.Writer = output
 
-	c := cli.NewContext(app, nil, nil)
+	c := NewContext(app, nil, nil)
 
-	cli.ShowAppHelp(c)
+	ShowAppHelp(c)
 
 	if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
 		t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
@@ -23,14 +21,14 @@ func Test_ShowAppHelp_NoAuthor(t *testing.T) {
 
 func Test_ShowAppHelp_NoVersion(t *testing.T) {
 	output := new(bytes.Buffer)
-	app := cli.NewApp()
+	app := NewApp()
 	app.Writer = output
 
 	app.Version = ""
 
-	c := cli.NewContext(app, nil, nil)
+	c := NewContext(app, nil, nil)
 
-	cli.ShowAppHelp(c)
+	ShowAppHelp(c)
 
 	if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
 		t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
diff --git a/helpers_test.go b/helpers_test.go
index cdc4feb..3ce8e93 100644
--- a/helpers_test.go
+++ b/helpers_test.go
@@ -1,4 +1,4 @@
-package cli_test
+package cli
 
 import (
 	"reflect"