feat(ifdata): Add shell completion for flags and network interfaces

Author: gabe565

cmd/ifdata/cmd.go

@@ -11,49 +11,20 @@ import (
 	"github.com/spf13/cobra"
 )
 
-const (
-	Name                 = "ifdata"
-	FlagExists           = "e"
-	FlagPrint            = "p"
-	FlagPrintExists      = "pe"
-	FlagAddress          = "pa"
-	FlagNetmask          = "pn"
-	FlagNetworkAddress   = "pN"
-	FlagBroadcastAddress = "pb"
-	FlagMTU              = "pm"
-	FlagFlags            = "pf"
-	FlagHardwareAddress  = "ph"
-
-	FlagInputStatistics  = "si"
-	FlagInputPackets     = "sip"
-	FlagInputBytes       = "sib"
-	FlagInputErrors      = "sie"
-	FlagInputDropped     = "sid"
-	FlagInputFIFO        = "sif"
-	FlagInputCompressed  = "sic"
-	FlagInputMulticast   = "sim"
-	FlagInputBytesSecond = "bips"
-
-	FlagOutputStatistics    = "so"
-	FlagOutputPackets       = "sop"
-	FlagOutputBytes         = "sob"
-	FlagOutputErrors        = "soe"
-	FlagOutputDropped       = "sod"
-	FlagOutputFIFO          = "sof"
-	FlagOutputCollisions    = "sox"
-	FlagOutputCarrierLosses = "soc"
-	FlagOutputMulticast     = "som"
-	FlagOutputBytesSecond   = "bops"
-)
+const Name = "ifdata"
 
 func New(opts ...cmdutil.Option) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     Name + " [flags] interface",
 		Short:   "Get network interface info without parsing ifconfig output",
 		RunE:    run,
 		GroupID: cmdutil.Applet,
+
+		ValidArgsFunction: validArgs,
 	}
 
+	cmd.InitDefaultHelpFlag()
+
 	cmd.SetUsageFunc(usageFunc)
 	cmd.DisableFlagsInUseLine = true
 	cmd.DisableFlagParsing = true
@@ -64,6 +35,41 @@ func New(opts ...cmdutil.Option) *cobra.Command {
 	return cmd
 }
 
+func validArgs(_ *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
+	if len(args) == 0 {
+		vals := formatterValues()
+		strs := make([]string, 0, len(vals))
+		for _, val := range vals {
+			if val == fmtNone {
+				continue
+			}
+
+			if val.supported() {
+				strs = append(strs, val.String()+"\t"+val.description())
+			}
+		}
+		return strs, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	names := make([]string, 0, len(ifaces))
+	for _, iface := range ifaces {
+		addrs, _ := iface.Addrs()
+		desc := make([]string, 0, len(addrs))
+		for _, addr := range addrs {
+			if addr, ok := addr.(*net.IPNet); ok && addr.IP.To4() != nil {
+				desc = append(desc, addr.String())
+			}
+		}
+		names = append(names, iface.Name+"\t"+strings.Join(desc, ","))
+	}
+	return names, cobra.ShellCompDirectiveNoFileComp
+}
+
 var (
 	ErrNoFormatter           = errors.New("no formatter was provided")
 	ErrUnknownFormatter      = errors.New("unknown formatter")
@@ -77,7 +83,8 @@ func run(cmd *cobra.Command, args []string) error {
 		return cmd.Usage()
 	}
 
-	var op, name string
+	var op formatter
+	var name string
 	for _, arg := range args {
 		switch {
 		case arg == "-h", arg == "--help":
@@ -92,14 +99,16 @@ func run(cmd *cobra.Command, args []string) error {
 				return tmpl.Execute(cmd.OutOrStdout(), cmd)
 			}
 		case strings.HasPrefix(arg, "-"):
-			op = strings.TrimPrefix(arg, "-")
+			if err := op.UnmarshalText([]byte(arg)); err != nil {
+				return err
+			}
 		default:
 			name = arg
 		}
 	}
 
 	switch {
-	case op == "":
+	case op == fmtNone:
 		return ErrNoFormatter
 	case name == "":
 		return ErrNoInterface
@@ -108,7 +117,7 @@ func run(cmd *cobra.Command, args []string) error {
 
 	iface, err := net.InterfaceByName(name)
 
-	if op == FlagPrintExists {
+	if op == fmtPrintExists {
 		if err != nil {
 			_, _ = fmt.Fprintln(cmd.OutOrStdout(), "no")
 		} else {
@@ -121,20 +130,20 @@ func run(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("%w: %s", err, name)
 	}
 
-	if op == FlagExists {
+	if op == fmtExists {
 		return nil
 	}
 
 	switch op {
-	case FlagMTU:
+	case fmtMTU:
 		_, _ = fmt.Fprintln(cmd.OutOrStdout(), iface.MTU)
-	case FlagFlags:
+	case fmtFlags:
 		for _, flag := range strings.Split(iface.Flags.String(), "|") {
 			_, _ = fmt.Fprintln(cmd.OutOrStdout(), flag)
 		}
-	case FlagHardwareAddress:
+	case fmtHardwareAddress:
 		_, _ = fmt.Fprintln(cmd.OutOrStdout(), strings.ToUpper(iface.HardwareAddr.String()))
-	case FlagAddress, FlagNetmask, FlagNetworkAddress, FlagBroadcastAddress, FlagPrint:
+	case fmtAddress, fmtNetmask, fmtNetworkAddress, fmtBroadcastAddress, fmtPrint:
 		addrs, err := iface.Addrs()
 		if err != nil {
 			return err
@@ -143,15 +152,15 @@ func run(cmd *cobra.Command, args []string) error {
 		for _, addr := range addrs {
 			if addr, ok := addr.(*net.IPNet); ok && addr.IP.To4() != nil {
 				switch op {
-				case FlagAddress:
+				case fmtAddress:
 					_, _ = fmt.Fprintln(cmd.OutOrStdout(), addr.IP)
-				case FlagNetmask:
+				case fmtNetmask:
 					_, _ = fmt.Fprintln(cmd.OutOrStdout(), net.IP(addr.Mask))
-				case FlagNetworkAddress:
+				case fmtNetworkAddress:
 					_, _ = fmt.Fprintln(cmd.OutOrStdout(), addr.IP.Mask(addr.Mask))
-				case FlagBroadcastAddress:
+				case fmtBroadcastAddress:
 					_, _ = fmt.Fprintln(cmd.OutOrStdout(), getBroadcastAddr(addr))
-				case FlagPrint:
+				case fmtPrint:
 					_, _ = fmt.Fprintf(cmd.OutOrStdout(),
 						"%s %s %s %d\n",
 						addr.IP,
@@ -168,7 +177,7 @@ func run(cmd *cobra.Command, args []string) error {
 		}
 
 		cmd.SilenceUsage = false
-		return fmt.Errorf("%w: -%s", ErrUnknownFormatter, op)
+		return fmt.Errorf("%w: %s", ErrUnknownFormatter, op)
 	}
 
 	return nil

cmd/ifdata/formatter.go

@@ -0,0 +1,111 @@
+package ifdata
+
+//go:generate enumer -type formatter -linecomment -text -output formatter_string.go
+
+type formatter uint8
+
+const (
+	fmtNone formatter = iota //
+
+	fmtExists           // -e
+	fmtPrint            // -p
+	fmtPrintExists      // -pe
+	fmtAddress          // -pa
+	fmtNetmask          // -pn
+	fmtNetworkAddress   // -pN
+	fmtBroadcastAddress // -pb
+	fmtMTU              // -pm
+	fmtFlags            // -pf
+	fmtHardwareAddress  // -ph
+
+	fmtInputStatistics // -si
+	fmtInputPackets    // -sip
+	fmtInputBytes      // -sib
+	fmtInputErrors     // -sie
+	fmtInputDropped    // -sid
+	fmtInputFIFO       // -sif
+	fmtInputCompressed // -sic
+	fmtInputMulticast  // -sim
+
+	fmtOutputStatistics    // -so
+	fmtOutputPackets       // -sop
+	fmtOutputBytes         // -sob
+	fmtOutputErrors        // -soe
+	fmtOutputDropped       // -sod
+	fmtOutputFIFO          // -sof
+	fmtOutputCollisions    // -sox
+	fmtOutputCarrierLosses // -soc
+	fmtOutputMulticast     // -som
+
+	fmtInputBytesSecond  // -bips
+	fmtOutputBytesSecond // -bops
+)
+
+func (f formatter) description() string {
+	switch f {
+	case fmtExists:
+		return "Test to see if the interface exists, exit nonzero if it does not"
+	case fmtPrint:
+		return "Prints out the whole configuration of the interface"
+	case fmtPrintExists:
+		return `Prints "yes" or "no" if the interface exists or not`
+	case fmtAddress:
+		return "Prints the IP address of the interface"
+	case fmtNetmask:
+		return "Prints the netmask of the interface"
+	case fmtNetworkAddress:
+		return "Prints the network address of the interface"
+	case fmtBroadcastAddress:
+		return "Prints the broadcast address of the interface"
+	case fmtMTU:
+		return "Prints the MTU of the interface"
+	case fmtFlags:
+		return "Prints the hardware address of the interface. Exit with a failure exit code if there is not hardware address for the given network interface"
+	case fmtHardwareAddress:
+		return "Prints the flags of the interface"
+	case fmtInputStatistics:
+		return "Prints all input statistics of the interface"
+	case fmtInputPackets:
+		return "Prints the number of input packets"
+	case fmtInputBytes:
+		return "Prints the number of input bytes"
+	case fmtInputErrors:
+		return "Prints the number of input errors"
+	case fmtInputDropped:
+		return "Prints the number of dropped input packets"
+	case fmtInputFIFO:
+		return "Prints the number of input fifo overruns"
+	case fmtInputCompressed:
+		return "Prints the number of compressed input packets"
+	case fmtInputMulticast:
+		return "Prints the number of input multicast packets"
+	case fmtInputBytesSecond:
+		return "Prints all output statistics of the interface"
+	case fmtOutputStatistics:
+		return "Prints the number of output packets"
+	case fmtOutputPackets:
+		return "Prints the number of output bytes"
+	case fmtOutputBytes:
+		return "Prints the number of output errors"
+	case fmtOutputErrors:
+		return "Prints the number of dropped output packets"
+	case fmtOutputDropped:
+		return "Prints the number of output fifo overruns"
+	case fmtOutputFIFO:
+		return "Prints the number of output collisions"
+	case fmtOutputCollisions:
+		return "Prints the number of output carrier losses"
+	case fmtOutputCarrierLosses:
+		return "Prints the number of output multicast packets"
+	case fmtOutputMulticast:
+		return "Prints the number of bytes of incoming traffic measured in one second"
+	case fmtOutputBytesSecond:
+		return "Prints the number of bytes of outgoing traffic measured in one second"
+	default:
+		return ""
+	}
+}
+
+func (f formatter) supported() bool {
+	return statisticsSupported || uint8(f) < uint8(fmtInputStatistics)
+}