feat(main): Filter list-available to latest (#368)

Signed-off-by: Akhil Repala <[email protected]>

Author: arepala-uml

README.md

@@ -103,6 +103,7 @@ Available Commands:
 Flags:
   -D, --debug   enable debug logging
   -h, --help    help for cardano-up
+  -v, --verbose Show all available versions of packages
 
 Use "cardano-up [command] --help" for more information about a command.
 ```
@@ -157,7 +158,8 @@ Lists installed packages in the active context, or all contexts with `-A`
 
 ### `list-available`
 
-List all packages available for install
+By default `list-available` lists only the latest version of each package available for install.
+Use the `--verbose` or `(-v)` flag to display all available versions of each package.
 
 ### `logs`
 

cmd/cardano-up/list.go

@@ -19,6 +19,7 @@ import (
 	"log/slog"
 
 	"github.com/blinklabs-io/cardano-up/pkgmgr"
+	"github.com/hashicorp/go-version"
 	"github.com/spf13/cobra"
 )
 
@@ -27,12 +28,14 @@ var listFlags = struct {
 }{}
 
 func listAvailableCommand() *cobra.Command {
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "list-available",
 		Short: "List available packages",
 		Run: func(cmd *cobra.Command, args []string) {
 			pm := createPackageManager()
 			packages := pm.AvailablePackages()
+			verbose, _ := cmd.Flags().GetBool("verbose")
+
 			slog.Info("Available packages:\n")
 			slog.Info(
 				fmt.Sprintf(
@@ -42,28 +45,35 @@ func listAvailableCommand() *cobra.Command {
 					"Description",
 				),
 			)
-			for _, tmpPackage := range packages {
-				slog.Info(
-					fmt.Sprintf(
-						"%-20s %-12s %s",
-						tmpPackage.Name,
-						tmpPackage.Version,
-						tmpPackage.Description,
-					),
-				)
-				if len(tmpPackage.Dependencies) > 0 {
-					tmpOutput := "    Requires: "
-					for idx, dep := range tmpPackage.Dependencies {
-						tmpOutput += dep
-						if idx < len(tmpPackage.Dependencies)-1 {
-							tmpOutput += ` | `
+			if verbose {
+				// show all versions of packages
+				for _, tmpPackage := range packages {
+					printPackageInfo(tmpPackage)
+				}
+			} else {
+				// Shows only latest version of each package
+				latestPackages := make(map[string]int)
+				order := make([]string, 0)
+				for index, pkg := range packages {
+					packageName := pkg.Name
+					packageVersion := pkg.Version
+					existingIndex, exists := latestPackages[packageName]
+					if !exists || compareVersions(packageVersion, packages[existingIndex].Version) {
+						if !exists {
+							order = append(order, packageName)
 						}
+						latestPackages[packageName] = index
 					}
-					slog.Info(tmpOutput)
+				}
+				for _, name := range order {
+					printPackageInfo(packages[latestPackages[name]])
 				}
 			}
 		},
 	}
+	// Added a verbose flag
+	cmd.Flags().BoolP("verbose", "v", false, "Show all versions of packages")
+	return cmd
 }
 
 func listCommand() *cobra.Command {
@@ -111,3 +121,36 @@ func listCommand() *cobra.Command {
 		BoolVarP(&listFlags.all, "all", "A", false, "show packages from all contexts (defaults to only active context)")
 	return listCmd
 }
+
+// Prints packge details
+func printPackageInfo(pkg pkgmgr.Package) {
+	slog.Info(
+		fmt.Sprintf(
+			"%-20s %-12s %s",
+			pkg.Name,
+			pkg.Version,
+			pkg.Description,
+		),
+	)
+	if len(pkg.Dependencies) > 0 {
+		tmpOutput := "    Requires: "
+		for idx, dep := range pkg.Dependencies {
+			tmpOutput += dep
+			if idx < len(pkg.Dependencies)-1 {
+				tmpOutput += ` | `
+			}
+		}
+		slog.Info(tmpOutput)
+	}
+}
+
+// Compare semantic version of packages
+func compareVersions(v1 string, v2 string) bool {
+	ver1, err1 := version.NewVersion(v1)
+	ver2, err2 := version.NewVersion(v2)
+
+	if err1 != nil || err2 != nil {
+		return v1 > v2
+	}
+	return ver1.GreaterThan(ver2)
+}

cmd/cardano-up/list_test.go

@@ -0,0 +1,25 @@
+package main
+
+import "testing"
+
+func TestCompareVersions(t *testing.T) {
+	cases := []struct {
+		v1, v2   string
+		expected bool
+	}{
+		{"10.1.1", "2.0.0", true},
+		{"1.10.0", "1.9.0", true},
+		{"1.2.3", "1.2.3", false},
+		{"0.9.5", "1.0.0", false},
+	}
+
+	for _, tc := range cases {
+		result := compareVersions(tc.v1, tc.v2)
+		if result == tc.expected {
+			t.Logf("Test Passed: compareVersions(%s, %s) = %v (Expected: %v)\n", tc.v1, tc.v2, result, tc.expected)
+
+		} else {
+			t.Errorf("Test Failed: compareVersions(%s, %s) = %v; Expected %v", tc.v1, tc.v2, result, tc.expected)
+		}
+	}
+}