What's the cleanest way to update my fork when working with both origin and upstream remotes?

[PAMinerva]

Hi! This is my first time trying out Lazygit.
I'm currently working on a fork, and my setup looks like this:

git remote -v
origin  https://github.com/MyUsername/MyFork (fetch)
origin  https://github.com/MyUsername/MyFork (push)
upstream        https://github.com/OwnerUsername/OwnerProject (fetch)
upstream        no_push (push)

I’m working on a custom branch called study, and I regularly want to rebase it onto the latest upstream/master.
Here’s what I used to do using the Developer PowerShell for Visual Studio:

git checkout master
git pull upstream master
git push origin master

git checkout study
git rebase master
# resolve conflicts if needed
git push origin study --force

This was my regular way of keeping my fork (origin/master) in sync with the upstream repo, and then rebasing my feature branch study on top of it. I’m not sure if it’s really the cleanest way to update a fork honestly. Anyway, now I’m trying to achieve the same workflow in Lazygit, and the only approach that came to mind was:

• Go to Local brances tab and checkout master
• With master selected, press u to set the upstream to upstream/master (instead of origin/master).
• Press p to pull from upstream/master to the local master.
• Reset the upstream back to origin/master.
• Press P to push changes to origin/master.
• Checkout study.
• Select master and press r to rebase study onto master.
• Resolve conflicts if needed.
• Push study (select force if prompted)

Is there a better or cleaner way to accomplish this in Lazygit?
Thanks in advance!

[stefanhaller]

This is a very good question, and one that doesn't have a good answer right now, I'm afraid.

While the scenario you describe is a very common one for open source contributors, it is one that I haven't paid much attention to so far, because I am in the fortunate position that I have push access to all the repos that I regularly contribute to, so I only need one remote (origin), which makes everything much easier.

Ok, let's see. There are two ways to set up the remotes in your clone, and they both have their pros and cons:

1. origin is your fork, and upstream is the upstream repo
2. origin is the upstream repo, and myfork (or whatever name you choose) is your fork.

I suppose 1. is the more natural and intuitive setup for most people (although I'm not sure). It has the advantage that pushing branches to your fork is easier (it's a matter of pressing shift-P, enter), and that opening a pull request is easier (simply pressing o). I'm not sure if the shift-O function let's you do this with 2.; I have never quite understood how this function even works.

So with these two criteria, 1. is the clear winner. However, lazygit has this concept of main branches (master or main by default), which let you do several useful and convenient things. For example, it's easy to rebase a feature branch onto its base branch by typing r b (no need to bring the local copy of the main branch up to date for this!), or to see how far a given feature branch is behind its base branch by typing u b on it. You can also turn on a permanent display of this divergence in the branches panel by setting gui.showDivergenceFromBaseBranch: arrowAndNumber, which I find very useful to see at a glance whether it's time to rebase my feature branches. And finally, as of recently lazygit even auto-fast-forwards the main branch(es) when fetching.

However, all these features assume that these main branches are in your origin remote. This is only a useful assumption for setup 2., because with 1. you'd have to manually keep your fork's main branch up to date with upstream's to make use of these features, which is cumbersome and easy to forget.

It seems to me that hard-coding origin for the main branches was a bad idea, and that we should either make this configurable, or always use upstream if it exists (falling back to origin if not), or both. This would make 1. a really useful setup. I'll think about this some more, and work on it the week after next week. Any thoughts or other input on this is welcome.

---

In the meantime, the approach you describe above is reasonable, except that you can omit the steps

• Reset the upstream back to origin/master.
• Press P to push changes to origin/master.

I would even consider deleting the master branch from your fork to prevent it from falling behind upstream's.

So my recommended approach right now would be:
One-time setup after cloning:

• Go to Local brances tab and checkout master
• With master selected, press u to set the upstream to upstream/master (instead of origin/master).

Then:

• Keep study checked out all the time (or switch to other feature branches; no need to ever check out master)
• In the local branches tab, select master and press f to fast-forward it to upstream's master (no need to check it out for this!)
• Select master and press r to rebase study onto master.
• Resolve conflicts if needed.
• Push study (select force if prompted)

[stefanhaller]

However, all these features assume that these main branches are in your origin remote.

Damn, I had forgotten how this works. 😄 What I wrote is not true: if you have a local main (or master), lazygit will use whatever its upstream is set to. So if your local main has upstream/main as its upstream, then all the nice main branches features described above will just work fine. It is only when you don't have a local main or master, that it will look in the origin remote if there is one.

So the recommendation is to go with approach 1. above, and have a local main that tracks upstream's main. You probably don't need a local branch that tracks origin's main, but if you want one, just call it something else locally (e.g. main-myfork).

[PAMinerva]

I don’t want to start a new discussion over something so small, but is there a way to assign different pull and push URLs for the same remote? I’m asking because I want to disable pushes. So far, I’ve been using lazygit to create a remote called "upstream" with the correct URL for pull and then manually running this in the console:

git remote set-url --push upstream no_push

Is there a way to automate this in lazygit?

[stefanhaller]

No, lazygit can only configure the fetch URL. You'll have to continue doing this on the command line, or create a custom command for it if you need it often.