Feature: add option to not rebuild with newer toolchain

[yukita443]

Is your feature request related to a problem?

An option to prevent unintended rebuilds caused by toolchain updates would be useful, especially if the user has a large number of packages installed.

Describe the solution you'd like

Adding an option like gup update --ignore-go-update

Describe alternatives you've considered

Installing a binary per go toolchains installed by asdf.

Additional context

#154

[nao1215]

@yukita443
Thank you for the suggestion of a new feature !!
I couldn't fully understand the use case, so I have a few questions.

Here is the use case I imagined:

• You are developing multiple projects, each using a different Go version.
• When you run go generate ./... for a project, you want to match the "Go version for the project" with the "Go version used to build the binaries under $GOPATH/bin."

Is this the situation you are referring to? I personally think it's fine to always use the latest Go version, so I’m not quite sure I understand your ideal situation.

Also, does the --ignore-go-update option skip the update only when the Go toolchain is updated? For example, if the toolchain becomes outdated, will gup still skip the update? Which of these behaviors is the feature you are requesting?

[nao1215]

@yukita443
Don't close without any explanation, please.

[krbreyn]

Hello,
I think what they meant is that when you update the version of your go binary (say 1.23 -> 1.24), when you use the flag --ignore-go-update it should not rebuild binaries that have not been updated but were built with an older go version. So if you have a binary that was built with go 1.23 but has not been updated, it would be left alone, even though you have go 1.24 now.

[KEINOS]

With the @krbreyn's comment, now I get it.

+1 for this feature.

Currently, if the Go version updates, gup will rebuild all the applications even if the application source code has no change (apps with no version change made).

In most cases and machines, this is fine. Since the build process in Go is fast and due to the Go 1 compatibility statement, it should build/compile the binaries with the newer Go versions.

But I recently had a chance to build a Go app on a low spec machine, such as Raspberry Pi Zero.
And hell yea, it takes a lot of time!

Thus, in that occasion, I prefer gup to update the binaries if and only if the source code were updated, and keep the binary as-is if no source code change (version up) were made.

But I prefer something like: --rebuild-on-go-update=no and set yes by default.

[nao1215]

I understand now. Some people find it bothersome to rebuild binaries every time the toolchain changes. Since I personally prefer keeping up with the latest version, I didn’t initially understand the request (I thought it was about go tool or something along those lines).

[nao1215]

I recently changed jobs and haven’t been feeling very energetic. My hobby OSS development has come to a halt. I don't think this implementation will progress for a while.

[KEINOS]

@nao1215

I understand. Take a rest and walk on your pace.

This is open source. You don't have to do everything yourself! This project is awesome and so are you!
You don't have to burn yourself out to get the tools that you need.

When one needs a new feature, that person should submit a pull request (PR). All you have to do is to make a decision to take/merge it.

Even if the person who submitted the pull request disagrees with your decision, they have the option to fork the project.
That's the basic idea behind OSS, I think.

Thus, in that manner, I shall PR for this issue 😝

[nao1215]

@KEINOS
Thank you for your kind words of encouragement. As a side note, I'm more burned out by life itself than by OSS.

Now, regarding this issue, I'm not exactly sure how it should be implemented.
gup can detect updates to the toolchain. However, at the moment, it has no way of detecting updates to the tools themselves.
For example, even if --rebuild-on-go-update=no is specified, I believe the expected behavior is that gup should still update a tool if it has been updated.

To achieve this behavior, perhaps gup could clone the tool’s git repository and check the tags in that repository.

[KEINOS]

@nao1215

I'm more burned out by life itself than by OSS.

Yea, working and switching jobs in Japan is hard ... （地獄で転職しても変わらぬ地獄）

In my case it took me 3 years to recover and start to work again. Meanwhile (during プー太郎 time), learning new things, such as Go, was my rehab. And strongly swore not to learn "for the job" but only to learn "for my motivation and to accumulate virtues" by contributing to OSS.

I don't know what works for you, but please take care of your self.

Now, regarding this issue, I'm not exactly sure how it should be implemented.

I dug the code and I think the below part is the key to implement the issue.

gup/internal/goutil/goutil.go

Lines 79 to 94 in d8a897c

	func (p *Package) CurrentToLatestStr() string {
	if p.IsAlreadyUpToDate() {
	return "Already up-to-date: " + color.GreenString(p.Version.Current) + " / " + color.GreenString(p.GoVersion.Current)
	}
	var ret string
	if p.Version.Current != p.Version.Latest {
	ret += color.GreenString(p.Version.Current) + " to " + color.YellowString(p.Version.Latest)
	}
	if p.GoVersion.Current != p.GoVersion.Latest {
	if len(ret) != 0 {
	ret += ", "
	}
	ret += color.GreenString(p.GoVersion.Current) + " to " + color.YellowString(p.GoVersion.Latest)
	}
	return ret
	}

By removing the go versions during comparison if the --rebuild-on-go-update is no, somewhat like the below, might be the clue.

package goutil

import (
    "fmt"
    "strings"
)

// 既存のPackage構造体に Latest や Current のフィールドがある前提
type Package struct {
    Current string
    Latest  string
    // ...existing code...
}

// SetLatestVer の中で、最新バージョンからGoバージョン部分を除外する
func (p *Package) SetLatestVer() {
    // ...既存のバージョン取得ロジック...
    // ここで取得した p.Latest に、もし " v1.2.3 go1.19" のようにGoバージョンが含まれてたら
    // それらを除去する
    p.Latest = removeGoVersionInfo(p.Latest)
    // ...existing code...
}

// 現在と最新のバージョンを比較する際にも、Goバージョン情報を除外して比較
func (p *Package) CurrentToLatestStr() string {
    currentNormalized := removeGoVersionInfo(p.Current)
    latestNormalized := removeGoVersionInfo(p.Latest)
    if currentNormalized == latestNormalized {
        return "up-to-date"
    }

    return fmt.Sprintf("%s -> %s", p.Current, p.Latest)
}

// ヘルパー関数: バージョン文字列からGoバージョン部分を除去
func removeGoVersionInfo(ver string) string {
    // スペースで区切って最初の部分だけ使えばOKとする例
    parts := strings.Split(ver, " ")
    if len(parts) > 0 {
        return parts[0]
    }

    return ver
}