Hide identical columns in the list command

If all the instances have the same type or arch,
then don't display the column - unless requested.

Only hide the arch if it is the same as host arch.
Emulated instances all show their arch by default.

Signed-off-by: Anders F Björklund <[email protected]>

Author: afbjorklund

cmd/limactl/list.go

@@ -54,6 +54,7 @@ func newListCommand() *cobra.Command {
 	listCommand.Flags().Bool("list-fields", false, "List fields available for format")
 	listCommand.Flags().Bool("json", false, "JSONify output")
 	listCommand.Flags().BoolP("quiet", "q", false, "Only show names")
+	listCommand.Flags().Bool("all-fields", false, "Show all fields")
 
 	return listCommand
 }
@@ -155,7 +156,14 @@ func listAction(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	return store.PrintInstances(cmd.OutOrStdout(), instances, format)
+	allFields, err := cmd.Flags().GetBool("all-fields")
+	if err != nil {
+		return err
+	}
+
+	options := store.PrintOptions{AllFields: allFields}
+	out := cmd.OutOrStdout()
+	return store.PrintInstances(out, instances, format, &options)
 }
 
 func listBashComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

pkg/store/instance.go

@@ -232,17 +232,48 @@ func AddGlobalFields(inst *Instance) (FormatData, error) {
 	return data, nil
 }
 
+type PrintOptions struct {
+	AllFields bool
+}
+
 // PrintInstances prints instances in a requested format to a given io.Writer.
 // Supported formats are "json", "yaml", "table", or a go template
-func PrintInstances(w io.Writer, instances []*Instance, format string) error {
+func PrintInstances(w io.Writer, instances []*Instance, format string, options *PrintOptions) error {
 	switch format {
 	case "json":
 		format = "{{json .}}"
 	case "yaml":
 		format = "{{yaml .}}"
 	case "table":
+		types := map[string]int{}
+		archs := map[string]int{}
+		for _, instance := range instances {
+			types[instance.VMType]++
+			archs[instance.Arch]++
+		}
+		all := options != nil && options.AllFields
+		hideType := false
+		hideArch := false
+		hideDir := false
+
+		hideType = len(types) == 1 && !all
+		// only hide arch if it is the same as the host arch
+		goarch := limayaml.NewArch(runtime.GOARCH)
+		hideArch = len(archs) == 1 && instances[0].Arch == goarch && !all
+
 		w := tabwriter.NewWriter(w, 4, 8, 4, ' ', 0)
-		fmt.Fprintln(w, "NAME\tSTATUS\tSSH\tVMTYPE\tARCH\tCPUS\tMEMORY\tDISK\tDIR")
+		fmt.Fprint(w, "NAME\tSTATUS\tSSH")
+		if !hideType {
+			fmt.Fprint(w, "\tVMTYPE")
+		}
+		if !hideArch {
+			fmt.Fprint(w, "\tARCH")
+		}
+		fmt.Fprint(w, "\tCPUS\tMEMORY\tDISK")
+		if !hideDir {
+			fmt.Fprint(w, "\tDIR")
+		}
+		fmt.Fprintln(w)
 
 		u, err := user.Current()
 		if err != nil {
@@ -255,17 +286,33 @@ func PrintInstances(w io.Writer, instances []*Instance, format string) error {
 			if strings.HasPrefix(dir, homeDir) {
 				dir = strings.Replace(dir, homeDir, "~", 1)
 			}
-			fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\t%s\n",
+			fmt.Fprintf(w, "%s\t%s\t%s",
 				instance.Name,
 				instance.Status,
 				fmt.Sprintf("127.0.0.1:%d", instance.SSHLocalPort),
-				instance.VMType,
-				instance.Arch,
+			)
+			if !hideType {
+				fmt.Fprintf(w, "\t%s",
+					instance.VMType,
+				)
+			}
+			if !hideArch {
+				fmt.Fprintf(w, "\t%s",
+					instance.Arch,
+				)
+			}
+			fmt.Fprintf(w, "\t%d\t%s\t%s",
 				instance.CPUs,
 				units.BytesSize(float64(instance.Memory)),
 				units.BytesSize(float64(instance.Disk)),
-				dir,
 			)
+			if !hideDir {
+				fmt.Fprintf(w, "\t%s",
+					dir,
+				)
+			}
+			fmt.Fprint(w, "\n")
+
 		}
 		return w.Flush()
 	default:

pkg/store/instance_test.go

@@ -0,0 +1,92 @@
+package store
+
+import (
+	"bytes"
+	"os/user"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/lima-vm/lima/pkg/limayaml"
+	"gotest.tools/v3/assert"
+)
+
+const separator = string(filepath.Separator)
+
+var vmtype = limayaml.QEMU
+var goarch = limayaml.NewArch(runtime.GOARCH)
+
+var instance = Instance{
+	Name:   "foo",
+	Status: StatusStopped,
+	VMType: vmtype,
+	Arch:   goarch,
+	Dir:    "dir",
+}
+
+var table = "NAME    STATUS     SSH            CPUS    MEMORY    DISK    DIR\n" +
+	"foo     Stopped    127.0.0.1:0    0       0B        0B      dir\n"
+
+var tableEmu = "NAME    STATUS     SSH            ARCH       CPUS    MEMORY    DISK    DIR\n" +
+	"foo     Stopped    127.0.0.1:0    unknown    0       0B        0B      dir\n"
+
+var tableHome = "NAME    STATUS     SSH            CPUS    MEMORY    DISK    DIR\n" +
+	"foo     Stopped    127.0.0.1:0    0       0B        0B      ~" + separator + "dir\n"
+
+var tableAll = "NAME    STATUS     SSH            VMTYPE    ARCH      CPUS    MEMORY    DISK    DIR\n" +
+	"foo     Stopped    127.0.0.1:0    " + vmtype + "      " + goarch + "    0       0B        0B      dir\n"
+
+var tableTwo = "NAME    STATUS     SSH            VMTYPE    ARCH       CPUS    MEMORY    DISK    DIR\n" +
+	"foo     Stopped    127.0.0.1:0    qemu      x86_64     0       0B        0B      dir\n" +
+	"bar     Stopped    127.0.0.1:0    vz        aarch64    0       0B        0B      dir\n"
+
+func TestPrintInstanceTable(t *testing.T) {
+	var buf bytes.Buffer
+	instances := []*Instance{&instance}
+	PrintInstances(&buf, instances, "table", nil)
+	assert.Equal(t, table, buf.String())
+}
+
+func TestPrintInstanceTableEmu(t *testing.T) {
+	var buf bytes.Buffer
+	instance1 := instance
+	instance1.Arch = "unknown"
+	instances := []*Instance{&instance1}
+	PrintInstances(&buf, instances, "table", nil)
+	assert.Equal(t, tableEmu, buf.String())
+}
+
+func TestPrintInstanceTableHome(t *testing.T) {
+	var buf bytes.Buffer
+	u, err := user.Current()
+	assert.NilError(t, err)
+	instance1 := instance
+	instance1.Dir = filepath.Join(u.HomeDir, "dir")
+	instances := []*Instance{&instance1}
+	PrintInstances(&buf, instances, "table", nil)
+	assert.Equal(t, tableHome, buf.String())
+}
+
+func TestPrintInstanceTableAll(t *testing.T) {
+	var buf bytes.Buffer
+	instances := []*Instance{&instance}
+	options := PrintOptions{AllFields: true}
+	PrintInstances(&buf, instances, "table", &options)
+	assert.Equal(t, tableAll, buf.String())
+}
+
+func TestPrintInstanceTableTwo(t *testing.T) {
+	var buf bytes.Buffer
+	instance1 := instance
+	instance1.Name = "foo"
+	instance1.VMType = limayaml.QEMU
+	instance1.Arch = limayaml.X8664
+	instance2 := instance
+	instance2.Name = "bar"
+	instance2.VMType = limayaml.VZ
+	instance2.Arch = limayaml.AARCH64
+	instances := []*Instance{&instance1, &instance2}
+	options := PrintOptions{}
+	PrintInstances(&buf, instances, "table", &options)
+	assert.Equal(t, tableTwo, buf.String())
+}