This repository has been archived by the owner on Aug 27, 2021. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
/
flag_timestamp.go
231 lines (199 loc) · 6.33 KB
/
flag_timestamp.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
// Copyright 2020 The vine Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
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 newTimestamp(timestamp, nil)
}
func newTimestamp(timestamp time.Time, p *time.Time) *Timestamp {
t := new(Timestamp)
if p == nil {
p = new(time.Time)
}
t.timestamp = p
*t.timestamp = timestamp
return t
}
// 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 = ×tamp
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.Name, f.Aliases)
}
// 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
}
func (a *App) timestampVar(p *time.Time, name, alias string, value time.Time, usage, env string) {
if a.Flags == nil {
a.Flags = make([]Flag, 0)
}
flag := &TimestampFlag{
Name: name,
Usage: usage,
Value: newTimestamp(value, p),
}
if alias != "" {
flag.Aliases = []string{alias}
}
if env != "" {
flag.EnvVars = []string{env}
}
a.Flags = append(a.Flags, flag)
}
// TimestampVar defines a time.Time flag with specified name, default value, usage string and env string.
// The argument p points to a time.Time variable in which to store the value of the flag.
func (a *App) TimestampVar(p *time.Time, name string, value time.Time, usage, env string) {
a.timestampVar(p, name, "", value, usage, env)
}
// TimestampVarP is like TimestampVar, but accepts a shorthand letter that can be used after a single dash.
func (a *App) TimestampVarP(p *time.Time, name, alias string, value time.Time, usage, env string) {
a.timestampVar(p, name, alias, value, usage, env)
}
// TimestampVar defines a Timestamp flag with specified name, default value, usage string and env string.
// The argument p points to a time.Time variable in which to store the value of the flag.
func TimestampVar(p *time.Time, name string, value time.Time, usage, env string) {
CommandLine.TimestampVar(p, name, value, usage, env)
}
// TimestampVarP is like TimestampVar, but accepts a shorthand letter that can be used after a single dash.
func TimestampVarP(p *time.Time, name, alias string, value time.Time, usage, env string) {
CommandLine.TimestampVarP(p, name, alias, value, usage, env)
}
// Timestamp defines a time.Time flag with specified name, default value, usage string and env string.
// The return value is the address of a time.Time variable that stores the value of the flag.
func (a *App) Timestamp(name string, value time.Time, usage, env string) *time.Time {
p := new(time.Time)
a.TimestampVar(p, name, value, usage, env)
return p
}
// TimestampP is like Timestamp, but accepts a shorthand letter that can be used after a single dash.
func (a *App) TimestampP(name, alias string, value time.Time, usage, env string) *time.Time {
p := new(time.Time)
a.TimestampVarP(p, name, alias, value, usage, env)
return p
}
// 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
}