Use pflag functions instead of ours.

cmd/hyperkube/hyperkube.go

@@ -77,8 +77,8 @@ func (hk *HyperKube) Flags() *pflag.FlagSet {
 
 		// These will add all of the "global" flags (defined with both the
 		// flag and pflag packages) to the new flag set we have.
-		util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
-		util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
+		hk.baseFlags.AddGoFlagSet(flag.CommandLine)
+		hk.baseFlags.AddFlagSet(pflag.CommandLine)
 
 	}
 	return hk.baseFlags
@@ -154,7 +154,7 @@ func (hk *HyperKube) Run(args []string) error {
 		return err
 	}
 
-	util.AddPFlagSetToPFlagSet(hk.Flags(), s.Flags())
+	s.Flags().AddFlagSet(hk.Flags())
 	err = s.Flags().Parse(args)
 	if err != nil || hk.helpFlagVal {
 		if err != nil {

cmd/hyperkube/hyperkube_test.go

@@ -126,7 +126,7 @@ func TestServerHelp(t *testing.T) {
 	x := runFull(t, "hyperkube test1 --help")
 	assert.NoError(t, x.err)
 	assert.Contains(t, x.output, "A simple server named test1")
-	assert.Contains(t, x.output, "--help=false: help for hyperkube")
+	assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
 	assert.NotContains(t, x.output, "test1 Run")
 }
 
@@ -134,7 +134,7 @@ func TestServerFlagsBad(t *testing.T) {
 	x := runFull(t, "hyperkube test1 --bad-flag")
 	assert.EqualError(t, x.err, "unknown flag: --bad-flag")
 	assert.Contains(t, x.output, "A simple server named test1")
-	assert.Contains(t, x.output, "--help=false: help for hyperkube")
+	assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
 	assert.NotContains(t, x.output, "test1 Run")
 }
 

contrib/mesos/cmd/km/hyperkube.go

@@ -75,8 +75,8 @@ func (hk *HyperKube) Flags() *pflag.FlagSet {
 
 		// These will add all of the "global" flags (defined with both the
 		// flag and pflag packages) to the new flag set we have.
-		util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
-		util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
+		hk.baseFlags.AddGoFlagSet(flag.CommandLine)
+		hk.baseFlags.AddFlagSet(pflag.CommandLine)
 
 	}
 	return hk.baseFlags
@@ -152,7 +152,7 @@ func (hk *HyperKube) Run(args []string) error {
 		return err
 	}
 
-	util.AddPFlagSetToPFlagSet(hk.Flags(), s.Flags())
+	s.Flags().AddFlagSet(hk.Flags())
 	err = s.Flags().Parse(args)
 	if err != nil || hk.helpFlagVal {
 		if err != nil {

contrib/mesos/cmd/km/hyperkube_test.go

@@ -125,7 +125,7 @@ func TestServerHelp(t *testing.T) {
 	x := runFull(t, "hyperkube test1 --help")
 	assert.NoError(t, x.err)
 	assert.Contains(t, x.output, "A simple server named test1")
-	assert.Contains(t, x.output, "--help=false: help for hyperkube")
+	assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
 	assert.NotContains(t, x.output, "test1 Run")
 }
 
@@ -133,7 +133,7 @@ func TestServerFlagsBad(t *testing.T) {
 	x := runFull(t, "hyperkube test1 --bad-flag")
 	assert.EqualError(t, x.err, "unknown flag: --bad-flag")
 	assert.Contains(t, x.output, "A simple server named test1")
-	assert.Contains(t, x.output, "--help=false: help for hyperkube")
+	assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
 	assert.NotContains(t, x.output, "test1 Run")
 }
 

pkg/kubectl/cmd/util/factory.go

@@ -271,11 +271,11 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 // BindFlags adds any flags that are common to all kubectl sub commands.
 func (f *Factory) BindFlags(flags *pflag.FlagSet) {
 	// any flags defined by external projects (not part of pflags)
-	util.AddFlagSetToPFlagSet(flag.CommandLine, flags)
+	flags.AddGoFlagSet(flag.CommandLine)
 
 	// This is necessary as github.com/spf13/cobra doesn't support "global"
 	// pflags currently.  See https://github.com/spf13/cobra/issues/44.
-	util.AddPFlagSetToPFlagSet(pflag.CommandLine, flags)
+	flags.AddFlagSet(pflag.CommandLine)
 
 	// Hack for global access to validation flag.
 	// TODO: Refactor out after configuration flag overhaul.
@@ -284,7 +284,7 @@ func (f *Factory) BindFlags(flags *pflag.FlagSet) {
 	}
 
 	// Merge factory's flags
-	util.AddPFlagSetToPFlagSet(f.flags, flags)
+	flags.AddFlagSet(f.flags)
 
 	// Globally persistent flags across all subcommands.
 	// TODO Change flag names to consts to allow safer lookup from subcommands.

pkg/util/flags.go

@@ -16,10 +16,13 @@ limitations under the License.
 
 package util
 
-import "strings"
+import (
+	goflag "flag"
+	"strings"
 
-import "github.com/spf13/pflag"
-import "github.com/golang/glog"
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+)
 
 // WordSepNormalizeFunc changes all flags that contain "_" separators
 func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
@@ -43,6 +46,6 @@ func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedNam
 // InitFlags normalizes and parses the command line flags
 func InitFlags() {
 	pflag.CommandLine.SetNormalizeFunc(WordSepNormalizeFunc)
-	AddAllFlagsToPFlags()
+	pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
 	pflag.Parse()
 }

pkg/util/pflag_import.go

-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
-	"flag"
-	"reflect"
-	"strings"
-
-	"github.com/spf13/pflag"
-)
-
-// flagValueWrapper implements pflag.Value around a flag.Value.  The main
-// difference here is the addition of the Type method that returns a string
-// name of the type.  As this is generally unknown, we approximate that with
-// reflection.
-type flagValueWrapper struct {
-	inner    flag.Value
-	flagType string
-}
-
-func wrapFlagValue(v flag.Value) pflag.Value {
-	// If the flag.Value happens to also be a pflag.Value, just use it directly.
-	if pv, ok := v.(pflag.Value); ok {
-		return pv
-	}
-
-	pv := &flagValueWrapper{
-		inner: v,
-	}
-
-	t := reflect.TypeOf(v)
-	if t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-
-	pv.flagType = t.Name()
-	pv.flagType = strings.TrimSuffix(pv.flagType, "Value")
-	return pv
-}
-
-func (v *flagValueWrapper) String() string {
-	return v.inner.String()
-}
-
-func (v *flagValueWrapper) Set(s string) error {
-	return v.inner.Set(s)
-}
-
-func (v *flagValueWrapper) Type() string {
-	return v.flagType
-}
-
-type boolFlag interface {
-	flag.Value
-	IsBoolFlag() bool
-}
-
-func (v *flagValueWrapper) IsBoolFlag() bool {
-	if bv, ok := v.inner.(boolFlag); ok {
-		return bv.IsBoolFlag()
-	}
-	return false
-}
-
-// Imports a 'flag.Flag' into a 'pflag.FlagSet'.  The "short" option is unset
-// and the type is inferred using reflection.
-func addFlagToPFlagSet(f *flag.Flag, fs *pflag.FlagSet) {
-	if fs.Lookup(f.Name) == nil {
-		fs.Var(wrapFlagValue(f.Value), f.Name, f.Usage)
-	}
-}
-
-// AddFlagSetToPFlagSet adds all of the flags in a 'flag.FlagSet' package flags to a 'pflag.FlagSet'.
-func AddFlagSetToPFlagSet(fsIn *flag.FlagSet, fsOut *pflag.FlagSet) {
-	fsIn.VisitAll(func(f *flag.Flag) {
-		addFlagToPFlagSet(f, fsOut)
-	})
-}
-
-// AddAllFlagsToPFlags adds all of the top level 'flag' package flags to the top level 'pflag' flags.
-func AddAllFlagsToPFlags() {
-	AddFlagSetToPFlagSet(flag.CommandLine, pflag.CommandLine)
-}
-
-// AddPFlagSetToPFlagSet merges the flags of fsFrom into fsTo.
-func AddPFlagSetToPFlagSet(fsFrom *pflag.FlagSet, fsTo *pflag.FlagSet) {
-	if fsFrom != nil && fsTo != nil {
-		fsFrom.VisitAll(func(f *pflag.Flag) {
-			if fsTo.Lookup(f.Name) == nil {
-				fsTo.AddFlag(f)
-			}
-		})
-	}
-}