Merge branch 'master' into patch-1

.github/workflows/cli.yml

@@ -1,6 +1,10 @@
 name: Run Tests
 
 on:
+  push:
+    branches:
+      - master  
+      - v1
   pull_request:
     branches:
       - master

README.md

@@ -64,5 +64,5 @@ 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
+released version of Go on OS X and Windows. This project uses Github Actions for
-[`./.travis.yml`](./.travis.yml) and [`./appveyor.yml`](./appveyor.yml).
+builds. For more build info, please look at the [./.github/workflows/cli.yml](https://github.com/urfave/cli/blob/master/.github/workflows/cli.yml).

docs.go

@@ -48,8 +48,8 @@ func (a *App) writeDocTemplate(w io.Writer) error {
 	return t.ExecuteTemplate(w, name, &cliTemplate{
 		App:          a,
 		Commands:     prepareCommands(a.Commands, 0),
-		GlobalArgs:   prepareArgsWithValues(a.Flags),
+		GlobalArgs:   prepareArgsWithValues(a.VisibleFlags()),
-		SynopsisArgs: prepareArgsSynopsis(a.Flags),
+		SynopsisArgs: prepareArgsSynopsis(a.VisibleFlags()),
 	})
 }
 

docs_test.go

@@ -22,6 +22,10 @@ func testApp() *App {
 			Aliases: []string{"b"},
 			Usage:   "another usage text",
 		},
+		&BoolFlag{
+			Name:   "hidden-flag",
+			Hidden: true,
+		},
 	}
 	app.Commands = []*Command{{
 		Aliases: []string{"c"},

flag_float64.go

@@ -18,11 +18,11 @@ type Float64Flag struct {
 	Value       float64
 	DefaultText string
 	Destination *float64
-	HasBeenSet bool
+	HasBeenSet  bool
 }
 
 // IsSet returns whether or not the flag has been set through env or file
-func (f *Float64Flag)IsSet() bool {
+func (f *Float64Flag) IsSet() bool {
 	return f.HasBeenSet
 }
 

flag_test.go

@@ -1678,3 +1678,58 @@ func TestInt64Slice_Serialized_Set(t *testing.T) {
 		t.Fatalf("pre and post serialization do not match: %v != %v", sl0, sl1)
 	}
 }
+
+func TestTimestamp_set(t *testing.T) {
+	ts := Timestamp{
+		timestamp:  nil,
+		hasBeenSet: false,
+		layout:     "Jan 2, 2006 at 3:04pm (MST)",
+	}
+
+	time1 := "Feb 3, 2013 at 7:54pm (PST)"
+	if err := ts.Set(time1); err != nil {
+		t.Fatalf("Failed to parse time %s with layout %s", time1, ts.layout)
+	}
+	if ts.hasBeenSet == false {
+		t.Fatalf("hasBeenSet is not true after setting a time")
+	}
+
+	ts.hasBeenSet = false
+	ts.SetLayout(time.RFC3339)
+	time2 := "2006-01-02T15:04:05Z"
+	if err := ts.Set(time2); err != nil {
+		t.Fatalf("Failed to parse time %s with layout %s", time2, ts.layout)
+	}
+	if ts.hasBeenSet == false {
+		t.Fatalf("hasBeenSet is not true after setting a time")
+	}
+}
+
+func TestTimestampFlagApply(t *testing.T) {
+	expectedResult, _ :=  time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
+	fl := TimestampFlag{Name: "time", Aliases: []string{"t"}, Layout: time.RFC3339}
+	set := flag.NewFlagSet("test", 0)
+	_ = fl.Apply(set)
+
+	err := set.Parse([]string{"--time", "2006-01-02T15:04:05Z"})
+	expect(t, err, nil)
+	expect(t, *fl.Value.timestamp, expectedResult)
+}
+
+func TestTimestampFlagApply_Fail_Parse_Wrong_Layout(t *testing.T) {
+	fl := TimestampFlag{Name: "time", Aliases: []string{"t"}, Layout: "randomlayout"}
+	set := flag.NewFlagSet("test", 0)
+	_ = fl.Apply(set)
+
+	err := set.Parse([]string{"--time", "2006-01-02T15:04:05Z"})
+	expect(t, err, fmt.Errorf("invalid value \"2006-01-02T15:04:05Z\" for flag -time: parsing time \"2006-01-02T15:04:05Z\" as \"randomlayout\": cannot parse \"2006-01-02T15:04:05Z\" as \"randomlayout\""))
+}
+
+func TestTimestampFlagApply_Fail_Parse_Wrong_Time(t *testing.T) {
+	fl := TimestampFlag{Name: "time", Aliases: []string{"t"}, Layout: "Jan 2, 2006 at 3:04pm (MST)"}
+	set := flag.NewFlagSet("test", 0)
+	_ = fl.Apply(set)
+
+	err := set.Parse([]string{"--time", "2006-01-02T15:04:05Z"})
+	expect(t, err, fmt.Errorf("invalid value \"2006-01-02T15:04:05Z\" for flag -time: parsing time \"2006-01-02T15:04:05Z\" as \"Jan 2, 2006 at 3:04pm (MST)\": cannot parse \"2006-01-02T15:04:05Z\" as \"Jan\""))
+}

flag_timestamp.go

@@ -0,0 +1,152 @@
+package cli
+
+import (
+	"flag"
+	"fmt"
+	"time"
+)
+
+// Timestamp wrap to satisfy golang's flag interface.
+type Timestamp struct {
+	timestamp  *time.Time
+	hasBeenSet bool
+	layout     string
+}
+
+// Timestamp constructor
+func NewTimestamp(timestamp time.Time) *Timestamp {
+	return &Timestamp{timestamp: &timestamp}
+}
+
+// Set the timestamp value directly
+func (t *Timestamp) SetTimestamp(value time.Time) {
+	if !t.hasBeenSet {
+		t.timestamp = &value
+		t.hasBeenSet = true
+	}
+}
+
+// Set the timestamp string layout for future parsing
+func (t *Timestamp) SetLayout(layout string) {
+	t.layout = layout
+}
+
+// Parses the string value to timestamp
+func (t *Timestamp) Set(value string) error {
+	timestamp, err := time.Parse(t.layout, value)
+	if err != nil {
+		return err
+	}
+
+	t.timestamp = &timestamp
+	t.hasBeenSet = true
+	return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (t *Timestamp) String() string {
+	return fmt.Sprintf("%#v", t.timestamp)
+}
+
+// Value returns the timestamp value stored in the flag
+func (t *Timestamp) Value() *time.Time {
+	return t.timestamp
+}
+
+// Get returns the flag structure
+func (t *Timestamp) Get() interface{} {
+	return *t
+}
+
+// TimestampFlag is a flag with type time
+type TimestampFlag struct {
+	Name        string
+	Aliases     []string
+	Usage       string
+	EnvVars     []string
+	FilePath    string
+	Required    bool
+	Hidden      bool
+	Layout      string
+	Value       *Timestamp
+	DefaultText string
+	HasBeenSet  bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *TimestampFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *TimestampFlag) String() string {
+	return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *TimestampFlag) Names() []string {
+	return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *TimestampFlag) IsRequired() bool {
+	return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *TimestampFlag) TakesValue() bool {
+	return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *TimestampFlag) GetUsage() string {
+	return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *TimestampFlag) GetValue() string {
+	if f.Value != nil {
+		return f.Value.timestamp.String()
+	}
+	return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *TimestampFlag) Apply(set *flag.FlagSet) error {
+	if f.Layout == "" {
+		return fmt.Errorf("timestamp Layout is required")
+	}
+	f.Value = &Timestamp{}
+	f.Value.SetLayout(f.Layout)
+
+	if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+		if err := f.Value.Set(val); err != nil {
+			return fmt.Errorf("could not parse %q as timestamp value for flag %s: %s", val, f.Name, err)
+		}
+		f.HasBeenSet = true
+	}
+
+	for _, name := range f.Names() {
+		set.Var(f.Value, name, f.Usage)
+	}
+	return nil
+}
+
+// Timestamp gets the timestamp from a flag name
+func (c *Context) Timestamp(name string) *time.Time {
+	if fs := lookupFlagSet(name, c); fs != nil {
+		return lookupTimestamp(name, fs)
+	}
+	return nil
+}
+
+// Fetches the timestamp value from the local timestampWrap
+func lookupTimestamp(name string, set *flag.FlagSet) *time.Time {
+	f := set.Lookup(name)
+	if f != nil {
+		return (f.Value.(*Timestamp)).Value()
+	}
+	return nil
+}