Resolved compile-time errors since merging from v1

command_test.go

@@ -124,15 +124,16 @@ func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
 }
 
 func TestCommand_OnUsageError_hasCommandContext(t *testing.T) {
-	app := NewApp()
-	app.Commands = []Command{
-		{
-			Name: "bar",
-			Flags: []Flag{
-				IntFlag{Name: "flag"},
-			},
-			OnUsageError: func(c *Context, err error, _ bool) error {
-				return fmt.Errorf("intercepted in %s: %s", c.Command.Name, err.Error())
+	app := &App{
+		Commands: []*Command{
+			{
+				Name: "bar",
+				Flags: []Flag{
+					&IntFlag{Name: "flag"},
+				},
+				OnUsageError: func(c *Context, err error, _ bool) error {
+					return fmt.Errorf("intercepted in %s: %s", c.Command.Name, err.Error())
+				},
 			},
 		},
 	}
@@ -176,23 +177,24 @@ func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
 }
 
 func TestCommand_OnUsageError_WithSubcommand(t *testing.T) {
-	app := NewApp()
-	app.Commands = []Command{
-		{
-			Name: "bar",
-			Subcommands: []Command{
-				{
-					Name: "baz",
+	app := &App{
+		Commands: []*Command{
+			{
+				Name: "bar",
+				Subcommands: []*Command{
+					{
+						Name: "baz",
+					},
+				},
+				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())
 				},
-			},
-			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())
 			},
 		},
 	}
@@ -208,22 +210,23 @@ func TestCommand_OnUsageError_WithSubcommand(t *testing.T) {
 }
 
 func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) {
-	app := NewApp()
-	app.ErrWriter = ioutil.Discard
-	app.Commands = []Command{
-		{
-			Name:  "bar",
-			Usage: "this is for testing",
-			Subcommands: []Command{
-				{
-					Name:  "baz",
-					Usage: "this is for testing",
-					Action: func(c *Context) error {
-						if c.App.ErrWriter != ioutil.Discard {
-							return fmt.Errorf("ErrWriter not passed")
-						}
-
-						return nil
+	app := &App{
+		ErrWriter: ioutil.Discard,
+		Commands: []*Command{
+			{
+				Name:  "bar",
+				Usage: "this is for testing",
+				Subcommands: []*Command{
+					{
+						Name:  "baz",
+						Usage: "this is for testing",
+						Action: func(c *Context) error {
+							if c.App.ErrWriter != ioutil.Discard {
+								return fmt.Errorf("ErrWriter not passed")
+							}
+
+							return nil
+						},
 					},
 				},
 			},

context.go

@@ -121,6 +121,11 @@ func (c *Context) Lineage() []*Context {
 	return lineage
 }
 
+// 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 returns the command line arguments associated with the context.
 func (c *Context) Args() Args {
 	ret := args(c.flagSet.Args())

context_test.go

@@ -2,7 +2,6 @@ package cli
 
 import (
 	"flag"
-	"os"
 	"sort"
 	"testing"
 	"time"
@@ -158,78 +157,6 @@ func TestContext_IsSet(t *testing.T) {
 	expect(t, ctx.IsSet("bogus"), 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, noEnvVarIsSet, nIsSet             bool
-		globalTimeoutIsSet, TIsSet, globalNoEnvVarIsSet, NIsSet bool
-	)
-
-	clearenv()
-	os.Setenv("GLOBAL_APP_TIMEOUT_SECONDS", "15.5")
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	os.Setenv("APP_PASSWORD", "")
-	a := App{
-		Flags: []Flag{
-			&Float64Flag{
-				Name:    "global-timeout",
-				Aliases: []string{"T"},
-				EnvVars: []string{"GLOBAL_APP_TIMEOUT_SECONDS"},
-			},
-			&Float64Flag{
-				Name:    "global-no-env-var",
-				Aliases: []string{"N"},
-			},
-		},
-		Commands: []*Command{
-			{
-				Name: "hello",
-				Flags: []Flag{
-					&Float64Flag{
-						Name:    "timeout",
-						Aliases: []string{"t"},
-						EnvVars: []string{"APP_TIMEOUT_SECONDS"},
-					},
-					&Float64Flag{
-						Name:    "no-env-var",
-						Aliases: []string{"n"},
-					},
-				},
-				Action: func(ctx *Context) error {
-					globalTimeoutIsSet = ctx.IsSet("global-timeout")
-					TIsSet = ctx.IsSet("T")
-					globalNoEnvVarIsSet = ctx.IsSet("global-no-env-var")
-					NIsSet = ctx.IsSet("N")
-					timeoutIsSet = ctx.IsSet("timeout")
-					tIsSet = ctx.IsSet("t")
-					noEnvVarIsSet = ctx.IsSet("no-env-var")
-					nIsSet = ctx.IsSet("n")
-					return nil
-				},
-			},
-		},
-	}
-	a.Run([]string{"run", "hello"})
-	expect(t, globalTimeoutIsSet, true)
-	expect(t, TIsSet, true)
-	expect(t, globalNoEnvVarIsSet, false)
-	expect(t, NIsSet, false)
-	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")

errors.go

@@ -66,15 +66,15 @@ type exitError struct {
 
 // Exit wraps a message and exit code into an ExitCoder suitable for handling by
 // HandleExitCoder
-func Exit(message string, exitCode int) ExitCoder {
+func Exit(message interface{}, exitCode int) ExitCoder {
 	return &exitError{
 		exitCode: exitCode,
 		message:  message,
 	}
 }
 
 func (ee *exitError) Error() string {
-	return ee.message
+	return fmt.Sprintf("%v", ee.message)
 }
 
 func (ee *exitError) ExitCode() int {
@@ -112,7 +112,7 @@ func HandleExitCoder(err error) {
 
 func handleMultiError(multiErr MultiError) int {
 	code := 1
-	for _, merr := range multiErr.Errors {
+	for _, merr := range multiErr.Errors() {
 		if multiErr2, ok := merr.(MultiError); ok {
 			code = handleMultiError(multiErr2)
 		} else {

errors_test.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"fmt"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestHandleExitCoder_nil(t *testing.T) {
@@ -95,7 +97,7 @@ func TestHandleExitCoder_ErrorWithFormat(t *testing.T) {
 		ErrWriter = fakeErrWriter
 	}()
 
-	err := NewExitError(NewErrorWithFormat("I am formatted"), 1)
+	err := Exit(NewErrorWithFormat("I am formatted"), 1)
 	HandleExitCoder(err)
 
 	expect(t, called, true)
@@ -114,9 +116,9 @@ func TestHandleExitCoder_MultiErrorWithFormat(t *testing.T) {
 
 	defer func() { OsExiter = fakeOsExiter }()
 
-	err := NewMultiError(NewErrorWithFormat("err1"), NewErrorWithFormat("err2"))
+	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")
+	assert.True(t, called)
+	assert.Equal(t, "This the format: err1\nThis the format: err2\n", ErrWriter.(*bytes.Buffer).String())
 }