Merge pull request #141 from legendu-net/dev

dclong · web-flow · commit 055f32894b58 · 2025-11-22T12:11:45.000-08:00
Merge dev into main
diff --git a/cmd/dev/bytehound.go b/cmd/dev/bytehound.go
@@ -16,7 +16,7 @@ func bytehound(cmd *cobra.Command, args []string) {
 		case "linux":
 			network.DownloadGitHubRelease("koute/bytehound", "", map[string][]string{
 				"common": {"bytehound", "tgz"},
-				"x86_64": {"x86_64"},
+				"amd64":  {"x86_64"},
 				"linux":  {"linux", "gnu"},
 			}, []string{}, "/tmp/bytehound.tar.gz")
 			command := utils.Format(`mkdir -p ~/.local/bin && tar -zxvf /tmp/bytehound.tar.gz -C ~/.local/bin \
diff --git a/cmd/dev/git.go b/cmd/dev/git.go
@@ -61,7 +61,7 @@ func installGitUi(cmd *cobra.Command) {
 			"common": {"tar.gz"},
 			"linux":  {"linux"},
 			"darwin": {"mac"},
-			"x86_64": {"musl"},
+			"amd64":  {"musl"},
 			"arm64":  {"aarch64"},
 		}, []string{}, file)
 		command := utils.Format(`{prefix} tar -zxvf {file} -C /usr/local/bin/`, map[string]string{
@@ -100,7 +100,7 @@ func installGitDelta(cmd *cobra.Command) {
 	file := filepath.Join(tmpdir, "git-delta.tar.gz")
 	network.DownloadGitHubRelease("dandavison/delta", "", map[string][]string{
 		"common": {},
-		"x86_64": {"x86_64"},
+		"amd64":  {"x86_64"},
 		"arm64":  {"aarch64"},
 		"linux":  {"linux", "gnu"},
 		"darwin": {"apple", "darwin"},
diff --git a/cmd/dev/golang.go b/cmd/dev/golang.go
@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"strings"
 
 	"github.com/spf13/cobra"
 	"golang.org/x/sys/unix"
@@ -27,6 +26,33 @@ func getGolangVersion() string {
 	return re.FindStringSubmatch(html)[1]
 }
 
+func installGoLang(prefix string) {
+	url := utils.Format("https://go.dev/dl/go{ver}.{os}-{arch}.tar.gz", map[string]string{
+		"ver":  getGolangVersion(),
+		"os":   runtime.GOOS,
+		"arch": utils.HostKernelArch(),
+	})
+	goTgz := utils.DownloadFile(url, "go_*.tar.gz", true)
+	cmd := utils.Format(`{prefix} rm -rf /usr/local/go \
+				&& {prefix} tar -C /usr/local/ -xzf {goTgz}\
+				&& {prefix} rm -rf /usr/local/go/pkg/*/cmd`,
+		map[string]string{
+			"prefix": prefix,
+			"goTgz":  goTgz,
+		},
+	)
+	utils.RunCmd(cmd)
+}
+
+func installGoLangCiLint(prefix string) {
+	script := "https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh"
+	cmd := utils.Format(`curl -sSfL {script} | {prefix} sh -s -- -b /usr/local/bin`, map[string]string{
+		"script": script,
+		"prefix": prefix,
+	})
+	utils.RunCmd(cmd)
+}
+
 // Install and configure Golang.
 func golang(cmd *cobra.Command, args []string) {
 	prefix := utils.GetCommandPrefix(false, map[string]uint32{
@@ -36,27 +62,9 @@ func golang(cmd *cobra.Command, args []string) {
 	})
 	if utils.GetBoolFlag(cmd, "install") {
 		switch runtime.GOOS {
-		case "windows":
-		case "darwin":
-			utils.BrewInstallSafe([]string{"go"})
-		case "linux":
-			ver := getGolangVersion()
-			url := strings.ReplaceAll("https://go.dev/dl/go{ver}.linux-amd64.tar.gz", "{ver}", ver)
-			goTgz := utils.DownloadFile(url, "go_*.tar.gz", true)
-			cmd := utils.Format(`{prefix} rm -rf /usr/local/go \
-						&& {prefix} tar -C /usr/local/ -xzf {goTgz}\
-						&& {prefix} rm -rf /usr/local/go/pkg/*/cmd \
-							/usr/local/go/pkg/bootstrap \
-							/usr/local/go/pkg/obj \
-							/usr/local/go/pkg/tool/*/api \
-							/usr/local/go/pkg/tool/*/go_bootstrap \
-							/usr/local/go/src/cmd/dist/dist`,
-				map[string]string{
-					"prefix": prefix,
-					"goTgz":  goTgz,
-				},
-			)
-			utils.RunCmd(cmd)
+		case "darwin", "linux":
+			installGoLang(prefix)
+			installGoLangCiLint(prefix)
 		default:
 			log.Fatal("The OS ", runtime.GOOS, " is not supported!")
 		}
diff --git a/cmd/dev/pytype.go b/cmd/dev/pytype.go
@@ -21,11 +21,17 @@ func pytype(cmd *cobra.Command, args []string) {
 	if utils.GetBoolFlag(cmd, "config") {
 		srcFile := "data/pytype/pyproject.toml"
 		var srcMap orderedmap.OrderedMap[string, any]
-		toml.Unmarshal(utils.ReadEmbeddedFile(srcFile), &srcMap)
+		err := toml.Unmarshal(utils.ReadEmbeddedFile(srcFile), &srcMap)
+		if err != nil {
+			log.Fatalf("Failed to parse TOML: %v", err)
+		}
 		destFile := filepath.Join(utils.GetStringFlag(cmd, "dest-dir"), "pyproject.toml")
 		var destMap orderedmap.OrderedMap[string, any]
 		if utils.ExistsFile(destFile) {
-			toml.Unmarshal(utils.ReadFile(destFile), &destMap)
+			err := toml.Unmarshal(utils.ReadFile(destFile), &destMap)
+			if err != nil {
+				log.Fatalf("Failed to parse TOML: %v", err)
+			}
 			utils.UpdateMap(destMap, srcMap)
 		} else {
 			destMap = srcMap
diff --git a/cmd/dev/rust.go b/cmd/dev/rust.go
@@ -69,7 +69,7 @@ func installSccache() {
 	file := filepath.Join(tmpdir, "sccache.tar.gz")
 	network.DownloadGitHubRelease("mozilla/sccache", "", map[string][]string{
 		"common": {"tar.gz"},
-		"x86_64": {"x86_64"},
+		"amd64":  {"x86_64"},
 		"arm64":  {"aarch64"},
 		"linux":  {"unknown", "linux", "musl"},
 		"darwin": {"apple", "darwin"},
@@ -89,7 +89,7 @@ func installCargoBinstall() {
 	file := filepath.Join(tmpdir, "cargo-binstall.tgz")
 	network.DownloadGitHubRelease("cargo-bins/cargo-binstall", "", map[string][]string{
 		"common": {"tgz"},
-		"x86_64": {"x86_64"},
+		"amd64":  {"x86_64"},
 		"arm64":  {"aarch64"},
 		"linux":  {"unknown", "linux", "gnu"},
 		"darwin": {"apple", "darwin"},
diff --git a/cmd/network/github.go b/cmd/network/github.go
@@ -58,7 +58,10 @@ func assetNameContainKeywords(name string, keywords []string, keyworkdsExclude [
 func filterReleases(url string, constraint string) ReleaseInfo {
 	log.Printf("Extracting release from %s with the constraint %s", url, constraint)
 	var releases []ReleaseInfo
-	json.Unmarshal(utils.HttpGetAsBytes(url, 3, 120), &releases)
+	err := json.Unmarshal(utils.HttpGetAsBytes(url, 3, 120), &releases)
+	if err != nil {
+		log.Fatalf("Failed to parse TOML: %v", err)
+	}
 	c := version.NewConstrainGroupFromString(constraint)
 	for _, release := range releases {
 		if c.Match(release.TagName) {
diff --git a/cmd/root.go b/cmd/root.go
@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"log"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -42,13 +43,25 @@ $ icon completion fish > ~/.config/fish/completions/icon.fish
 	Run: func(cmd *cobra.Command, args []string) {
 		switch args[0] {
 		case "bash":
-			cmd.Root().GenBashCompletion(os.Stdout)
+			err := cmd.Root().GenBashCompletion(os.Stdout)
+			if err != nil {
+				log.Fatalf("Failed to generate completion script for bash: %v", err)
+			}
 		case "zsh":
-			cmd.Root().GenZshCompletion(os.Stdout)
+			err := cmd.Root().GenZshCompletion(os.Stdout)
+			if err != nil {
+				log.Fatalf("Failed to generate completion script for bash: %v", err)
+			}
 		case "fish":
-			cmd.Root().GenFishCompletion(os.Stdout, true)
+			err := cmd.Root().GenFishCompletion(os.Stdout, true)
+			if err != nil {
+				log.Fatalf("Failed to generate completion script for bash: %v", err)
+			}
 		case "powershell":
-			cmd.Root().GenPowerShellCompletion(os.Stdout)
+			err := cmd.Root().GenPowerShellCompletion(os.Stdout)
+			if err != nil {
+				log.Fatalf("Failed to generate completion script for bash: %v", err)
+			}
 		}
 	},
 }
diff --git a/cmd/shell/fish.go b/cmd/shell/fish.go
@@ -16,8 +16,9 @@ func downloadFishFromGitHub(version string) string {
 	output := "/tmp/_fish_shell.tar.xz"
 	network.DownloadGitHubRelease("fish-shell/fish-shell", version, map[string][]string{
 		"common":             {"fish", "tar.xz"},
-		"x86_64":             {"x86_64"},
+		"amd64":              {"x86_64"},
 		"arm64":              {"aarch64"},
+		"linux":              {"linux"},
 		"DebianUbuntuSeries": {},
 		"FedoraSeries":       {},
 		"OtherLinux":         {},
diff --git a/cmd/shell/hyper.go b/cmd/shell/hyper.go
@@ -14,7 +14,7 @@ func downloadHyperFromGitHub(version string) string {
 	output := "/tmp/_hyper_js_terminal"
 	network.DownloadGitHubRelease("vercel/hyper", version, map[string][]string{
 		"common":             {},
-		"x86_64":             {"amd64"},
+		"amd64":              {"amd64"},
 		"arm64":              {"arm64"},
 		"DebianUbuntuSeries": {"deb"},
 		"FedoraSeries":       {"rpm"},
diff --git a/cmd/shell/nushell.go b/cmd/shell/nushell.go
@@ -16,7 +16,7 @@ func downloadNushellFromGitHub(version string) string {
 			"common": {"tar.gz"},
 			"linux":  {"unknown", "linux", "gnu"},
 			"darwin": {"apple", "darwin"},
-			"x86_64": {"x86_64"},
+			"amd64":  {"x86_64"},
 			"arm64":  {"aarch64"},
 		}, []string{}, output)
 	return output
diff --git a/cmd/version.go b/cmd/version.go
@@ -8,7 +8,7 @@ import (
 
 // Update icon.
 func version(cmd *cobra.Command, args []string) {
-	fmt.Println("0.28.0")
+	fmt.Println("0.29.0")
 }
 
 var versionCmd = &cobra.Command{
diff --git a/utils/utils.go b/utils/utils.go
@@ -1679,6 +1679,25 @@ func UpdateMap(map1 orderedmap.OrderedMap[string, any], map2 orderedmap.OrderedM
 	}
 }
 
+func HostInfo() *host.InfoStat {
+	info, err := host.Info()
+	if err != nil {
+		log.Fatal(err)
+	}
+	return info
+}
+
+func HostKernelArch() string {
+	switch HostInfo().KernelArch {
+	case "x86_64", "amd64":
+		return "amd64"
+	case "arm64", "aarch64":
+		return "arm64"
+	default:
+		return "_other"
+	}
+}
+
 // BuildKernelOSKeywords constructs a list of keywords based on kernel architecture and operating system.
 //
 // @param keywords A map where keys are keyword categories and values are lists of keywords.
@@ -1689,7 +1708,7 @@ func UpdateMap(map1 orderedmap.OrderedMap[string, any], map2 orderedmap.OrderedM
 //
 //	keywords := map[string][]string{
 //		"common":             {"keyword1", "keyword2"},
-//		"x86_64":             {"x86_64_keyword"},
+//		"amd64":             {"amd64_keyword"},
 //		"arm64":              {"arm64_keyword"},
 //		"darwin":             {"darwin_keyword"},
 //		"linux":              {"linux_keyword"},
@@ -1702,51 +1721,29 @@ func UpdateMap(map1 orderedmap.OrderedMap[string, any], map2 orderedmap.OrderedM
 
 func BuildKernelOSKeywords(keywords map[string][]string) []string {
 	kwds := keywords["common"]
-	info, err := host.Info()
-	if err != nil {
-		log.Fatal(err)
+	k, found := keywords[HostKernelArch()]
+	if found {
+		kwds = append(kwds, k...)
 	}
-	switch info.KernelArch {
-	case "x86_64":
-		x86_64, found := keywords["x86_64"]
-		if found {
-			kwds = append(kwds, x86_64...)
-		}
-	case "arm64", "aarch64":
-		arm64, found := keywords["arm64"]
-		if found {
-			kwds = append(kwds, arm64...)
-		}
-	default:
+	k, found = keywords[runtime.GOOS]
+	if found {
+		kwds = append(kwds, k...)
 	}
-	switch runtime.GOOS {
-	case "darwin":
-		darwin, found := keywords["darwin"]
+	if IsDebianUbuntuSeries() {
+		debianUbuntuSeries, found := keywords["DebianUbuntuSeries"]
 		if found {
-			kwds = append(kwds, darwin...)
+			kwds = append(kwds, debianUbuntuSeries...)
 		}
-	case "linux":
-		linux, found := keywords["linux"]
+	} else if IsFedoraSeries() {
+		fedoraSeries, found := keywords["FedoraSeries"]
 		if found {
-			kwds = append(kwds, linux...)
+			kwds = append(kwds, fedoraSeries...)
 		}
-		if IsDebianUbuntuSeries() {
-			debianUbuntuSeries, found := keywords["DebianUbuntuSeries"]
-			if found {
-				kwds = append(kwds, debianUbuntuSeries...)
-			}
-		} else if IsFedoraSeries() {
-			fedoraSeries, found := keywords["FedoraSeries"]
-			if found {
-				kwds = append(kwds, fedoraSeries...)
-			}
-		} else {
-			otherLinux, found := keywords["OtherLinux"]
-			if found {
-				kwds = append(kwds, otherLinux...)
-			}
+	} else {
+		otherLinux, found := keywords["OtherLinux"]
+		if found {
+			kwds = append(kwds, otherLinux...)
 		}
-	default:
 	}
 	return kwds
 }
