import "go.chromium.org/luci/common/flag"
boolslice.go choice.go commalist.go fieldslice.go int32.go int64slice.go jsonmap.go meta.go protomsgsliceflag.go reltime.go stringslice.go strpairs.go time.go
BoolSlice returns a flag.Getter which reads flags into the given []bool pointer.
CommaList returns a flag.Getter for parsing a comma separated flag argument into a string slice.
FieldSlice returns a flag.Getter which reads flags into the given []googleapi.Field pointer.
GRPCMetadata returns a flag.Getter for parsing gRPC metadata from a a set of colon-separated strings. Example: -f a:1 -f a:2 -f b:3 Panics if md is nil.
Int32 returns a flag.Getter which reads flags into the given int32 pointer.
Int64Slice returns a flag.Getter which reads flags into the given []int64 pointer.
JSONMap returns a flag.Value that can be passed to flag.Var to parse a JSON string into a map.
MessageSliceFlag returns a new flag for a slice of pointer to concrete proto message struct which implements the proto.Message interface. Expect input to be of type *[]*B where B is concrete struct of proto message like pb.Build. A flag value must be a JSON string of the provided concrete proto message.
Code:
package main
import (
"flag"
"fmt"
"testing"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
pb "go.chromium.org/luci/buildbucket/proto"
. "github.com/smartystreets/goconvey/convey"
)
// special type that implements proto.Message interface for test purpose
type messageImpl string
func (messageImpl) Reset() {}
func (m messageImpl) String() string {
return string(m)
}
func (messageImpl) ProtoMessage() {}
// Assert that messageImpl implements to the proto.Message interface.
var _ = proto.Message(new(messageImpl))
func TestProtoMessageSliceFlag(t *testing.T) {
Convey("Basic", t, func() {
var builds []*pb.Build
fs := flag.NewFlagSet("test", flag.ContinueOnError)
flag := MessageSliceFlag(&builds)
fs.Var(flag, "build", "Test Proto Message")
var err error
err = flag.Set("{\"id\": 111111, \"status\": \"SUCCESS\"}")
So(err, ShouldBeNil)
err = flag.Set("{\"id\": 222222, \"status\": \"FAILURE\"}")
So(err, ShouldBeNil)
err = flag.Set("{\"id\": 333333, \"status\": \"CANCELED\"}")
So(err, ShouldBeNil)
So(flag.Get(), ShouldResemble, builds)
So(builds, ShouldHaveLength, 3)
So(builds, ShouldContain,
&pb.Build{Id: 111111, Status: pb.Status_SUCCESS})
So(builds, ShouldContain,
&pb.Build{Id: 222222, Status: pb.Status_FAILURE})
So(builds, ShouldContain,
&pb.Build{Id: 333333, Status: pb.Status_CANCELED})
// Hard to set expectation for JSON string due to indentation
// and field order. Therefore, simply check if it's empty or not.
So(flag.String(), ShouldNotBeBlank)
})
Convey("Panic when input is not pointer", t, func() {
So(func() { MessageSliceFlag("a string") }, ShouldPanic)
})
Convey("Panic when input pointer dose not point to a slice", t, func() {
So(func() { MessageSliceFlag(&map[string]string{}) }, ShouldPanic)
})
Convey("Panic when element does not implement proto.Message", t, func() {
So(func() { MessageSliceFlag(&[]string{}) }, ShouldPanic)
})
Convey("Panic when element is not pointer", t, func() {
So(func() { MessageSliceFlag(&[]messageImpl{}) }, ShouldPanic)
})
Convey("Panic when element pointer does not point to a struct", t, func() {
So(func() { MessageSliceFlag(&[]*messageImpl{}) }, ShouldPanic)
})
}
func main() {
var builds []*pb.Build
fs := flag.NewFlagSet("test", flag.ContinueOnError)
flag := MessageSliceFlag(&builds)
fs.Var(flag, "build", "Test Proto Message")
fs.Parse([]string{"-build",
"{\"id\": 111111, \"status\": \"SUCCESS\"}"})
marshaler := &jsonpb.Marshaler{Indent: " "}
jsonMsg, _ := marshaler.MarshalToString(builds[0])
fmt.Println(jsonMsg)
}
StringPairs returns a flag.Getter for parsing strpair.Map from a a set of colon-separated strings. Example: -f a:1 -f a:2 -f b:3 Panics if m is nil.
StringSlice returns a flag.Getter which reads flags into the given []string pointer.
Time returns a flag.Getter which parses a string into a time.Time pointer.
The timestamp to parse must be formatted as stiptime: https://chromium.googlesource.com/infra/infra/infra_libs/+/b2e2c9948c327b88b138d8bd60ec4bb3a957be78/time_functions/README.md
Caveat: Leap seconds are not supported due to a limitation in go's time library: https://github.com/golang/go/issues/15247
type Choice struct {
// contains filtered or unexported fields
}Choice is an implementation of flag.Value for parsing a multiple-choice string.
NewChoice creates a Choice value
Set implements the flag.Value interface.
String implements the flag.Value interface.
RelativeTime is an implementation of flag.Value for parsing a time by a relative day offset.
func (f RelativeTime) Set(s string) error
Set implements the flag.Value interface.
func (f RelativeTime) String() string
String implements the flag.Value interface.
| Path | Synopsis |
|---|---|
| fixflagpos | |
| flagenum | Package flagenum is a utility package which facilitates implementation of flag.Value, json.Marshaler, and json.Unmarshaler interfaces via a string-to- value mapping. |
| multiflag | Package multiflag is a package providing a flag.Value implementation capable of switching between multiple registered sub-flags, each of which have their own set of parameter flags. |
| nestedflagset | |
| stringlistflag | Package stringlistflag provides a flag.Value implementation which resolves multiple args into a []string. |
| stringmapflag | Package stringmapflag provides a flag.Value that, when parsed, augments a map[string]string with the supplied parameter. |
| stringsetflag | Package stringsetflag provides a flag.Value implementation which resolves multiple args into a stringset. |
Package flag imports 14 packages (graph) and is imported by 13 packages. Updated 2020-03-28. Refresh now. Tools for package owners.